def __init__(self,
name: str,
basedirpath: str,
client: Client = None,
wallet: Wallet = None,
port: int = None):
super().__init__(name, basedirpath, client, port)
self._wallet = wallet or Wallet(name)
obs = self._wallet.handleIncomingReply
if not self.client.hasObserver(obs):
self.client.registerObserver(obs)
self._wallet.pendSyncRequests()
prepared = self._wallet.preparePending()
self.client.submitReqs(*prepared)
self.loop = asyncio.get_event_loop()
self.msgHandlers = {
ERROR: self._handleError,
AVAIL_CLAIM_LIST: self._handleAcceptInviteResponse,
CLAIMS: self._handleReqClaimResponse,
ACCEPT_INVITE: self._acceptInvite,
REQUEST_CLAIM_ATTRS: self._returnClaimAttrs,
REQUEST_CLAIM: self._reqClaim,
CLAIM_ATTRS: self._handleClaimAttrs,
EVENT: self._eventHandler
}
def runAgent(agentClass,
name,
wallet=None,
basedirpath=None,
port=None,
startRunning=True,
bootstrap=False):
config = getConfig()
if not wallet:
wallet = Wallet(name)
if not basedirpath:
basedirpath = config.baseDir
if not port:
_, port = genHa()
_, clientPort = genHa()
client = Client(randomString(6),
ha=("0.0.0.0", clientPort),
basedirpath=basedirpath)
agent = agentClass(basedirpath=basedirpath,
client=client,
wallet=wallet,
port=port)
if startRunning:
if bootstrap:
agent.bootstrap()
with Looper(debug=True) as looper:
looper.add(agent)
logger.debug("Running {} now (port: {})".format(name, port))
looper.run()
else:
return agent
def clientFromSigner(signer, looper, nodeSet, tdir):
wallet = Wallet(signer.identifier)
wallet.addIdentifier(signer)
s = genTestClient(nodeSet, tmpdir=tdir, identifier=signer.identifier)
looper.add(s)
looper.run(s.ensureConnectedToNodes())
return s
def createAgent(agentClass,
name,
wallet=None,
basedirpath=None,
port=None,
loop=None,
clientClass=Client):
config = getConfig()
if not wallet:
wallet = Wallet(name)
if not basedirpath:
basedirpath = config.baseDir
if not port:
_, port = genHa()
_, clientPort = genHa()
client = clientClass(randomString(6),
ha=("0.0.0.0", clientPort),
basedirpath=basedirpath)
return agentClass(basedirpath=basedirpath,
client=client,
wallet=wallet,
port=port,
loop=loop)
def addRole(looper, creatorClient, creatorWallet, name, useDid=True,
addVerkey=True, role=None):
wallet = Wallet(name)
signer = DidSigner() if useDid else SimpleSigner()
idr, _ = wallet.addIdentifier(signer=signer)
verkey = wallet.getVerkey(idr) if addVerkey else None
createNym(looper, idr, creatorClient, creatorWallet, verkey=verkey,
role=role)
return wallet
def nonSponsor(looper, nodeSet, tdir):
sseed = b'this is a secret sponsor seed...'
signer = SimpleSigner(seed=sseed)
c, _ = genTestClient(nodeSet, tmpdir=tdir, usePoolLedger=True)
w = Wallet(c.name)
w.addIdentifier(signer=signer)
c.registerObserver(w.handleIncomingReply)
looper.add(c)
looper.run(c.ensureConnectedToNodes())
return c, w
def anotherSponsor(genned, steward, stewardWallet, tdir, looper):
sseed = b'this is 1 secret sponsor seed...'
signer = SimpleSigner(seed=sseed)
c, _ = genTestClient(genned, tmpdir=tdir)
w = Wallet(c.name)
w.addSigner(signer=signer)
c.registerObserver(w.handleIncomingReply)
looper.add(c)
looper.run(c.ensureConnectedToNodes())
createNym(looper, signer.verstr, steward, stewardWallet, SPONSOR)
return c, w
def testNonSponsoredNymCanDoGetNym(nodeSet, addedSponsor, sponsorWallet, tdir,
looper):
signer = SimpleSigner()
someClient, _ = genTestClient(nodeSet, tmpdir=tdir, usePoolLedger=True)
wallet = Wallet(someClient.name)
wallet.addIdentifier(signer=signer)
someClient.registerObserver(wallet.handleIncomingReply)
looper.add(someClient)
looper.run(someClient.ensureConnectedToNodes())
needle = sponsorWallet.defaultId
makeGetNymRequest(someClient, wallet, needle)
looper.run(eventually(someClient.hasNym, needle, retryWait=1, timeout=5))
def anotherSponsor(nodeSet, steward, stewardWallet, tdir, looper):
sseed = b'this is 1 secret sponsor seed...'
signer = SimpleSigner(seed=sseed)
c, _ = genTestClient(nodeSet, tmpdir=tdir, usePoolLedger=True)
w = Wallet(c.name)
w.addIdentifier(signer=signer)
c.registerObserver(w.handleIncomingReply)
looper.add(c)
looper.run(c.ensureConnectedToNodes())
createNym(looper, signer.identifier, steward, stewardWallet,
role=SPONSOR, verkey=signer.verkey)
return c, w
def __init__(self,
name: str,
basedirpath: str,
client: Client = None,
wallet: Wallet = None,
port: int = None,
loop=None,
attrRepo=None):
Agent.__init__(self, name, basedirpath, client, port, loop=loop)
self._wallet = wallet or Wallet(name)
self._attrRepo = attrRepo or AttributeRepoInMemory()
Walleted.__init__(self)
if self.client:
self._initIssuerProverVerifier()
def testCredDefSecretKey(tdir, staticPrimes):
GVT = issuer.AttribDef('gvt', [
issuer.AttribType('name', encode=True),
issuer.AttribType('age', encode=False),
issuer.AttribType('sex', encode=True)
])
sprimes = staticPrimes["prime1"]
# sk = CredDefSecretKey(*sprimes)
sk = CredDefSecretKey(*sprimes)
cd = cred_def.CredDef(322324, GVT.attribNames())
wallet = Wallet("testWallet")
# cdsk = CredDefSk(name, version, serializedSk)
wallet.addCredDefSk(str(sk))
stored = wallet.getCredDefSk(CredDefKey(name, version))
assert serializedSk == stored.secretKey
def runAlice(name=None,
wallet=None,
basedirpath=None,
port=None,
startRunning=True):
# TODO: Copied code from `runFaber`, need to refactor
name = name or 'Alice Jones'
wallet = wallet or Wallet(name)
config = getConfig()
basedirpath = basedirpath or os.path.expanduser(config.baseDir)
if not port:
_, port = genHa()
_, clientPort = genHa()
client = Client(randomString(6),
ha=("0.0.0.0", clientPort),
basedirpath=basedirpath)
def listClaims(msg):
body, frm = msg
"""
body = {
"type": <some type>,
"identifier": <id>,
"nonce": <nonce>,
"signature" : <sig>
}
"""
# TODO: Need to do nonce verification here
data = json.loads(body)
print(data)
# wallet.knownIds[data['identifier']] =
# TODO: Send claims
handlers = {AVAIL_CLAIM_LIST: listClaims}
alice = AliceAgent(name,
basedirpath=basedirpath,
client=client,
port=port,
handlers=handlers)
if startRunning:
with Looper(debug=True) as looper:
looper.add(alice)
logger.debug("Running Faber now...")
looper.run()
else:
return alice
def testNewKeyChangesWalletsDefaultId(be, do, poolNodesStarted,
aliceCLI, connectedToTest):
mywallet = Wallet('my wallet')
keyseed='a'*32
idr, _ = mywallet.addIdentifier(seed=keyseed.encode("utf-8"))
be(aliceCLI)
do('connect test', within=3, expect=connectedToTest)
do('new key with seed {}'.format(keyseed))
do('send NYM dest={}'.format(idr))
do('new key with seed 11111111111111111111111111111111')
do('send NYM dest={}'.format(idr),
within=3,
expect=["Nym {} added".format(idr)]
)
def wallet():
return Wallet('my wallet')
def _newWallet(name=None):
signer = SimpleSigner()
w = Wallet(name or signer.identifier)
w.addIdentifier(signer=signer)
return w
def clientAndWallet1(client1Signer, looper, nodeSet, tdir, up):
client, wallet = genTestClient(nodeSet, tmpdir=tdir)
wallet = Wallet(client.name)
wallet.addSigner(signer=client1Signer)
return client, wallet
def __init__(self, client=None):
self.client = client
self.wallet = Wallet(self.client) # created only once per organization
self.userWallets = {} # type: Dict[str, Wallet]
def stewardWallet():
wallet = Wallet('steward')
seed = b'is a pit seed, or somepin else'
wallet.addSigner(seed=seed)
assert wallet.defaultId == 'LRtO/oin94hzKKCVG4GOG1eMuH7uVMJ3txDUHBX2BqY='
return wallet
def _(name):
wallet = Wallet(name)
wallet.addIdentifier(signer=DidSigner())
return wallet
def trusteeWallet(trusteeData):
name, sigseed = trusteeData
wallet = Wallet('trustee')
signer = SimpleSigner(seed=sigseed)
wallet.addIdentifier(signer=signer)
return wallet
def sponsorWallet():
wallet = Wallet('sponsor')
seed = b'sponsors are people too.........'
wallet.addIdentifier(seed=seed)
return wallet
def buildAgentWallet(name, seed):
wallet = Wallet(name)
wallet.addIdentifier(signer=SimpleSigner(seed=seed))
return wallet
def faberWallet():
name = "FaberCollege"
wallet = Wallet(name)
return wallet
def aliceWallet():
name = "Alice"
wallet = Wallet(name)
return wallet
def clientAndWallet1(client1Signer, looper, nodeSet, tdir, up):
client, wallet = genTestClient(nodeSet, tmpdir=tdir, usePoolLedger=True)
wallet = Wallet(client.name)
wallet.addIdentifier(signer=client1Signer)
return client, wallet
def acmeWallet():
name = "Acme"
wallet = Wallet(name)
return wallet
def stewardWallet(poolTxnStewardData):
name, sigseed = poolTxnStewardData
wallet = Wallet('steward')
signer = SimpleSigner(seed=sigseed)
wallet.addIdentifier(signer=signer)
return wallet
def addUser(looper, creatorClient, creatorWallet, name):
wallet = Wallet(name)
wallet.addSigner()
createNym(looper, wallet.defaultId, creatorClient, creatorWallet)
return wallet