@0xpolygonid/js-sdk 1.31.1 → 1.31.3

package/dist/node/esm/storage/memory/cache-lru.js

@@ -0,0 +1,18 @@
+import QuickLRU from 'quick-lru';
+export function createInMemoryCache(params) {
+    const cache = new QuickLRU({ maxSize: params.maxSize, maxAge: params.ttl });
+    return {
+        get: async (key) => {
+            return cache.get(key);
+        },
+        set: async (key, value, ttl) => {
+            cache.set(key, value, { maxAge: ttl ?? params.ttl });
+        },
+        clear: async () => {
+            cache.clear();
+        },
+        delete: async (key) => {
+            cache.delete(key);
+        }
+    };
+}

package/dist/node/esm/storage/memory/index.js

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

package/dist/node/esm/storage/shared/identity-storage.js

@@ -24,9 +24,16 @@ export class IdentityStorage {
             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) {
         return this._profileDataSource.get(verifier, 'verifier');
     }
+    async getProfilesByVerifier(verifier, tags) {
+        return (await this._profileDataSource.load()).filter((p) => p.verifier === verifier && (!tags || tags.every((tag) => p.tags?.includes(tag))));
+    }
     async getProfileById(profileId) {
         return this._profileDataSource.get(profileId);
     }

package/dist/node/esm/verifiable/constants.js

@@ -16,6 +16,7 @@ export const VerifiableConstants = Object.freeze({
         ID_WALLET_CORE_CLAIM_IS_NOT_SET: 'core claim is not set in credential proofs',
         ID_WALLET_PROFILE_OR_IDENTITY_NOT_FOUND: 'profile or identity not found',
         ID_WALLET_PROFILE_ALREADY_EXISTS: 'profile with given nonce or verifier already exists',
+        ID_WALLET_PROFILE_ALREADY_EXISTS_VERIFIER_TAGS: 'profile with given verifier and tags already exists',
         ID_WALLET_ISSUER_AUTH_BJJ_CRED_MUST_HAVE_ANY_PROOF: 'issuer auth credential must have proof',
         ID_WALLET_ISSUER_AUTH_BJJ_CRED_MUST_HAVE_MTP_PROOF: 'mtp is required for auth bjj key to issue new credentials',
         // proof service
@@ -197,3 +198,7 @@ export var DisplayMethodType;
 (function (DisplayMethodType) {
     DisplayMethodType["Iden3BasicDisplayMethodV1"] = "Iden3BasicDisplayMethodV1";
 })(DisplayMethodType || (DisplayMethodType = {}));
+/**
+ * Default cache max size for in-memory cache
+ */
+export const DEFAULT_CACHE_MAX_SIZE = 10000;

package/dist/types/credentials/status/on-chain-revocation.d.ts

@@ -2,6 +2,10 @@ import { RevocationStatus, CredentialStatus } from '../../verifiable';
 import { EthConnectionConfig } from '../../storage/blockchain';
 import { CredentialStatusResolver, CredentialStatusResolveOptions } from './resolver';
 import { DID } from '@iden3/js-iden3-core';
+import { EthStateStorageOptions } from '../../storage/blockchain/state';
+export type OnChainResolverOptions = {
+    stateStorageOptions?: EthStateStorageOptions;
+};
 /**
  * OnChainIssuer is a class that allows to interact with the onchain contract
  * and build the revocation status.
@@ -11,13 +15,14 @@ import { DID } from '@iden3/js-iden3-core';
  */
 export declare class OnChainResolver implements CredentialStatusResolver {
     private readonly _configs;
+    private readonly _stateStorage;
     /**
      *
      * Creates an instance of OnChainIssuer.
      * @public
      * @param {Array<EthConnectionConfig>} _configs - list of ethereum network connections
      */
-    constructor(_configs: EthConnectionConfig[]);
+    constructor(_configs: EthConnectionConfig[], _opts?: OnChainResolverOptions);
     /**
      * resolve is a method to resolve a credential status from the blockchain.
      *
@@ -48,6 +53,5 @@ export declare class OnChainResolver implements CredentialStatusResolver {
         stateHex: string;
     };
     networkByChainId(chainId: number): EthConnectionConfig;
-    private _getStateStorageForIssuer;
     private _getOnChainRevocationStorageForIssuer;
 }

package/dist/types/identity/identity-wallet.d.ts

@@ -117,9 +117,10 @@ export interface IIdentityWallet {
      * @param {DID} did - identity to derive profile from
      * @param {number |string} nonce - unique integer number to generate a profile
      * @param {string} verifier - verifier identity/alias in a string from
+     * @param {string[]} tags      - optional tag that can be assigned to profile by client
      * @returns `Promise<DID>` - profile did
      */
-    createProfile(did: DID, nonce: number | string, verifier: string): Promise<DID>;
+    createProfile(did: DID, nonce: number | string, verifier: string, tags?: string[]): Promise<DID>;
     /**
      * Generates a new key
      *
@@ -291,11 +292,19 @@ export interface IIdentityWallet {
     /**
      *
      * gets profile identity 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 -  identifier of the verifier
      * @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, tags to filter profile entry
+     * @returns `{Promise<Profile[]>}`
+     */
+    getProfilesByVerifier(verifier: string, tags?: string[]): Promise<Profile[]>;
     /**
      *
      * updates latest identity state in storage with given state or latest from the trees.
@@ -398,7 +407,7 @@ export declare class IdentityWallet implements IIdentityWallet {
         genesisDID: DID;
     }>;
     /** {@inheritDoc IIdentityWallet.createProfile} */
-    createProfile(did: DID, nonce: number | string, verifier: string): Promise<DID>;
+    createProfile(did: DID, nonce: number | string, verifier: string, tags?: string[]): Promise<DID>;
     /**
      *
      * gets profile identity by genesis identifiers
@@ -409,7 +418,13 @@ export declare class IdentityWallet implements IIdentityWallet {
     getProfilesByDID(did: DID): Promise<Profile[]>;
     /** {@inheritDoc IIdentityWallet.generateKey} */
     generateKey(keyType: KmsKeyType): Promise<KmsKeyId>;
+    /**
+     * @deprecated The method should not be used. It returns only one profile per verifier, which can potentially restrict business use cases
+     * {@inheritDoc IIdentityWallet.getProfileByVerifier}
+     */
     getProfileByVerifier(verifier: string): Promise<Profile | undefined>;
+    /** {@inheritDoc IIdentityWallet.getProfilesByVerifier} */
+    getProfilesByVerifier(verifier: string, tags?: string[]): Promise<Profile[]>;
     /** {@inheritDoc IIdentityWallet.getDIDTreeModel} */
     getDIDTreeModel(did: DID): Promise<TreesModel>;
     /** {@inheritDoc IIdentityWallet.generateClaimMtp} */

package/dist/types/storage/blockchain/state.d.ts

@@ -3,6 +3,53 @@ import { ZKProof } from '@iden3/js-jwz';
 import { IStateStorage, UserStateTransitionInfo } from '../interfaces/state';
 import { Contract, JsonRpcProvider, Signer } from 'ethers';
 import { StateInfo } from '../entities/state';
+import { ICache } from '../memory';
+/**
+ * Configuration options for caching behavior
+ */
+export type ResolverCacheOptions = {
+    /** TTL in milliseconds for latest states/roots (shorter since they can change) */
+    notReplacedTtl?: number;
+    /** TTL in milliseconds for historical states/roots (longer since they can change with less probability) */
+    replacedTtl?: number;
+    /** Maximum number of entries to store in cache */
+    maxSize?: number;
+};
+/**
+ * Simplified cache config with a single TTL (used for latest/gist proofs etc.)
+ */
+export type SimpleCacheOptions = {
+    /** TTL in milliseconds for latest states/gist proof */
+    ttl?: number;
+    /** Maximum number of entries to store in cache */
+    maxSize?: number;
+};
+/**
+ * EthStateStorageOptions options for the Ethereum state storage.
+ */
+export type EthStateStorageOptions = {
+    /** Disable caching */
+    disableCache?: boolean;
+    /** Configuration for latest state resolution caching */
+    latestStateCacheOptions?: {
+        /** Custom cache implementation (if not provided, uses in-memory cache) */
+        cache?: ICache<StateInfo>;
+    } & SimpleCacheOptions;
+    /** Configuration for state resolution caching */
+    stateCacheOptions?: {
+        /** Custom cache implementation (if not provided, uses in-memory cache) */
+        cache?: ICache<StateInfo>;
+    } & ResolverCacheOptions;
+    /** Configuration for GIST root resolution caching */
+    rootCacheOptions?: {
+        /** Custom cache implementation (if not provided, uses in-memory cache) */
+        cache?: ICache<RootInfo>;
+    } & ResolverCacheOptions;
+    gistProofCacheOptions?: {
+        /** Custom cache implementation for GIST proofs (if not provided, uses in-memory cache) */
+        cache?: ICache<StateProof>;
+    } & SimpleCacheOptions;
+};
 /**
  * Configuration of ethereum based blockchain connection
  *
@@ -38,11 +85,20 @@ export declare class EthStateStorage implements IStateStorage {
     readonly stateContract: Contract;
     private readonly provider;
     private readonly _transactionService;
+    private _latestStateResolveCache;
+    private _stateResolveCache;
+    private _rootResolveCache;
+    private _gistProofResolveCache;
+    private _latestStateCacheOptions;
+    private _stateCacheOptions;
+    private _rootCacheOptions;
+    private _gistProofCacheOptions;
+    private _disableCache;
     /**
      * Creates an instance of EthStateStorage.
      * @param {EthConnectionConfig} [ethConfig=defaultEthConnectionConfig]
      */
-    constructor(ethConfig: EthConnectionConfig | EthConnectionConfig[]);
+    constructor(ethConfig: EthConnectionConfig | EthConnectionConfig[], options?: EthStateStorageOptions);
     /** {@inheritdoc IStateStorage.getLatestStateById} */
     getLatestStateById(id: bigint): Promise<StateInfo>;
     /** {@inheritdoc IStateStorage.getStateInfoByIdAndState} */
@@ -57,6 +113,14 @@ export declare class EthStateStorage implements IStateStorage {
     getGISTRootInfo(root: bigint, id: bigint): Promise<RootInfo>;
     /** {@inheritdoc IStateStorage.getRpcProvider} */
     getRpcProvider(): JsonRpcProvider;
+    /** enable caching */
+    enableCache(): void;
+    /** disable caching */
+    disableCache(): void;
     private getStateContractAndProviderForId;
     private networkByChainId;
+    private getGistProofCacheKey;
+    private getLatestStateCacheKey;
+    private getStateCacheKey;
+    private getRootCacheKey;
 }

package/dist/types/storage/entities/identity.d.ts

@@ -12,4 +12,5 @@ export type Profile = {
     nonce: number | string;
     genesisIdentifier: string;
     verifier: string;
+    tags?: string[];
 };

package/dist/types/storage/interfaces/identity.d.ts

@@ -39,11 +39,18 @@ export interface IIdentityStorage {
     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
      *

package/dist/types/storage/memory/cache-lru.d.ts

@@ -0,0 +1,10 @@
+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 declare function createInMemoryCache<T>(params: {
+    ttl?: number;
+    maxSize: number;
+}): ICache<T>;

package/dist/types/storage/memory/index.d.ts

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

package/dist/types/storage/shared/identity-storage.d.ts

@@ -30,7 +30,12 @@ export declare class IdentityStorage implements IIdentityStorage {
      */
     constructor(_identityDataSource: IDataSource<Identity>, _profileDataSource: IDataSource<Profile>);
     saveProfile(profile: Profile): Promise<void>;
+    /**
+     *  @deprecated The method should not be used. It returns only one profile per verifier, which can potentially restrict business use cases
+     *   Use getProfilesByVerifier instead.
+     */
     getProfileByVerifier(verifier: string): Promise<Profile | undefined>;
+    getProfilesByVerifier(verifier: string, tags?: string[]): Promise<Profile[]>;
     getProfileById(profileId: string): Promise<Profile | undefined>;
     getProfilesByGenesisIdentifier(genesisIdentifier: string): Promise<Profile[]>;
     getAllIdentities(): Promise<Identity[]>;

package/dist/types/verifiable/constants.d.ts

@@ -14,6 +14,7 @@ export declare const VerifiableConstants: Readonly<{
         ID_WALLET_CORE_CLAIM_IS_NOT_SET: string;
         ID_WALLET_PROFILE_OR_IDENTITY_NOT_FOUND: string;
         ID_WALLET_PROFILE_ALREADY_EXISTS: string;
+        ID_WALLET_PROFILE_ALREADY_EXISTS_VERIFIER_TAGS: string;
         ID_WALLET_ISSUER_AUTH_BJJ_CRED_MUST_HAVE_ANY_PROOF: string;
         ID_WALLET_ISSUER_AUTH_BJJ_CRED_MUST_HAVE_MTP_PROOF: string;
         PROOF_SERVICE_NO_CREDENTIAL_FOR_IDENTITY_OR_PROFILE: string;
@@ -162,3 +163,7 @@ export declare enum PaymentFeatures {
 export declare enum DisplayMethodType {
     Iden3BasicDisplayMethodV1 = "Iden3BasicDisplayMethodV1"
 }
+/**
+ * Default cache max size for in-memory cache
+ */
+export declare const DEFAULT_CACHE_MAX_SIZE = 10000;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xpolygonid/js-sdk",
-  "version": "1.31.1",
+  "version": "1.31.3",
   "description": "SDK to work with Polygon ID",
   "main": "dist/node/cjs/index.js",
   "module": "dist/node/esm/index.js",
@@ -99,7 +99,7 @@
   },
   "dependencies": {
     "@iden3/onchain-non-merklized-issuer-base-abi": "^0.0.3",
-    "@iden3/universal-verifier-v2-abi": "^2.0.1",
+    "@iden3/universal-verifier-v2-abi": "^2.0.2",
     "@noble/curves": "^1.9.2",
     "ajv": "8.12.0",
     "ajv-formats": "2.1.1",
@@ -110,6 +110,7 @@
     "js-sha3": "0.9.3",
     "jsonld": "8.3.1",
     "pubsub-js": "1.9.4",
+    "quick-lru": "^7.0.1",
     "uuid": "9.0.1"
   },
   "browserslist": {