Nixar Core Developer Integration Guide

inv_base64_seed = test_utils.encode_base64("00000000000000000000000000AGENTA")
conn_inv = agent_a.connection_create_local_invitation("agent A", "http://localhost:8080", inv_base64_seed)
logging.info("Agent A create connection invitation, conn_inv: {}".format(json.dumps(conn_inv)))

let publicInvitation = try issuer.createLocalInvitation(label: "labello", endpoint: "http://pil.sat", seed: nil)

# Agent B receive invitation and create connection request
req_base64_seed = test_utils.encode_base64("00000000000000000000000000AGENTB")
conn_req = agent_b.connection_create_request(conn_inv, req_base64_seed)
logging.info("Agent B create connection request, conn_req: {}".format(json.dumps(conn_req)))

let seed = "000000000000000000MYCONNECTION01"
let encryptedConnectionRequest = try prover.createConnectionRequest(
  invitation: publicInvitation,
  seed: convertToBase64Seed(seed)
)

# Agent A receive connection request and create connection response
conn_res = agent_a.connection_accept_request(conn_req, None)
logging.info("Agent A create connection response, conn_res: {}".format(json.dumps(conn_res)))

let encryptedConnectionResponse = try issuer.acceptConnectionRequest(requestMessage: encryptedConnectionRequest, alias: proverAlias)

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

try prover.acceptConnectionResponse(responseMessage: encryptedConnectionResponse)

packed_signature = {}
packed_signature['signedData'] = signed_data
packed_signature['signature'] = base64_encoded_signature
logging.info("Packed signature {}".format(packed_signature))
encrypted_message = agent_b.connection_encrypt(from_did,
                                               their_did,
                                               NixarMessageType.MESSAGE_TYPE_SIMPLE,
                                               packed_signature)
logging.info("Agent B create message of signature info, encrypted_message: {}".format(encrypted_message))

var packedSignature: [String: String] = [:]
packedSignature["signedData"] = signedDataAsData.base64EncodedString()
packedSignature["signature"] = base64EncodedSignature

let messageString = try JSONHelper.encode(packedSignature)

var _: NixarEncryptedMessage = try prover.encryptMessage(
  fromDid: (issuerConnection?.myDid)!,
  toDid: (issuerConnection?.theirDid)!,
  messageType: SwiftNixarMessageType.MessageTypeSimple,
  content: messageString
)

schema_version = "2.0"
schema_id = issuer.issuer_create_schema(schema_name, attribute_set, schema_version)
logger.info("Schema created, schema_id: {}".format(schema_id))
# if it is not revocable, issuance_type, max_cred_num will be ignored in nixar
cred_def_id = issuer.issuer_create_credential_definition(schema_id, is_revocable, tag, issuance_type, MAX_CRED_NUM)
logger.info("Credential definition created, cred_def_id: " + cred_def_id)

var schemaId: String

do {
  let schema = try agent.getSchema(schemaId: expectedSchema.id!)
  schemaId = schema.id!
} catch {
  print("Error", error.localizedDescription, error)
  schemaId = try agent.createSchema(
    schemaName: expectedSchema.name, attributeSet: Set(expectedSchema.attrNames), schemaVersion: expectedSchema.version
  )
}

print("SchemaId: \(schemaId)")
var credDefId: String

do {
  let credentialDefinitions = try agent.getCredentialDefinitions(schemaId: schemaId)
  if credentialDefinitions.count > 0 {
    credDefId = credentialDefinitions[credentialDefinitions.count - 1].id
  } else {
    throw NixarApiException.ApiError(code: "NoCredentialDefinition", description: "No cred def")
  }
} catch {
  print("Error", error.localizedDescription, error)
  credDefId = try agent.createCredentialDefinition(
    schemaId: schemaId,
    isRevocable: isRevocable,
    issuanceType: issuanceType,
    maxCredNum: 20,
    tag: tag
  )
}

print("CredDefId: \(credDefId)")

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:{}".format(json.dumps(cred_offer)))

let sIssuerNonce = getNonce()
let credOffer = try issuer.createCredentialOffer(credDefId: credDefId, sIssuerNonce)
print("Credential offer created, credOffer: \(try JSONHelper.encode(credOffer))")

cred_request = prover.prover_create_credential_request(cred_offer)
logging.info("Credential request created, cred_request: {}".format( json.dumps(cred_request)))

let credReq = try prover.createCredentialRequest(credOffer: credOffer)
print("Credential request created, credReq: \(try JSONHelper.encode(credReq))")

cred_values = generate_sample_cred_values(attribute_set)
cred_info = issuer.issuer_create_credential(cred_request, cred_values, issuer_nonce)
cred = cred_info["credential"]
cred_rev_id = cred_info["credRevId"]
logging.info("Credential created, cred: {}".format( json.dumps(cred)))

let credValues = basicIdentitySchema.fillAttributeValues(name: "Mehmet", surname: "Öztürk", age: "30", gender: "Male")
let credValues1 = try JSONHelper.encode(credValues)
let issuedCredInfo = try issuer.createCredential(credRequest: credReq, credValues: credValues1, sIssuerNonce)
print("Credential created, cred: \(try JSONHelper.encode(issuedCredInfo.credential))")

store_cred = prover.prover_store_credential(None, cred)
logging.info("Credential stored, store_cred: {}".format(store_cred))

let storeCred = try prover.storeCredential(credId: issuedCredInfo.credRevId!, credential: issuedCredInfo.credential)
print("Store credential created, store_cred: \(storeCred)")

# 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": {
    "attribute1_referent": {
      "name": "name",
      # Optional
      "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
    }
  }
}

//requested_attributes
var reqAttrs: [String: AttributeInfo] = [:]

let attributeInfo1 = AttributeInfo(name: "name")
reqAttrs["attribute1_referent"] = attributeInfo1

let attributeInfo2 = AttributeInfo(name: "surname")
reqAttrs["attribute2_referent"] = attributeInfo2

let attributeInfo3 = AttributeInfo(name: "gender")
reqAttrs["attribute3_referent"] = attributeInfo3

let attributeInfo4 = AttributeInfo(name: "hobbies")
reqAttrs["attribute4_referent"] = attributeInfo4

// requested_predicates
var reqPreds: [String: PredicateInfo] = [:]

let predicateInfo = PredicateInfo(name: "age", p_type: PredicateTypes.GT, p_value: 10)
reqPreds["predicate1_referent"] = predicateInfo

let presReq = PresentationRequest(nonce: "88510039", name: "IdentityPR", version: "2.0", requestedAttributes: reqAttrs, requestedPredicates: reqPreds, nonRevokedInterval: Optional.none)

con_pre_req = {
  "version": "1.0",
  "nonce": "1023493215165936210711920",
  "requestedAttributes": [
    "name",
    "surname"
  ],
  "restrictions": {
    "And": [
      {
        "And": [
          {
            "Gte": [
              {
                "Identifier": "age"
              },
              {
                "Number": 18.0
              }
            ]
          },
          {
            "Lte": [
              {
                "Identifier": "age"
              },
              {
                "Number": 40.0
              }
            ]
          }
        ]
      },
      {
        "In": {
          "left": {
            "Identifier": "department"
          },
          "right": [
            {
              "String": "Bilgisayar Mühendisliği"
            },
            {
              "String": "Bilişim Sistemleri Mühendisliği"
            },
            {
              "String": "Elektrik-Elektronik Mühendisliği"
            },
            {
              "String": "Elektrik Mühendisliği"
            },
            {
              "String": "Endüstri Mühendisliği"
            }
          ]
        }
      },
      {
        "Gte": [
          {
            "Identifier": "grade"
          },
          {
            "Number": 2.0
          }
        ]
      },
      {
        "Exists": {
          "Identifier": "labor_number"
        }
      },
      {
        "Eq": [
          {
            "Identifier": "profession"
          },
          {
            "String": "Bilgisayar Mühendisi"
          }
        ]
      },
      {
        "Gte": [
          {
            "Identifier": "salary"
          },
          {
            "Number": 35000.0
          }
        ]
      }
    ]
  }
}

func getConditionalPresentationRequest() -> ConditionalPresentationRequest {
  let gender = ExprWrapper.eq(
    Eq(eq: [
      .identifier(IdentifierOperand(value: "gender")),
      .string(StringOperand(value: "Male"))
    ])
  )
  
  let ageLte = ExprWrapper.lte(
    Lte(lte: [
      .identifier(IdentifierOperand(value: "age")),
      .number(NumberOperand(value: 35.0))
    ])
  )
  
  let ageGte = ExprWrapper.gte(
    Gte(gte: [
      .identifier(IdentifierOperand(value: "age")),
      .number(NumberOperand(value: 25.0))
    ])
  )
  
  let age = ExprWrapper.and(
    And(and: [ageLte, ageGte])
  )
  
  let inExpr = InExpr(
    left: IdentifierOperand(value: "department"),
    right: [
      .string(StringOperand(value: "Bilgisayar Mühendisliği")),
      .string(StringOperand(value: "Bilişim Sistemleri Mühendisliği")),
      .string(StringOperand(value: "Elektrik-Elektronik Mühendisliği")),
      .string(StringOperand(value: "Elektrik Mühendisliği")),
      .string(StringOperand(value: "Endüstri Mühendisliği"))
    ]
  )
  
  let `in` = ExprWrapper.in(In(in: inExpr))
  
  let grade = ExprWrapper.gte(
    Gte(gte: [
      .identifier(IdentifierOperand(value: "grade")),
      .number(NumberOperand(value: 3.0))
    ])
  )
  
  let laborNumber = ExprWrapper.exists(
    Exists(exists: IdentifierOperand(value: "labor_number"))
  )
  
  let profession = ExprWrapper.eq(
    Eq(eq: [
      .identifier(IdentifierOperand(value: "profession")),
      .string(StringOperand(value: "Bilgisayar Mühendisi"))
    ])
  )
  
  let salary = ExprWrapper.gte(
    Gte(gte: [
      .identifier(IdentifierOperand(value: "salary")),
      .number(NumberOperand(value: 25000.0))
    ])
  )
  
  let expr = ExprWrapper.and(
    And(and: [gender, `in`, age, grade, laborNumber, profession, salary])
  )
  
  return ConditionalPresentationRequest(
    version: "2.0",
    nonce: "1023493215165936210711920",
    requestedAttributes: ["name", "surname"],
    restrictions: expr
  )
}

self_attested_values = {"self_attested_referent": "swim"}

pres_req = get_presentation_request(schema_id, cred_def_id)
pres = prover.prover_create_presentation(pres_req, self_attested_values)
logging.info("Presentation created, pres: {}".format(json.dumps(pres)))

// Prover create presentation
let selfAttestedValues = "{\"attribute4_referent\": \"swim\"}"

var pres = try prover.createPresentation(presentationRequest: presReq, selfAttestedValues: selfAttestedValues)
print("Prover created presentation, pres: \(try JSONHelper.encode(pres))")

con_pres_req = test_utils.get_conditional_presentation_request()
logging.info("Conditional presentation request created, con_pres_req: {}".format(json.dumps(con_pres_req)))
self_attested_values = {}
pres = prover.prover_create_presentation_by_ast(con_pres_req, self_attested_values)
logging.info("Presentation created, pres: {}".format(json.dumps(pres)))

// Prover create presentation
let selfAttestedValues = "{\"attribute4_referent\": \"swim\"}"

var pres = try prover.createPresentation(presentationRequest: presReq, selfAttestedValues: selfAttestedValues)
print("Prover created presentation, pres: \(try JSONHelper.encode(pres))")

v_result = verifier.verifier_verify_presentation(pres_req, pres)
logging.info("Presentation verified, result: {}".format(v_result))
assert v_result == True

// verifier verify presentation
var vResult = try verifier.verifyPresentation(presentationRequest: presReq, presentation: pres)
print("Verifier verify presentation, result: \(vResult)")
XCTAssert(vResult == true)

v_result = verifier.verifier_verify_presentation_by_ast(con_pres_req, pres)
logging.info("Presentation verified, result: {}".format(v_result))
assert v_result == True

// verifier verify presentation
let vResult = try verifier.verifyPresentationByAST(conditionalPresentationRequest: conPresReq, presentation: pres)
print("Verifier verify presentation, result: \(vResult)")
assert(vResult)

issuer.issuer_revoke_credential(cred_rev_id, cred_def_id)
logging.info("Credential revoked")

try issuer.revokeCredential(credRevIndex: issuedCredInfo.credRevId!, credDefId: credDefId)
print("Issuer revoke credential: OK")

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

let tail = try issuer.getTail(revRegId: "TbAqayWyFFK6VN7eebBTf1:4:TbAqayWyFFK6VN7eebBTf1:3:CL:302423:bilgem:CL_ACCUM:bilgem")
print("TAIL")
print(tail)

prover.prover_store_tail("P_" + tail_name_of_rev_reg, tail)
logging.info("Tail stored")

try prover.storeTail(revRegId: "TmAqayWyFFK6VN7eebBTf1:4:TbAqayWyFFK6VN7eebBTf1:3:CL:302423:bilgem:CL_ACCUM:bilgem", tail: tail)