@mocanetwork/privado-js-sdk 1.0.0

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

@@ -0,0 +1,87 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { StorageErrors } from '../errors';
+import { IDataSource } from '../interfaces/data-source';
+
+/**
+ * Storage in the browser, uses local storage
+ *
+ * @public
+ * @class BrowserDataSource
+ * @template Type
+ */
+export class BrowserDataSource<Type> implements IDataSource<Type> {
+  /**
+   * Creates an instance of BrowserDataSource.
+   * @param {string} _localStorageKey - key string to put storage name in the local storage
+   */
+  constructor(private _localStorageKey: string) {
+    const data = localStorage.getItem(this._localStorageKey);
+    if (!data) {
+      localStorage.setItem(_localStorageKey, JSON.stringify([]));
+    }
+  }
+
+  /**
+   *
+   * saves value to the local storage
+   * @param {string} key - key value
+   * @param {Type} value - value to store
+   * @param {string} [keyName='id'] -  key name
+   */
+  async save(key: string, value: Type, keyName = 'id'): Promise<void> {
+    if (localStorage) {
+      const data = localStorage.getItem(this._localStorageKey);
+      let items: Type[] = [];
+      if (data) {
+        items = JSON.parse(data) as Type[];
+      }
+      const itemIndex = items.findIndex((i: any): boolean => i[keyName] === key);
+      if (itemIndex === -1) {
+        items.push(value);
+      } else {
+        items[itemIndex] = value;
+      }
+      localStorage.setItem(this._localStorageKey, JSON.stringify(items));
+    }
+  }
+
+  /**
+   * gets value from the local storage by given key
+   * @param {string} key - key value
+   * @param {string}  [keyName='id'] -  key name
+   */
+
+  async get(key: string, keyName = 'id'): Promise<Type | undefined> {
+    const data = localStorage.getItem(this._localStorageKey);
+    let parsedData: Type[] = [];
+    if (data) {
+      parsedData = JSON.parse(data) as Type[];
+    }
+    return parsedData.find((t: any) => t[keyName] === key);
+  }
+
+  /**
+   * loads all from the local storage
+   */
+  async load(): Promise<Type[]> {
+    const data = localStorage.getItem(this._localStorageKey);
+    return data && JSON.parse(data);
+  }
+  /**
+   * deletes item from the local storage
+   * @param {string} key - key value
+   * @param {string}  [keyName='id'] -  key name
+   */
+  async delete(key: string, keyName = 'id'): Promise<void> {
+    const dataStr = localStorage.getItem(this._localStorageKey);
+    let data: Type[] = [];
+    if (dataStr) {
+      data = JSON.parse(dataStr) as Type[];
+    }
+    const items = data.filter((i: any) => i[keyName] !== key);
+    if (data.length === items.length) {
+      throw new Error(`${StorageErrors.ItemNotFound} to delete: ${key}`);
+    }
+    localStorage.setItem(this._localStorageKey, JSON.stringify(items));
+  }
+}

package/src/storage/local-storage/index.ts

@@ -0,0 +1,2 @@
+export * from './data-source';
+export * from './merkletree';

package/src/storage/local-storage/merkletree.ts

@@ -0,0 +1,137 @@
+import { LocalStorageDB, 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 local storage
+ *
+ * @public
+ * @class MerkleTreeLocalStorage
+ * @implements implements IMerkleTreeStorage interface
+ */
+export class MerkleTreeLocalStorage implements IMerkleTreeStorage {
+  /**
+   * key for the storage key metadata
+   *
+   * @static
+   */
+  static readonly storageKeyMeta = 'merkle-tree-meta';
+
+  /**
+   * Creates an instance of MerkleTreeLocalStorage.
+   * @param {number} _mtDepth
+   */
+  constructor(private readonly _mtDepth: number) {}
+
+  /** creates a tree in the local storage */
+  async createIdentityMerkleTrees(
+    identifier: string
+  ): Promise<IdentityMerkleTreeMetaInformation[]> {
+    if (!identifier) {
+      identifier = `${uuid.v4()}`;
+    }
+    const meta = localStorage.getItem(MerkleTreeLocalStorage.storageKeyMeta);
+    if (meta) {
+      const metaInfo: IdentityMerkleTreeMetaInformation[] = JSON.parse(meta);
+      const presentMetaForIdentifier = metaInfo.find((m) => m.treeId === `${identifier}+${m.type}`);
+      if (presentMetaForIdentifier) {
+        throw new Error(
+          `Present merkle tree meta information in the store for current identifier ${identifier}`
+        );
+      }
+      const identityMetaInfo = metaInfo.filter((m) => m.identifier === identifier);
+      if (identityMetaInfo.length > 0) {
+        return identityMetaInfo;
+      }
+      const treesMeta = createMerkleTreeMetaInfo(identifier);
+      localStorage.setItem(
+        MerkleTreeLocalStorage.storageKeyMeta,
+        JSON.stringify([...metaInfo, ...treesMeta])
+      );
+
+      return [...metaInfo, ...treesMeta];
+    }
+    const treesMeta = createMerkleTreeMetaInfo(identifier);
+    localStorage.setItem(MerkleTreeLocalStorage.storageKeyMeta, JSON.stringify(treesMeta));
+    return treesMeta;
+  }
+  /**
+   *
+   * getIdentityMerkleTreesInfo from the local storage
+   * @param {string} identifier
+   * @returns `{Promise<IdentityMerkleTreeMetaInformation[]>}`
+   */
+  async getIdentityMerkleTreesInfo(
+    identifier: string
+  ): Promise<IdentityMerkleTreeMetaInformation[]> {
+    const meta = localStorage.getItem(MerkleTreeLocalStorage.storageKeyMeta);
+    if (meta) {
+      const metaInfo: IdentityMerkleTreeMetaInformation[] = JSON.parse(meta);
+      return metaInfo.filter((m) => m.identifier === identifier);
+    }
+    throw new Error(`Merkle tree meta not found for identifier ${identifier}`);
+  }
+
+  /** get merkle tree from the local storage */
+  async getMerkleTreeByIdentifierAndType(
+    identifier: string,
+    mtType: MerkleTreeType
+  ): Promise<Merkletree> {
+    const resultMeta = this.getMeta(identifier, mtType);
+    return new Merkletree(new LocalStorageDB(str2Bytes(resultMeta.treeId)), true, this._mtDepth);
+  }
+
+  private getMeta(identifier: string, mtType: MerkleTreeType) {
+    const meta = localStorage.getItem(MerkleTreeLocalStorage.storageKeyMeta);
+    const err = new Error(`Merkle tree not found for identifier ${identifier} and type ${mtType}`);
+    if (!meta) {
+      throw err;
+    }
+
+    const metaInfo: IdentityMerkleTreeMetaInformation[] = JSON.parse(meta);
+    const resultMeta = metaInfo.filter((m) => m.identifier === identifier && m.type === mtType)[0];
+    if (!resultMeta) {
+      throw err;
+    }
+    return resultMeta;
+  }
+
+  /** adds to merkle tree in the local storage */
+  async addToMerkleTree(
+    identifier: string,
+    mtType: MerkleTreeType,
+    hindex: bigint,
+    hvalue: bigint
+  ): Promise<void> {
+    const resultMeta = this.getMeta(identifier, mtType);
+
+    const tree = new Merkletree(
+      new LocalStorageDB(str2Bytes(resultMeta.treeId)),
+      true,
+      this._mtDepth
+    );
+
+    await tree.add(hindex, hvalue);
+  }
+
+  /** binds merkle tree in the local storage to the new identifiers */
+  async bindMerkleTreeToNewIdentifier(oldIdentifier: string, newIdentifier: string): Promise<void> {
+    const meta = localStorage.getItem(MerkleTreeLocalStorage.storageKeyMeta);
+    if (!meta) {
+      throw new Error(`Merkle tree meta not found for identifier ${oldIdentifier}`);
+    }
+    const metaInfo: IdentityMerkleTreeMetaInformation[] = JSON.parse(meta);
+    const treesMeta = metaInfo
+      .filter((m) => m.identifier === oldIdentifier)
+      .map((m) => ({ ...m, identifier: newIdentifier }));
+    if (treesMeta.length === 0) {
+      throw new Error(`Merkle tree meta not found for identifier ${oldIdentifier}`);
+    }
+
+    const newMetaInfo = [...metaInfo.filter((m) => m.identifier !== oldIdentifier), ...treesMeta];
+    localStorage.setItem(MerkleTreeLocalStorage.storageKeyMeta, JSON.stringify(newMetaInfo));
+  }
+}

package/src/storage/memory/cache-lru.ts

@@ -0,0 +1,30 @@
+import QuickLRU from 'quick-lru';
+
+export interface ICache<T> {
+  get(key: string): Promise<T | undefined>;
+  set(key: string, value: T, ttl?: number): Promise<void>;
+  delete(key: string): Promise<void>;
+  clear(): Promise<void>;
+}
+
+export function createInMemoryCache<T>(params: { ttl?: number; maxSize: number }): ICache<T> {
+  const cache = new QuickLRU<string, T>({ maxSize: params.maxSize, maxAge: params.ttl });
+
+  return {
+    get: async (key: string): Promise<T | undefined> => {
+      return cache.get(key);
+    },
+
+    set: async (key: string, value: T, ttl?: number) => {
+      cache.set(key, value, { maxAge: ttl ?? params.ttl });
+    },
+
+    clear: async () => {
+      cache.clear();
+    },
+
+    delete: async (key: string) => {
+      cache.delete(key);
+    }
+  };
+}

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

@@ -0,0 +1,45 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { StorageErrors } from '../errors';
+import { IDataSource } from '../interfaces/data-source';
+
+/**
+ * Generic Memory Data Source
+ *
+ * @public
+ * @class InMemoryDataSource - class
+ * @template Type
+ */
+export class InMemoryDataSource<Type> implements IDataSource<Type> {
+  private _data: Type[] = [];
+
+  /** saves in the memory */
+  async save(key: string, value: Type, keyName = 'id'): Promise<void> {
+    const itemIndex = this._data.findIndex((i: any) => i[keyName] === key);
+    if (itemIndex === -1) {
+      this._data.push(value);
+    } else {
+      this._data[itemIndex] = value;
+    }
+  }
+
+  /** gets value from from the memory */
+  async get(key: string, keyName = 'id'): Promise<Type | undefined> {
+    return this._data.find((t: any) => t[keyName] === key);
+  }
+
+  /** loads from value from the memory */
+  async load(): Promise<Type[]> {
+    return this._data;
+  }
+
+  /** deletes from value from the memory */
+  async delete(key: string, keyName = 'id'): Promise<void> {
+    const newData = this._data.filter((i: any) => i[keyName] !== key);
+
+    if (newData.length === this._data.length) {
+      throw new Error(`${StorageErrors.ItemNotFound} to delete: ${key}`);
+    }
+
+    this._data = newData;
+  }
+}

package/src/storage/memory/index.ts

@@ -0,0 +1,3 @@
+export * from './merkletree';
+export * from './data-source';
+export * from './cache-lru';

package/src/storage/memory/merkletree.ts

@@ -0,0 +1,116 @@
+import { InMemoryDB, Merkletree, str2Bytes } from '@iden3/js-merkletree';
+import { IdentityMerkleTreeMetaInformation, MerkleTreeType } from '../entities/mt';
+import * as uuid from 'uuid';
+
+import { IMerkleTreeStorage } from '../interfaces/merkletree';
+import { MERKLE_TREE_TYPES } from '../utils';
+
+export interface TreeWithMetaInfo {
+  tree: Merkletree;
+  metaInfo: IdentityMerkleTreeMetaInformation;
+}
+
+/**
+ *
+ *
+ * @public
+ * @class InMemoryMerkleTreeStorage
+ * @implements implements IMerkleTreeStorage interface
+ */
+export class InMemoryMerkleTreeStorage implements IMerkleTreeStorage {
+  /**
+   * key value storage for trees where key is identifier
+   *
+   * @type {{
+   *     [v in string]: TreeWithMetaInfo[];
+   *   }}
+   */
+  _data: {
+    [v in string]: TreeWithMetaInfo[];
+  };
+  /**
+   * tree depth
+   *
+   * @type {number}
+   */
+  mtDepth: number;
+  /**
+   * Creates an instance of InMemoryMerkleTreeStorage.
+   * @param {number} _mtDepth
+   */
+  constructor(_mtDepth: number) {
+    this.mtDepth = _mtDepth;
+    this._data = {};
+  }
+
+  /** create trees in the  memory*/
+  async createIdentityMerkleTrees(
+    identifier: string
+  ): Promise<IdentityMerkleTreeMetaInformation[]> {
+    if (!identifier) {
+      identifier = `${uuid.v4()}`;
+    }
+    if (this._data[identifier]) {
+      throw new Error(
+        `Present merkle tree meta information in the store for current identifier ${identifier}`
+      );
+    }
+    this._data[identifier] = [];
+
+    const treesMeta: IdentityMerkleTreeMetaInformation[] = [];
+    MERKLE_TREE_TYPES.forEach((t) => {
+      const treeId = identifier.concat('+' + t.toString());
+      const tree = new Merkletree(new InMemoryDB(str2Bytes(treeId)), true, this.mtDepth);
+
+      const metaInfo = { treeId, identifier: identifier, type: t };
+      this._data[identifier].push({ tree, metaInfo });
+
+      treesMeta.push(metaInfo);
+    });
+    return treesMeta;
+  }
+
+  /** get trees meta info from the memory */
+  async getIdentityMerkleTreesInfo(
+    identifier: string
+  ): Promise<IdentityMerkleTreeMetaInformation[]> {
+    return this._data[identifier].map((treeWithInfo) => treeWithInfo.metaInfo);
+  }
+  /** get merkle tree by identifier and type from memory */
+  async getMerkleTreeByIdentifierAndType(
+    identifier: string,
+    mtType: MerkleTreeType
+  ): Promise<Merkletree> {
+    const treeWithMeta = this._data[identifier].find(
+      (treeWithInfo) => treeWithInfo.metaInfo.type == mtType
+    );
+    if (!treeWithMeta) {
+      throw new Error(`Merkle tree not found for identifier ${identifier} and type ${mtType}`);
+    }
+
+    return treeWithMeta.tree;
+  }
+  /** adds entry to merkle tree in the memory */
+  async addToMerkleTree(
+    identifier: string,
+    mtType: MerkleTreeType,
+    hindex: bigint,
+    hvalue: bigint
+  ): Promise<void> {
+    for (let index = 0; index < this._data[identifier].length; index++) {
+      if (this._data[identifier][index].metaInfo.type === mtType) {
+        await this._data[identifier][index].tree.add(hindex, hvalue);
+      }
+    }
+  }
+
+  /** bind merkle tree identifier in memory */
+  async bindMerkleTreeToNewIdentifier(oldIdentifier: string, newIdentifier: string): Promise<void> {
+    this._data[newIdentifier] = [...this._data[oldIdentifier]];
+    delete this._data[oldIdentifier];
+
+    this._data[newIdentifier].forEach((treeWithMeta) => {
+      treeWithMeta.metaInfo.identifier = newIdentifier;
+    });
+  }
+}

package/src/storage/shared/circuit-storage.ts

@@ -0,0 +1,49 @@
+import { CircuitId } from '../../circuits';
+import { CircuitData } from '../entities/circuitData';
+import { StorageErrors } from '../errors';
+import { ICircuitStorage } from '../interfaces/circuits';
+import { IDataSource } from '../interfaces/data-source';
+
+/**
+ * Implementation of ICircuitStorage to store keys data
+ *
+ * @public
+ * @class CircuitStorage
+ * @implements implements ICircuitStorage interface
+ */
+export class CircuitStorage implements ICircuitStorage {
+  /**
+   * storage key for circuits
+   */
+  static readonly storageKey = 'circuits';
+  /**
+   * Creates an instance of CircuitStorage.
+   * @param {IDataSource<CircuitData>} _dataSource - data source to store circuit keys
+   */
+  constructor(private readonly _dataSource: IDataSource<CircuitData>) {}
+
+  /**
+   * loads circuit data by id
+   * {@inheritdoc  ICircuitStorage.loadCircuitData}
+   * @param {CircuitId} circuitId - id of the circuit
+   * @returns `Promise<CircuitData>`
+   */
+  async loadCircuitData(circuitId: CircuitId): Promise<CircuitData> {
+    const circuitData = await this._dataSource.get(circuitId.toString(), 'circuitId');
+    if (!circuitData) {
+      throw new Error(`${StorageErrors.ItemNotFound}: ${circuitId}`);
+    }
+    return circuitData;
+  }
+
+  /**
+   * {@inheritdoc  ICircuitStorage.loadCircuitData}
+   * saves circuit data for circuit id
+   * @param {CircuitId} circuitId - id of the circuit
+   * @param {CircuitData} circuitData - circuit keys
+   * @returns `Promise<void>`
+   */
+  async saveCircuitData(circuitId: CircuitId, circuitData: CircuitData): Promise<void> {
+    await this._dataSource.save(circuitId.toString(), circuitData, 'circuitId');
+  }
+}

package/src/storage/shared/credential-storage.ts

@@ -0,0 +1,70 @@
+import { ProofQuery, W3CCredential } from '../../verifiable';
+import { StandardJSONCredentialsQueryFilter } from '../filters';
+import { ICredentialStorage } from '../interfaces/credentials';
+import { IDataSource } from '../interfaces/data-source';
+
+/**
+ * Implementation of ICredentialStorage with KV Data source
+ *
+ * @public
+ * @class CredentialStorage
+ * @implements {ICredentialStorage}
+ */
+export class CredentialStorage implements ICredentialStorage {
+  /**
+   * key for storage
+   *
+   * @static
+   */
+  static readonly storageKey = 'credentials';
+  /**
+   * Creates an instance of CredentialStorage.
+   * @param {IDataSource<W3CCredential>} _dataSource - W3CCredential credential KV data source
+   */
+  constructor(private readonly _dataSource: IDataSource<W3CCredential>) {}
+
+  /** {@inheritdoc ICredentialStorage.listCredentials } */
+  async listCredentials(): Promise<W3CCredential[]> {
+    const creds = await this._dataSource.load();
+    return creds.filter((i) => i !== undefined).map((cred) => cred && W3CCredential.fromJSON(cred));
+  }
+
+  /** @inheritdoc */
+  async saveCredential(credential: W3CCredential): Promise<void> {
+    return this._dataSource.save(credential.id, credential.toJSON());
+  }
+
+  /** {@inheritdoc ICredentialStorage.listCredentials } */
+  async saveAllCredentials(credentials: W3CCredential[]): Promise<void> {
+    for (const credential of credentials) {
+      await this.saveCredential(credential);
+    }
+  }
+
+  /** {@inheritdoc ICredentialStorage.listCredentials } */
+  async removeCredential(id: string): Promise<void> {
+    return this._dataSource.delete(id);
+  }
+
+  /** {@inheritdoc ICredentialStorage.listCredentials } */
+  async findCredentialById(id: string): Promise<W3CCredential | undefined> {
+    const cred = await this._dataSource.get(id);
+    return cred && W3CCredential.fromJSON(cred);
+  }
+
+  /** {@inheritdoc ICredentialStorage.listCredentials }
+   * uses JSON query
+   */
+  async findCredentialsByQuery(query: ProofQuery): Promise<W3CCredential[]> {
+    const filters = StandardJSONCredentialsQueryFilter(query);
+    const creds = (await this._dataSource.load()).filter((credential) =>
+      filters.every((filter) => filter.execute(credential))
+    );
+
+    const mappedCreds = creds
+      .filter((i) => i !== undefined)
+      .map((cred) => W3CCredential.fromJSON(cred));
+
+    return mappedCreds;
+  }
+}

package/src/storage/shared/identity-storage.ts

@@ -0,0 +1,82 @@
+import { Identity, Profile } from '../entities';
+import { IDataSource } from '../interfaces/data-source';
+import { IIdentityStorage } from '../interfaces/identity';
+
+/**
+ * Implementation of the IIdentityStorage with KV data source
+ *
+ * @public
+ * @class IdentityStorage
+ * @implements implements IIdentityStorage interface
+ */
+export class IdentityStorage implements IIdentityStorage {
+  /**
+   * storage key for identities
+   *
+   * @static
+   */
+  static readonly identitiesStorageKey = 'identities';
+  /**
+   * storage key for profiles
+   *
+   * @static
+   */
+  static readonly profilesStorageKey = 'profiles';
+
+  /**
+   * Creates an instance of IdentityStorage.
+   * @param {IDataSource<Identity>} _identityDataSource - data source for identities
+   * @param {IDataSource<Profile>} _profileDataSource - data source for profiles
+   */
+  constructor(
+    private readonly _identityDataSource: IDataSource<Identity>,
+    private readonly _profileDataSource: IDataSource<Profile>
+  ) {}
+
+  async saveProfile(profile: Profile): Promise<void> {
+    const profiles = await this._profileDataSource.load();
+    const identityProfiles = profiles.filter(
+      (p) => p.genesisIdentifier === profile.genesisIdentifier
+    );
+    const toSave = identityProfiles.length ? [...identityProfiles, profile] : [profile];
+    for (let index = 0; index < toSave.length; index++) {
+      const element = toSave[index];
+      await this._profileDataSource.save(element.id, element);
+    }
+  }
+  /**
+   *  @deprecated The method should not be used. It returns only one profile per verifier, which can potentially restrict business use cases
+   *   Use getProfilesByVerifier instead.
+   */
+  async getProfileByVerifier(verifier: string): Promise<Profile | undefined> {
+    return this._profileDataSource.get(verifier, 'verifier');
+  }
+
+  async getProfilesByVerifier(verifier: string, tags?: string[]): Promise<Profile[]> {
+    return (await this._profileDataSource.load()).filter(
+      (p) => p.verifier === verifier && (!tags || tags.every((tag) => p.tags?.includes(tag)))
+    );
+  }
+
+  async getProfileById(profileId: string): Promise<Profile | undefined> {
+    return this._profileDataSource.get(profileId);
+  }
+
+  async getProfilesByGenesisIdentifier(genesisIdentifier: string): Promise<Profile[]> {
+    return (await this._profileDataSource.load()).filter(
+      (p) => p.genesisIdentifier === genesisIdentifier
+    );
+  }
+
+  async getAllIdentities(): Promise<Identity[]> {
+    return this._identityDataSource.load();
+  }
+
+  async saveIdentity(identity: Identity): Promise<void> {
+    return this._identityDataSource.save(identity.did, identity, 'did');
+  }
+
+  async getIdentity(identifier: string): Promise<Identity | undefined> {
+    return this._identityDataSource.get(identifier, 'did');
+  }
+}

package/src/storage/shared/index.ts

@@ -0,0 +1,3 @@
+export * from './circuit-storage';
+export * from './credential-storage';
+export * from './identity-storage';

package/src/storage/utils.ts

@@ -0,0 +1,19 @@
+import { IdentityMerkleTreeMetaInformation, MerkleTreeType } from './entities';
+
+export const MERKLE_TREE_TYPES: MerkleTreeType[] = [
+  MerkleTreeType.Claims,
+  MerkleTreeType.Revocations,
+  MerkleTreeType.Roots
+];
+
+export const createMerkleTreeMetaInfo = (
+  identifier: string
+): IdentityMerkleTreeMetaInformation[] => {
+  const treesMeta: IdentityMerkleTreeMetaInformation[] = [];
+  for (let index = 0; index < MERKLE_TREE_TYPES.length; index++) {
+    const mType = MERKLE_TREE_TYPES[index];
+    const treeId = `${identifier}+${mType}`;
+    treesMeta.push({ treeId, identifier, type: mType });
+  }
+  return treesMeta;
+};

package/src/utils/compare-func.ts

@@ -0,0 +1,5 @@
+export const bigIntCompare = (a: bigint, b: bigint): number => {
+  if (a < b) return -1;
+  if (a > b) return 1;
+  return 0;
+};