async def test(self):
# 1. Create wallet.
# 2. Open wallet.
self.wallet_handle = await common.create_and_open_wallet_for_steps(
self.steps, self.wallet_name, self.pool_name)
# 3. Create 'issuer_did1'.
# 4. Create 'issuer_did2'.
((issuer_did1, _),
(issuer_did2, _)) = await common.create_and_store_dids_and_verkeys(
self.steps, self.wallet_handle, number=2,
step_descriptions=["Create 'issuer_did1'", "Create 'issuer_did2'"])
# 5. Create and store claim definition.
self.steps.add_step("Create and store claim definition")
await utils.perform(self.steps,
anoncreds.issuer_create_and_store_claim_def,
self.wallet_handle, issuer_did1,
json.dumps(constant.gvt_schema),
constant.signature_type, False)
# 6. Store claim offer for 'issuer_did1'.
self.steps.add_step("Store claim offer for 'issuer_did1'")
offer_json1 = utils.create_claim_offer(issuer_did1,
constant.gvt_schema_seq)
await utils.perform(self.steps, anoncreds.prover_store_claim_offer,
self.wallet_handle, json.dumps(offer_json1),
ignore_exception=False)
# 7. Store claim offer for 'issuer_did2'.
self.steps.add_step("Store claim offer for 'issuer_did2'")
offer_json2 = utils.create_claim_offer(issuer_did2,
constant.gvt_schema_seq)
await utils.perform(self.steps, anoncreds.prover_store_claim_offer,
self.wallet_handle, json.dumps(offer_json2),
ignore_exception=False)
# 8. Get claim offers and store returned value into 'list_claim_offer'.
self.steps.add_step("Get claim offers and store "
"returned value in to 'list_claim_offer'")
list_claim_offer = await \
utils.perform(self.steps, anoncreds.prover_get_claim_offers,
self.wallet_handle, '{}')
list_claim_offer = json.loads(list_claim_offer)
# 9. Verify that 'offer_json1' and 'offer_json2'
# exist in 'list_claim_offer'.
self.steps.add_step("Verify that 'offer_json1' and 'offer_json2' "
"exist in 'list_claim_offer'")
utils.check(self.steps, error_message="Cannot store a claim offer",
condition=lambda: offer_json1 in list_claim_offer and
offer_json2 in list_claim_offer)
async def test(self):
# 1. Create wallet.
# 2. Open wallet.
self.wallet_handle = await common.create_and_open_wallet_for_steps(
self.steps, self.wallet_name, self.pool_name)
# 3. Create 'issuer_did'.
self.steps.add_step("Create 'issuer_did'")
(issuer_did, _) = await utils.perform(self.steps,
signus.create_and_store_my_did,
self.wallet_handle, "{}")
# 4. Create and store claim definition.
self.steps.add_step("Create and store claim definition")
await utils.perform(self.steps,
anoncreds.issuer_create_and_store_claim_def,
self.wallet_handle, issuer_did,
json.dumps(constant.gvt_schema),
constant.signature_type, False)
# 5. Store claim offer with invalid json and
# verify that claim offer cannot be stored.
self.steps.add_step("Store claim offer with invalid json and "
"verify that claim offer cannot be stored")
offer_json = utils.create_claim_offer(issuer_did,
constant.gvt_schema_seq)
error_code = ErrorCode.WalletInvalidHandle
await utils.perform_with_expected_code(
self.steps,
anoncreds.prover_store_claim_offer,
self.wallet_handle + 1,
json.dumps(offer_json),
expected_code=error_code)
async def test(self):
# 1. Create wallet.
# 2. Open wallet.
self.wallet_handle = await common.create_and_open_wallet_for_steps(
self.steps, self.wallet_name, self.pool_name)
# 3. Create 'issuer_did'.
# 4. Create 'prover_did'.
((issuer_did, _),
(prover_did, _)) = await common.create_and_store_dids_and_verkeys(
self.steps,
self.wallet_handle,
number=2,
step_descriptions=["Create 'issuer_did'", "Create 'prover_did'"])
# 5. Create master secret.
self.steps.add_step("Create master secret")
await utils.perform(self.steps, anoncreds.prover_create_master_secret,
self.wallet_handle, constant.secret_name)
# 6. Create and store claim definition.
self.steps.add_step("Create and store claim definition")
claim_def = await utils.perform(
self.steps, anoncreds.issuer_create_and_store_claim_def,
self.wallet_handle, issuer_did, json.dumps(constant.gvt_schema),
constant.signature_type, False)
# 7. Create claim request.
self.steps.add_step("Create claim request")
claim_offer = utils.create_claim_offer(issuer_did,
constant.gvt_schema_seq)
claim_req = await utils.perform(
self.steps, anoncreds.prover_create_and_store_claim_req,
self.wallet_handle, prover_did, json.dumps(claim_offer), claim_def,
constant.secret_name)
# 8. Create claim that not correspond with 'claim_req' and verify that
# user cannot create claim.
self.steps.add_step("Create claim that not correspond with 'claim_req'"
" and verify that user cannot create claim")
error_code = ErrorCode.CommonInvalidStructure
await utils.perform_with_expected_code(self.steps,
anoncreds.issuer_create_claim,
self.wallet_handle,
claim_req,
json.dumps(constant.xyz_claim),
-1,
expected_code=error_code)
async def test(self):
# 1. Create wallet.
# 2. Open wallet.
self.wallet_handle = await common.create_and_open_wallet_for_steps(
self.steps, self.wallet_name, self.pool_name)
# 3. Create 'issuer_did'.
self.steps.add_step("Create 'issuer_did'")
(issuer_did, _) = await utils.perform(self.steps,
signus.create_and_store_my_did,
self.wallet_handle, "{}")
# 4. Create and store claim definition.
self.steps.add_step("Create and store claim definition")
await utils.perform(self.steps,
anoncreds.issuer_create_and_store_claim_def,
self.wallet_handle, issuer_did,
json.dumps(constant.gvt_schema),
constant.signature_type, False)
# 5. Store claim offer and verify that there is no exception raise.
self.steps.add_step("Store claim offer and verify that "
"there is no exception raise")
offer_json = utils.create_claim_offer(issuer_did,
constant.gvt_schema_seq)
await utils.perform(self.steps,
anoncreds.prover_store_claim_offer,
self.wallet_handle,
json.dumps(offer_json),
ignore_exception=False)
# 6. Get claim offers and store returned value into 'list_claim_offer'.
self.steps.add_step("Get claim offers and store "
"returned value in to 'list_claim_offer'")
list_claim_offer = await utils.perform(
self.steps, anoncreds.prover_get_claim_offers, self.wallet_handle,
'{}')
list_claim_offer = json.loads(list_claim_offer)
# 7. Verify that 'offer_json' exists in 'list_claim_offer'.
self.steps.add_step("Verify that 'offer_json' exists "
"in 'list_claim_offer'")
utils.check(self.steps,
error_message="Cannot store a claim offer",
condition=lambda: offer_json in list_claim_offer)
async def test(self):
# 1. Create wallet.
# 2. Open wallet.
self.wallet_handle = await \
common.create_and_open_wallet_for_steps(self.steps,
self.wallet_name,
self.pool_name)
# 3. Create 'issuer_did'.
self.steps.add_step("Create 'issuer_did'")
(issuer_did, _) = await utils.perform(self.steps,
signus.create_and_store_my_did,
self.wallet_handle, "{}")
# 4. Create 'prover_did'.
self.steps.add_step("Create 'prover_did'")
(prover_did, _) = await utils.perform(self.steps,
signus.create_and_store_my_did,
self.wallet_handle, '{}')
# 5. Create master secret.
self.steps.add_step("Create master secret")
await utils.perform(self.steps, anoncreds.prover_create_master_secret,
self.wallet_handle, constant.secret_name)
# 6. Create and store claim definition.
self.steps.add_step("Create and store claim definition")
claim_def = await \
utils.perform(self.steps,
anoncreds.issuer_create_and_store_claim_def,
self.wallet_handle, issuer_did,
json.dumps(constant.gvt_schema),
constant.signature_type, False)
# 7. Create claim request.
self.steps.add_step("Create claim request")
claim_offer = utils.create_claim_offer(issuer_did,
constant.gvt_schema_seq)
claim_req = await \
utils.perform(self.steps,
anoncreds.prover_create_and_store_claim_req,
self.wallet_handle, prover_did,
json.dumps(claim_offer), claim_def,
constant.secret_name)
# 8. Create claim.
self.steps.add_step("Create claim")
(_, created_claim) = await \
utils.perform(self.steps, anoncreds.issuer_create_claim,
self.wallet_handle, claim_req,
json.dumps(constant.gvt_claim), -1)
# 9. Store claims into wallet.
self.steps.add_step("Store claims into wallet")
await utils.perform(self.steps, anoncreds.prover_store_claim,
self.wallet_handle, created_claim)
# 10. Get stored claims with proof request that
# contains empty requested attrs and
# store result into 'returned_claims'.
self.steps.add_step(
"Get stored claims with proof request that contains "
"empty requested attrs and store result into 'returned_claims'")
attrs_req = {"attr1_referent": {"name": "name"}}
predicates_js = {
"predicate1_referent": {
"attr_name": "age",
"p_type": "GE",
"value": 25
}
}
proof_req = utils.create_proof_req("1", "proof_req_1", "1.0",
attrs_req, predicates_js)
returned_claims = json.loads(await utils.perform(
self.steps, anoncreds.prover_get_claims_for_proof_req,
self.wallet_handle, proof_req))
# 11. Get claim
self.steps.add_step("Get claims")
lst_claims = json.loads(await
utils.perform(self.steps,
anoncreds.prover_get_claims,
self.wallet_handle, "{}"))
# 12. Check returned_claims['attrs'].
self.steps.add_step("Check returned_claims['attrs'] is correct")
err_msg = "returned_claims['attrs'] is incorrect"
utils.check(self.steps,
error_message=err_msg,
condition=lambda: returned_claims['attrs']['attr1_referent'
] == lst_claims)
# 13. Check returned_claims['predicates'].
self.steps.add_step("Check returned_claims['predicates'] is correct")
err_msg = "returned_claims['predicates'] is incorrect"
utils.check(self.steps,
error_message=err_msg,
condition=lambda: returned_claims['predicates'][
'predicate1_referent'] == lst_claims)
async def test(self):
# 1. Create wallet.
# 2. Open wallet.
self.wallet_handle = await common.create_and_open_wallet_for_steps(
self.steps, self.wallet_name, self.pool_name)
# 3. Create 'issuer_did'.
# 4. Create 'prover_did'.
((issuer_did, _),
(prover_did, _)) = await common.create_and_store_dids_and_verkeys(
self.steps,
self.wallet_handle,
number=2,
step_descriptions=["Create 'issuer_did'", "Create 'prover_did'"])
# 5. Create master secret.
self.steps.add_step("Create master secret")
await utils.perform(self.steps, anoncreds.prover_create_master_secret,
self.wallet_handle, constant.secret_name)
# 6. Create and store claim definition.
self.steps.add_step("Create and store claim definition")
gvt_claim_def = await utils.perform(
self.steps, anoncreds.issuer_create_and_store_claim_def,
self.wallet_handle, issuer_did, json.dumps(constant.gvt_schema),
constant.signature_type, False)
# 7. Create claim request.
# 8. Create claim.
# 9. Store claims into wallet.
claim_offer = utils.create_claim_offer(issuer_did,
constant.gvt_schema_seq)
await common.create_and_store_claim(self.steps,
self.wallet_handle, prover_did,
json.dumps(claim_offer),
gvt_claim_def,
constant.secret_name,
json.dumps(constant.gvt_claim), -1)
# 10. Get stored claims with proof and
# store result into 'returned_claims'.
self.steps.add_step("Get stored claims with proof request "
"and store result into 'returned_claims'")
proof_req = utils.create_proof_req(
"1",
"proof_req_1",
"1.0",
requested_attrs={'attr1_referent': {
'name': 'name'
}},
requested_predicates={})
returned_claims = await utils.perform(
self.steps, anoncreds.prover_get_claims_for_proof_req,
self.wallet_handle, proof_req)
returned_claims = json.loads(returned_claims)
# 11. Create proof for proof request and
# store result as "created_proof".
self.steps.add_step("Create proof for proof request and "
"store result as 'created_proof'")
referent = returned_claims["attrs"]["attr1_referent"][0][
constant.claim_uuid_key]
requested_claims_json = json.dumps({
'self_attested_attributes': {},
'requested_attrs': {
'attr1_referent': [referent, True]
},
'requested_predicates': {}
})
schemas_json = json.dumps({referent: constant.gvt_schema})
claims_defs_json = json.dumps({referent: json.loads(gvt_claim_def)})
created_proof = await utils.perform(self.steps,
anoncreds.prover_create_proof,
self.wallet_handle, proof_req,
requested_claims_json,
schemas_json, constant.secret_name,
claims_defs_json, '{}')
# 12. Create 'issuer_did2'.
self.steps.add_step("Create 'issuer_did2'")
issuer_did2, _ = await utils.perform(self.steps,
signus.create_and_store_my_did,
self.wallet_handle, '{}')
# 13. Create and store other claim definition with 'issuer_did2'
# and store returned result as 'gvt_claim_def2'.
self.steps.add_step("Create and store other claim definition with "
"'issuer_did2' and store returned result as"
" 'gvt_claim_def2'")
gvt_claim_def2 = await utils.perform(
self.steps, anoncreds.issuer_create_and_store_claim_def,
self.wallet_handle, issuer_did2, json.dumps(constant.gvt_schema),
constant.signature_type, False)
# 14. Verify created proof with incompatible claim defs json.
self.steps.add_step("Verify created proof with "
"incompatible claim defs json")
claims_defs_json = json.dumps({referent: json.loads(gvt_claim_def2)})
result = await utils.perform(self.steps,
anoncreds.verifier_verify_proof,
proof_req, created_proof, schemas_json,
claims_defs_json, '{}')
err_msg = "True is returned instead"
utils.check(self.steps,
error_message=err_msg,
condition=lambda: not result)
async def test(self):
# 1. Create wallet.
# 2. Open wallet.
self.wallet_handle = await common.create_and_open_wallet_for_steps(
self.steps, self.wallet_name, self.pool_name)
# 3. Create 'issuer1_did'.
# 4. Create 'issuer2_did'.
# 5. Create 'prover_did'.
((issuer1_did, _), (issuer2_did, _),
(prover_did, _)) = await common.create_and_store_dids_and_verkeys(
self.steps,
self.wallet_handle,
number=3,
step_descriptions=[
"Create 'issuer1_did'", "Create 'issuer2_did'",
"Create 'prover_did'"
])
# 6. Create master secret.
self.steps.add_step("Create master secret")
await utils.perform(self.steps, anoncreds.prover_create_master_secret,
self.wallet_handle, constant.secret_name)
# 7. Create and store claim definition with 'issuer1_did'.
self.steps.add_step("Create and store claim definition "
"with 'issuer1_did'")
gvt_claim_def = await utils.perform(
self.steps, anoncreds.issuer_create_and_store_claim_def,
self.wallet_handle, issuer1_did, json.dumps(constant.gvt_schema),
constant.signature_type, False)
# 8. Create and store other claim definition with 'issuer2_did'.
self.steps.add_step("Create and store other claim definition "
"with 'issuer2_did'")
xyz_claim_def = await utils.perform(
self.steps, anoncreds.issuer_create_and_store_claim_def,
self.wallet_handle, issuer2_did, json.dumps(constant.xyz_schema),
constant.signature_type, False)
# 9. Create claim request with 'issuer1_did'.
# 10. Create claim.
# 11. Store created claim into wallet.
claim_offer = utils.create_claim_offer(issuer1_did,
constant.gvt_schema_seq)
step_descriptions = [
"Create claim request with 'issuer1_did'", "Create claim",
"Store created claim into wallet"
]
await common.create_and_store_claim(
self.steps,
self.wallet_handle,
prover_did,
json.dumps(claim_offer),
gvt_claim_def,
constant.secret_name,
json.dumps(constant.gvt_claim),
-1,
step_descriptions=step_descriptions)
# 12. Create other claim request with 'issuer2_did'.
# 13. Create other claim.
# 14. Store created claim into wallet.
claim_offer = utils.create_claim_offer(issuer2_did,
constant.xyz_schema_seq)
step_descriptions = [
"Create other claim request with 'issuer2_did'",
"Create other claim", "Store created claim into wallet"
]
await common.create_and_store_claim(
self.steps,
self.wallet_handle,
prover_did,
json.dumps(claim_offer),
xyz_claim_def,
constant.secret_name,
json.dumps(constant.xyz_claim),
-1,
step_descriptions=step_descriptions)
# 15. Get stored claims by filtering with gvt_schema_no.
self.steps.add_step("Get stored claims by "
"filtering with gvt_schema_no")
filter_json = json.dumps({"schema_seq_no": constant.gvt_schema_seq})
lst_claims = await utils.perform(self.steps,
anoncreds.prover_get_claims,
self.wallet_handle, filter_json)
lst_claims = json.loads(lst_claims)
# 16. Check returned list claims.
self.steps.add_step("Check returned list claims")
err_msg = "Cannot get claims from wallet"
utils.check(self.steps,
error_message=err_msg,
condition=lambda: len(lst_claims) == 1)
# 17. Check lst_claims[0]['claim_uuid'].
# 18. Check lst_claims[0]['attrs'].
# 19. Check lst_claims[0]['issuer_did'].
# 20. Check lst_claims[0]['schema_seq_no'].
utils.check_gotten_claim_is_valid(self.steps, lst_claims[0],
constant.gvt_claim, issuer1_did,
constant.gvt_schema_seq)
async def test(self):
# 1. Create wallet.
# 2. Open wallet.
self.wallet_handle = await common.create_and_open_wallet_for_steps(
self.steps, self.wallet_name, self.pool_name)
# 3. Create 'issuer_did'.
# 4. Create 'prover_did'.
((issuer_did, _),
(prover_did, _)) = await common.create_and_store_dids_and_verkeys(
self.steps,
self.wallet_handle,
number=2,
step_descriptions=["Create 'issuer_did'", "Create 'prover_did'"])
# 5. Create master secret.
self.steps.add_step("Create master secret")
await utils.perform(self.steps, anoncreds.prover_create_master_secret,
self.wallet_handle, constant.secret_name)
# 6. Create and store claim definition.
self.steps.add_step("Create and store claim definition")
claim_def = await utils.perform(
self.steps, anoncreds.issuer_create_and_store_claim_def,
self.wallet_handle, issuer_did, json.dumps(constant.gvt_schema),
constant.signature_type, False)
# 7. Create claim request.
self.steps.add_step("Create claim request")
claim_offer = utils.create_claim_offer(issuer_did,
constant.gvt_schema_seq)
claim_req = await utils.perform(
self.steps, anoncreds.prover_create_and_store_claim_req,
self.wallet_handle, prover_did, json.dumps(claim_offer), claim_def,
constant.secret_name)
# 8. Create claim.
self.steps.add_step("Create claim")
(_, created_claim1) = await utils.perform(
self.steps, anoncreds.issuer_create_claim, self.wallet_handle,
claim_req, json.dumps(constant.gvt_claim), -1)
# 9. Create other claim.
self.steps.add_step("Create other claim")
(_, created_claim2) = await utils.perform(
self.steps, anoncreds.issuer_create_claim, self.wallet_handle,
claim_req, json.dumps(constant.gvt_other_claim), -1)
# 10. Store claims into wallet.
self.steps.add_step("Store claims into wallet")
await utils.perform(self.steps, anoncreds.prover_store_claim,
self.wallet_handle, created_claim1)
await utils.perform(self.steps, anoncreds.prover_store_claim,
self.wallet_handle, created_claim2)
# 11. Get claims store in wallet.
self.steps.add_step("Get claims store in wallet")
lst_claims = await utils.perform(self.steps,
anoncreds.prover_get_claims,
self.wallet_handle, "{}")
lst_claims = json.loads(lst_claims)
# 12. Check returned claims.
self.steps.add_step("Check returned claims")
err_msg = "Returned claims is not a list with two elements"
utils.check(self.steps,
error_message=err_msg,
condition=lambda: isinstance(lst_claims, list) and len(
lst_claims) == 2)
async def test(self):
# 1. Create wallet.
# 2. Open wallet.
self.wallet_handle = await common.create_and_open_wallet_for_steps(
self.steps, self.wallet_name, self.pool_name)
# 3. Create 'issuer_did'.
# 4. Create 'prover_did'.
((issuer_did, _),
(prover_did, _)) = await common.create_and_store_dids_and_verkeys(
self.steps,
self.wallet_handle,
number=2,
step_descriptions=["Create 'issuer_did'", "Create 'prover_did'"])
# 5. Create master secret.
self.steps.add_step("Create master secret")
await utils.perform(self.steps, anoncreds.prover_create_master_secret,
self.wallet_handle, constant.secret_name)
# 6. Create and store claim definition.
self.steps.add_step("Create and store claim definition")
claim_def = await utils.perform(
self.steps, anoncreds.issuer_create_and_store_claim_def,
self.wallet_handle, issuer_did, json.dumps(constant.gvt_schema),
constant.signature_type, False)
# 7. Create claim request.
self.steps.add_step("Create claim request")
claim_offer = utils.create_claim_offer(issuer_did,
constant.gvt_schema_seq)
claim_req = await utils.perform(
self.steps, anoncreds.prover_create_and_store_claim_req,
self.wallet_handle, prover_did, json.dumps(claim_offer), claim_def,
constant.secret_name)
claim_req = json.loads(claim_req)
# 8. Check claim_req['blinded_ms'].
self.steps.add_step("Check claim_req['blinded_ms']")
err_msg = "claim_req['blinded_ms'] missing some fields"
blinded_ms = claim_req["blinded_ms"]
utils.check(self.steps,
error_message=err_msg,
condition=lambda: "prover_did" in blinded_ms and "u" in
blinded_ms and "ur" in blinded_ms)
# 9. Check claim_req['blinded_ms']['prover_did'].
self.steps.add_step("Check claim_req['blinded_ms']['prover_did']")
err_msg = "Prover did in claim request mismatches"
utils.check(self.steps,
error_message=err_msg,
condition=lambda: blinded_ms["prover_did"] == prover_did)
# 10. Check claim_req['blinded_ms']['u'].
self.steps.add_step("Check claim_req['blinded_ms']['u']")
err_msg = "claim_req['blinded_ms']['u'] is empty"
utils.check(self.steps,
error_message=err_msg,
condition=lambda: len(blinded_ms["u"]) > 0)
# 11. Check claim_req['blinded_ms']['ur'].
self.steps.add_step("Check claim_req['blinded_ms']['ur']")
err_msg = "claim_req['blinded_ms']['ur'] is not empty"
utils.check(self.steps,
error_message=err_msg,
condition=lambda: not blinded_ms["ur"])
# 12. Check claim_req['issuer_did'].
self.steps.add_step("Check claim_req['issuer_did']")
err_msg = "Issuer did in claim request mismatches"
utils.check(self.steps,
error_message=err_msg,
condition=lambda: claim_req["issuer_did"] == issuer_did)
# 13. Check claim_req['schema_seq_no'].
self.steps.add_step("Check claim_req['schema_seq_no']")
err_msg = "Schema sequence number in claim request mismatches"
utils.check(self.steps,
error_message=err_msg,
condition=lambda: claim_req["schema_seq_no"] == constant.
gvt_schema_seq)
async def test(self):
# 1. Create wallet.
# 2. Open wallet.
self.wallet_handle = await common.create_and_open_wallet_for_steps(
self.steps, self.wallet_name, self.pool_name)
# 3. Create 'issuer_did'.
# 4. Create 'prover_did'.
((issuer_did, _),
(prover_did, _)) = await common.create_and_store_dids_and_verkeys(
self.steps,
self.wallet_handle,
number=2,
step_descriptions=["Create 'issuer_did'", "Create 'prover_did'"])
# 5. Create master secret.
self.steps.add_step("Create master secret")
await utils.perform(self.steps, anoncreds.prover_create_master_secret,
self.wallet_handle, constant.secret_name)
# 6. Create and store claim definition.
self.steps.add_step("Create and store claim definition")
claim_def = await utils.perform(
self.steps, anoncreds.issuer_create_and_store_claim_def,
self.wallet_handle, issuer_did, json.dumps(constant.gvt_schema),
constant.signature_type, False)
# 7. Create claim request and store result in 'claim_req'.
# 8. Create claim and store result as 'created_claim'.
# 9. Store 'created_claim' into wallet.
claim_offer = utils.create_claim_offer(issuer_did,
constant.gvt_schema_seq)
description = [
"Create claim request and store result in 'claim_req'",
"Create claim and store result as 'created_claim'",
"Store 'created_claim' into wallet"
]
await common.create_and_store_claim(self.steps,
self.wallet_handle,
prover_did,
json.dumps(claim_offer),
claim_def,
constant.secret_name,
json.dumps(constant.gvt_claim),
-1,
step_descriptions=description)
# 10. Get stored claims with proof request that
# and store result into 'returned_claims'.
self.steps.add_step("Get stored claims with proof request "
"and store result into 'returned_claims'")
proof_req = utils.create_proof_req(
"1",
"proof_req_1",
"1.0",
requested_attrs={'attr1_referent': {
'name': 'name'
}},
requested_predicates={
'predicate1_referent': {
'attr_name': 'age',
'p_type': 'GE',
'value': 25
}
})
returned_claims = await utils.perform(
self.steps, anoncreds.prover_get_claims_for_proof_req,
self.wallet_handle, proof_req)
returned_claims = json.loads(returned_claims)
# 11. Create proof for proof request
# and store result as "created_proof".
self.steps.add_step("Create proof for proof request and "
"store result as 'created_proof'")
referent = returned_claims["attrs"]["attr1_referent"][0][
constant.claim_uuid_key]
requested_claims_json = json.dumps({
'self_attested_attributes': {},
'requested_attrs': {
'attr1_referent': [referent, True]
},
'requested_predicates': {}
})
schemas_json = json.dumps({referent: constant.gvt_schema})
claims_defs_json = json.dumps({referent: json.loads(claim_def)})
created_proof = await utils.perform(self.steps,
anoncreds.prover_create_proof,
self.wallet_handle, proof_req,
requested_claims_json,
schemas_json, constant.secret_name,
claims_defs_json, '{}')
created_proof = json.loads(created_proof)
temp_proofs = created_proof['proofs']
print(str(temp_proofs.keys()))
temp_ref = temp_proofs[referent]
temp_proof = temp_ref['proof']
temp_pri_proof = temp_proof['primary_proof']
temp_eq_proof = temp_pri_proof['eq_proof']
temp_agg = created_proof['aggregated_proof']
temp_req_proof = created_proof['requested_proof']
# 12. Check created_proof['proofs'][referent]['proof']['primary_proof']
# ['eq_proof']['revealed_attrs']['name']
self.steps.add_step(
"Check created_proof['proofs'][referent]['proof']"
"['primary_proof']['eq_proof']['revealed_attrs']['name']")
err_msg = "created_proof['proofs'][referent]['proof']" \
"['primary_proof']['eq_proof']['revealed_attrs']" \
"['name'] mismatches"
temp = temp_eq_proof['revealed_attrs']['name']
utils.check(self.steps,
error_message=err_msg,
condition=lambda: temp == constant.gvt_claim['name'][1])
# 13. Check created_proof['proofs'][referent]
# ['proof']['primary_proof']['eq_proof']['m']
self.steps.add_step("Check created_proof['proofs'][referent]['proof']"
"['primary_proof']['eq_proof']['m']")
err_msg = "Some field is miss from created_proof['proofs'][referent]"\
"['proof']['primary_proof']['eq_proof']['m']"
utils.check(self.steps,
error_message=err_msg,
condition=lambda: all(i in ('sex', 'height', 'age')
for i in temp_eq_proof['m'].keys()))
# 14. Check created_proof['proofs'][referent]['proof']
# [non_revoc_proof']
self.steps.add_step("Check created_proof['proofs'][referent]['proof']"
"[non_revoc_proof']")
err_msg = "created_proof['proofs'][referent]['proof']" \
"[non_revoc_proof'] is not None"
utils.check(self.steps,
error_message=err_msg,
condition=lambda: not temp_proof['non_revoc_proof'])
# 15. Check created_proof['proofs'][referent]['issuer_did']
self.steps.add_step("Check created_proof['proofs']"
"[referent]['issuer_did']")
err_msg = "created_proof['proofs'][referent]" \
"['issuer_did'] mismatches"
utils.check(self.steps,
error_message=err_msg,
condition=lambda: temp_ref['issuer_did'] == issuer_did)
# 16. Check created_proof['proofs'][referent]['schema_seq_no']
self.steps.add_step("Check created_proof['proofs'][referent]"
"['schema_seq_no']")
err_msg = "Check created_proof['proofs'][referent]" \
"['schema_seq_no'] mismatches"
utils.check(self.steps,
error_message=err_msg,
condition=lambda: temp_ref['schema_seq_no'] == constant.
gvt_schema_seq)
# 17. Check created_proof['aggregated_proof']
self.steps.add_step("Check created_proof" "['aggregated_proof']")
err_msg = "Some field is missing from " \
"created_proof['aggregated_proof']"
utils.check(self.steps,
error_message=err_msg,
condition=lambda: all(i in ('c_hash', 'c_list')
for i in temp_agg))
# 18. Check created_proof['requested_proof']
# ['revealed_attrs']['attr1_referent']
self.steps.add_step("Check created_proof['requested_proof']"
"['revealed_attrs']['attr1_referent']")
err_msg = "created_proof['requested_proof']" \
"['revealed_attrs']['attr1_referent'] mismatches"
temp = temp_req_proof['revealed_attrs']['attr1_referent']
utils.check(
self.steps, err_msg, lambda: all(i in [
referent, constant.gvt_claim['name'][1], constant.gvt_claim[
'name'][0]
] for i in temp))
# 19. Check created_proof['requested_proof']['unrevealed_attrs']
self.steps.add_step("Check created_proof"
"['requested_proof']['unrevealed_attrs']")
err_msg = "created_proof['requested_proof']" \
"['unrevealed_attrs'] is not empty"
utils.check(self.steps,
error_message=err_msg,
condition=lambda: not temp_req_proof['unrevealed_attrs'])
# 20. Check created_proof['requested_proof']['self_attested_attrs']
self.steps.add_step("Check created_proof"
"['requested_proof']['self_attested_attrs']")
err_msg = "created_proof['requested_proof']" \
"['self_attested_attrs'] is not empty"
utils.check(
self.steps,
error_message=err_msg,
condition=lambda: not temp_req_proof['self_attested_attrs'])
# 21. Check created_proof['requested_proof']['predicates']
self.steps.add_step("Check created_proof['requested_proof']"
"['predicates']")
err_msg = "created_proof['requested_proof']" \
"['predicates'] is not empty"
utils.check(self.steps,
error_message=err_msg,
condition=lambda: not temp_req_proof['predicates'])
async def test(self):
# 1. Create wallet.
# 2. Open wallet.
self.wallet_handle = await common.create_and_open_wallet_for_steps(
self.steps, self.wallet_name, self.pool_name)
# 3. Create 'issuer_did'.
# 4. Create 'prover_did'.
((issuer_did, _),
(prover_did, _)) = await common.create_and_store_dids_and_verkeys(
self.steps,
self.wallet_handle,
number=2,
step_descriptions=["Create 'issuer_did'", "Create 'prover_did'"])
# 5. Create master secret.
self.steps.add_step("Create master secret")
await utils.perform(self.steps, anoncreds.prover_create_master_secret,
self.wallet_handle, constant.secret_name)
# 6. Create and store claim definition.
self.steps.add_step("Create and store claim definition")
claim_def = await utils.perform(
self.steps, anoncreds.issuer_create_and_store_claim_def,
self.wallet_handle, issuer_did, json.dumps(constant.gvt_schema),
constant.signature_type, False)
# 7. Create claim request.
# 8. Create claim.
# 9. Store created claim into wallet and verify that
# there is no exception raised.
claim_offer = utils.create_claim_offer(issuer_did,
constant.gvt_schema_seq)
step_descriptions = [
"", "", "Store claim created into wallet and "
"verify that there is no exception raised"
]
await common.create_and_store_claim(
self.steps,
self.wallet_handle,
prover_did,
json.dumps(claim_offer),
claim_def,
constant.secret_name,
json.dumps(constant.gvt_claim),
-1,
ignore_exception=False,
step_descriptions=step_descriptions)
# 10. Get claims store in wallet.
self.steps.add_step("Get claims store in wallet")
lst_claims = await utils.perform(self.steps,
anoncreds.prover_get_claims,
self.wallet_handle, "{}")
lst_claims = json.loads(lst_claims)
# 11. Check lst_claims[0]['claim_uuid'].
# 12. Check lst_claims[0]['attrs'].
# 13. Check lst_claims[0]['issuer_did'].
# 14. Check lst_claims[0]['schema_seq_no'].
utils.check_gotten_claim_is_valid(self.steps, lst_claims[0],
constant.gvt_claim, issuer_did,
constant.gvt_schema_seq)
async def test(self):
# 1. Create wallet.
# 2. Open wallet.
self.wallet_handle = await \
common.create_and_open_wallet_for_steps(self.steps,
self.wallet_name,
self.pool_name)
# 3. Create 'issuer2_did'.
self.steps.add_step("Create 'issuer1_did'")
(issuer1_did, _) = await utils.perform(self.steps,
signus.create_and_store_my_did,
self.wallet_handle, "{}")
# 4. Create 'issuer2_did'.
self.steps.add_step("Create 'issuer2_did'")
(issuer2_did, _) = await utils.perform(self.steps,
signus.create_and_store_my_did,
self.wallet_handle, "{}")
# 5. Create 'prover_did'.
self.steps.add_step("Create 'prover_did'")
(prover_did, _) = await utils.perform(self.steps,
signus.create_and_store_my_did,
self.wallet_handle, '{}')
# 6. Create master secret.
self.steps.add_step("Create master secret")
await utils.perform(self.steps, anoncreds.prover_create_master_secret,
self.wallet_handle, constant.secret_name)
# 7. Create and store claim definition.
self.steps.add_step("Create and store claim definition for issuer1")
gvt_claim_def1 = await \
utils.perform(self.steps,
anoncreds.issuer_create_and_store_claim_def,
self.wallet_handle, issuer1_did,
json.dumps(constant.gvt_schema),
constant.signature_type, False)
# 8. Create and store claim definition.
self.steps.add_step("Create and store claim definition for issuer2")
gvt_claim_def2 = await \
utils.perform(self.steps,
anoncreds.issuer_create_and_store_claim_def,
self.wallet_handle, issuer2_did,
json.dumps(constant.gvt_schema),
constant.signature_type, False)
# 9. Create claim1 request with issuer1.
self.steps.add_step("Create claim request with issuer1")
claim_offer = utils.create_claim_offer(issuer1_did,
constant.gvt_schema_seq)
gvt_claim_req1 = json.loads(await utils.perform(
self.steps, anoncreds.prover_create_and_store_claim_req,
self.wallet_handle, prover_did, json.dumps(claim_offer),
gvt_claim_def1, constant.secret_name))
# 10. Check gvt_claim_req1['issuer_did'].
self.steps.add_step("gvt_claim_req1['issuer_did']")
err_msg = "gvt_claim_req1['issuer_did'] isn't equal issuer1_did"
utils.check(
self.steps,
error_message=err_msg,
condition=lambda: gvt_claim_req1['issuer_did'] == issuer1_did)
# 11. Check gvt_claim_req1['schema_seq_no'].
self.steps.add_step("gvt_claim_req1['schema_seq_no']")
err_msg = "gvt_claim_req1['schema_seq_no'] isn't equal" + \
str(constant.gvt_schema['seqNo'])
utils.check(self.steps,
error_message=err_msg,
condition=lambda: gvt_claim_req1['schema_seq_no'] ==
constant.gvt_schema['seqNo'])
# 12. Create claim request with issuer2.
self.steps.add_step("Create claim request with issuer2")
claim_offer = utils.create_claim_offer(issuer2_did,
constant.gvt_schema_seq)
gvt_claim_req2 = json.loads(await utils.perform(
self.steps, anoncreds.prover_create_and_store_claim_req,
self.wallet_handle, prover_did, json.dumps(claim_offer),
gvt_claim_def2, constant.secret_name))
# 13. Check gvt_claim_req2['issuer_did'].
self.steps.add_step("gvt_claim_req2['issuer_did']")
err_msg = "gvt_claim_req2['issuer_did'] isn't equal issuer2_did"
utils.check(
self.steps,
error_message=err_msg,
condition=lambda: gvt_claim_req2['issuer_did'] == issuer2_did)
# 14. Check gvt_claim_req2['schema_seq_no'].
self.steps.add_step("gvt_claim_req2['schema_seq_no']")
err_msg = "gvt_claim_req2['schema_seq_no'] isn't equal" + \
str(constant.gvt_schema['seqNo'])
utils.check(self.steps,
error_message=err_msg,
condition=lambda: gvt_claim_req2['schema_seq_no'] ==
constant.gvt_schema['seqNo'])
async def test(self):
# 1. Create wallet.
# 2. Open wallet.
self.wallet_handle = await common.create_and_open_wallet_for_steps(
self.steps, self.wallet_name, self.pool_name)
# 3. Create 'issuer_did'.
# 4. Create 'prover_did'.
((issuer_did, _),
(prover_did, _)) = await common.create_and_store_dids_and_verkeys(
self.steps,
self.wallet_handle,
number=2,
step_descriptions=["Create 'issuer_did'", "Create 'prover_did'"])
# 5. Create master secret.
self.steps.add_step("Create master secret")
await utils.perform(self.steps, anoncreds.prover_create_master_secret,
self.wallet_handle, constant.secret_name)
# 6. Create and store claim definition.
self.steps.add_step("Create and store claim definition")
claim_def = await utils.perform(
self.steps, anoncreds.issuer_create_and_store_claim_def,
self.wallet_handle, issuer_did, json.dumps(constant.gvt_schema),
constant.signature_type, False)
# 7. Create claim request.
# 8. Create claim.
# 9. Store claim into wallet.
claim_offer = utils.create_claim_offer(issuer_did,
constant.gvt_schema_seq)
description = [
"Create claim request", "Create claim", "Store claim into wallet"
]
await common.create_and_store_claim(self.steps,
self.wallet_handle,
prover_did,
json.dumps(claim_offer),
claim_def,
constant.secret_name,
json.dumps(constant.gvt_claim),
-1,
step_descriptions=description)
# 10. Get claims store in wallet.
self.steps.add_step("Get claims store in wallet")
filter_json = json.dumps(
{"schema_seq_no": constant.gvt_schema_seq + 1})
lst_claims = await utils.perform(self.steps,
anoncreds.prover_get_claims,
self.wallet_handle, filter_json)
lst_claims = json.loads(lst_claims)
# 11. Check returned claims.
self.steps.add_step("Check returned claims")
err_msg = "Returned claims is not an empty list"
utils.check(self.steps,
error_message=err_msg,
condition=lambda: not lst_claims)
async def test(self):
# 1. Create wallet.
# 2. Open wallet.
self.wallet_handle = await common.create_and_open_wallet_for_steps(
self.steps, self.wallet_name, self.pool_name)
# 3. Create 'issuer_did'.
# 4. Create 'prover_did'.
((issuer_did, _),
(prover_did, _)) = await common.create_and_store_dids_and_verkeys(
self.steps,
self.wallet_handle,
number=2,
step_descriptions=["Create 'issuer_did'", "Create 'prover_did'"])
# 5. Create master secret.
self.steps.add_step("Create master secret")
await utils.perform(self.steps, anoncreds.prover_create_master_secret,
self.wallet_handle, constant.secret_name)
# 6. Create and store claim definition.
self.steps.add_step("Create and store claim definition")
claim_def = await utils.perform(
self.steps, anoncreds.issuer_create_and_store_claim_def,
self.wallet_handle, issuer_did, json.dumps(constant.gvt_schema),
constant.signature_type, False)
# 7. Create claim request.
self.steps.add_step("Create claim request")
claim_offer = utils.create_claim_offer(issuer_did,
constant.gvt_schema_seq)
claim_req = await \
utils.perform(self.steps,
anoncreds.prover_create_and_store_claim_req,
self.wallet_handle, prover_did,
json.dumps(claim_offer), claim_def,
constant.secret_name)
# 8. Create claim.
self.steps.add_step("Create claim")
(_, created_claim) = await \
utils.perform(self.steps, anoncreds.issuer_create_claim,
self.wallet_handle, claim_req,
json.dumps(constant.gvt_claim), -1)
created_claim = json.loads(created_claim)
# 9. Check created_claim['issuer_did'].
self.steps.add_step("Check created_claim['issuer_did']")
error_msg = "'issuer_did' mismatches"
utils.check(
self.steps,
error_msg,
condition=lambda: created_claim['issuer_did'] == issuer_did)
# 10. Check created_claim['schema_seq_no'].
self.steps.add_step("Check created_claim['schema_seq_no']")
error_msg = "'schema_seq_no' mismatches"
utils.check(self.steps,
error_msg,
condition=lambda: created_claim['schema_seq_no'] ==
constant.gvt_schema_seq)
# 11. Check created_claim['claim'].
self.steps.add_step("Check created_claim['claim']")
error_msg = "'claim' mismatches"
utils.check(
self.steps,
error_msg,
condition=lambda: created_claim['claim'] == constant.gvt_claim)
async def test(self):
# 1. Create wallet.
# 2. Open wallet.
self.wallet_handle = await common.create_and_open_wallet_for_steps(
self.steps, self.wallet_name, self.pool_name)
# 3. Create 'issuer_did'.
# 4. Create 'prover_did'.
((issuer_did, _),
(prover_did, _)) = await common.create_and_store_dids_and_verkeys(
self.steps, self.wallet_handle, number=2,
step_descriptions=["Create 'issuer_did'", "Create 'prover_did'"])
# 5. Create master secret.
self.steps.add_step("Create master secret")
await utils.perform(self.steps, anoncreds.prover_create_master_secret,
self.wallet_handle, constant.secret_name)
# 6. Create and store claim definition.
self.steps.add_step("Create and store claim definition")
gvt_claim_def = await utils.perform(
self.steps, anoncreds.issuer_create_and_store_claim_def,
self.wallet_handle, issuer_did, json.dumps(constant.gvt_schema),
constant.signature_type, False)
# 7. Create claim request.
# 8. Create claim.
# 9. Store claims into wallet.
claim_offer = utils.create_claim_offer(issuer_did,
constant.gvt_schema_seq)
await common.create_and_store_claim(
self.steps, self.wallet_handle, prover_did,
json.dumps(claim_offer), gvt_claim_def, constant.secret_name,
json.dumps(constant.gvt_claim), -1)
# 10. Get stored claims with proof and
# store result into 'returned_claims'.
self.steps.add_step(
"Get stored claims with proof request "
"and store result into 'returned_claims'")
proof_req = utils.create_proof_req(
"1", "proof_req_1", "1.0",
requested_attrs={'attr1_referent': {'name': 'name'}},
requested_predicates={})
returned_claims = await utils.perform(
self.steps, anoncreds.prover_get_claims_for_proof_req,
self.wallet_handle, proof_req)
returned_claims = json.loads(returned_claims)
# 11. Create proof for proof request and
# store result as "created_proof".
self.steps.add_step("Create proof for proof request and "
"store result as 'created_proof'")
referent = returned_claims["attrs"]["attr1_referent"][0][
constant.claim_uuid_key]
requested_claims_json = json.dumps({
'self_attested_attributes': {},
'requested_attrs': {'attr1_referent': [referent, True]},
'requested_predicates': {}})
schemas_json = json.dumps({referent: constant.gvt_schema})
claims_defs_json = json.dumps({referent: json.loads(gvt_claim_def)})
created_proof = await utils.perform(
self.steps, anoncreds.prover_create_proof, self.wallet_handle,
proof_req, requested_claims_json, schemas_json,
constant.secret_name, claims_defs_json, '{}')
# 12. Verify created proof with incompatible schemas json and
# verify that user cannot verify proof.
self.steps.add_step("Verify created proof with incompatible schemas "
"json and verify that user cannot verify proof")
incompatible_schemas_json = json.dumps({referent: constant.xyz_schema})
err_code = ErrorCode.CommonInvalidStructure
await utils.perform_with_expected_code(
self.steps, anoncreds.verifier_verify_proof, proof_req,
created_proof, incompatible_schemas_json, claims_defs_json, '{}',
expected_code=err_code)
async def test(self):
# 1. Create wallet.
# 2. Open wallet.
self.wallet_handle = await common.create_and_open_wallet_for_steps(
self.steps, self.wallet_name, self.pool_name)
# 3. Create 'issuer_did1'.
# 4. Create 'issuer_did2'.
((issuer_did1, _),
(issuer_did2, _)) = await common.create_and_store_dids_and_verkeys(
self.steps,
self.wallet_handle,
number=2,
step_descriptions=[
"Create 'issuer_did1'", "Create 'issuer_did2'"
])
# 5. Create and store claim definition.
self.steps.add_step("Create and store claim definition")
await utils.perform(self.steps,
anoncreds.issuer_create_and_store_claim_def,
self.wallet_handle, issuer_did1,
json.dumps(constant.gvt_schema),
constant.signature_type, False)
# 6. Store claim offer for 'issuer_did1'.
self.steps.add_step("Store claim offer for 'issuer_did1'")
offer_json1 = utils.create_claim_offer(issuer_did1,
constant.gvt_schema_seq)
await utils.perform(self.steps, anoncreds.prover_store_claim_offer,
self.wallet_handle, json.dumps(offer_json1))
# 7. Store another claim offer for 'issuer_did1'.
self.steps.add_step("Store another claim offer for 'issuer_did1'")
offer_json2 = utils.create_claim_offer(issuer_did1, 2)
await utils.perform(self.steps, anoncreds.prover_store_claim_offer,
self.wallet_handle, json.dumps(offer_json2))
# 8. Store claim offer for 'issuer_did2'.
self.steps.add_step("Store claim offer for 'issuer_did2'")
offer_json3 = utils.create_claim_offer(issuer_did2, 2)
await utils.perform(self.steps, anoncreds.prover_store_claim_offer,
self.wallet_handle, json.dumps(offer_json3))
# 9. Get claim offers and store returned value into 'list_claim_offer'.
self.steps.add_step("Get claim offers and store "
"returned value in to 'list_claim_offer'")
list_claim_offer = await \
utils.perform(self.steps, anoncreds.prover_get_claim_offers,
self.wallet_handle, json.dumps({"schema_seq_no": 2}))
list_claim_offer = json.loads(list_claim_offer)
# 10. Check length of "list_claim_offer".
self.steps.add_step("Check length of 'list_claim_offer'")
error_msg = "Length of 'list_claim_offer' is not equal with 2"
utils.check(self.steps,
error_message=error_msg,
condition=lambda: len(list_claim_offer) == 2)
# 11. Verify that 'offer_json2' and 'offer_json3'
# exist in 'list_claim_offer'.
self.steps.add_step("Verify that 'offer_json2' and 'offer_json3' "
"exist in 'list_claim_offer'")
utils.check(self.steps,
error_message="Cannot get claim offer",
condition=lambda: offer_json2 in list_claim_offer and
offer_json3 in list_claim_offer)
async def test(self):
# 1. Create wallet.
# 2. Open wallet.
self.wallet_handle = await common.create_and_open_wallet_for_steps(
self.steps, self.wallet_name, self.pool_name)
# 3. Create 'issuer_did'.
# 4. Create 'prover_did'.
((issuer_did, _),
(prover_did, _)) = await common.create_and_store_dids_and_verkeys(
self.steps, self.wallet_handle, number=2,
step_descriptions=["Create 'issuer_did'", "Create 'prover_did'"])
# 5. Create master secret.
self.steps.add_step("Create master secret")
await utils.perform(self.steps, anoncreds.prover_create_master_secret,
self.wallet_handle, constant.secret_name)
# 6. Create and store claim definition.
self.steps.add_step("Create and store claim definition")
claim_def = await utils.perform(
self.steps, anoncreds.issuer_create_and_store_claim_def,
self.wallet_handle, issuer_did, json.dumps(constant.gvt_schema),
constant.signature_type, False)
# 7. Create claim request.
# 8. Create claim.
# 9. Store claims into wallet.
claim_offer = utils.create_claim_offer(issuer_did,
constant.gvt_schema_seq)
await common.create_and_store_claim(
self.steps, self.wallet_handle, prover_did,
json.dumps(claim_offer), claim_def, constant.secret_name,
json.dumps(constant.gvt_claim), -1)
# 10. Get stored claims with proof request that
# contains empty requested predicates and empty
# requested attrs and store result into 'returned_claims'.
self.steps.add_step(
"Get stored claims with proof request that contains "
"empty requested predicates and empty requested attrs "
"and store result into 'returned_claims'")
proof_req = utils.create_proof_req("1", "proof_req_1", "1.0",
requested_attrs={},
requested_predicates={})
returned_claims = await utils.perform(
self.steps, anoncreds.prover_get_claims_for_proof_req,
self.wallet_handle, proof_req)
returned_claims = json.loads(returned_claims)
# 11. Check returned_claims['attrs'].
self.steps.add_step("Check returned_claims['attrs']")
err_msg = "returned_claims['attrs'] is not empty"
utils.check(self.steps, error_message=err_msg,
condition=lambda: not returned_claims['attrs'])
# 12. Check returned_claims['predicates'].
self.steps.add_step("Check returned_claims['predicates']")
err_msg = "returned_claims['predicates'] is not empty"
utils.check(self.steps, error_message=err_msg,
condition=lambda: not returned_claims['predicates'])
async def test(self):
# 1. Create wallet.
# 2. Open wallet.
self.wallet_handle = await common.create_and_open_wallet_for_steps(
self.steps, self.wallet_name, self.pool_name)
# 3. Create 'issuer_did'.
# 4. Create 'prover_did'.
((issuer_did, _),
(prover_did, _)) = await common.create_and_store_dids_and_verkeys(
self.steps,
self.wallet_handle,
number=2,
step_descriptions=["Create 'issuer_did'", "Create 'prover_did'"])
# 5. Create master secret.
self.steps.add_step("Create master secret")
await utils.perform(self.steps, anoncreds.prover_create_master_secret,
self.wallet_handle, constant.secret_name)
# 6. Create and store claim definition.
self.steps.add_step("Create and store claim definition")
claim_def = await utils.perform(
self.steps, anoncreds.issuer_create_and_store_claim_def,
self.wallet_handle, issuer_did, json.dumps(constant.gvt_schema),
constant.signature_type, False)
# 7. Create claim request.
# 8. Create claim.
# 9. Store claim into wallet.
claim_offer = utils.create_claim_offer(issuer_did,
constant.gvt_schema_seq)
await common.create_and_store_claim(self.steps,
self.wallet_handle, prover_did,
json.dumps(claim_offer), claim_def,
constant.secret_name,
json.dumps(constant.gvt_claim), -1)
# 10. Get claims store in wallet.
self.steps.add_step("Get claims store in wallet")
lst_claims = await utils.perform(self.steps,
anoncreds.prover_get_claims,
self.wallet_handle, "{}")
lst_claims = json.loads(lst_claims)
# 11. Check returned claims.
self.steps.add_step("Check returned claims")
err_msg = "Returned claims is not a list"
utils.check(self.steps,
error_message=err_msg,
condition=lambda: isinstance(lst_claims, list))
# 12. Check lst_claims[0].
self.steps.add_step("Check lst_claims[0]")
err_msg = "Length of lst_claim[0] is incorrect"
utils.check(self.steps,
error_message=err_msg,
condition=lambda: len(lst_claims[0]) == 4)
# 13. Check lst_claims[0]['claim_uuid'].
# 14. Check lst_claims[0]['attrs'].
# 15. Check lst_claims[0]['issuer_did'].
# 16. Check lst_claims[0]['schema_seq_no'].
utils.check_gotten_claim_is_valid(self.steps, lst_claims[0],
constant.gvt_claim, issuer_did,
constant.gvt_schema_seq)