@0xpolygonid/js-sdk 1.30.0 → 1.31.3

package/dist/node/cjs/credentials/credential-wallet.js

@@ -196,7 +196,7 @@ class CredentialWallet {
             }
             return { cred, revStatus };
         }
-        throw new Error('all claims are revoked');
+        throw new Error(verifiable_1.VerifiableConstants.ERRORS.CREDENTIAL_WALLET_ALL_CREDENTIALS_ARE_REVOKED);
     }
 }
 exports.CredentialWallet = CredentialWallet;

package/dist/node/cjs/credentials/status/on-chain-revocation.js

@@ -21,8 +21,9 @@ class OnChainResolver {
      * @public
      * @param {Array<EthConnectionConfig>} _configs - list of ethereum network connections
      */
-    constructor(_configs) {
+    constructor(_configs, _opts) {
         this._configs = _configs;
+        this._stateStorage = new state_1.EthStateStorage(_configs, _opts?.stateStorageOptions);
     }
     /**
      * resolve is a method to resolve a credential status from the blockchain.
@@ -53,8 +54,7 @@ class OnChainResolver {
         const issuerId = js_iden3_core_1.DID.idFromDID(issuer);
         let latestIssuerState;
         try {
-            const ethStorage = this._getStateStorageForIssuer(issuerId);
-            const latestStateInfo = await ethStorage.getLatestStateById(issuerId.bigInt());
+            const latestStateInfo = await this._stateStorage.getLatestStateById(issuerId.bigInt());
             if (!latestStateInfo.state) {
                 throw new Error('state contract returned empty state');
             }
@@ -120,13 +120,6 @@ class OnChainResolver {
         }
         return network;
     }
-    // TODO: is dirty hack for mock in tests.
-    // need to pass to constructor list of state stores not list of network configs
-    _getStateStorageForIssuer(issuerId) {
-        const issuerChainId = (0, js_iden3_core_1.getChainId)(js_iden3_core_1.DID.blockchainFromId(issuerId), js_iden3_core_1.DID.networkIdFromId(issuerId));
-        const ethStorage = new state_1.EthStateStorage(this.networkByChainId(issuerChainId));
-        return ethStorage;
-    }
     _getOnChainRevocationStorageForIssuer(chainId, contractAddress) {
         const networkConfig = this.networkByChainId(chainId);
         const onChainCaller = new onchain_revocation_1.OnChainRevocationStorage(networkConfig, contractAddress);

package/dist/node/cjs/iden3comm/handlers/common.js

@@ -4,6 +4,7 @@ exports.verifyExpiresTime = exports.packMetadatas = exports.calcChallengeAuthV2
 const js_crypto_1 = require("@iden3/js-crypto");
 const types_1 = require("../types");
 const utils_1 = require("../../utils");
+const verifiable_1 = require("../../verifiable");
 const js_iden3_core_1 = require("@iden3/js-iden3-core");
 const constants_1 = require("../constants");
 const ethers_1 = require("ethers");
@@ -55,34 +56,60 @@ const processZeroKnowledgeProofRequests = async (to, requests, from, proofServic
     const groupedCredentialsCache = new Map();
     const zkpResponses = [];
     for (const proofReq of requestScope) {
-        if (!opts.supportedCircuits.includes(proofReq.circuitId)) {
-            throw new Error(`Circuit ${proofReq.circuitId} is not allowed`);
-        }
-        const query = proofReq.query;
-        const groupId = query.groupId;
-        const combinedQueryData = combinedQueries.get(groupId);
-        if (groupId) {
-            if (!combinedQueryData) {
-                throw new Error(`Invalid group id ${query.groupId}`);
+        let zkpRes;
+        try {
+            const isCircuitSupported = opts.supportedCircuits.includes(proofReq.circuitId);
+            if (!isCircuitSupported) {
+                if (proofReq.optional) {
+                    continue;
+                }
+                throw new Error(`Circuit ${proofReq.circuitId} is not allowed`);
             }
-            const combinedQuery = combinedQueryData.query;
-            if (!groupedCredentialsCache.has(groupId)) {
-                const credWithRevStatus = await proofService.findCredentialByProofQuery(to, combinedQueryData.query);
-                if (!credWithRevStatus.cred) {
-                    throw new Error(`Credential not found for query ${JSON.stringify(combinedQuery)}`);
+            const query = proofReq.query;
+            const groupId = query.groupId;
+            const combinedQueryData = combinedQueries.get(groupId);
+            if (groupId) {
+                if (!combinedQueryData) {
+                    throw new Error(`Invalid group id ${query.groupId}`);
+                }
+                const combinedQuery = combinedQueryData.query;
+                if (!groupedCredentialsCache.has(groupId)) {
+                    const credWithRevStatus = await proofService.findCredentialByProofQuery(to, combinedQueryData.query);
+                    if (!credWithRevStatus.cred) {
+                        if (proofReq.optional) {
+                            continue;
+                        }
+                        throw new Error(verifiable_1.VerifiableConstants.ERRORS.PROOF_SERVICE_NO_CREDENTIAL_FOR_QUERY +
+                            `${JSON.stringify(combinedQuery)}`);
+                    }
+                    groupedCredentialsCache.set(groupId, credWithRevStatus);
                 }
-                groupedCredentialsCache.set(groupId, credWithRevStatus);
             }
+            const credWithRevStatus = groupedCredentialsCache.get(groupId);
+            zkpRes = await proofService.generateProof(proofReq, to, {
+                verifierDid: from,
+                challenge: opts.challenge,
+                skipRevocation: Boolean(query.skipClaimRevocationCheck),
+                credential: credWithRevStatus?.cred,
+                credentialRevocationStatus: credWithRevStatus?.revStatus,
+                linkNonce: combinedQueryData?.linkNonce ? BigInt(combinedQueryData.linkNonce) : undefined
+            });
+        }
+        catch (error) {
+            const expectedErrors = [
+                verifiable_1.VerifiableConstants.ERRORS.PROOF_SERVICE_NO_CREDENTIAL_FOR_IDENTITY_OR_PROFILE,
+                verifiable_1.VerifiableConstants.ERRORS.ID_WALLET_NO_CREDENTIAL_SATISFIED_QUERY,
+                verifiable_1.VerifiableConstants.ERRORS.CREDENTIAL_WALLET_ALL_CREDENTIALS_ARE_REVOKED
+            ];
+            // handle only errors in case credential is not found and it is optional proof request - otherwise throw
+            if (error instanceof Error &&
+                (expectedErrors.includes(error.message) ||
+                    error.message.includes(verifiable_1.VerifiableConstants.ERRORS.PROOF_SERVICE_NO_CREDENTIAL_FOR_QUERY)) &&
+                proofReq.optional) {
+                continue;
+            }
+            throw error;
         }
-        const credWithRevStatus = groupedCredentialsCache.get(groupId);
-        const zkpRes = await proofService.generateProof(proofReq, to, {
-            verifierDid: from,
-            challenge: opts.challenge,
-            skipRevocation: Boolean(query.skipClaimRevocationCheck),
-            credential: credWithRevStatus?.cred,
-            credentialRevocationStatus: credWithRevStatus?.revStatus,
-            linkNonce: combinedQueryData?.linkNonce ? BigInt(combinedQueryData.linkNonce) : undefined
-        });
         zkpResponses.push(zkpRes);
     }
     return zkpResponses;

package/dist/node/cjs/identity/identity-wallet.js

@@ -229,7 +229,7 @@ class IdentityWallet {
         let credential;
         const ethSigner = opts.ethSigner;
         if (opts.createBjjCredential && !ethSigner) {
-            throw new Error('Ethereum signer is required to create Ethereum identities in order to transit state');
+            throw new Error(verifiable_1.VerifiableConstants.ERRORS.ID_WALLET_SIGNER_IS_REQUIRED);
         }
         const currentState = js_merkletree_1.ZERO_HASH; // In Ethereum identities we don't have an initial state with the auth credential
         const didType = (0, js_iden3_core_1.buildDIDType)(opts.method || js_iden3_core_1.DidMethod.Iden3, opts.blockchain || js_iden3_core_1.Blockchain.Polygon, opts.networkId || js_iden3_core_1.NetworkId.Amoy);
@@ -267,23 +267,28 @@ class IdentityWallet {
         }
         const profile = await this._storage.identity.getProfileById(did.string());
         if (!profile) {
-            throw new Error('profile or identity not found');
+            throw new Error(verifiable_1.VerifiableConstants.ERRORS.ID_WALLET_PROFILE_OR_IDENTITY_NOT_FOUND);
         }
         return { nonce: profile.nonce, genesisDID: js_iden3_core_1.DID.parse(profile.genesisIdentifier) };
     }
     /** {@inheritDoc IIdentityWallet.createProfile} */
-    async createProfile(did, nonce, verifier) {
+    async createProfile(did, nonce, verifier, tags) {
         const profileDID = (0, common_1.generateProfileDID)(did, nonce);
         const identityProfiles = await this._storage.identity.getProfilesByGenesisIdentifier(did.string());
-        const existingProfile = identityProfiles.find((p) => p.nonce == nonce || p.verifier == verifier);
-        if (existingProfile) {
-            throw new Error('profile with given nonce or verifier already exists');
+        const profilesForTagAndVerifier = await this._storage.identity.getProfilesByVerifier(verifier, tags);
+        if (profilesForTagAndVerifier.length) {
+            throw new Error(verifiable_1.VerifiableConstants.ERRORS.ID_WALLET_PROFILE_ALREADY_EXISTS_VERIFIER_TAGS);
+        }
+        const existingProfileWithNonce = identityProfiles.find((p) => p.nonce == nonce);
+        if (existingProfileWithNonce) {
+            throw new Error(verifiable_1.VerifiableConstants.ERRORS.ID_WALLET_PROFILE_ALREADY_EXISTS);
         }
         await this._storage.identity.saveProfile({
             id: profileDID.string(),
             nonce,
             genesisIdentifier: did.string(),
-            verifier
+            verifier,
+            tags
         });
         return profileDID;
     }
@@ -302,9 +307,17 @@ class IdentityWallet {
         const key = await this._kms.createKeyFromSeed(keyType, (0, js_crypto_1.getRandomBytes)(32));
         return key;
     }
+    /**
+     * @deprecated The method should not be used. It returns only one profile per verifier, which can potentially restrict business use cases
+     * {@inheritDoc IIdentityWallet.getProfileByVerifier}
+     */
     async getProfileByVerifier(verifier) {
         return this._storage.identity.getProfileByVerifier(verifier);
     }
+    /** {@inheritDoc IIdentityWallet.getProfilesByVerifier} */
+    async getProfilesByVerifier(verifier, tags) {
+        return this._storage.identity.getProfilesByVerifier(verifier, tags);
+    }
     /** {@inheritDoc IIdentityWallet.getDIDTreeModel} */
     async getDIDTreeModel(did) {
         const didStr = did.string();
@@ -426,11 +439,11 @@ class IdentityWallet {
         const coreClaimHash = js_crypto_1.poseidon.hash([hi, hv]);
         const signature = await this.signChallenge(coreClaimHash, issuerAuthBJJCredential);
         if (!issuerAuthBJJCredential.proof) {
-            throw new Error('issuer auth credential must have proof');
+            throw new Error(verifiable_1.VerifiableConstants.ERRORS.ID_WALLET_ISSUER_AUTH_BJJ_CRED_MUST_HAVE_ANY_PROOF);
         }
         const mtpAuthBJJProof = issuerAuthBJJCredential.getIden3SparseMerkleTreeProof();
         if (!mtpAuthBJJProof) {
-            throw new Error('mtp is required for auth bjj key to issue new credentials');
+            throw new Error(verifiable_1.VerifiableConstants.ERRORS.ID_WALLET_ISSUER_AUTH_BJJ_CRED_MUST_HAVE_MTP_PROOF);
         }
         const sigProof = new verifiable_1.BJJSignatureProof2021({
             issuerData: {
@@ -470,7 +483,7 @@ class IdentityWallet {
         const issuerTree = await this.getDIDTreeModel(issuerDID);
         const coreClaim = await this.getCoreClaimFromCredential(credential);
         if (!coreClaim) {
-            throw new Error('credential must have coreClaim representation in proofs');
+            throw new Error(verifiable_1.VerifiableConstants.ERRORS.ID_WALLET_CORE_CLAIM_REQUIRED_IN_ANY_PROOF);
         }
         const nonce = coreClaim.getRevocationNonce();
         await issuerTree.revocationTree.add(nonce, BigInt(0));
@@ -493,7 +506,7 @@ class IdentityWallet {
             // credential must have a bjj signature proof
             const coreClaim = credential.getCoreClaimFromProof(verifiable_1.ProofType.BJJSignature);
             if (!coreClaim) {
-                throw new Error('credential must have coreClaim representation in the signature proof');
+                throw new Error(verifiable_1.VerifiableConstants.ERRORS.ID_WALLET_CORE_CLAIM_REQUIRED_IN_SIG_PROOF);
             }
             await this._storage.mt.addToMerkleTree(issuerDID.string(), storage_1.MerkleTreeType.Claims, coreClaim.hIndex(), coreClaim.hValue());
         }
@@ -525,7 +538,7 @@ class IdentityWallet {
             const coreClaim = credential.getCoreClaimFromProof(verifiable_1.ProofType.BJJSignature) ||
                 (await credential.toCoreClaim(opts));
             if (!coreClaim) {
-                throw new Error('credential must have coreClaim representation in the signature proof');
+                throw new Error(verifiable_1.VerifiableConstants.ERRORS.ID_WALLET_CORE_CLAIM_REQUIRED_IN_SIG_PROOF);
             }
             const mtpWithProof = await this.generateCoreClaimMtp(issuerDID, coreClaim, treeState);
             const mtpProof = new verifiable_1.Iden3SparseMerkleTreeProof({
@@ -595,10 +608,10 @@ class IdentityWallet {
         if (coreClaimFromMtpProof &&
             coreClaimFromSigProof &&
             coreClaimFromMtpProof.hex() !== coreClaimFromSigProof.hex()) {
-            throw new Error('core claim representations is set in both proofs but they are not equal');
+            throw new Error(verifiable_1.VerifiableConstants.ERRORS.ID_WALLET_CORE_CLAIM_MISMATCH);
         }
         if (!coreClaimFromMtpProof && !coreClaimFromSigProof) {
-            throw new Error('core claim is not set in credential proofs');
+            throw new Error(verifiable_1.VerifiableConstants.ERRORS.ID_WALLET_CORE_CLAIM_IS_NOT_SET);
         }
         //eslint-disable-next-line  @typescript-eslint/no-non-null-assertion
         const coreClaim = coreClaimFromMtpProof ?? coreClaimFromSigProof;
@@ -607,7 +620,7 @@ class IdentityWallet {
     async findOwnedCredentialsByDID(did, query) {
         const credentials = await this._credentialWallet.findByQuery(query);
         if (!credentials.length) {
-            throw new Error(`no credential satisfied query`);
+            throw new Error(verifiable_1.VerifiableConstants.ERRORS.ID_WALLET_NO_CREDENTIAL_SATISFIED_QUERY);
         }
         const { genesisDID } = await this.getGenesisDIDMetadata(did);
         const profiles = await this.getProfilesByDID(genesisDID);
@@ -647,7 +660,7 @@ class IdentityWallet {
         let txId;
         if (!isEthIdentity) {
             if (!prover) {
-                throw new Error('prover is required to generate proofs for non ethereum identities');
+                throw new Error(verifiable_1.VerifiableConstants.ERRORS.ID_WALLET_PROVER_IS_REQUIRED);
             }
             // generate the proof
             const authInfo = await this._inputsGenerator.prepareAuthBJJCredential(did, oldTreeState);

package/dist/node/cjs/proof/proof-service.js

@@ -76,7 +76,8 @@ class ProofService {
             credentialWithRevStatus = { cred: opts.credential, revStatus };
         }
         if (!credentialWithRevStatus.cred) {
-            throw new Error(`credential not found for query ${JSON.stringify(proofReq.query)}`);
+            throw new Error(verifiable_1.VerifiableConstants.ERRORS.PROOF_SERVICE_NO_CREDENTIAL_FOR_QUERY +
+                ` ${JSON.stringify(proofReq.query)}`);
         }
         const credentialCoreClaim = await this._identityWallet.getCoreClaimFromCredential(credentialWithRevStatus.cred);
         const { nonce: authProfileNonce, genesisDID } = await this._identityWallet.getGenesisDIDMetadata(identifier);
@@ -88,11 +89,11 @@ class ProofService {
         const subjectDID = js_iden3_core_1.DID.parse(preparedCredential.credential.credentialSubject['id']);
         const { nonce: credentialSubjectProfileNonce, genesisDID: subjectGenesisDID } = await this._identityWallet.getGenesisDIDMetadata(subjectDID);
         if (subjectGenesisDID.string() !== genesisDID.string()) {
-            throw new Error('subject and auth profiles are not derived from the same did');
+            throw new Error(verifiable_1.VerifiableConstants.ERRORS.PROOF_SERVICE_PROFILE_GENESIS_DID_MISMATCH);
         }
         const propertiesMetadata = (0, common_1.parseCredentialSubject)(proofReq.query.credentialSubject);
         if (!propertiesMetadata.length) {
-            throw new Error('no queries in zkp request');
+            throw new Error(verifiable_1.VerifiableConstants.ERRORS.PROOF_SERVICE_NO_QUERIES_IN_ZKP_REQUEST);
         }
         const mtPosition = preparedCredential.credentialCoreClaim.getMerklizedPosition();
         let mk;
@@ -276,7 +277,7 @@ class ProofService {
     async findCredentialByProofQuery(did, query) {
         const credentials = await this._identityWallet.findOwnedCredentialsByDID(did, query);
         if (!credentials.length) {
-            throw new Error(`no credentials belong to did or its profiles`);
+            throw new Error(verifiable_1.VerifiableConstants.ERRORS.PROOF_SERVICE_NO_CREDENTIAL_FOR_IDENTITY_OR_PROFILE);
         }
         //  For EQ / IN / NIN / LT / GT operations selective if credential satisfies query - we can get any.
         // TODO: choose credential for selective credentials

package/dist/node/cjs/proof/verifiers/query.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fieldValueFromVerifiablePresentation = exports.validateEmptyCredentialSubjectNoopNativeSupport = exports.validateDisclosureNativeSDSupport = exports.validateDisclosureV2Circuit = exports.validateOperators = exports.validateEmptyCredentialSubjectV2Circuit = exports.verifyFieldValueInclusionNativeExistsSupport = exports.verifyFieldValueInclusionV2 = exports.checkCircuitOperator = exports.checkCircuitQueriesLength = exports.checkQueryRequest = void 0;
+exports.calculateMultiRequestId = exports.calculateRequestId = exports.calculateGroupId = exports.fieldValueFromVerifiablePresentation = exports.validateEmptyCredentialSubjectNoopNativeSupport = exports.validateDisclosureNativeSDSupport = exports.validateDisclosureV2Circuit = exports.validateOperators = exports.validateEmptyCredentialSubjectV2Circuit = exports.verifyFieldValueInclusionNativeExistsSupport = exports.verifyFieldValueInclusionV2 = exports.checkCircuitOperator = exports.checkCircuitQueriesLength = exports.checkQueryRequest = void 0;
 const js_iden3_core_1 = require("@iden3/js-iden3-core");
 const js_jsonld_merklization_1 = require("@iden3/js-jsonld-merklization");
 const utils_1 = require("../../utils");
 const comparer_1 = require("../../circuits/comparer");
 const verifiable_1 = require("../../verifiable");
 const provers_1 = require("../provers");
+const ethers_1 = require("ethers");
 const defaultProofGenerationDelayOpts = 24 * 60 * 60 * 1000; // 24 hours
 async function checkQueryRequest(query, queriesMetadata, ldContext, outputs, circuitId, schemaLoader, opts) {
     // validate issuer
@@ -211,3 +212,26 @@ const fieldValueFromVerifiablePresentation = async (fieldName, verifiablePresent
     return await value.mtEntry();
 };
 exports.fieldValueFromVerifiablePresentation = fieldValueFromVerifiablePresentation;
+function calculateGroupId(requestIds) {
+    const types = Array(requestIds.length).fill('uint256');
+    const groupID = BigInt(ethers_1.ethers.keccak256(ethers_1.ethers.solidityPacked(types, requestIds))) &
+        // It should fit in a field number in the circuit (max 253 bits). With this we truncate to 252 bits for the group ID
+        BigInt('0x0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF');
+    return groupID;
+}
+exports.calculateGroupId = calculateGroupId;
+function calculateRequestId(requestParams, creatorAddress) {
+    // 0x0000000000000000FFFF...FF. Reserved first 8 bytes for the request Id type and future use
+    // 0x00010000000000000000...00. First 2 bytes for the request Id type
+    //    - 0x0000... for old request Ids with uint64
+    //    - 0x0001... for new request Ids with uint256
+    const requestId = (BigInt(ethers_1.ethers.keccak256(ethers_1.ethers.solidityPacked(['bytes', 'address'], [requestParams, creatorAddress]))) &
+        BigInt('0x0000000000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF')) +
+        BigInt('0x0001000000000000000000000000000000000000000000000000000000000000');
+    return requestId;
+}
+exports.calculateRequestId = calculateRequestId;
+function calculateMultiRequestId(requestIds, groupIds, creatorAddress) {
+    return BigInt(ethers_1.ethers.keccak256(ethers_1.ethers.solidityPacked(['uint256[]', 'uint256[]', 'address'], [requestIds, groupIds, creatorAddress])));
+}
+exports.calculateMultiRequestId = calculateMultiRequestId;

package/dist/node/cjs/schema-processor/json/validator.js

@@ -44,6 +44,7 @@ class JsonSchemaValidator {
         validator = ajv ?? defaultJSONSchemaValidator;
         if (validator.formats && !Object.keys(validator.formats).length) {
             (0, ajv_formats_1.default)(validator);
+            addCustomFormats(validator);
         }
         const validate = (schema.$id ? validator.getSchema(schema.$id) : undefined) || validator.compile(schema);
         const valid = validate(data);
@@ -55,3 +56,13 @@ class JsonSchemaValidator {
     }
 }
 exports.JsonSchemaValidator = JsonSchemaValidator;
+function addCustomFormats(validator) {
+    validator.addFormat('positive-integer', {
+        type: 'string',
+        validate: (positiveIntegerStr) => /^[1-9]\d*$/.test(positiveIntegerStr)
+    });
+    validator.addFormat('non-negative-integer', {
+        type: 'string',
+        validate: (nonNegativeIntegerStr) => /^(0|[1-9]\d*)$/.test(nonNegativeIntegerStr)
+    });
+}

package/dist/node/cjs/storage/blockchain/onchain-zkp-verifier.js

@@ -7,7 +7,6 @@ exports.packEthIdentityProof = exports.OnChainZKPVerifier = exports.toTxDataArgs
 const ethers_1 = require("ethers");
 const iden3comm_1 = require("../../iden3comm");
 const ZkpVerifier_json_1 = __importDefault(require("./abi/ZkpVerifier.json"));
-//import { UniversalVerifier } from '@iden3/universal-verifier-v2-abi';
 const universal_verifier_v2_abi_1 = require("@iden3/universal-verifier-v2-abi");
 const blockchain_1 = require("../../blockchain");
 const js_iden3_core_1 = require("@iden3/js-iden3-core");

package/dist/node/cjs/storage/blockchain/state.js

@@ -11,6 +11,9 @@ const State_json_1 = __importDefault(require("./abi/State.json"));
 const js_iden3_core_1 = require("@iden3/js-iden3-core");
 const blockchain_1 = require("../../blockchain");
 const common_1 = require("./common");
+const memory_1 = require("../memory");
+const iden3comm_1 = require("../../iden3comm");
+const verifiable_1 = require("../../verifiable");
 exports.defaultEthConnectionConfig = {
     url: 'http://localhost:8545',
     defaultGasLimit: 600000,
@@ -36,15 +39,71 @@ class EthStateStorage {
      * Creates an instance of EthStateStorage.
      * @param {EthConnectionConfig} [ethConfig=defaultEthConnectionConfig]
      */
-    constructor(ethConfig) {
+    constructor(ethConfig, options) {
         this.ethConfig = ethConfig;
+        this._disableCache = false;
         const config = Array.isArray(ethConfig) ? ethConfig[0] : ethConfig;
         this.provider = new ethers_1.JsonRpcProvider(config.url);
         this.stateContract = new ethers_1.Contract(config.contractAddress, State_json_1.default, this.provider);
         this._transactionService = new blockchain_1.TransactionService(this.getRpcProvider());
+        // Store cache options for later use
+        this._latestStateCacheOptions = {
+            ttl: options?.latestStateCacheOptions?.ttl ?? iden3comm_1.PROTOCOL_CONSTANTS.DEFAULT_PROOF_VERIFY_DELAY / 2,
+            maxSize: options?.latestStateCacheOptions?.maxSize ?? verifiable_1.DEFAULT_CACHE_MAX_SIZE
+        };
+        this._stateCacheOptions = {
+            notReplacedTtl: options?.stateCacheOptions?.notReplacedTtl ??
+                iden3comm_1.PROTOCOL_CONSTANTS.DEFAULT_PROOF_VERIFY_DELAY / 2,
+            replacedTtl: options?.stateCacheOptions?.replacedTtl ?? iden3comm_1.PROTOCOL_CONSTANTS.DEFAULT_PROOF_VERIFY_DELAY,
+            maxSize: options?.stateCacheOptions?.maxSize ?? verifiable_1.DEFAULT_CACHE_MAX_SIZE
+        };
+        this._rootCacheOptions = {
+            replacedTtl: options?.rootCacheOptions?.replacedTtl ?? iden3comm_1.PROTOCOL_CONSTANTS.DEFAULT_AUTH_VERIFY_DELAY,
+            notReplacedTtl: options?.rootCacheOptions?.notReplacedTtl ??
+                iden3comm_1.PROTOCOL_CONSTANTS.DEFAULT_AUTH_VERIFY_DELAY / 2,
+            maxSize: options?.rootCacheOptions?.maxSize ?? verifiable_1.DEFAULT_CACHE_MAX_SIZE
+        };
+        this._gistProofCacheOptions = {
+            ttl: iden3comm_1.PROTOCOL_CONSTANTS.DEFAULT_AUTH_VERIFY_DELAY / 2,
+            maxSize: options?.gistProofCacheOptions?.maxSize ?? verifiable_1.DEFAULT_CACHE_MAX_SIZE
+        };
+        // Initialize cache instances
+        this._latestStateResolveCache =
+            options?.latestStateCacheOptions?.cache ??
+                (0, memory_1.createInMemoryCache)({
+                    maxSize: this._latestStateCacheOptions.maxSize,
+                    ttl: this._latestStateCacheOptions.ttl
+                });
+        this._stateResolveCache =
+            options?.stateCacheOptions?.cache ??
+                (0, memory_1.createInMemoryCache)({
+                    maxSize: this._stateCacheOptions.maxSize,
+                    ttl: this._stateCacheOptions.replacedTtl
+                });
+        this._rootResolveCache =
+            options?.rootCacheOptions?.cache ??
+                (0, memory_1.createInMemoryCache)({
+                    maxSize: this._rootCacheOptions.maxSize,
+                    ttl: this._rootCacheOptions.replacedTtl
+                });
+        this._gistProofResolveCache =
+            options?.gistProofCacheOptions?.cache ??
+                (0, memory_1.createInMemoryCache)({
+                    maxSize: this._gistProofCacheOptions.maxSize,
+                    ttl: this._gistProofCacheOptions.ttl
+                });
+        this._disableCache = options?.disableCache ?? false;
     }
     /** {@inheritdoc IStateStorage.getLatestStateById} */
     async getLatestStateById(id) {
+        const cacheKey = this.getLatestStateCacheKey(id);
+        if (!this._disableCache) {
+            // Check cache first
+            const cachedResult = await this._latestStateResolveCache?.get(cacheKey);
+            if (cachedResult) {
+                return cachedResult;
+            }
+        }
         const { stateContract } = this.getStateContractAndProviderForId(id);
         const rawData = await stateContract.getStateInfoById(id);
         const stateInfo = {
@@ -56,10 +115,20 @@ class EthStateStorage {
             createdAtBlock: BigInt(rawData[5]),
             replacedAtBlock: BigInt(rawData[6])
         };
+        !this._disableCache &&
+            (await this._latestStateResolveCache?.set(cacheKey, stateInfo, this._latestStateCacheOptions.ttl));
         return stateInfo;
     }
     /** {@inheritdoc IStateStorage.getStateInfoByIdAndState} */
     async getStateInfoByIdAndState(id, state) {
+        const cacheKey = this.getStateCacheKey(id, state);
+        if (!this._disableCache) {
+            // Check cache first
+            const cachedResult = await this._stateResolveCache?.get(cacheKey);
+            if (cachedResult) {
+                return cachedResult;
+            }
+        }
         const { stateContract } = this.getStateContractAndProviderForId(id);
         const rawData = await stateContract.getStateInfoByIdAndState(id, state);
         const stateInfo = {
@@ -71,6 +140,10 @@ class EthStateStorage {
             createdAtBlock: BigInt(rawData[5]),
             replacedAtBlock: BigInt(rawData[6])
         };
+        const ttl = stateInfo.replacedAtTimestamp === 0n
+            ? this._stateCacheOptions.notReplacedTtl
+            : this._stateCacheOptions.replacedTtl;
+        !this._disableCache && (await this._stateResolveCache?.set(cacheKey, stateInfo, ttl));
         return stateInfo;
     }
     /** {@inheritdoc IStateStorage.publishState} */
@@ -143,9 +216,17 @@ class EthStateStorage {
     }
     /** {@inheritdoc IStateStorage.getGISTProof} */
     async getGISTProof(id) {
+        const cacheKey = this.getGistProofCacheKey(id);
+        if (!this._disableCache) {
+            // Check cache first
+            const cachedResult = await this._gistProofResolveCache?.get(cacheKey);
+            if (cachedResult) {
+                return cachedResult;
+            }
+        }
         const { stateContract } = this.getStateContractAndProviderForId(id);
         const data = await stateContract.getGISTProof(id);
-        return {
+        const stateProof = {
             root: BigInt(data.root.toString()),
             existence: data.existence,
             siblings: data.siblings?.map((sibling) => BigInt(sibling.toString())),
@@ -155,12 +236,23 @@ class EthStateStorage {
             auxIndex: BigInt(data.auxIndex.toString()),
             auxValue: BigInt(data.auxValue.toString())
         };
+        !this._disableCache &&
+            (await this._gistProofResolveCache?.set(cacheKey, stateProof, this._gistProofCacheOptions.ttl));
+        return stateProof;
     }
     /** {@inheritdoc IStateStorage.getGISTRootInfo} */
     async getGISTRootInfo(root, id) {
+        const cacheKey = this.getRootCacheKey(root);
+        if (!this._disableCache) {
+            // Check cache first
+            const cachedResult = await this._rootResolveCache?.get(cacheKey);
+            if (cachedResult) {
+                return cachedResult;
+            }
+        }
         const { stateContract } = this.getStateContractAndProviderForId(id);
         const data = await stateContract.getGISTRootInfo(root);
-        return {
+        const rootInfo = {
             root: BigInt(data.root.toString()),
             replacedByRoot: BigInt(data.replacedByRoot.toString()),
             createdAtTimestamp: BigInt(data.createdAtTimestamp.toString()),
@@ -168,11 +260,24 @@ class EthStateStorage {
             createdAtBlock: BigInt(data.createdAtBlock.toString()),
             replacedAtBlock: BigInt(data.replacedAtBlock.toString())
         };
+        const ttl = rootInfo.replacedAtTimestamp == 0n
+            ? this._rootCacheOptions.notReplacedTtl
+            : this._rootCacheOptions.replacedTtl;
+        !this._disableCache && (await this._rootResolveCache?.set(cacheKey, rootInfo, ttl));
+        return rootInfo;
     }
     /** {@inheritdoc IStateStorage.getRpcProvider} */
     getRpcProvider() {
         return this.provider;
     }
+    /** enable caching */
+    enableCache() {
+        this._disableCache = false;
+    }
+    /** disable caching */
+    disableCache() {
+        this._disableCache = true;
+    }
     getStateContractAndProviderForId(id) {
         const idTyped = js_iden3_core_1.Id.fromBigInt(id);
         const chainId = (0, js_iden3_core_1.getChainId)(js_iden3_core_1.DID.blockchainFromId(idTyped), js_iden3_core_1.DID.networkIdFromId(idTyped));
@@ -189,5 +294,17 @@ class EthStateStorage {
         }
         return network;
     }
+    getGistProofCacheKey(id) {
+        return `gist-${id.toString()}`;
+    }
+    getLatestStateCacheKey(id) {
+        return `latest-${id.toString()}`;
+    }
+    getStateCacheKey(id, state) {
+        return `${id.toString()}-${state.toString()}`;
+    }
+    getRootCacheKey(root) {
+        return root.toString();
+    }
 }
 exports.EthStateStorage = EthStateStorage;

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

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInMemoryCache = void 0;
+const quick_lru_1 = __importDefault(require("quick-lru"));
+function createInMemoryCache(params) {
+    const cache = new quick_lru_1.default({ 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);
+        }
+    };
+}
+exports.createInMemoryCache = createInMemoryCache;

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

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./merkletree"), exports);
 __exportStar(require("./data-source"), exports);
+__exportStar(require("./cache-lru"), exports);

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

@@ -27,9 +27,16 @@ 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);
     }