Nixar Core Developer Integration Guide

inv_seed = "00000000000000000000000000AGENTA"
conn_inv = issuer.connection_create_local_invitation("agent A", "http://localhost:8080", inv_seed)
logging.info("Agent A create connection invitation, conn_inv" +
             json.dumps(conn_inv))

# Agent B receive invitation and create connection request
req_seed = "00000000000000000000000000AGENTB"
conn_req = prover.connection_create_request(conn_inv, req_seed)
logging.info("Agent B create connection request, conn_req" +
             json.dumps(conn_req))

# Agent A receive connection request and create connection response
conn_res = issuer.connection_accept_request(conn_req, None)
logging.info("Agent A create connection response, conn_res" +
             json.dumps(conn_res))

# Agent B receive connection response and finalize connection creation
prover.connection_accept_response(conn_res)
logging.info("Connection created between Agent A and Agent  B")

packed_signature = {}
packed_signature['signedData'] = base64.b64encode(signed_data).decode('utf-8')
packed_signature['signature'] = base64_encoded_signature
logging.info("Packed signature {}".format(packed_signature))
encrypted_message = prover.connection_encrypt(from_did,
                                              their_did,
                                              NixarMessageType.MESSAGE_TYPE_SIMPLE,
                                              packed_signature)
logging.info("Prover Agent create message of signature info, encrypted_message: {}".format(encrypted_message))

//send the signature and the data to issuer (via didcomm)
var packedSignature : [String: String] = [:]
packedSignature["signedData"] = Data(signedData).base64EncodedString()
packedSignature["signature"] = base64EncodedSignature;

let messageString = try JSONHelper.encode(packedSignature);

let encryptedMessage = try agentb.encryptMessage(fromDid: connection.myDid, toDid: connection.theirDid,
                                             messageType: SwiftNixarMessageType.MessageTypeSimple, content: messageString);

schema_version = '2.0'
schema_id = issuer.issuer_create_schema(schema_name, attribute_set, schema_version)
logging.info('Schema created, schema_id: ' + schema_id)
# if it is not revocable, CredDefIssuanceType.ISSUANCE_ON_DEMAND, max_cred_num will be ignored in nixar
cred_def_id = issuer.issuer_create_credential_definition(schema_id, is_revocable,
                                                         CredDefIssuanceType.ISSUANCE_ON_DEMAND, max_cred_num)
logging.info('Credential definition created, cred_def_id: ' + cred_def_id)

issuer_nonce = str(random.getrandbits(80))
cred_offer = issuer.issuer_create_credential_offer(cred_def_id, issuer_nonce)
logging.info('Credential offer created, cred_offer: ' + str(cred_offer))

cred_req = prover.prover_create_credential_request(cred_offer)
logging.info('Credential request created, cred_req: ' + str(cred_req))

issued_cred_info = issuer.issuer_create_credential(
    cred_req, json.dumps(cred_values), issuer_nonce)

cred = issued_cred_info['credential']
cred_rev_id = issued_cred_info['credRevId']
logging.info('Credential created, cred: ' + json.dumps(cred))

store_cred = prover.prover_store_credential(None, cred)
logging.info('Store credential created, store_cred: ' + str(store_cred))

# Default restriction operator or, the following restriction equal that
# "restrictions": { "$or":
#                   [
#                     {"schema_id": schema_id},
#                     {"cred_def_id": cred_def_id}
#                 ]}
pres_req = {
    "name": "IdentityPR",
    "version": "2.0",
    "nonce": "92210735",
    "requestedAttributes": {
        "name_attribute": {
            "name": "name",
            "restrictions": {"$and": [
                {"schema_id": schema_id},
                {"cred_def_id": cred_def_id}
            ]}
        },
        "attribute2_referent": {
            "name": "surname"
        },
        "attribute3_referent": {
            "name": "gender"
        },
        "self_attested_referent": {
            "name": "hobies"
        }
    },
    "requestedPredicates": {
        "predicate1_referent": {
            "name": "age",
            "p_type": ">",
            "p_value": 10
        }
    }
}

# Prover create presentation
self_attested_values = {}
self_attested_values["self_attested_referent"] = "swim"

pres = prover.prover_create_presentation(pres_req, self_attested_values)
logging.info('Prover created presentation, pres: ' + json.dumps(pres))

# verifier verify presentation
v_result = verifier.verifier_verify_presentation(pres_req, pres)
logging.info('verfier verify presentation, result: ' + str(v_result))

# issuer revoke credential
issuer.issuer_revoke_credential(cred_rev_id, cred_def_id)
logging.info('Issuer revoked credential')

tail_name_of_rev_reg = cred['rev_reg_id']
tail = issuer.issuer_get_tail(tail_name_of_rev_reg)

        # store tail into prover, note: in this example issuer and prover use same location to store tail we have to change name of tail to see system is work
        prover.prover_store_tail('P_' + tail_name_of_rev_reg, tail)
        return issued_cred_info['credRevId']


    return None


def create_proof_and_verify(pres_req):
    # Prover create presentation
    self_attested_values = {}
    self_attested_values["self_attested_referent"] = "swim"

    pres = prover.prover_create_presentation(pres_req, self_attested_values)
    logging.info('Prover created presentation, pres: ' + json.dumps(pres))

    # verifier verify presentation
    v_result = verifier.verifier_verify_presentation(pres_req, pres)
    logging.info('verfier verify presentation, result: ' + str(v_result))

    return v_result


def revoke_cred(cred_rev_id, cred_def_id):
    # issuer revoke credential
    issuer.issuer_revoke_credential(cred_rev_id, cred_def_id)
    logging.info('Issuer revoked credential')


def demo_with_revocable():
    schema_name = 'python_schema_revocable.v.0.1'
    schema_name = 'python_schema_non_revocable.v.0.1'
    attribute_set = ['name', 'surname', 'age', 'gender']
    schema_id = create_schema_if_not_exist(schema_name, attribute_set)

    cred_def_id = create_credential_definition(schema_id, True)

    cred_values = {
        "name": {
            "raw": "Metin",
            "encoded": "332414609774"
        },
        "surname": {
            "raw": "Öztürk",
            "encoded": "521660491122"
        },
        "age": {
            "raw": "30",
            "encoded": "30"
        },
        "gender": {
            "raw": "male",
            "encoded": "1835101285"
        }
    }

    cred_rev_id = create_credential(cred_def_id, cred_values)

    cred_def_id = create_credential_definition(schema_id, True)

    # create presentation reauest
    pres_req = {
        "name": "IdentityPR",
        "version": "2.0",
        "nonce": "92210735",
        "requestedAttributes": {
            "name_attribute": {
                "name": "name",
                "restrictions": {"$or": [
                    {"schema_id": schema_id},
                    {"cred_def_id": cred_def_id}
                ]}
            },
            "attribute2_referent": {
                "name": "surname"
            },
            "attribute3_referent": {
                "name": "gender"
            },
            "self_attested_referent": {
                "name": "hobies"
            }
        },
        "requestedPredicates": {
            "predicate1_referent": {
                "name": "age",
                "p_type": ">",
                "p_value": 10
            }
        }
    }

    v_result = create_proof_and_verify(pres_req)
    assert v_result == True

    # issuer revoke credential
    revoke_cred(cred_rev_id, cred_def_id)

    v_result = create_proof_and_verify(pres_req)
    assert v_result == False


def demo_with_non_revocable():
    schema_name = 'python_schema_non_revocable.v.0.1'
    attribute_set = ['name', 'surname', 'age', 'gender']
    schema_id = create_schema_if_not_exist(schema_name, attribute_set)

    cred_def_id = create_credential_definition(schema_id, False)

    cred_values = {
        "name": {
            "raw": "Metin",
            "encoded": "332414609774"
        },
        "surname": {
            "raw": "Öztürk",
            "encoded": "521660491122"
        },
        "age": {
            "raw": "30",
            "encoded": "30"
        },
        "gender": {
            "raw": "male",
            "encoded": "1835101285"
        }
    }
    cred_rev_id = create_credential(cred_def_id, cred_values)

    # Default restriction operator or, the following restriction equal that
    # "restrictions": { "$or":
    #                   [
    #                     {"schema_id": schema_id},
    #                     {"cred_def_id": cred_def_id}
    #                 ]}
    pres_req = {
        "name": "IdentityPR",
        "version": "2.0",
        "nonce": "92210735",
        "requestedAttributes": {
            "name_attribute": {
                "name": "name",
                "restrictions": {"$and": [
                    {"schema_id": schema_id},
                    {"cred_def_id": cred_def_id}
                ]}
            },
            "attribute2_referent": {
                "name": "surname"
            },
            "attribute3_referent": {
                "name": "gender"
            },
            "self_attested_referent": {
                "name": "hobies"
            }
        },
        "requestedPredicates": {
            "predicate1_referent": {
                "name": "age",
                "p_type": ">",
                "p_value": 10
            }
        }
    }

    v_result = create_proof_and_verify(pres_req)
    assert v_result == True


def demo_did_comm():
    # Agent A create connection invitation

    inv_seed = "00000000000000000000000000AGENTA"
    conn_inv = issuer.connection_create_local_invitation("agent A", "http://localhost:8080", inv_seed)
    logging.info("Agent A create connection invitation, conn_inv" +
                 json.dumps(conn_inv))

    # Agent B receive invitation and create connection request
    req_seed = "00000000000000000000000000AGENTB"
    conn_req = prover.connection_create_request(conn_inv, req_seed)
    logging.info("Agent B create connection request, conn_req" +
                 json.dumps(conn_req))

    # Agent A receive connection request and create connection response
    conn_res = issuer.connection_accept_request(conn_req, None)
    logging.info("Agent A create connection response, conn_res" +
                 json.dumps(conn_res))


    # Agent B receive connection response and finalize connection creation
    prover.connection_accept_response(conn_res)
    logging.info("Connection created between Agent A and Agent  B")


    # Agent A Connections
    agent_a_conns = issuer.connection_get_connections()
    logging.info("Agent A Connections" + json.dumps(agent_a_conns))
    assert len(agent_a_conns) == 1

    # Agent B Connections
    agent_b_conns = prover.connection_get_connections()
    logging.info("Agent B Connections" + json.dumps(agent_b_conns))
    assert len(agent_b_conns) == 1

    # Agent A Create Simpele Message
    from_did = agent_a_conns[0]["my_did"]
    their_did = agent_a_conns[0]["their_did"]
    message = "hello agent A"
    encrypted_message = issuer.connection_encrypt(
        from_did, their_did, NixarMessageType.MESSAGE_TYPE_SIMPLE, message)
    logging.info("Agent A create message, encrypted_message:" +
                 json.dumps(encrypted_message))

    # Agent B receive message and decrypt
    decrypted_message = prover.connection_decrypt(encrypted_message)
    logging.info("Agent B decrypt message, decrypted_message:" +
                 json.dumps(decrypted_message))

    # Sign and verify with did
    # Prover get connections
    agent_b_conns = prover.connection_get_connections()
    from_did = agent_b_conns[0]["my_did"]
    their_did = agent_b_conns[0]["their_did"]

    data = "Data To Be Signed"
    signed_data = bytes(data, 'utf-8')
    logging.info("Data To Be Signed: {}".format(base64.b64encode(signed_data)));
    base64_encoded_signature = prover.sign_with_did(from_did, signed_data)
    logging.info("Signature: {}".format(base64_encoded_signature));

    packed_signature = {}
    packed_signature['signedData'] = base64.b64encode(signed_data).decode('utf-8')
    packed_signature['signature'] = base64_encoded_signature
    logging.info("Packed signature {}".format(packed_signature))
    encrypted_message = prover.connection_encrypt(from_did,
                                                  their_did,
                                                  NixarMessageType.MESSAGE_TYPE_SIMPLE,
                                                  packed_signature)
    logging.info("Prover Agent create message of signature info, encrypted_message: {}".format(encrypted_message))

    decrypted_message = issuer.connection_decrypt(encrypted_message)
    logging.info("Issuer Agent decrypt message, decrypted_message: {}".format(decrypted_message))
    unpacked_signature = json.loads(decrypted_message['content'])
    logging.info("Unpacked signature info {}".format(unpacked_signature))

    # 1. verify with their did from connection.
    is_verified = issuer.verify_signature_with_their_did(decrypted_message['senderDid'],
                                                         unpacked_signature['signedData'],
                                                         unpacked_signature['signature'])

    logging.info("Verification Result with their did {}".format(is_verified))

    # 2. OR verify with their PUBLIC Key
    did_doc = issuer.get_their_did_as_did_doc(decrypted_message['senderDid'])
    logging.info(did_doc)
    logging.info(did_doc['publicKeys'][0])
    is_verified = prover.verify_signature_with_did_public_key(did_doc['publicKeys'][0]['value'],
                                                              unpacked_signature['signedData'],
                                                              unpacked_signature['signature'])

    logging.info("Verification Result {}".format(is_verified))


def read_store_tail():
    issuer.issuer_get_tail()


demo_did_comm()

demo_with_non_revocable()

demo_with_revocable()