from indy import anoncreds, crypto, did, ledger, pool, wallet
import os, json, time
from collections import defaultdict

# procedures we wrote to support the notebook examples
from supporting_procedures import (prover_create_revocation_states, extract_revocation_time_from_proof_request,
                           verifier_get_revocation_info_for_proof_verification)

from indy.error import PoolLedgerConfigAlreadyExistsError

# keep memory of the handle to close the pool in case of error
pool_handle_for_closing = None

pool_genesis_txn_path = os.path.join(os.pardir,"config-file.txt")
pool_config = json.dumps({"genesis_txn": str(pool_genesis_txn_path)})
pool_name = 'pool1'
await pool.set_protocol_version(2)

async def create_and_open_pool(pool_name, pool_config):
    global pool_handle_for_closing
    await pool.create_pool_ledger_config(pool_name, pool_config)
    print("Pool successfully created")
    print("Establishing a connection to the pool ...")
    pool_handle = await pool.open_pool_ledger(pool_name, None)
    print("Connection Established! Pool handle: {}".format(pool_handle))
    try:
        pool_handle
    except NameError:
        pool_handle = None

    if pool_handle is not None:
        pool_handle_for_closing = pool_handle

try:
    await create_and_open_pool(pool_name, pool_config)
except:
    print("A pool with such a configuration was already existing")
    try:
        await pool.delete_pool_ledger_config(pool_name)
        print("The pool has been deleted!\nCreation of a new one...")
        await create_and_open_pool(pool_name, pool_config)
    except:
        print("It seems the pool is still opened.\nClosing the pool")
        await pool.close_pool_ledger(pool_handle_for_closing)
        ("The pool has been closed!")
        await pool.delete_pool_ledger_config(pool_name)
        ("The pool has been deleted!\nCreation of a new one...")
        await create_and_open_pool(pool_name, pool_config)

# we retrieve the last available pool_handle to be used later
pool_handle = pool_handle_for_closing

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 wallet.create_wallet(steward['wallet_config'], steward['wallet_credentials'])
steward['wallet'] = await wallet.open_wallet(steward['wallet_config'], steward['wallet_credentials'])

# Creation of the did using the seed specified above
steward['did_info'] = json.dumps({'seed': steward['seed']})
steward['did'], steward['key'] = await did.create_and_store_my_did(steward['wallet'], steward['did_info'])

steward['did']

# Creation of the did using another seed
# we use a 32bytes string as seed
did_json_config = json.dumps({'seed': 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'})
new_did, new_key = await did.create_and_store_my_did(steward['wallet'], did_json_config)
new_did,new_key

# create a wallet for the Govt.
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 wallet.create_wallet(government['wallet_config'], government['wallet_credentials'])
government['wallet'] = await wallet.open_wallet(government['wallet_config'], government['wallet_credentials'])

# create a Govt did to be used in the onboarding with the Steward
# govt_did_for_steward := the did Govt creates to interact with the Steward
# govt_key_for_steward := the ver key assigned to the did above

govt_did_for_steward, govt_key_for_steward = await did.create_and_store_my_did(government['wallet'], "{}")
govt_did_for_steward,govt_key_for_steward

# from: Steward --- to: Government
# create adhoc dids for the onboarding between steward and govt.
(steward_did_for_govt, steward_key_for_govt) = await did.create_and_store_my_did(steward['wallet'], "{}")
(steward_did_for_govt,steward_key_for_govt)

# send nym request to ledger
# the steward registers its new did
nym_request = await ledger.build_nym_request(steward['did'], steward_did_for_govt, steward_key_for_govt, None, None)
receipt = await ledger.sign_and_submit_request(steward['pool'], steward['wallet'], steward['did'], nym_request)
receipt

# Steward says: here are my did and my nonce for the challenge
connection_request = {
    'did': steward_did_for_govt,
    'nonce': 123456789
}
connection_request

# Govt gets the verkey associated to steward_did_for_govt directly from the ledger
steward_key_for_govt_in_ledger = await did.key_for_did(government['pool'], government['wallet'], connection_request['did'])
steward_key_for_govt_in_ledger

assert steward_key_for_govt_in_ledger == steward_key_for_govt

government['response_for_stward_clear'] = json.dumps({
    'did': govt_did_for_steward,
    'verkey': govt_key_for_steward,
    'nonce': connection_request['nonce']
})

# Govt. encryptes the previous info using the Steward's Pubkey it got back from the ledger
government['response_for_stward_encrypted'] = \
        await crypto.anon_crypt(steward_key_for_govt_in_ledger,\
                                government['response_for_stward_clear'].encode('utf-8'))

steward['response_from_Govt_encrypted'] = government['response_for_stward_encrypted']

# To decrypt the Steward provides the vekey she got in creation phase of the did with which she interacts with the Govt.
steward['response_from_Govt_clear'] = \
        json.loads((await crypto.anon_decrypt(steward['wallet'], steward_key_for_govt,
                                              steward['response_from_Govt_encrypted'])).decode("utf-8"))

#check if the secret is valid
assert steward['response_from_Govt_clear']['nonce'] == connection_request['nonce']

nym_request = await ledger.build_nym_request(steward['did'],\
                                             steward['response_from_Govt_clear']['did'] ,\
                                             steward['response_from_Govt_clear']['verkey'],\
                                             None, None)
await ledger.sign_and_submit_request(steward['pool'], steward['wallet'], steward['did'], nym_request)

# create a new did for Govt.
# save it inside the dictionary data structure used here just to signal that this is the did Govt uses for SSI
government['did'], government['key'] = await did.create_and_store_my_did(government['wallet'], "{}")

# create the message to send to the Steward
government['did_info'] = json.dumps({
    'did': government['did'],
    'verkey': government['key']
})
government['did_info']

# govt_key_for_steward (the sender)
# steward_key_for_govt_in_ledger(the receiver)
authcrypted_government_did_info_json = \
    await crypto.auth_crypt(government['wallet'],govt_key_for_steward, steward_key_for_govt_in_ledger, government['did_info'].encode('utf-8'))

# Steward receives the encrypted msg from Govt.
# NOTE: the auth_decrypt method will be deprecated
from_verkey, decrypted_message_json = \
    await crypto.auth_decrypt(steward['wallet'], steward_key_for_govt, authcrypted_government_did_info_json)
govt_did_info = json.loads(decrypted_message_json.decode('utf-8'))

from_verkey, govt_did_info

#Steward asks the ledger for the verKey of the Govt.
retrived_pubkey_govt_for_steward = await did.key_for_did(steward['pool'], steward['wallet'],govt_did_for_steward)
retrived_pubkey_govt_for_steward

assert from_verkey == retrived_pubkey_govt_for_steward

nym_request = await ledger.build_nym_request(steward['did'], govt_did_info['did'],
                                             govt_did_info['verkey'], None, 'TRUST_ANCHOR')
await ledger.sign_and_submit_request(steward['pool'], steward['wallet'], steward['did'], nym_request)

#create a new did and a new key for the steward agent
new_did, new_key = await did.create_and_store_my_did(steward['wallet'],'{}')
new_did, new_key

#We then send the nym request using the Govt did that has the role of TA
nym_request = await ledger.build_nym_request(government['did'],new_did,
                                             new_key, None, None)
await ledger.sign_and_submit_request(government['pool'], government['wallet'], government['did'], nym_request)

# create new did-key for govt
new_gov_did, new_gov_key = await did.create_and_store_my_did(government['wallet'],'{}')
new_gov_did, new_gov_key

# make the Steward add them to the ledger but without a specific role
nym_request = await ledger.build_nym_request(steward['did'], new_gov_did,
                                             new_gov_key, None, None)
await ledger.sign_and_submit_request(steward['pool'], steward['wallet'], steward['did'], nym_request)

# create new pair did-key for the steward wallet
new_did, new_key = await did.create_and_store_my_did(government['wallet'],'{}')
new_did, new_key

# try to use the govt did with a user role to send a nym transaction
nym_request = await ledger.build_nym_request(new_gov_did,new_did,
                                             new_key, None, None)
await ledger.sign_and_submit_request(government['pool'], government['wallet'], new_gov_did, nym_request)

# try to change the role of an already deployed did
nym_request = await ledger.build_nym_request(steward['did'], new_gov_did,
                                             new_gov_key, None, 'TRUST_ANCHOR')
await ledger.sign_and_submit_request(steward['pool'], steward['wallet'], steward['did'], nym_request)

async def onboarding(Alice, Bob):
    # we assume that Alice can send nym transaction to the ledger
    # we use Alice as the "from account" and Bob as the "to account"

    # create ad-hoc dids for the connection

    # Alice creates a new did-key pair
    (Alice_did_for_Bob, Alice_key_for_Bob) = await did.create_and_store_my_did(Alice['wallet'], "{}")

    # Alice_did_for_Bob : Alice creates a did on purpose for Bob, she wants Bob to know her with this did
    # Alice_key_for_Bob: the verkey(e.g. PubKey) of the previous did

    # assuming Alice can send nym transaction, she register her new did in the ledger
    nym_request = await ledger.build_nym_request(Alice['did'],Alice_did_for_Bob, Alice_key_for_Bob, None, None)
    await ledger.sign_and_submit_request(Alice['pool'], Alice['wallet'], Alice['did'], nym_request)

    connection_request = {
        'did': Alice_did_for_Bob,
        'nonce': 123456789
    }

    # if Bob doesn't have a wallet for his did we create a new one
    if 'wallet' not in Bob:
        try:
            await wallet.create_wallet(Bob['wallet_config'], Bob['wallet_credentials'])
        except IndyError as ex:
            if ex.error_code == ErrorCode.PoolLedgerConfigAlreadyExistsError:
                pass
        Bob['wallet'] = await wallet.open_wallet(Bob['wallet_config'], Bob['wallet_credentials'])

    # we then create a did that Bob will use to connect with Alice
    (Bob_did_for_Alice, Bob_key_for_Alice) = await did.create_and_store_my_did(Bob['wallet'], "{}")

    # Bob asks the ledger for the verkey of the did Alice sent him in the connection request
    # this should be the same as Alice_key_for_Bob
    Alice_verkey_for_Bob = await did.key_for_did(Bob['pool'], Bob['wallet'], connection_request['did'])

    # Bob creates a response for Alice to solve the random challenge
    # Bob wants to say: Ehi Alice here are my did, my verkey and the secret you sent to me
    Bob['connection_response'] = json.dumps({
        'did': Bob_did_for_Alice,
        'verkey': Bob_key_for_Alice,
        'nonce': connection_request['nonce']
    })

    # Bob encrypts the response he wants to send to Alice
    # he uses the verkey of Alice that he got from the ledger
    Bob['anoncrypted_connection_response'] = \
        await crypto.anon_crypt(Alice_verkey_for_Bob, Bob['connection_response'].encode('utf-8'))

    # Alice receives the encrypted message
    Alice['anoncrypted_connection_response'] = Bob['anoncrypted_connection_response']

    # Alice decryptes the message
    Alice['connection_response'] = \
        json.loads((await crypto.anon_decrypt(Alice['wallet'], Alice_key_for_Bob,
                                              Alice['anoncrypted_connection_response'])).decode("utf-8"))

    # check that the random challenge is solved
    assert connection_request['nonce'] == Alice['connection_response']['nonce']

    # Alice sends the nym request to the ledger in order to register the did of Bob
    nym_request = await ledger.build_nym_request(Alice['did'],Bob_did_for_Alice, Bob_key_for_Alice, None, None)
    await ledger.sign_and_submit_request(Alice['pool'], Alice['wallet'], Alice['did'], nym_request)

    return Alice_did_for_Bob, Alice_key_for_Bob, Bob_did_for_Alice, Bob_key_for_Alice, Bob['connection_response']

# government creates a schema for the credential transcript. It sets the semantics basis
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']

# build the schema request and send it to the ledger
schema_request = await ledger.build_schema_request(government['did'], government['transcript_schema'])
await ledger.sign_and_submit_request(government['pool'], government['wallet'], government['did'], schema_request)

# in the same way the govt sends a schema definition to the ledger for the Job Certificate
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']

schema_request = await ledger.build_schema_request(government['did'], government['job_certificate_schema'])
await ledger.sign_and_submit_request(government['pool'], government['wallet'], government['did'], schema_request)

# Let's first of all create a wallet for Faber and save one of its did as TA
faber = {
  'name': "Faber College",
  'wallet_config': json.dumps({'id': 'faber_wallet'}),
  'wallet_credentials': json.dumps({'key': 'faber_wallet_key'}),
  'pool': pool_handle,
  'seed': '000000000000000000000000Faber001'
}
await wallet.create_wallet(faber['wallet_config'], faber['wallet_credentials'])
faber['wallet'] = await wallet.open_wallet(faber['wallet_config'], faber['wallet_credentials'])

faber['did'], faber['key'] = await did.create_and_store_my_did(faber['wallet'],json.dumps({'seed':faber['seed']}))

# the Steward sends the nym transaction to the ledger to assign the role of TA to faber['did']
nym_request = await ledger.build_nym_request(steward['did'],faber['did'],faber['key'],None,'TRUST_ANCHOR')
await ledger.sign_and_submit_request(steward['pool'],steward['wallet'],steward['did'],nym_request)

# get the schema from the ledger
get_schema_request = await ledger.build_get_schema_request(faber['did'], transcript_schema_id)
get_schema_response = await ledger.submit_request(faber['pool'], get_schema_request)
faber['transcript_schema_id'], faber['transcript_schema'] = await ledger.parse_get_schema_response(get_schema_response)

faber['transcript_schema']

government['transcript_schema']

faber['transcript_schema_id'] == government['transcript_schema_id']

# Faber creates and send the credential definition
transcript_cred_def = {
    'tag': 'TAG1',
    'type': 'CL',
    'config': {"support_revocation": False}
}
(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']))

# send the request to the ledger
cred_def_request = await ledger.build_cred_def_request(faber['did'], faber['transcript_cred_def'])
receipt = await ledger.sign_and_submit_request(faber['pool'], faber['wallet'], faber['did'], cred_def_request)

# create a did for ACME and register it as TA into the ledger
acme = {
  'name': "Acme",
  'wallet_config': json.dumps({'id': 'acme_wallet'}),
  'wallet_credentials': json.dumps({'key': 'acme_wallet_key'}),
  'pool': pool_handle,
  'seed': '000000000000000000000000Acme0001'
}
await wallet.create_wallet(acme['wallet_config'], acme['wallet_credentials'])
acme['wallet'] = await wallet.open_wallet(acme['wallet_config'], acme['wallet_credentials'])
acme['did'], acme['key'] = await did.create_and_store_my_did(acme['wallet'],json.dumps({'seed':acme['seed']}))

just_an_other_did_for_acme, just_an_other_key_for_acme = await did.create_and_store_my_did(acme['wallet'],'{}')

nym_request = await ledger.build_nym_request(steward['did'],acme['did'],acme['key'],None,'TRUST_ANCHOR')
await ledger.sign_and_submit_request(steward['pool'],steward['wallet'],steward['did'],nym_request)

get_schema_request = await ledger.build_get_schema_request(acme['did'], job_certificate_schema_id)
get_schema_response = await ledger.submit_request(acme['pool'], get_schema_request)
acme['job_certificate_schema_id'], acme['job_certificate_schema'] = await ledger.parse_get_schema_response(get_schema_response)

acme['job_certificate_schema_id'] == government['job_certificate_schema_id']

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']))

cred_def_request = await ledger.build_cred_def_request(acme['did'], acme['job_certificate_cred_def'])
receipt = await ledger.sign_and_submit_request(acme['pool'], acme['wallet'], acme['did'], cred_def_request)

from indy import blob_storage

# acme creates a revocation registry
from pathlib import Path

acme['tails_writer_config'] = json.dumps({'base_dir': str(Path.home().joinpath('.indy_client').joinpath("tails")), 'uri_pattern': ''})
acme['tails_writer'] = await blob_storage.open_writer('default', acme['tails_writer_config'])

revoc_reg_def_data = {
    'tag': 'cred_def_tag',
    'config': json.dumps({"max_cred_num": 5, 'issuance_type': 'ISSUANCE_ON_DEMAND'})
}

(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',
                                                          revoc_reg_def_data['tag'],
                                                          acme['job_certificate_cred_def_id'],
                                                          revoc_reg_def_data['config'],
                                                          acme['tails_writer'])

# build a request for revocation reg definition, Send it to the ledger
# this adds a REVOC_REG_DEF to an exixting credential definition
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'])

# Request to add the RevocReg entry containing the new accumulator value and issued/revoked indices
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'])

# create Alice wallet and did
alice = {
    'name': 'Alice',
    'wallet_config': json.dumps({'id': 'alice_wallet'}),
    'wallet_credentials': json.dumps({'key': 'alice_wallet_key'}),
    'pool': pool_handle
}
await wallet.create_wallet(alice['wallet_config'], alice['wallet_credentials'])
alice['wallet'] = await wallet.open_wallet(alice['wallet_config'], alice['wallet_credentials'])

faber_did_for_alice,faber_key_for_alice, \
alice_did_for_faber, alice_key_for_faber,\
connection_response_alice_to_faber = await onboarding(faber,alice)

 faber['transcript_cred_offer'] = await anoncreds.issuer_create_credential_offer(faber['wallet'], faber['transcript_cred_def_id'])

# Faber retrieves the verkey of Alice's known did
key_of_alice_did_know_to_faber = await did.key_for_did(faber['pool'],faber['wallet'],alice_did_for_faber)

# expected to be True, since Faber gets back the key of the did that Alice decided to use in their pairwise connection
key_of_alice_did_know_to_faber == alice_key_for_faber

faber['authcrypted_transcript_cred_offer'] = await crypto.auth_crypt(faber['wallet'],\
                                                                    faber_key_for_alice,
                                                                    key_of_alice_did_know_to_faber,
                                                                    faber['transcript_cred_offer'].encode("utf-8"))

alice['authcrypted_transcript_cred_offer'] = faber['authcrypted_transcript_cred_offer']

# Alice decrypts it
_,encoded_transcript_offer = await crypto.auth_decrypt(alice['wallet'],alice_key_for_faber,alice['authcrypted_transcript_cred_offer'])

alice['transcript_cred_offer'] = encoded_transcript_offer.decode("utf-8")

# check that Alice got the original message without tampering
assert alice['transcript_cred_offer'] == faber['transcript_cred_offer']

schema_id = json.loads(alice['transcript_cred_offer'])['schema_id']

get_schema_request = await ledger.build_get_schema_request(alice_did_for_faber, schema_id)
get_schema_response = await ledger.submit_request(alice['pool'], get_schema_request)
transcript_id, transcript_schema = await ledger.parse_get_schema_response(get_schema_response)

print(transcript_schema)

alice['master_secret_id'] = await anoncreds.prover_create_master_secret(alice['wallet'], None)

cred_def_id = json.loads(alice['transcript_cred_offer'])['cred_def_id']

get_cred_def_request = await ledger.build_get_cred_def_request(alice_did_for_faber,cred_def_id )
get_cred_def_response = await ledger.submit_request(alice['pool'], get_cred_def_request)
alice['transcript_cred_def_id'], alice['transcript_cred_def'] = await ledger.parse_get_cred_def_response(get_cred_def_response)

(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['transcript_cred_def'], alice['master_secret_id'])

# We can see how Alice gets the role of the prover. Her did is indeed the value of "prover_did" key
alice_did_for_faber == json.loads(alice['transcript_cred_request'])['prover_did']

alice['authcrypted_transcript_cred_request'] = await crypto.auth_crypt(alice['wallet'],\
                                                                alice_key_for_faber,
                                                                faber_key_for_alice,
                                                                alice['transcript_cred_request'].encode("utf-8"))

# Faber receives the encrypted message
faber['authcrypted_transcript_cred_request'] = alice['authcrypted_transcript_cred_request']

_ , encoded_transcript_request = await crypto.auth_decrypt(faber['wallet'],faber_key_for_alice,\
                                                faber['authcrypted_transcript_cred_request'])

faber['transcript_cred_request'] = encoded_transcript_request.decode("utf-8")

# check no tapering
assert faber['transcript_cred_request'] == alice['transcript_cred_request']

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['transcript_cred_offer'] -> created by Faber and sent to Alice
# faber['transcript_cred_request'] -> after offer received, created by Alice and sent to Faber
# then Faber combines the offer and the request with the credential values provided in order to issue the credential
faber['transcript_cred'], _, _ = \
  await anoncreds.issuer_create_credential(faber['wallet'], faber['transcript_cred_offer'], faber['transcript_cred_request'],
                                           transcript_cred_values, None, None)

# assume encrypted exchange here as done in previous steps
alice['transcript_cred'] = faber['transcript_cred']

# alice['transcript_cred'] : full credentials received from Faber
await anoncreds.prover_store_credential(alice['wallet'], None, alice['transcript_cred_request_metadata'], alice['transcript_cred'],
                                        alice['transcript_cred_def'], None)

acme['did_for_alice'], acme['key_for_alice'],alice['did_for_acme'], alice['key_for_acme'], \
    acme['alice_connection_response'] = await onboarding(acme, alice)

acme['did_for_alice']

json.dumps({
    'nonce': '1432422343242122312411212',
      'name': 'Job-Application',
      'version': '0.1',
      'requested_attributes': {
          'attr1_referent': {
              'name': 'first_name'
          }}})

# proof request from Acme
acme['job_application_proof_request'] = 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']}]
          }
      }
  })

# Acme will use this key to encrypt messages to Alice
acme['alice_key_for_acme'] = \
    await did.key_for_did(acme['pool'], acme['wallet'], json.loads(acme['alice_connection_response'])['did'])

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'))

alice['authcrypted_job_application_proof_request'] = acme['authcrypted_job_application_proof_request']

alice['acme_key_for_alice'], alice['job_application_proof_request_encoded'] = \
await crypto.auth_decrypt(alice['wallet'], alice['key_for_acme'],\
                           alice['authcrypted_job_application_proof_request'])

alice['job_application_proof_request'] = alice['job_application_proof_request_encoded'].decode("utf-8")

alice['job_application_proof_request']

# Search for credentials matching the given proof request.
# Instead of immediately returning of fetched credentials this call returns search_handle that can be used later
# to fetch records by small batches (with prover_fetch_credentials_for_proof_req).

search_for_job_application_proof_request = \
    await anoncreds.prover_search_credentials_for_proof_req(alice['wallet'],
                                                            alice['job_application_proof_request'], None)

# it returns a search handle that will be fetched on request
search_for_job_application_proof_request

# this procedure gets the search handle and a given referent requested by Acme returns credential information
# it is important to look at how the results are fetched
async def get_credential_for_referent(search_handle, referent):
    credentials = json.loads(
        await anoncreds.prover_fetch_credentials_for_proof_req(search_handle, referent, 10))
    return credentials[0]['cred_info']

# fetch the attributes requested by Acme and create the relative credential
cred_for_attr1 = await get_credential_for_referent(search_for_job_application_proof_request, 'attr1_referent')
cred_for_attr2 = await get_credential_for_referent(search_for_job_application_proof_request, 'attr2_referent')
cred_for_attr3 = await get_credential_for_referent(search_for_job_application_proof_request, 'attr3_referent')
cred_for_attr4 = await get_credential_for_referent(search_for_job_application_proof_request, 'attr4_referent')
cred_for_attr5 = await get_credential_for_referent(search_for_job_application_proof_request, 'attr5_referent')
cred_for_predicate1 = \
    await get_credential_for_referent(search_for_job_application_proof_request, 'predicate1_referent')

# let's look inside one of them
cred_for_attr1

# after the relevant data are retreived we can close the search handle
await anoncreds.prover_close_credentials_search_for_proof_req(search_for_job_application_proof_request)

# prepare the credentials to fill the application
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['creds_for_job_application_proof']

# these procedures allow the prover to retrieve from the ledger the relevant schemas and definitions
async def get_schema(pool_handle, _did, schema_id):
    get_schema_request = await ledger.build_get_schema_request(_did, schema_id)
    get_schema_response = await ledger.submit_request(pool_handle, get_schema_request)
    return await ledger.parse_get_schema_response(get_schema_response)


async def get_cred_def(pool_handle, _did, cred_def_id):
    get_cred_def_request = await ledger.build_get_cred_def_request(_did, cred_def_id)
    get_cred_def_response = await ledger.submit_request(pool_handle, get_cred_def_request)
    return await ledger.parse_get_cred_def_response(get_cred_def_response)

async def prover_get_schemas_and_definitions_from_ledger(pool_handle, _did, identifiers):
    """
    This takes the identifiers (response to a Credential Request) and returns Credentials Schemas and Definitions
    """
    schemas = {}
    cred_defs = {}
    for item in identifiers.values():
        (received_schema_id, received_schema) = await get_schema(pool_handle, _did, item['schema_id'])
        schemas[received_schema_id] = json.loads(received_schema)

        (received_cred_def_id, received_cred_def) = await get_cred_def(pool_handle, _did, item['cred_def_id'])
        cred_defs[received_cred_def_id] = json.loads(received_cred_def)

    return json.dumps(schemas), json.dumps(cred_defs)

alice['schemas'], alice['cred_defs'] = \
        await prover_get_schemas_and_definitions_from_ledger(alice['pool'], alice['did_for_acme'],
                                              alice['creds_for_job_application_proof'])

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},
        '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']}}
})

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'], alice['cred_defs'], '{}') # empty dict because no revocation states

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'))

# recall to encrypt we need to pass to auth_crypt:
# wallet_handle: int,
# sender_vk: str,
# recipient_vk: str,
#  msg: bytes(encoded)

# here with 'acme_key_for_alice' we mean: the key acme produced to interact with alice (it is the recipient key)
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"))

# send this encrypted proof to Acme
acme['authcrypted_job_application_proof'] = alice['authcrypted_job_application_proof']

# Acme then decryptes the msg
# recall that the auth_decrypt returns a tuple (key, bytes(msg))
_, acme['job_application_proof_encoded'] = await crypto.auth_decrypt(acme['wallet'],acme['key_for_alice'],\
                                                                    acme['authcrypted_job_application_proof'])

acme['job_application_proof'] = acme['job_application_proof_encoded'].decode("utf-8")

# check that the proof Alice computed is the one that Acme got

assert alice['job_application_proof'] == acme['job_application_proof']

async def verifier_get_schemas_and_definitions_from_ledger(pool_handle, _did, identifiers):
    schemas = {}
    cred_defs = {}
    for item in identifiers:
        (received_schema_id, received_schema) = await get_schema(pool_handle, _did, item['schema_id'])
        schemas[received_schema_id] = json.loads(received_schema)

        (received_cred_def_id, received_cred_def) = await get_cred_def(pool_handle, _did, item['cred_def_id'])
        cred_defs[received_cred_def_id] = json.loads(received_cred_def)

    return json.dumps(schemas), json.dumps(cred_defs)

acme['schemas'], acme['cred_defs'] = \
        await verifier_get_schemas_and_definitions_from_ledger(acme['pool'], acme['did'],
                                                json.loads(acme['job_application_proof'])['identifiers'])

decrypted_job_application_proof = json.loads(acme['job_application_proof'])

# Assert that all the fields are consistent
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']

acme['job_application_proof_request']

assert await anoncreds.verifier_verify_proof(acme['job_application_proof_request'], acme['job_application_proof'],
                                                 acme['schemas'], acme['cred_defs'], '{}','{}')
                                            # empty dicts for the last arguments because no revocation is present

 acme['job_certificate_cred_offer'] = await anoncreds.issuer_create_credential_offer(acme['wallet'], acme['job_certificate_cred_def_id'])

### ASSUME SECRET EXCHANGE ###
alice['job_certificate_cred_offer'] = acme['job_certificate_cred_offer']

job_cred_def_id = json.loads(alice['job_certificate_cred_offer'])['cred_def_id']

# we find the usual pattern: build request -> submit request -> parse response
get_cred_def_request = await ledger.build_get_cred_def_request(alice['did_for_acme'],job_cred_def_id )
get_cred_def_response = await ledger.submit_request(alice['pool'], get_cred_def_request)

alice['job_certificate_cred_def_id'], alice['job_certificate_cred_def'] = \
    await ledger.parse_get_cred_def_response(get_cred_def_response)

# a check
job_cred_def_id == alice['job_certificate_cred_def_id']

alice['job_certificate_cred_req'], alice['job_certificate_cred_req_metadata'] = \
    await anoncreds.prover_create_credential_req(alice['wallet'], alice['did_for_acme'], alice['job_certificate_cred_offer'],
                                                 alice['job_certificate_cred_def'], alice['master_secret_id'])

acme['job_certificate_cred_req'] = alice['job_certificate_cred_req']

acme['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 opens the storage reader
acme['blob_storage_reader'] = 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_req'],
                                             acme['job_certificate_cred_values'],
                                             acme['revoc_reg_id'],
                                             acme['blob_storage_reader'])

# this is the local id of for revocation info of the credential
acme['job_certificate_cred_rev_id']

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'])

# Alice gets the job certificate credential
alice['job_certificate_cred'] = acme['job_certificate_cred']

# build the request
alice['acme_revoc_reg_des_req'] = \
        await ledger.build_get_revoc_reg_def_request(alice['did_for_acme'],
                                                     json.loads(alice['job_certificate_cred'])['rev_reg_id'])

# send the request
alice['acme_revoc_reg_des_resp'] = await ledger.submit_request(alice['pool'], alice['acme_revoc_reg_des_req'])

(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'])

 await anoncreds.prover_store_credential(alice['wallet'], None, alice['job_certificate_cred_req_metadata'],
                                          alice['job_certificate_cred'], alice['job_certificate_cred_def'], alice['acme_revoc_reg_def_json'])

thrift = {
  'name': "Thrift Bank",
  'wallet_config': json.dumps({'id': 'thrift_wallet'}),
  'wallet_credentials': json.dumps({'key': 'thrift_wallet_key'}),
  'pool': pool_handle,
  'seed': '000000000000000000000000Thrift01'
}
await wallet.create_wallet(thrift['wallet_config'], thrift['wallet_credentials'])
thrift['wallet'] = await wallet.open_wallet(thrift['wallet_config'], thrift['wallet_credentials'])

thrift['did'], thrift['key'] = await did.create_and_store_my_did(thrift['wallet'],json.dumps({'seed':thrift['seed']}))

nym_request = await ledger.build_nym_request(steward['did'],thrift['did'],thrift['key'],None,'TRUST_ANCHOR')
res = await ledger.sign_and_submit_request(steward['pool'],steward['wallet'],steward['did'],nym_request)

thrift['apply_loan_proof_request'] = 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']}]
      }
  },
  'non_revoked': {'to': int(time.time())}
})

# Alice gets the request
alice['apply_loan_proof_request'] = thrift['apply_loan_proof_request']

# Alice search for the credential to be used to answer back the request
search_for_apply_loan_proof_request = \
        await anoncreds.prover_search_credentials_for_proof_req(alice['wallet'],
                                                                alice['apply_loan_proof_request'], None)

# we use the procedure written in the previously when retrieving data using the search handle

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')

# close the search handle
await anoncreds.prover_close_credentials_search_for_proof_req(search_for_apply_loan_proof_request)

# as we can see Alice has only one credential that meets all the proof requirements
cred_for_attr1

# in order to query it Alice needs to open a storage reader
alice['tails_reader_config'] = json.dumps({'base_dir': str(Path.home().joinpath('.indy_client').joinpath("tails")), 'uri_pattern': ''})
alice['blob_storage_reader'] = await blob_storage.open_reader('default', alice['tails_reader_config'])

_from, to = extract_revocation_time_from_proof_request(alice['apply_loan_proof_request'])

_from, to

alice['apply_loan_requested_creds'] = json.dumps({
        'self_attested_attributes': {},
        'requested_attributes': {
            'attr1_referent': {'cred_id': cred_for_attr1['referent'], 'revealed': True, 'timestamp': to}
        },
        'requested_predicates': {
            'predicate1_referent': {'cred_id': cred_for_predicate1['referent'], 'timestamp': to},
            'predicate2_referent': {'cred_id': cred_for_predicate2['referent'], 'timestamp': to}
        }
    })

alice['creds_for_loan_application_proof'] = {cred_for_attr1['referent']: cred_for_attr1,
                                             cred_for_predicate1['referent']: cred_for_predicate1,
                                             cred_for_predicate2['referent']: cred_for_predicate2}

alice['creds_for_loan_application_proof']

# all schemas json participating in the proof request in dict with pair (key=schema_id, value=schema_json)
# all cred defs json participating in the proof request in dict with pair (key=cred_def_id, value=cred_def_json)
alice['loan_schemas'], alice['loan_cred_defs'] = \
        await prover_get_schemas_and_definitions_from_ledger(alice['pool'], alice['did_for_acme'],
                                              alice['creds_for_loan_application_proof'])

alice['revoc_states_for_loan_app'] = await prover_create_revocation_states(alice['pool'], alice['blob_storage_reader'], alice['did_for_acme'],
                                            alice['creds_for_loan_application_proof'],
                                            _from=_from, _to= to)

alice['revoc_states_for_loan_app']

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['loan_schemas'], alice['loan_cred_defs'],
                                                alice['revoc_states_for_loan_app'])

# send the proof to Thrift
thrift['alice_apply_loan_proof'] = alice['apply_loan_proof']

json.loads(thrift['alice_apply_loan_proof'])['identifiers']

thrift['schemas_for_loan_app'],thrift['cred_defs_for_loan_app']=\
        await verifier_get_schemas_and_definitions_from_ledger(thrift['pool'],thrift['did'],
                                                json.loads(thrift['alice_apply_loan_proof'])['identifiers'])

json.loads(thrift['alice_apply_loan_proof'])['identifiers']

identifier = json.loads(thrift['alice_apply_loan_proof'])['identifiers'][0]

identifiers = json.loads(thrift['alice_apply_loan_proof'])['identifiers']

identifiers

revoc_reg_defs_json, revoc_regs_json = await verifier_get_revocation_info_for_proof_verification(thrift['pool'], thrift['did'], identifiers)

thrift['revoc_defs_for_loan_app'] = revoc_reg_defs_json
thrift['revoc_regs_for_loan_app'] = revoc_regs_json

assert await anoncreds.verifier_verify_proof(thrift['apply_loan_proof_request'],
                                             thrift['alice_apply_loan_proof'],
                                             thrift['schemas_for_loan_app'],
                                             thrift['cred_defs_for_loan_app'],
                                             thrift['revoc_defs_for_loan_app'],
                                             thrift['revoc_regs_for_loan_app'])

revoc_reg_defs_json

# issuer_revoke_credential will return a delta revocation registry that as such will be sent to the ledger
rev_reg_delta = await anoncreds.issuer_revoke_credential(acme['wallet'],
                                         acme['blob_storage_reader'],
                                         acme['revoc_reg_id'],
                                         acme['job_certificate_cred_rev_id'])

rev_reg_delta_request = \
        await ledger.build_revoc_reg_entry_request(acme['did'], acme['revoc_reg_id'], 'CL_ACCUM',
                                                   rev_reg_delta)

await ledger.sign_and_submit_request(acme['pool'], acme['wallet'], acme['did'],rev_reg_delta_request)

thrift['apply_loan_proof_request'] = 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']}]
      }
  },
  'non_revoked': {'to': int(time.time())}
})

# Alice gets the request
alice['apply_loan_proof_request'] = thrift['apply_loan_proof_request']

# Alice search for the credential to be used to answer back the request
search_for_apply_loan_proof_request = \
        await anoncreds.prover_search_credentials_for_proof_req(alice['wallet'],
                                                                alice['apply_loan_proof_request'], None)
# we use the procedure written in the previously when retrieving data using the search handle

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)

_from, to = extract_revocation_time_from_proof_request(alice['apply_loan_proof_request'])

alice['apply_loan_requested_creds'] = json.dumps({
        'self_attested_attributes': {},
        'requested_attributes': {
            'attr1_referent': {'cred_id': cred_for_attr1['referent'], 'revealed': True, 'timestamp': to}
        },
        'requested_predicates': {
            'predicate1_referent': {'cred_id': cred_for_predicate1['referent'], 'timestamp': to},
            'predicate2_referent': {'cred_id': cred_for_predicate2['referent'], 'timestamp': to}
        }
    })

alice['creds_for_loan_application_proof'] = {cred_for_attr1['referent']: cred_for_attr1,
                                             cred_for_predicate1['referent']: cred_for_predicate1,
                                             cred_for_predicate2['referent']: cred_for_predicate2}

alice['loan_schemas'], alice['loan_cred_defs'] = \
        await prover_get_schemas_and_definitions_from_ledger(alice['pool'], alice['did_for_acme'],
                                              alice['creds_for_loan_application_proof'])


alice['revoc_states_for_loan_app'] = await prover_create_revocation_states(alice['pool'], alice['blob_storage_reader'], alice['did_for_acme'],
                                            alice['creds_for_loan_application_proof'],
                                            _from=_from, _to= to)

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['loan_schemas'], alice['loan_cred_defs'],
                                                alice['revoc_states_for_loan_app'])

# send the proof to Thrift
thrift['alice_apply_loan_proof'] = alice['apply_loan_proof']

thrift['schemas_for_loan_app'],thrift['cred_defs_for_loan_app']=\
        await verifier_get_schemas_and_definitions_from_ledger(thrift['pool'],thrift['did'],
                                                json.loads(thrift['alice_apply_loan_proof'])['identifiers'])
identifiers = json.loads(thrift['alice_apply_loan_proof'])['identifiers']

revoc_reg_defs_json, revoc_regs_json = await verifier_get_revocation_info_for_proof_verification(thrift['pool'], thrift['did'], identifiers)

thrift['revoc_defs_for_loan_app'] = revoc_reg_defs_json
thrift['revoc_regs_for_loan_app'] = revoc_regs_json

assert await anoncreds.verifier_verify_proof(thrift['apply_loan_proof_request'],
                                             thrift['alice_apply_loan_proof'],
                                             thrift['schemas_for_loan_app'],
                                             thrift['cred_defs_for_loan_app'],
                                             thrift['revoc_defs_for_loan_app'],
                                             thrift['revoc_regs_for_loan_app'])