@0xpolygonid/js-sdk 1.30.0 → 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

@@ -5,7 +5,27 @@ export const VerifiableConstants = Object.freeze({
         CONTEXT_TYPE_IS_EMPTY: 'ctxType is empty',
         // ErrStateNotFound issuer state is genesis state.
         IDENTITY_DOES_NOT_EXIST: 'Identity does not exist',
-        NO_AUTH_CRED_FOUND: 'no auth credentials found'
+        NO_AUTH_CRED_FOUND: 'no auth credentials found',
+        // identity wallet
+        ID_WALLET_NO_CREDENTIAL_SATISFIED_QUERY: 'no credential satisfied query',
+        ID_WALLET_SIGNER_IS_REQUIRED: 'Ethereum signer is required to create Ethereum identities in order to transit state',
+        ID_WALLET_PROVER_IS_REQUIRED: 'prover is required to generate proofs for non ethereum identities',
+        ID_WALLET_CORE_CLAIM_REQUIRED_IN_SIG_PROOF: 'credential must have coreClaim representation in the signature proof',
+        ID_WALLET_CORE_CLAIM_REQUIRED_IN_ANY_PROOF: 'credential must have coreClaim representation in proofs',
+        ID_WALLET_CORE_CLAIM_MISMATCH: 'core claim representations is set in both proofs but they are not equal',
+        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
+        PROOF_SERVICE_NO_CREDENTIAL_FOR_IDENTITY_OR_PROFILE: 'no credentials belong to did or its profiles',
+        PROOF_SERVICE_NO_CREDENTIAL_FOR_QUERY: 'credential not found for query',
+        PROOF_SERVICE_PROFILE_GENESIS_DID_MISMATCH: 'subject and auth profiles are not derived from the same did',
+        PROOF_SERVICE_NO_QUERIES_IN_ZKP_REQUEST: 'no queries in zkp request',
+        // credential wallet
+        CREDENTIAL_WALLET_ALL_CREDENTIALS_ARE_REVOKED: 'all claims are revoked'
     },
     CREDENTIAL_TYPE: {
         // VerifiableCredential is a W3C verifiable credential type
@@ -178,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/node/esm/verifiable/presentation.js

@@ -41,12 +41,12 @@ export const createVerifiablePresentation = (context, tp, credential, queries) =
     }
     const skeleton = {
         '@context': baseContext,
-        '@type': VerifiableConstants.CREDENTIAL_TYPE.W3C_VERIFIABLE_PRESENTATION,
+        type: VerifiableConstants.CREDENTIAL_TYPE.W3C_VERIFIABLE_PRESENTATION,
         verifiableCredential: {
             '@context': ldContext,
-            '@type': vcTypes,
+            type: vcTypes,
             credentialSubject: {
-                '@type': tp
+                type: tp
             }
         }
     };

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/iden3comm/types/protocol/auth.d.ts

@@ -70,10 +70,10 @@ export type ZeroKnowledgeProofAuthResponse = Omit<ZeroKnowledgeProofResponse, 'i
 /** VerifiablePresentation represents structure of Verifiable Presentation */
 export type VerifiablePresentation = {
     '@context': string | (string | object)[];
-    '@type': string;
+    type: string;
     verifiableCredential: {
         '@context': string | string[];
-        '@type': string | string[];
+        type: string | string[];
         credentialSubject: JsonDocumentObject;
     };
 };

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/proof/verifiers/query.d.ts

@@ -37,3 +37,6 @@ export declare function validateDisclosureV2Circuit(cq: QueryMetadata, outputs:
 export declare function validateDisclosureNativeSDSupport(cq: QueryMetadata, outputs: ClaimOutputs, verifiablePresentation?: VerifiablePresentation, ldLoader?: DocumentLoader): Promise<void>;
 export declare function validateEmptyCredentialSubjectNoopNativeSupport(outputs: ClaimOutputs): Promise<void>;
 export declare const fieldValueFromVerifiablePresentation: (fieldName: string, verifiablePresentation?: VerifiablePresentation, ldLoader?: DocumentLoader) => Promise<bigint>;
+export declare function calculateGroupId(requestIds: bigint[]): bigint;
+export declare function calculateRequestId(requestParams: string, creatorAddress: string): bigint;
+export declare function calculateMultiRequestId(requestIds: bigint[], groupIds: bigint[], creatorAddress: string): bigint;

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

@@ -5,6 +5,23 @@ export declare const VerifiableConstants: Readonly<{
         CONTEXT_TYPE_IS_EMPTY: string;
         IDENTITY_DOES_NOT_EXIST: string;
         NO_AUTH_CRED_FOUND: string;
+        ID_WALLET_NO_CREDENTIAL_SATISFIED_QUERY: string;
+        ID_WALLET_SIGNER_IS_REQUIRED: string;
+        ID_WALLET_PROVER_IS_REQUIRED: string;
+        ID_WALLET_CORE_CLAIM_REQUIRED_IN_SIG_PROOF: string;
+        ID_WALLET_CORE_CLAIM_REQUIRED_IN_ANY_PROOF: string;
+        ID_WALLET_CORE_CLAIM_MISMATCH: string;
+        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;
+        PROOF_SERVICE_NO_CREDENTIAL_FOR_QUERY: string;
+        PROOF_SERVICE_PROFILE_GENESIS_DID_MISMATCH: string;
+        PROOF_SERVICE_NO_QUERIES_IN_ZKP_REQUEST: string;
+        CREDENTIAL_WALLET_ALL_CREDENTIALS_ARE_REVOKED: string;
     };
     CREDENTIAL_TYPE: {
         W3C_VERIFIABLE_CREDENTIAL: string;
@@ -146,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.30.0",
+  "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": {