@mocanetwork/privado-js-sdk 1.0.0

package/src/verifiable/presentation.ts

@@ -0,0 +1,97 @@
+import { VerifiableConstants } from './constants';
+import { Options, Path } from '@iden3/js-jsonld-merklization';
+import { W3CCredential } from './credential';
+import { QueryMetadata } from '../proof';
+import { VerifiablePresentation, JsonDocumentObject } from '../iden3comm';
+
+export const stringByPath = (obj: { [key: string]: unknown }, path: string): string => {
+  const parts = path.split('.');
+
+  let value = obj;
+  for (let index = 0; index < parts.length; index++) {
+    const key = parts[index];
+    if (!key) {
+      throw new Error('path is empty');
+    }
+    value = value[key] as { [key: string]: unknown };
+    if (value === undefined) {
+      throw new Error('path not found');
+    }
+  }
+  return value.toString();
+};
+
+export const buildFieldPath = async (
+  ldSchema: string,
+  contextType: string,
+  field: string,
+  opts?: Options
+): Promise<Path> => {
+  let path = new Path();
+
+  if (field) {
+    path = await Path.getContextPathKey(ldSchema, contextType, field, opts);
+  }
+  path.prepend([VerifiableConstants.CREDENTIAL_SUBJECT_PATH]);
+  return path;
+};
+
+export const findValue = (fieldName: string, credential: W3CCredential): JsonDocumentObject => {
+  const [first, ...rest] = fieldName.split('.');
+  let v = credential.credentialSubject[first];
+  for (const part of rest) {
+    v = (v as JsonDocumentObject)[part];
+  }
+  return v as JsonDocumentObject;
+};
+
+export const createVerifiablePresentation = (
+  context: string,
+  tp: string,
+  credential: W3CCredential,
+  queries: QueryMetadata[]
+): VerifiablePresentation => {
+  const baseContext = [VerifiableConstants.JSONLD_SCHEMA.W3C_CREDENTIAL_2018];
+  const ldContext = baseContext[0] === context ? baseContext : [...baseContext, context];
+
+  const vc = VerifiableConstants.CREDENTIAL_TYPE.W3C_VERIFIABLE_CREDENTIAL;
+  const vcTypes = [vc];
+  if (tp !== vc) {
+    vcTypes.push(tp);
+  }
+
+  const skeleton = {
+    '@context': baseContext,
+    type: VerifiableConstants.CREDENTIAL_TYPE.W3C_VERIFIABLE_PRESENTATION,
+    verifiableCredential: {
+      '@context': ldContext,
+      type: vcTypes,
+      credentialSubject: {
+        type: tp
+      }
+    }
+  };
+
+  let result: JsonDocumentObject = {};
+  for (const query of queries) {
+    const parts = query.fieldName.split('.');
+    const current: JsonDocumentObject = parts.reduceRight(
+      (acc: JsonDocumentObject, part: string) => {
+        if (result[part]) {
+          return { [part]: { ...(result[part] as JsonDocumentObject), ...acc } };
+        }
+        return { [part]: acc };
+      },
+      findValue(query.fieldName, credential) as JsonDocumentObject
+    );
+
+    result = { ...result, ...current };
+  }
+
+  skeleton.verifiableCredential.credentialSubject = {
+    ...skeleton.verifiableCredential.credentialSubject,
+    ...result
+  };
+
+  return skeleton;
+};

package/src/verifiable/proof.ts

@@ -0,0 +1,277 @@
+import { Hash, Proof } from '@iden3/js-merkletree';
+import {
+  ProofType,
+  CredentialStatusType,
+  RefreshServiceType,
+  DisplayMethodType
+} from './constants';
+import { TreeState } from '../circuits';
+import { Hex, Signature } from '@iden3/js-crypto';
+import { Claim, DID } from '@mocanetwork/moca-iden3';
+import { JsonDocumentObject, JSONObject } from '../iden3comm';
+
+/**
+ * Represents the published state of the issuer
+ *
+ * @public
+ * @interface   State
+ */
+export interface State {
+  txId?: string;
+  blockTimestamp?: number;
+  blockNumber?: number;
+  rootOfRoots: Hash;
+  claimsTreeRoot: Hash;
+  revocationTreeRoot: Hash;
+  value: Hash;
+  status?: string;
+}
+
+/**
+ * Iden3SparseMerkleProof is a iden3 protocol merkle tree proof
+ *
+ * @public
+ * @class Iden3SparseMerkleTreeProof
+ */
+export class Iden3SparseMerkleTreeProof {
+  type: ProofType;
+  issuerData: {
+    id: DID;
+    state: State;
+  };
+  mtp: Proof;
+  coreClaim: Claim;
+  /**
+   * Creates an instance of Iden3SparseMerkleTreeProof.
+   * @param {object} obj
+   */
+  constructor(obj: {
+    issuerData: {
+      id: DID;
+      state: State;
+    };
+    mtp: Proof;
+    coreClaim: Claim;
+  }) {
+    this.coreClaim = obj.coreClaim;
+    this.issuerData = obj.issuerData;
+    this.type = ProofType.Iden3SparseMerkleTreeProof;
+    this.mtp = obj.mtp;
+  }
+
+  /**
+   *
+   *
+   * @returns `json object in serialized presentation`
+   */
+  toJSON() {
+    const issuerId = this.issuerData.id;
+    return {
+      issuerData: {
+        id: issuerId.string(),
+        state: {
+          ...this.issuerData.state,
+          rootOfRoots: this.issuerData.state.rootOfRoots.hex(),
+          claimsTreeRoot: this.issuerData.state.claimsTreeRoot.hex(),
+          revocationTreeRoot: this.issuerData.state.revocationTreeRoot.hex(),
+          value: this.issuerData.state.value.hex()
+        }
+      },
+      type: this.type,
+      coreClaim: this.coreClaim.hex(),
+      mtp: this.mtp.toJSON()
+    };
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromJSON(obj: any) {
+    let mtp: Proof;
+    if (obj?.mtp?.notEmpties && obj?.mtp?.depth && obj?.mtp?.siblings) {
+      // legacy
+
+      const ne = obj?.mtp?.notEmpties;
+      const notEmpties = ne instanceof Uint8Array ? ne : new Uint8Array(Object.values(ne));
+      const siblingsHashes = obj?.mtp?.siblings.map((h: unknown) =>
+        Hash.fromString(JSON.stringify(h))
+      );
+      const allSiblings = Proof.buildAllSiblings(obj?.mtp?.depth, notEmpties, siblingsHashes);
+      let nodeAux = obj.mtp.nodeAux || obj.mtp.node_aux;
+      if (nodeAux) {
+        nodeAux = {
+          key: Hash.fromString(JSON.stringify(nodeAux.key)),
+          value: Hash.fromString(JSON.stringify(nodeAux.value))
+        };
+      }
+      mtp = new Proof({ existence: obj?.mtp.existence, nodeAux: nodeAux, siblings: allSiblings });
+    } else {
+      mtp = Proof.fromJSON(obj.mtp);
+    }
+
+    return new Iden3SparseMerkleTreeProof({
+      coreClaim: new Claim().fromHex(obj.coreClaim),
+      mtp,
+      issuerData: {
+        id: DID.parse(obj.issuerData.id),
+        state: {
+          ...obj.issuerData.state,
+          rootOfRoots: Hash.fromHex(obj.issuerData.state.rootOfRoots),
+          claimsTreeRoot: Hash.fromHex(obj.issuerData.state.claimsTreeRoot),
+          revocationTreeRoot: Hash.fromHex(obj.issuerData.state.revocationTreeRoot),
+          value: Hash.fromHex(obj.issuerData.state.value)
+        }
+      }
+    });
+  }
+}
+
+/**
+ *
+ * BJJSignatureProof2021 is a signature of core claim by BJJ key
+ * @public
+ * @class BJJSignatureProof2021
+ */
+export class BJJSignatureProof2021 {
+  type: ProofType;
+  issuerData: {
+    id: DID;
+    state: State;
+    authCoreClaim: Claim;
+    mtp: Proof;
+    credentialStatus: CredentialStatus;
+  };
+  signature: Signature;
+  coreClaim: Claim;
+
+  constructor(obj: {
+    issuerData: {
+      id: DID;
+      state: State;
+      authCoreClaim: Claim;
+      mtp: Proof;
+      credentialStatus: CredentialStatus;
+    };
+    coreClaim: Claim;
+    signature: Signature;
+  }) {
+    this.type = ProofType.BJJSignature;
+    this.issuerData = obj.issuerData;
+    this.coreClaim = obj.coreClaim;
+    this.signature = obj.signature;
+  }
+
+  /**
+   * toJSON is a method to serialize BJJSignatureProof2021 to json
+   *
+   * @returns `json object in serialized presentation`
+   */
+  toJSON() {
+    return {
+      issuerData: {
+        id: this.issuerData.id.string(),
+        state: {
+          ...this.issuerData.state,
+          rootOfRoots: this.issuerData.state.rootOfRoots.hex(),
+          claimsTreeRoot: this.issuerData.state.claimsTreeRoot.hex(),
+          revocationTreeRoot: this.issuerData.state.revocationTreeRoot.hex(),
+          value: this.issuerData.state.value.hex()
+        },
+        mtp: this.issuerData.mtp.toJSON(),
+        authCoreClaim: this.issuerData.authCoreClaim.hex(),
+        credentialStatus: this.issuerData.credentialStatus
+      },
+      type: this.type,
+      coreClaim: this.coreClaim.hex(),
+      signature: Hex.encodeString(this.signature.compress())
+    };
+  }
+
+  /**
+   * fromJSON is a method to deserialize BJJSignatureProof2021 from json
+   * @param obj
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromJSON(obj: any) {
+    return new BJJSignatureProof2021({
+      issuerData: {
+        id: DID.parse(obj.issuerData.id),
+        mtp: Proof.fromJSON(obj.issuerData.mtp),
+        state: {
+          ...obj.issuerData.state,
+          rootOfRoots: Hash.fromHex(obj.issuerData.state.rootOfRoots),
+          claimsTreeRoot: Hash.fromHex(obj.issuerData.state.claimsTreeRoot),
+          revocationTreeRoot: Hash.fromHex(obj.issuerData.state.revocationTreeRoot),
+          value: Hash.fromHex(obj.issuerData.state.value)
+        },
+        credentialStatus: obj.issuerData.credentialStatus,
+        authCoreClaim: new Claim().fromHex(obj.issuerData.authCoreClaim)
+      },
+      coreClaim: new Claim().fromHex(obj.coreClaim),
+      signature: Signature.newFromCompressed(
+        Uint8Array.from(Hex.decodeString(obj.signature)).slice(0, 64)
+      )
+    });
+  }
+}
+/**
+ *  Query represents structure for query to atomic circuit
+ *
+ * @public
+ * @interface   ProofQuery
+ */
+export interface ProofQuery {
+  allowedIssuers?: string[];
+  credentialSubject?: JsonDocumentObject;
+  schema?: string; // string url
+  claimId?: string;
+  credentialSubjectId?: string;
+  context?: string;
+  type?: string;
+  skipClaimRevocationCheck?: boolean;
+  proofType?: string;
+  groupId?: number;
+  params?: JSONObject;
+}
+
+/**
+ * Proof with MerkleTree info
+ *
+ * @public
+ * @interface   MerkleTreeProofWithTreeState
+ */
+export interface MerkleTreeProofWithTreeState {
+  proof: Proof;
+  treeState: TreeState;
+}
+
+/**
+ *
+ * CredentialStatus contains type and revocation Url
+ * @public
+ * @interface   CredentialStatus
+ */
+export interface CredentialStatus {
+  id: string;
+  type: CredentialStatusType;
+  revocationNonce?: number;
+  statusIssuer?: { id: string; type: CredentialStatusType; revocationNonce?: number };
+}
+
+/**
+ * RefreshService contains type and id
+ * @public
+ * @interface   RefreshService
+ */
+export interface RefreshService {
+  id: string;
+  type: RefreshServiceType | string;
+}
+
+/**
+ * DisplayMethod contains type and id
+ * @public
+ * @interface   DisplayMethod
+ */
+export interface DisplayMethod {
+  id: string;
+  type: DisplayMethodType | string;
+}

package/src/verifiable/schema.ts

@@ -0,0 +1,241 @@
+/** DIDDocumentJSONSchema is a basic schema of did document */
+export const DIDDocumentJSONSchema = `{
+  "type": "object",
+  "$defs": {
+    "serviceEndpoint": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "string"
+        },
+        "type": {
+          "type": "string"
+        },
+        "serviceEndpoint": {
+          "type": "string"
+        },
+        "metadata": {
+          "type": "object"
+        }
+      },
+      "required": [
+        "id",
+        "type",
+        "serviceEndpoint"
+      ]
+    },
+    "jsonWebKey": {
+      "type": "object",
+      "properties": {
+        "alg": {
+          "type": "string"
+        },
+        "crv": {
+          "type": "string"
+        },
+        "e": {
+          "type": "string"
+        },
+        "ext": {
+          "type": "boolean"
+        },
+        "key_ops": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "kid": {
+          "type": "string"
+        },
+        "kty": {
+          "type": "string"
+        },
+        "n": {
+          "type": "string"
+        },
+        "use": {
+          "type": "string"
+        },
+        "x": {
+          "type": "string"
+        },
+        "y": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "kty"
+      ],
+      "description": "Public parts of JSON web key"
+    },
+    "verificationMethod": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "string"
+        },
+        "type": {
+          "type": "string"
+        },
+        "controller": {
+          "type": "string"
+        },
+        "publicKeyBase58": {
+          "type": "string"
+        },
+        "publicKeyBase64": {
+          "type": "string"
+        },
+        "publicKeyJwk": {
+          "$ref": "#/$defs/jsonWebKey"
+        },
+        "publicKeyHex": {
+          "type": "string"
+        },
+        "publicKeyMultibase": {
+          "type": "string"
+        },
+        "blockchainAccountId": {
+          "type": "string"
+        },
+        "ethereumAddress": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "id",
+        "type",
+        "controller"
+      ]
+    }
+  },
+  "properties": {
+    "authentication": {
+      "type": "array",
+      "items": {
+        "anyOf": [
+          {
+            "type": "string"
+          },
+          {
+            "$ref": "#/$defs/verificationMethod"
+          }
+        ]
+      }
+    },
+    "assertionMethod": {
+      "type": "array",
+      "items": {
+        "anyOf": [
+          {
+            "type": "string"
+          },
+          {
+            "$ref": "#/$defs/verificationMethod"
+          }
+        ]
+      }
+    },
+    "keyAgreement": {
+      "type": "array",
+      "items": {
+        "anyOf": [
+          {
+            "type": "string"
+          },
+          {
+            "$ref": "#/$defs/verificationMethod"
+          }
+        ]
+      }
+    },
+    "capabilityInvocation": {
+      "type": "array",
+      "items": {
+        "anyOf": [
+          {
+            "type": "string"
+          },
+          {
+            "$ref": "#/$defs/verificationMethod"
+          }
+        ]
+      }
+    },
+    "capabilityDelegation": {
+      "type": "array",
+      "items": {
+        "anyOf": [
+          {
+            "type": "string"
+          },
+          {
+            "$ref": "#/$defs/verificationMethod"
+          }
+        ]
+      }
+    },
+    "@context": {
+      "anyOf": [
+        {
+          "type": "string",
+          "const": "https://www.w3.org/ns/did/v1"
+        },
+        {
+          "type": "string"
+        },
+        {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        }
+      ]
+    },
+    "id": {
+      "type": "string"
+    },
+    "alsoKnownAs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "controller": {
+      "anyOf": [
+        {
+          "type": "string"
+        },
+        {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        }
+      ]
+    },
+    "verificationMethod": {
+      "type": "array",
+      "items": {
+        "$ref": "#/$defs/verificationMethod"
+      }
+    },
+    "service": {
+      "type": "array",
+      "items": {
+        "$ref": "#/$defs/serviceEndpoint"
+      }
+    },
+    "publicKey": {
+      "type": "array",
+      "items": {
+        "$ref": "#/$defs/verificationMethod"
+      },
+      "deprecated": true
+    }
+  },
+  "required": [
+    "id"
+  ]
+}`;