docs/getting-started/getting-started.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import asyncio\n",
    "import time\n",
    "import json\n",
    "\n",
    "from indy import anoncreds, did, ledger, pool, wallet, IndyError\n",
    "from indy.error import ErrorCode\n",
    "\n",
    "async def run():\n",
    "    print(\"Getting started -> started\")\n",
    "\n",
    "    # Set protocol version 2 to work with Indy Node 1.4\n",
    "    await pool.set_protocol_version(2)\n",
    "\n",
    "    pool_ = {\n",
    "        'name': 'pool1',\n",
    "        'config': json.dumps({\"genesis_txn\": '/home/indy/sandbox/pool_transactions_genesis'})\n",
    "    }\n",
    "    print(\"Open Pool Ledger: {}\".format(pool_['name']))\n",
    "\n",
    "    try:\n",
    "        await pool.create_pool_ledger_config(pool_['name'], pool_['config'])\n",
    "    except IndyError as ex:\n",
    "        if ex.error_code == ErrorCode.PoolLedgerConfigAlreadyExistsError:\n",
    "            pass\n",
    "    pool_['handle'] = await pool.open_pool_ledger(pool_['name'], None)\n",
    "\n",
    "    print(\"\\n=====================================================================\")\n",
    "    print(\"=== Getting Endorser credentials for Faber, Acme, Thrift and Government\")\n",
    "\n",
    "\n",
    "    steward = {\n",
    "        'name': \"Sovrin Steward\",\n",
    "        'wallet_config': json.dumps({'id': 'sovrin_steward_wallet'}),\n",
    "        'wallet_credentials': json.dumps({'key': 'steward_wallet_key'}),\n",
    "        'pool': pool_['handle'],\n",
    "        'seed': '000000000000000000000000Steward1'\n",
    "    }\n",
    "\n",
    "    await create_wallet(steward)\n",
    "\n",
    "    print(\"\\\"Sovrin Steward\\\" -> Create and store in Wallet DID from seed\")\n",
    "    steward['did_info'] = json.dumps({'seed': steward['seed']})\n",
    "    steward['did'], steward['key'] = await did.create_and_store_my_did(steward['wallet'], steward['did_info'])\n",
    "\n",
    "    print(\"\\n=====================================================================\")\n",
    "    print(\"== Getting Endorser credentials - Government getting Verinym\")\n",
    "\n",
    "\n",
    "    government = {\n",
    "        'name': 'Government',\n",
    "        'wallet_config': json.dumps({'id': 'government_wallet'}),\n",
    "        'wallet_credentials': json.dumps({'key': 'government_wallet_key'}),\n",
    "        'pool': pool_['handle'],\n",
    "        'role': 'ENDORSER'\n",
    "    }\n",
    "\n",
    "    await getting_verinym(steward, government)\n",
    "\n",
    "    print(\"\\n=====================================================================\")\n",
    "    print(\"== Getting Endorser credentials - Faber getting Verinym\")\n",
    "\n",
    "\n",
    "    faber = {\n",
    "        'name': 'Faber',\n",
    "        'wallet_config': json.dumps({'id': 'faber_wallet'}),\n",
    "        'wallet_credentials': json.dumps({'key': 'faber_wallet_key'}),\n",
    "        'pool': pool_['handle'],\n",
    "        'role': 'ENDORSER'\n",
    "    }\n",
    "\n",
    "    await getting_verinym(steward, faber)\n",
    "\n",
    "    print(\"\\n=====================================================================\")\n",
    "    print(\"== Getting Endorser credentials - Acme getting Verinym\")\n",
    "\n",
    "\n",
    "    acme = {\n",
    "        'name': 'Acme',\n",
    "        'wallet_config': json.dumps({'id': 'acme_wallet'}),\n",
    "        'wallet_credentials': json.dumps({'key': 'acme_wallet_key'}),\n",
    "        'pool': pool_['handle'],\n",
    "        'role': 'ENDORSER'\n",
    "    }\n",
    "\n",
    "    await getting_verinym(steward, acme)\n",
    "\n",
    "    print(\"\\n=====================================================================\")\n",
    "    print(\"== Getting Endorser credentials - Thrift getting Verinym\")\n",
    "\n",
    "\n",
    "    thrift = {\n",
    "        'name': 'Thrift',\n",
    "        'wallet_config': json.dumps({'id': 'thrift_wallet'}),\n",
    "        'wallet_credentials': json.dumps({'key': 'thrift_wallet_key'}),\n",
    "        'pool': pool_['handle'],\n",
    "        'role': 'ENDORSER'\n",
    "    }\n",
    "\n",
    "    await getting_verinym(steward, thrift)\n",
    "\n",
    "    print(\"\\n=====================================================================\")\n",
    "    print(\"=== Credential Schemas Setup ==\")\n",
    "\n",
    "\n",
    "    print(\"\\\"Government\\\" -> Create \\\"Job-Certificate\\\" Schema\")\n",
    "    job_certificate = {\n",
    "        'name': 'Job-Certificate',\n",
    "        'version': '0.2',\n",
    "        'attributes': ['first_name', 'last_name', 'salary', 'employee_status', 'experience']\n",
    "    }\n",
    "    (government['job_certificate_schema_id'], government['job_certificate_schema']) = \\\n",
    "        await anoncreds.issuer_create_schema(government['did'], job_certificate['name'], job_certificate['version'],\n",
    "                                             json.dumps(job_certificate['attributes']))\n",
    "    job_certificate_schema_id = government['job_certificate_schema_id']\n",
    "\n",
    "    print(\"\\\"Government\\\" -> Send \\\"Job-Certificate\\\" Schema to Ledger\")\n",
    "    await send_schema(government['pool'], government['wallet'], government['did'], government['job_certificate_schema'])\n",
    "\n",
    "    print(\"\\\"Government\\\" -> Create \\\"Transcript\\\" Schema\")\n",
    "    transcript = {\n",
    "        'name': 'Transcript',\n",
    "        'version': '1.2',\n",
    "        'attributes': ['first_name', 'last_name', 'degree', 'status', 'year', 'average', 'ssn']\n",
    "    }\n",
    "    (government['transcript_schema_id'], government['transcript_schema']) = \\\n",
    "        await anoncreds.issuer_create_schema(government['did'], transcript['name'], transcript['version'],\n",
    "                                             json.dumps(transcript['attributes']))\n",
    "    transcript_schema_id = government['transcript_schema_id']\n",
    "\n",
    "    print(\"\\\"Government\\\" -> Send \\\"Transcript\\\" Schema to Ledger\")\n",
    "    await send_schema(government['pool'], government['wallet'], government['did'], government['transcript_schema'])\n",
    "\n",
    "    time.sleep(1)  # sleep 1 second before getting schema\n",
    "\n",
    "    print(\"\\n=====================================================================\")\n",
    "    print(\"=== Faber Credential Definition Setup ==\")\n",
    "\n",
    "\n",
    "    print(\"\\\"Faber\\\" -> Get \\\"Transcript\\\" Schema from Ledger\")\n",
    "    (faber['transcript_schema_id'], faber['transcript_schema']) = \\\n",
    "        await get_schema(faber['pool'], faber['did'], transcript_schema_id)\n",
    "\n",
    "    print(\"\\\"Faber\\\" -> Create and store in Wallet \\\"Faber Transcript\\\" Credential Definition\")\n",
    "    transcript_cred_def = {\n",
    "        'tag': 'TAG1',\n",
    "        'type': 'CL',\n",
    "        'config': {\"support_revocation\": False}\n",
    "    }\n",
    "    (faber['transcript_cred_def_id'], faber['transcript_cred_def']) = \\\n",
    "        await anoncreds.issuer_create_and_store_credential_def(faber['wallet'], faber['did'],\n",
    "                                                               faber['transcript_schema'], transcript_cred_def['tag'],\n",
    "                                                               transcript_cred_def['type'],\n",
    "                                                               json.dumps(transcript_cred_def['config']))\n",
    "\n",
    "    print(\"\\\"Faber\\\" -> Send  \\\"Faber Transcript\\\" Credential Definition to Ledger\")\n",
    "    await send_cred_def(faber['pool'], faber['wallet'], faber['did'], faber['transcript_cred_def'])\n",
    "\n",
    "    print(\"\\n=====================================================================\")\n",
    "    print(\"=== Acme Credential Definition Setup ==\")\n",
    "\n",
    "\n",
    "    print(\"\\\"Acme\\\" -> Get from Ledger \\\"Job-Certificate\\\" Schema\")\n",
    "    (acme['job_certificate_schema_id'], acme['job_certificate_schema']) = \\\n",
    "        await get_schema(acme['pool'], acme['did'], job_certificate_schema_id)\n",
    "\n",
    "    print(\"\\\"Acme\\\" -> Create and store in Wallet \\\"Acme Job-Certificate\\\" Credential Definition\")\n",
    "    job_certificate_cred_def = {\n",
    "        'tag': 'TAG1',\n",
    "        'type': 'CL',\n",
    "        'config': {\"support_revocation\": False}\n",
    "    }\n",
    "    (acme['job_certificate_cred_def_id'], acme['job_certificate_cred_def']) = \\\n",
    "        await anoncreds.issuer_create_and_store_credential_def(acme['wallet'], acme['did'],\n",
    "                                                               acme['job_certificate_schema'],\n",
    "                                                               job_certificate_cred_def['tag'],\n",
    "                                                               job_certificate_cred_def['type'],\n",
    "                                                               json.dumps(job_certificate_cred_def['config']))\n",
    "\n",
    "    print(\"\\\"Acme\\\" -> Send \\\"Acme Job-Certificate\\\" Credential Definition to Ledger\")\n",
    "    await send_cred_def(acme['pool'], acme['wallet'], acme['did'], acme['job_certificate_cred_def'])\n",
    "\n",
    "    print(\"\\n=====================================================================\")\n",
    "    print(\"=== Getting Transcript with Faber ==\")\n",
    "    print(\"\\n=====================================================================\")\n",
    "    print(\"== Alice setup ==\")\n",
    "    print(\"\\n=====================================================================\")\n",
    "\n",
    "    alice = {\n",
    "        'name': 'Alice',\n",
    "        'wallet_config': json.dumps({'id': 'alice_wallet'}),\n",
    "        'wallet_credentials': json.dumps({'key': 'alice_wallet_key'}),\n",
    "        'pool': pool_['handle'],\n",
    "    }\n",
    "    await create_wallet(alice)\n",
    "    (alice['did'], alice['key']) = await did.create_and_store_my_did(alice['wallet'], \"{}\")\n",
    "\n",
    "    print(\"\\n=====================================================================\")\n",
    "    print(\"== Getting Transcript with Faber - Getting Transcript Credential ==\")\n",
    "\n",
    "\n",
    "    print(\"\\\"Faber\\\" -> Create \\\"Transcript\\\" Credential Offer for Alice\")\n",
    "    faber['transcript_cred_offer'] = \\\n",
    "        await anoncreds.issuer_create_credential_offer(faber['wallet'], faber['transcript_cred_def_id'])\n",
    "\n",
    "    print(\"\\\"Faber\\\" -> Send \\\"Transcript\\\" Credential Offer to Alice\")\n",
    "    alice['transcript_cred_offer'] = faber['transcript_cred_offer']\n",
    "    transcript_cred_offer_object = json.loads(alice['transcript_cred_offer'])\n",
    "\n",
    "    alice['transcript_schema_id'] = transcript_cred_offer_object['schema_id']\n",
    "    alice['transcript_cred_def_id'] = transcript_cred_offer_object['cred_def_id']\n",
    "\n",
    "    print(\"\\\"Alice\\\" -> Create and store \\\"Alice\\\" Master Secret in Wallet\")\n",
    "    alice['master_secret_id'] = await anoncreds.prover_create_master_secret(alice['wallet'], None)\n",
    "\n",
    "    print(\"\\\"Alice\\\" -> Get \\\"Faber Transcript\\\" Credential Definition from Ledger\")\n",
    "    (alice['faber_transcript_cred_def_id'], alice['faber_transcript_cred_def']) = \\\n",
    "        await get_cred_def(alice['pool'], alice['did'], alice['transcript_cred_def_id'])\n",
    "\n",
    "    print(\"\\\"Alice\\\" -> Create \\\"Transcript\\\" Credential Request for Faber\")\n",
    "    (alice['transcript_cred_request'], alice['transcript_cred_request_metadata']) = \\\n",
    "        await anoncreds.prover_create_credential_req(alice['wallet'], alice['did'],\n",
    "                                                     alice['transcript_cred_offer'], alice['faber_transcript_cred_def'],\n",
    "                                                     alice['master_secret_id'])\n",
    "\n",
    "    print(\"\\\"Alice\\\" -> Send \\\"Transcript\\\" Credential Request to Faber\")\n",
    "    faber['transcript_cred_request'] = alice['transcript_cred_request']\n",
    "\n",
    "    alice['transcript_cred_values'] = json.dumps({\n",
    "        \"first_name\": {\"raw\": \"Alice\", \"encoded\": \"1139481716457488690172217916278103335\"},\n",
    "        \"last_name\": {\"raw\": \"Garcia\", \"encoded\": \"5321642780241790123587902456789123452\"},\n",
    "        \"degree\": {\"raw\": \"Bachelor of Science, Marketing\", \"encoded\": \"12434523576212321\"},\n",
    "        \"status\": {\"raw\": \"graduated\", \"encoded\": \"2213454313412354\"},\n",
    "        \"ssn\": {\"raw\": \"123-45-6789\", \"encoded\": \"3124141231422543541\"},\n",
    "        \"year\": {\"raw\": \"2015\", \"encoded\": \"2015\"},\n",
    "        \"average\": {\"raw\": \"5\", \"encoded\": \"5\"}\n",
    "    })\n",
    "    faber['alice_transcript_cred_values'] = alice['transcript_cred_values']\n",
    "\n",
    "    print(\"\\\"Faber\\\" -> Create \\\"Transcript\\\" Credential for Alice\")\n",
    "\n",
    "    faber['transcript_cred'], _, _ = \\\n",
    "        await anoncreds.issuer_create_credential(faber['wallet'], faber['transcript_cred_offer'],\n",
    "                                                 faber['transcript_cred_request'],\n",
    "                                                 faber['alice_transcript_cred_values'], None, None)\n",
    "\n",
    "    print(\"\\\"Faber\\\" -> Send \\\"Transcript\\\" Credential to Alice\")\n",
    "    alice['transcript_cred'] = faber['transcript_cred']\n",
    "\n",
    "    print(\"\\\"Alice\\\" -> Store \\\"Transcript\\\" Credential from Faber\")\n",
    "    _, alice['transcript_cred_def'] = await get_cred_def(alice['pool'], alice['did'],\n",
    "                                                         alice['transcript_cred_def_id'])\n",
    "\n",
    "    await anoncreds.prover_store_credential(alice['wallet'], None, alice['transcript_cred_request_metadata'],\n",
    "                                            alice['transcript_cred'], alice['transcript_cred_def'], None)\n",
    "\n",
    "    print(\"\\n=====================================================================\")\n",
    "    print(\"== Apply for the job with Acme - Transcript proving ==\")\n",
    "\n",
    "\n",
    "    print(\"\\\"Acme\\\" -> Create \\\"Job-Application\\\" Proof Request\")\n",
    "    nonce = await anoncreds.generate_nonce()\n",
    "    acme['job_application_proof_request'] = json.dumps({\n",
    "        'nonce': nonce,\n",
    "        'name': 'Job-Application',\n",
    "        'version': '0.1',\n",
    "        'requested_attributes': {\n",
    "            'attr1_referent': {\n",
    "                'name': 'first_name'\n",
    "            },\n",
    "            'attr2_referent': {\n",
    "                'name': 'last_name'\n",
    "            },\n",
    "            'attr3_referent': {\n",
    "                'name': 'degree',\n",
    "                'restrictions': [{'cred_def_id': faber['transcript_cred_def_id']}]\n",
    "            },\n",
    "            'attr4_referent': {\n",
    "                'name': 'status',\n",
    "                'restrictions': [{'cred_def_id': faber['transcript_cred_def_id']}]\n",
    "            },\n",
    "            'attr5_referent': {\n",
    "                'name': 'ssn',\n",
    "                'restrictions': [{'cred_def_id': faber['transcript_cred_def_id']}]\n",
    "            },\n",
    "            'attr6_referent': {\n",
    "                'name': 'phone_number'\n",
    "            }\n",
    "        },\n",
    "        'requested_predicates': {\n",
    "            'predicate1_referent': {\n",
    "                'name': 'average',\n",
    "                'p_type': '>=',\n",
    "                'p_value': 4,\n",
    "                'restrictions': [{'cred_def_id': faber['transcript_cred_def_id']}]\n",
    "            }\n",
    "        }\n",
    "    })\n",
    "\n",
    "    print(\"\\\"Acme\\\" -> Send \\\"Job-Application\\\" Proof Request to Alice\")\n",
    "    alice['job_application_proof_request'] = acme['job_application_proof_request']\n",
    "\n",
    "    print(\"\\\"Alice\\\" -> Get credentials for \\\"Job-Application\\\" Proof Request\")\n",
    "\n",
    "    search_for_job_application_proof_request = \\\n",
    "        await anoncreds.prover_search_credentials_for_proof_req(alice['wallet'],\n",
    "                                                                alice['job_application_proof_request'], None)\n",
    "\n",
    "    cred_for_attr1 = await get_credential_for_referent(search_for_job_application_proof_request, 'attr1_referent')\n",
    "    cred_for_attr2 = await get_credential_for_referent(search_for_job_application_proof_request, 'attr2_referent')\n",
    "    cred_for_attr3 = await get_credential_for_referent(search_for_job_application_proof_request, 'attr3_referent')\n",
    "    cred_for_attr4 = await get_credential_for_referent(search_for_job_application_proof_request, 'attr4_referent')\n",
    "    cred_for_attr5 = await get_credential_for_referent(search_for_job_application_proof_request, 'attr5_referent')\n",
    "    cred_for_predicate1 = \\\n",
    "        await get_credential_for_referent(search_for_job_application_proof_request, 'predicate1_referent')\n",
    "\n",
    "    await anoncreds.prover_close_credentials_search_for_proof_req(search_for_job_application_proof_request)\n",
    "\n",
    "    alice['creds_for_job_application_proof'] = {cred_for_attr1['referent']: cred_for_attr1,\n",
    "                                                cred_for_attr2['referent']: cred_for_attr2,\n",
    "                                                cred_for_attr3['referent']: cred_for_attr3,\n",
    "                                                cred_for_attr4['referent']: cred_for_attr4,\n",
    "                                                cred_for_attr5['referent']: cred_for_attr5,\n",
    "                                                cred_for_predicate1['referent']: cred_for_predicate1}\n",
    "\n",
    "    alice['schemas'], alice['cred_defs'], alice['revoc_states'] = \\\n",
    "        await prover_get_entities_from_ledger(alice['pool'], alice['did'],\n",
    "                                              alice['creds_for_job_application_proof'], alice['name'])\n",
    "\n",
    "    print(\"\\\"Alice\\\" -> Create \\\"Job-Application\\\" Proof\")\n",
    "    alice['job_application_requested_creds'] = json.dumps({\n",
    "        'self_attested_attributes': {\n",
    "            'attr1_referent': 'Alice',\n",
    "            'attr2_referent': 'Garcia',\n",
    "            'attr6_referent': '123-45-6789'\n",
    "        },\n",
    "        'requested_attributes': {\n",
    "            'attr3_referent': {'cred_id': cred_for_attr3['referent'], 'revealed': True},\n",
    "            'attr4_referent': {'cred_id': cred_for_attr4['referent'], 'revealed': True},\n",
    "            'attr5_referent': {'cred_id': cred_for_attr5['referent'], 'revealed': True},\n",
    "        },\n",
    "        'requested_predicates': {'predicate1_referent': {'cred_id': cred_for_predicate1['referent']}}\n",
    "    })\n",
    "\n",
    "    alice['job_application_proof'] = \\\n",
    "        await anoncreds.prover_create_proof(alice['wallet'], alice['job_application_proof_request'],\n",
    "                                            alice['job_application_requested_creds'], alice['master_secret_id'],\n",
    "                                            alice['schemas'], alice['cred_defs'], alice['revoc_states'])\n",
    "\n",
    "    print(\"\\\"Alice\\\" -> Send \\\"Job-Application\\\" Proof to Acme\")\n",
    "    acme['job_application_proof'] = alice['job_application_proof']\n",
    "    job_application_proof_object = json.loads(acme['job_application_proof'])\n",
    "\n",
    "    acme['schemas_for_job_application'], acme['cred_defs_for_job_application'], \\\n",
    "    acme['revoc_ref_defs_for_job_application'], acme['revoc_regs_for_job_application'] = \\\n",
    "        await verifier_get_entities_from_ledger(acme['pool'], acme['did'],\n",
    "                                                job_application_proof_object['identifiers'], acme['name'])\n",
    "\n",
    "    print(\"\\\"Acme\\\" -> Verify \\\"Job-Application\\\" Proof from Alice\")\n",
    "    assert 'Bachelor of Science, Marketing' == \\\n",
    "           job_application_proof_object['requested_proof']['revealed_attrs']['attr3_referent']['raw']\n",
    "    assert 'graduated' == \\\n",
    "           job_application_proof_object['requested_proof']['revealed_attrs']['attr4_referent']['raw']\n",
    "    assert '123-45-6789' == \\\n",
    "           job_application_proof_object['requested_proof']['revealed_attrs']['attr5_referent']['raw']\n",
    "\n",
    "    assert 'Alice' == job_application_proof_object['requested_proof']['self_attested_attrs']['attr1_referent']\n",
    "    assert 'Garcia' == job_application_proof_object['requested_proof']['self_attested_attrs']['attr2_referent']\n",
    "    assert '123-45-6789' == job_application_proof_object['requested_proof']['self_attested_attrs']['attr6_referent']\n",
    "\n",
    "    assert await anoncreds.verifier_verify_proof(acme['job_application_proof_request'], acme['job_application_proof'],\n",
    "                                                 acme['schemas_for_job_application'],\n",
    "                                                 acme['cred_defs_for_job_application'],\n",
    "                                                 acme['revoc_ref_defs_for_job_application'],\n",
    "                                                 acme['revoc_regs_for_job_application'])\n",
    "\n",
    "    print(\"\\n=====================================================================\")\n",
    "    print(\"== Apply for the job with Acme - Getting Job-Certificate Credential ==\")\n",
    "\n",
    "\n",
    "    print(\"\\\"Acme\\\" -> Create \\\"Job-Certificate\\\" Credential Offer for Alice\")\n",
    "    acme['job_certificate_cred_offer'] = \\\n",
    "        await anoncreds.issuer_create_credential_offer(acme['wallet'], acme['job_certificate_cred_def_id'])\n",
    "\n",
    "    print(\"\\\"Acme\\\" -> Send \\\"Job-Certificate\\\" Credential Offer to Alice\")\n",
    "    alice['job_certificate_cred_offer'] = acme['job_certificate_cred_offer']\n",
    "    job_certificate_cred_offer_object = json.loads(alice['job_certificate_cred_offer'])\n",
    "\n",
    "    print(\"\\\"Alice\\\" -> Get \\\"Acme Job-Certificate\\\" Credential Definition from Ledger\")\n",
    "    (alice['acme_job_certificate_cred_def_id'], alice['acme_job_certificate_cred_def']) = \\\n",
    "        await get_cred_def(alice['pool'], alice['did'], job_certificate_cred_offer_object['cred_def_id'])\n",
    "\n",
    "    print(\"\\\"Alice\\\" -> Create and store in Wallet \\\"Job-Certificate\\\" Credential Request for Acme\")\n",
    "    (alice['job_certificate_cred_request'], alice['job_certificate_cred_request_metadata']) = \\\n",
    "        await anoncreds.prover_create_credential_req(alice['wallet'], alice['did'],\n",
    "                                                     alice['job_certificate_cred_offer'],\n",
    "                                                     alice['acme_job_certificate_cred_def'], alice['master_secret_id'])\n",
    "\n",
    "    print(\"\\\"Alice\\\" -> Send \\\"Job-Certificate\\\" Credential Request to Acme\")\n",
    "    acme['job_certificate_cred_request'] = alice['job_certificate_cred_request']\n",
    "\n",
    "    alice['job_certificate_cred_values'] = json.dumps({\n",
    "        \"first_name\": {\"raw\": \"Alice\", \"encoded\": \"245712572474217942457235975012103335\"},\n",
    "        \"last_name\": {\"raw\": \"Garcia\", \"encoded\": \"312643218496194691632153761283356127\"},\n",
    "        \"employee_status\": {\"raw\": \"Permanent\", \"encoded\": \"2143135425425143112321314321\"},\n",
    "        \"salary\": {\"raw\": \"2400\", \"encoded\": \"2400\"},\n",
    "        \"experience\": {\"raw\": \"10\", \"encoded\": \"10\"}\n",
    "    })\n",
    "    acme['job_certificate_cred_values'] = alice['job_certificate_cred_values']\n",
    "\n",
    "    print(\"\\\"Acme\\\" -> Create \\\"Job-Certificate\\\" Credential for Alice\")\n",
    "\n",
    "    acme['job_certificate_cred'], _, _ = \\\n",
    "        await anoncreds.issuer_create_credential(acme['wallet'], acme['job_certificate_cred_offer'],\n",
    "                                                 acme['job_certificate_cred_request'],\n",
    "                                                 acme['job_certificate_cred_values'], None, None)\n",
    "\n",
    "    print(\"\\\"Acme\\\" -> Send \\\"Job-Certificate\\\" Credential to Alice\")\n",
    "    alice['job_certificate_cred'] = acme['job_certificate_cred']\n",
    "\n",
    "    print(\"\\\"Alice\\\" -> Store \\\"Job-Certificate\\\" Credential\")\n",
    "    await anoncreds.prover_store_credential(alice['wallet'], None, alice['job_certificate_cred_request_metadata'],\n",
    "                                            alice['job_certificate_cred'],\n",
    "                                            alice['acme_job_certificate_cred_def'], None)\n",
    "\n",
    "    print(\"\\n=====================================================================\")\n",
    "    print(\"== Apply for the loan with Thrift - Job-Certificate proving\")\n",
    "\n",
    "\n",
    "    print(\"\\\"Thrift\\\" -> Create \\\"Loan-Application-Basic\\\" Proof Request\")\n",
    "    nonce = await anoncreds.generate_nonce()\n",
    "    thrift['apply_loan_proof_request'] = json.dumps({\n",
    "        'nonce': nonce,\n",
    "        'name': 'Loan-Application-Basic',\n",
    "        'version': '0.1',\n",
    "        'requested_attributes': {\n",
    "            'attr1_referent': {\n",
    "                'name': 'employee_status',\n",
    "                'restrictions': [{'cred_def_id': acme['job_certificate_cred_def_id']}]\n",
    "            }\n",
    "        },\n",
    "        'requested_predicates': {\n",
    "            'predicate1_referent': {\n",
    "                'name': 'salary',\n",
    "                'p_type': '>=',\n",
    "                'p_value': 2000,\n",
    "                'restrictions': [{'cred_def_id': acme['job_certificate_cred_def_id']}]\n",
    "            },\n",
    "            'predicate2_referent': {\n",
    "                'name': 'experience',\n",
    "                'p_type': '>=',\n",
    "                'p_value': 1,\n",
    "                'restrictions': [{'cred_def_id': acme['job_certificate_cred_def_id']}]\n",
    "            }\n",
    "        }\n",
    "    })\n",
    "\n",
    "    print(\"\\\"Thrift\\\" -> Send \\\"Loan-Application-Basic\\\" Proof Request to Alice\")\n",
    "    alice['apply_loan_proof_request'] = thrift['apply_loan_proof_request']\n",
    "\n",
    "    print(\"\\\"Alice\\\" -> Get credentials for \\\"Loan-Application-Basic\\\" Proof Request\")\n",
    "\n",
    "    search_for_apply_loan_proof_request = \\\n",
    "        await anoncreds.prover_search_credentials_for_proof_req(alice['wallet'],\n",
    "                                                                alice['apply_loan_proof_request'], None)\n",
    "\n",
    "    cred_for_attr1 = await get_credential_for_referent(search_for_apply_loan_proof_request, 'attr1_referent')\n",
    "    cred_for_predicate1 = await get_credential_for_referent(search_for_apply_loan_proof_request, 'predicate1_referent')\n",
    "    cred_for_predicate2 = await get_credential_for_referent(search_for_apply_loan_proof_request, 'predicate2_referent')\n",
    "\n",
    "    await anoncreds.prover_close_credentials_search_for_proof_req(search_for_apply_loan_proof_request)\n",
    "\n",
    "    alice['creds_for_apply_loan_proof'] = {cred_for_attr1['referent']: cred_for_attr1,\n",
    "                                           cred_for_predicate1['referent']: cred_for_predicate1,\n",
    "                                           cred_for_predicate2['referent']: cred_for_predicate2}\n",
    "\n",
    "    alice['schemas'], alice['cred_defs'], alice['revoc_states'] = \\\n",
    "        await prover_get_entities_from_ledger(alice['pool'], alice['did'],\n",
    "                                              alice['creds_for_apply_loan_proof'],\n",
    "                                              alice['name'])\n",
    "\n",
    "    print(\"\\\"Alice\\\" -> Create \\\"Loan-Application-Basic\\\" Proof\")\n",
    "    alice['apply_loan_requested_creds'] = json.dumps({\n",
    "        'self_attested_attributes': {},\n",
    "        'requested_attributes': {\n",
    "            'attr1_referent': {'cred_id': cred_for_attr1['referent'], 'revealed': True}\n",
    "        },\n",
    "        'requested_predicates': {\n",
    "            'predicate1_referent': {'cred_id': cred_for_predicate1['referent']},\n",
    "            'predicate2_referent': {'cred_id': cred_for_predicate2['referent']}\n",
    "        }\n",
    "    })\n",
    "    alice['apply_loan_proof'] = \\\n",
    "        await anoncreds.prover_create_proof(alice['wallet'], alice['apply_loan_proof_request'],\n",
    "                                            alice['apply_loan_requested_creds'], alice['master_secret_id'],\n",
    "                                            alice['schemas'], alice['cred_defs'], alice['revoc_states'])\n",
    "\n",
    "    print(\"\\\"Alice\\\" -> Send \\\"Loan-Application-Basic\\\" Proof to Thrift\")\n",
    "    thrift['apply_loan_proof'] = alice['apply_loan_proof']\n",
    "    apply_loan_proof_object = json.loads(thrift['apply_loan_proof'])\n",
    "\n",
    "    print(\"\\\"Thrift\\\" -> Get Schemas, Credential Definitions and Revocation Registries from Ledger\"\n",
    "          \" required for Proof verifying\")\n",
    "\n",
    "    thrift['schemas'], thrift['cred_defs'], thrift['revoc_defs'], thrift['revoc_regs'] = \\\n",
    "        await verifier_get_entities_from_ledger(thrift['pool'], thrift['did'],\n",
    "                                                apply_loan_proof_object['identifiers'], thrift['name'])\n",
    "\n",
    "    print(\"\\\"Thrift\\\" -> Verify \\\"Loan-Application-Basic\\\" Proof from Alice\")\n",
    "    assert 'Permanent' == \\\n",
    "           apply_loan_proof_object['requested_proof']['revealed_attrs']['attr1_referent']['raw']\n",
    "\n",
    "    assert await anoncreds.verifier_verify_proof(thrift['apply_loan_proof_request'], thrift['apply_loan_proof'],\n",
    "                                                 thrift['schemas'], thrift['cred_defs'], thrift['revoc_defs'],\n",
    "                                                 thrift['revoc_regs'])\n",
    "\n",
    "    print(\"\\n=====================================================================\")\n",
    "    print(\"== Apply for the loan with Thrift - Transcript and Job-Certificate proving\")\n",
    "\n",
    "\n",
    "    print(\"\\\"Thrift\\\" -> Create \\\"Loan-Application-KYC\\\" Proof Request\")\n",
    "    nonce = await anoncreds.generate_nonce()\n",
    "    thrift['apply_loan_kyc_proof_request'] = json.dumps({\n",
    "        'nonce': nonce,\n",
    "        'name': 'Loan-Application-KYC',\n",
    "        'version': '0.1',\n",
    "        'requested_attributes': {\n",
    "            'attr1_referent': {'name': 'first_name'},\n",
    "            'attr2_referent': {'name': 'last_name'},\n",
    "            'attr3_referent': {'name': 'ssn'}\n",
    "        },\n",
    "        'requested_predicates': {}\n",
    "    })\n",
    "\n",
    "    print(\"\\\"Thrift\\\" -> Send \\\"Loan-Application-KYC\\\" Proof Request to Alice\")\n",
    "    alice['apply_loan_kyc_proof_request'] = thrift['apply_loan_kyc_proof_request']\n",
    "\n",
    "    print(\"\\\"Alice\\\" -> Get credentials for \\\"Loan-Application-KYC\\\" Proof Request\")\n",
    "\n",
    "    search_for_apply_loan_kyc_proof_request = \\\n",
    "        await anoncreds.prover_search_credentials_for_proof_req(alice['wallet'],\n",
    "                                                                alice['apply_loan_kyc_proof_request'], None)\n",
    "\n",
    "    cred_for_attr1 = await get_credential_for_referent(search_for_apply_loan_kyc_proof_request, 'attr1_referent')\n",
    "    cred_for_attr2 = await get_credential_for_referent(search_for_apply_loan_kyc_proof_request, 'attr2_referent')\n",
    "    cred_for_attr3 = await get_credential_for_referent(search_for_apply_loan_kyc_proof_request, 'attr3_referent')\n",
    "\n",
    "    await anoncreds.prover_close_credentials_search_for_proof_req(search_for_apply_loan_kyc_proof_request)\n",
    "\n",
    "    alice['creds_for_apply_loan_kyc_proof'] = {cred_for_attr1['referent']: cred_for_attr1,\n",
    "                                               cred_for_attr2['referent']: cred_for_attr2,\n",
    "                                               cred_for_attr3['referent']: cred_for_attr3}\n",
    "\n",
    "    alice['schemas'], alice['cred_defs'], alice['revoc_states'] = \\\n",
    "        await prover_get_entities_from_ledger(alice['pool'], alice['did'],\n",
    "                                              alice['creds_for_apply_loan_kyc_proof'], 'Alice')\n",
    "\n",
    "    print(\"\\\"Alice\\\" -> Create \\\"Loan-Application-KYC\\\" Proof\")\n",
    "\n",
    "    alice['apply_loan_kyc_requested_creds'] = json.dumps({\n",
    "        'self_attested_attributes': {},\n",
    "        'requested_attributes': {\n",
    "            'attr1_referent': {'cred_id': cred_for_attr1['referent'], 'revealed': True},\n",
    "            'attr2_referent': {'cred_id': cred_for_attr2['referent'], 'revealed': True},\n",
    "            'attr3_referent': {'cred_id': cred_for_attr3['referent'], 'revealed': True}\n",
    "        },\n",
    "        'requested_predicates': {}\n",
    "    })\n",
    "\n",
    "    alice['apply_loan_kyc_proof'] = \\\n",
    "        await anoncreds.prover_create_proof(alice['wallet'], alice['apply_loan_kyc_proof_request'],\n",
    "                                            alice['apply_loan_kyc_requested_creds'], alice['master_secret_id'],\n",
    "                                            alice['schemas'], alice['cred_defs'], alice['revoc_states'])\n",
    "\n",
    "    print(\"\\\"Alice\\\" -> Send \\\"Loan-Application-KYC\\\" Proof to Thrift\")\n",
    "    thrift['apply_loan_kyc_proof'] = alice['apply_loan_kyc_proof']\n",
    "    apply_loan_kyc_proof_object = json.loads(thrift['apply_loan_kyc_proof'])\n",
    "\n",
    "    print(\"\\\"Thrift\\\" -> Get Schemas, Credential Definitions and Revocation Registries from Ledger\"\n",
    "          \" required for Proof verifying\")\n",
    "\n",
    "    thrift['schemas'], thrift['cred_defs'], thrift['revoc_defs'], thrift['revoc_regs'] = \\\n",
    "        await verifier_get_entities_from_ledger(thrift['pool'], thrift['did'],\n",
    "                                                apply_loan_kyc_proof_object['identifiers'], 'Thrift')\n",
    "\n",
    "    print(\"\\\"Thrift\\\" -> Verify \\\"Loan-Application-KYC\\\" Proof from Alice\")\n",
    "    assert 'Alice' == \\\n",
    "           apply_loan_kyc_proof_object['requested_proof']['revealed_attrs']['attr1_referent']['raw']\n",
    "    assert 'Garcia' == \\\n",
    "           apply_loan_kyc_proof_object['requested_proof']['revealed_attrs']['attr2_referent']['raw']\n",
    "    assert '123-45-6789' == \\\n",
    "           apply_loan_kyc_proof_object['requested_proof']['revealed_attrs']['attr3_referent']['raw']\n",
    "\n",
    "    assert await anoncreds.verifier_verify_proof(thrift['apply_loan_kyc_proof_request'],\n",
    "                                                 thrift['apply_loan_kyc_proof'],\n",
    "                                                 thrift['schemas'], thrift['cred_defs'], thrift['revoc_defs'],\n",
    "                                                 thrift['revoc_regs'])\n",
    "\n",
    "    print(\"\\n=====================================================================\")\n",
    "\n",
    "    print(\"\\\"Sovrin Steward\\\" -> Close and Delete wallet\")\n",
    "    await wallet.close_wallet(steward['wallet'])\n",
    "    await wallet.delete_wallet(steward['wallet_config'], steward['wallet_credentials'])\n",
    "\n",
    "    print(\"\\\"Government\\\" -> Close and Delete wallet\")\n",
    "    await wallet.close_wallet(government['wallet'])\n",
    "    await wallet.delete_wallet(government['wallet_config'], government['wallet_credentials'])\n",
    "\n",
    "    print(\"\\\"Faber\\\" -> Close and Delete wallet\")\n",
    "    await wallet.close_wallet(faber['wallet'])\n",
    "    await wallet.delete_wallet(faber['wallet_config'], faber['wallet_credentials'])\n",
    "\n",
    "    print(\"\\\"Acme\\\" -> Close and Delete wallet\")\n",
    "    await wallet.close_wallet(acme['wallet'])\n",
    "    await wallet.delete_wallet(acme['wallet_config'], acme['wallet_credentials'])\n",
    "\n",
    "    print(\"\\\"Thrift\\\" -> Close and Delete wallet\")\n",
    "    await wallet.close_wallet(thrift['wallet'])\n",
    "    await wallet.delete_wallet(thrift['wallet_config'], thrift['wallet_credentials'])\n",
    "\n",
    "    print(\"\\\"Alice\\\" -> Close and Delete wallet\")\n",
    "    await wallet.close_wallet(alice['wallet'])\n",
    "    await wallet.delete_wallet(alice['wallet_config'], alice['wallet_credentials'])\n",
    "\n",
    "    print(\"Close and Delete pool\")\n",
    "    await pool.close_pool_ledger(pool_['handle'])\n",
    "    await pool.delete_pool_ledger_config(pool_['name'])\n",
    "\n",
    "    print(\"Getting started -> done\")\n",
    "\n",
    "async def create_wallet(identity):\n",
    "    print(\"\\\"{}\\\" -> Create wallet\".format(identity['name']))\n",
    "    try:\n",
    "        await wallet.create_wallet(identity['wallet_config'], identity['wallet_credentials'])\n",
    "    except IndyError as ex:\n",
    "        if ex.error_code == ErrorCode.PoolLedgerConfigAlreadyExistsError:\n",
    "            pass\n",
    "    identity['wallet'] = await wallet.open_wallet(identity['wallet_config'], identity['wallet_credentials'])\n",
    "\n",
    "\n",
    "async def getting_verinym(from_, to):\n",
    "    await create_wallet(to)\n",
    "\n",
    "    (to['did'], to['key']) = await did.create_and_store_my_did(to['wallet'], \"{}\")\n",
    "\n",
    "    from_['info'] = {\n",
    "        'did': to['did'],\n",
    "        'verkey': to['key'],\n",
    "        'role': to['role'] or None\n",
    "    }\n",
    "\n",
    "    await send_nym(from_['pool'], from_['wallet'], from_['did'], from_['info']['did'],\n",
    "                   from_['info']['verkey'], from_['info']['role'])\n",
    "\n",
    "\n",
    "async def send_nym(pool_handle, wallet_handle, _did, new_did, new_key, role):\n",
    "    nym_request = await ledger.build_nym_request(_did, new_did, new_key, None, role)\n",
    "    await ledger.sign_and_submit_request(pool_handle, wallet_handle, _did, nym_request)\n",
    "\n",
    "\n",
    "async def send_schema(pool_handle, wallet_handle, _did, schema):\n",
    "    schema_request = await ledger.build_schema_request(_did, schema)\n",
    "    await ledger.sign_and_submit_request(pool_handle, wallet_handle, _did, schema_request)\n",
    "\n",
    "\n",
    "async def send_cred_def(pool_handle, wallet_handle, _did, cred_def_json):\n",
    "    cred_def_request = await ledger.build_cred_def_request(_did, cred_def_json)\n",
    "    await ledger.sign_and_submit_request(pool_handle, wallet_handle, _did, cred_def_request)\n",
    "\n",
    "\n",
    "async def get_schema(pool_handle, _did, schema_id):\n",
    "    get_schema_request = await ledger.build_get_schema_request(_did, schema_id)\n",
    "    get_schema_response = await ledger.submit_request(pool_handle, get_schema_request)\n",
    "    return await ledger.parse_get_schema_response(get_schema_response)\n",
    "\n",
    "\n",
    "async def get_cred_def(pool_handle, _did, cred_def_id):\n",
    "    get_cred_def_request = await ledger.build_get_cred_def_request(_did, cred_def_id)\n",
    "    get_cred_def_response = await ledger.submit_request(pool_handle, get_cred_def_request)\n",
    "    return await ledger.parse_get_cred_def_response(get_cred_def_response)\n",
    "\n",
    "\n",
    "async def get_credential_for_referent(search_handle, referent):\n",
    "    credentials = json.loads(\n",
    "        await anoncreds.prover_fetch_credentials_for_proof_req(search_handle, referent, 10))\n",
    "    return credentials[0]['cred_info']\n",
    "\n",
    "\n",
    "async def prover_get_entities_from_ledger(pool_handle, _did, identifiers, actor):\n",
    "    schemas = {}\n",
    "    cred_defs = {}\n",
    "    rev_states = {}\n",
    "    for item in identifiers.values():\n",
    "        print(\"\\\"{}\\\" -> Get Schema from Ledger\".format(actor))\n",
    "        (received_schema_id, received_schema) = await get_schema(pool_handle, _did, item['schema_id'])\n",
    "        schemas[received_schema_id] = json.loads(received_schema)\n",
    "\n",
    "        print(\"\\\"{}\\\" -> Get Credential Definition from Ledger\".format(actor))\n",
    "        (received_cred_def_id, received_cred_def) = await get_cred_def(pool_handle, _did, item['cred_def_id'])\n",
    "        cred_defs[received_cred_def_id] = json.loads(received_cred_def)\n",
    "\n",
    "        if 'rev_reg_seq_no' in item:\n",
    "            pass  # TODO Create Revocation States\n",
    "\n",
    "    return json.dumps(schemas), json.dumps(cred_defs), json.dumps(rev_states)\n",
    "\n",
    "\n",
    "async def verifier_get_entities_from_ledger(pool_handle, _did, identifiers, actor):\n",
    "    schemas = {}\n",
    "    cred_defs = {}\n",
    "    rev_reg_defs = {}\n",
    "    rev_regs = {}\n",
    "    for item in identifiers:\n",
    "        print(\"\\\"{}\\\" -> Get Schema from Ledger\".format(actor))\n",
    "        (received_schema_id, received_schema) = await get_schema(pool_handle, _did, item['schema_id'])\n",
    "        schemas[received_schema_id] = json.loads(received_schema)\n",
    "\n",
    "        print(\"\\\"{}\\\" -> Get Credential Definition from Ledger\".format(actor))\n",
    "        (received_cred_def_id, received_cred_def) = await get_cred_def(pool_handle, _did, item['cred_def_id'])\n",
    "        cred_defs[received_cred_def_id] = json.loads(received_cred_def)\n",
    "\n",
    "        if 'rev_reg_seq_no' in item:\n",
    "            pass  # TODO Get Revocation Definitions and Revocation Registries\n",
    "\n",
    "    return json.dumps(schemas), json.dumps(cred_defs), json.dumps(rev_reg_defs), json.dumps(rev_regs)\n",
    "\n",
    "await run()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}