async def pool_configuration(IP):
pool_name = input('Pool name?:').strip().lower()
file_name = pool_name + '.pickle'
try:
with open(file_name, 'rb') as f:
pool_ = pickle.load(f)
except (FileNotFoundError) as e:
pool_ = {'name': pool_name}
genesis_file_path = get_pool_genesis_txn_path(pool_name, IP)
pool_['config'] = json.dumps({'genesis_txn': str(genesis_file_path)})
# Set pool PROTOCAL VERSION:
await pool.set_protocol_version(PROTOCOL_VERSION)
genesis_file_path = get_pool_genesis_txn_path(pool_['name'], IP)
# try:
# await pool.close_pool_ledger(pool_['handle'])
# except IndyError as ex:
# if ex.error_code == ErrorCode.PoolLedgerInvalidPoolHandle:
# pass
# try:
# await pool.delete_pool_ledger_config('pool')
# except IndyError as ex:
# if ex.error_code == ErrorCode.CommonIOError:
# pass
try:
await pool.create_pool_ledger_config(config_name=pool_['name'],
config=pool_['config'])
print_log('\n Setting up pool configuration.\n')
except IndyError as ex:
if ex.error_code == ErrorCode.PoolLedgerConfigAlreadyExistsError:
pass
try:
pool_['handle'] = await pool.open_pool_ledger(pool_['name'], None)
print_log('\n Open ledger and get handle\n')
except IndyError as ex:
if ex.error_code == ErrorCode.PoolLedgerInvalidPoolHandle:
pass
print(genesis_file_path)
print('Pool handle:', pool_['handle'])
with open(file_name, 'wb') as f:
pickle.dump(pool_, f)
return pool_
async def pool_configuration(pool_name):
pool_ = {'name': pool_name}
genesis_file_path = get_pool_genesis_txn_path(pool_name)
pool_['config'] = json.dumps({'genesis_txn': str(genesis_file_path)})
# Set pool PROTOCAL VERSION:
await pool.set_protocol_version(PROTOCOL_VERSION)
# Check if the pool configuration is already open:
try:
await pool.delete_pool_ledger_config(pool_['name'])
except IndyError as ex:
if ex.error_code == ErrorCode.CommonIOError:
pass
try:
await pool.create_pool_ledger_config(config_name=pool_['name'],
config=pool_['config'])
except IndyError as ex:
if ex.error_code == ErrorCode.PoolLedgerConfigAlreadyExistsError:
pass
print(genesis_file_path)
print_log('\n2. Open ledger and get handle\n')
pool_['handle'] = await pool.open_pool_ledger(pool_['name'], None)
return (pool_)
async def open_pool(target_pool):
target_pool['genesis_txn_path'] = get_pool_genesis_txn_path(
target_pool['pool_name'])
target_pool['pool_config'] = json.dumps(
{"genesis_txn": str(target_pool['genesis_txn_path'])})
await pool.create_pool_ledger_config(target_pool['pool_name'],
target_pool['pool_config'])
target_pool['pool'] = await pool.open_pool_ledger(target_pool['pool_name'],
None)
async def demo():
logger.info("Ledger sample -> started")
pool_name = 'pool1'
wallet_config = json.dumps({"id": "wallet1"})
seed_trustee1 = "000000000000000000000000Trustee1"
pool_genesis_txn_path = get_pool_genesis_txn_path(pool_name)
# Set protocol version 2 to work with Indy Node 1.4
await pool.set_protocol_version(PROTOCOL_VERSION)
# 1. Create ledger config from genesis txn file
pool_config = json.dumps({"genesis_txn": str(pool_genesis_txn_path)})
await pool.create_pool_ledger_config(pool_name, pool_config)
# 2. Open pool ledger
pool_handle = await pool.open_pool_ledger(pool_name, None)
# 3. Create Trustee Wallet and Get Wallet Handle
credentials = json.dumps({"key": "wallet_key"})
await wallet.create_wallet(wallet_config, credentials)
wallet_handle = await wallet.open_wallet(wallet_config, credentials)
# 4. Create New DID
(new_did,
new_verkey) = await did.create_and_store_my_did(wallet_handle, "{}")
# 5. Create DID from Trustee1 seed
(trustee_did, _) = await did.create_and_store_my_did(
wallet_handle, json.dumps({"seed": seed_trustee1}))
# 6. Prepare and send NYM transaction
nym_txn_req = await ledger.build_nym_request(trustee_did, new_did,
new_verkey, None, None)
await ledger.sign_and_submit_request(pool_handle, wallet_handle,
trustee_did, nym_txn_req)
# 7. Prepare and send GET_NYM request
get_nym_txn_req = await ledger.build_get_nym_request(trustee_did, new_did)
get_nym_txn_resp = await ledger.submit_request(pool_handle,
get_nym_txn_req)
get_nym_txn_resp = json.loads(get_nym_txn_resp)
assert get_nym_txn_resp['result']['dest'] == new_did
# 8. Close wallet and pool
await wallet.close_wallet(wallet_handle)
await pool.close_pool_ledger(pool_handle)
# 10. Delete wallets
await wallet.delete_wallet(wallet_config, credentials)
# 11. Delete pool ledger config
await pool.delete_pool_ledger_config(pool_name)
logger.info("Ledger sample -> completed")
async def run():
print("\n\n")
pool_name = 'pool1'
pool_genesis_txn_path = get_pool_genesis_txn_path(pool_name)
pool_config = json.dumps({"genesis_txn": str(pool_genesis_txn_path)})
# Set protocol version 2 NSUT work with Indy Node 1.4
await pool.set_protocol_version(PROTOCOL_VERSION)
try:
await pool.create_pool_ledger_config(pool_name, pool_config)
except IndyError as ex:
if ex.error_code == ErrorCode.PoolLedgerConfigAlreadyExistsError:
pass
pool_handle = await pool.open_pool_ledger(pool_name, None)
steward_wallet_config = json.dumps({"id": "sovrin_steward_wallet"})
steward_wallet_credentials = json.dumps({"key": "steward_wallet_key"})
steward_wallet = await wallet.open_wallet(steward_wallet_config,
steward_wallet_credentials)
fname = "stewardDID.txt"
with open(fname, 'r') as f:
steward_did = f.readline()
logger.info(
" \"Steward\" -> Creates and stores \"Steward-NSUT\" DID in the wallet\n"
)
(steward_NSUT_did, steward_NSUT_key) = await did.create_and_store_my_did(
steward_wallet, "{}")
logger.info(
" \"Steward\" -> Sends Nym(DID, verification key pair) to the Ledger for \"Steward-NSUT\" DID\n"
)
await send_nym(pool_handle, steward_wallet, steward_did, steward_NSUT_did,
steward_NSUT_key, None)
logger.info(
" \"Steward\" -> Sends connection request to NSUT with \"Steward-NSUT\" DID and nonce\n\n"
)
connection_request = {'did': steward_NSUT_did, 'nonce': 123456789}
fname = "connectionReqStewardNSUT.txt"
with open(fname, 'w') as f:
f.write(str(connection_request))
fname = "stewardNSUTDIDPair.txt"
with open(fname, 'w') as f:
f.write(steward_NSUT_did)
async def run():
bashCommand = "bash refresh.sh"
process = subprocess.Popen(bashCommand.split(), stdout=subprocess.PIPE)
output, error = process.communicate()
#----- Enter Code Here -----#
pool_name = 'pool1'
pool_genesis_txn_path = get_pool_genesis_txn_path(pool_name)
pool_config = json.dumps({"genesis_txn": str(pool_genesis_txn_path)})
await pool.set_protocol_version(PROTOCOL_VERSION)
try:
await pool.create_pool_ledger_config(pool_name, pool_config)
except IndyError as ex:
if ex.error_code == ErrorCode.PoolLedgerConfigAlreadyExistsError:
pass
pool_handle = await pool.open_pool_ledger(pool_name, None)
async def run():
print("\n")
logger.info(" Getting Started\n")
logger.info(
" \"Sovrin Steward\" -> Connecting to the started indy pool \n")
pool_name = 'pool1'
logger.info(" Open Pool Ledger: {}".format(pool_name))
pool_genesis_txn_path = get_pool_genesis_txn_path(pool_name)
pool_config = json.dumps({"genesis_txn": str(pool_genesis_txn_path)})
# Set protocol version 2 to work with Indy Node 1.4
await pool.set_protocol_version(PROTOCOL_VERSION)
try:
await pool.create_pool_ledger_config(pool_name, pool_config)
except IndyError as ex:
if ex.error_code == ErrorCode.PoolLedgerConfigAlreadyExistsError:
pass
pool_handle = await pool.open_pool_ledger(pool_name, None)
logger.info(
" \"Sovrin Steward\" -> Creating wallet to store its credentials\n")
steward_wallet_config = json.dumps({"id": "sovrin_steward_wallet"})
steward_wallet_credentials = json.dumps({"key": "steward_wallet_key"})
try:
await wallet.create_wallet(steward_wallet_config,
steward_wallet_credentials)
except IndyError as ex:
if ex.error_code == ErrorCode.WalletAlreadyExistsError:
pass
logger.info(" \"Sovrin Steward\" -> Opening Steward wallet \n")
steward_wallet = await wallet.open_wallet(steward_wallet_config,
steward_wallet_credentials)
logger.info(
" \"Sovrin Steward\" -> Creates and stores the DID in the wallet using the intital seed values\n\n"
)
steward_did_info = {'seed': '000000000000000000000000Steward1'}
(steward_did, steward_key) = await did.create_and_store_my_did(
steward_wallet, json.dumps(steward_did_info))
fname = "stewardDID.txt"
with open(fname, 'w') as f:
f.write(steward_did)
async def run():
logger.info("Getting started -> started")
# Pool setup
pool_name = 'pool_test'
logger.info("Open Pool Ledger: {}".format(pool_name))
pool_genesis_txn_path = get_pool_genesis_txn_path(pool_name)
pool_config = json.dumps({"genesis_txn": str(pool_genesis_txn_path)})
try:
await pool.create_pool_ledger_config(pool_name, pool_config)
except IndyError as ex:
if ex.error_code == ErrorCode.PoolLedgerConfigAlreadyExistsError:
pass
pool_handle = await pool.open_pool_ledger(pool_name, None)
logger.info("==============================")
logger.info("=== Getting Trust Anchor credentials for Faber, Acme, Thrift and Government ==")
logger.info("------------------------------")
#create generic steward
logger.info("\"Sovrin Steward\" -> Create wallet")
steward_wallet_name = 'sovrin_steward_wallet'
try:
await wallet.create_wallet(pool_name, steward_wallet_name, None, None,
None)
except IndyError as ex:
if ex.error_code == ErrorCode.WalletAlreadyExistsError:
pass
steward_wallet = await wallet.open_wallet(steward_wallet_name, None, None)
logger.info("\"Sovrin Steward\" -> Create and store in Wallet DID from seed")
steward_did_info = {'seed': '000000000000000000000000Steward1'}
(steward_did, steward_key) = await did.create_and_store_my_did(steward_wallet, json.dumps(steward_did_info))
# Create and onbording generic government from dataset
logger.info("==============================")
logger.info("== Getting Trust Anchor credentials - Government Onboarding ==")
logger.info("------------------------------")
gen_gov_name = dforg.ix[0, 'Name']
;
async def run():
print('\n')
logger.info(
" \"Sovrin Steward\" -> Connecting to the started indy pool \n")
pool_name = 'pool1'
logger.info(" Open Pool Ledger: {}".format(pool_name))
pool_genesis_txn_path = get_pool_genesis_txn_path(pool_name)
pool_config = json.dumps({"genesis_txn": str(pool_genesis_txn_path)})
# Set protocol version 2 to work with Indy Node 1.4
await pool.set_protocol_version(PROTOCOL_VERSION)
try:
await pool.create_pool_ledger_config(pool_name, pool_config)
except IndyError as ex:
if ex.error_code == ErrorCode.PoolLedgerConfigAlreadyExistsError:
pass
pool_handle = await pool.open_pool_ledger(pool_name, None)
logger.info(
" \"Sovrin Steward\" -> Creating wallet to store its credentials\n")
steward_wallet_config = json.dumps({"id": "sovrin_steward_wallet"})
steward_wallet_credentials = json.dumps({"key": "steward_wallet_key"})
try:
await wallet.create_wallet(steward_wallet_config,
steward_wallet_credentials)
except IndyError as ex:
if ex.error_code == ErrorCode.WalletAlreadyExistsError:
pass
logger.info(" \"Sovrin Steward\" -> Opening Steward wallet \n")
steward_wallet = await wallet.open_wallet(steward_wallet_config,
steward_wallet_credentials)
logger.info(" \"Sovrin Steward\" -> Deleting Steward wallet \n")
await wallet.close_wallet(steward_wallet)
await wallet.delete_wallet(steward_wallet_config,
steward_wallet_credentials)
async def demo():
logger.info("Transaction Author Agreement sample -> started")
# Set protocol version 2 to work with Indy Node 1.4
await pool.set_protocol_version(PROTOCOL_VERSION)
# Trustee preparation
trustee = {
'seed': '000000000000000000000000Trustee1',
'wallet_config': json.dumps({'id': 'trustee_wallet'}),
'wallet_credentials': json.dumps({'key': 'trustee_wallet_key'}),
'pool_name': 'trustee_pool',
}
# Trustee opens pool ledger
trustee['genesis_txn_path'] = get_pool_genesis_txn_path(trustee['pool_name'])
trustee['pool_config'] = json.dumps({"genesis_txn": str(trustee['genesis_txn_path'])})
await pool.create_pool_ledger_config(trustee['pool_name'], trustee['pool_config'])
trustee['pool'] = await pool.open_pool_ledger(trustee['pool_name'], None)
# Trustee creates and open Wallet
await wallet.create_wallet(trustee['wallet_config'], trustee['wallet_credentials'])
trustee['wallet'] = await wallet.open_wallet(trustee['wallet_config'], trustee['wallet_credentials'])
# Trustee creates DID (predefined on the ledger)
(trustee['did'], trustee['verkey']) = \
await did.create_and_store_my_did(trustee['wallet'], json.dumps({"seed": trustee['seed']}))
# Trustee set up Transaction Author Agreement on the ledger
trustee['txn_agreement'] = {
'text': 'Indy transaction author agreement text',
'version': str(randint(0, 1000)),
}
trustee['acceptance_mechanisms'] = {
'aml': {
'Demo acceptance': 'Demo acceptance mechanism'
},
'version': str(randint(0, 1000)),
'context': 'Some common context for acceptance mechanisms'
}
# Trustee sends Acceptance Mechanisms to the ledger
aml_req = await ledger.build_acceptance_mechanisms_request(trustee['did'],
json.dumps(trustee['acceptance_mechanisms']['aml']),
trustee['acceptance_mechanisms']['version'],
trustee['acceptance_mechanisms']['context'])
await ledger.sign_and_submit_request(trustee['pool'], trustee['wallet'], trustee['did'], aml_req)
# Trustee sends Transaction Agreement to the ledger
txn_agreement_req = \
await ledger.build_txn_author_agreement_request(trustee['did'],
trustee['txn_agreement']['text'],
trustee['txn_agreement']['version'])
await ledger.sign_and_submit_request(trustee['pool'], trustee['wallet'], trustee['did'], txn_agreement_req)
# User initialization
user = {
'wallet_config': json.dumps({'id': 'user_wallet'}),
'wallet_credentials': json.dumps({'key': 'user_wallet_key'}),
'pool_name': 'user_pool'
}
# User opens pool ledger
user['genesis_txn_path'] = get_pool_genesis_txn_path(user['pool_name'])
user['pool_config'] = json.dumps({"genesis_txn": str(user['genesis_txn_path'])})
await pool.create_pool_ledger_config(user['pool_name'], user['pool_config'])
user['pool'] = await pool.open_pool_ledger(user['pool_name'], None)
# User opens pool ledger
await wallet.create_wallet(user['wallet_config'], user['wallet_credentials'])
user['wallet'] = await wallet.open_wallet(user['wallet_config'], user['wallet_credentials'])
# User creates DID and tells it Trustee
(user['did'], user['verkey']) = await did.create_and_store_my_did(user['wallet'], "{}")
trustee['user_did'] = user['did']
trustee['user_verkey'] = user['verkey']
# Trustee sends NYM transaction for user
nym_req = await ledger.build_nym_request(trustee['did'], trustee['user_did'], trustee['user_verkey'], None, None)
# Append Transaction Agreement to request
nym_req = \
await ledger.append_txn_author_agreement_acceptance_to_request(nym_req,
trustee['txn_agreement']['text'],
trustee['txn_agreement']['version'],
None,
next(iter(
trustee['acceptance_mechanisms']['aml'])),
int(time.time()))
# Sends request
await ledger.sign_and_submit_request(trustee['pool'], trustee['wallet'], trustee['did'], nym_req)
# User sends ATTRIB transaction to the Ledger
# User gets Transaction Agreement from the ledger
get_txn_author_agreement_req = await ledger.build_get_txn_author_agreement_request(user['did'], None)
get_txn_author_agreement_resp = json.loads(await ledger.submit_request(user['pool'], get_txn_author_agreement_req))
user['txn_agreement'] = get_txn_author_agreement_resp['result']['data']
# User gets Acceptance Mechanisms from the ledger
get_acc_mech_req = await ledger.build_get_acceptance_mechanisms_request(user['did'], None, None)
get_acc_mech_resp = json.loads(await ledger.submit_request(user['pool'], get_acc_mech_req))
user['acceptance_mechanisms'] = get_acc_mech_resp['result']['data']
# User sends ATTRIB transaction to Ledger
attr_req = \
await ledger.build_attrib_request(user['did'], user['did'], None, '{"endpoint":{"ha":"127.0.0.1:5555"}}', None)
# Appends Transaction Agreement to request
attr_req = \
await ledger.append_txn_author_agreement_acceptance_to_request(attr_req, user['txn_agreement']['text'],
user['txn_agreement']['version'],
None,
next(iter(user['acceptance_mechanisms']['aml'])),
int(time.time()))
# Sends to request
resp = json.loads(await ledger.sign_and_submit_request(user['pool'], user['wallet'], user['did'], attr_req))
assert resp['op'] == 'REPLY'
# Trustee reset Transaction Agreement
txn_agreement_req = \
await ledger.build_txn_author_agreement_request(trustee['did'], '', str(randint(0, 1000)))
await ledger.sign_and_submit_request(trustee['pool'], trustee['wallet'], trustee['did'], txn_agreement_req)
# Trustee closes and deletes Wallet
await wallet.close_wallet(trustee['wallet'])
await wallet.delete_wallet(trustee['wallet_config'], trustee['wallet_credentials'])
# User closes and deletes Wallet
await wallet.close_wallet(user['wallet'])
await wallet.delete_wallet(user['wallet_config'], user['wallet_credentials'])
# Trustee and USer closes and deletes Wallet
await pool.close_pool_ledger(trustee['pool'])
await pool.close_pool_ledger(user['pool'])
# Delete pool ledger config
await pool.delete_pool_ledger_config(trustee['pool_name'])
await pool.delete_pool_ledger_config(user['pool_name'])
logger.info("Transaction Author Agreement sample -> completed")
async def run():
logger.info("Getting started -> started")
pool_ = {'name': 'pool1'}
logger.info("Open Pool Ledger: {}".format(pool_['name']))
pool_['genesis_txn_path'] = get_pool_genesis_txn_path(pool_['name'])
pool_['config'] = json.dumps(
{"genesis_txn": str(pool_['genesis_txn_path'])})
# Set protocol version 2 to work with Indy Node 1.4
await pool.set_protocol_version(PROTOCOL_VERSION)
try:
await pool.create_pool_ledger_config(pool_['name'], pool_['config'])
except IndyError as ex:
if ex.error_code == ErrorCode.PoolLedgerConfigAlreadyExistsError:
pass
pool_['handle'] = await pool.open_pool_ledger(pool_['name'], None)
logger.info("==============================")
logger.info(
"=== Getting Trust Anchor credentials for Faber, Acme, Thrift and Government =="
)
logger.info("------------------------------")
logger.info("\"Sovrin Steward\" -> Create wallet")
steward = {
'name': "Sovrin Steward",
'wallet_config': json.dumps({'id': 'sovrin_steward_wallet'}),
'wallet_credentials': json.dumps({'key': 'steward_wallet_key'}),
'pool': pool_['handle'],
'seed': '000000000000000000000000Steward1'
}
try:
await wallet.create_wallet(steward['wallet_config'],
steward['wallet_credentials'])
except IndyError as ex:
if ex.error_code == ErrorCode.WalletAlreadyExistsError:
pass
steward['wallet'] = await wallet.open_wallet(steward['wallet_config'],
steward['wallet_credentials'])
logger.info(
"\"Sovrin Steward\" -> Create and store in Wallet DID from seed")
steward['did_info'] = json.dumps({'seed': steward['seed']})
steward['did'], steward['key'] = await did.create_and_store_my_did(
steward['wallet'], steward['did_info'])
logger.info("==============================")
logger.info(
"== Getting Trust Anchor credentials - Government Onboarding ==")
logger.info("------------------------------")
government = {
'name': 'Government',
'wallet_config': json.dumps({'id': 'government_wallet'}),
'wallet_credentials': json.dumps({'key': 'government_wallet_key'}),
'pool': pool_['handle'],
'role': 'TRUST_ANCHOR'
}
steward['did_for_government'], steward['key_for_government'], government['did_for_steward'], \
government['key_for_steward'], _ = await onboarding(steward, government)
logger.info("==============================")
logger.info(
"== Getting Trust Anchor credentials - Government getting Verinym ==")
logger.info("------------------------------")
government['did'] = await get_verinym(steward,
steward['did_for_government'],
steward['key_for_government'],
government,
government['did_for_steward'],
government['key_for_steward'])
logger.info("==============================")
logger.info("== Getting Trust Anchor credentials - Faber Onboarding ==")
logger.info("------------------------------")
faber = {
'name': 'Faber',
'wallet_config': json.dumps({'id': 'faber_wallet'}),
'wallet_credentials': json.dumps({'key': 'faber_wallet_key'}),
'pool': pool_['handle'],
'role': 'TRUST_ANCHOR'
}
steward['did_for_faber'], steward['key_for_faber'], faber['did_for_steward'], faber['key_for_steward'], _ = \
await onboarding(steward, faber)
logger.info("==============================")
logger.info(
"== Getting Trust Anchor credentials - Faber getting Verinym ==")
logger.info("------------------------------")
faber['did'] = \
await get_verinym(steward, steward['did_for_faber'], steward['key_for_faber'],
faber, faber['did_for_steward'], faber['key_for_steward'])
logger.info("==============================")
logger.info("== Getting Trust Anchor credentials - Acme Onboarding ==")
logger.info("------------------------------")
acme = {
'name': 'Acme',
'wallet_config': json.dumps({'id': 'acme_wallet'}),
'wallet_credentials': json.dumps({'key': 'acme_wallet_key'}),
'pool': pool_['handle'],
'role': 'TRUST_ANCHOR'
}
steward['did_for_acme'], steward['key_for_acme'], acme['did_for_steward'], acme['key_for_steward'], _ = \
await onboarding(steward, acme)
logger.info("==============================")
logger.info(
"== Getting Trust Anchor credentials - Acme getting Verinym ==")
logger.info("------------------------------")
acme['did'] = await get_verinym(steward, steward['did_for_acme'],
steward['key_for_acme'], acme,
acme['did_for_steward'],
acme['key_for_steward'])
logger.info("==============================")
logger.info("=== Credential Schemas Setup ==")
logger.info("------------------------------")
logger.info("\"Government\" -> Create \"Job-Certificate\" Schema")
job_certificate = {
'name':
'Job-Certificate',
'version':
'0.2',
'attributes':
['first_name', 'last_name', 'salary', 'employee_status', 'experience']
}
(government['job_certificate_schema_id'], government['job_certificate_schema']) = \
await anoncreds.issuer_create_schema(government['did'], job_certificate['name'], job_certificate['version'],
json.dumps(job_certificate['attributes']))
job_certificate_schema_id = government['job_certificate_schema_id']
logger.info("\"Government\" -> Send \"Job-Certificate\" Schema to Ledger")
await send_schema(government['pool'], government['wallet'],
government['did'], government['job_certificate_schema'])
logger.info("\"Government\" -> Create \"Transcript\" Schema")
transcript = {
'name':
'Transcript',
'version':
'1.2',
'attributes': [
'first_name', 'last_name', 'degree', 'status', 'year', 'average',
'ssn'
]
}
(government['transcript_schema_id'], government['transcript_schema']) = \
await anoncreds.issuer_create_schema(government['did'], transcript['name'], transcript['version'],
json.dumps(transcript['attributes']))
transcript_schema_id = government['transcript_schema_id']
logger.info("\"Government\" -> Send \"Transcript\" Schema to Ledger")
await send_schema(government['pool'], government['wallet'],
government['did'], government['transcript_schema'])
time.sleep(1) # sleep 1 second before getting schema
logger.info("==============================")
logger.info("=== Faber Credential Definition Setup ==")
logger.info("------------------------------")
logger.info("\"Faber\" -> Get \"Transcript\" Schema from Ledger")
(faber['transcript_schema_id'], faber['transcript_schema']) = \
await get_schema(faber['pool'], faber['did'], transcript_schema_id)
logger.info(
"\"Faber\" -> Create and store in Wallet \"Faber Transcript\" Credential Definition"
)
transcript_cred_def = {
'tag': 'TAG1',
'type': 'CL',
'config': {
"support_revocation": True
}
}
(faber['transcript_cred_def_id'], faber['transcript_cred_def']) = \
await anoncreds.issuer_create_and_store_credential_def(faber['wallet'], faber['did'],
faber['transcript_schema'], transcript_cred_def['tag'],
transcript_cred_def['type'],
json.dumps(transcript_cred_def['config']))
logger.info(
"\"Faber\" -> Send \"Faber Transcript\" Credential Definition to Ledger"
)
await send_cred_def(faber['pool'], faber['wallet'], faber['did'],
faber['transcript_cred_def'])
logger.info("\"Faber\" -> Creates Revocation Registry")
faber['tails_writer_config'] = json.dumps({
'base_dir': "/tmp/indy_faber_tails",
'uri_pattern': ''
})
tails_writer = await blob_storage.open_writer('default',
faber['tails_writer_config'])
(faber['revoc_reg_id'], faber['revoc_reg_def'], faber['revoc_reg_entry']) = \
await anoncreds.issuer_create_and_store_revoc_reg(
faber['wallet'], faber['did'], 'CL_ACCUM',
'TAG1',
faber['transcript_cred_def_id'],
json.dumps({'max_cred_num': 5,
'issuance_type': 'ISSUANCE_ON_DEMAND'}),
tails_writer)
logger.info("\"Faber\" -> Post Revocation Registry Definition to Ledger")
faber['revoc_reg_def_request'] = await ledger.build_revoc_reg_def_request(
faber['did'], faber['revoc_reg_def'])
await ledger.sign_and_submit_request(faber['pool'], faber['wallet'],
faber['did'],
faber['revoc_reg_def_request'])
logger.info("\"Faber\" -> Post Revocation Registry Entry to Ledger")
faber['revoc_reg_entry_request'] = \
await ledger.build_revoc_reg_entry_request(faber['did'], faber['revoc_reg_id'], 'CL_ACCUM',
faber['revoc_reg_entry'])
await ledger.sign_and_submit_request(faber['pool'], faber['wallet'],
faber['did'],
faber['revoc_reg_entry_request'])
logger.info("==============================")
logger.info("=== Acme Credential Definition Setup ==")
logger.info("------------------------------")
logger.info("\"Acme\" -> Get from Ledger \"Job-Certificate\" Schema")
(acme['job_certificate_schema_id'], acme['job_certificate_schema']) = \
await get_schema(acme['pool'], acme['did'], job_certificate_schema_id)
logger.info(
"\"Acme\" -> Create and store in Wallet \"Acme Job-Certificate\" Credential Definition"
)
job_certificate_cred_def = {
'tag': 'TAG1',
'type': 'CL',
'config': {
"support_revocation": True
}
}
(acme['job_certificate_cred_def_id'], acme['job_certificate_cred_def']) = \
await anoncreds.issuer_create_and_store_credential_def(acme['wallet'], acme['did'],
acme['job_certificate_schema'],
job_certificate_cred_def['tag'],
job_certificate_cred_def['type'],
json.dumps(job_certificate_cred_def['config']))
logger.info(
"\"Acme\" -> Send \"Acme Job-Certificate\" Credential Definition to Ledger"
)
await send_cred_def(acme['pool'], acme['wallet'], acme['did'],
acme['job_certificate_cred_def'])
logger.info("\"Acme\" -> Creates Revocation Registry")
acme['tails_writer_config'] = json.dumps({
'base_dir': "/tmp/indy_acme_tails",
'uri_pattern': ''
})
tails_writer = await blob_storage.open_writer('default',
acme['tails_writer_config'])
(acme['revoc_reg_id'], acme['revoc_reg_def'], acme['revoc_reg_entry']) = \
await anoncreds.issuer_create_and_store_revoc_reg(acme['wallet'], acme['did'], 'CL_ACCUM', 'TAG1',
acme['job_certificate_cred_def_id'],
json.dumps({'max_cred_num': 5,
'issuance_type': 'ISSUANCE_ON_DEMAND'}),
tails_writer)
logger.info("\"Acme\" -> Post Revocation Registry Definition to Ledger")
acme['revoc_reg_def_request'] = await ledger.build_revoc_reg_def_request(
acme['did'], acme['revoc_reg_def'])
await ledger.sign_and_submit_request(acme['pool'], acme['wallet'],
acme['did'],
acme['revoc_reg_def_request'])
logger.info("\"Acme\" -> Post Revocation Registry Entry to Ledger")
acme['revoc_reg_entry_request'] = \
await ledger.build_revoc_reg_entry_request(acme['did'], acme['revoc_reg_id'], 'CL_ACCUM',
acme['revoc_reg_entry'])
await ledger.sign_and_submit_request(acme['pool'], acme['wallet'],
acme['did'],
acme['revoc_reg_entry_request'])
logger.info("==============================")
logger.info("=== Getting Transcript with Faber ==")
logger.info("==============================")
logger.info("== Getting Transcript with Faber - Onboarding ==")
logger.info("------------------------------")
alice = {
'name': 'Alice',
'wallet_config': json.dumps({'id': 'alice_wallet'}),
'wallet_credentials': json.dumps({'key': 'alice_wallet_key'}),
'pool': pool_['handle'],
}
faber['did_for_alice'], faber['key_for_alice'], alice['did_for_faber'], alice['key_for_faber'], \
faber['alice_connection_response'] = await onboarding(faber, alice)
logger.info(
"\"Alice\" -> Create and store \"Alice\" Master Secret in Wallet")
alice['master_secret_id'] = await anoncreds.prover_create_master_secret(
alice['wallet'], None)
for i in range(2): # Gets the transcript from Faber twice
logger.info("==============================")
logger.info(
"== Getting Transcript with Faber - Getting Transcript Credential =="
)
logger.info("------------------------------")
logger.info(
"\"Faber\" -> Create \"Transcript\" Credential Offer for Alice")
faber_transcript_cred_offer = \
await anoncreds.issuer_create_credential_offer(faber['wallet'], faber['transcript_cred_def_id'])
logger.info("\"Faber\" -> Get key for Alice did")
if 'alice_key_for_faber' not in faber:
faber['alice_key_for_faber'] = \
await did.key_for_did(faber['pool'], faber['wallet'], faber['alice_connection_response']['did'])
logger.info(
"\"Faber\" -> Authcrypt \"Transcript\" Credential Offer for Alice")
faber_authcrypted_transcript_cred_offer = \
await crypto.auth_crypt(faber['wallet'], faber['key_for_alice'], faber['alice_key_for_faber'],
faber_transcript_cred_offer.encode('utf-8'))
logger.info(
"\"Faber\" -> Send authcrypted \"Transcript\" Credential Offer to Alice"
)
alice_authcrypted_transcript_cred_offer = faber_authcrypted_transcript_cred_offer
logger.info(
"\"Alice\" -> Authdecrypted \"Transcript\" Credential Offer from Faber"
)
alice['faber_key_for_alice'], alice_transcript_cred_offer, transcript_cred_offer = \
await auth_decrypt(alice['wallet'], alice['key_for_faber'], alice_authcrypted_transcript_cred_offer)
logger.info(
"\"Alice\" -> Get \"Faber Transcript\" Credential Definition from Ledger"
)
(alice['faber_transcript_cred_def_id'], alice['faber_transcript_cred_def']) = \
await get_cred_def(alice['pool'], alice['did_for_faber'], transcript_cred_offer['cred_def_id'])
logger.info(
"\"Alice\" -> Create \"Transcript\" Credential Request for Faber")
(alice_transcript_cred_request, alice_transcript_cred_request_metadata) = \
await anoncreds.prover_create_credential_req(alice['wallet'], alice['did_for_faber'],
alice_transcript_cred_offer,
alice['faber_transcript_cred_def'], alice['master_secret_id'])
logger.info(
"\"Alice\" -> Authcrypt \"Transcript\" Credential Request for Faber"
)
alice_authcrypted_transcript_cred_request = \
await crypto.auth_crypt(alice['wallet'], alice['key_for_faber'], alice['faber_key_for_alice'],
alice_transcript_cred_request.encode('utf-8'))
logger.info(
"\"Alice\" -> Send authcrypted \"Transcript\" Credential Request to Faber"
)
faber_authcrypted_transcript_cred_request = \
alice_authcrypted_transcript_cred_request
logger.info(
"\"Faber\" -> Authdecrypt \"Transcript\" Credential Request from Alice"
)
faber['alice_key_for_faber'], faber_transcript_cred_request, _ = \
await auth_decrypt(faber['wallet'], faber['key_for_alice'], faber_authcrypted_transcript_cred_request)
logger.info("\"Faber\" -> Create \"Transcript\" Credential for Alice")
faber['alice_transcript_cred_values'] = json.dumps({
"first_name": {
"raw": "Alice",
"encoded": "1139481716457488690172217916278103335"
},
"last_name": {
"raw": "Garcia",
"encoded": "5321642780241790123587902456789123452"
},
"degree": {
"raw": "Bachelor of Science, Marketing",
"encoded": "12434523576212321"
},
"status": {
"raw": "graduated",
"encoded": "2213454313412354"
},
"ssn": {
"raw": "123-45-6789",
"encoded": "3124141231422543541"
},
"year": {
"raw": "2015",
"encoded": "2015"
},
"average": {
"raw": "5",
"encoded": "5"
}
})
faber[
'blob_storage_reader_cfg_handle'] = await blob_storage.open_reader(
'default', faber['tails_writer_config'])
faber_transcript_cred, faber_transcript_cred_rev_id, faber_alice_cert_rev_reg_delta = \
await anoncreds.issuer_create_credential(faber['wallet'], faber_transcript_cred_offer,
faber_transcript_cred_request,
faber['alice_transcript_cred_values'],
faber['revoc_reg_id'],
faber['blob_storage_reader_cfg_handle'])
logger.info("\"Faber\" -> Post Revocation Registry Delta to Ledger")
faber['revoc_reg_entry_req'] = \
await ledger.build_revoc_reg_entry_request(faber['did'], faber['revoc_reg_id'], 'CL_ACCUM',
faber_alice_cert_rev_reg_delta)
await ledger.sign_and_submit_request(faber['pool'], faber['wallet'],
faber['did'],
faber['revoc_reg_entry_req'])
logger.info(
"\"Faber\" -> Authcrypt \"Transcript\" Credential for Alice")
faber_authcrypted_transcript_cred = \
await crypto.auth_crypt(faber['wallet'], faber['key_for_alice'], faber['alice_key_for_faber'],
faber_transcript_cred.encode('utf-8'))
logger.info(
"\"Faber\" -> Send authcrypted \"Transcript\" Credential to Alice")
alice_authcrypted_transcript_cred = faber_authcrypted_transcript_cred
logger.info(
"\"Alice\" -> Authdecrypted \"Transcript\" Credential from Faber")
_, alice_transcript_cred_json, alice_transcript_cred = \
await auth_decrypt(alice['wallet'], alice['key_for_faber'], alice_authcrypted_transcript_cred)
logger.info(
"\"Alice\" -> Gets RevocationRegistryDefinition for \"Transcript\" Credential from Faber"
)
alice['faber_revoc_reg_des_req'] = \
await ledger.build_get_revoc_reg_def_request(alice['did_for_faber'],
alice_transcript_cred['rev_reg_id'])
alice['faber_revoc_reg_des_resp'] = await ledger.submit_request(
alice['pool'], alice['faber_revoc_reg_des_req'])
(alice['faber_revoc_reg_def_id'], alice['faber_revoc_reg_def_json']) = \
await ledger.parse_get_revoc_reg_def_response(alice['faber_revoc_reg_des_resp'])
logger.info("\"Alice\" -> Store \"Transcript\" Credential from Faber")
_, alice_transcript_cred_def = await get_cred_def(
alice['pool'], alice['did_for_faber'],
transcript_cred_offer['cred_def_id'])
await anoncreds.prover_store_credential(
alice['wallet'], None, alice_transcript_cred_request_metadata,
alice_transcript_cred_json, alice_transcript_cred_def,
alice['faber_revoc_reg_def_json'])
logger.info("==============================")
logger.info("=== Apply for the job with Acme ==")
logger.info("==============================")
logger.info("== Apply for the job with Acme - Onboarding ==")
logger.info("------------------------------")
acme['did_for_alice'], acme['key_for_alice'], alice['did_for_acme'], alice['key_for_acme'], \
acme['alice_connection_response'] = await onboarding(acme, alice)
logger.info("==============================")
logger.info("== Apply for the job with Acme - Transcript proving ==")
logger.info("------------------------------")
logger.info("\"Acme\" -> Create \"Job-Application\" Proof Request")
nonce = await anoncreds.generate_nonce()
time_stamp = int(time.time())
acme['job_application_proof_request'] = json.dumps({
'nonce': nonce,
'name': 'Job-Application',
'version': '0.1',
'requested_attributes': {
'attr1_referent': {
'name': 'first_name'
},
'attr2_referent': {
'name': 'last_name'
},
'attr3_referent': {
'name': 'degree',
'restrictions': [{
'cred_def_id': faber['transcript_cred_def_id']
}]
},
'attr4_referent': {
'name': 'status',
'restrictions': [{
'cred_def_id': faber['transcript_cred_def_id']
}]
},
'attr5_referent': {
'name': 'ssn',
'restrictions': [{
'cred_def_id': faber['transcript_cred_def_id']
}]
},
'attr6_referent': {
'name': 'phone_number'
}
},
'requested_predicates': {
'predicate1_referent': {
'name': 'average',
'p_type': '>=',
'p_value': 4,
'restrictions': [{
'cred_def_id': faber['transcript_cred_def_id']
}]
}
},
'non_revoked': {
'to': time_stamp
}
})
logger.info("\"Acme\" -> Get key for Alice did")
acme['alice_key_for_acme'] = \
await did.key_for_did(acme['pool'], acme['wallet'], acme['alice_connection_response']['did'])
logger.info(
"\"Acme\" -> Authcrypt \"Job-Application\" Proof Request for Alice")
acme['authcrypted_job_application_proof_request'] = \
await crypto.auth_crypt(acme['wallet'], acme['key_for_alice'], acme['alice_key_for_acme'],
acme['job_application_proof_request'].encode('utf-8'))
logger.info(
"\"Acme\" -> Send authcrypted \"Job-Application\" Proof Request to Alice"
)
alice['authcrypted_job_application_proof_request'] = acme[
'authcrypted_job_application_proof_request']
logger.info(
"\"Alice\" -> Authdecrypt \"Job-Application\" Proof Request from Acme")
alice['acme_key_for_alice'], alice['job_application_proof_request'], _ = \
await auth_decrypt(alice['wallet'], alice['key_for_acme'], alice['authcrypted_job_application_proof_request'])
logger.info(
"\"Alice\" -> Get credentials for \"Job-Application\" Proof Request")
search_for_job_application_proof_request = \
await anoncreds.prover_search_credentials_for_proof_req(alice['wallet'],
alice['job_application_proof_request'], None)
# Use alternatively one of the two transcripts from Faber for generating the proof
cred_for_attr1 = await get_credential_for_referent(
search_for_job_application_proof_request, 'attr1_referent', 0)
cred_for_attr2 = await get_credential_for_referent(
search_for_job_application_proof_request, 'attr2_referent', 1)
cred_for_attr3 = await get_credential_for_referent(
search_for_job_application_proof_request, 'attr3_referent', 0)
cred_for_attr4 = await get_credential_for_referent(
search_for_job_application_proof_request, 'attr4_referent', 1)
cred_for_attr5 = await get_credential_for_referent(
search_for_job_application_proof_request, 'attr5_referent', 0)
cred_for_predicate1 = \
await get_credential_for_referent(search_for_job_application_proof_request,
'predicate1_referent', 1)
await anoncreds.prover_close_credentials_search_for_proof_req(
search_for_job_application_proof_request)
alice['creds_for_job_application_proof'] = {
cred_for_attr1['referent']: cred_for_attr1,
cred_for_attr2['referent']: cred_for_attr2,
cred_for_attr3['referent']: cred_for_attr3,
cred_for_attr4['referent']: cred_for_attr4,
cred_for_attr5['referent']: cred_for_attr5,
cred_for_predicate1['referent']: cred_for_predicate1
}
alice['schemas_for_job_application'], alice['cred_defs_for_job_application'], \
alice['revoc_states_for_job_application'] = \
await prover_get_entities_from_ledger(alice['pool'], alice['did_for_acme'],
alice['creds_for_job_application_proof'],
alice['name'],
timestamp_to=time_stamp)
logger.info("\"Alice\" -> Create \"Job-Application\" Proof")
revoc_states_for_job_application = json.loads(
alice['revoc_states_for_job_application'])
alice['job_application_requested_creds'] = json.dumps({
'self_attested_attributes': {
'attr1_referent': 'Alice',
'attr2_referent': 'Garcia',
'attr6_referent': '123-45-6789'
},
'requested_attributes': {
'attr3_referent': {
'cred_id':
cred_for_attr3['referent'],
'revealed':
True,
'timestamp':
get_timestamp_for_attribute(cred_for_attr3,
revoc_states_for_job_application)
},
'attr4_referent': {
'cred_id':
cred_for_attr4['referent'],
'revealed':
True,
'timestamp':
get_timestamp_for_attribute(cred_for_attr4,
revoc_states_for_job_application)
},
'attr5_referent': {
'cred_id':
cred_for_attr5['referent'],
'revealed':
True,
'timestamp':
get_timestamp_for_attribute(cred_for_attr5,
revoc_states_for_job_application)
},
},
'requested_predicates': {
'predicate1_referent': {
'cred_id':
cred_for_predicate1['referent'],
'timestamp':
get_timestamp_for_attribute(cred_for_predicate1,
revoc_states_for_job_application)
}
}
})
alice['job_application_proof'] = \
await anoncreds.prover_create_proof(alice['wallet'], alice['job_application_proof_request'],
alice['job_application_requested_creds'], alice['master_secret_id'],
alice['schemas_for_job_application'],
alice['cred_defs_for_job_application'],
alice['revoc_states_for_job_application'])
logger.info("\"Alice\" -> Authcrypt \"Job-Application\" Proof for Acme")
alice['authcrypted_job_application_proof'] = \
await crypto.auth_crypt(alice['wallet'], alice['key_for_acme'], alice['acme_key_for_alice'],
alice['job_application_proof'].encode('utf-8'))
logger.info(
"\"Alice\" -> Send authcrypted \"Job-Application\" Proof to Acme")
acme['authcrypted_job_application_proof'] = alice[
'authcrypted_job_application_proof']
logger.info(
"\"Acme\" -> Authdecrypted \"Job-Application\" Proof from Alice")
_, acme['job_application_proof'], decrypted_job_application_proof = \
await auth_decrypt(acme['wallet'], acme['key_for_alice'], acme['authcrypted_job_application_proof'])
acme['schemas_for_job_application'], acme['cred_defs_for_job_application'], \
acme['revoc_ref_defs_for_job_application'], acme['revoc_regs_for_job_application'] = \
await verifier_get_entities_from_ledger(acme['pool'], acme['did'],
decrypted_job_application_proof['identifiers'], acme['name'],
timestamp=time_stamp)
logger.info("\"Acme\" -> Verify \"Job-Application\" Proof from Alice")
assert 'Bachelor of Science, Marketing' == \
decrypted_job_application_proof['requested_proof']['revealed_attrs']['attr3_referent']['raw']
assert 'graduated' == \
decrypted_job_application_proof['requested_proof']['revealed_attrs']['attr4_referent']['raw']
assert '123-45-6789' == \
decrypted_job_application_proof['requested_proof']['revealed_attrs']['attr5_referent']['raw']
assert 'Alice' == decrypted_job_application_proof['requested_proof'][
'self_attested_attrs']['attr1_referent']
assert 'Garcia' == decrypted_job_application_proof['requested_proof'][
'self_attested_attrs']['attr2_referent']
assert '123-45-6789' == decrypted_job_application_proof['requested_proof'][
'self_attested_attrs']['attr6_referent']
assert await anoncreds.verifier_verify_proof(
acme['job_application_proof_request'], acme['job_application_proof'],
acme['schemas_for_job_application'],
acme['cred_defs_for_job_application'],
acme['revoc_ref_defs_for_job_application'],
acme['revoc_regs_for_job_application'])
logger.info("==============================")
logger.info(" \"Sovrin Steward\" -> Close and Delete wallet")
await wallet.close_wallet(steward['wallet'])
await wallet.delete_wallet(steward['wallet_config'],
steward['wallet_credentials'])
logger.info("\"Government\" -> Close and Delete wallet")
await wallet.close_wallet(government['wallet'])
await wallet.delete_wallet(
wallet_config("delete", government['wallet_config']),
wallet_credentials("delete", government['wallet_credentials']))
logger.info("\"Faber\" -> Close and Delete wallet")
await wallet.close_wallet(faber['wallet'])
await wallet.delete_wallet(
wallet_config("delete", faber['wallet_config']),
wallet_credentials("delete", faber['wallet_credentials']))
logger.info("\"Acme\" -> Close and Delete wallet")
await wallet.close_wallet(acme['wallet'])
await wallet.delete_wallet(
wallet_config("delete", acme['wallet_config']),
wallet_credentials("delete", acme['wallet_credentials']))
logger.info("\"Alice\" -> Close and Delete wallet")
await wallet.close_wallet(alice['wallet'])
await wallet.delete_wallet(
wallet_config("delete", alice['wallet_config']),
wallet_credentials("delete", alice['wallet_credentials']))
logger.info("Close and Delete pool")
await pool.close_pool_ledger(pool_['handle'])
await pool.delete_pool_ledger_config(pool_['name'])
logger.info("Getting started -> done")
async def run():
logger.info("Getting started -> started")
pool_name = 'pool1'
logger.info("Open Pool Ledger: {}".format(pool_name))
pool_genesis_txn_path = get_pool_genesis_txn_path(pool_name)
pool_config = json.dumps({"genesis_txn": str(pool_genesis_txn_path)})
# Set protocol version 2 to work with Indy Node 1.4
await pool.set_protocol_version(2)
try:
await pool.create_pool_ledger_config(pool_name, pool_config)
except IndyError as ex:
if ex.error_code == ErrorCode.PoolLedgerConfigAlreadyExistsError:
pass
pool_handle = await pool.open_pool_ledger(pool_name, None)
logger.info("==============================")
logger.info(
"=== Getting Trust Anchor credentials for Faber, Acme, Thrift and Government =="
)
logger.info("------------------------------")
logger.info("\"Sovrin Steward\" -> Create wallet")
steward_wallet_name = 'sovrin_steward_wallet'
steward_wallet_credentials = json.dumps({"key": "steward_wallet_key"})
try:
await wallet.create_wallet(pool_name, steward_wallet_name, None, None,
steward_wallet_credentials)
except IndyError as ex:
if ex.error_code == ErrorCode.WalletAlreadyExistsError:
pass
steward_wallet = await wallet.open_wallet(steward_wallet_name, None,
steward_wallet_credentials)
logger.info(
"\"Sovrin Steward\" -> Create and store in Wallet DID from seed")
steward_did_info = {'seed': '000000000000000000000000Steward1'}
(steward_did, steward_key) = await did.create_and_store_my_did(
steward_wallet, json.dumps(steward_did_info))
logger.info("==============================")
logger.info(
"== Getting Trust Anchor credentials - Government Onboarding ==")
logger.info("------------------------------")
government_wallet_name = 'government_wallet'
government_wallet_credentials = json.dumps(
{"key": "government_wallet_key"})
government_wallet, steward_government_key, government_steward_did, government_steward_key, _ \
= await onboarding(pool_handle, pool_name, "Sovrin Steward", steward_wallet,
steward_did, "Government", None, government_wallet_name, government_wallet_credentials)
logger.info("==============================")
logger.info(
"== Getting Trust Anchor credentials - Government getting Verinym ==")
logger.info("------------------------------")
government_did = await get_verinym(pool_handle, "Sovrin Steward",
steward_wallet, steward_did,
steward_government_key, "Government",
government_wallet,
government_steward_did,
government_steward_key, 'TRUST_ANCHOR')
logger.info("==============================")
logger.info("== Getting Trust Anchor credentials - Faber Onboarding ==")
logger.info("------------------------------")
faber_wallet_name = 'faber_wallet'
faber_wallet_credentials = json.dumps({"key": "faber_wallet_key"})
faber_wallet, steward_faber_key, faber_steward_did, faber_steward_key, _ = \
await onboarding(pool_handle, pool_name, "Sovrin Steward", steward_wallet, steward_did,
"Faber", None, faber_wallet_name, faber_wallet_credentials)
logger.info("==============================")
logger.info(
"== Getting Trust Anchor credentials - Faber getting Verinym ==")
logger.info("------------------------------")
faber_did = await get_verinym(pool_handle, "Sovrin Steward",
steward_wallet, steward_did,
steward_faber_key, "Faber", faber_wallet,
faber_steward_did, faber_steward_key,
'TRUST_ANCHOR')
logger.info("==============================")
logger.info("== Getting Trust Anchor credentials - Acme Onboarding ==")
logger.info("------------------------------")
acme_wallet_name = 'acme_wallet'
acme_wallet_credentials = json.dumps({"key": "acme_wallet_key"})
acme_wallet, steward_acme_key, acme_steward_did, acme_steward_key, _ = \
await onboarding(pool_handle, pool_name, "Sovrin Steward", steward_wallet, steward_did,
"Acme", None, acme_wallet_name, acme_wallet_credentials)
logger.info("==============================")
logger.info(
"== Getting Trust Anchor credentials - Acme getting Verinym ==")
logger.info("------------------------------")
acme_did = await get_verinym(pool_handle, "Sovrin Steward", steward_wallet,
steward_did, steward_acme_key, "Acme",
acme_wallet, acme_steward_did,
acme_steward_key, 'TRUST_ANCHOR')
logger.info("==============================")
logger.info("== Getting Trust Anchor credentials - Thrift Onboarding ==")
logger.info("------------------------------")
thrift_wallet_name = 'thrift_wallet'
thrift_wallet_credentials = json.dumps({"key": "thrift_wallet_key"})
thrift_wallet, steward_thrift_key, thrift_steward_did, thrift_steward_key, _ = \
await onboarding(pool_handle, pool_name, "Sovrin Steward", steward_wallet, steward_did,
"Thrift", None, thrift_wallet_name, thrift_wallet_credentials)
logger.info("==============================")
logger.info(
"== Getting Trust Anchor credentials - Thrift getting Verinym ==")
logger.info("------------------------------")
thrift_did = await get_verinym(pool_handle, "Sovrin Steward",
steward_wallet, steward_did,
steward_thrift_key, "Thrift", thrift_wallet,
thrift_steward_did, thrift_steward_key,
'TRUST_ANCHOR')
logger.info("==============================")
logger.info("=== Credential Schemas Setup ==")
logger.info("------------------------------")
logger.info("\"Government\" -> Create \"Job-Certificate\" Schema")
(job_certificate_schema_id, job_certificate_schema) = \
await anoncreds.issuer_create_schema(government_did, 'Job-Certificate', '0.2',
json.dumps(['first_name', 'last_name', 'salary', 'employee_status',
'experience']))
logger.info("\"Government\" -> Send \"Job-Certificate\" Schema to Ledger")
await send_schema(pool_handle, government_wallet, government_did,
job_certificate_schema)
logger.info("\"Government\" -> Create \"Transcript\" Schema")
(transcript_schema_id, transcript_schema) = \
await anoncreds.issuer_create_schema(government_did, 'Transcript', '1.2',
json.dumps(['first_name', 'last_name', 'degree', 'status',
'year', 'average', 'ssn']))
logger.info("\"Government\" -> Send \"Transcript\" Schema to Ledger")
await send_schema(pool_handle, government_wallet, government_did,
transcript_schema)
logger.info("==============================")
logger.info("=== Faber Credential Definition Setup ==")
logger.info("------------------------------")
logger.info("\"Faber\" -> Get \"Transcript\" Schema from Ledger")
(_, transcript_schema) = await get_schema(pool_handle, faber_did,
transcript_schema_id)
logger.info(
"\"Faber\" -> Create and store in Wallet \"Faber Transcript\" Credential Definition"
)
(faber_transcript_cred_def_id, faber_transcript_cred_def_json) = \
await anoncreds.issuer_create_and_store_credential_def(faber_wallet, faber_did, transcript_schema,
'TAG1', 'CL', '{"support_revocation": false}')
logger.info(
"\"Faber\" -> Send \"Faber Transcript\" Credential Definition to Ledger"
)
await send_cred_def(pool_handle, faber_wallet, faber_did,
faber_transcript_cred_def_json)
logger.info("==============================")
logger.info("=== Acme Credential Definition Setup ==")
logger.info("------------------------------")
logger.info("\"Acme\" -> Get from Ledger \"Job-Certificate\" Schema")
(_, job_certificate_schema) = await get_schema(pool_handle, acme_did,
job_certificate_schema_id)
logger.info(
"\"Acme\" -> Create and store in Wallet \"Acme Job-Certificate\" Credential Definition"
)
(acme_job_certificate_cred_def_id, acme_job_certificate_cred_def_json) = \
await anoncreds.issuer_create_and_store_credential_def(acme_wallet, acme_did, job_certificate_schema,
'TAG1', 'CL', '{"support_revocation": false}')
logger.info(
"\"Acme\" -> Send \"Acme Job-Certificate\" Credential Definition to Ledger"
)
await send_cred_def(pool_handle, acme_wallet, acme_did,
acme_job_certificate_cred_def_json)
logger.info("==============================")
logger.info("=== Getting Transcript with Faber ==")
logger.info("==============================")
logger.info("== Getting Transcript with Faber - Onboarding ==")
logger.info("------------------------------")
alice_wallet_name = 'alice_wallet'
alice_wallet_credentials = json.dumps({"key": "alice_wallet_key"})
alice_wallet, faber_alice_key, alice_faber_did, alice_faber_key, faber_alice_connection_response \
= await onboarding(pool_handle, pool_name, "Faber", faber_wallet, faber_did, "Alice", None,
alice_wallet_name, alice_wallet_credentials)
logger.info("==============================")
logger.info(
"== Getting Transcript with Faber - Getting Transcript Credential ==")
logger.info("------------------------------")
logger.info(
"\"Faber\" -> Create \"Transcript\" Credential Offer for Alice")
transcript_cred_offer_json = \
await anoncreds.issuer_create_credential_offer(faber_wallet, faber_transcript_cred_def_id)
logger.info("\"Faber\" -> Get key for Alice did")
alice_faber_verkey = await did.key_for_did(
pool_handle, acme_wallet, faber_alice_connection_response['did'])
logger.info(
"\"Faber\" -> Authcrypt \"Transcript\" Credential Offer for Alice")
authcrypted_transcript_cred_offer = await crypto.auth_crypt(
faber_wallet, faber_alice_key, alice_faber_verkey,
transcript_cred_offer_json.encode('utf-8'))
logger.info(
"\"Faber\" -> Send authcrypted \"Transcript\" Credential Offer to Alice"
)
logger.info(
"\"Alice\" -> Authdecrypted \"Transcript\" Credential Offer from Faber"
)
faber_alice_verkey, authdecrypted_transcript_cred_offer_json, authdecrypted_transcript_cred_offer = \
await auth_decrypt(alice_wallet, alice_faber_key, authcrypted_transcript_cred_offer)
logger.info(
"\"Alice\" -> Create and store \"Alice\" Master Secret in Wallet")
alice_master_secret_id = await anoncreds.prover_create_master_secret(
alice_wallet, None)
logger.info(
"\"Alice\" -> Get \"Faber Transcript\" Credential Definition from Ledger"
)
(faber_transcript_cred_def_id, faber_transcript_cred_def) = \
await get_cred_def(pool_handle, alice_faber_did, authdecrypted_transcript_cred_offer['cred_def_id'])
logger.info(
"\"Alice\" -> Create \"Transcript\" Credential Request for Faber")
(transcript_cred_request_json, transcript_cred_request_metadata_json) = \
await anoncreds.prover_create_credential_req(alice_wallet, alice_faber_did,
authdecrypted_transcript_cred_offer_json,
faber_transcript_cred_def, alice_master_secret_id)
logger.info(
"\"Alice\" -> Authcrypt \"Transcript\" Credential Request for Faber")
authcrypted_transcript_cred_request = await crypto.auth_crypt(
alice_wallet, alice_faber_key, faber_alice_verkey,
transcript_cred_request_json.encode('utf-8'))
logger.info(
"\"Alice\" -> Send authcrypted \"Transcript\" Credential Request to Faber"
)
logger.info(
"\"Faber\" -> Authdecrypt \"Transcript\" Credential Request from Alice"
)
alice_faber_verkey, authdecrypted_transcript_cred_request_json, _ = \
await auth_decrypt(faber_wallet, faber_alice_key, authcrypted_transcript_cred_request)
logger.info("\"Faber\" -> Create \"Transcript\" Credential for Alice")
transcript_cred_values = json.dumps({
"first_name": {
"raw": "Alice",
"encoded": "1139481716457488690172217916278103335"
},
"last_name": {
"raw": "Garcia",
"encoded": "5321642780241790123587902456789123452"
},
"degree": {
"raw": "Bachelor of Science, Marketing",
"encoded": "12434523576212321"
},
"status": {
"raw": "graduated",
"encoded": "2213454313412354"
},
"ssn": {
"raw": "123-45-6789",
"encoded": "3124141231422543541"
},
"year": {
"raw": "2015",
"encoded": "2015"
},
"average": {
"raw": "5",
"encoded": "5"
}
})
transcript_cred_json, _, _ = \
await anoncreds.issuer_create_credential(faber_wallet, transcript_cred_offer_json,
authdecrypted_transcript_cred_request_json,
transcript_cred_values, None, None)
logger.info("\"Faber\" -> Authcrypt \"Transcript\" Credential for Alice")
authcrypted_transcript_cred_json = await crypto.auth_crypt(
faber_wallet, faber_alice_key, alice_faber_verkey,
transcript_cred_json.encode('utf-8'))
logger.info(
"\"Faber\" -> Send authcrypted \"Transcript\" Credential to Alice")
logger.info(
"\"Alice\" -> Authdecrypted \"Transcript\" Credential from Faber")
_, authdecrypted_transcript_cred_json, _ = \
await auth_decrypt(alice_wallet, alice_faber_key, authcrypted_transcript_cred_json)
logger.info("\"Alice\" -> Store \"Transcript\" Credential from Faber")
await anoncreds.prover_store_credential(
alice_wallet, None, transcript_cred_request_metadata_json,
authdecrypted_transcript_cred_json, faber_transcript_cred_def, None)
logger.info("==============================")
logger.info("=== Apply for the job with Acme ==")
logger.info("==============================")
logger.info("== Apply for the job with Acme - Onboarding ==")
logger.info("------------------------------")
alice_wallet, acme_alice_key, alice_acme_did, alice_acme_key, acme_alice_connection_response = \
await onboarding(pool_handle, pool_name, "Acme", acme_wallet, acme_did, "Alice", alice_wallet,
alice_wallet_name, alice_wallet_credentials)
logger.info("==============================")
logger.info("== Apply for the job with Acme - Transcript proving ==")
logger.info("------------------------------")
logger.info("\"Acme\" -> Create \"Job-Application\" Proof Request")
job_application_proof_request_json = json.dumps({
'nonce': '1432422343242122312411212',
'name': 'Job-Application',
'version': '0.1',
'requested_attributes': {
'attr1_referent': {
'name': 'first_name'
},
'attr2_referent': {
'name': 'last_name'
},
'attr3_referent': {
'name': 'degree',
'restrictions': [{
'cred_def_id': faber_transcript_cred_def_id
}]
},
'attr4_referent': {
'name': 'status',
'restrictions': [{
'cred_def_id': faber_transcript_cred_def_id
}]
},
'attr5_referent': {
'name': 'ssn',
'restrictions': [{
'cred_def_id': faber_transcript_cred_def_id
}]
},
'attr6_referent': {
'name': 'phone_number'
}
},
'requested_predicates': {
'predicate1_referent': {
'name': 'average',
'p_type': '>=',
'p_value': 4,
'restrictions': [{
'cred_def_id': faber_transcript_cred_def_id
}]
}
}
})
logger.info("\"Acme\" -> Get key for Alice did")
alice_acme_verkey = await did.key_for_did(
pool_handle, acme_wallet, acme_alice_connection_response['did'])
logger.info(
"\"Acme\" -> Authcrypt \"Job-Application\" Proof Request for Alice")
authcrypted_job_application_proof_request_json = \
await crypto.auth_crypt(acme_wallet, acme_alice_key, alice_acme_verkey,
job_application_proof_request_json.encode('utf-8'))
logger.info(
"\"Acme\" -> Send authcrypted \"Job-Application\" Proof Request to Alice"
)
logger.info(
"\"Alice\" -> Authdecrypt \"Job-Application\" Proof Request from Acme")
acme_alice_verkey, authdecrypted_job_application_proof_request_json, _ = \
await auth_decrypt(alice_wallet, alice_acme_key, authcrypted_job_application_proof_request_json)
logger.info(
"\"Alice\" -> Get credentials for \"Job-Application\" Proof Request")
creds_for_job_application_proof_request = json.loads(
await anoncreds.prover_get_credentials_for_proof_req(
alice_wallet, authdecrypted_job_application_proof_request_json))
cred_for_attr1 = creds_for_job_application_proof_request['attrs'][
'attr1_referent'][0]['cred_info']
cred_for_attr2 = creds_for_job_application_proof_request['attrs'][
'attr2_referent'][0]['cred_info']
cred_for_attr3 = creds_for_job_application_proof_request['attrs'][
'attr3_referent'][0]['cred_info']
cred_for_attr4 = creds_for_job_application_proof_request['attrs'][
'attr4_referent'][0]['cred_info']
cred_for_attr5 = creds_for_job_application_proof_request['attrs'][
'attr5_referent'][0]['cred_info']
cred_for_predicate1 = creds_for_job_application_proof_request[
'predicates']['predicate1_referent'][0]['cred_info']
creds_for_job_application_proof = {
cred_for_attr1['referent']: cred_for_attr1,
cred_for_attr2['referent']: cred_for_attr2,
cred_for_attr3['referent']: cred_for_attr3,
cred_for_attr4['referent']: cred_for_attr4,
cred_for_attr5['referent']: cred_for_attr5,
cred_for_predicate1['referent']: cred_for_predicate1
}
schemas_json, cred_defs_json, revoc_states_json = \
await prover_get_entities_from_ledger(pool_handle, alice_faber_did, creds_for_job_application_proof, 'Alice')
logger.info("\"Alice\" -> Create \"Job-Application\" Proof")
job_application_requested_creds_json = json.dumps({
'self_attested_attributes': {
'attr1_referent': 'Alice',
'attr2_referent': 'Garcia',
'attr6_referent': '123-45-6789'
},
'requested_attributes': {
'attr3_referent': {
'cred_id': cred_for_attr3['referent'],
'revealed': True
},
'attr4_referent': {
'cred_id': cred_for_attr4['referent'],
'revealed': True
},
'attr5_referent': {
'cred_id': cred_for_attr5['referent'],
'revealed': True
},
},
'requested_predicates': {
'predicate1_referent': {
'cred_id': cred_for_predicate1['referent']
}
}
})
job_application_proof_json = \
await anoncreds.prover_create_proof(alice_wallet, authdecrypted_job_application_proof_request_json,
job_application_requested_creds_json, alice_master_secret_id,
schemas_json, cred_defs_json, revoc_states_json)
logger.info("\"Alice\" -> Authcrypt \"Job-Application\" Proof for Acme")
authcrypted_job_application_proof_json = await crypto.auth_crypt(
alice_wallet, alice_acme_key, acme_alice_verkey,
job_application_proof_json.encode('utf-8'))
logger.info(
"\"Alice\" -> Send authcrypted \"Job-Application\" Proof to Acme")
logger.info(
"\"Acme\" -> Authdecrypted \"Job-Application\" Proof from Alice")
_, decrypted_job_application_proof_json, decrypted_job_application_proof = \
await auth_decrypt(acme_wallet, acme_alice_key, authcrypted_job_application_proof_json)
schemas_json, cred_defs_json, revoc_ref_defs_json, revoc_regs_json = \
await verifier_get_entities_from_ledger(pool_handle, acme_did,
decrypted_job_application_proof['identifiers'], 'Acme')
logger.info("\"Acme\" -> Verify \"Job-Application\" Proof from Alice")
assert 'Bachelor of Science, Marketing' == \
decrypted_job_application_proof['requested_proof']['revealed_attrs']['attr3_referent']['raw']
assert 'graduated' == \
decrypted_job_application_proof['requested_proof']['revealed_attrs']['attr4_referent']['raw']
assert '123-45-6789' == \
decrypted_job_application_proof['requested_proof']['revealed_attrs']['attr5_referent']['raw']
assert 'Alice' == decrypted_job_application_proof['requested_proof'][
'self_attested_attrs']['attr1_referent']
assert 'Garcia' == decrypted_job_application_proof['requested_proof'][
'self_attested_attrs']['attr2_referent']
assert '123-45-6789' == decrypted_job_application_proof['requested_proof'][
'self_attested_attrs']['attr6_referent']
assert await anoncreds.verifier_verify_proof(
job_application_proof_request_json,
decrypted_job_application_proof_json, schemas_json, cred_defs_json,
revoc_ref_defs_json, revoc_regs_json)
logger.info("==============================")
logger.info(
"== Apply for the job with Acme - Getting Job-Certificate Credential =="
)
logger.info("------------------------------")
logger.info(
"\"Acme\" -> Create \"Job-Certificate\" Credential Offer for Alice")
job_certificate_cred_offer_json = \
await anoncreds.issuer_create_credential_offer(acme_wallet, acme_job_certificate_cred_def_id)
logger.info("\"Acme\" -> Get key for Alice did")
alice_acme_verkey = await did.key_for_did(
pool_handle, acme_wallet, acme_alice_connection_response['did'])
logger.info(
"\"Acme\" -> Authcrypt \"Job-Certificate\" Credential Offer for Alice")
authcrypted_job_certificate_cred_offer = await crypto.auth_crypt(
acme_wallet, acme_alice_key, alice_acme_verkey,
job_certificate_cred_offer_json.encode('utf-8'))
logger.info(
"\"Acme\" -> Send authcrypted \"Job-Certificate\" Credential Offer to Alice"
)
logger.info(
"\"Alice\" -> Authdecrypted \"Job-Certificate\" Credential Offer from Acme"
)
acme_alice_verkey, authdecrypted_job_certificate_cred_offer_json, authdecrypted_job_certificate_cred_offer = \
await auth_decrypt(alice_wallet, alice_acme_key, authcrypted_job_certificate_cred_offer)
logger.info(
"\"Alice\" -> Get \"Acme Job-Certificate\" Credential Definition from Ledger"
)
(_, acme_job_certificate_cred_def) = \
await get_cred_def(pool_handle, alice_acme_did, authdecrypted_job_certificate_cred_offer['cred_def_id'])
logger.info(
"\"Alice\" -> Create and store in Wallet \"Job-Certificate\" Credential Request for Acme"
)
(job_certificate_cred_request_json, job_certificate_cred_request_metadata_json) = \
await anoncreds.prover_create_credential_req(alice_wallet, alice_acme_did,
authdecrypted_job_certificate_cred_offer_json,
acme_job_certificate_cred_def, alice_master_secret_id)
logger.info(
"\"Alice\" -> Authcrypt \"Job-Certificate\" Credential Request for Acme"
)
authcrypted_job_certificate_cred_request_json = \
await crypto.auth_crypt(alice_wallet, alice_acme_key, acme_alice_verkey,
job_certificate_cred_request_json.encode('utf-8'))
logger.info(
"\"Alice\" -> Send authcrypted \"Job-Certificate\" Credential Request to Acme"
)
logger.info(
"\"Acme\" -> Authdecrypt \"Job-Certificate\" Credential Request from Alice"
)
alice_acme_verkey, authdecrypted_job_certificate_cred_request_json, _ = \
await auth_decrypt(acme_wallet, acme_alice_key, authcrypted_job_certificate_cred_request_json)
logger.info("\"Acme\" -> Create \"Job-Certificate\" Credential for Alice")
alice_job_certificate_cred_values_json = json.dumps({
"first_name": {
"raw": "Alice",
"encoded": "245712572474217942457235975012103335"
},
"last_name": {
"raw": "Garcia",
"encoded": "312643218496194691632153761283356127"
},
"employee_status": {
"raw": "Permanent",
"encoded": "2143135425425143112321314321"
},
"salary": {
"raw": "2400",
"encoded": "2400"
},
"experience": {
"raw": "10",
"encoded": "10"
}
})
job_certificate_cred_json, _, _ = \
await anoncreds.issuer_create_credential(acme_wallet, job_certificate_cred_offer_json,
authdecrypted_job_certificate_cred_request_json,
alice_job_certificate_cred_values_json, None, None)
logger.info(
"\"Acme\" -> Authcrypt \"Job-Certificate\" Credential for Alice")
authcrypted_job_certificate_cred_json = \
await crypto.auth_crypt(acme_wallet, acme_alice_key, alice_acme_verkey,
job_certificate_cred_json.encode('utf-8'))
logger.info(
"\"Acme\" -> Send authcrypted \"Job-Certificate\" Credential to Alice"
)
logger.info(
"\"Alice\" -> Authdecrypted \"Job-Certificate\" Credential from Acme")
_, authdecrypted_job_certificate_cred_json, _ = \
await auth_decrypt(alice_wallet, alice_acme_key, authcrypted_job_certificate_cred_json)
logger.info("\"Alice\" -> Store \"Job-Certificate\" Credential")
await anoncreds.prover_store_credential(
alice_wallet, None, job_certificate_cred_request_metadata_json,
authdecrypted_job_certificate_cred_json,
acme_job_certificate_cred_def_json, None)
logger.info("==============================")
logger.info("=== Apply for the loan with Thrift ==")
logger.info("==============================")
logger.info("== Apply for the loan with Thrift - Onboarding ==")
logger.info("------------------------------")
_, thrift_alice_key, alice_thrift_did, alice_thrift_key, \
thrift_alice_connection_response = await onboarding(pool_handle, pool_name, "Thrift", thrift_wallet, thrift_did,
"Alice", alice_wallet, alice_wallet_name,
alice_wallet_credentials)
logger.info("==============================")
logger.info(
"== Apply for the loan with Thrift - Job-Certificate proving ==")
logger.info("------------------------------")
logger.info(
"\"Thrift\" -> Create \"Loan-Application-Basic\" Proof Request")
apply_loan_proof_request_json = json.dumps({
'nonce': '123432421212',
'name': 'Loan-Application-Basic',
'version': '0.1',
'requested_attributes': {
'attr1_referent': {
'name': 'employee_status',
'restrictions': [{
'cred_def_id':
acme_job_certificate_cred_def_id
}]
}
},
'requested_predicates': {
'predicate1_referent': {
'name': 'salary',
'p_type': '>=',
'p_value': 2000,
'restrictions': [{
'cred_def_id':
acme_job_certificate_cred_def_id
}]
},
'predicate2_referent': {
'name': 'experience',
'p_type': '>=',
'p_value': 1,
'restrictions': [{
'cred_def_id':
acme_job_certificate_cred_def_id
}]
}
}
})
logger.info("\"Thrift\" -> Get key for Alice did")
alice_thrift_verkey = await did.key_for_did(
pool_handle, thrift_wallet, thrift_alice_connection_response['did'])
logger.info(
"\"Thrift\" -> Authcrypt \"Loan-Application-Basic\" Proof Request for Alice"
)
authcrypted_apply_loan_proof_request_json = \
await crypto.auth_crypt(thrift_wallet, thrift_alice_key, alice_thrift_verkey,
apply_loan_proof_request_json.encode('utf-8'))
logger.info(
"\"Thrift\" -> Send authcrypted \"Loan-Application-Basic\" Proof Request to Alice"
)
logger.info(
"\"Alice\" -> Authdecrypt \"Loan-Application-Basic\" Proof Request from Thrift"
)
thrift_alice_verkey, authdecrypted_apply_loan_proof_request_json, _ = \
await auth_decrypt(alice_wallet, alice_thrift_key, authcrypted_apply_loan_proof_request_json)
logger.info(
"\"Alice\" -> Get credentials for \"Loan-Application-Basic\" Proof Request"
)
creds_json_for_apply_loan_proof_request = \
await anoncreds.prover_get_credentials_for_proof_req(alice_wallet, authdecrypted_apply_loan_proof_request_json)
creds_for_apply_loan_proof_request = json.loads(
creds_json_for_apply_loan_proof_request)
cred_for_attr1 = creds_for_apply_loan_proof_request['attrs'][
'attr1_referent'][0]['cred_info']
cred_for_predicate1 = creds_for_apply_loan_proof_request['predicates'][
'predicate1_referent'][0]['cred_info']
cred_for_predicate2 = creds_for_apply_loan_proof_request['predicates'][
'predicate2_referent'][0]['cred_info']
creds_for_apply_loan_proof = {
cred_for_attr1['referent']: cred_for_attr1,
cred_for_predicate1['referent']: cred_for_predicate1,
cred_for_predicate2['referent']: cred_for_predicate2
}
schemas_json, cred_defs_json, revoc_states_json = \
await prover_get_entities_from_ledger(pool_handle, alice_thrift_did, creds_for_apply_loan_proof, 'Alice')
logger.info("\"Alice\" -> Create \"Loan-Application-Basic\" Proof")
apply_loan_requested_creds_json = json.dumps({
'self_attested_attributes': {},
'requested_attributes': {
'attr1_referent': {
'cred_id': cred_for_attr1['referent'],
'revealed': True
}
},
'requested_predicates': {
'predicate1_referent': {
'cred_id': cred_for_predicate1['referent']
},
'predicate2_referent': {
'cred_id': cred_for_predicate2['referent']
}
}
})
alice_apply_loan_proof_json = \
await anoncreds.prover_create_proof(alice_wallet, authdecrypted_apply_loan_proof_request_json,
apply_loan_requested_creds_json, alice_master_secret_id, schemas_json,
cred_defs_json, revoc_states_json)
logger.info(
"\"Alice\" -> Authcrypt \"Loan-Application-Basic\" Proof for Thrift")
authcrypted_alice_apply_loan_proof_json = \
await crypto.auth_crypt(alice_wallet, alice_thrift_key, thrift_alice_verkey,
alice_apply_loan_proof_json.encode('utf-8'))
logger.info(
"\"Alice\" -> Send authcrypted \"Loan-Application-Basic\" Proof to Thrift"
)
logger.info(
"\"Thrift\" -> Authdecrypted \"Loan-Application-Basic\" Proof from Alice"
)
_, authdecrypted_alice_apply_loan_proof_json, authdecrypted_alice_apply_loan_proof = \
await auth_decrypt(thrift_wallet, thrift_alice_key, authcrypted_alice_apply_loan_proof_json)
logger.info(
"\"Thrift\" -> Get Schemas, Credential Definitions and Revocation Registries from Ledger"
" required for Proof verifying")
schemas_json, cred_defs_json, revoc_defs_json, revoc_regs_json = \
await verifier_get_entities_from_ledger(pool_handle, thrift_did,
authdecrypted_alice_apply_loan_proof['identifiers'], 'Thrift')
logger.info(
"\"Thrift\" -> Verify \"Loan-Application-Basic\" Proof from Alice")
assert 'Permanent' == \
authdecrypted_alice_apply_loan_proof['requested_proof']['revealed_attrs']['attr1_referent']['raw']
assert await anoncreds.verifier_verify_proof(
apply_loan_proof_request_json,
authdecrypted_alice_apply_loan_proof_json, schemas_json,
cred_defs_json, revoc_defs_json, revoc_regs_json)
logger.info("==============================")
logger.info("==============================")
logger.info(
"== Apply for the loan with Thrift - Transcript and Job-Certificate proving =="
)
logger.info("------------------------------")
logger.info("\"Thrift\" -> Create \"Loan-Application-KYC\" Proof Request")
apply_loan_kyc_proof_request_json = json.dumps({
'nonce': '123432421212',
'name': 'Loan-Application-KYC',
'version': '0.1',
'requested_attributes': {
'attr1_referent': {
'name': 'first_name'
},
'attr2_referent': {
'name': 'last_name'
},
'attr3_referent': {
'name': 'ssn'
}
},
'requested_predicates': {}
})
logger.info("\"Thrift\" -> Get key for Alice did")
alice_thrift_verkey = await did.key_for_did(
pool_handle, thrift_wallet, thrift_alice_connection_response['did'])
logger.info(
"\"Thrift\" -> Authcrypt \"Loan-Application-KYC\" Proof Request for Alice"
)
authcrypted_apply_loan_kyc_proof_request_json = \
await crypto.auth_crypt(thrift_wallet, thrift_alice_key, alice_thrift_verkey,
apply_loan_kyc_proof_request_json.encode('utf-8'))
logger.info(
"\"Thrift\" -> Send authcrypted \"Loan-Application-KYC\" Proof Request to Alice"
)
logger.info(
"\"Alice\" -> Authdecrypt \"Loan-Application-KYC\" Proof Request from Thrift"
)
thrift_alice_verkey, authdecrypted_apply_loan_kyc_proof_request_json, _ = \
await auth_decrypt(alice_wallet, alice_thrift_key, authcrypted_apply_loan_kyc_proof_request_json)
logger.info(
"\"Alice\" -> Get credentials for \"Loan-Application-KYC\" Proof Request"
)
creds_json_for_apply_loan_kyc_proof_request = \
await anoncreds.prover_get_credentials_for_proof_req(alice_wallet,
authdecrypted_apply_loan_kyc_proof_request_json)
creds_for_apply_loan_kyc_proof_request = json.loads(
creds_json_for_apply_loan_kyc_proof_request)
cred_for_attr1 = creds_for_apply_loan_kyc_proof_request['attrs'][
'attr1_referent'][0]['cred_info']
cred_for_attr2 = creds_for_apply_loan_kyc_proof_request['attrs'][
'attr2_referent'][0]['cred_info']
cred_for_attr3 = creds_for_apply_loan_kyc_proof_request['attrs'][
'attr3_referent'][0]['cred_info']
creds_for_apply_loan_kyc_proof = {
cred_for_attr1['referent']: cred_for_attr1,
cred_for_attr2['referent']: cred_for_attr2,
cred_for_attr3['referent']: cred_for_attr3
}
schemas_json, cred_defs_json, revoc_states_json = \
await prover_get_entities_from_ledger(pool_handle, alice_thrift_did, creds_for_apply_loan_kyc_proof, 'Alice')
logger.info("\"Alice\" -> Create \"Loan-Application-KYC\" Proof")
apply_loan_kyc_requested_creds_json = json.dumps({
'self_attested_attributes': {},
'requested_attributes': {
'attr1_referent': {
'cred_id': cred_for_attr1['referent'],
'revealed': True
},
'attr2_referent': {
'cred_id': cred_for_attr2['referent'],
'revealed': True
},
'attr3_referent': {
'cred_id': cred_for_attr3['referent'],
'revealed': True
}
},
'requested_predicates': {}
})
alice_apply_loan_kyc_proof_json = \
await anoncreds.prover_create_proof(alice_wallet, authdecrypted_apply_loan_kyc_proof_request_json,
apply_loan_kyc_requested_creds_json, alice_master_secret_id,
schemas_json, cred_defs_json, revoc_states_json)
logger.info(
"\"Alice\" -> Authcrypt \"Loan-Application-KYC\" Proof for Thrift")
authcrypted_alice_apply_loan_kyc_proof_json = \
await crypto.auth_crypt(alice_wallet, alice_thrift_key, thrift_alice_verkey,
alice_apply_loan_kyc_proof_json.encode('utf-8'))
logger.info(
"\"Alice\" -> Send authcrypted \"Loan-Application-KYC\" Proof to Thrift"
)
logger.info(
"\"Thrift\" -> Authdecrypted \"Loan-Application-KYC\" Proof from Alice"
)
_, authdecrypted_alice_apply_loan_kyc_proof_json, authdecrypted_alice_apply_loan_kyc_proof = \
await auth_decrypt(thrift_wallet, thrift_alice_key, authcrypted_alice_apply_loan_kyc_proof_json)
logger.info(
"\"Thrift\" -> Get Schemas, Credential Definitions and Revocation Registries from Ledger"
" required for Proof verifying")
schemas_json, cred_defs_json, revoc_defs_json, revoc_regs_json = \
await verifier_get_entities_from_ledger(pool_handle, thrift_did,
authdecrypted_alice_apply_loan_kyc_proof['identifiers'], 'Thrift')
logger.info(
"\"Thrift\" -> Verify \"Loan-Application-KYC\" Proof from Alice")
assert 'Alice' == \
authdecrypted_alice_apply_loan_kyc_proof['requested_proof']['revealed_attrs']['attr1_referent']['raw']
assert 'Garcia' == \
authdecrypted_alice_apply_loan_kyc_proof['requested_proof']['revealed_attrs']['attr2_referent']['raw']
assert '123-45-6789' == \
authdecrypted_alice_apply_loan_kyc_proof['requested_proof']['revealed_attrs']['attr3_referent']['raw']
assert await anoncreds.verifier_verify_proof(
apply_loan_kyc_proof_request_json,
authdecrypted_alice_apply_loan_kyc_proof_json, schemas_json,
cred_defs_json, revoc_defs_json, revoc_regs_json)
logger.info("==============================")
logger.info(" \"Sovrin Steward\" -> Close and Delete wallet")
await wallet.close_wallet(steward_wallet)
await wallet.delete_wallet(steward_wallet_name, steward_wallet_credentials)
logger.info("\"Government\" -> Close and Delete wallet")
await wallet.close_wallet(government_wallet)
await wallet.delete_wallet(government_wallet_name,
government_wallet_credentials)
logger.info("\"Faber\" -> Close and Delete wallet")
await wallet.close_wallet(faber_wallet)
await wallet.delete_wallet(faber_wallet_name, faber_wallet_credentials)
logger.info("\"Acme\" -> Close and Delete wallet")
await wallet.close_wallet(acme_wallet)
await wallet.delete_wallet(acme_wallet_name, acme_wallet_credentials)
logger.info("\"Thrift\" -> Close and Delete wallet")
await wallet.close_wallet(thrift_wallet)
await wallet.delete_wallet(thrift_wallet_name, thrift_wallet_credentials)
logger.info("\"Alice\" -> Close and Delete wallet")
await wallet.close_wallet(alice_wallet)
await wallet.delete_wallet(alice_wallet_name, alice_wallet_credentials)
logger.info("Close and Delete pool")
await pool.close_pool_ledger(pool_handle)
await pool.delete_pool_ledger_config(pool_name)
logger.info("Getting started -> done")
added by Steward
"""
import asyncio
import json
import pprint
from indy import pool, ledger, wallet, did
from indy.error import IndyError
from src.utils import get_pool_genesis_txn_path, PROTOCOL_VERSION
pool_name = 'pool'
genesis_file_path = get_pool_genesis_txn_path(pool_name)
wallet_config = json.dumps({"id": "wallet"})
wallet_credentials = json.dumps({"key": "wallet_key"})
# Set protocol version to 2 to work with the current version of Indy Node
PROTOCOL_VERSION = 2
def print_log(value_color="", value_noncolor=""):
"""set the colors for text."""
HEADER = '\033[92m'
ENDC = '\033[0m'
print(HEADER + value_color + ENDC + str(value_noncolor))
async def rotate_key_on_the_ledger():
async def proof_negotiation():
seq_no = 1
pool_name = 'pool1'
wallet_path = "/root/indy/python/.indy_client/wallet"
wallet_credentials = json.dumps({"key": "wallet_key"})
steward_wallet_config = json.dumps({
"id": "steward_wallet",
"storage_config": {
"path": wallet_path
}
})
issuer_wallet_config = json.dumps({
"id": "issuer_wallet",
"storage_config": {
"path": wallet_path
}
})
pool_genesis_txn_path = get_pool_genesis_txn_path(pool_name)
pool_config = json.dumps({"genesis_txn": str(pool_genesis_txn_path)})
# Set protocol version 2 to work with Indy Node 1.4
await pool.set_protocol_version(PROTOCOL_VERSION)
try:
await pool.create_pool_ledger_config(pool_name, pool_config)
except:
pass
try:
# 1.
print_log(
'\n1. Creates a new local pool ledger configuration that is used '
'later when connecting to ledger.\n')
# 2.
print_log('\n2. Open pool ledger and get handle from libindy\n')
pool_handle = await pool.open_pool_ledger(pool_name, pool_config)
# 3.
print_log(
'\n3. Creating new issuer, steward, and prover secure wallet\n')
await wallet.create_wallet(issuer_wallet_config, wallet_credentials)
await wallet.create_wallet(steward_wallet_config, wallet_credentials)
# 4.
print_log('\n4. Open wallet and get handle from libindy\n')
issuer_wallet_handle = await wallet.open_wallet(
issuer_wallet_config, wallet_credentials)
steward_wallet_handle = await wallet.open_wallet(
steward_wallet_config, wallet_credentials)
# 5.
print_log('\n5. Generating and storing steward DID and verkey\n')
steward_seed = '000000000000000000000000Steward1'
did_json = json.dumps({'seed': steward_seed})
steward_did, steward_verkey = await did.create_and_store_my_did(
steward_wallet_handle, did_json)
print_log('Steward DID: ', steward_did)
print_log('Steward Verkey: ', steward_verkey)
# 6.
print_log(
'\n6. Generating and storing trust anchor (also issuer) DID and verkey\n'
)
trust_anchor_did, trust_anchor_verkey = await did.create_and_store_my_did(
issuer_wallet_handle, "{}")
print_log('Trust anchor DID: ', trust_anchor_did)
print_log('Trust anchor Verkey: ', trust_anchor_verkey)
# 7.
print_log(
'\n7. Building NYM request to add Trust Anchor to the ledger\n')
nym_transaction_request = await ledger.build_nym_request(
submitter_did=steward_did,
target_did=trust_anchor_did,
ver_key=trust_anchor_verkey,
alias=None,
role='TRUST_ANCHOR')
print_log('NYM transaction request: ')
pprint.pprint(json.loads(nym_transaction_request))
# 8.
print_log('\n8. Sending NYM request to the ledger\n')
nym_transaction_response = await ledger.sign_and_submit_request(
pool_handle=pool_handle,
wallet_handle=steward_wallet_handle,
submitter_did=steward_did,
request_json=nym_transaction_request)
print_log('NYM transaction response: ')
pprint.pprint(json.loads(nym_transaction_response))
# 9.
print_log('\n9. Issuer create Credential Schema\n')
schema = {
'name': 'gvt',
'version': '1.0',
'attributes': '["age", "sex", "height", "name"]'
}
issuer_schema_id, issuer_schema_json = await anoncreds.issuer_create_schema(
steward_did, schema['name'], schema['version'],
schema['attributes'])
print_log('Schema: ')
pprint.pprint(issuer_schema_json)
# 10.
print_log(
'\n10. Build the SCHEMA request to add new schema to the ledger\n')
schema_request = await ledger.build_schema_request(
steward_did, issuer_schema_json)
print_log('Schema request: ')
pprint.pprint(json.loads(schema_request))
# 11.
print_log('\n11. Sending the SCHEMA request to the ledger\n')
schema_response = \
await ledger.sign_and_submit_request(pool_handle,
steward_wallet_handle,
steward_did,
schema_request)
print_log('Schema response:')
pprint.pprint(json.loads(schema_response))
# 12.
print_log(
'\n12. Creating and storing Credential Definition using anoncreds as Trust Anchor, for the given Schema\n'
)
cred_def_tag = 'TAG1'
cred_def_type = 'CL'
cred_def_config = json.dumps({"support_revocation": False})
(cred_def_id, cred_def_json) = \
await anoncreds.issuer_create_and_store_credential_def(issuer_wallet_handle,
trust_anchor_did,
issuer_schema_json,
cred_def_tag,
cred_def_type,
cred_def_config)
print_log('Credential definition: ')
pprint.pprint(json.loads(cred_def_json))
# 13.
print_log(
'\n13. Creating Prover wallet and opening it to get the handle.\n')
prover_did = 'VsKV7grR1BUE29mG2Fm2kX'
prover_wallet_config = json.dumps({
"id": "prover_wallet",
"storage_config": {
"path": wallet_path
}
})
await wallet.create_wallet(prover_wallet_config, wallet_credentials)
prover_wallet_handle = await wallet.open_wallet(
prover_wallet_config, wallet_credentials)
# 14.
print_log('\n14. Prover is creating Link Secret\n')
prover_link_secret_name = 'link_secret'
link_secret_id = await anoncreds.prover_create_master_secret(
prover_wallet_handle, prover_link_secret_name)
# 15.
print_log(
'\n15. Issuer (Trust Anchor) is creating a Credential Offer for Prover\n'
)
cred_offer_json = await anoncreds.issuer_create_credential_offer(
issuer_wallet_handle, cred_def_id)
print_log('Credential Offer: ')
pprint.pprint(json.loads(cred_offer_json))
# 16.
print_log(
'\n16. Prover creates Credential Request for the given credential offer\n'
)
(cred_req_json, cred_req_metadata_json) = \
await anoncreds.prover_create_credential_req(prover_wallet_handle,
prover_did,
cred_offer_json,
cred_def_json,
prover_link_secret_name)
print_log('Credential Request: ')
pprint.pprint(json.loads(cred_req_json))
# 17.
print_log(
'\n17. Issuer (Trust Anchor) creates Credential for Credential Request\n'
)
cred_values_json = json.dumps({
"sex": {
"raw":
"male",
"encoded":
"5944657099558967239210949258394887428692050081607692519917050011144233"
},
"name": {
"raw": "Alex",
"encoded": "1139481716457488690172217916278103335"
},
"height": {
"raw": "175",
"encoded": "175"
},
"age": {
"raw": "28",
"encoded": "28"
}
})
(cred_json, _, _) = \
await anoncreds.issuer_create_credential(issuer_wallet_handle,
cred_offer_json,
cred_req_json,
cred_values_json, None, None)
print_log('Credential: ')
pprint.pprint(json.loads(cred_json))
# 18.
print_log('\n18. Prover processes and stores received Credential\n')
await anoncreds.prover_store_credential(prover_wallet_handle, None,
cred_req_metadata_json,
cred_json, cred_def_json, None)
# 19.
print_log('\n19. Prover gets Credentials for Proof Request\n')
proof_request = {
'nonce': '123432421212',
'name': 'proof_req_1',
'version': '0.1',
'requested_attributes': {
'attr1_referent': {
'name': 'name',
"restrictions": {
"issuer_did": trust_anchor_did,
"schema_id": issuer_schema_id
}
}
},
'requested_predicates': {
'predicate1_referent': {
'name': 'age',
'p_type': '>=',
'p_value': 18,
"restrictions": {
"issuer_did": trust_anchor_did
}
}
}
}
print_log('Proof Request: ')
pprint.pprint(proof_request)
# 20.
print_log(
'\n20. Prover gets Credentials for attr1_referent anf predicate1_referent\n'
)
proof_req_json = json.dumps(proof_request)
prover_cred_search_handle = \
await anoncreds.prover_search_credentials_for_proof_req(prover_wallet_handle, proof_req_json, None)
creds_for_attr1 = await anoncreds.prover_fetch_credentials_for_proof_req(
prover_cred_search_handle, 'attr1_referent', 1)
prover_cred_for_attr1 = json.loads(creds_for_attr1)[0]['cred_info']
print_log('Prover credential for attr1_referent: ')
pprint.pprint(prover_cred_for_attr1)
creds_for_predicate1 = await anoncreds.prover_fetch_credentials_for_proof_req(
prover_cred_search_handle, 'predicate1_referent', 1)
prover_cred_for_predicate1 = json.loads(
creds_for_predicate1)[0]['cred_info']
print_log('Prover credential for predicate1_referent: ')
pprint.pprint(prover_cred_for_predicate1)
await anoncreds.prover_close_credentials_search_for_proof_req(
prover_cred_search_handle)
# 21.
print_log('\n21. Prover creates Proof for Proof Request\n')
prover_requested_creds = json.dumps({
'self_attested_attributes': {},
'requested_attributes': {
'attr1_referent': {
'cred_id': prover_cred_for_attr1['referent'],
'revealed': True
}
},
'requested_predicates': {
'predicate1_referent': {
'cred_id': prover_cred_for_predicate1['referent']
}
}
})
print_log('Requested Credentials for Proving: ')
pprint.pprint(json.loads(prover_requested_creds))
prover_schema_id = json.loads(cred_offer_json)['schema_id']
schemas_json = json.dumps(
{prover_schema_id: json.loads(issuer_schema_json)})
cred_defs_json = json.dumps({cred_def_id: json.loads(cred_def_json)})
proof_json = await anoncreds.prover_create_proof(
prover_wallet_handle, proof_req_json, prover_requested_creds,
link_secret_id, schemas_json, cred_defs_json, "{}")
proof = json.loads(proof_json)
assert 'Alex' == proof['requested_proof']['revealed_attrs'][
'attr1_referent']["raw"]
# 22.
print_log('\n22. Verifier is verifying proof from Prover\n')
assert await anoncreds.verifier_verify_proof(proof_req_json,
proof_json, schemas_json,
cred_defs_json, "{}",
"{}")
# 23.
print_log('\n23. Closing both wallet_handles and pool\n')
await wallet.close_wallet(issuer_wallet_handle)
await wallet.close_wallet(prover_wallet_handle)
await wallet.close_wallet(steward_wallet_handle)
await pool.close_pool_ledger(pool_handle)
# 24.
print_log('\n24. Deleting created wallet_handles\n')
await wallet.delete_wallet(issuer_wallet_config, wallet_credentials)
await wallet.delete_wallet(prover_wallet_config, wallet_credentials)
await wallet.delete_wallet(steward_wallet_config, wallet_credentials)
# 25.
print_log('\n25. Deleting pool ledger config\n')
await pool.delete_pool_ledger_config(pool_name)
except IndyError as e:
print('Error occurred: %s' % e)
async def run():
print("\n")
logger.info(" NSUT connects to the running indy pool\n")
pool_name = 'pool1'
pool_genesis_txn_path = get_pool_genesis_txn_path(pool_name)
pool_config = json.dumps({"genesis_txn": str(pool_genesis_txn_path)})
# Set protocol version 2 NSUT work with Indy Node 1.4
await pool.set_protocol_version(PROTOCOL_VERSION)
try:
await pool.create_pool_ledger_config(pool_name, pool_config)
except IndyError as ex:
if ex.error_code == ErrorCode.PoolLedgerConfigAlreadyExistsError:
pass
pool_handle = await pool.open_pool_ledger(pool_name, None)
logger.info(" ==============================")
logger.info(" == \"NSUT\" creates a wallet to store its credentials ==")
logger.info(" ------------------------------\n")
NSUT_wallet_config = json.dumps({"id": "NSUT_wallet"})
NSUT_wallet_credentials = json.dumps({"key": "NSUT_wallet_key"})
try:
await wallet.create_wallet(NSUT_wallet_config, NSUT_wallet_credentials)
except IndyError as ex:
if ex.error_code == ErrorCode.WalletAlreadyExistsError:
pass
NSUT_wallet = await wallet.open_wallet(NSUT_wallet_config,
NSUT_wallet_credentials)
logger.info(" ==============================")
logger.info(" == \"NSUT\" opens its wallet ==")
logger.info(" ------------------------------\n")
logger.info(
" \"NSUT\" -> Creates and stores \"NSUT-Steward DID\"(serves as an id of NSUT for its relation with the steward.\n"
)
(NSUT_steward_did,
NSUT_steward_key) = await did.create_and_store_my_did(NSUT_wallet, "{}")
logger.info(
" \"NSUT\" -> Gets the verification key for Steward's DID from connection request sent by the \"Steward\" \n"
)
fname = "connectionReqStewardNSUT.txt"
with open(fname, 'r') as f:
connection_request = eval(f.readline())
steward_NSUT_verkey = await did.key_for_did(pool_handle, NSUT_wallet,
connection_request['did'])
logger.info(
" \"NSUT\" -> Anoncrypts the connection response for Steward with \"NSUT-Steward\" DID, verkey and nonce using verification key of the steward\n"
)
'''connection_response = json.dumps({
'did': NSUT_steward_did,
'verkey': NSUT_steward_key,
'nonce': connection_request['nonce']
})'''
anoncrypted_connection_response = {
'did': NSUT_steward_did,
'verkey': NSUT_steward_key,
'nonce': connection_request['nonce']
}
#anoncrypted_connection_response = await crypto.anon_crypt(steward_NSUT_verkey, connection_response.encode('utf-8'))
logger.info(
"\"NSUT\" -> Sends anoncrypted connection response to the \"Steward\"\n\n"
)
fname = "connectionRespNSUTSteward.txt"
with open(fname, 'w') as f:
f.write(str(anoncrypted_connection_response))
async def demo():
logger.info("Agent sample -> started")
pool_name = 'pool1'
listener_wallet_name = 'listener_wallet'
sender_wallet_name = 'sender_wallet'
seed_trustee1 = "000000000000000000000000Trustee1"
endpoint = '127.0.0.1:9700'
pool_genesis_txn_path = get_pool_genesis_txn_path(pool_name)
# 1. Create ledger config from genesis txn file
pool_config = json.dumps({"genesis_txn": str(pool_genesis_txn_path)})
await pool.create_pool_ledger_config(pool_name, pool_config)
# 2. Open pool ledger
pool_handle = await pool.open_pool_ledger(pool_name, None)
# 3. Create and Open Listener Wallet. Gets wallet handle
await wallet.create_wallet(pool_name, listener_wallet_name, None, None,
None)
listener_wallet_handle = await wallet.open_wallet(listener_wallet_name,
None, None)
# 4. Create and Open Sender Wallet. Gets wallet handle
await wallet.create_wallet(pool_name, sender_wallet_name, None, None, None)
sender_wallet_handle = await wallet.open_wallet(sender_wallet_name, None,
None)
# 5. Create Listener DID
(listener_did, listener_verkey,
listener_pk) = await signus.create_and_store_my_did(
listener_wallet_handle, "{}")
# 6. Create Sender DID from Trustee1 seed
(sender_did, sender_verkey, sender_pk) = \
await signus.create_and_store_my_did(sender_wallet_handle, json.dumps({"seed": seed_trustee1}))
# 7. Prepare and send NYM transaction
nym_txn_req = await ledger.build_nym_request(sender_did, listener_did,
listener_verkey, None, None)
await ledger.sign_and_submit_request(pool_handle, sender_wallet_handle,
sender_did, nym_txn_req)
# 8. Prepare and send Attrib request
raw = json.dumps({"endpoint": {"ha": endpoint, "verkey": listener_pk}})
attrib_txn_req = await ledger.build_attrib_request(listener_did,
listener_did, None, raw,
None)
await ledger.sign_and_submit_request(pool_handle, listener_wallet_handle,
listener_did, attrib_txn_req)
# 9. Start listener on endpoint
listener_handle = await agent.agent_listen(endpoint)
# 10. Allow listener accept incoming connection for specific DID (listener_did)
await agent.agent_add_identity(listener_handle, pool_handle,
listener_wallet_handle, listener_did)
# 11. Initiate connection from sender to listener
connection_handle = await agent.agent_connect(pool_handle,
sender_wallet_handle,
sender_did, listener_did)
event = await agent.agent_wait_for_event([listener_handle]
) # type: agent.ConnectionEvent
inc_con_handle = event.connection_handle
# 12. Send test message from sender to listener
message = 'msg_from_sender_to_listener'
await agent.agent_send(connection_handle, message)
message_event = await agent.agent_wait_for_event(
[listener_handle, inc_con_handle]) # type: agent.MessageEvent
assert message_event.message == message
# 13. Close connection, listener, wallets, pool
await agent.agent_close_listener(listener_handle)
await agent.agent_close_connection(connection_handle)
# 14. Close wallets
await wallet.close_wallet(listener_wallet_handle)
await wallet.close_wallet(sender_wallet_handle)
# 15. Close pool
await pool.close_pool_ledger(pool_handle)
# 16. Delete wallets
await wallet.delete_wallet(listener_wallet_name, None)
await wallet.delete_wallet(sender_wallet_name, None)
# 17. Delete pool ledger config
await pool.delete_pool_ledger_config(pool_name)
logger.info("Agent sample -> completed")
async def demo():
logger.info("Ledger sample -> started")
# Set protocol version 2 to work with Indy Node 1.4
await pool.set_protocol_version(PROTOCOL_VERSION)
trustee = {
'seed': '000000000000000000000000Trustee1',
'wallet_config': json.dumps({'id': 'trustee_wallet'}),
'wallet_credentials': json.dumps({'key': 'trustee_wallet_key'}),
'pool_name': 'trustee_pool',
}
# 1. Trustee open pool ledger
trustee['genesis_txn_path'] = get_pool_genesis_txn_path(trustee['pool_name'])
trustee['pool_config'] = json.dumps({"genesis_txn": str(trustee['genesis_txn_path'])})
await pool.create_pool_ledger_config(trustee['pool_name'], trustee['pool_config'])
trustee['pool'] = await pool.open_pool_ledger(trustee['pool_name'], None)
# 2. Create Trustee Wallet and Get Wallet Handle
await wallet.create_wallet(trustee['wallet_config'], trustee['wallet_credentials'])
trustee['wallet'] = await wallet.open_wallet(trustee['wallet_config'], trustee['wallet_credentials'])
# 3. Create Trustee DID
(trustee['did'], trustee['verkey']) = \
await did.create_and_store_my_did(trustee['wallet'], json.dumps({"seed": trustee['seed']}))
# 4. User init
user = {
'wallet_config': json.dumps({'id': 'user_wallet'}),
'wallet_credentials': json.dumps({'key': 'user_wallet_key'}),
'pool_name': 'user_pool'
}
user['genesis_txn_path'] = get_pool_genesis_txn_path(user['pool_name'])
user['pool_config'] = json.dumps({"genesis_txn": str(user['genesis_txn_path'])})
await pool.create_pool_ledger_config(user['pool_name'], user['pool_config'])
user['pool'] = await pool.open_pool_ledger(user['pool_name'], None)
await wallet.create_wallet(user['wallet_config'], user['wallet_credentials'])
user['wallet'] = await wallet.open_wallet(user['wallet_config'], user['wallet_credentials'])
# 5. User create DID
(user['did'], user['verkey']) = await did.create_and_store_my_did(user['wallet'], "{}")
trustee['user_did'] = user['did']
trustee['user_verkey'] = user['verkey']
# 6. Trustee prepare and send NYM transaction for user
nym_req = await ledger.build_nym_request(trustee['did'], trustee['user_did'], trustee['user_verkey'], None, None)
await ledger.sign_and_submit_request(trustee['pool'], trustee['wallet'], trustee['did'], nym_req)
# 7. User send ATTRIB transaction to Ledger
attr_req = \
await ledger.build_attrib_request(user['did'], user['did'], None, '{"endpoint":{"ha":"127.0.0.1:5555"}}', None)
resp = await ledger.sign_and_submit_request(user['pool'], user['wallet'], user['did'], attr_req)
assert json.loads(resp)['op'] == 'REPLY'
# 8. Close and delete Trustee wallet
await wallet.close_wallet(trustee['wallet'])
await wallet.delete_wallet(trustee['wallet_config'], trustee['wallet_credentials'])
# 9. Close and delete User wallet
await wallet.close_wallet(user['wallet'])
await wallet.delete_wallet(user['wallet_config'], user['wallet_credentials'])
# 10. Close Trustee and User pools
await pool.close_pool_ledger(trustee['pool'])
await pool.close_pool_ledger(user['pool'])
# 11 Delete pool ledger config
await pool.delete_pool_ledger_config(trustee['pool_name'])
await pool.delete_pool_ledger_config(user['pool_name'])
logger.info("Ledger sample -> completed")
async def demo():
logger.info("Ledger sample -> started")
pool_name = 'pool1'
my_wallet_name = 'my_wallet'
their_wallet_name = 'their_wallet'
seed_trustee1 = "000000000000000000000000Trustee1"
pool_genesis_txn_path = get_pool_genesis_txn_path(pool_name)
# 1. Create ledger config from genesis txn file
pool_config = json.dumps({"genesis_txn": str(pool_genesis_txn_path)})
await pool.create_pool_ledger_config(pool_name, pool_config)
# 2. Open pool ledger
pool_handle = await pool.open_pool_ledger(pool_name, None)
# 3. Create My Wallet and Get Wallet Handle
await wallet.create_wallet(pool_name, my_wallet_name, None, None, None)
my_wallet_handle = await wallet.open_wallet(my_wallet_name, None, None)
# 4. Create Their Wallet and Get Wallet Handle
await wallet.create_wallet(pool_name, their_wallet_name, None, None, None)
their_wallet_handle = await wallet.open_wallet(their_wallet_name, None,
None)
# 5. Create My DID
(my_did,
my_verkey) = await signus.create_and_store_my_did(my_wallet_handle, "{}")
# 6. Create Their DID from Trustee1 seed
(their_did, their_verkey) = \
await signus.create_and_store_my_did(their_wallet_handle, json.dumps({"seed": seed_trustee1}))
# 7. Store Their DID
their_identity_json = json.dumps({
'did': their_did,
'verkey': their_verkey
})
await signus.store_their_did(my_wallet_handle, their_identity_json)
# 8. Prepare and send NYM transaction
nym_txn_req = await ledger.build_nym_request(their_did, my_did, None, None,
None)
await ledger.sign_and_submit_request(pool_handle, their_wallet_handle,
their_did, nym_txn_req)
# 9. Prepare and send GET_NYM request
get_nym_txn_req = await ledger.build_get_nym_request(their_did, my_did)
get_nym_txn_resp = await ledger.submit_request(pool_handle,
get_nym_txn_req)
get_nym_txn_resp = json.loads(get_nym_txn_resp)
assert get_nym_txn_resp['result']['dest'] == my_did
# 10. Close wallets and pool
await wallet.close_wallet(their_wallet_handle)
await wallet.close_wallet(my_wallet_handle)
await pool.close_pool_ledger(pool_handle)
# 11. Delete wallets
await wallet.delete_wallet(my_wallet_name, None)
await wallet.delete_wallet(their_wallet_name, None)
# 12. Delete pool ledger config
await pool.delete_pool_ledger_config(pool_name)
logger.info("Ledger sample -> completed")
async def run():
logger.info("Getting started -> started")
logger.info("Open Pool Ledger")
pool_name = 'pool1'
pool_genesis_txn_path = get_pool_genesis_txn_path(pool_name)
pool_config = json.dumps({"genesis_txn": str(pool_genesis_txn_path)})
await pool.create_pool_ledger_config(pool_name, pool_config)
pool_handle = await pool.open_pool_ledger(pool_name, None)
logger.info("==============================")
logger.info("=== Getting Trust Anchor credentials for Faber, Acme, Thrift and Government ==")
logger.info("------------------------------")
logger.info("\"Sovrin Steward\" -> Create wallet")
steward_wallet_name = 'sovrin_steward_wallet'
await wallet.create_wallet(pool_name, steward_wallet_name, None, None, None)
steward_wallet = await wallet.open_wallet(steward_wallet_name, None, None)
logger.info("\"Sovrin Steward\" -> Create and store in Wallet DID from seed")
steward_did_info = {'seed': '000000000000000000000000Steward1'}
(steward_did, steward_key) = await did.create_and_store_my_did(steward_wallet, json.dumps(steward_did_info))
logger.info("==============================")
logger.info("== Getting Trust Anchor credentials - Government Onboarding ==")
logger.info("------------------------------")
government_wallet, government_wallet_name, steward_government_key, government_steward_did, government_steward_key, _ \
= await onboarding(pool_handle, pool_name, "Sovrin Steward", steward_wallet,
steward_did, "Government", None, 'government_wallet')
logger.info("==============================")
logger.info("== Getting Trust Anchor credentials - Government getting Verinym ==")
logger.info("------------------------------")
government_did = await get_verinym(pool_handle, "Sovrin Steward", steward_wallet, steward_did,
steward_government_key, "Government", government_wallet, government_steward_did,
government_steward_key, 'TRUST_ANCHOR')
logger.info("==============================")
logger.info("== Getting Trust Anchor credentials - Faber Onboarding ==")
logger.info("------------------------------")
faber_wallet, faber_wallet_name, steward_faber_key, faber_steward_did, faber_steward_key, _ = \
await onboarding(pool_handle, pool_name, "Sovrin Steward", steward_wallet, steward_did,
"Faber", None, 'faber_wallet')
logger.info("==============================")
logger.info("== Getting Trust Anchor credentials - Faber getting Verinym ==")
logger.info("------------------------------")
faber_did = await get_verinym(pool_handle, "Sovrin Steward", steward_wallet, steward_did, steward_faber_key,
"Faber", faber_wallet, faber_steward_did, faber_steward_key, 'TRUST_ANCHOR')
logger.info("==============================")
logger.info("== Getting Trust Anchor credentials - Acme Onboarding ==")
logger.info("------------------------------")
acme_wallet, acme_wallet_name, steward_acme_key, acme_steward_did, acme_steward_key, _ = \
await onboarding(pool_handle, pool_name, "Sovrin Steward", steward_wallet, steward_did,
"Acme", None, 'acme_wallet')
logger.info("==============================")
logger.info("== Getting Trust Anchor credentials - Acme getting Verinym ==")
logger.info("------------------------------")
acme_did = await get_verinym(pool_handle, "Sovrin Steward", steward_wallet, steward_did, steward_acme_key,
"Acme", acme_wallet, acme_steward_did, acme_steward_key, 'TRUST_ANCHOR')
logger.info("==============================")
logger.info("== Getting Trust Anchor credentials - Thrift Onboarding ==")
logger.info("------------------------------")
thrift_wallet, thrift_wallet_name, steward_thrift_key, thrift_steward_did, thrift_steward_key, _ = \
await onboarding(pool_handle, pool_name, "Sovrin Steward", steward_wallet, steward_did,
"Thrift", None, ' thrift_wallet')
logger.info("==============================")
logger.info("== Getting Trust Anchor credentials - Thrift getting Verinym ==")
logger.info("------------------------------")
thrift_did = await get_verinym(pool_handle, "Sovrin Steward", steward_wallet, steward_did, steward_thrift_key,
"Thrift", thrift_wallet, thrift_steward_did, thrift_steward_key, 'TRUST_ANCHOR')
logger.info("==============================")
logger.info("=== Claim Schemas Setup ==")
logger.info("------------------------------")
logger.info("\"Government\" -> Create and store in Wallet \"Government Issuer\" DID")
(government_issuer_did, government_issuer_key) = await did.create_and_store_my_did(government_wallet, "{}")
logger.info("\"Government\" -> Send Nym to Ledger for \"Government Issuer\" DID")
await send_nym(pool_handle, government_wallet, government_did, government_issuer_did, government_issuer_key, None)
logger.info("\"Government\" -> Send to Ledger \"Job-Certificate\" Schema")
job_certificate_schema = {
'name': 'Job-Certificate',
'version': '0.2',
'attr_names': ['first_name', 'last_name', 'salary', 'employee_status', 'experience']
}
job_certificate_schema_key = {
'name': job_certificate_schema['name'],
'version': job_certificate_schema['version'],
'did': government_issuer_did
}
await send_schema(pool_handle, government_wallet, government_issuer_did, job_certificate_schema)
logger.info("\"Government\" -> Send to Ledger \"Transcript\" Schema")
transcript_schema = {
'name': 'Transcript',
'version': '1.2',
'attr_names': ['first_name', 'last_name', 'degree', 'status', 'year', 'average', 'ssn']
}
transcript_schema_key = {
'name': transcript_schema['name'],
'version': transcript_schema['version'],
'did': government_issuer_did
}
await send_schema(pool_handle, government_wallet, government_issuer_did, transcript_schema)
logger.info("==============================")
logger.info("=== Faber Claim Definition Setup ==")
logger.info("------------------------------")
logger.info("\"Faber\" -> Create and store in Wallet \"Faber Issuer\" DID")
(faber_issuer_did, faber_issuer_key) = await did.create_and_store_my_did(faber_wallet, "{}")
logger.info("\"Faber\" -> Send Nym to Ledger for \"Faber Issuer\" DID")
await send_nym(pool_handle, faber_wallet, faber_did, faber_issuer_did, faber_issuer_key, None)
logger.info("\"Faber\" -> Get \"Transcript\" Schema from Ledger")
transcript_schema = await get_schema(pool_handle, faber_issuer_did, transcript_schema_key)
logger.info("\"Faber\" -> Create and store in Wallet \"Faber Transcript\" Claim Definition")
faber_transcript_claim_def_json = \
await anoncreds.issuer_create_and_store_claim_def(faber_wallet, faber_issuer_did,
json.dumps(transcript_schema), 'CL', False)
logger.info("\"Faber\" -> Send ClaimDef to Ledger for \"Faber Transcript\" Claim Definition")
await send_claim_def(pool_handle, faber_wallet, faber_issuer_did, faber_transcript_claim_def_json)
logger.info("==============================")
logger.info("=== Acme Claim Definition Setup ==")
logger.info("------------------------------")
logger.info("\"Acme\" -> Create and store in Wallet \"Acme Issuer\" DID")
(acme_issuer_did, acme_issuer_key) = await did.create_and_store_my_did(acme_wallet, "{}")
logger.info("\"Acme\" -> Send Nym to Ledger for \"Acme Issuer\" DID")
await send_nym(pool_handle, acme_wallet, acme_did, acme_issuer_did, acme_issuer_key, None)
logger.info("\"Acme\" -> Get from Ledger \"Job-Certificate\" Schema")
job_certificate_schema = await get_schema(pool_handle, acme_issuer_did, job_certificate_schema_key)
logger.info("\"Acme\" -> Create and store in Wallet \"Acme Job-Certificate\" Claim Definition")
acme_job_certificate_claim_def_json = \
await anoncreds.issuer_create_and_store_claim_def(acme_wallet, acme_issuer_did,
json.dumps(job_certificate_schema), 'CL', False)
logger.info("\"Acme\" -> Send ClaimDef to Ledger for \"Acme Job-Certificate\" Claim Definition")
await send_claim_def(pool_handle, acme_wallet, acme_issuer_did, acme_job_certificate_claim_def_json)
logger.info("==============================")
logger.info("=== Getting Transcript with Faber ==")
logger.info("==============================")
logger.info("== Getting Transcript with Faber - Onboarding ==")
logger.info("------------------------------")
alice_wallet, alice_wallet_name, faber_alice_key, alice_faber_did, alice_faber_key, faber_alice_connection_response \
= await onboarding(pool_handle, pool_name, "Faber", faber_wallet, faber_did, "Alice", None, ' alice_wallet')
logger.info("==============================")
logger.info("== Getting Transcript with Faber - Getting Transcript Claim ==")
logger.info("------------------------------")
logger.info("\"Faber\" -> Create \"Transcript\" Claim Offer for Alice")
transcript_claim_offer_json = \
await anoncreds.issuer_create_claim_offer(faber_wallet, json.dumps(transcript_schema),
faber_issuer_did, alice_faber_did)
logger.info("\"Faber\" -> Get key for Alice did")
alice_faber_verkey = await did.key_for_did(pool_handle, acme_wallet, faber_alice_connection_response['did'])
logger.info("\"Faber\" -> Authcrypt \"Transcript\" Claim Offer for Alice")
authcrypted_transcript_claim_offer = await crypto.auth_crypt(faber_wallet, faber_alice_key, alice_faber_verkey,
transcript_claim_offer_json.encode('utf-8'))
logger.info("\"Faber\" -> Send authcrypted \"Transcript\" Claim Offer to Alice")
logger.info("\"Alice\" -> Authdecrypted \"Transcript\" Claim Offer from Faber")
faber_alice_verkey, authdecrypted_transcript_claim_offer_json, authdecrypted_transcript_claim_offer = \
await auth_decrypt(alice_wallet, alice_faber_key, authcrypted_transcript_claim_offer)
logger.info("\"Alice\" -> Store \"Transcript\" Claim Offer in Wallet from Faber")
await anoncreds.prover_store_claim_offer(alice_wallet, authdecrypted_transcript_claim_offer_json)
logger.info("\"Alice\" -> Create and store \"Alice\" Master Secret in Wallet")
alice_master_secret_name = 'alice_master_secret'
await anoncreds.prover_create_master_secret(alice_wallet, alice_master_secret_name)
logger.info("\"Alice\" -> Get \"Transcript\" Schema from Ledger")
transcript_schema = await get_schema(pool_handle, alice_faber_did,
authdecrypted_transcript_claim_offer['schema_key'])
logger.info("\"Alice\" -> Get \"Faber Transcript\" Claim Definition from Ledger")
faber_transcript_claim_def = await get_claim_def(pool_handle, alice_faber_did, transcript_schema,
authdecrypted_transcript_claim_offer['issuer_did'])
logger.info("\"Alice\" -> Create and store in Wallet \"Transcript\" Claim Request for Faber")
transcript_claim_request_json = \
await anoncreds.prover_create_and_store_claim_req(alice_wallet, alice_faber_did,
authdecrypted_transcript_claim_offer_json,
json.dumps(faber_transcript_claim_def),
alice_master_secret_name)
logger.info("\"Alice\" -> Authcrypt \"Transcript\" Claim Request for Faber")
authcrypted_transcript_claim_request = await crypto.auth_crypt(alice_wallet, alice_faber_key, faber_alice_verkey,
transcript_claim_request_json.encode('utf-8'))
logger.info("\"Alice\" -> Send authcrypted \"Transcript\" Claim Request to Faber")
logger.info("\"Faber\" -> Authdecrypt \"Transcript\" Claim Request from Alice")
alice_faber_verkey, authdecrypted_transcript_claim_request_json, _ = \
await auth_decrypt(faber_wallet, faber_alice_key, authcrypted_transcript_claim_request)
logger.info("\"Faber\" -> Create \"Transcript\" Claim for Alice")
transcript_claim_values = json.dumps({
'first_name': ['Alice', '1139481716457488690172217916278103335'],
'last_name': ['Garcia', '5321642780241790123587902456789123452'],
'degree': ['Bachelor of Science, Marketing', '12434523576212321'],
'status': ['graduated', '2213454313412354'],
'ssn': ['123-45-6789', '3124141231422543541'],
'year': ['2015', '2015'],
'average': ['5', '5']
})
_, transcript_claim_json = \
await anoncreds.issuer_create_claim(faber_wallet, authdecrypted_transcript_claim_request_json,
transcript_claim_values, -1)
logger.info("\"Faber\" -> Authcrypt \"Transcript\" Claim for Alice")
authcrypted_transcript_claim_json = await crypto.auth_crypt(faber_wallet, faber_alice_key, alice_faber_verkey,
transcript_claim_json.encode('utf-8'))
logger.info("\"Faber\" -> Send authcrypted \"Transcript\" Claim to Alice")
logger.info("\"Alice\" -> Authdecrypted \"Transcript\" Claim from Faber")
_, authdecrypted_transcript_claim_json, _ = \
await auth_decrypt(alice_wallet, alice_faber_key, authcrypted_transcript_claim_json)
logger.info("\"Alice\" -> Store \"Transcript\" Claim from Faber")
await anoncreds.prover_store_claim(alice_wallet, authdecrypted_transcript_claim_json, None)
logger.info("==============================")
logger.info("=== Apply for the job with Acme ==")
logger.info("==============================")
logger.info("== Apply for the job with Acme - Onboarding ==")
logger.info("------------------------------")
alice_wallet, alice_wallet_name, acme_alice_key, alice_acme_did, alice_acme_key, acme_alice_connection_response = \
await onboarding(pool_handle, pool_name, "Acme", acme_wallet, acme_did, "Alice", alice_wallet, ' alice_wallet')
logger.info("==============================")
logger.info("== Apply for the job with Acme - Transcript proving ==")
logger.info("------------------------------")
logger.info("\"Acme\" -> Create \"Job-Application\" Proof Request")
job_application_proof_request_json = json.dumps({
'nonce': '1432422343242122312411212',
'name': 'Job-Application',
'version': '0.1',
'requested_attrs': {
'attr1_referent': {
'name': 'first_name'
},
'attr2_referent': {
'name': 'last_name'
},
'attr3_referent': {
'name': 'degree',
'restrictions': [{'issuer_did': faber_issuer_did, 'schema_key': transcript_schema_key}]
},
'attr4_referent': {
'name': 'status',
'restrictions': [{'issuer_did': faber_issuer_did, 'schema_key': transcript_schema_key}]
},
'attr5_referent': {
'name': 'ssn',
'restrictions': [{'issuer_did': faber_issuer_did, 'schema_key': transcript_schema_key}]
},
'attr6_referent': {
'name': 'phone_number'
}
},
'requested_predicates': {
'predicate1_referent': {
'attr_name': 'average',
'p_type': '>=',
'value': 4,
'restrictions': [{'issuer_did': faber_issuer_did, 'schema_key': transcript_schema_key}]
}
}
})
logger.info("\"Acme\" -> Get key for Alice did")
alice_acme_verkey = await did.key_for_did(pool_handle, acme_wallet, acme_alice_connection_response['did'])
logger.info("\"Acme\" -> Authcrypt \"Job-Application\" Proof Request for Alice")
authcrypted_job_application_proof_request_json = \
await crypto.auth_crypt(acme_wallet, acme_alice_key, alice_acme_verkey,
job_application_proof_request_json.encode('utf-8'))
logger.info("\"Acme\" -> Send authcrypted \"Job-Application\" Proof Request to Alice")
logger.info("\"Alice\" -> Authdecrypt \"Job-Application\" Proof Request from Acme")
acme_alice_verkey, authdecrypted_job_application_proof_request_json, _ = \
await auth_decrypt(alice_wallet, alice_acme_key, authcrypted_job_application_proof_request_json)
logger.info("\"Alice\" -> Get claims for \"Job-Application\" Proof Request")
claims_for_job_application_proof_request = json.loads(
await anoncreds.prover_get_claims_for_proof_req(alice_wallet, authdecrypted_job_application_proof_request_json))
claim_for_attr1 = claims_for_job_application_proof_request['attrs']['attr1_referent'][0]
claim_for_attr2 = claims_for_job_application_proof_request['attrs']['attr2_referent'][0]
claim_for_attr3 = claims_for_job_application_proof_request['attrs']['attr3_referent'][0]
claim_for_attr4 = claims_for_job_application_proof_request['attrs']['attr4_referent'][0]
claim_for_attr5 = claims_for_job_application_proof_request['attrs']['attr5_referent'][0]
claim_for_predicate1 = claims_for_job_application_proof_request['predicates']['predicate1_referent'][0]
claims_for_job_application_proof = {claim_for_attr1['referent']: claim_for_attr1,
claim_for_attr2['referent']: claim_for_attr2,
claim_for_attr3['referent']: claim_for_attr3,
claim_for_attr4['referent']: claim_for_attr4,
claim_for_attr5['referent']: claim_for_attr5,
claim_for_predicate1['referent']: claim_for_predicate1}
schemas_json, claim_defs_json, revoc_regs_json = \
await get_entities_from_ledger(pool_handle, alice_faber_did, claims_for_job_application_proof, 'Alice')
logger.info("\"Alice\" -> Create \"Job-Application\" Proof")
job_application_requested_claims_json = json.dumps({
'self_attested_attributes': {
'attr1_referent': 'Alice',
'attr2_referent': 'Garcia',
'attr6_referent': '123-45-6789'
},
'requested_attrs': {
'attr3_referent': [claim_for_attr3['referent'], True],
'attr4_referent': [claim_for_attr4['referent'], True],
'attr5_referent': [claim_for_attr5['referent'], True],
},
'requested_predicates': {'predicate1_referent': claim_for_predicate1['referent']}
})
job_application_proof_json = \
await anoncreds.prover_create_proof(alice_wallet, authdecrypted_job_application_proof_request_json,
job_application_requested_claims_json, schemas_json,
alice_master_secret_name, claim_defs_json, revoc_regs_json)
logger.info("\"Alice\" -> Authcrypt \"Job-Application\" Proof for Acme")
authcrypted_job_application_proof_json = await crypto.auth_crypt(alice_wallet, alice_acme_key, acme_alice_verkey,
job_application_proof_json.encode('utf-8'))
logger.info("\"Alice\" -> Send authcrypted \"Job-Application\" Proof to Acme")
logger.info("\"Acme\" -> Authdecrypted \"Job-Application\" Proof from Alice")
_, decrypted_job_application_proof_json, decrypted_job_application_proof = \
await auth_decrypt(acme_wallet, acme_alice_key, authcrypted_job_application_proof_json)
schemas_json, claim_defs_json, revoc_regs_json = \
await get_entities_from_ledger(pool_handle, acme_did, decrypted_job_application_proof['identifiers'], 'Acme')
logger.info("\"Acme\" -> Verify \"Job-Application\" Proof from Alice")
assert 'Bachelor of Science, Marketing' == \
decrypted_job_application_proof['requested_proof']['revealed_attrs']['attr3_referent'][1]
assert 'graduated' == \
decrypted_job_application_proof['requested_proof']['revealed_attrs']['attr4_referent'][1]
assert '123-45-6789' == \
decrypted_job_application_proof['requested_proof']['revealed_attrs']['attr5_referent'][1]
assert 'Alice' == decrypted_job_application_proof['requested_proof']['self_attested_attrs']['attr1_referent']
assert 'Garcia' == decrypted_job_application_proof['requested_proof']['self_attested_attrs']['attr2_referent']
assert '123-45-6789' == decrypted_job_application_proof['requested_proof']['self_attested_attrs']['attr6_referent']
assert await anoncreds.verifier_verify_proof(job_application_proof_request_json,
decrypted_job_application_proof_json,
schemas_json, claim_defs_json, revoc_regs_json)
logger.info("==============================")
logger.info("== Apply for the job with Acme - Getting Job-Certificate Claim ==")
logger.info("------------------------------")
logger.info("\"Acme\" -> Create \"Job-Certificate\" Claim Offer for Alice")
job_certificate_claim_offer_json = \
await anoncreds.issuer_create_claim_offer(acme_wallet, json.dumps(job_certificate_schema),
acme_issuer_did, alice_acme_did)
logger.info("\"Acme\" -> Get key for Alice did")
alice_acme_verkey = await did.key_for_did(pool_handle, acme_wallet, acme_alice_connection_response['did'])
logger.info("\"Acme\" -> Authcrypt \"Job-Certificate\" Claim Offer for Alice")
authcrypted_job_certificate_claim_offer = await crypto.auth_crypt(acme_wallet, acme_alice_key, alice_acme_verkey,
job_certificate_claim_offer_json.encode('utf-8'))
logger.info("\"Acme\" -> Send authcrypted \"Job-Certificate\" Claim Offer to Alice")
logger.info("\"Alice\" -> Authdecrypted \"Job-Certificate\" Claim Offer from Acme")
acme_alice_verkey, authdecrypted_job_certificate_claim_offer_json, authdecrypted_job_certificate_claim_offer = \
await auth_decrypt(alice_wallet, alice_acme_key, authcrypted_job_certificate_claim_offer)
logger.info("\"Alice\" -> Store \"Job-Certificate\" Claim Offer in Wallet")
await anoncreds.prover_store_claim_offer(alice_wallet, authdecrypted_job_certificate_claim_offer_json)
logger.info("\"Alice\" -> Get \"Job-Certificate\" Schema from Ledger")
job_certificate_schema = \
await get_schema(pool_handle, alice_acme_did, authdecrypted_job_certificate_claim_offer['schema_key'])
logger.info("\"Alice\" -> Get \"Acme Job-Certificate\" Claim Definition from Ledger")
acme_job_certificate_claim_def = await get_claim_def(pool_handle, alice_acme_did, job_certificate_schema,
authdecrypted_job_certificate_claim_offer['issuer_did'])
logger.info("\"Alice\" -> Create and store in Wallet \"Job-Certificate\" Claim Request for Acme")
job_certificate_claim_request_json = \
await anoncreds.prover_create_and_store_claim_req(alice_wallet, alice_acme_did,
authdecrypted_job_certificate_claim_offer_json,
json.dumps(acme_job_certificate_claim_def),
alice_master_secret_name)
logger.info("\"Alice\" -> Authcrypt \"Job-Certificate\" Claim Request for Acme")
authcrypted_job_certificate_claim_request_json = \
await crypto.auth_crypt(alice_wallet, alice_acme_key, acme_alice_verkey,
job_certificate_claim_request_json.encode('utf-8'))
logger.info("\"Alice\" -> Send authcrypted \"Job-Certificate\" Claim Request to Acme")
logger.info("\"Acme\" -> Authdecrypt \"Job-Certificate\" Claim Request from Alice")
alice_acme_verkey, authdecrypted_job_certificate_claim_request_json, _ = \
await auth_decrypt(acme_wallet, acme_alice_key, authcrypted_job_certificate_claim_request_json)
logger.info("\"Acme\" -> Create \"Job-Certificate\" Claim for Alice")
alice_job_certificate_claim_values_json = json.dumps({
'first_name': ['Alice', '245712572474217942457235975012103335'],
'last_name': ['Garcia', '312643218496194691632153761283356127'],
'employee_status': ['Permanent', '2143135425425143112321314321'],
'salary': ['2400', '2400'],
'experience': ['10', '10']
})
_, job_certificate_claim_json = \
await anoncreds.issuer_create_claim(acme_wallet, authdecrypted_job_certificate_claim_request_json,
alice_job_certificate_claim_values_json, -1)
logger.info("\"Acme\" -> Authcrypt \"Job-Certificate\" Claim for Alice")
authcrypted_job_certificate_claim_json = \
await crypto.auth_crypt(acme_wallet, acme_issuer_key, alice_acme_verkey,
job_certificate_claim_json.encode('utf-8'))
logger.info("\"Acme\" -> Send authcrypted \"Job-Certificate\" Claim to Alice")
logger.info("\"Alice\" -> Authdecrypted \"Job-Certificate\" Claim from Acme")
_, authdecrypted_job_certificate_claim_json, _ = \
await auth_decrypt(alice_wallet, alice_acme_key, authcrypted_job_certificate_claim_json)
logger.info("\"Alice\" -> Store \"Job-Certificate\" Claim")
await anoncreds.prover_store_claim(alice_wallet, authdecrypted_job_certificate_claim_json, None)
logger.info("==============================")
logger.info("=== Apply for the loan with Thrift ==")
logger.info("==============================")
logger.info("== Apply for the loan with Thrift - Onboarding ==")
logger.info("------------------------------")
alice_wallet, alice_wallet_name, thrift_alice_key, alice_thrift_did, alice_thrift_key, \
thrift_alice_connection_response = await onboarding(pool_handle, pool_name, "Thrift", thrift_wallet, thrift_did,
"Alice", alice_wallet, ' alice_wallet')
logger.info("==============================")
logger.info("== Apply for the loan with Thrift - Job-Certificate proving ==")
logger.info("------------------------------")
logger.info("\"Thrift\" -> Create \"Loan-Application-Basic\" Proof Request")
apply_loan_proof_request_json = json.dumps({
'nonce': '123432421212',
'name': 'Loan-Application-Basic',
'version': '0.1',
'requested_attrs': {
'attr1_referent': {
'name': 'employee_status',
'restrictions': [{'issuer_did': acme_issuer_did, 'schema_key': job_certificate_schema_key}]
}
},
'requested_predicates': {
'predicate1_referent': {
'attr_name': 'salary',
'p_type': '>=',
'value': 2000,
'restrictions': [{'issuer_did': acme_issuer_did, 'schema_key': job_certificate_schema_key}]
},
'predicate2_referent': {
'attr_name': 'experience',
'p_type': '>=',
'value': 1,
'restrictions': [{'issuer_did': acme_issuer_did, 'schema_key': job_certificate_schema_key}]
}
}
})
logger.info("\"Thrift\" -> Get key for Alice did")
alice_thrift_verkey = await did.key_for_did(pool_handle, thrift_wallet, thrift_alice_connection_response['did'])
logger.info("\"Thrift\" -> Authcrypt \"Loan-Application-Basic\" Proof Request for Alice")
authcrypted_apply_loan_proof_request_json = \
await crypto.auth_crypt(thrift_wallet, thrift_alice_key, alice_thrift_verkey,
apply_loan_proof_request_json.encode('utf-8'))
logger.info("\"Thrift\" -> Send authcrypted \"Loan-Application-Basic\" Proof Request to Alice")
logger.info("\"Alice\" -> Authdecrypt \"Loan-Application-Basic\" Proof Request from Thrift")
thrift_alice_verkey, authdecrypted_apply_loan_proof_request_json, _ = \
await auth_decrypt(alice_wallet, alice_thrift_key, authcrypted_apply_loan_proof_request_json)
logger.info("\"Alice\" -> Get claims for \"Loan-Application-Basic\" Proof Request")
claims_json_for_apply_loan_proof_request = \
await anoncreds.prover_get_claims_for_proof_req(alice_wallet, authdecrypted_apply_loan_proof_request_json)
claims_for_apply_loan_proof_request = json.loads(claims_json_for_apply_loan_proof_request)
claim_for_attr1 = claims_for_apply_loan_proof_request['attrs']['attr1_referent'][0]
claim_for_predicate1 = claims_for_apply_loan_proof_request['predicates']['predicate1_referent'][0]
claim_for_predicate2 = claims_for_apply_loan_proof_request['predicates']['predicate2_referent'][0]
claims_for_apply_loan_proof = {claim_for_attr1['referent']: claim_for_attr1,
claim_for_predicate1['referent']: claim_for_predicate1,
claim_for_predicate2['referent']: claim_for_predicate2}
schemas_json, claim_defs_json, revoc_regs_json = \
await get_entities_from_ledger(pool_handle, alice_thrift_did, claims_for_apply_loan_proof, 'Alice')
logger.info("\"Alice\" -> Create \"Loan-Application-Basic\" Proof")
apply_loan_requested_claims_json = json.dumps({
'self_attested_attributes': {},
'requested_attrs': {
'attr1_referent': [claim_for_attr1['referent'], True]
},
'requested_predicates': {
'predicate1_referent': claim_for_predicate1['referent'],
'predicate2_referent': claim_for_predicate2['referent']
}
})
alice_apply_loan_proof_json = \
await anoncreds.prover_create_proof(alice_wallet, authdecrypted_apply_loan_proof_request_json,
apply_loan_requested_claims_json, schemas_json, alice_master_secret_name,
claim_defs_json, revoc_regs_json)
logger.info("\"Alice\" -> Authcrypt \"Loan-Application-Basic\" Proof for Thrift")
authcrypted_alice_apply_loan_proof_json = \
await crypto.auth_crypt(alice_wallet, alice_thrift_key, thrift_alice_verkey,
alice_apply_loan_proof_json.encode('utf-8'))
logger.info("\"Alice\" -> Send authcrypted \"Loan-Application-Basic\" Proof to Thrift")
logger.info("\"Thrift\" -> Authdecrypted \"Loan-Application-Basic\" Proof from Alice")
_, authdecrypted_alice_apply_loan_proof_json, authdecrypted_alice_apply_loan_proof = \
await auth_decrypt(thrift_wallet, thrift_alice_key, authcrypted_alice_apply_loan_proof_json)
logger.info("\"Thrift\" -> Get Schemas, Claim Definitions and Revocation Registries from Ledger"
" required for Proof verifying")
schemas_json, claim_defs_json, revoc_regs_json = \
await get_entities_from_ledger(pool_handle, thrift_did,
authdecrypted_alice_apply_loan_proof['identifiers'], 'Thrift')
logger.info("\"Thrift\" -> Verify \"Loan-Application-Basic\" Proof from Alice")
assert 'Permanent' == authdecrypted_alice_apply_loan_proof['requested_proof']['revealed_attrs']['attr1_referent'][1]
assert await anoncreds.verifier_verify_proof(apply_loan_proof_request_json,
authdecrypted_alice_apply_loan_proof_json,
schemas_json, claim_defs_json, revoc_regs_json)
logger.info("==============================")
logger.info("==============================")
logger.info("== Apply for the loan with Thrift - Transcript and Job-Certificate proving ==")
logger.info("------------------------------")
logger.info("\"Thrift\" -> Create \"Loan-Application-KYC\" Proof Request")
apply_loan_kyc_proof_request_json = json.dumps({
'nonce': '123432421212',
'name': 'Loan-Application-KYC',
'version': '0.1',
'requested_attrs': {
'attr1_referent': {'name': 'first_name'},
'attr2_referent': {'name': 'last_name'},
'attr3_referent': {'name': 'ssn'}
},
'requested_predicates': {}
})
logger.info("\"Thrift\" -> Get key for Alice did")
alice_thrift_verkey = await did.key_for_did(pool_handle, thrift_wallet, thrift_alice_connection_response['did'])
logger.info("\"Thrift\" -> Authcrypt \"Loan-Application-KYC\" Proof Request for Alice")
authcrypted_apply_loan_kyc_proof_request_json = \
await crypto.auth_crypt(thrift_wallet, thrift_alice_key, alice_thrift_verkey,
apply_loan_kyc_proof_request_json.encode('utf-8'))
logger.info("\"Thrift\" -> Send authcrypted \"Loan-Application-KYC\" Proof Request to Alice")
logger.info("\"Alice\" -> Authdecrypt \"Loan-Application-KYC\" Proof Request from Thrift")
thrift_alice_verkey, authdecrypted_apply_loan_kyc_proof_request_json, _ = \
await auth_decrypt(alice_wallet, alice_thrift_key, authcrypted_apply_loan_kyc_proof_request_json)
logger.info("\"Alice\" -> Get claims for \"Loan-Application-KYC\" Proof Request")
claims_json_for_apply_loan_kyc_proof_request = \
await anoncreds.prover_get_claims_for_proof_req(alice_wallet, authdecrypted_apply_loan_kyc_proof_request_json)
claims_for_apply_loan_kyc_proof_request = json.loads(claims_json_for_apply_loan_kyc_proof_request)
claim_for_attr1 = claims_for_apply_loan_kyc_proof_request['attrs']['attr1_referent'][0]
claim_for_attr2 = claims_for_apply_loan_kyc_proof_request['attrs']['attr2_referent'][0]
claim_for_attr3 = claims_for_apply_loan_kyc_proof_request['attrs']['attr3_referent'][0]
claims_for_apply_loan_kyc_proof = {claim_for_attr1['referent']: claim_for_attr1,
claim_for_attr2['referent']: claim_for_attr2,
claim_for_attr3['referent']: claim_for_attr3}
schemas_json, claim_defs_json, revoc_regs_json = \
await get_entities_from_ledger(pool_handle, alice_thrift_did, claims_for_apply_loan_kyc_proof, 'Alice')
logger.info("\"Alice\" -> Create \"Loan-Application-KYC\" Proof")
apply_loan_kyc_requested_claims_json = json.dumps({
'self_attested_attributes': {},
'requested_attrs': {
'attr1_referent': [claim_for_attr1['referent'], True],
'attr2_referent': [claim_for_attr2['referent'], True],
'attr3_referent': [claim_for_attr3['referent'], True]
},
'requested_predicates': {}
})
alice_apply_loan_kyc_proof_json = \
await anoncreds.prover_create_proof(alice_wallet, authdecrypted_apply_loan_kyc_proof_request_json,
apply_loan_kyc_requested_claims_json, schemas_json,
alice_master_secret_name, claim_defs_json, revoc_regs_json)
logger.info("\"Alice\" -> Authcrypt \"Loan-Application-KYC\" Proof for Thrift")
authcrypted_alice_apply_loan_kyc_proof_json = \
await crypto.auth_crypt(alice_wallet, alice_thrift_key, thrift_alice_verkey,
alice_apply_loan_kyc_proof_json.encode('utf-8'))
logger.info("\"Alice\" -> Send authcrypted \"Loan-Application-KYC\" Proof to Thrift")
logger.info("\"Thrift\" -> Authdecrypted \"Loan-Application-KYC\" Proof from Alice")
_, authdecrypted_alice_apply_loan_kyc_proof_json, authdecrypted_alice_apply_loan_kyc_proof = \
await auth_decrypt(thrift_wallet, thrift_alice_key, authcrypted_alice_apply_loan_kyc_proof_json)
logger.info("\"Thrift\" -> Get Schemas, Claim Definitions and Revocation Registries from Ledger"
" required for Proof verifying")
schemas_json, claim_defs_json, revoc_regs_json = \
await get_entities_from_ledger(pool_handle, thrift_did,
authdecrypted_alice_apply_loan_kyc_proof['identifiers'], 'Thrift')
logger.info("\"Thrift\" -> Verify \"Loan-Application-KYC\" Proof from Alice")
assert 'Alice' == authdecrypted_alice_apply_loan_kyc_proof['requested_proof']['revealed_attrs']['attr1_referent'][1]
assert 'Garcia' == \
authdecrypted_alice_apply_loan_kyc_proof['requested_proof']['revealed_attrs']['attr2_referent'][1]
assert '123-45-6789' == \
authdecrypted_alice_apply_loan_kyc_proof['requested_proof']['revealed_attrs']['attr3_referent'][1]
assert await anoncreds.verifier_verify_proof(apply_loan_kyc_proof_request_json,
authdecrypted_alice_apply_loan_kyc_proof_json,
schemas_json, claim_defs_json, revoc_regs_json)
logger.info("==============================")
logger.info(" \"Sovrin Steward\" -> Close and Delete wallet")
await wallet.close_wallet(steward_wallet)
await wallet.delete_wallet(steward_wallet_name, None)
logger.info("\"Government\" -> Close and Delete wallet")
await wallet.close_wallet(government_wallet)
await wallet.delete_wallet(government_wallet_name, None)
logger.info("\"Faber\" -> Close and Delete wallet")
await wallet.close_wallet(faber_wallet)
await wallet.delete_wallet(faber_wallet_name, None)
logger.info("\"Acme\" -> Close and Delete wallet")
await wallet.close_wallet(acme_wallet)
await wallet.delete_wallet(acme_wallet_name, None)
logger.info("\"Thrift\" -> Close and Delete wallet")
await wallet.close_wallet(thrift_wallet)
await wallet.delete_wallet(thrift_wallet_name, None)
logger.info("\"Alice\" -> Close and Delete wallet")
await wallet.close_wallet(alice_wallet)
await wallet.delete_wallet(alice_wallet_name, None)
logger.info("Close and Delete pool")
await pool.close_pool_ledger(pool_handle)
await pool.delete_pool_ledger_config(pool_name)
logger.info("Getting started -> done")
async def run():
bash_command = "bash refresh.sh"
process = subprocess.Popen(bash_command.split(), stdout=subprocess.PIPE)
output, error = process.communicate()
logger.info("Code Started -> started")
pool_name = 'pool1'
logger.info("Open Pool Ledger: {}".format(pool_name))
pool_genesis_txn_path = get_pool_genesis_txn_path(pool_name)
pool_config = json.dumps({"genesis_txn": str(pool_genesis_txn_path)})
#Set protocol version 2
await pool.set_protocol_version(PROTOCOL_VERSION)
try:
await pool.create_pool_ledger_config(pool_name, pool_config)
except IndyError as ex:
if ex.error_code == ErrorCode.PoolLedgerConfigAlreadyExistsError:
pass
pool_handle = await pool.open_pool_ledger(pool_name, None)
logger.info("==========================================================================")
logger.info("== Getting Trust Anchor credentials for CUET(Chittagong University of Engineering & Technology),"
" BJIT Group, City Bank and Government ==")
logger.info("**************************************************************************")
logger.info("\"Bd Steward\" -> Create wallet")
steward_wallet_config = json.dumps({"id" : "bd_steward_wallet"})
steward_wallet_credentials = json.dumps({"key": "steward_wallet_key"})
try:
await wallet.create_wallet(steward_wallet_config, steward_wallet_credentials)
except IndyError as ex:
if ex.error_code == ErrorCode.WalletAlreadyExistsError:
pass
steward_wallet = await wallet.open_wallet(steward_wallet_config, steward_wallet_credentials)
logger.info("\"Bd Steward\" -> Create and store in Wallet DID from seed")
steward_did_info = {'seed': '000000000000000000000000Steward1'}
(steward_did, steward_key) = await did.create_and_store_my_did(steward_wallet, json.dumps(steward_did_info))
logger.info("==========================================================================")
logger.info("== Getting Trust Anchor credentials - Government Onboarding ==")
logger.info("**************************************************************************")
government_wallet_config = json.dumps({"id": "government_wallet"})
government_wallet_credentials = json.dumps({"key": "government_wallet_key"})
government_wallet, steward_government_key, government_steward_did, government_steward_key, _ \
= await onboarding(pool_handle, "Bd Steward", steward_wallet, steward_did, "Government", None,
government_wallet_config, government_wallet_credentials)
logger.info("==========================================================================")
logger.info("== Getting Trust Anchor credentials - Government getting Verinym ==")
logger.info("**************************************************************************")
government_did = await get_verinym(pool_handle, "Bd Steward", steward_wallet, steward_did,
steward_government_key, "Government", government_wallet, government_steward_did,
government_steward_key, 'TRUST_ANCHOR')
logger.info("==========================================================================")
logger.info("== Getting Trust Anchor credentials - CUET Onboarding ==")
logger.info("**************************************************************************")
cuet_wallet_config = json.dumps({"id": "cuet_wallet"})
cuet_wallet_credentials = json.dumps({"key": "cuet_wallet_key"})
cuet_wallet, steward_cuet_key, cuet_steward_did, cuet_steward_key, _ = \
await onboarding(pool_handle, "Bd Steward", steward_wallet, steward_did, "Cuet", None, cuet_wallet_config,
cuet_wallet_credentials)
logger.info("==========================================================================")
logger.info("== Getting Trust Anchor credentials - CUET getting Verinym ==")
logger.info("**************************************************************************")
cuet_did = await get_verinym(pool_handle, "Bd Steward", steward_wallet, steward_did, steward_cuet_key,
"Cuet", cuet_wallet, cuet_steward_did, cuet_steward_key, 'TRUST_ANCHOR')
logger.info("==========================================================================")
logger.info("== Getting Trust Anchor credentials - BJIT Onboarding ==")
logger.info("**************************************************************************")
bjit_wallet_config = json.dumps({"id": "bjit_wallet"})
bjit_wallet_credentials = json.dumps({"key": "bjit_wallet_key"})
bjit_wallet, steward_bjit_key, bjit_steward_did, bjit_steward_key, _ = \
await onboarding(pool_handle, "Bd Steward", steward_wallet, steward_did, "Bjit", None, bjit_wallet_config,
bjit_wallet_credentials)
logger.info("==========================================================================")
logger.info("== Getting Trust Anchor credentials - BJIT getting Verinym ==")
logger.info("**************************************************************************")
bjit_did = await get_verinym(pool_handle, "Bd Steward", steward_wallet, steward_did, steward_bjit_key,
"Bjit", bjit_wallet, bjit_steward_did, bjit_steward_key, 'TRUST_ANCHOR')
logger.info("==========================================================================")
logger.info("== Getting Trust Anchor credentials - City Onboarding ==")
logger.info("**************************************************************************")
city_wallet_config = json.dumps({"id": " city_wallet"})
city_wallet_credentials = json.dumps({"key": "city_wallet_key"})
city_wallet, steward_city_key, city_steward_did, city_steward_key, _ = \
await onboarding(pool_handle, "Bd Steward", steward_wallet, steward_did, "City", None,
city_wallet_config, city_wallet_credentials)
logger.info("==========================================================================")
logger.info("== Getting Trust Anchor credentials - City Onboarding ==")
logger.info("**************************************************************************")
city_did = await get_verinym(pool_handle, "Bd Steward", steward_wallet, steward_did, steward_city_key,
"City", city_wallet, city_steward_did, city_steward_key, 'TRUST_ANCHOR')
logger.info("==========================================================================")
logger.info("== Credential Schemas Setup ==")
logger.info("**************************************************************************")
logger.info("\"Government\" -> Create \"Job-Certificate\" Schema")
job_certificate = {
'name': 'Job-Certificate',
'version': '0.0.1',
'attributes': ['first_name', 'last_name', 'salary', 'employee_status', 'experience']
}
(job_certificate_schema_id, job_certificate_schema) = \
await anoncreds.issuer_create_schema(government_did, job_certificate['name'], job_certificate['version'],
json.dumps(job_certificate['attributes']))
logger.info("\"Government\" -> Send \"Job-Certificate\" Schema to Ledger")
await send_schema(pool_handle, government_wallet, government_did, job_certificate_schema)
logger.info("\"Government\" -> Create \"Transcript\" Schema")
transcript = {
'name': 'Transcript',
'version': '1.0.1',
'attributes': ['first_name', 'last_name', 'degree', 'status', 'year', 'average', 'ssn']
}
(transcript_schema_id, transcript_schema) = \
await anoncreds.issuer_create_schema(government_did, transcript['name'], transcript['version'],
json.dumps(transcript['attributes']))
logger.info("\"Government\" -> Send \"Transcript\" Schema to Ledger")
await send_schema(pool_handle, government_wallet, government_did, transcript_schema)
time.sleep(1)
logger.info("==========================================================================")
logger.info("== CUET Credential Definition Setup ==")
logger.info("**************************************************************************")
logger.info("\"CUET\" -> Get \"Transcript\" Schema from Ledger")
(_, transcript_schema) = await get_schema(pool_handle, cuet_did, transcript_schema_id)
logger.info("\"CUET\" -> Create and store in Wallet \"CUET Transcript\" Credential Definition")
transcript_cred_def = {
'tag': 'TAG1',
'type': 'CL',
'config': {"support_revocation": False}
}
(cuet_transcript_cred_def_id, cuet_transcript_cred_def_json) = \
await anoncreds.issuer_create_and_store_credential_def(cuet_wallet, cuet_did, transcript_schema,
transcript_cred_def['tag'], transcript_cred_def['type'],
json.dumps(transcript_cred_def['config']))
logger.info("\"CUET\" -> Send \"CUET Transcript\" Credential Definition to Ledger")
await send_cred_def(pool_handle, cuet_wallet, cuet_did, cuet_transcript_cred_def_json)
logger.info("==========================================================================")
logger.info("== BJIT Credential Definition Setup ==")
logger.info("**************************************************************************")
logger.info("\"BJIT\" -> Get from Ledger \"Job-Certificate\" Schema")
(_, job_certificate_schema) = await get_schema(pool_handle, bjit_did, job_certificate_schema_id)
logger.info("\"BJIT\" -> Create and store in Wallet \"BJIT Job-Certificate\" Credential Definition")
job_certificate_cred_def = {
'tag': 'TAG1',
'type': 'CL',
'config': {"support_revocation": False}
}
(bjit_job_certificate_cred_def_id, bjit_job_certificate_cred_def_json) = \
await anoncreds.issuer_create_and_store_credential_def(bjit_wallet, bjit_did, job_certificate_schema,
job_certificate_cred_def['tag'], job_certificate_cred_def['type'],
json.dumps(job_certificate_cred_def['config']))
logger.info("\"BJIT\" -> Send \"BJIT Job-Certificate\" Credential Definition to Ledger")
await send_cred_def(pool_handle, bjit_wallet, bjit_did, bjit_job_certificate_cred_def_json)
logger.info("==========================================================================")
async def run():
logger.info("Getting started -> started")
if not (args.mode == "http"):
pool_ = {'name': 'pool1'}
logger.info("Open Pool Ledger: {}".format(pool_['name']))
pool_['genesis_txn_path'] = get_pool_genesis_txn_path(pool_['name'])
pool_['config'] = json.dumps(
{"genesis_txn": str(pool_['genesis_txn_path'])})
# Set protocol version 2 to work with Indy Node 1.4
await pool.set_protocol_version(PROTOCOL_VERSION)
try:
await pool.create_pool_ledger_config(pool_['name'],
pool_['config'])
except IndyError as ex:
if ex.error_code == ErrorCode.PoolLedgerConfigAlreadyExistsError:
pass
pool_['handle'] = await pool.open_pool_ledger(pool_['name'], None)
logger.info("==============================")
#logger.info("=== Getting Trust Anchor credentials for Faber, Acme, Thrift and Government ==")
logger.info("=== Getting Trust Anchor credentials for Acme ==")
logger.info("------------------------------")
steward = {
'name': "Sovrin Steward",
'wallet_config': json.dumps({'id': 'sovrin_steward_wallet'}),
'wallet_credentials': json.dumps({'key': 'steward_wallet_key'}),
'pool': pool_['handle'],
'seed': '000000000000000000000000Steward1'
}
await create_wallet(steward)
logger.info(
"\"Sovrin Steward\" -> Create and store in Wallet DID from seed")
steward['did_info'] = json.dumps({'seed': steward['seed']})
steward['did'], steward['key'] = await did.create_and_store_my_did(
steward['wallet'], steward['did_info'])
logger.info("==============================")
logger.info(
"== Getting Trust Anchor credentials - Government getting Verinym =="
)
logger.info("------------------------------")
government = {
'name': 'Government',
'wallet_config': json.dumps({'id': 'government_wallet'}),
'wallet_credentials': json.dumps({'key': 'government_wallet_key'}),
'pool': pool_['handle'],
'role': 'TRUST_ANCHOR'
}
await getting_verinym(steward, government)
logger.info("==============================")
logger.info(
"== Getting Trust Anchor credentials - Acme getting Verinym ==")
logger.info("------------------------------")
acme = {
'name': 'Acme',
'wallet_config': json.dumps({'id': 'acme_wallet'}),
'wallet_credentials': json.dumps({'key': 'acme_wallet_key'}),
'pool': pool_['handle'],
'role': 'TRUST_ANCHOR'
}
await getting_verinym(steward, acme)
logger.info("==============================")
logger.info(
"== Getting Trust Anchor credentials - Thrift getting Verinym ==")
logger.info("------------------------------")
thrift = {
'name': 'Thrift',
'wallet_config': json.dumps({'id': 'thrift_wallet'}),
'wallet_credentials': json.dumps({'key': 'thrift_wallet_key'}),
'pool': pool_['handle'],
'role': 'TRUST_ANCHOR'
}
await getting_verinym(steward, thrift)
logger.info("==============================")
logger.info("=== Credential Schemas Setup ==")
logger.info("------------------------------")
logger.info("\"Government\" -> Create \"Job-Certificate\" Schema")
job_certificate = {
'name':
'Job-Certificate',
'version':
'0.2',
'attributes': [
'first_name', 'last_name', 'salary', 'employee_status',
'experience'
]
}
(government['job_certificate_schema_id'], government['job_certificate_schema']) = \
await anoncreds.issuer_create_schema(government['did'], job_certificate['name'], job_certificate['version'],
json.dumps(job_certificate['attributes']))
job_certificate_schema_id = government['job_certificate_schema_id']
logger.info(
"\"Government\" -> Send \"Job-Certificate\" Schema to Ledger")
await send_schema(government['pool'], government['wallet'],
government['did'],
government['job_certificate_schema'])
time.sleep(1) # sleep 1 second before getting schema
logger.info("==============================")
logger.info("=== Acme Credential Definition Setup ==")
logger.info("------------------------------")
logger.info("\"Acme\" -> Get from Ledger \"Job-Certificate\" Schema")
(acme['job_certificate_schema_id'], acme['job_certificate_schema']) = \
await get_schema(acme['pool'], acme['did'], job_certificate_schema_id)
logger.info(
"\"Acme\" -> Create and store in Wallet \"Acme Job-Certificate\" Credential Definition"
)
job_certificate_cred_def = {
'tag': 'TAG1',
'type': 'CL',
'config': {
"support_revocation": False
}
}
(acme['job_certificate_cred_def_id'], acme['job_certificate_cred_def']) = \
await anoncreds.issuer_create_and_store_credential_def(acme['wallet'], acme['did'],
acme['job_certificate_schema'],
job_certificate_cred_def['tag'],
job_certificate_cred_def['type'],
json.dumps(job_certificate_cred_def['config']))
logger.info(
"\"Acme\" -> Send \"Acme Job-Certificate\" Credential Definition to Ledger"
)
await send_cred_def(acme['pool'], acme['wallet'], acme['did'],
acme['job_certificate_cred_def'])
logger.info("\"Acme\" -> Creates Revocation Registry")
acme['tails_writer_config'] = json.dumps({
'base_dir': "/tmp/indy_acme_tails",
'uri_pattern': ''
})
tails_writer = await blob_storage.open_writer(
'default', acme['tails_writer_config'])
acme['revoc_reg_id'] = None
#(acme['revoc_reg_id'], acme['revoc_reg_def'], acme['revoc_reg_entry']) = \
# await anoncreds.issuer_create_and_store_revoc_reg(acme['wallet'], acme['did'], 'CL_ACCUM', 'TAG1',
# acme['job_certificate_cred_def_id'],
# json.dumps({'max_cred_num': 5,
# 'issuance_type': 'ISSUANCE_ON_DEMAND'}),
# tails_writer)
#logger.info("\"Acme\" -> Post Revocation Registry Definition to Ledger")
#acme['revoc_reg_def_request'] = await ledger.build_revoc_reg_def_request(acme['did'], acme['revoc_reg_def'])
#await ledger.sign_and_submit_request(acme['pool'], acme['wallet'], acme['did'], acme['revoc_reg_def_request'])
#logger.info("\"Acme\" -> Post Revocation Registry Entry to Ledger")
#acme['revoc_reg_entry_request'] = \
# await ledger.build_revoc_reg_entry_request(acme['did'], acme['revoc_reg_id'], 'CL_ACCUM',
# acme['revoc_reg_entry'])
#await ledger.sign_and_submit_request(acme['pool'], acme['wallet'], acme['did'], acme['revoc_reg_entry_request'])
logger.info("==============================")
logger.info("== Alice setup ==")
logger.info("------------------------------")
alice = {
'name': 'Alice',
'wallet_config': json.dumps({'id': 'alice_wallet'}),
'wallet_credentials': json.dumps({'key': 'alice_wallet_key'}),
'pool': pool_['handle'],
}
await create_wallet(alice)
(alice['did'], alice['key']) = await did.create_and_store_my_did(
alice['wallet'], "{}")
logger.info(
"\"Alice\" -> Create and store \"Alice\" Master Secret in Wallet")
alice[
'master_secret_id'] = await anoncreds.prover_create_master_secret(
alice['wallet'], None)
logger.info("==============================")
logger.info(
"== Apply for the job with Acme - Getting Job-Certificate Credential =="
)
logger.info("------------------------------")
logger.info(
"\"Acme\" -> Create \"Job-Certificate\" Credential Offer for Alice"
)
acme['job_certificate_cred_offer'] = \
await anoncreds.issuer_create_credential_offer(acme['wallet'], acme['job_certificate_cred_def_id'])
logger.info(
"\"Acme\" -> Send \"Job-Certificate\" Credential Offer to Alice")
alice['job_certificate_cred_offer'] = acme[
'job_certificate_cred_offer']
job_certificate_cred_offer_object = json.loads(
alice['job_certificate_cred_offer'])
logger.info(
"\"Alice\" -> Get \"Acme Job-Certificate\" Credential Definition from Ledger"
)
(alice['acme_job_certificate_cred_def_id'], alice['acme_job_certificate_cred_def']) = \
await get_cred_def(alice['pool'], alice['did'], job_certificate_cred_offer_object['cred_def_id'])
logger.info(
"\"Alice\" -> Create and store in Wallet \"Job-Certificate\" Credential Request for Acme"
)
(alice['job_certificate_cred_request'], alice['job_certificate_cred_request_metadata']) = \
await anoncreds.prover_create_credential_req(alice['wallet'], alice['did'],
alice['job_certificate_cred_offer'],
alice['acme_job_certificate_cred_def'], alice['master_secret_id'])
logger.info(
"\"Alice\" -> Send \"Job-Certificate\" Credential Request to Acme")
alice['job_certificate_cred_values'] = json.dumps({
"first_name": {
"raw": "Alice",
"encoded": "245712572474217942457235975012103335"
},
"last_name": {
"raw": "Garcia",
"encoded": "312643218496194691632153761283356127"
},
"employee_status": {
"raw": "Permanent",
"encoded": "2143135425425143112321314321"
},
"salary": {
"raw": "2400",
"encoded": "2400"
},
"experience": {
"raw": "10",
"encoded": "10"
}
})
acme['job_certificate_cred_request'] = alice[
'job_certificate_cred_request']
acme['job_certificate_cred_values'] = alice[
'job_certificate_cred_values']
logger.info(
"\"Acme\" -> Create \"Job-Certificate\" Credential for Alice")
acme[
'blob_storage_reader_cfg_handle'] = await blob_storage.open_reader(
'default', acme['tails_writer_config'])
acme['job_certificate_cred'], acme['job_certificate_cred_rev_id'], acme['alice_cert_rev_reg_delta'] = \
await anoncreds.issuer_create_credential(acme['wallet'], acme['job_certificate_cred_offer'],
acme['job_certificate_cred_request'],
acme['job_certificate_cred_values'],
acme['revoc_reg_id'],
acme['blob_storage_reader_cfg_handle'])
#logger.info("\"Acme\" -> Post Revocation Registry Delta to Ledger")
#acme['revoc_reg_entry_req'] = \
# await ledger.build_revoc_reg_entry_request(acme['did'], acme['revoc_reg_id'], 'CL_ACCUM',
# acme['alice_cert_rev_reg_delta'])
#await ledger.sign_and_submit_request(acme['pool'], acme['wallet'], acme['did'], acme['revoc_reg_entry_req'])
logger.info("\"Acme\" -> Send \"Job-Certificate\" Credential to Alice")
alice['job_certificate_cred'] = acme['job_certificate_cred']
job_certificate_cred_object = json.loads(alice['job_certificate_cred'])
#logger.info("\"Alice\" -> Gets RevocationRegistryDefinition for \"Job-Certificate\" Credential from Acme")
#alice['acme_revoc_reg_des_req'] = \
# await ledger.build_get_revoc_reg_def_request(alice['did'],
# job_certificate_cred_object['rev_reg_id'])
#alice['acme_revoc_reg_des_resp'] = \
# await ensure_previous_request_applied(alice['pool'], alice['acme_revoc_reg_des_req'],
# lambda response: response['result']['data'] is not None)
#(alice['acme_revoc_reg_def_id'], alice['acme_revoc_reg_def_json']) = \
# await ledger.parse_get_revoc_reg_def_response(alice['acme_revoc_reg_des_resp'])
alice['acme_revoc_reg_def_json'] = None
logger.info("\"Alice\" -> Store \"Job-Certificate\" Credential")
await anoncreds.prover_store_credential(
alice['wallet'], None,
alice['job_certificate_cred_request_metadata'],
alice['job_certificate_cred'],
alice['acme_job_certificate_cred_def'],
alice['acme_revoc_reg_def_json'])
logger.info("Creating Credential in Getting started -> done")
logger.info("==============================")
logger.info("=== Apply for the loan with Thrift ==")
logger.info("==============================")
async def apply_loan_basic():
# This method will be called twice: once with a valid Job-Certificate and
# the second time after the Job-Certificate has been revoked.
logger.info("==============================")
logger.info(
"== Apply for the loan with Thrift - Job-Certificate proving =="
)
logger.info("------------------------------")
#logger.info("\"Thrift\" -> Create \"Loan-Application-Basic\" Proof Request")
logger.info(
"\"Alice\" -> Create \"Loan-Application-Basic\" Proof Request")
nonce = await anoncreds.generate_nonce()
#thrift['apply_loan_proof_request'] = json.dumps({
alice['apply_loan_proof_request'] = json.dumps({
'nonce': nonce,
'name': 'Loan-Application-Basic',
'version': '0.1',
'requested_attributes': {
'attr1_referent': {
'name':
'employee_status',
'restrictions': [{
'cred_def_id':
acme['job_certificate_cred_def_id']
}]
}
},
'requested_predicates': {
'predicate1_referent': {
'name':
'salary',
'p_type':
'>=',
'p_value':
2000,
'restrictions': [{
'cred_def_id':
acme['job_certificate_cred_def_id']
}]
},
'predicate2_referent': {
'name':
'experience',
'p_type':
'>=',
'p_value':
1,
'restrictions': [{
'cred_def_id':
acme['job_certificate_cred_def_id']
}]
}
} #,
# 'non_revoked': {'to': int(time.time())}
})
#logger.info("\"Thrift\" -> Send \"Loan-Application-Basic\" Proof Request to Alice")
#alice['apply_loan_proof_request'] = thrift_apply_loan_proof_request
logger.info("Creating Proof Request in Getting started -> done")
logger.info(
"\"Alice\" -> Get credentials for \"Loan-Application-Basic\" Proof Request"
)
search_for_apply_loan_proof_request = \
await anoncreds.prover_search_credentials_for_proof_req(alice['wallet'],
alice['apply_loan_proof_request'], None)
cred_for_attr1 = await get_credential_for_referent(
search_for_apply_loan_proof_request, 'attr1_referent')
cred_for_predicate1 = await get_credential_for_referent(
search_for_apply_loan_proof_request, 'predicate1_referent')
cred_for_predicate2 = await get_credential_for_referent(
search_for_apply_loan_proof_request, 'predicate2_referent')
await anoncreds.prover_close_credentials_search_for_proof_req(
search_for_apply_loan_proof_request)
alice['creds_for_apply_loan_proof'] = {
cred_for_attr1['referent']: cred_for_attr1,
cred_for_predicate1['referent']: cred_for_predicate1,
cred_for_predicate2['referent']: cred_for_predicate2
}
# requested_timestamp = int(json.loads(alice['apply_loan_proof_request'])['non_revoked']['to'])
requested_timestamp = None
alice['schemas_for_loan_app'], alice['cred_defs_for_loan_app'], alice['revoc_states_for_loan_app'] = \
await prover_get_entities_from_ledger(alice['pool'], alice['did'],
alice['creds_for_apply_loan_proof'],
alice['name'], None, requested_timestamp)
logger.info("\"Alice\" -> Create \"Loan-Application-Basic\" Proof")
revoc_states_for_loan_app = json.loads(
alice['revoc_states_for_loan_app'])
timestamp_for_attr1 = get_timestamp_for_attribute(
cred_for_attr1, revoc_states_for_loan_app)
timestamp_for_predicate1 = get_timestamp_for_attribute(
cred_for_predicate1, revoc_states_for_loan_app)
timestamp_for_predicate2 = get_timestamp_for_attribute(
cred_for_predicate2, revoc_states_for_loan_app)
alice['apply_loan_requested_creds'] = json.dumps({
'self_attested_attributes': {},
'requested_attributes': {
'attr1_referent': {
'cred_id': cred_for_attr1['referent'],
'revealed': True,
'timestamp': timestamp_for_attr1
}
},
'requested_predicates': {
'predicate1_referent': {
'cred_id': cred_for_predicate1['referent'],
'timestamp': timestamp_for_predicate1
},
'predicate2_referent': {
'cred_id': cred_for_predicate2['referent'],
'timestamp': timestamp_for_predicate2
}
}
})
alice['apply_loan_proof'] = \
await anoncreds.prover_create_proof(alice['wallet'], alice['apply_loan_proof_request'],
alice['apply_loan_requested_creds'], alice['master_secret_id'],
alice['schemas_for_loan_app'], alice['cred_defs_for_loan_app'],
alice['revoc_states_for_loan_app'])
logger.info("Creating Proof in Getting started -> done")
logger.info(
"\"Alice\" -> Send \"Loan-Application-Basic\" Proof to Thrift")
logger.info(json.dumps(alice['apply_loan_proof']))
# logger.info("USER_PROOF_REQUEST: " + json.dumps(alice['apply_loan_proof_request']))
# logger.info("USER_PROOF: " + json.dumps(alice['apply_loan_proof']))
# logger.info('{ "proof_request": ' + json.dumps(alice['apply_loan_proof_request']) + ', "proof": ' + json.dumps(alice['apply_loan_proof']) + ' }')
# request_str = '{ "proof_request": ' + json.dumps(alice['apply_loan_proof_request']) + ', "proof": ' + json.dumps(alice['apply_loan_proof']) + ' }'
# logger.info(request_str)
##request_json = { "proof_request": json.dumps(alice['apply_loan_proof_request']), "proof": json.dumps(alice['apply_loan_proof'])}
request_json = {
"proof_request": alice['apply_loan_proof_request'],
"proof": alice['apply_loan_proof']
}
logger.info(json.dumps(request_json))
# create_user_proof_file(file_name, json.dumps(request_str))
create_user_proof_file(file_name, json.dumps(request_json))
await apply_loan_basic()
request_discounted_cartrade(file_name)
async def run():
logger.info("Getting started -> started")
pool_name = 'pool1'
logger.info("Open Pool Ledger: {}".format(pool_name))
pool_genesis_txn_path = get_pool_genesis_txn_path(pool_name)
print(pool_genesis_txn_path)
pool_config = json.dumps({"genesis_txn": str(pool_genesis_txn_path)})
# Set protocol version 2 to work with Indy Node 1.4
await pool.set_protocol_version(PROTOCOL_VERSION)
logger.info("==========================================")
logger.info("=== Setting up Sovrin Steward's Wallet ===")
logger.info("------------------------------------------")
logger.info("\"Sovrin Steward\" -> Create wallet")
steward_wallet_config = json.dumps({"id": "sovrin_steward_wallet"})
steward_wallet_credentials = json.dumps({"key": "steward_wallet_key"})
try:
await wallet.create_wallet(steward_wallet_config,
steward_wallet_credentials)
except IndyError as ex:
if ex.error_code == ErrorCode.WalletAlreadyExistsError:
pass
steward_wallet = await wallet.open_wallet(steward_wallet_config,
steward_wallet_credentials)
logger.info(
"\"Sovrin Steward\" -> Create and store in Wallet DID from seed")
steward_did_info = {'seed': '000000000000000000000000Steward1'}
(steward_did, steward_key) = await did.create_and_store_my_did(
steward_wallet, json.dumps(steward_did_info))
try:
await pool.create_pool_ledger_config(pool_name, pool_config)
except IndyError as ex:
if ex.error_code == ErrorCode.PoolLedgerConfigAlreadyExistsError:
pass
pool_handle = await pool.open_pool_ledger(pool_name, None)
logger.info("=================================")
logger.info("=== Setting up Alice's Wallet ===")
logger.info("---------------------------------")
logger.info("\"Alice\" -> Create wallet")
alice_wallet_config = json.dumps({"id": "alice_wallet"})
alice_wallet_credentials = json.dumps({"key": "alice_wallet_key"})
try:
await wallet.create_wallet(alice_wallet_config,
alice_wallet_credentials)
except IndyError as ex:
if ex.error_code == ErrorCode.WalletAlreadyExistsError:
pass
logger.info("==============================================")
logger.info("=== Onboarding A+ Accountants to ledger =====")
logger.info("----------------------------------------------")
logger.info("\"Bob\" -> Create wallet")
employer_wallet_config = json.dumps({"id": "A+_Accountant_wallet"})
employer_wallet_credentials = json.dumps(
{"key": "a+_accountant_wallet_key"})
employer_wallet, steward_employer_key, faber_employer_did, employer_steward_key, _ = \
await onboarding(pool_handle, "Sovrin Steward", steward_wallet, steward_did, "A+ Accountants", None, faber_wallet_config, faber_wallet_credentials)
logger.info("==================================================")
logger.info("=== Setting up ACME Accounting WebApp's Wallet ===")
logger.info("--------------------------------------------------")
logger.info("\"Bob\" -> Create wallet")
acme_wallet_config = json.dumps({"id": "acme_wallet"})
acme_wallet_credentials = json.dumps({"key": "acme_wallet_key"})
Once that succeeds, Trust Anchor uses anonymous credentials to issue and store
claim definition for the Schema added by Steward.
"""
import asyncio
import json
import pprint
import time
from indy import pool, ledger, wallet, did, anoncreds
from indy.error import ErrorCode, IndyError
from src.utils import run_coroutine, get_pool_genesis_txn_path, PROTOCOL_VERSION
pool_name = 'pool1'
pool_genesis_txn_path = get_pool_genesis_txn_path(pool_name)
wallet_config = json.dumps({"id": "wallet"})
wallet_credentials = json.dumps({"key": "wallet_key"})
pool_config = json.dumps({"genesis_txn": str(pool_genesis_txn_path)})
def print_log(value_color="", value_noncolor=""):
"""set the colors for text."""
HEADER = '\033[92m'
ENDC = '\033[0m'
print(HEADER + value_color + ENDC + str(value_noncolor))
async def write_schema_and_cred_def():
try:
# Set protocol version 2 to work with Indy Node 1.4
async def run():
logger.info("===== Start =====")
pool_ = {'name': 'pool1'}
logger.info("Open Pool Ledger: {}".format(pool_['name']))
pool_['genesis_txn_path'] = get_pool_genesis_txn_path(pool_['name'])
logger.info(get_pool_genesis_txn_path(pool_['name']))
pool_['config'] = json.dumps(
{"genesis_txn": str(pool_['genesis_txn_path'])})
# Set protocol version 2 to work with Indy Node 1.4
await pool.set_protocol_version(PROTOCOL_VERSION)
try:
await pool.create_pool_ledger_config(pool_['name'], pool_['config'])
except IndyError as ex:
if ex.error_code == ErrorCode.PoolLedgerConfigAlreadyExistsError:
pass
pool_['handle'] = await pool.open_pool_ledger(pool_['name'], None)
logger.info("==============================")
logger.info(
"=== Getting Trust Anchor credentials for Uniandes, Entry and Sicua =="
)
logger.info("------------------------------")
steward = {
'name': "Sovrin Steward",
'wallet_config': json.dumps({'id': 'sovrin_steward_wallet'}),
'wallet_credentials': json.dumps({'key': 'steward_wallet_key'}),
'pool': pool_['handle'],
'seed': '000000000000000000000000Steward1'
}
await create_wallet(steward)
logger.info(
"\"Sovrin Steward\" -> Create and store in Wallet DID from seed")
steward['did_info'] = json.dumps({'seed': steward['seed']})
steward['did'], steward['key'] = await did.create_and_store_my_did(
steward['wallet'], steward['did_info'])
logger.info("==============================")
logger.info(
"== Getting Trust Anchor credentials - Uniandes getting Verinym ==")
logger.info("------------------------------")
uniandes = {
'name': 'Uniandes',
'wallet_config': json.dumps({'id': 'uniandes_wallet'}),
'wallet_credentials': json.dumps({'key': 'uniandes_wallet_key'}),
'pool': pool_['handle'],
'role': 'TRUST_ANCHOR'
}
await getting_verinym(steward, uniandes)
logger.info("==============================")
logger.info(
"== Getting Trust Anchor credentials - Entry getting Verinym ==")
logger.info("------------------------------")
entry = {
'name': 'Entry',
'wallet_config': json.dumps({'id': 'entry_wallet'}),
'wallet_credentials': json.dumps({'key': 'entry_wallet_key'}),
'pool': pool_['handle'],
'role': 'TRUST_ANCHOR'
}
await getting_verinym(steward, entry)
logger.info("==============================")
logger.info(
"== Getting Trust Anchor credentials - Sicua getting Verinym ==")
logger.info("------------------------------")
sicua = {
'name': 'Sicua',
'wallet_config': json.dumps({'id': 'sicua_wallet'}),
'wallet_credentials': json.dumps({'key': 'sicua_wallet_key'}),
'pool': pool_['handle'],
'role': 'TRUST_ANCHOR'
}
await getting_verinym(steward, sicua)
logger.info("------------------------------")
logger.info("== Student/User setup ==")
logger.info("------------------------------")
susan = {
'name': 'Susan',
'wallet_config': json.dumps({'id': 'susan_wallet'}),
'wallet_credentials': json.dumps({'key': 'susan_wallet_key'}),
'pool': pool_['handle'],
}
name = input("Name:")
user = {}
user['name'] = name
last_name = input("Last Name:")
user['last_name'] = last_name
print("Type of user: "******"1. Student ")
print("2. Teacher ")
print("3. Employee")
print("4. Invited")
type_of_user = int(input("Enter the number for your type of user: "******"Student ID:")
user['code'] = cod
elif type_of_user == 2:
status = 'teacher'
elif type_of_user == 3:
status = 'employee'
elif type_of_user == 4:
status = 'invited'
else:
print("Enter a valid number")
user['status'] = status
id = input("ID:")
user['id'] = id
print("First name: " + user['name'])
print("Last name: " + user['last_name'])
print("User: "******"ID: " + user['id'])
user['wallet_config'] = json.dumps(
{'id': user['name'].lower() + '_wallet'})
print(user['wallet_config'])
user['wallet_credentials'] = json.dumps(
{'key': user['name'].lower() + '_wallet_key'})
user['pool'] = pool_['handle']
await create_wallet(user)
(user['did'],
user['key']) = await did.create_and_store_my_did(user['wallet'], "{}")
logger.info("==============================")
logger.info("=== Credential Schemas Setup ==")
logger.info("------------------------------")
logger.info("\"Uniandes\" -> Create \"Uniandino\" Schema")
uniandino = {
'name': 'Uniandino',
'version': '0.1',
'attributes': ['first_name', 'last_name', 'status', 'id', 'code']
}
(uniandes['uniandino_schema_id'], uniandes['uniandino_schema']) = \
await anoncreds.issuer_create_schema(uniandes['did'], uniandino['name'], uniandino['version'],
json.dumps(uniandino['attributes']))
uniandino_schema_id = uniandes['uniandino_schema_id']
logger.info("\"Uniandes\" -> Send \"Uniandino\" Schema to Ledger")
await send_schema(uniandes['pool'], uniandes['wallet'], uniandes['did'],
uniandes['uniandino_schema'])
time.sleep(1) # sleep 1 second before getting schema
logger.info("==============================")
logger.info("=== Uniandes Credential Definition Setup ==")
logger.info("------------------------------")
logger.info("\"Uniandes\" -> Get from Ledger \"Uniandino\" Schema")
(uniandes['uniandino_schema_id'], uniandes['uniandino_schema']) = \
await get_schema(uniandes['pool'], uniandes['did'], uniandino_schema_id)
logger.info(
"\"Uniandes\" -> Create and store in Wallet \"Uniandino\" Credential Definition"
)
uniandino_cred_def = {
'tag': 'TAG1',
'type': 'CL',
'config': {
"support_revocation": True
}
}
(uniandes['uniandino_cred_def_id'], uniandes['uniandino_cred_def']) = \
await anoncreds.issuer_create_and_store_credential_def(uniandes['wallet'], uniandes['did'],
uniandes['uniandino_schema'],
uniandino_cred_def['tag'],
uniandino_cred_def['type'],
json.dumps(uniandino_cred_def['config']))
logger.info(
"\"Uniandes\" -> Send \"Uniandino\" Credential Definition to Ledger")
await send_cred_def(uniandes['pool'], uniandes['wallet'], uniandes['did'],
uniandes['uniandino_cred_def'])
logger.info("\"Uniandes\" -> Creates Revocation Registry")
uniandes['tails_writer_config'] = json.dumps({
'base_dir': "/tmp/indy_acme_tails",
'uri_pattern': ''
})
tails_writer = await blob_storage.open_writer(
'default', uniandes['tails_writer_config'])
(uniandes['revoc_reg_id'], uniandes['revoc_reg_def'], uniandes['revoc_reg_entry']) = \
await anoncreds.issuer_create_and_store_revoc_reg(uniandes['wallet'], uniandes['did'], 'CL_ACCUM', 'TAG1',
uniandes['uniandino_cred_def_id'],
json.dumps({'max_cred_num': 5,
'issuance_type': 'ISSUANCE_ON_DEMAND'}),
tails_writer)
logger.info(
"\"Uniandes\" -> Post Revocation Registry Definition to Ledger")
uniandes[
'revoc_reg_def_request'] = await ledger.build_revoc_reg_def_request(
uniandes['did'], uniandes['revoc_reg_def'])
await ledger.sign_and_submit_request(uniandes['pool'], uniandes['wallet'],
uniandes['did'],
uniandes['revoc_reg_def_request'])
logger.info("\"Uniandes\" -> Post Revocation Registry Entry to Ledger")
uniandes['revoc_reg_entry_request'] = \
await ledger.build_revoc_reg_entry_request(uniandes['did'], uniandes['revoc_reg_id'], 'CL_ACCUM',
uniandes['revoc_reg_entry'])
await ledger.sign_and_submit_request(uniandes['pool'], uniandes['wallet'],
uniandes['did'],
uniandes['revoc_reg_entry_request'])
logger.info("==============================")
logger.info("=== Getting Uniandino with Uniandes ==")
logger.info("==============================")
logger.info("==============================")
logger.info(
"== Getting Uniandino with Uninades - Getting Uniandino Credential ==")
logger.info("------------------------------")
logger.info("\"Uniandes\" -> Create \"Uniandino\" Credential Offer for" +
user['name'])
uniandes['uniandino_cred_offer'] = \
await anoncreds.issuer_create_credential_offer(uniandes['wallet'], uniandes['uniandino_cred_def_id'])
logger.info("\"Uniandes\" -> Send \"Uniandino\" Credential Offer to " +
user['name'])
user['uniandino_cred_offer'] = uniandes['uniandino_cred_offer']
uniandino_cred_offer_object = json.loads(user['uniandino_cred_offer'])
#susan['uniandino_schema_id'] = uniandino_cred_offer_object['schema_id']
#susan['uniandino_cred_def_id'] = uniandino_cred_offer_object['cred_def_id']
logger.info("\"" + user['name'] + "\" -> Create and store " +
user['name'] + " Master Secret in Wallet")
user['master_secret_id'] = await anoncreds.prover_create_master_secret(
user['wallet'], None)
logger.info(
"\"" + user['name'] +
"\"-> Get \"Uniandes Uniandino\" Credential Definition from Ledger")
(user['uniandes_uniandino_cred_def_id'], user['uniandes_uniandino_cred_def']) = \
await get_cred_def(user['pool'], user['did'], uniandino_cred_offer_object['cred_def_id'])
logger.info("\"" + user['name'] +
"\" -> Create \"Uniandino\" Credential Request for Uniandes")
(user['uniandino_cred_request'], user['uniandino_cred_request_metadata']) = \
await anoncreds.prover_create_credential_req(user['wallet'], user['did'],
user['uniandino_cred_offer'], user['uniandes_uniandino_cred_def'],
user['master_secret_id'])
logger.info("\"" + user['name'] +
"\" -> Send \"Uniandino\" Credential Request to Uniandes")
user['uniandino_cred_values'] = json.dumps({
"first_name": {
"raw": user['name'],
"encoded": "1400206177 1845493760"
},
"last_name": {
"raw": user['last_name'],
"encoded": "1248818789 1845493760"
},
"status": {
"raw": user['status'],
"encoded": "1937012068 1701737472"
},
"id": {
"raw": user['id'],
"encoded": "825307441 825307441 825294848"
},
"code": {
"raw": user['code'],
"encoded": "825307441 825307441 825294848"
}
})
uniandes['uniandino_cred_request'] = user['uniandino_cred_request']
uniandes['uniandino_cred_values'] = user['uniandino_cred_values']
logger.info("\"Uniandes\" -> Create \"Uniandino\" Credential for " +
user['name'])
uniandes[
'blob_storage_reader_cfg_handle'] = await blob_storage.open_reader(
'default', uniandes['tails_writer_config'])
uniandes['uniandino_cred'], uniandes['uniandino_cred_rev_id'], uniandes['susan_cert_rev_reg_delta'] = \
await anoncreds.issuer_create_credential(uniandes['wallet'], uniandes['uniandino_cred_offer'],
uniandes['uniandino_cred_request'],
uniandes['uniandino_cred_values'], uniandes['revoc_reg_id'],
uniandes['blob_storage_reader_cfg_handle'])
logger.info("\"Uniandes\" -> Post Revocation Registry Delta to Ledger")
uniandes['revoc_reg_entry_req'] = \
await ledger.build_revoc_reg_entry_request(uniandes['did'], uniandes['revoc_reg_id'], 'CL_ACCUM',
uniandes['susan_cert_rev_reg_delta'])
await ledger.sign_and_submit_request(uniandes['pool'], uniandes['wallet'],
uniandes['did'],
uniandes['revoc_reg_entry_req'])
logger.info("\"Uniandes\" -> Send \"Uniandino\" Credential to " +
user['name'])
user['uniandino_cred'] = uniandes['uniandino_cred']
uniandino_cred_object = json.loads(user['uniandino_cred'])
logger.info(
"\"" + user['name'] +
"\"-> Gets RevocationRegistryDefinition for \"Uniandino\" Credential from Uniandes"
)
user['uniandes_revoc_reg_des_req'] = \
await ledger.build_get_revoc_reg_def_request(user['did'],
uniandino_cred_object['rev_reg_id'])
user['uniandes_revoc_reg_des_resp'] = \
await ensure_previous_request_applied(user['pool'], user['uniandes_revoc_reg_des_req'],
lambda response: response['result']['data'] is not None)
(user['uniandes_revoc_reg_def_id'], user['uniandes_revoc_reg_def_json']) = \
await ledger.parse_get_revoc_reg_def_response(user['uniandes_revoc_reg_des_resp'])
logger.info("\"" + user['name'] +
"\" -> Store \"Uniandino\" Credential from Uniandes")
await anoncreds.prover_store_credential(
user['wallet'], None, user['uniandino_cred_request_metadata'],
user['uniandino_cred'], user['uniandes_uniandino_cred_def'],
user['uniandes_revoc_reg_def_json'])
async def get_into():
logger.info("==============================")
logger.info(
"== Trying to get into the university with Entry - Uniandino proving =="
)
logger.info("------------------------------")
logger.info("\"Entry\" -> Create \"Uniandino\" Proof Request")
nonce = await anoncreds.generate_nonce()
entry['uniandino_proof_request'] = json.dumps({
'nonce': nonce,
'name': 'Uniandino',
'version': '0.1',
'self_attested_attributes': {},
'requested_attributes': {
'attr1_referent': {
'name': 'first_name'
},
'attr2_referent': {
'name': 'last_name'
},
'attr3_referent': {
'name':
'id',
'restrictions': [{
'cred_def_id':
uniandes['uniandino_cred_def_id']
}]
},
'attr4_referent': {
'name':
'status',
'restrictions': [{
'cred_def_id':
uniandes['uniandino_cred_def_id']
}]
}
},
'requested_predicates': {},
'non_revoked': {
'to': int(time.time())
}
})
logger.info("\"Entry\" -> Send \"Uniandino\" Proof Request to " +
user['name'])
user['uniandino_proof_request'] = entry['uniandino_proof_request']
logger.info("\"" + user['name'] +
"\" -> Get credentials for \"Uniandino\" Proof Request")
search_for_uniandino_proof_request = \
await anoncreds.prover_search_credentials_for_proof_req(user['wallet'],
user['uniandino_proof_request'], None)
cred_for_attr1 = await get_credential_for_referent(
search_for_uniandino_proof_request, 'attr1_referent')
cred_for_attr2 = await get_credential_for_referent(
search_for_uniandino_proof_request, 'attr2_referent')
cred_for_attr3 = await get_credential_for_referent(
search_for_uniandino_proof_request, 'attr3_referent')
cred_for_attr4 = await get_credential_for_referent(
search_for_uniandino_proof_request, 'attr4_referent')
await anoncreds.prover_close_credentials_search_for_proof_req(
search_for_uniandino_proof_request)
logger.info(cred_for_attr1)
user['creds_for_uniandino_proof'] = {
cred_for_attr1['referent']: cred_for_attr1,
cred_for_attr2['referent']: cred_for_attr2,
cred_for_attr3['referent']: cred_for_attr3,
cred_for_attr4['referent']: cred_for_attr4
}
requested_timestamp = int(
json.loads(entry['uniandino_proof_request'])['non_revoked']['to'])
user['schemas_for_uniandino'], user['cred_defs_for_uniandino'], \
user['revoc_states_for_uniandino'] = \
await prover_get_entities_from_ledger(user['pool'], user['did'],
user['creds_for_uniandino_proof'], user['name'], None, requested_timestamp)
logger.info("\"" + user['name'] + "\" -> Create \"Uniandino\" Proof")
revoc_states_for_uniandino = json.loads(
user['revoc_states_for_uniandino'])
timestamp_for_attr1 = get_timestamp_for_attribute(
cred_for_attr1, revoc_states_for_uniandino)
timestamp_for_attr2 = get_timestamp_for_attribute(
cred_for_attr2, revoc_states_for_uniandino)
timestamp_for_attr3 = get_timestamp_for_attribute(
cred_for_attr3, revoc_states_for_uniandino)
timestamp_for_attr4 = get_timestamp_for_attribute(
cred_for_attr4, revoc_states_for_uniandino)
user['uniandino_requested_creds'] = json.dumps({
'self_attested_attributes': {
'attr1_referent': 'Susan',
'attr2_referent': 'Joven'
},
'requested_attributes': {
'attr3_referent': {
'cred_id': cred_for_attr3['referent'],
'revealed': True,
'timestamp': timestamp_for_attr3
},
'attr4_referent': {
'cred_id': cred_for_attr4['referent'],
'revealed': True,
'timestamp': timestamp_for_attr4
}
},
'requested_predicates': {}
})
user['uniandino_proof'] = \
await anoncreds.prover_create_proof(user['wallet'], user['uniandino_proof_request'],
user['uniandino_requested_creds'], user['master_secret_id'],
user['schemas_for_uniandino'],
user['cred_defs_for_uniandino'],
user['revoc_states_for_uniandino'])
logger.info("\"" + user['name'] +
"\" -> Send \"Uniandino\" Proof to Entry")
entry['uniandino_proof'] = user['uniandino_proof']
uniandino_proof_object = json.loads(entry['uniandino_proof'])
logger.info(
"\"Entry\" -> Get Schemas, Credential Definitions and Revocation Registries from Ledger"
" required for Proof verifying")
entry['schemas_for_uniandino'], entry['cred_defs_for_uniandino'], \
entry['revoc_ref_defs_for_uniandino'], entry['revoc_regs_for_uniandino'] = \
await verifier_get_entities_from_ledger(entry['pool'], entry['did'],
uniandino_proof_object['identifiers'], entry['name'], requested_timestamp)
logger.info("\"Entry\" -> Verify \"Uniandino\" Proof from " +
user['name'])
assert 'student' == \
uniandino_proof_object['requested_proof']['revealed_attrs']['attr4_referent']['raw']
assert '12345' == \
uniandino_proof_object['requested_proof']['revealed_attrs']['attr3_referent']['raw']
# assert 'Susan' == uniandino_proof_object['requested_proof']['self_attested_attrs']['attr1_referent']
#assert 'Joven' == uniandino_proof_object['requested_proof']['self_attested_attrs']['attr2_referent']
async def get_sicua():
logger.info("==============================")
logger.info("== Trying to get access to Sicua - Uniandino proving ==")
logger.info("------------------------------")
logger.info("\"Sicua\" -> Create \"Uniandino\" Proof Request")
nonce = await anoncreds.generate_nonce()
sicua['uniandino_proof_request'] = json.dumps({
'nonce': nonce,
'name': 'Uniandino',
'version': '0.1',
'self_attested_attributes': {},
'requested_attributes': {
'attr1_referent': {
'name':
'first_name',
'restrictions': [{
'cred_def_id':
uniandes['uniandino_cred_def_id']
}]
},
'attr2_referent': {
'name':
'last_name',
'restrictions': [{
'cred_def_id':
uniandes['uniandino_cred_def_id']
}]
},
'attr3_referent': {
'name':
'id',
'restrictions': [{
'cred_def_id':
uniandes['uniandino_cred_def_id']
}]
},
'attr4_referent': {
'name':
'status',
'restrictions': [{
'cred_def_id':
uniandes['uniandino_cred_def_id']
}]
},
'attr5_referent': {
'name':
'code',
'restrictions': [{
'cred_def_id':
uniandes['uniandino_cred_def_id']
}]
}
},
'requested_predicates': {},
'non_revoked': {
'to': int(time.time())
}
})
logger.info("\"Sicua\" -> Send \"Uniandino\" Proof Request to " +
user['name'])
user['uniandino_proof_request'] = sicua['uniandino_proof_request']
logger.info("\"" + user['name'] +
"\" -> Get credentials for \"Uniandino\" Proof Request")
search_for_uniandino_proof_request = \
await anoncreds.prover_search_credentials_for_proof_req(user['wallet'],
user['uniandino_proof_request'], None)
cred_for_attr1 = await get_credential_for_referent(
search_for_uniandino_proof_request, 'attr1_referent')
cred_for_attr2 = await get_credential_for_referent(
search_for_uniandino_proof_request, 'attr2_referent')
cred_for_attr3 = await get_credential_for_referent(
search_for_uniandino_proof_request, 'attr3_referent')
cred_for_attr4 = await get_credential_for_referent(
search_for_uniandino_proof_request, 'attr4_referent')
cred_for_attr5 = await get_credential_for_referent(
search_for_uniandino_proof_request, 'attr5_referent')
await anoncreds.prover_close_credentials_search_for_proof_req(
search_for_uniandino_proof_request)
logger.info(cred_for_attr1)
user['creds_for_uniandino_proof'] = {
cred_for_attr1['referent']: cred_for_attr1,
cred_for_attr2['referent']: cred_for_attr2,
cred_for_attr3['referent']: cred_for_attr3,
cred_for_attr4['referent']: cred_for_attr4,
cred_for_attr5['referent']: cred_for_attr5
}
requested_timestamp = int(
json.loads(entry['uniandino_proof_request'])['non_revoked']['to'])
user['schemas_for_uniandino'], user['cred_defs_for_uniandino'], \
user['revoc_states_for_uniandino'] = \
await prover_get_entities_from_ledger(user['pool'], user['did'],
user['creds_for_uniandino_proof'], user['name'], None, requested_timestamp)
logger.info("\"" + user['name'] + "\" -> Create \"Uniandino\" Proof")
revoc_states_for_uniandino = json.loads(
user['revoc_states_for_uniandino'])
timestamp_for_attr1 = get_timestamp_for_attribute(
cred_for_attr1, revoc_states_for_uniandino)
timestamp_for_attr2 = get_timestamp_for_attribute(
cred_for_attr2, revoc_states_for_uniandino)
timestamp_for_attr3 = get_timestamp_for_attribute(
cred_for_attr3, revoc_states_for_uniandino)
timestamp_for_attr4 = get_timestamp_for_attribute(
cred_for_attr4, revoc_states_for_uniandino)
timestamp_for_attr5 = get_timestamp_for_attribute(
cred_for_attr5, revoc_states_for_uniandino)
user['uniandino_requested_creds'] = json.dumps({
'self_attested_attributes': {},
'requested_attributes': {
'attr1_referent': {
'cred_id': cred_for_attr3['referent'],
'revealed': True,
'timestamp': timestamp_for_attr1
},
'attr2_referent': {
'cred_id': cred_for_attr3['referent'],
'revealed': True,
'timestamp': timestamp_for_attr2
},
'attr3_referent': {
'cred_id': cred_for_attr3['referent'],
'revealed': True,
'timestamp': timestamp_for_attr3
},
'attr4_referent': {
'cred_id': cred_for_attr4['referent'],
'revealed': True,
'timestamp': timestamp_for_attr4
},
'attr5_referent': {
'cred_id': cred_for_attr4['referent'],
'revealed': True,
'timestamp': timestamp_for_attr5
}
},
'requested_predicates': {}
})
user['uniandino_proof'] = \
await anoncreds.prover_create_proof(user['wallet'], user['uniandino_proof_request'],
user['uniandino_requested_creds'], user['master_secret_id'],
user['schemas_for_uniandino'],
user['cred_defs_for_uniandino'],
user['revoc_states_for_uniandino'])
logger.info("\"" + user['name'] +
"\" -> Send \"Uniandino\" Proof to Sicua")
sicua['uniandino_proof'] = user['uniandino_proof']
uniandino_proof_object = json.loads(sicua['uniandino_proof'])
logger.info(
"\"Sicua\" -> Get Schemas, Credential Definitions and Revocation Registries from Ledger"
" required for Proof verifying")
sicua['schemas_for_uniandino'], sicua['cred_defs_for_uniandino'], \
sicua['revoc_ref_defs_for_uniandino'], sicua['revoc_regs_for_uniandino'] = \
await verifier_get_entities_from_ledger(sicua['pool'], sicua['did'],
uniandino_proof_object['identifiers'], sicua['name'], requested_timestamp)
logger.info("\"Sicua\" -> Verify \"Uniandino\" Proof from " +
user['name'])
assert 'student' == \
uniandino_proof_object['requested_proof']['revealed_attrs']['attr4_referent']['raw']
assert '12345' == \
uniandino_proof_object['requested_proof']['revealed_attrs']['attr3_referent']['raw']
assert '54321' == uniandino_proof_object['requested_proof'][
'revealed_attrs']['attr5_referent']['raw']
assert 'Joven' == uniandino_proof_object['requested_proof'][
'revealed_attrs']['attr2_referent']['raw']
assert 'Susan' == uniandino_proof_object['requested_proof'][
'revealed_attrs']['attr1_referent']['raw']
await get_into()
await get_sicua()
assert await anoncreds.verifier_verify_proof(
entry['uniandino_proof_request'], entry['uniandino_proof'],
entry['schemas_for_uniandino'], entry['cred_defs_for_uniandino'],
entry['revoc_ref_defs_for_uniandino'],
entry['revoc_regs_for_uniandino'])
logger.info("==============================")
logger.info("==============================")
logger.info("== Credential revocation - Uniandes revokes" + user['name'] +
"'s Uniandino ==")
logger.info("------------------------------")
logger.info("\"Uniandes\" - Revoke credential")
uniandes['susan_cert_rev_reg_delta'] = \
await anoncreds.issuer_revoke_credential(uniandes['wallet'],
uniandes['blob_storage_reader_cfg_handle'],
uniandes['revoc_reg_id'],
uniandes['uniandino_cred_rev_id'])
logger.info("\"Uniandes\" - Post RevocationRegistryDelta to Ledger")
uniandes['revoc_reg_entry_req'] = \
await ledger.build_revoc_reg_entry_request(uniandes['did'], uniandes['revoc_reg_id'], 'CL_ACCUM',
uniandes['susan_cert_rev_reg_delta'])
await ledger.sign_and_submit_request(uniandes['pool'], uniandes['wallet'],
uniandes['did'],
uniandes['revoc_reg_entry_req'])
