def _handleAcceptance(self, msg): body, (frm, ha) = msg link = self.verifyAndGetLink(msg) # TODO this is really kludgy code... needs refactoring # exception handling, separation of concerns, etc. if not link: return logger.debug("proceeding with link: {}".format(link.name)) identifier = body.get(f.IDENTIFIER.nm) verkey = body.get(VERKEY) idy = Identity(identifier, verkey=verkey) link.targetVerkey = verkey try: pendingCount = self.wallet.addSponsoredIdentity(idy) logger.debug("pending request count {}".format(pendingCount)) alreadyAdded = False except Exception as e: if e.args[0] in ['identifier already added']: alreadyAdded = True else: logger.warning("Exception raised while adding nym, " "error was: {}".format(e.args[0])) raise e def sendClaimList(reply=None, error=None): logger.debug("sent to sovrin {}".format(identifier)) resp = self.createAvailClaimListMsg(self.getAvailableClaimList(), alreadyAccepted=alreadyAdded) self.signAndSend(resp, link.localIdentifier, frm, origReqId=body.get(f.REQ_ID.nm)) if alreadyAdded: sendClaimList() logger.debug("already accepted, " "so directly sending available claims") self.agentLogger.info( 'Already added identifier [{}] in sovrin'.format(identifier)) # self.notifyToRemoteCaller(EVENT_NOTIFY_MSG, # " Already accepted", # link.verkey, frm) else: logger.debug("not added to the ledger, so add nym to the ledger " "and then will send available claims") reqs = self.wallet.preparePending() # Assuming there was only one pending request logger.debug("sending to sovrin {}".format(reqs[0])) # Specifically for bulldog POC, need to think through # how to provide separate logging for each agent # anyhow this class should be implemented by each agent # so we might not even need to add it as a separate logic self.agentLogger.info( 'Creating identifier [{}] in sovrin'.format(identifier)) self._sendToSovrinAndDo(reqs[0], clbk=sendClaimList)
def testRetrieveEmptyVerkey(didAddedWithoutVerkey, looper, trustAnchor, trustAnchorWallet, noKeyIdr): """{ type: GET_NYM, dest: <id1> }""" identity = Identity(identifier=noKeyIdr) req = trustAnchorWallet.requestIdentity(identity, sender=trustAnchorWallet.defaultId) trustAnchor.submitReqs(req) def chk(): assert trustAnchorWallet.getIdentity(noKeyIdr).verkey is None looper.run(eventually(chk, retryWait=1, timeout=5))
def fetchFullVerkeyFromSovrin(looper, senderWallet, senderClient, ownerWallet, idr): identity = Identity(identifier=idr) req = senderWallet.requestIdentity(identity, sender=senderWallet.defaultId) senderClient.submitReqs(req) def chk(): retrievedVerkey = senderWallet.getIdentity(idr).verkey assertEquality(retrievedVerkey, ownerWallet.getVerkey(idr)) checkFullVerkeySize(retrievedVerkey) looper.run(eventually(chk, retryWait=1, timeout=5))
def suspendRole(looper, actingClient, actingWallet, did): idy = Identity(identifier=did, role=None) if actingWallet.getSponsoredIdentity(did): actingWallet.updateSponsoredIdentity(idy) else: actingWallet.addSponsoredIdentity(idy) reqs = actingWallet.preparePending() actingClient.submitReqs(*reqs) def chk(): assert actingWallet.getSponsoredIdentity(did).seqNo is not None looper.run(eventually(chk, retryWait=1, timeout=5))
def createNym(looper, nym, creatorClient, creatorWallet: Wallet, role=None, verkey=None): idy = Identity(identifier=nym, verkey=verkey, role=role) creatorWallet.addSponsoredIdentity(idy) reqs = creatorWallet.preparePending() creatorClient.submitReqs(*reqs) def check(): assert creatorWallet._sponsored[nym].seqNo looper.run(eventually(check, timeout=10))
def verkeyFetched(didUpdatedWithVerkey, looper, trustAnchor, trustAnchorWallet, noKeyIdr, wallet): """{ type: GET_NYM, dest: <id1> }""" identity = Identity(identifier=noKeyIdr) req = trustAnchorWallet.requestIdentity(identity, sender=trustAnchorWallet.defaultId) trustAnchor.submitReqs(req) def chk(): assert trustAnchorWallet.getIdentity( noKeyIdr).verkey == wallet.getVerkey(noKeyIdr) looper.run(eventually(chk, retryWait=1, timeout=5))
def updateSovrinIdrWithVerkey(looper, senderWallet, senderClient, idr, fullKey): idy = Identity(identifier=idr, verkey=fullKey) senderWallet.updateTrustAnchoredIdentity(idy) # TODO: What if the request fails, there must be some rollback mechanism assert senderWallet.getTrustAnchoredIdentity(idr).seqNo is None reqs = senderWallet.preparePending() senderClient.submitReqs(*reqs) def chk(): assert senderWallet.getTrustAnchoredIdentity(idr).seqNo is not None timeout = plenumWaits.expectedReqAckQuorumTime() looper.run(eventually(chk, retryWait=1, timeout=timeout))
def updateSovrinIdrWithFullKey(looper, senderWallet, senderClient, ownerWallet, idr, fullKey): idy = Identity(identifier=idr, verkey=fullKey) senderWallet.updateSponsoredIdentity(idy) # TODO: What if the request fails, there must be some rollback mechanism assert senderWallet.getSponsoredIdentity(idr).seqNo is None reqs = senderWallet.preparePending() senderClient.submitReqs(*reqs) def chk(): assert senderWallet.getSponsoredIdentity(idr).seqNo is not None looper.run(eventually(chk, retryWait=1, timeout=5)) return ownerWallet
def testRetrieveAbbrvVerkey(didAddedWithAbbrvVerkey, looper, trustAnchor, trustAnchorWallet, wallet, abbrevIdr): """{ type: GET_NYM, dest: <id1> }""" identity = Identity(identifier=abbrevIdr) req = trustAnchorWallet.requestIdentity(identity, sender=trustAnchorWallet.defaultId) trustAnchor.submitReqs(req) def chk(): retrievedVerkey = trustAnchorWallet.getIdentity(abbrevIdr).verkey assertEquality(retrievedVerkey, wallet.getVerkey(abbrevIdr)) checkAbbrVerkeySize(retrievedVerkey) looper.run(eventually(chk, retryWait=1, timeout=5)) chkVerifyForRetrievedIdentity(wallet, trustAnchorWallet, abbrevIdr)
def testRetrieveFullVerkey(didAddedWithFullVerkey, looper, sponsor, sponsorWallet, wallet, fullKeyIdr): """{ type: GET_NYM, dest: <id1> }""" identity = Identity(identifier=fullKeyIdr) req = sponsorWallet.requestIdentity(identity, sender=sponsorWallet.defaultId) sponsor.submitReqs(req) def chk(): retrievedVerkey = sponsorWallet.getIdentity(fullKeyIdr).verkey assert retrievedVerkey == wallet.getVerkey(fullKeyIdr) checkFullVerkeySize(retrievedVerkey) looper.run(eventually(chk, retryWait=1, timeout=5)) chkVerifyForRetrievedIdentity(wallet, sponsorWallet, fullKeyIdr)
def testRetrieveFullVerkey(didAddedWithFullVerkey, looper, trustAnchor, trustAnchorWallet, wallet, fullKeyIdr): """{ type: GET_NYM, dest: <id1> }""" identity = Identity(identifier=fullKeyIdr) req = trustAnchorWallet.requestIdentity(identity, sender=trustAnchorWallet.defaultId) trustAnchor.submitReqs(req) def chk(): retrievedVerkey = trustAnchorWallet.getIdentity(fullKeyIdr).verkey assert retrievedVerkey == wallet.getVerkey(fullKeyIdr) checkFullVerkeySize(retrievedVerkey) timeout = plenumWaits.expectedReqAckQuorumTime() looper.run(eventually(chk, retryWait=1, timeout=timeout)) chkVerifyForRetrievedIdentity(wallet, trustAnchorWallet, fullKeyIdr)
def createNym(looper, nym, creatorClient, creatorWallet: Wallet, role=None, verkey=None): idy = Identity(identifier=nym, verkey=verkey, role=role) creatorWallet.addTrustAnchoredIdentity(idy) reqs = creatorWallet.preparePending() creatorClient.submitReqs(*reqs) def check(): assert creatorWallet._trustAnchored[nym].seqNo timeout = waits.expectedTransactionExecutionTime(len( creatorClient.nodeReg)) looper.run(eventually(check, retryWait=1, timeout=timeout))
def demo_start_agent(base_dir, create_func, bootstrap_func, client, looper, steward): looper.runFor(2) agent = create_func(base_dir_path=base_dir, client=client) steward.publish_trust_anchor(Identity(identifier=agent.wallet.defaultId, verkey=agent.wallet.getVerkey(agent.wallet.defaultId), role=TRUST_ANCHOR)) looper.runFor(4) raw = '{"endpoint": {"ha": "127.0.0.1:' + str(agent.port) + '"}}' endpointAttrib = agent.wallet.build_attrib(agent.wallet.defaultId, raw=raw) agent.publish_trust_anchor_attribute(endpointAttrib) looper.runFor(4) looper.add(agent) looper.runFor(2) looper.run(bootstrap_func(agent))
def test_nym_addition_fails_with_empty_verkey(looper, addedTrustAnchor, trustAnchor, trustAnchorWallet): new_wallet = addRole(looper, trustAnchor, trustAnchorWallet, 'userC', useDid=False, addVerkey=False) idy = Identity(identifier=new_wallet.defaultId, verkey='') trustAnchorWallet.updateTrustAnchoredIdentity(idy) reqs = trustAnchorWallet.preparePending() reqs = trustAnchor.submitReqs(*reqs) timeout = waits.expectedReqNAckQuorumTime() looper.run( eventually( checkNacks, trustAnchor, reqs[0].reqId, 'validation error: b58 decoded value length 0 should be one of [32]', retryWait=1, timeout=timeout))
def sendChangeVerkey(actingClient, actingWallet, idr, verkey): idy = Identity(identifier=idr, verkey=verkey) return sendIdentityRequest(actingClient, actingWallet, idy)
def getIdentity(self, identifier): identity = Identity(identifier=identifier) req = self.wallet.requestIdentity(identity, sender=self.wallet.defaultId) self.getClient().submitReqs(req) return req
def sendSuspendRole(actingClient, actingWallet, did): idy = Identity(identifier=did, role=NULL) return sendIdentityRequest(actingClient, actingWallet, idy)
def changeVerkey(looper, actingClient, actingWallet, idr, verkey): idy = Identity(identifier=idr, verkey=verkey) return makeIdentityRequest(looper, actingClient, actingWallet, idy)
def suspendRole(looper, actingClient, actingWallet, did): idy = Identity(identifier=did, role=NULL) return makeIdentityRequest(looper, actingClient, actingWallet, idy)
def makeRequest(cli, wallet): signer = newSigner() idy = Identity(identifier=signer.identifier, verkey=signer.verkey) wallet.addTrustAnchoredIdentity(idy)
def test_end_to_end(tconf): base_dir = tconf.baseDir print('*' * 20) print(base_dir) print('*' * 20) with create_local_pool(base_dir) as network: print(network.genesis_transactions) network.runFor(5) client = network.create_client(5555) bank_wallet = Wallet() bank_agent = RefAgent(name="bank", basedirpath=base_dir, client=client, wallet=bank_wallet, port=8787, endpointArgs={ 'seed': BANK_SEED, 'onlyListener': True }) network.add(bank_agent) bank_id, bank_verkey = bank_agent.new_identifier(seed=BANK_SEED) print(bank_id) print(bank_verkey) s1_agent = network.steward_agent() s1_agent.publish_trust_anchor( Identity(identifier=bank_id, verkey=bank_verkey, role=TRUST_ANCHOR)) network.runFor(5) # this allows calling asynchronous functions from a synchronous context run_async = network.run bank_attribute_definition = \ anoncreds.protocol.types.AttribDef('basic', [anoncreds.protocol.types.AttribType('title', encode=True), anoncreds.protocol.types.AttribType('first_name', encode=True), anoncreds.protocol.types.AttribType('last_name', encode=True), anoncreds.protocol.types.AttribType('address_1', encode=True), anoncreds.protocol.types.AttribType('address_2', encode=True), anoncreds.protocol.types.AttribType('address_3', encode=True), anoncreds.protocol.types.AttribType('postcode_zip', encode=True), anoncreds.protocol.types.AttribType('date_of_birth', encode=True), anoncreds.protocol.types.AttribType('account_type', encode=True), anoncreds.protocol.types.AttribType('year_opened', encode=True), anoncreds.protocol.types.AttribType('account_status', encode=True)]) bank_agent.add_attribute_definition(bank_attribute_definition) backend = MockBackendSystem(bank_attribute_definition) alices_id_in_banks_system = 1999891343 bobs_id_in_banks_system = 2911891343 backend.add_record(alices_id_in_banks_system, title='Mrs.', first_name='Alicia', last_name='Garcia', address_1='H-301', address_2='Street 1', address_3='UK', postcode_zip='G61 3NR', date_of_birth='December 28, 1990', account_type='savings', year_opened='2000', account_status='active') backend.add_record(bobs_id_in_banks_system, title='Mrs.', first_name='Jay', last_name='Raj', address_1='222', address_2='Baker Street', address_3='UK', postcode_zip='G61 3NR', date_of_birth='January 15, 1980', account_type='savings', year_opened='1999', account_status='active') bank_agent.set_issuer_backend(backend) schema_id = run_async( bank_agent.publish_schema('basic', schema_name='Bank Membership', schema_version='1.0')) # NOTE: do NOT use known primes in a non-test environment issuer_pub_key, revocation_pub_key = run_async( bank_agent.publish_issuer_keys(schema_id, p_prime=primes["prime1"][0], q_prime=primes["prime1"][1])) print(issuer_pub_key) print(revocation_pub_key) # TODO: Not implemented yet # accPK = run_async(bank_agent.publish_revocation_registry( # schema_id=schema_id)) # print(accPK) run_async( bank_agent._set_available_claim_by_internal_id( alices_id_in_banks_system, schema_id)) run_async( bank_agent._set_available_claim_by_internal_id( bobs_id_in_banks_system, schema_id)) alice_wallet = Wallet() alice_agent = RefAgent(name="Alice", basedirpath=base_dir, client=client, wallet=alice_wallet, port=8786) network.add(alice_agent) network.runFor(1) invitation = bank_agent.create_link(alices_id_in_banks_system, "Alice") # Transfer of this invitation happens out-of-band (website, QR code, etc) alices_link_to_bank = alice_agent.load_invitation_str(invitation) # notice the link is not accepted print(alices_link_to_bank) alice_agent.accept_invitation(alices_link_to_bank) network.runFor(10) # notice that the link is accepted print(alices_link_to_bank) banks_link_to_alice = bank_agent.get_link_by_name( alices_id_in_banks_system) # note the available claims are now there print(banks_link_to_alice) claim_to_request = alices_link_to_bank.find_available_claim( name='Bank Membership') print(claim_to_request) run_async(alice_agent.send_claim(alices_link_to_bank, claim_to_request)) network.runFor(5) claim = run_async(alice_agent.get_claim(schema_id)) print(claim)