@0xpolygonid/js-sdk 1.30.0 → 1.31.3

package/dist/browser/umd/index.js

@@ -11388,7 +11388,27 @@ var PolygonIdSdk = (function (exports) {
             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
@@ -11561,6 +11581,10 @@ var PolygonIdSdk = (function (exports) {
     (function (DisplayMethodType) {
         DisplayMethodType["Iden3BasicDisplayMethodV1"] = "Iden3BasicDisplayMethodV1";
     })(exports.DisplayMethodType || (exports.DisplayMethodType = {}));
+    /**
+     * Default cache max size for in-memory cache
+     */
+    const DEFAULT_CACHE_MAX_SIZE = 10000;
 
     /**
      * Iden3SparseMerkleProof is a iden3 protocol merkle tree proof
@@ -37772,12 +37796,12 @@ var PolygonIdSdk = (function (exports) {
         }
         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
                 }
             }
         };
@@ -48209,6 +48233,7 @@ var PolygonIdSdk = (function (exports) {
             validator = ajv ?? defaultJSONSchemaValidator;
             if (validator.formats && !Object.keys(validator.formats).length) {
                 addFormats(validator);
+                addCustomFormats(validator);
             }
             const validate = (schema.$id ? validator.getSchema(schema.$id) : undefined) || validator.compile(schema);
             const valid = validate(data);
@@ -48219,6 +48244,16 @@ var PolygonIdSdk = (function (exports) {
             return true;
         }
     }
+    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)
+        });
+    }
 
     /* eslint-disable @typescript-eslint/no-var-requires */
     /**
@@ -57574,6 +57609,82 @@ var PolygonIdSdk = (function (exports) {
         }))) + "00";
     }
 
+    const regexBytes = new RegExp("^bytes([0-9]+)$");
+    const regexNumber = new RegExp("^(u?int)([0-9]*)$");
+    const regexArray = new RegExp("^(.*)\\[([0-9]*)\\]$");
+    function _pack(type, value, isArray) {
+        switch (type) {
+            case "address":
+                if (isArray) {
+                    return getBytes(zeroPadValue(value, 32));
+                }
+                return getBytes(getAddress(value));
+            case "string":
+                return toUtf8Bytes(value);
+            case "bytes":
+                return getBytes(value);
+            case "bool":
+                value = (!!value ? "0x01" : "0x00");
+                if (isArray) {
+                    return getBytes(zeroPadValue(value, 32));
+                }
+                return getBytes(value);
+        }
+        let match = type.match(regexNumber);
+        if (match) {
+            let signed = (match[1] === "int");
+            let size = parseInt(match[2] || "256");
+            assertArgument((!match[2] || match[2] === String(size)) && (size % 8 === 0) && size !== 0 && size <= 256, "invalid number type", "type", type);
+            if (isArray) {
+                size = 256;
+            }
+            if (signed) {
+                value = toTwos(value, size);
+            }
+            return getBytes(zeroPadValue(toBeArray(value), size / 8));
+        }
+        match = type.match(regexBytes);
+        if (match) {
+            const size = parseInt(match[1]);
+            assertArgument(String(size) === match[1] && size !== 0 && size <= 32, "invalid bytes type", "type", type);
+            assertArgument(dataLength(value) === size, `invalid value for ${type}`, "value", value);
+            if (isArray) {
+                return getBytes(zeroPadBytes(value, 32));
+            }
+            return value;
+        }
+        match = type.match(regexArray);
+        if (match && Array.isArray(value)) {
+            const baseType = match[1];
+            const count = parseInt(match[2] || String(value.length));
+            assertArgument(count === value.length, `invalid array length for ${type}`, "value", value);
+            const result = [];
+            value.forEach(function (value) {
+                result.push(_pack(baseType, value, true));
+            });
+            return getBytes(concat(result));
+        }
+        assertArgument(false, "invalid type", "type", type);
+    }
+    // @TODO: Array Enum
+    /**
+     *   Computes the [[link-solc-packed]] representation of %%values%%
+     *   respectively to their %%types%%.
+     *
+     *   @example:
+     *       addr = "0x8ba1f109551bd432803012645ac136ddd64dba72"
+     *       solidityPacked([ "address", "uint" ], [ addr, 45 ]);
+     *       //_result:
+     */
+    function solidityPacked(types, values) {
+        assertArgument(types.length === values.length, "wrong number of values; expected ${ types.length }", "values", values);
+        const tight = [];
+        types.forEach(function (type, index) {
+            tight.push(_pack(type, values[index]));
+        });
+        return hexlify(concat(tight));
+    }
+
     //import { TypedDataDomain, TypedDataField } from "@ethersproject/providerabstract-signer";
     const padding = new Uint8Array(32);
     padding.fill(0);
@@ -70737,186 +70848,471 @@ var PolygonIdSdk = (function (exports) {
         };
     };
 
-    const defaultEthConnectionConfig = {
-        url: 'http://localhost:8545',
-        defaultGasLimit: 600000,
-        minGasPrice: '0',
-        maxGasPrice: '100000000000',
-        confirmationBlockCount: 5,
-        confirmationTimeout: 600000,
-        contractAddress: '',
-        receiptTimeout: 600000,
-        rpcResponseTimeout: 5000,
-        waitReceiptCycleTime: 30000,
-        waitBlockCycleTime: 3000
+    /**
+     * Type of MerkleTree
+     *
+     * @enum {number}
+     */
+    exports.MerkleTreeType = void 0;
+    (function (MerkleTreeType) {
+        // Claims is merkle tree type for claims tree
+        MerkleTreeType[MerkleTreeType["Claims"] = 0] = "Claims";
+        // Revocations is merkle tree type for revocations tree
+        MerkleTreeType[MerkleTreeType["Revocations"] = 1] = "Revocations";
+        // Roots is merkle tree type for roots tree
+        MerkleTreeType[MerkleTreeType["Roots"] = 2] = "Roots";
+    })(exports.MerkleTreeType || (exports.MerkleTreeType = {}));
+
+    const MERKLE_TREE_TYPES = [
+        exports.MerkleTreeType.Claims,
+        exports.MerkleTreeType.Revocations,
+        exports.MerkleTreeType.Roots
+    ];
+    const createMerkleTreeMetaInfo = (identifier) => {
+        const treesMeta = [];
+        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;
     };
+
     /**
      *
      *
      * @public
-     * @class EthStateStorage
-     * @implements implements IStateStorage interface
+     * @class InMemoryMerkleTreeStorage
+     * @implements implements IMerkleTreeStorage interface
      */
-    class EthStateStorage {
+    class InMemoryMerkleTreeStorage {
         /**
-         * Creates an instance of EthStateStorage.
-         * @param {EthConnectionConfig} [ethConfig=defaultEthConnectionConfig]
+         * Creates an instance of InMemoryMerkleTreeStorage.
+         * @param {number} _mtDepth
          */
-        constructor(ethConfig) {
-            this.ethConfig = ethConfig;
-            const config = Array.isArray(ethConfig) ? ethConfig[0] : ethConfig;
-            this.provider = new JsonRpcProvider(config.url);
-            this.stateContract = new Contract(config.contractAddress, abi$3, this.provider);
-            this._transactionService = new TransactionService(this.getRpcProvider());
+        constructor(_mtDepth) {
+            this.mtDepth = _mtDepth;
+            this._data = {};
         }
-        /** {@inheritdoc IStateStorage.getLatestStateById} */
-        async getLatestStateById(id) {
-            const { stateContract } = this.getStateContractAndProviderForId(id);
-            const rawData = await stateContract.getStateInfoById(id);
-            const stateInfo = {
-                id: BigInt(rawData[0]),
-                state: BigInt(rawData[1]),
-                replacedByState: BigInt(rawData[2]),
-                createdAtTimestamp: BigInt(rawData[3]),
-                replacedAtTimestamp: BigInt(rawData[4]),
-                createdAtBlock: BigInt(rawData[5]),
-                replacedAtBlock: BigInt(rawData[6])
-            };
-            return stateInfo;
+        /** create trees in the  memory*/
+        async createIdentityMerkleTrees(identifier) {
+            if (!identifier) {
+                identifier = `${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 = [];
+            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;
         }
-        /** {@inheritdoc IStateStorage.getStateInfoByIdAndState} */
-        async getStateInfoByIdAndState(id, state) {
-            const { stateContract } = this.getStateContractAndProviderForId(id);
-            const rawData = await stateContract.getStateInfoByIdAndState(id, state);
-            const stateInfo = {
-                id: BigInt(rawData[0]),
-                state: BigInt(rawData[1]),
-                replacedByState: BigInt(rawData[2]),
-                createdAtTimestamp: BigInt(rawData[3]),
-                replacedAtTimestamp: BigInt(rawData[4]),
-                createdAtBlock: BigInt(rawData[5]),
-                replacedAtBlock: BigInt(rawData[6])
-            };
-            return stateInfo;
+        /** get trees meta info from the memory */
+        async getIdentityMerkleTreesInfo(identifier) {
+            return this._data[identifier].map((treeWithInfo) => treeWithInfo.metaInfo);
         }
-        /** {@inheritdoc IStateStorage.publishState} */
-        async publishState(proof, signer) {
-            const stateTransitionPubSig = new StateTransitionPubSignals();
-            stateTransitionPubSig.pubSignalsUnmarshal(byteEncoder$1.encode(JSON.stringify(proof.pub_signals)));
-            const { userId, oldUserState, newUserState, isOldStateGenesis } = stateTransitionPubSig;
-            const { stateContract, provider } = this.getStateContractAndProviderForId(userId.bigInt());
-            const contract = stateContract.connect(signer);
-            const preparedZkpProof = prepareZkpProof(proof.proof);
-            const payload = [
-                userId.bigInt().toString(),
-                oldUserState.bigInt().toString(),
-                newUserState.bigInt().toString(),
-                isOldStateGenesis,
-                preparedZkpProof.a,
-                preparedZkpProof.b,
-                preparedZkpProof.c
-            ];
-            const feeData = await provider.getFeeData();
-            const maxFeePerGas = defaultEthConnectionConfig.maxFeePerGas
-                ? BigInt(defaultEthConnectionConfig.maxFeePerGas)
-                : feeData.maxFeePerGas;
-            const maxPriorityFeePerGas = defaultEthConnectionConfig.maxPriorityFeePerGas
-                ? BigInt(defaultEthConnectionConfig.maxPriorityFeePerGas)
-                : feeData.maxPriorityFeePerGas;
-            const gasLimit = await contract.transitState.estimateGas(...payload);
-            const txData = await contract.transitState.populateTransaction(...payload);
-            const request = {
-                to: txData.to,
-                data: txData.data,
-                gasLimit,
-                maxFeePerGas,
-                maxPriorityFeePerGas
-            };
-            const { txnHash } = await this._transactionService.sendTransactionRequest(signer, request);
-            return txnHash;
+        /** get merkle tree by identifier and type from memory */
+        async getMerkleTreeByIdentifierAndType(identifier, mtType) {
+            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;
         }
-        /** {@inheritdoc IStateStorage.publishStateGeneric} */
-        async publishStateGeneric(signer, userStateTransitionInfo) {
-            const { userId, oldUserState, newUserState, isOldStateGenesis, methodId, methodParams } = userStateTransitionInfo;
-            const { stateContract, provider } = this.getStateContractAndProviderForId(userId.bigInt());
-            const contract = stateContract.connect(signer);
-            const feeData = await provider.getFeeData();
-            const maxFeePerGas = defaultEthConnectionConfig.maxFeePerGas
-                ? BigInt(defaultEthConnectionConfig.maxFeePerGas)
-                : feeData.maxFeePerGas;
-            const maxPriorityFeePerGas = defaultEthConnectionConfig.maxPriorityFeePerGas
-                ? BigInt(defaultEthConnectionConfig.maxPriorityFeePerGas)
-                : feeData.maxPriorityFeePerGas;
-            const payload = [
-                userId.bigInt().toString(),
-                oldUserState.bigInt().toString(),
-                newUserState.bigInt().toString(),
-                isOldStateGenesis,
-                methodId,
-                methodParams //'0x'
-            ];
-            const gasLimit = await contract.transitStateGeneric.estimateGas(...payload);
-            const txData = await contract.transitStateGeneric.populateTransaction(...payload);
-            const request = {
-                to: txData.to,
-                data: txData.data,
-                gasLimit,
-                maxFeePerGas,
-                maxPriorityFeePerGas
-            };
-            const { txnHash } = await this._transactionService.sendTransactionRequest(signer, request);
-            return txnHash;
+        /** adds entry to merkle tree in the memory */
+        async addToMerkleTree(identifier, mtType, hindex, hvalue) {
+            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);
+                }
+            }
         }
-        /** {@inheritdoc IStateStorage.getGISTProof} */
-        async getGISTProof(id) {
-            const { stateContract } = this.getStateContractAndProviderForId(id);
-            const data = await stateContract.getGISTProof(id);
-            return {
-                root: BigInt(data.root.toString()),
-                existence: data.existence,
-                siblings: data.siblings?.map((sibling) => BigInt(sibling.toString())),
-                index: BigInt(data.index.toString()),
-                value: BigInt(data.value.toString()),
-                auxExistence: data.auxExistence,
-                auxIndex: BigInt(data.auxIndex.toString()),
-                auxValue: BigInt(data.auxValue.toString())
-            };
+        /** bind merkle tree identifier in memory */
+        async bindMerkleTreeToNewIdentifier(oldIdentifier, newIdentifier) {
+            this._data[newIdentifier] = [...this._data[oldIdentifier]];
+            delete this._data[oldIdentifier];
+            this._data[newIdentifier].forEach((treeWithMeta) => {
+                treeWithMeta.metaInfo.identifier = newIdentifier;
+            });
         }
-        /** {@inheritdoc IStateStorage.getGISTRootInfo} */
-        async getGISTRootInfo(root, id) {
-            const { stateContract } = this.getStateContractAndProviderForId(id);
-            const data = await stateContract.getGISTRootInfo(root);
-            return {
-                root: BigInt(data.root.toString()),
-                replacedByRoot: BigInt(data.replacedByRoot.toString()),
-                createdAtTimestamp: BigInt(data.createdAtTimestamp.toString()),
-                replacedAtTimestamp: BigInt(data.replacedAtTimestamp.toString()),
-                createdAtBlock: BigInt(data.createdAtBlock.toString()),
-                replacedAtBlock: BigInt(data.replacedAtBlock.toString())
-            };
+    }
+
+    /**
+     * Storage Errors definition
+     *
+     * @enum {number}
+     */
+    var StorageErrors;
+    (function (StorageErrors) {
+        StorageErrors["ItemNotFound"] = "item not found";
+    })(StorageErrors || (StorageErrors = {}));
+
+    /* eslint-disable @typescript-eslint/no-explicit-any */
+    /**
+     * Generic Memory Data Source
+     *
+     * @public
+     * @class InMemoryDataSource - class
+     * @template Type
+     */
+    class InMemoryDataSource {
+        constructor() {
+            this._data = [];
         }
-        /** {@inheritdoc IStateStorage.getRpcProvider} */
-        getRpcProvider() {
-            return this.provider;
+        /** saves in the memory */
+        async save(key, value, keyName = 'id') {
+            const itemIndex = this._data.findIndex((i) => i[keyName] === key);
+            if (itemIndex === -1) {
+                this._data.push(value);
+            }
+            else {
+                this._data[itemIndex] = value;
+            }
         }
-        getStateContractAndProviderForId(id) {
-            const idTyped = Id.fromBigInt(id);
-            const chainId = getChainId(DID.blockchainFromId(idTyped), DID.networkIdFromId(idTyped));
-            const config = this.networkByChainId(chainId);
-            const provider = new JsonRpcProvider(config.url);
-            const stateContract = new Contract(config.contractAddress, abi$3, provider);
-            return { stateContract, provider };
+        /** gets value from from the memory */
+        async get(key, keyName = 'id') {
+            return this._data.find((t) => t[keyName] === key);
         }
-        networkByChainId(chainId) {
-            const config = Array.isArray(this.ethConfig) ? this.ethConfig : [this.ethConfig];
-            const network = config.find((c) => c.chainId === chainId);
-            if (!network) {
-                throw new Error(`chainId "${chainId}" not supported`);
+        /** loads from value from the memory */
+        async load() {
+            return this._data;
+        }
+        /** deletes from value from the memory */
+        async delete(key, keyName = 'id') {
+            const newData = this._data.filter((i) => i[keyName] !== key);
+            if (newData.length === this._data.length) {
+                throw new Error(`${StorageErrors.ItemNotFound} to delete: ${key}`);
             }
-            return network;
+            this._data = newData;
         }
     }
 
+    class QuickLRU extends Map {
+    	#size = 0;
+    	#cache = new Map();
+    	#oldCache = new Map();
+    	#maxSize;
+    	#maxAge;
+    	#onEviction;
+
+    	constructor(options = {}) {
+    		super();
+
+    		if (!(options.maxSize && options.maxSize > 0)) {
+    			throw new TypeError('`maxSize` must be a number greater than 0');
+    		}
+
+    		if (typeof options.maxAge === 'number' && options.maxAge === 0) {
+    			throw new TypeError('`maxAge` must be a number greater than 0');
+    		}
+
+    		this.#maxSize = options.maxSize;
+    		this.#maxAge = options.maxAge || Number.POSITIVE_INFINITY;
+    		this.#onEviction = options.onEviction;
+    	}
+
+    	// For tests.
+    	get __oldCache() {
+    		return this.#oldCache;
+    	}
+
+    	#emitEvictions(cache) {
+    		if (typeof this.#onEviction !== 'function') {
+    			return;
+    		}
+
+    		for (const [key, item] of cache) {
+    			this.#onEviction(key, item.value);
+    		}
+    	}
+
+    	#deleteIfExpired(key, item) {
+    		if (typeof item.expiry === 'number' && item.expiry <= Date.now()) {
+    			if (typeof this.#onEviction === 'function') {
+    				this.#onEviction(key, item.value);
+    			}
+
+    			return this.delete(key);
+    		}
+
+    		return false;
+    	}
+
+    	#getOrDeleteIfExpired(key, item) {
+    		const deleted = this.#deleteIfExpired(key, item);
+    		if (deleted === false) {
+    			return item.value;
+    		}
+    	}
+
+    	#getItemValue(key, item) {
+    		return item.expiry ? this.#getOrDeleteIfExpired(key, item) : item.value;
+    	}
+
+    	#peek(key, cache) {
+    		const item = cache.get(key);
+
+    		return this.#getItemValue(key, item);
+    	}
+
+    	#set(key, value) {
+    		this.#cache.set(key, value);
+    		this.#size++;
+
+    		if (this.#size >= this.#maxSize) {
+    			this.#size = 0;
+    			this.#emitEvictions(this.#oldCache);
+    			this.#oldCache = this.#cache;
+    			this.#cache = new Map();
+    		}
+    	}
+
+    	#moveToRecent(key, item) {
+    		this.#oldCache.delete(key);
+    		this.#set(key, item);
+    	}
+
+    	* #entriesAscending() {
+    		for (const item of this.#oldCache) {
+    			const [key, value] = item;
+    			if (!this.#cache.has(key)) {
+    				const deleted = this.#deleteIfExpired(key, value);
+    				if (deleted === false) {
+    					yield item;
+    				}
+    			}
+    		}
+
+    		for (const item of this.#cache) {
+    			const [key, value] = item;
+    			const deleted = this.#deleteIfExpired(key, value);
+    			if (deleted === false) {
+    				yield item;
+    			}
+    		}
+    	}
+
+    	get(key) {
+    		if (this.#cache.has(key)) {
+    			const item = this.#cache.get(key);
+    			return this.#getItemValue(key, item);
+    		}
+
+    		if (this.#oldCache.has(key)) {
+    			const item = this.#oldCache.get(key);
+    			if (this.#deleteIfExpired(key, item) === false) {
+    				this.#moveToRecent(key, item);
+    				return item.value;
+    			}
+    		}
+    	}
+
+    	set(key, value, {maxAge = this.#maxAge} = {}) {
+    		const expiry = typeof maxAge === 'number' && maxAge !== Number.POSITIVE_INFINITY
+    			? (Date.now() + maxAge)
+    			: undefined;
+
+    		if (this.#cache.has(key)) {
+    			this.#cache.set(key, {
+    				value,
+    				expiry,
+    			});
+    		} else {
+    			this.#set(key, {value, expiry});
+    		}
+
+    		return this;
+    	}
+
+    	has(key) {
+    		if (this.#cache.has(key)) {
+    			return !this.#deleteIfExpired(key, this.#cache.get(key));
+    		}
+
+    		if (this.#oldCache.has(key)) {
+    			return !this.#deleteIfExpired(key, this.#oldCache.get(key));
+    		}
+
+    		return false;
+    	}
+
+    	peek(key) {
+    		if (this.#cache.has(key)) {
+    			return this.#peek(key, this.#cache);
+    		}
+
+    		if (this.#oldCache.has(key)) {
+    			return this.#peek(key, this.#oldCache);
+    		}
+    	}
+
+    	delete(key) {
+    		const deleted = this.#cache.delete(key);
+    		if (deleted) {
+    			this.#size--;
+    		}
+
+    		return this.#oldCache.delete(key) || deleted;
+    	}
+
+    	clear() {
+    		this.#cache.clear();
+    		this.#oldCache.clear();
+    		this.#size = 0;
+    	}
+
+    	resize(newSize) {
+    		if (!(newSize && newSize > 0)) {
+    			throw new TypeError('`maxSize` must be a number greater than 0');
+    		}
+
+    		const items = [...this.#entriesAscending()];
+    		const removeCount = items.length - newSize;
+    		if (removeCount < 0) {
+    			this.#cache = new Map(items);
+    			this.#oldCache = new Map();
+    			this.#size = items.length;
+    		} else {
+    			if (removeCount > 0) {
+    				this.#emitEvictions(items.slice(0, removeCount));
+    			}
+
+    			this.#oldCache = new Map(items.slice(removeCount));
+    			this.#cache = new Map();
+    			this.#size = 0;
+    		}
+
+    		this.#maxSize = newSize;
+    	}
+
+    	* keys() {
+    		for (const [key] of this) {
+    			yield key;
+    		}
+    	}
+
+    	* values() {
+    		for (const [, value] of this) {
+    			yield value;
+    		}
+    	}
+
+    	* [Symbol.iterator]() {
+    		for (const item of this.#cache) {
+    			const [key, value] = item;
+    			const deleted = this.#deleteIfExpired(key, value);
+    			if (deleted === false) {
+    				yield [key, value.value];
+    			}
+    		}
+
+    		for (const item of this.#oldCache) {
+    			const [key, value] = item;
+    			if (!this.#cache.has(key)) {
+    				const deleted = this.#deleteIfExpired(key, value);
+    				if (deleted === false) {
+    					yield [key, value.value];
+    				}
+    			}
+    		}
+    	}
+
+    	* entriesDescending() {
+    		let items = [...this.#cache];
+    		for (let i = items.length - 1; i >= 0; --i) {
+    			const item = items[i];
+    			const [key, value] = item;
+    			const deleted = this.#deleteIfExpired(key, value);
+    			if (deleted === false) {
+    				yield [key, value.value];
+    			}
+    		}
+
+    		items = [...this.#oldCache];
+    		for (let i = items.length - 1; i >= 0; --i) {
+    			const item = items[i];
+    			const [key, value] = item;
+    			if (!this.#cache.has(key)) {
+    				const deleted = this.#deleteIfExpired(key, value);
+    				if (deleted === false) {
+    					yield [key, value.value];
+    				}
+    			}
+    		}
+    	}
+
+    	* entriesAscending() {
+    		for (const [key, value] of this.#entriesAscending()) {
+    			yield [key, value.value];
+    		}
+    	}
+
+    	get size() {
+    		if (!this.#size) {
+    			return this.#oldCache.size;
+    		}
+
+    		let oldCacheSize = 0;
+    		for (const key of this.#oldCache.keys()) {
+    			if (!this.#cache.has(key)) {
+    				oldCacheSize++;
+    			}
+    		}
+
+    		return Math.min(this.#size + oldCacheSize, this.#maxSize);
+    	}
+
+    	get maxSize() {
+    		return this.#maxSize;
+    	}
+
+    	entries() {
+    		return this.entriesAscending();
+    	}
+
+    	forEach(callbackFunction, thisArgument = this) {
+    		for (const [key, value] of this.entriesAscending()) {
+    			callbackFunction.call(thisArgument, value, key, this);
+    		}
+    	}
+
+    	get [Symbol.toStringTag]() {
+    		return 'QuickLRU';
+    	}
+
+    	toString() {
+    		return `QuickLRU(${this.size}/${this.maxSize})`;
+    	}
+
+    	[Symbol.for('nodejs.util.inspect.custom')]() {
+    		return this.toString();
+    	}
+    }
+
+    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);
+            }
+        };
+    }
+
     /**
      * creates empty basic message
      *
@@ -92676,34 +93072,60 @@ var PolygonIdSdk = (function (exports) {
         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}`);
-                }
-                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)}`);
+            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 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(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 = [
+                    VerifiableConstants.ERRORS.PROOF_SERVICE_NO_CREDENTIAL_FOR_IDENTITY_OR_PROFILE,
+                    VerifiableConstants.ERRORS.ID_WALLET_NO_CREDENTIAL_SATISFIED_QUERY,
+                    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(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;
@@ -93573,8 +93995,9 @@ var PolygonIdSdk = (function (exports) {
          * @public
          * @param {Array<EthConnectionConfig>} _configs - list of ethereum network connections
          */
-        constructor(_configs) {
+        constructor(_configs, _opts) {
             this._configs = _configs;
+            this._stateStorage = new EthStateStorage(_configs, _opts?.stateStorageOptions);
         }
         /**
          * resolve is a method to resolve a credential status from the blockchain.
@@ -93605,8 +94028,7 @@ var PolygonIdSdk = (function (exports) {
             const issuerId = 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');
                 }
@@ -93672,13 +94094,6 @@ var PolygonIdSdk = (function (exports) {
             }
             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 = getChainId(DID.blockchainFromId(issuerId), DID.networkIdFromId(issuerId));
-            const ethStorage = new EthStateStorage(this.networkByChainId(issuerChainId));
-            return ethStorage;
-        }
         _getOnChainRevocationStorageForIssuer(chainId, contractAddress) {
             const networkConfig = this.networkByChainId(chainId);
             const onChainCaller = new OnChainRevocationStorage(networkConfig, contractAddress);
@@ -94371,7 +94786,7 @@ var PolygonIdSdk = (function (exports) {
                 }
                 return { cred, revStatus };
             }
-            throw new Error('all claims are revoked');
+            throw new Error(VerifiableConstants.ERRORS.CREDENTIAL_WALLET_ALL_CREDENTIALS_ARE_REVOKED);
         }
     }
 
@@ -95950,6 +96365,300 @@ var PolygonIdSdk = (function (exports) {
         };
     }
 
+    const defaultEthConnectionConfig = {
+        url: 'http://localhost:8545',
+        defaultGasLimit: 600000,
+        minGasPrice: '0',
+        maxGasPrice: '100000000000',
+        confirmationBlockCount: 5,
+        confirmationTimeout: 600000,
+        contractAddress: '',
+        receiptTimeout: 600000,
+        rpcResponseTimeout: 5000,
+        waitReceiptCycleTime: 30000,
+        waitBlockCycleTime: 3000
+    };
+    /**
+     *
+     *
+     * @public
+     * @class EthStateStorage
+     * @implements implements IStateStorage interface
+     */
+    class EthStateStorage {
+        /**
+         * Creates an instance of EthStateStorage.
+         * @param {EthConnectionConfig} [ethConfig=defaultEthConnectionConfig]
+         */
+        constructor(ethConfig, options) {
+            this.ethConfig = ethConfig;
+            this._disableCache = false;
+            const config = Array.isArray(ethConfig) ? ethConfig[0] : ethConfig;
+            this.provider = new JsonRpcProvider(config.url);
+            this.stateContract = new Contract(config.contractAddress, abi$3, this.provider);
+            this._transactionService = new TransactionService(this.getRpcProvider());
+            // Store cache options for later use
+            this._latestStateCacheOptions = {
+                ttl: options?.latestStateCacheOptions?.ttl ?? DEFAULT_PROOF_VERIFY_DELAY / 2,
+                maxSize: options?.latestStateCacheOptions?.maxSize ?? DEFAULT_CACHE_MAX_SIZE
+            };
+            this._stateCacheOptions = {
+                notReplacedTtl: options?.stateCacheOptions?.notReplacedTtl ??
+                    DEFAULT_PROOF_VERIFY_DELAY / 2,
+                replacedTtl: options?.stateCacheOptions?.replacedTtl ?? DEFAULT_PROOF_VERIFY_DELAY,
+                maxSize: options?.stateCacheOptions?.maxSize ?? DEFAULT_CACHE_MAX_SIZE
+            };
+            this._rootCacheOptions = {
+                replacedTtl: options?.rootCacheOptions?.replacedTtl ?? DEFAULT_AUTH_VERIFY_DELAY,
+                notReplacedTtl: options?.rootCacheOptions?.notReplacedTtl ??
+                    DEFAULT_AUTH_VERIFY_DELAY / 2,
+                maxSize: options?.rootCacheOptions?.maxSize ?? DEFAULT_CACHE_MAX_SIZE
+            };
+            this._gistProofCacheOptions = {
+                ttl: DEFAULT_AUTH_VERIFY_DELAY / 2,
+                maxSize: options?.gistProofCacheOptions?.maxSize ?? DEFAULT_CACHE_MAX_SIZE
+            };
+            // Initialize cache instances
+            this._latestStateResolveCache =
+                options?.latestStateCacheOptions?.cache ??
+                    createInMemoryCache({
+                        maxSize: this._latestStateCacheOptions.maxSize,
+                        ttl: this._latestStateCacheOptions.ttl
+                    });
+            this._stateResolveCache =
+                options?.stateCacheOptions?.cache ??
+                    createInMemoryCache({
+                        maxSize: this._stateCacheOptions.maxSize,
+                        ttl: this._stateCacheOptions.replacedTtl
+                    });
+            this._rootResolveCache =
+                options?.rootCacheOptions?.cache ??
+                    createInMemoryCache({
+                        maxSize: this._rootCacheOptions.maxSize,
+                        ttl: this._rootCacheOptions.replacedTtl
+                    });
+            this._gistProofResolveCache =
+                options?.gistProofCacheOptions?.cache ??
+                    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 = {
+                id: BigInt(rawData[0]),
+                state: BigInt(rawData[1]),
+                replacedByState: BigInt(rawData[2]),
+                createdAtTimestamp: BigInt(rawData[3]),
+                replacedAtTimestamp: BigInt(rawData[4]),
+                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 = {
+                id: BigInt(rawData[0]),
+                state: BigInt(rawData[1]),
+                replacedByState: BigInt(rawData[2]),
+                createdAtTimestamp: BigInt(rawData[3]),
+                replacedAtTimestamp: BigInt(rawData[4]),
+                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} */
+        async publishState(proof, signer) {
+            const stateTransitionPubSig = new StateTransitionPubSignals();
+            stateTransitionPubSig.pubSignalsUnmarshal(byteEncoder$1.encode(JSON.stringify(proof.pub_signals)));
+            const { userId, oldUserState, newUserState, isOldStateGenesis } = stateTransitionPubSig;
+            const { stateContract, provider } = this.getStateContractAndProviderForId(userId.bigInt());
+            const contract = stateContract.connect(signer);
+            const preparedZkpProof = prepareZkpProof(proof.proof);
+            const payload = [
+                userId.bigInt().toString(),
+                oldUserState.bigInt().toString(),
+                newUserState.bigInt().toString(),
+                isOldStateGenesis,
+                preparedZkpProof.a,
+                preparedZkpProof.b,
+                preparedZkpProof.c
+            ];
+            const feeData = await provider.getFeeData();
+            const maxFeePerGas = defaultEthConnectionConfig.maxFeePerGas
+                ? BigInt(defaultEthConnectionConfig.maxFeePerGas)
+                : feeData.maxFeePerGas;
+            const maxPriorityFeePerGas = defaultEthConnectionConfig.maxPriorityFeePerGas
+                ? BigInt(defaultEthConnectionConfig.maxPriorityFeePerGas)
+                : feeData.maxPriorityFeePerGas;
+            const gasLimit = await contract.transitState.estimateGas(...payload);
+            const txData = await contract.transitState.populateTransaction(...payload);
+            const request = {
+                to: txData.to,
+                data: txData.data,
+                gasLimit,
+                maxFeePerGas,
+                maxPriorityFeePerGas
+            };
+            const { txnHash } = await this._transactionService.sendTransactionRequest(signer, request);
+            return txnHash;
+        }
+        /** {@inheritdoc IStateStorage.publishStateGeneric} */
+        async publishStateGeneric(signer, userStateTransitionInfo) {
+            const { userId, oldUserState, newUserState, isOldStateGenesis, methodId, methodParams } = userStateTransitionInfo;
+            const { stateContract, provider } = this.getStateContractAndProviderForId(userId.bigInt());
+            const contract = stateContract.connect(signer);
+            const feeData = await provider.getFeeData();
+            const maxFeePerGas = defaultEthConnectionConfig.maxFeePerGas
+                ? BigInt(defaultEthConnectionConfig.maxFeePerGas)
+                : feeData.maxFeePerGas;
+            const maxPriorityFeePerGas = defaultEthConnectionConfig.maxPriorityFeePerGas
+                ? BigInt(defaultEthConnectionConfig.maxPriorityFeePerGas)
+                : feeData.maxPriorityFeePerGas;
+            const payload = [
+                userId.bigInt().toString(),
+                oldUserState.bigInt().toString(),
+                newUserState.bigInt().toString(),
+                isOldStateGenesis,
+                methodId,
+                methodParams //'0x'
+            ];
+            const gasLimit = await contract.transitStateGeneric.estimateGas(...payload);
+            const txData = await contract.transitStateGeneric.populateTransaction(...payload);
+            const request = {
+                to: txData.to,
+                data: txData.data,
+                gasLimit,
+                maxFeePerGas,
+                maxPriorityFeePerGas
+            };
+            const { txnHash } = await this._transactionService.sendTransactionRequest(signer, request);
+            return txnHash;
+        }
+        /** {@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);
+            const stateProof = {
+                root: BigInt(data.root.toString()),
+                existence: data.existence,
+                siblings: data.siblings?.map((sibling) => BigInt(sibling.toString())),
+                index: BigInt(data.index.toString()),
+                value: BigInt(data.value.toString()),
+                auxExistence: data.auxExistence,
+                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);
+            const rootInfo = {
+                root: BigInt(data.root.toString()),
+                replacedByRoot: BigInt(data.replacedByRoot.toString()),
+                createdAtTimestamp: BigInt(data.createdAtTimestamp.toString()),
+                replacedAtTimestamp: BigInt(data.replacedAtTimestamp.toString()),
+                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 = Id.fromBigInt(id);
+            const chainId = getChainId(DID.blockchainFromId(idTyped), DID.networkIdFromId(idTyped));
+            const config = this.networkByChainId(chainId);
+            const provider = new JsonRpcProvider(config.url);
+            const stateContract = new Contract(config.contractAddress, abi$3, provider);
+            return { stateContract, provider };
+        }
+        networkByChainId(chainId) {
+            const config = Array.isArray(this.ethConfig) ? this.ethConfig : [this.ethConfig];
+            const network = config.find((c) => c.chainId === chainId);
+            if (!network) {
+                throw new Error(`chainId "${chainId}" not supported`);
+            }
+            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();
+        }
+    }
+
     var abi$1 = [
     	{
     		inputs: [
@@ -97285,7 +97994,7 @@ var PolygonIdSdk = (function (exports) {
     					},
     					{
     						internalType: "address",
-    						name: "owner",
+    						name: "creator",
     						type: "address"
     					}
     				],
@@ -100449,21 +101158,6 @@ var PolygonIdSdk = (function (exports) {
         return erc20Contract.decimals();
     }
 
-    /**
-     * Type of MerkleTree
-     *
-     * @enum {number}
-     */
-    exports.MerkleTreeType = void 0;
-    (function (MerkleTreeType) {
-        // Claims is merkle tree type for claims tree
-        MerkleTreeType[MerkleTreeType["Claims"] = 0] = "Claims";
-        // Revocations is merkle tree type for revocations tree
-        MerkleTreeType[MerkleTreeType["Revocations"] = 1] = "Revocations";
-        // Roots is merkle tree type for roots tree
-        MerkleTreeType[MerkleTreeType["Roots"] = 2] = "Roots";
-    })(exports.MerkleTreeType || (exports.MerkleTreeType = {}));
-
     /**
      * search errors
      *
@@ -100734,136 +101428,6 @@ var PolygonIdSdk = (function (exports) {
                     ? exports.SupportedDataFormat.Boolean
                     : exports.SupportedDataFormat.String;
 
-    const MERKLE_TREE_TYPES = [
-        exports.MerkleTreeType.Claims,
-        exports.MerkleTreeType.Revocations,
-        exports.MerkleTreeType.Roots
-    ];
-    const createMerkleTreeMetaInfo = (identifier) => {
-        const treesMeta = [];
-        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;
-    };
-
-    /**
-     *
-     *
-     * @public
-     * @class InMemoryMerkleTreeStorage
-     * @implements implements IMerkleTreeStorage interface
-     */
-    class InMemoryMerkleTreeStorage {
-        /**
-         * Creates an instance of InMemoryMerkleTreeStorage.
-         * @param {number} _mtDepth
-         */
-        constructor(_mtDepth) {
-            this.mtDepth = _mtDepth;
-            this._data = {};
-        }
-        /** create trees in the  memory*/
-        async createIdentityMerkleTrees(identifier) {
-            if (!identifier) {
-                identifier = `${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 = [];
-            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) {
-            return this._data[identifier].map((treeWithInfo) => treeWithInfo.metaInfo);
-        }
-        /** get merkle tree by identifier and type from memory */
-        async getMerkleTreeByIdentifierAndType(identifier, mtType) {
-            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, mtType, hindex, hvalue) {
-            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, newIdentifier) {
-            this._data[newIdentifier] = [...this._data[oldIdentifier]];
-            delete this._data[oldIdentifier];
-            this._data[newIdentifier].forEach((treeWithMeta) => {
-                treeWithMeta.metaInfo.identifier = newIdentifier;
-            });
-        }
-    }
-
-    /**
-     * Storage Errors definition
-     *
-     * @enum {number}
-     */
-    var StorageErrors;
-    (function (StorageErrors) {
-        StorageErrors["ItemNotFound"] = "item not found";
-    })(StorageErrors || (StorageErrors = {}));
-
-    /* eslint-disable @typescript-eslint/no-explicit-any */
-    /**
-     * Generic Memory Data Source
-     *
-     * @public
-     * @class InMemoryDataSource - class
-     * @template Type
-     */
-    class InMemoryDataSource {
-        constructor() {
-            this._data = [];
-        }
-        /** saves in the memory */
-        async save(key, value, keyName = 'id') {
-            const itemIndex = this._data.findIndex((i) => i[keyName] === key);
-            if (itemIndex === -1) {
-                this._data.push(value);
-            }
-            else {
-                this._data[itemIndex] = value;
-            }
-        }
-        /** gets value from from the memory */
-        async get(key, keyName = 'id') {
-            return this._data.find((t) => t[keyName] === key);
-        }
-        /** loads from value from the memory */
-        async load() {
-            return this._data;
-        }
-        /** deletes from value from the memory */
-        async delete(key, keyName = 'id') {
-            const newData = this._data.filter((i) => i[keyName] !== key);
-            if (newData.length === this._data.length) {
-                throw new Error(`${StorageErrors.ItemNotFound} to delete: ${key}`);
-            }
-            this._data = newData;
-        }
-    }
-
     /* eslint-disable @typescript-eslint/no-explicit-any */
     /**
      * Storage in the browser, uses local storage
@@ -101315,9 +101879,16 @@ var PolygonIdSdk = (function (exports) {
                 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);
         }
@@ -102524,6 +103095,26 @@ var PolygonIdSdk = (function (exports) {
         }
         return await value.mtEntry();
     };
+    function calculateGroupId(requestIds) {
+        const types = Array(requestIds.length).fill('uint256');
+        const groupID = BigInt(keccak256(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;
+    }
+    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(keccak256(solidityPacked(['bytes', 'address'], [requestParams, creatorAddress]))) &
+            BigInt('0x0000000000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF')) +
+            BigInt('0x0001000000000000000000000000000000000000000000000000000000000000');
+        return requestId;
+    }
+    function calculateMultiRequestId(requestIds, groupIds, creatorAddress) {
+        return BigInt(keccak256(solidityPacked(['uint256[]', 'uint256[]', 'address'], [requestIds, groupIds, creatorAddress])));
+    }
 
     function calculateQueryHashV2(values, schema, slotIndex, operator, claimPathKey, claimPathNotExists) {
         const expValue = prepareCircuitArrayValues(values, 64);
@@ -103057,7 +103648,8 @@ var PolygonIdSdk = (function (exports) {
                 credentialWithRevStatus = { cred: opts.credential, revStatus };
             }
             if (!credentialWithRevStatus.cred) {
-                throw new Error(`credential not found for query ${JSON.stringify(proofReq.query)}`);
+                throw new Error(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);
@@ -103069,11 +103661,11 @@ var PolygonIdSdk = (function (exports) {
             const subjectDID = 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(VerifiableConstants.ERRORS.PROOF_SERVICE_PROFILE_GENESIS_DID_MISMATCH);
             }
             const propertiesMetadata = parseCredentialSubject(proofReq.query.credentialSubject);
             if (!propertiesMetadata.length) {
-                throw new Error('no queries in zkp request');
+                throw new Error(VerifiableConstants.ERRORS.PROOF_SERVICE_NO_QUERIES_IN_ZKP_REQUEST);
             }
             const mtPosition = preparedCredential.credentialCoreClaim.getMerklizedPosition();
             let mk;
@@ -103257,7 +103849,7 @@ var PolygonIdSdk = (function (exports) {
         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(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
@@ -103456,7 +104048,7 @@ var PolygonIdSdk = (function (exports) {
             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(VerifiableConstants.ERRORS.ID_WALLET_SIGNER_IS_REQUIRED);
             }
             const currentState = ZERO_HASH; // In Ethereum identities we don't have an initial state with the auth credential
             const didType = buildDIDType(opts.method || DidMethod.Iden3, opts.blockchain || Blockchain.Polygon, opts.networkId || NetworkId.Amoy);
@@ -103494,23 +104086,28 @@ var PolygonIdSdk = (function (exports) {
             }
             const profile = await this._storage.identity.getProfileById(did.string());
             if (!profile) {
-                throw new Error('profile or identity not found');
+                throw new Error(VerifiableConstants.ERRORS.ID_WALLET_PROFILE_OR_IDENTITY_NOT_FOUND);
             }
             return { nonce: profile.nonce, genesisDID: DID.parse(profile.genesisIdentifier) };
         }
         /** {@inheritDoc IIdentityWallet.createProfile} */
-        async createProfile(did, nonce, verifier) {
+        async createProfile(did, nonce, verifier, tags) {
             const profileDID = 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(VerifiableConstants.ERRORS.ID_WALLET_PROFILE_ALREADY_EXISTS_VERIFIER_TAGS);
+            }
+            const existingProfileWithNonce = identityProfiles.find((p) => p.nonce == nonce);
+            if (existingProfileWithNonce) {
+                throw new Error(VerifiableConstants.ERRORS.ID_WALLET_PROFILE_ALREADY_EXISTS);
             }
             await this._storage.identity.saveProfile({
                 id: profileDID.string(),
                 nonce,
                 genesisIdentifier: did.string(),
-                verifier
+                verifier,
+                tags
             });
             return profileDID;
         }
@@ -103529,9 +104126,17 @@ var PolygonIdSdk = (function (exports) {
             const key = await this._kms.createKeyFromSeed(keyType, N$2(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();
@@ -103653,11 +104258,11 @@ var PolygonIdSdk = (function (exports) {
             const coreClaimHash = z$2.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(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(VerifiableConstants.ERRORS.ID_WALLET_ISSUER_AUTH_BJJ_CRED_MUST_HAVE_MTP_PROOF);
             }
             const sigProof = new BJJSignatureProof2021({
                 issuerData: {
@@ -103697,7 +104302,7 @@ var PolygonIdSdk = (function (exports) {
             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(VerifiableConstants.ERRORS.ID_WALLET_CORE_CLAIM_REQUIRED_IN_ANY_PROOF);
             }
             const nonce = coreClaim.getRevocationNonce();
             await issuerTree.revocationTree.add(nonce, BigInt(0));
@@ -103720,7 +104325,7 @@ var PolygonIdSdk = (function (exports) {
                 // credential must have a bjj signature proof
                 const coreClaim = credential.getCoreClaimFromProof(exports.ProofType.BJJSignature);
                 if (!coreClaim) {
-                    throw new Error('credential must have coreClaim representation in the signature proof');
+                    throw new Error(VerifiableConstants.ERRORS.ID_WALLET_CORE_CLAIM_REQUIRED_IN_SIG_PROOF);
                 }
                 await this._storage.mt.addToMerkleTree(issuerDID.string(), exports.MerkleTreeType.Claims, coreClaim.hIndex(), coreClaim.hValue());
             }
@@ -103752,7 +104357,7 @@ var PolygonIdSdk = (function (exports) {
                 const coreClaim = credential.getCoreClaimFromProof(exports.ProofType.BJJSignature) ||
                     (await credential.toCoreClaim(opts));
                 if (!coreClaim) {
-                    throw new Error('credential must have coreClaim representation in the signature proof');
+                    throw new Error(VerifiableConstants.ERRORS.ID_WALLET_CORE_CLAIM_REQUIRED_IN_SIG_PROOF);
                 }
                 const mtpWithProof = await this.generateCoreClaimMtp(issuerDID, coreClaim, treeState);
                 const mtpProof = new Iden3SparseMerkleTreeProof({
@@ -103820,10 +104425,10 @@ var PolygonIdSdk = (function (exports) {
             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(VerifiableConstants.ERRORS.ID_WALLET_CORE_CLAIM_MISMATCH);
             }
             if (!coreClaimFromMtpProof && !coreClaimFromSigProof) {
-                throw new Error('core claim is not set in credential proofs');
+                throw new Error(VerifiableConstants.ERRORS.ID_WALLET_CORE_CLAIM_IS_NOT_SET);
             }
             //eslint-disable-next-line  @typescript-eslint/no-non-null-assertion
             const coreClaim = coreClaimFromMtpProof ?? coreClaimFromSigProof;
@@ -103832,7 +104437,7 @@ var PolygonIdSdk = (function (exports) {
         async findOwnedCredentialsByDID(did, query) {
             const credentials = await this._credentialWallet.findByQuery(query);
             if (!credentials.length) {
-                throw new Error(`no credential satisfied query`);
+                throw new Error(VerifiableConstants.ERRORS.ID_WALLET_NO_CREDENTIAL_SATISFIED_QUERY);
             }
             const { genesisDID } = await this.getGenesisDIDMetadata(did);
             const profiles = await this.getProfilesByDID(genesisDID);
@@ -103872,7 +104477,7 @@ var PolygonIdSdk = (function (exports) {
             let txId;
             if (!isEthIdentity) {
                 if (!prover) {
-                    throw new Error('prover is required to generate proofs for non ethereum identities');
+                    throw new Error(VerifiableConstants.ERRORS.ID_WALLET_PROVER_IS_REQUIRED);
                 }
                 // generate the proof
                 const authInfo = await this._inputsGenerator.prepareAuthBJJCredential(did, oldTreeState);
@@ -104019,6 +104624,7 @@ var PolygonIdSdk = (function (exports) {
     exports.CredentialStatusResolverRegistry = CredentialStatusResolverRegistry;
     exports.CredentialStorage = CredentialStorage;
     exports.CredentialWallet = CredentialWallet;
+    exports.DEFAULT_CACHE_MAX_SIZE = DEFAULT_CACHE_MAX_SIZE;
     exports.DIDDocumentJSONSchema = DIDDocumentJSONSchema;
     exports.DataPrepareHandlerFunc = DataPrepareHandlerFunc;
     exports.DidDocumentCredentialStatusResolver = DidDocumentCredentialStatusResolver;
@@ -104113,8 +104719,11 @@ var PolygonIdSdk = (function (exports) {
     exports.cacheLoader = cacheLoader;
     exports.calcChallengeAuthV2 = calcChallengeAuthV2;
     exports.calculateCoreSchemaHash = calculateCoreSchemaHash;
+    exports.calculateGroupId = calculateGroupId;
+    exports.calculateMultiRequestId = calculateMultiRequestId;
     exports.calculateQueryHashV2 = calculateQueryHashV2;
     exports.calculateQueryHashV3 = calculateQueryHashV3;
+    exports.calculateRequestId = calculateRequestId;
     exports.checkCircuitOperator = checkCircuitOperator;
     exports.checkCircuitQueriesLength = checkCircuitQueriesLength;
     exports.checkDataInField = checkDataInField;
@@ -104126,6 +104735,7 @@ var PolygonIdSdk = (function (exports) {
     exports.createAuthorizationRequestWithMessage = createAuthorizationRequestWithMessage;
     exports.createDiscoveryFeatureDiscloseMessage = createDiscoveryFeatureDiscloseMessage;
     exports.createDiscoveryFeatureQueryMessage = createDiscoveryFeatureQueryMessage;
+    exports.createInMemoryCache = createInMemoryCache;
     exports.createPayment = createPayment;
     exports.createPaymentRequest = createPaymentRequest;
     exports.createProblemReportMessage = createProblemReportMessage;