@mocanetwork/privado-js-sdk 1.0.0

package/src/circuits/common.ts

@@ -0,0 +1,261 @@
+import { Hex } from '@iden3/js-crypto';
+import { Hash, ZERO_HASH, Proof, swapEndianness } from '@iden3/js-merkletree';
+import { TreeState } from './models';
+import { Id } from '@mocanetwork/moca-iden3';
+
+export const defaultMTLevels = 40; // max MT levels, default value for identity circuits
+export const defaultValueArraySize = 64; // max value array size, default value for identity circuits
+export const defaultMTLevelsOnChain = 64; // max MT levels on chain, default value for identity circuits
+export const defaultMTLevelsClaim = 32; // max MT levels of JSON-LD merklization on claim
+
+export const ErrorEmptyAuthClaimProof = 'empty auth claim mtp proof';
+export const ErrorEmptyAuthClaimNonRevProof = 'empty auth claim non-revocation mtp proof';
+export const ErrorEmptyChallengeSignature = 'empty challenge signature';
+export const ErrorEmptyClaimSignature = 'empty claim signature';
+export const ErrorEmptyClaimProof = 'empty claim mtp proof';
+export const ErrorEmptyClaimNonRevProof = 'empty claim non-revocation mtp proof';
+export const ErrorUserStateInRelayClaimProof =
+  'empty user state in relay claim non-revocation mtp proof';
+export const ErrorEmptyIssuerAuthClaimProof = 'empty issuer auth claim mtp proof';
+export const ErrorEmptyIssuerAuthClaimNonRevProof =
+  'empty issuer auth claim non-revocation mtp proof';
+
+/**
+ * base config for circuit inputs
+ *
+ * @public
+ * @class BaseConfig
+ */
+export class BaseConfig {
+  mtLevel!: number; // Max levels of MT
+  maxValueArraySize!: number; // Size if( value array in identity circuit)s
+  mtLevelOnChain!: number;
+  mtLevelClaim!: number; // Max level of JSONLD claim
+
+  /**
+   *  getMTLevel max circuit MT levels
+   *
+   * @returns number
+   */
+  getMTLevel(): number {
+    return this.mtLevel ? this.mtLevel : defaultMTLevels;
+  }
+  /**
+   *  GetMTLevelsClaim max jsonld Claim levels
+   *
+   * @returns number
+   */
+  getMTLevelsClaim(): number {
+    return this.mtLevelClaim ? this.mtLevelClaim : defaultMTLevelsClaim;
+  }
+
+  /**
+   * GetValueArrSize return size of circuits value array size
+   *
+   * @returns number
+   */
+  getValueArrSize(): number {
+    return this.maxValueArraySize ? this.maxValueArraySize : defaultValueArraySize;
+  }
+
+  /**
+   * getMTLevelOnChain return level on chain for given circuit
+   *
+   * @returns number
+   */
+  getMTLevelOnChain(): number {
+    return this.mtLevelOnChain ? this.mtLevelOnChain : defaultMTLevelsOnChain;
+  }
+}
+
+/**
+ * @deprecated The method should not be used and will be removed in the next major version,
+ * please use Hash.fromHex instead
+ * @param {(string | undefined)} s - string hex
+ * @returns Hash
+ */
+export const strMTHex = (s: string | undefined): Hash => {
+  if (!s) {
+    return ZERO_HASH;
+  }
+  const h = new Hash();
+  h.value = swapEndianness(Hex.decodeString(s));
+  return h;
+};
+
+/**
+ * converts hexes of tree roots to Hashes
+ *
+ * @param {(string | undefined)} state - state of tree hex
+ * @param {(string | undefined)} claimsTreeRoot - claims tree root hex
+ * @param {(string | undefined)} revocationTreeRoot - revocation tree root hex
+ * @param {(string | undefined)} rootOfRoots - root of roots tree root hex
+ * @returns TreeState
+ */
+export const buildTreeState = (
+  state: string | undefined,
+  claimsTreeRoot: string | undefined,
+  revocationTreeRoot: string | undefined,
+  rootOfRoots: string | undefined
+): TreeState => ({
+  state: Hash.fromHex(state),
+  claimsRoot: Hash.fromHex(claimsTreeRoot),
+  revocationRoot: Hash.fromHex(revocationTreeRoot),
+  rootOfRoots: Hash.fromHex(rootOfRoots)
+});
+
+/**
+ * siblings as string array
+ *
+ * @param {Proof} proof - proof with siblings
+ * @param {number} levels - levels number
+ * @returns string[]
+ */
+export const prepareSiblingsStr = (proof: Proof, levels: number): string[] => {
+  const siblings = proof.allSiblings();
+
+  // Add the rest of empty levels to the siblings
+  for (let i = siblings.length; i < levels; i++) {
+    siblings.push(ZERO_HASH);
+  }
+  return siblings.map((s: Hash) => s.bigInt().toString());
+};
+
+/**
+ * PrepareCircuitArrayValues padding values to size.
+ * Validate array size and throw an exception if array is bigger than size
+ * if array is bigger, circuit cannot compile because number of inputs does not match
+ *
+ *
+ * @param {bigint[]} arr - given values
+ * @param {number} size - size to pad
+ * @returns bigint[]
+ */
+export const prepareCircuitArrayValues = (arr: bigint[], size: number): bigint[] => {
+  if (!arr) {
+    arr = [];
+  }
+  if (arr.length > size) {
+    throw new Error(`array size ${arr.length} is bigger max expected size ${size}`);
+  }
+
+  // Add the empty values
+  for (let i = arr.length; i < size; i++) {
+    arr.push(BigInt(0));
+  }
+
+  return arr;
+};
+
+/**
+ * converts each big integer in array to string
+ *
+ * @param {bigint[]} arr -  array of big numbers
+ * @returns string[]
+ */
+export const bigIntArrayToStringArray = (arr: bigint[]): string[] => {
+  return arr.map((a) => a.toString());
+};
+
+/**
+ * auxiliary node
+ *
+ * @public
+ * @interface   NodeAuxValue
+ */
+export interface NodeAuxValue {
+  key: Hash;
+  value: Hash;
+  noAux: string;
+}
+
+export /**
+ * gets auxiliary node from proof
+ *
+ * @param {(Proof | undefined)} p - mtp
+ * @returns NodeAuxValue
+ */
+const getNodeAuxValue = (p: Proof | undefined): NodeAuxValue => {
+  // proof of inclusion
+  if (p?.existence) {
+    return {
+      key: ZERO_HASH,
+      value: ZERO_HASH,
+      noAux: '0'
+    };
+  }
+
+  // proof of non-inclusion (NodeAux exists)
+  if (p?.nodeAux?.value !== undefined && p?.nodeAux?.key !== undefined) {
+    return {
+      key: p.nodeAux.key,
+      value: p.nodeAux.value,
+      noAux: '0'
+    };
+  }
+  // proof of non-inclusion (NodeAux does not exist)
+  return {
+    key: ZERO_HASH,
+    value: ZERO_HASH,
+    noAux: '1'
+  };
+};
+
+/**
+ * converts boolean existence param to integer
+ * if true - 1, else - 0
+ *
+ * @param {boolean} b - existence
+ * @returns number
+ */
+export const existenceToInt = (b: boolean): number => (b ? 0 : 1);
+
+/**
+ * return object properties
+ *
+ * @param {object} obj
+ * @returns object
+ */
+export function getProperties(obj: object): object {
+  const result: { [key: string]: unknown } = {};
+
+  for (const property in obj) {
+    // eslint-disable-next-line no-prototype-builtins
+    if (obj.hasOwnProperty(property) && !property.startsWith('_')) {
+      result[property] = obj[property as keyof typeof obj];
+    }
+  }
+  return result;
+}
+
+/**
+ * states info from pub signals
+ *
+ * @public
+ * @type   StatesInfo
+ */
+export type StatesInfo = {
+  states: {
+    id: Id;
+    state: Hash;
+  }[];
+  gists: {
+    id: Id;
+    root: Hash;
+  }[];
+};
+
+/**
+ * state pub signals
+ *
+ * @public
+ * @interface   IStatePubSignals
+ */
+export interface IStateInfoPubSignals {
+  /**
+   * return object with state params
+   *
+   * @returns {OnChainStateInfo}
+   */
+  getStatesInfo(): StatesInfo;
+}

package/src/circuits/comparer.ts

@@ -0,0 +1,227 @@
+/**
+ * Represents the XSD namespace and its corresponding data types.
+ */
+
+export enum XSDNS {
+  Boolean = 'http://www.w3.org/2001/XMLSchema#boolean',
+  Integer = 'http://www.w3.org/2001/XMLSchema#integer',
+  NonNegativeInteger = 'http://www.w3.org/2001/XMLSchema#nonNegativeInteger',
+  NonPositiveInteger = 'http://www.w3.org/2001/XMLSchema#nonPositiveInteger',
+  NegativeInteger = 'http://www.w3.org/2001/XMLSchema#negativeInteger',
+  PositiveInteger = 'http://www.w3.org/2001/XMLSchema#positiveInteger',
+  DateTime = 'http://www.w3.org/2001/XMLSchema#dateTime',
+  Double = 'http://www.w3.org/2001/XMLSchema#double',
+  String = 'http://www.w3.org/2001/XMLSchema#string'
+}
+
+/**
+ * List of available operators.
+ *
+ * @enum {number}
+ */
+export enum Operators {
+  NOOP = 0, // No operation, skip query verification in circuit
+  EQ = 1,
+  LT = 2,
+  GT = 3,
+  IN = 4,
+  NIN = 5,
+  NE = 6,
+  LTE = 7,
+  GTE = 8,
+  BETWEEN = 9,
+  NONBETWEEN = 10,
+  EXISTS = 11,
+  SD = 16,
+  NULLIFY = 17
+}
+
+/** QueryOperators represents operators for atomic circuits */
+export const QueryOperators = {
+  $noop: Operators.NOOP,
+  $eq: Operators.EQ,
+  $lt: Operators.LT,
+  $gt: Operators.GT,
+  $in: Operators.IN,
+  $nin: Operators.NIN,
+  $ne: Operators.NE,
+  $lte: Operators.LTE,
+  $gte: Operators.GTE,
+  $between: Operators.BETWEEN,
+  $nonbetween: Operators.NONBETWEEN,
+  $exists: Operators.EXISTS,
+  $sd: Operators.SD,
+  $nullify: Operators.NULLIFY
+};
+
+export const getOperatorNameByValue = (operator: number): string => {
+  const ops = Object.entries(QueryOperators).find(([, queryOp]) => queryOp === operator);
+  return ops ? ops[0] : 'unknown';
+};
+
+const allOperations = Object.values(QueryOperators);
+
+export const availableTypesOperators: Map<string, Operators[]> = new Map([
+  [
+    XSDNS.Boolean,
+    [QueryOperators.$eq, QueryOperators.$ne, QueryOperators.$sd, QueryOperators.$exists]
+  ],
+  [XSDNS.Integer, allOperations],
+  [XSDNS.NonNegativeInteger, allOperations],
+  [XSDNS.PositiveInteger, allOperations],
+  [
+    XSDNS.Double,
+    [
+      QueryOperators.$eq,
+      QueryOperators.$ne,
+      QueryOperators.$in,
+      QueryOperators.$nin,
+      QueryOperators.$sd,
+      QueryOperators.$exists
+    ]
+  ],
+  [
+    XSDNS.String,
+    [
+      QueryOperators.$eq,
+      QueryOperators.$ne,
+      QueryOperators.$in,
+      QueryOperators.$nin,
+      QueryOperators.$sd,
+      QueryOperators.$exists
+    ]
+  ],
+  [XSDNS.DateTime, allOperations]
+]);
+
+/**
+ * Checks if the given operation is valid for the specified datatype.
+ * @param datatype - The datatype to check the operation for.
+ * @param op - The operation to check.
+ * @returns True if the operation is valid, false otherwise.
+ */
+export const isValidOperation = (datatype: string, op: number): boolean => {
+  if (op === Operators.NOOP) {
+    return true;
+  }
+
+  if (!availableTypesOperators.has(datatype)) {
+    return false;
+  }
+  const ops = availableTypesOperators.get(datatype);
+  if (!ops) {
+    return false;
+  }
+  return ops.includes(op);
+};
+
+// Comparer value.
+export interface IComparer {
+  compare(int: number): boolean;
+}
+
+/**
+ * Scalar is used to compare two scalar value.
+ *
+ * @public
+ * @class Scalar
+ * @implements implements IComparer interface
+ */
+export class Scalar implements IComparer {
+  /**
+   * Creates an instance of Scalar.
+   * @param {bigint} x - val x
+   * @param {bigint} y - val y
+   */
+  constructor(private x: bigint, private y: bigint) {}
+  /**
+   * compares two  scalar values
+   *
+   * @param {Operators} operator - EQ / LT / GT
+   * @returns boolean
+   */
+  compare(operator: Operators): boolean {
+    switch (operator) {
+      case Operators.EQ:
+        return this.x === this.y;
+      case Operators.LT:
+        return this.x < this.y;
+      case Operators.GT:
+        return this.x > this.y;
+      case Operators.NE:
+        return this.x !== this.y;
+      default:
+        throw new Error('unknown compare type for scalar');
+    }
+  }
+}
+
+/**
+ * Vector uses for find/not find x scalar type in y vector type.
+ *
+ * @public
+ * @class Vector
+ * @implements implements IComparer interface
+ */
+export class Vector implements IComparer {
+  /**
+   * Creates an instance of Vector.
+   * @param {bigint} x - val x
+   * @param {bigint[]} y - array values y
+   */
+  constructor(private x: bigint, private y: bigint[]) {}
+  /**
+   *
+   *
+   * @param {Operators} operator - IN / NIN
+   * @returns boolean
+   */
+  compare(operator: Operators): boolean {
+    switch (operator) {
+      case Operators.IN:
+        return this.y.includes(this.x);
+      case Operators.NIN:
+        return !this.y.includes(this.x);
+      case Operators.BETWEEN:
+        if (this.y.length !== 2) {
+          return false;
+        }
+        return this.x >= this.y[0] && this.x <= this.y[1];
+      case Operators.NONBETWEEN:
+        if (this.y.length !== 2) {
+          return false;
+        }
+        return this.x < this.y[0] || this.x > this.y[1];
+      default:
+        throw new Error('unknown compare type for vector');
+    }
+  }
+}
+
+/**
+ * FactoryComparer depends on input data will return right comparer.
+ *
+ * @param {bigint} x - val x
+ * @param {bigint[]} y - array of values y
+ * @param {Operators} operator - EQ / LT / GT / IN / NIN
+ * @returns IComparer
+ */
+export const factoryComparer = (x: bigint, y: bigint[], operator: Operators): IComparer => {
+  switch (operator) {
+    case Operators.EQ:
+    case Operators.LT:
+    case Operators.GT:
+    case Operators.NE:
+      if (y.length !== 1) {
+        throw new Error('currently we support only one value for scalar comparison');
+      }
+      return new Scalar(x, y[0]);
+    case Operators.IN:
+    case Operators.NIN:
+    case Operators.BETWEEN:
+    case Operators.NONBETWEEN:
+      return new Vector(x, y);
+    default:
+      throw new Error('unknown compare type');
+  }
+};

package/src/circuits/index.ts

@@ -0,0 +1,12 @@
+export * from './common';
+export * from './models';
+export * from './comparer';
+export * from './atomic-query-mtp-v2';
+export * from './atomic-query-mtp-v2-on-chain';
+export * from './atomic-query-sig-v2';
+export * from './atomic-query-v3';
+export * from './atomic-query-v3-on-chain';
+export * from './atomic-query-sig-v2-on-chain';
+export * from './auth-v2';
+export * from './state-transition';
+export * from './linked-multi-query';

package/src/circuits/linked-multi-query.ts

@@ -0,0 +1,180 @@
+import { Claim } from '@mocanetwork/moca-iden3';
+import { Proof } from '@iden3/js-merkletree';
+import { byteDecoder, byteEncoder } from '../utils';
+import {
+  BaseConfig,
+  bigIntArrayToStringArray,
+  getNodeAuxValue,
+  prepareCircuitArrayValues,
+  prepareSiblingsStr
+} from './common';
+import { Query, ValueProof } from './models';
+
+/**
+ * LinkedMultiQuery circuit representation
+ * Inputs and public signals declaration, marshalling and parsing
+ *
+ * @beta
+ * @class LinkedMultiQueryInputs
+ */
+export class LinkedMultiQueryInputs extends BaseConfig {
+  static queryCount = 10;
+  linkNonce!: bigint;
+  claim!: Claim;
+  query!: Query[];
+
+  // InputsMarshal returns Circom private inputs for linkedMultiQueryInputs.circom
+  inputsMarshal(): Uint8Array {
+    const claimPathMtp: string[][] = [];
+    const claimPathMtpNoAux: string[] = [];
+    const claimPathMtpAuxHi: string[] = [];
+    const claimPathMtpAuxHv: string[] = [];
+    const claimPathKey: string[] = [];
+    const claimPathValue: string[] = [];
+    const slotIndex: number[] = [];
+    const operator: number[] = [];
+    const value: string[][] = [];
+    const valueArraySize: number[] = [];
+
+    for (let i = 0; i < LinkedMultiQueryInputs.queryCount; i++) {
+      if (!this.query[i]) {
+        claimPathMtp.push(new Array(this.getMTLevelsClaim()).fill('0'));
+
+        claimPathMtpNoAux.push('0');
+        claimPathMtpAuxHi.push('0');
+        claimPathMtpAuxHv.push('0');
+
+        claimPathKey.push('0');
+
+        claimPathValue.push('0');
+
+        slotIndex.push(0);
+        operator.push(0);
+
+        const valuesArr = prepareCircuitArrayValues([], this.getValueArrSize());
+        value.push(bigIntArrayToStringArray(valuesArr));
+        valueArraySize.push(0);
+        continue;
+      }
+      let valueProof = this.query[i].valueProof;
+      if (!valueProof) {
+        valueProof = new ValueProof();
+        valueProof.path = 0n;
+        valueProof.value = 0n;
+        valueProof.mtp = new Proof();
+      }
+      claimPathMtp.push(prepareSiblingsStr(valueProof.mtp, this.getMTLevelsClaim()));
+
+      const nodAuxJSONLD = getNodeAuxValue(valueProof.mtp);
+
+      claimPathMtpNoAux.push(nodAuxJSONLD.noAux);
+      claimPathMtpAuxHi.push(nodAuxJSONLD.key.bigInt().toString());
+      claimPathMtpAuxHv.push(nodAuxJSONLD.value.bigInt().toString());
+
+      claimPathKey.push(valueProof.path.toString());
+
+      claimPathValue.push(valueProof.value.toString());
+
+      slotIndex.push(this.query[i].slotIndex);
+      operator.push(this.query[i].operator);
+
+      valueArraySize.push(this.query[i].values.length);
+      const valuesArr = prepareCircuitArrayValues(this.query[i].values, this.getValueArrSize());
+      value.push(bigIntArrayToStringArray(valuesArr));
+    }
+
+    const s: Partial<LinkedMultiQueryCircuitInputs> = {
+      linkNonce: this.linkNonce.toString(),
+      issuerClaim: this.claim.marshalJson(),
+      claimSchema: this.claim.getSchemaHash().bigInt().toString(),
+      claimPathMtp,
+      claimPathMtpNoAux,
+      claimPathMtpAuxHi,
+      claimPathMtpAuxHv,
+      claimPathKey,
+      claimPathValue,
+      slotIndex,
+      operator,
+      value,
+      valueArraySize
+    };
+
+    return byteEncoder.encode(JSON.stringify(s));
+  }
+}
+
+/**
+ * @beta
+ */
+interface LinkedMultiQueryCircuitInputs {
+  linkNonce: string;
+  issuerClaim: string[];
+  claimSchema: string;
+  claimPathMtp: string[][];
+  claimPathMtpNoAux: string[];
+  claimPathMtpAuxHi: string[];
+  claimPathMtpAuxHv: string[];
+  claimPathKey: string[];
+  claimPathValue: string[];
+  slotIndex: number[];
+  operator: number[];
+  value: string[][];
+  valueArraySize: number[];
+}
+
+// LinkedMultiQueryPubSignals linkedMultiQuery10.circom public signals
+/**
+ * public signals
+ *
+ * @beta
+ * @class LinkedMultiQueryPubSignals
+ */
+export class LinkedMultiQueryPubSignals {
+  linkID!: bigint;
+  merklized!: number;
+  operatorOutput!: bigint[];
+  circuitQueryHash!: bigint[];
+
+  /**
+   * PubSignalsUnmarshal unmarshal linkedMultiQuery10.circom public inputs to LinkedMultiQueryPubSignals
+   *
+   * @beta
+   * @param {Uint8Array} data
+   * @returns LinkedMultiQueryPubSignals
+   */
+  pubSignalsUnmarshal(data: Uint8Array): LinkedMultiQueryPubSignals {
+    const len = 22;
+    const queryLength = LinkedMultiQueryInputs.queryCount;
+    const sVals: string[] = JSON.parse(byteDecoder.decode(data));
+
+    if (sVals.length !== len) {
+      throw new Error(`invalid number of Output values expected ${len} got ${sVals.length}`);
+    }
+
+    let fieldIdx = 0;
+
+    // -- linkID
+    this.linkID = BigInt(sVals[fieldIdx]);
+    fieldIdx++;
+
+    // -- merklized
+    this.merklized = parseInt(sVals[fieldIdx]);
+    fieldIdx++;
+
+    // - operatorOutput
+    this.operatorOutput = [];
+    for (let i = 0; i < queryLength; i++) {
+      this.operatorOutput.push(BigInt(sVals[fieldIdx]));
+      fieldIdx++;
+    }
+
+    // - circuitQueryHash
+    this.circuitQueryHash = [];
+    for (let i = 0; i < queryLength; i++) {
+      this.circuitQueryHash.push(BigInt(sVals[fieldIdx]));
+      fieldIdx++;
+    }
+
+    return this;
+  }
+}