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,
credentials=self.wallet_credentials)
# 3. Get stored claims with proof request
# 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_attributes={'attr1_referent': {
'name': 'name'
}},
requested_predicates={
'predicate1_referent': {
'name': 'age',
'p_type': '>=',
'p_value': 25
}
})
returned_claims = await utils.perform(
self.steps, anoncreds.prover_get_credentials_for_proof_req,
self.wallet_handle, proof_req)
returned_claims = json.loads(returned_claims)
# 4. Check returned_claims['attrs']['attr1_referent'].
self.steps.add_step("Check returned_claims['attrs']['attr1_referent']")
err_msg = "returned_claims['attrs']['attr1_referent'] is not empty"
utils.check(
self.steps,
error_message=err_msg,
condition=lambda: not returned_claims['attrs']['attr1_referent'])
# 5. Check returned_claims['predicates']['predicate1_referent'].
self.steps.add_step(
"Check returned_claims['predicates']['predicate1_referent']")
err_msg = "returned_claims['predicates']['predicate1_referent'] " \
"is not empty"
utils.check(self.steps,
error_message=err_msg,
condition=lambda: not returned_claims['predicates'][
'predicate1_referent'])
async def test(self):
# 1. Create and open pool.
self.pool_handle = await common.create_and_open_pool_ledger_for_steps(
self.steps, self.pool_name, self.pool_genesis_txn_file)
# 2. Create and open wallet.
self.wallet_handle = await \
common.create_and_open_wallet_for_steps(self.steps,
self.wallet_name,
self.pool_name,
credentials=self.wallet_credentials)
# 3. Create 'issuer_did'.
# 4. Create 'prover_did'.
((issuer_did, issuer_vk),
(prover_did,
prover_vk)) = 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 'submitter_did'.
self.steps.add_step("Create 'submitter_did'")
await utils.perform(self.steps, did.create_and_store_my_did,
self.wallet_handle,
"{\"seed\":\"000000000000000000000000Trustee1\"}")
# 6. Add issuer to the ledger.
self.steps.add_step("Add issuer to the ledger")
req = await ledger.build_nym_request(constant.did_default_trustee,
issuer_did,
issuer_vk,
alias=None,
role='TRUSTEE')
await utils.perform(self.steps, ledger.sign_and_submit_request,
self.pool_handle, self.wallet_handle,
constant.did_default_trustee, req)
# 7. Add prover to the ledger.
self.steps.add_step("Add prover to the ledger")
req = await ledger.build_nym_request(constant.did_default_trustee,
prover_did,
prover_vk,
alias=None,
role='TRUSTEE')
await utils.perform(self.steps, ledger.sign_and_submit_request,
self.pool_handle, self.wallet_handle,
constant.did_default_trustee, req)
# 8. 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)
# 9. Create and store claim definition.
self.steps.add_step("Create and store claim definition")
schema_id, schema_json = await anoncreds.issuer_create_schema(
issuer_did, constant.gvt_schema_name, "1.0",
constant.gvt_schema_attr_names)
schema_request = await ledger.build_schema_request(
issuer_did, schema_json)
schema_result = await ledger.sign_and_submit_request(
self.pool_handle, self.wallet_handle, issuer_did, schema_request)
schema_json = json.loads(schema_json)
schema_json['seqNo'] = json.loads(
schema_result)['result']['txnMetadata']['seqNo']
schema_json = json.dumps(schema_json)
cred_def_id, cred_def_json = await utils.perform(
self.steps, anoncreds.issuer_create_and_store_credential_def,
self.wallet_handle, issuer_did, schema_json, constant.tag,
constant.signature_type, constant.config_false)
# 10. Create claim request.
self.steps.add_step("Create claim request")
cred_offer = await anoncreds.issuer_create_credential_offer(
self.wallet_handle, cred_def_id)
cred_req, cred_req_meta = await utils.perform(
self.steps, anoncreds.prover_create_credential_req,
self.wallet_handle, prover_did, cred_offer, cred_def_json,
constant.secret_name)
# 11. Create claim.
self.steps.add_step("Create claim")
cred_json, cred_revoc_id, revoc_reg_delta_json = await utils.perform(
self.steps, anoncreds.issuer_create_credential,
self.wallet_handle, cred_offer, cred_req,
json.dumps(constant.gvt_schema_attr_values), None, None)
# 12. Store claims into wallet.
self.steps.add_step("Store claims into wallet")
await utils.perform(self.steps, anoncreds.prover_store_credential,
self.wallet_handle, None, cred_req_meta, cred_json,
cred_def_json, None)
# 13. 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'")
predicates_js = {
"predicate1_referent": {
"name": "age",
"p_type": ">=",
"p_value": 25
}
}
proof_req = utils.create_proof_req("1", "proof_req_1", "1.0", {},
predicates_js)
returned_claims = json.loads(await utils.perform(
self.steps, anoncreds.prover_get_credentials_for_proof_req,
self.wallet_handle, proof_req))
# 14. Get claim
self.steps.add_step("Get claims")
lst_claims = json.loads(await
utils.perform(self.steps,
anoncreds.prover_get_credentials,
self.wallet_handle, "{}"))
# 15. 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'])
# 16. Check returned_claims['predicates'].
self.steps.add_step("Check returned_claims['predicates']")
err_msg = "returned_claims['predicates'] is incorrect"
utils.check(self.steps,
error_message=err_msg,
condition=lambda: returned_claims['predicates']
['predicate1_referent'][0]['cred_info'] == lst_claims[0])
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")
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_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 and open pool.
self.pool_handle = await common.create_and_open_pool_ledger_for_steps(
self.steps, self.pool_name, self.pool_genesis_txn_file)
# 2. Create and open wallet.
self.wallet_handle = await \
common.create_and_open_wallet_for_steps(self.steps,
self.wallet_name,
self.pool_name,
credentials=self.wallet_credentials)
# 3. Create 'issuer_did'.
# 4. Create 'prover_did'.
((issuer_did, issuer_vk),
(prover_did, prover_vk)) = 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 'submitter_did'.
self.steps.add_step("Create 'submitter_did'")
await utils.perform(self.steps,
did.create_and_store_my_did,
self.wallet_handle, "{\"seed\":\"000000000000000000000000Trustee1\"}")
# 6. Add issuer to the ledger.
self.steps.add_step("Add issuer to the ledger")
req = await ledger.build_nym_request(
constant.did_default_trustee, issuer_did, issuer_vk, alias=None, role='TRUSTEE')
await utils.perform(self.steps,
ledger.sign_and_submit_request,
self.pool_handle, self.wallet_handle, constant.did_default_trustee, req)
# 7. Add prover to the ledger.
self.steps.add_step("Add prover to the ledger")
req = await ledger.build_nym_request(
constant.did_default_trustee, prover_did, prover_vk, alias=None, role='TRUSTEE')
await utils.perform(self.steps,
ledger.sign_and_submit_request,
self.pool_handle, self.wallet_handle, constant.did_default_trustee, req)
# 8. 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)
# 9. Create and store claim definition.
self.steps.add_step("Create and store claim definition")
schema_id, schema_json = await anoncreds.issuer_create_schema(
issuer_did, constant.gvt_schema_name, "1.0", constant.gvt_schema_attr_names)
schema_request = await ledger.build_schema_request(issuer_did, schema_json)
schema_result = await ledger.sign_and_submit_request(
self.pool_handle, self.wallet_handle, issuer_did, schema_request)
schema_json = json.loads(schema_json)
schema_json['seqNo'] = json.loads(schema_result)['result']['txnMetadata']['seqNo']
schema_json = json.dumps(schema_json)
cred_def_id, cred_def_json = await utils.perform(
self.steps,
anoncreds.issuer_create_and_store_credential_def,
self.wallet_handle, issuer_did,
schema_json, constant.tag,
constant.signature_type, constant.config_false)
# 10. Create claim request.
# 11. Create claim.
# 12. Store claims into wallet.
cred_offer = await anoncreds.issuer_create_credential_offer(self.wallet_handle, cred_def_id)
await common.create_and_store_claim(
self.steps, self.wallet_handle, prover_did,
cred_offer, cred_def_json, constant.secret_name, json.dumps(constant.gvt_schema_attr_values))
# 13. 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_attributes={'attr1_referent': {'name': 'name'}},
requested_predicates={})
returned_claims = await utils.perform(
self.steps, anoncreds.prover_get_credentials_for_proof_req,
self.wallet_handle, proof_req)
returned_claims = json.loads(returned_claims)
# 14. 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]["cred_info"][constant.claim_uuid_key]
requested_claims_json = json.dumps({
'self_attested_attributes': {},
'requested_attributes': {'attr1_referent': {"cred_id": referent, "revealed": True}},
'requested_predicates': {}})
schemas_json = json.dumps({schema_id: json.loads(schema_json)})
claims_defs_json = json.dumps({cred_def_id: json.loads(cred_def_json)})
created_proof = await utils.perform(
self.steps, anoncreds.prover_create_proof, self.wallet_handle,
proof_req, requested_claims_json,
constant.secret_name, schemas_json, claims_defs_json, '{}')
# 15. 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({cred_def_id: {}})
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 and open pool.
self.pool_handle = await common.create_and_open_pool_ledger_for_steps(
self.steps, self.pool_name, self.pool_genesis_txn_file)
# 2. Create and open wallet.
self.wallet_handle = await \
common.create_and_open_wallet_for_steps(self.steps,
self.wallet_name,
self.pool_name,
credentials=self.wallet_credentials)
# 3. Create 'issuer_did'.
# 4. Create 'prover_did'.
((issuer_did, issuer_vk),
(prover_did,
prover_vk)) = 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 'submitter_did'.
self.steps.add_step("Create 'submitter_did'")
await utils.perform(self.steps, did.create_and_store_my_did,
self.wallet_handle,
"{\"seed\":\"000000000000000000000000Trustee1\"}")
# 6. Add issuer to the ledger.
self.steps.add_step("Add issuer to the ledger")
req = await ledger.build_nym_request(constant.did_default_trustee,
issuer_did,
issuer_vk,
alias=None,
role='TRUSTEE')
await utils.perform(self.steps, ledger.sign_and_submit_request,
self.pool_handle, self.wallet_handle,
constant.did_default_trustee, req)
# 7. Add prover to the ledger.
self.steps.add_step("Add prover to the ledger")
req = await ledger.build_nym_request(constant.did_default_trustee,
prover_did,
prover_vk,
alias=None,
role='TRUSTEE')
await utils.perform(self.steps, ledger.sign_and_submit_request,
self.pool_handle, self.wallet_handle,
constant.did_default_trustee, req)
# 8. 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)
# 9. Create and store claim definition.
self.steps.add_step("Create and store claim definition")
schema_id, schema_json = await anoncreds.issuer_create_schema(
issuer_did, constant.gvt_schema_name, "1.0",
constant.gvt_schema_attr_names)
schema_request = await ledger.build_schema_request(
issuer_did, schema_json)
schema_result = await ledger.sign_and_submit_request(
self.pool_handle, self.wallet_handle, issuer_did, schema_request)
schema_json = json.loads(schema_json)
schema_json['seqNo'] = json.loads(
schema_result)['result']['txnMetadata']['seqNo']
schema_json = json.dumps(schema_json)
cred_def_id, cred_def_json = await utils.perform(
self.steps, anoncreds.issuer_create_and_store_credential_def,
self.wallet_handle, issuer_did, schema_json, constant.tag,
constant.signature_type, constant.config_false)
# 10. Create claim request and store result in 'claim_req'.
# 11. Create claim and store result as 'created_claim'.
# 12. Store 'created_claim' into wallet.
cred_offer = await anoncreds.issuer_create_credential_offer(
self.wallet_handle, cred_def_id)
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,
cred_offer,
cred_def_json,
constant.secret_name,
json.dumps(constant.gvt_schema_attr_values),
step_descriptions=description)
# 13. 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_attributes={'attr1_referent': {
'name': 'name'
}},
requested_predicates={
'predicate1_referent': {
'name': 'age',
'p_type': '>=',
'p_value': 25
}
})
returned_claims = await utils.perform(
self.steps, anoncreds.prover_get_credentials_for_proof_req,
self.wallet_handle, proof_req)
returned_claims = json.loads(returned_claims)
# 14. 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]["cred_info"][
constant.claim_uuid_key]
requested_claims_json = json.dumps({
'self_attested_attributes': {},
'requested_attributes': {
'attr1_referent': {
"cred_id": referent,
"revealed": True
}
},
'requested_predicates': {}
})
schemas_json = json.dumps({schema_id: json.loads(schema_json)})
claims_defs_json = json.dumps({cred_def_id: json.loads(cred_def_json)})
created_proof = await utils.perform(self.steps,
anoncreds.prover_create_proof,
self.wallet_handle, proof_req,
requested_claims_json,
constant.secret_name, schemas_json,
claims_defs_json, '{}')
created_proof = json.loads(created_proof)
temp_proofs = created_proof['proof']['proofs']
print(str(temp_proofs))
temp_proof = temp_proofs[0]
temp_identifier = created_proof['identifiers'][0]
temp_pri_proof = temp_proof['primary_proof']
temp_eq_proof = temp_pri_proof['eq_proof']
temp_agg = created_proof['proof']['aggregated_proof']
temp_req_proof = created_proof['requested_proof']
# 15. 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])
# 16. 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()))
# 17. 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'])
# 18. 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_identifier['cred_def_id'] == cred_def_id)
# 19. 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_identifier['schema_id'] == schema_id)
# 20. 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))
# 21. 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 [
0, constant.gvt_claim['name'][1], constant.gvt_claim['name'][0]
] for i in temp.values()))
# 22. 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'])
# 23. 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'])
# 24. 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 and store result in 'claim_req'.
# 8. Create claim and store result as 'created_claim'.
# 9. Store 'created_claim' into wallet.
claim_offer = await anoncreds.issuer_create_claim_offer(
self.wallet_handle, json.dumps(constant.gvt_schema), issuer_did,
prover_did)
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,
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': '>=',
'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['proof']['proofs']
print(str(temp_proofs.keys()))
temp_proof = temp_proofs[referent]
temp_identifier = created_proof['identifiers'][referent]
temp_pri_proof = temp_proof['primary_proof']
temp_eq_proof = temp_pri_proof['eq_proof']
temp_agg = created_proof['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_identifier['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_identifier['schema_key']['name'] ==
constant.gvt_schema['data']['name'])
# 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'])
