@mocanetwork/privado-js-sdk 1.0.0

package/src/storage/indexed-db/merkletree.ts

@@ -0,0 +1,140 @@
+import { createStore, UseStore, get, set, del } from 'idb-keyval';
+import { IndexedDBStorage, Merkletree, str2Bytes } from '@iden3/js-merkletree';
+import { IdentityMerkleTreeMetaInformation, MerkleTreeType } from '../entities/mt';
+import * as uuid from 'uuid';
+
+import { IMerkleTreeStorage } from '../interfaces/merkletree';
+import { createMerkleTreeMetaInfo } from '../utils';
+
+/**
+ * Merkle tree storage that uses browser indexed db storage
+ *
+ * @public
+ * @class MerkleTreeIndexedDBStorage
+ * @implements implements IMerkleTreeStorage interface
+ */
+export class MerkleTreeIndexedDBStorage implements IMerkleTreeStorage {
+  /**
+   * key for the storage key metadata
+   *
+   * @static
+   */
+  static readonly storageKeyMeta = 'merkle-tree-meta';
+  static readonly storageBindingKeyMeta = 'binding-did';
+
+  private readonly _merkleTreeMetaStore: UseStore;
+  private readonly _bindingStore: UseStore;
+
+  /**
+   * Creates an instance of MerkleTreeIndexedDBStorage.
+   * @param {number} _mtDepth
+   */
+  constructor(private readonly _mtDepth: number) {
+    this._merkleTreeMetaStore = createStore(
+      `${MerkleTreeIndexedDBStorage.storageKeyMeta}-db`,
+      MerkleTreeIndexedDBStorage.storageKeyMeta
+    );
+    this._bindingStore = createStore(
+      `${MerkleTreeIndexedDBStorage.storageBindingKeyMeta}-db`,
+      MerkleTreeIndexedDBStorage.storageBindingKeyMeta
+    );
+  }
+
+  /** creates a tree in the indexed db storage */
+  async createIdentityMerkleTrees(
+    identifier: string
+  ): Promise<IdentityMerkleTreeMetaInformation[]> {
+    if (!identifier) {
+      identifier = `${uuid.v4()}`;
+    }
+    const existingBinging = await get(identifier, this._bindingStore);
+    if (existingBinging) {
+      throw new Error(
+        `Present merkle tree meta information in the store for current identifier ${identifier}`
+      );
+    }
+    const treesMeta = createMerkleTreeMetaInfo(identifier);
+    await set(identifier, treesMeta, this._merkleTreeMetaStore);
+    return treesMeta;
+  }
+  /**
+   *
+   * getIdentityMerkleTreesInfo from the indexed db storage
+   * @param {string} identifier
+   * @returns `{Promise<IdentityMerkleTreeMetaInformation[]>}`
+   */
+  async getIdentityMerkleTreesInfo(
+    identifier: string
+  ): Promise<IdentityMerkleTreeMetaInformation[]> {
+    const meta = await get(identifier, this._merkleTreeMetaStore);
+    if (meta) {
+      return meta;
+    }
+    throw new Error(`Merkle tree meta not found for identifier ${identifier}`);
+  }
+
+  /** get merkle tree from the indexed db storage */
+  async getMerkleTreeByIdentifierAndType(
+    identifier: string,
+    mtType: MerkleTreeType
+  ): Promise<Merkletree> {
+    const meta = await get(identifier, this._merkleTreeMetaStore);
+    const err = new Error(`Merkle tree not found for identifier ${identifier} and type ${mtType}`);
+    if (!meta) {
+      throw err;
+    }
+
+    const resultMeta = meta.find(
+      (m: { identifier: string; type: MerkleTreeType }) =>
+        m.identifier === identifier && m.type === mtType
+    );
+    if (!resultMeta) {
+      throw err;
+    }
+    return new Merkletree(new IndexedDBStorage(str2Bytes(resultMeta.treeId)), true, this._mtDepth);
+  }
+  /** adds to merkle tree in the indexed db storage */
+  async addToMerkleTree(
+    identifier: string,
+    mtType: MerkleTreeType,
+    hindex: bigint,
+    hvalue: bigint
+  ): Promise<void> {
+    const meta = await get(identifier, this._merkleTreeMetaStore);
+    if (!meta) {
+      throw new Error(`Merkle tree meta not found for identifier ${identifier}`);
+    }
+    const resultMeta = meta.find(
+      (m: { identifier: string; type: MerkleTreeType }) =>
+        m.identifier === identifier && m.type === mtType
+    );
+    if (!resultMeta) {
+      throw new Error(`Merkle tree not found for identifier ${identifier} and type ${mtType}`);
+    }
+
+    const tree = new Merkletree(
+      new IndexedDBStorage(str2Bytes(resultMeta.treeId)),
+      true,
+      this._mtDepth
+    );
+
+    await tree.add(hindex, hvalue);
+  }
+
+  /** binds merkle tree in the indexed db storage to the new identifiers */
+  async bindMerkleTreeToNewIdentifier(oldIdentifier: string, newIdentifier: string): Promise<void> {
+    const meta = await get(oldIdentifier, this._merkleTreeMetaStore);
+    if (!meta || !meta?.length) {
+      throw new Error(`Merkle tree meta not found for identifier ${oldIdentifier}`);
+    }
+
+    const treesMeta = meta.map((m: { identifier: string; type: MerkleTreeType }) => ({
+      ...m,
+      identifier: newIdentifier
+    }));
+
+    await del(oldIdentifier, this._merkleTreeMetaStore);
+    await set(newIdentifier, treesMeta, this._merkleTreeMetaStore);
+    await set(oldIdentifier, newIdentifier, this._bindingStore);
+  }
+}

package/src/storage/interfaces/circuits.ts

@@ -0,0 +1,27 @@
+import { CircuitId } from '../../circuits';
+import { CircuitData } from '../entities/circuitData';
+
+/**
+ * Interface to work with circuit files
+ *
+ * @public
+ * @interface   ICircuitStorage
+ */
+export interface ICircuitStorage {
+  /**
+   * load circuit keys by id
+   *
+   * @param {CircuitId} circuitId - circuit id
+   * @returns `{Promise<CircuitData>}`
+   */
+  loadCircuitData(circuitId: CircuitId): Promise<CircuitData>;
+
+  /**
+   * saves circuit files by circuit id
+   *
+   * @param {CircuitId} circuitId - circuit id
+   * @param {CircuitData} circuitData - circuit keys
+   * @returns `Promise<void>`
+   */
+  saveCircuitData(circuitId: CircuitId, circuitData: CircuitData): Promise<void>;
+}

package/src/storage/interfaces/credentials.ts

@@ -0,0 +1,53 @@
+import { ProofQuery, W3CCredential } from '../../verifiable';
+
+/**
+ * Interface for credential storages
+ *
+ * @public
+ * @interface   ICredentialStorage
+ */
+export interface ICredentialStorage {
+  /**
+   *
+   * save credential to the storage
+   *
+   * @param {W3CCredential} credential - credential to save
+   * @returns `{Promise<void>}`
+   */
+  saveCredential(credential: W3CCredential): Promise<void>;
+  /**
+   *
+   * save all credential (upsert) to the storage
+   *
+   * @param {W3CCredential[]} credentials - credentials to save
+   * @returns `Promise<void>`
+   */
+  saveAllCredentials(credentials: W3CCredential[]): Promise<void>;
+  /**
+   * returns all credentials in the storage
+   *
+   * @returns `Promise<W3CCredential[]>`
+   */
+  listCredentials(): Promise<W3CCredential[]>;
+  /**
+   * Removes credential from storage
+   *
+   * @param {string} id  - id of credential
+   * @returns `Promise<void>`
+   */
+  removeCredential(id: string): Promise<void>;
+  /**
+   * finds credential in the storage for given query
+   *
+   * @param {ProofQuery} query - query to apply
+   * @returns `{Promise<W3CCredential[]>}`
+   */
+  findCredentialsByQuery(query: ProofQuery): Promise<W3CCredential[]>;
+  /**
+   * finds credential by identifier
+   *
+   * @param {string} id - id of credential
+   * @returns `{(Promise<W3CCredential | undefined>)}`
+   */
+  findCredentialById(id: string): Promise<W3CCredential | undefined>;
+}

package/src/storage/interfaces/data-source.ts

@@ -0,0 +1,41 @@
+/**
+ * Generic Key/Value Data Source for crud operation
+ *
+ * @public
+ * @interface   IDataSource
+ * @template Type - generic type
+ */
+export interface IDataSource<Type> {
+  /**
+   * load all object with Type from data source
+   *
+   * @returns `{Type[]}`
+   */
+  load(): Promise<Type[]>;
+
+  /**
+   * Save value under the key with optional key name
+   *
+   * @param {string} key - key value
+   * @param {Type} value - value to store
+   * @param {string} [keyName] - key name
+   */
+  save(key: string, value: Type, keyName?: string): Promise<void>;
+
+  /**
+   * returns data value for key value and optional key name
+   *
+   * @param {string} key - key value
+   * @param {string} [keyName] -  key name
+   * @returns ` {(Type | undefined)}`
+   */
+  get(key: string, keyName?: string): Promise<Type | undefined>;
+
+  /**
+   * deletes data value for given key with an optional key name
+   *
+   * @param {string} key - key value
+   * @param {string} [keyName] -  key name
+   */
+  delete(key: string, keyName?: string): Promise<void>;
+}

package/src/storage/interfaces/data-storage.ts

@@ -0,0 +1,17 @@
+import { ICredentialStorage } from './credentials';
+import { IIdentityStorage } from './identity';
+import { IMerkleTreeStorage } from './merkletree';
+import { IStateStorage } from './state';
+
+/**
+ * General Data storage interface that union identity, credential, merkletree and states storage.
+ *
+ * @public
+ * @interface   IDataStorage
+ */
+export interface IDataStorage {
+  credential: ICredentialStorage;
+  identity: IIdentityStorage;
+  mt: IMerkleTreeStorage;
+  states: IStateStorage;
+}

package/src/storage/interfaces/identity.ts

@@ -0,0 +1,73 @@
+import { Identity } from '../entities';
+import { Profile } from '../entities';
+
+/**
+ * storage for identities and profiles
+ *
+ * @public
+ * @interface   IIdentityStorage
+ */
+export interface IIdentityStorage {
+  /**
+   * saves identity to the data source
+   *
+   * @param {Identity} identity
+   * @returns `{Promise<void>}`
+   */
+  saveIdentity(identity: Identity): Promise<void>;
+  /**
+   * gets identity from the the data source
+   *
+   *
+   * @param {string} identifier - id of identity
+   * @returns `{(Promise<Identity | undefined>)}`
+   */
+  getIdentity(identifier: string): Promise<Identity | undefined>;
+  /**
+   *
+   * gets all identity from the data source
+   *
+   * @returns `{Promise<Identity[]>}`
+   */
+  getAllIdentities(): Promise<Identity[]>;
+
+  /**
+   *
+   * saves profile identity to data
+   *
+   * @param {Profile} profile - identity profile
+   * @returns `{Promise<void>}`
+   */
+  saveProfile(profile: Profile): Promise<void>;
+  /**
+   * gets profile by verifier
+   * @deprecated The method should not be used. It returns only one profile per verifier, which can potentially restrict business use cases
+   * @param {string} verifier - verifier to which profile has been shared
+   * @returns `{Promise<Profile>}`
+   */
+  getProfileByVerifier(verifier: string): Promise<Profile | undefined>;
+
+  /**
+   * gets profile by verifiers
+   * @param {string} verifier - verifier to which profile has been shared
+   * @param {string[]} tags - optional tag to filter profile entry
+   * @returns `{Promise<Profile[]>}`
+   */
+  getProfilesByVerifier(verifier: string, tags?: string[]): Promise<Profile[]>;
+
+  /**
+   * gets profile by identifier
+   *
+   * @param {string} identifier - profile id
+   * @returns `{Promise<Profile>}`
+   */
+  getProfileById(identifier: string): Promise<Profile | undefined>;
+  /**
+   *
+   * gets profile identity by genesis identifiers
+   *
+   * @param {string} genesisIdentifier - genesis identifier from which profile has been derived
+   * @returns `{Promise<Profile[]>}`
+   */
+  getProfilesByGenesisIdentifier(genesisIdentifier: string): Promise<Profile[]>;
+}

package/src/storage/interfaces/index.ts

@@ -0,0 +1,10 @@
+export * from './credentials';
+export * from './identity';
+export * from './merkletree';
+export * from './state';
+export * from './data-storage';
+export * from './data-source';
+export * from './circuits';
+export * from './onchain-zkp-verifier';
+export * from './onchain-revocation';
+export * from './onchain-issuer';

package/src/storage/interfaces/merkletree.ts

@@ -0,0 +1,52 @@
+import { Merkletree } from '@iden3/js-merkletree';
+import { IdentityMerkleTreeMetaInformation, MerkleTreeType } from '../entities/mt';
+
+/**
+ * Interface to work with a merkle tree storage
+ *
+ * @public
+ * @interface   IMerkleTreeStorage
+ */
+export interface IMerkleTreeStorage {
+  /**
+   * creates merkle tree in the storage
+   *
+   * @param {string} identifier
+   * @returns `Promise<IdentityMerkleTreeMetaInformation[]>`
+   */
+  createIdentityMerkleTrees(identifier: string): Promise<IdentityMerkleTreeMetaInformation[]>;
+
+  /**
+   * adds entry to merkle tree
+   *
+   * @param {string} identifier - identifier to which tree belongs
+   * @param {MerkleTreeType} mtType - merkle tree type
+   * @param {bigint} hindex - hash index
+   * @param {bigint} hvalue - hash value
+   * @returns `Promise<void>`
+   */
+  addToMerkleTree(
+    identifier: string,
+    mtType: MerkleTreeType,
+    hindex: bigint,
+    hvalue: bigint
+  ): Promise<void>;
+
+  /**
+   * gets merkle tree by identifier and type
+   *
+   * @param {string} identifier     - identifier for tree
+   * @param {MerkleTreeType} mtType - merkle tree type
+   * @returns `{Promise<Merkletree>}`
+   */
+  getMerkleTreeByIdentifierAndType(identifier: string, mtType: MerkleTreeType): Promise<Merkletree>;
+
+  /**
+   * binding to be able to update identifier that belongs to tree
+   *
+   * @param {string} oldIdentifier -
+   * @param {string} newIdentifier -
+   * @returns `{Promise<void>}`
+   */
+  bindMerkleTreeToNewIdentifier(oldIdentifier: string, newIdentifier: string): Promise<void>;
+}

package/src/storage/interfaces/onchain-issuer.ts

@@ -0,0 +1,13 @@
+import { DID } from '@mocanetwork/moca-iden3';
+import { W3CCredential } from '../../verifiable';
+
+/**
+ * Interface that allows the processing of the on-chain issuer
+ *
+ * @beta
+ * @interface IOnchainIssuer
+ */
+export interface IOnchainIssuer {
+  getCredential(issuerDID: DID, userDID: DID, credentialId: bigint): Promise<W3CCredential>;
+  getUserCredentialIds(issuerDID: DID, userDID: DID): Promise<bigint[]>;
+}

package/src/storage/interfaces/onchain-revocation.ts

@@ -0,0 +1,22 @@
+import { RevocationStatus } from '../../verifiable';
+/**
+ * Interface that defines methods for onchain revocation store
+ *
+ * @public
+ * @interface   IOnchainRevocationStore
+ */
+export interface IOnchainRevocationStore {
+  /**
+   * gets latest state of identity
+   *
+   * @param {bigint} issuerID - issuer id
+   * @param {bigint} state - issuer state
+   * @param {number} nonce - revocation nonce
+   * @returns `Promise<StateInfo>`
+   */
+  getRevocationStatusByIdAndState(
+    issuerID: bigint,
+    state: bigint,
+    nonce: number
+  ): Promise<RevocationStatus>;
+}

package/src/storage/interfaces/onchain-zkp-verifier.ts

@@ -0,0 +1,94 @@
+import { Signer } from 'ethers';
+import {
+  AuthProof,
+  ContractInvokeTransactionData,
+  JsonDocumentObjectValue,
+  ZeroKnowledgeInvokeResponse,
+  ZeroKnowledgeProofResponse
+} from '../../iden3comm';
+import { TxPreparationResultSubmitResponse } from '../blockchain/onchain-zkp-verifier';
+
+/**
+ * Interface that defines methods for ZKP verifier
+ *
+ * @beta
+ * @interface IOnChainZKPVerifier
+ */
+export interface IOnChainZKPVerifier {
+  /**
+   * Submit ZKP Responses to OnChainZKPVerifier contract.
+   * @beta
+   * @param {Signer} ethSigner - tx signer
+   * @param {txData} ContractInvokeTransactionData - transaction data
+   * @param {ZeroKnowledgeProofResponse[]} zkProofResponses - zkProofResponses
+   * @returns {Promise<Map<string, ZeroKnowledgeProofResponse>>} - map of transaction hash - ZeroKnowledgeProofResponse
+   */
+  submitZKPResponse(
+    ethSigner: Signer,
+    txData: ContractInvokeTransactionData,
+    zkProofResponses: ZeroKnowledgeProofResponse[]
+  ): Promise<Map<string, ZeroKnowledgeProofResponse>>;
+
+  /**
+   * Submit ZKP Response V2 to OnChainZKPVerifier contract.
+   * @beta
+   * @param {Signer} ethSigner - tx signer
+   * @param {txData} ContractInvokeTransactionData - transaction data
+   * @param {ZeroKnowledgeProofResponse[]} zkProofResponses - zkProofResponses
+   * @returns {Promise<Map<string, ZeroKnowledgeProofResponse[]>>} - map of transaction hash - ZeroKnowledgeProofResponse[]
+   */
+  submitZKPResponseV2(
+    ethSigner: Signer,
+    txData: ContractInvokeTransactionData,
+    zkProofResponses: ZeroKnowledgeProofResponse[]
+  ): Promise<Map<string, ZeroKnowledgeProofResponse[]>>;
+
+  /**
+   * Submit Response to OnChainZKPVerifier contract.
+   * @beta
+   * @param {Signer} ethSigner - tx signer
+   * @param {txData} ContractInvokeTransactionData - transaction data
+   * @param {AuthProofResponse} authResponse - authResponse
+   * @param {ZeroKnowledgeProofMultiQueryResponse[]} responses - singleResponses and groupedResponses
+   * @param {ZeroKnowledgeProofAuthResponse} [authProof] - authProof in case of authV2
+   * @returns {Promise<Map<string, ZeroKnowledgeInvokeResponse>>} - map of transaction hash - ZeroKnowledgeInvokeResponse
+   */
+  submitResponse(
+    ethSigner: Signer,
+    txData: ContractInvokeTransactionData,
+    responses: ZeroKnowledgeProofResponse[],
+    authProof: AuthProof
+  ): Promise<Map<string, ZeroKnowledgeInvokeResponse>>;
+
+  /**
+   * Returns tx args for the ZKP verifier contract submission (singe tx args for each response).
+   * @param txData
+   * @param zkProofResponse
+   */
+  prepareTxArgsSubmitV1(
+    txData: ContractInvokeTransactionData,
+    zkProofResponse: ZeroKnowledgeProofResponse
+  ): Promise<JsonDocumentObjectValue[]>;
+
+  /**
+   * Returns args for the ZKP verifier contract submission V2 (single tx args for an array of responses).
+   * @param txData
+   * @param zkProofResponses
+   */
+  prepareTxArgsSubmitV2(
+    txData: ContractInvokeTransactionData,
+    zkProofResponses: ZeroKnowledgeProofResponse[]
+  ): Promise<JsonDocumentObjectValue[]>;
+
+  /**
+   * Returns args for the verifier multi-query contract submission (single tx args for an array of responses).
+   * @param {txData} ContractInvokeTransactionData - transaction data
+   * @param {authProof} AuthProof - AuthProof
+   * @param {ZeroKnowledgeProofMultiQueryResponse[]} responses - singleResponses and groupedResponses
+   */
+  prepareTxArgsSubmit(
+    txData: ContractInvokeTransactionData,
+    responses: ZeroKnowledgeProofResponse[],
+    authProof: AuthProof
+  ): Promise<{ result: TxPreparationResultSubmitResponse; txDataArgs: JsonDocumentObjectValue[] }>;
+}

package/src/storage/interfaces/state.ts

@@ -0,0 +1,81 @@
+import { ZKProof } from '@iden3/js-jwz';
+import { JsonRpcProvider, Signer } from 'ethers';
+import { RootInfo, StateInfo, StateProof } from '../entities/state';
+import { Id } from '@mocanetwork/moca-iden3';
+import { Hash } from '@iden3/js-merkletree';
+
+export interface UserStateTransitionInfo {
+  userId: Id; // Identity id
+  oldUserState: Hash; // Previous identity state
+  newUserState: Hash; // New identity state
+  isOldStateGenesis: boolean; // Is the previous state genesis?
+  methodId: bigint; // State transition method id
+  methodParams: string; // State transition method-specific params
+}
+
+/**
+ * Interface that defines methods for state storage
+ *
+ * @public
+ * @interface   IStateStorage
+ */
+export interface IStateStorage {
+  /**
+   * gets latest state of identity
+   *
+   * @param {bigint} id - id to check
+   * @returns `Promise<StateInfo>`
+   */
+  getLatestStateById(id: bigint): Promise<StateInfo>;
+
+  /**
+   * gets state info of identity by id and state
+   *
+   * @param {bigint} id - id to check
+   * @param {bigint} state - state to check
+   * @returns `Promise<StateInfo>`
+   */
+  getStateInfoByIdAndState(id: bigint, state: bigint): Promise<StateInfo>;
+  /**
+   * method to publish state onchain
+   *
+   * @param {ZKProof} proof - proof to publish
+   * @param {Signer} signer  - signer of transaction
+   * @returns `Promise<string>` - transaction identifier
+   */
+  publishState(proof: ZKProof | undefined, signer: Signer): Promise<string>;
+  /**
+   * method to publish state onchain
+   *
+   * @param {Signer} signer  - signer of transaction
+   * @param {UserStateTransitionInfo} userStateTransitionInfo  - user state transition information
+   * @returns `Promise<string>` - transaction identifier
+   */
+  publishStateGeneric(
+    signer: Signer,
+    userStateTransitionInfo?: UserStateTransitionInfo
+  ): Promise<string>;
+  /**
+   * generates proof of inclusion / non-inclusion to global identity state for given identity
+   *
+   * @param {bigint} id - id to check
+   * @returns `Promise<StateProof>`
+   */
+  getGISTProof(id: bigint): Promise<StateProof>;
+
+  /**
+   * gets root info of global identity state tree
+   *
+   * @param {bigint} root - root to check
+   * @param {bigint} userId - user id
+   * @returns `Promise<RootInfo>`
+   */
+  getGISTRootInfo(root: bigint, userId: bigint): Promise<RootInfo>;
+
+  /**
+   * gets RPC provider
+   *
+   * @returns `Promise<JsonRpcProvider>`
+   */
+  getRpcProvider(): JsonRpcProvider;
+}