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)
