@0xpolygonid/js-sdk 1.31.1 → 1.31.3

package/dist/browser/umd/index.js

@@ -11399,6 +11399,7 @@ var PolygonIdSdk = (function (exports) {
             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
@@ -11580,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
@@ -70843,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
      *
@@ -93705,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.
@@ -93737,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');
                 }
@@ -93804,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);
@@ -96082,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: [
@@ -97417,7 +97994,7 @@ var PolygonIdSdk = (function (exports) {
     					},
     					{
     						internalType: "address",
-    						name: "owner",
+    						name: "creator",
     						type: "address"
     					}
     				],
@@ -100581,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
      *
@@ -100866,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
@@ -101447,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);
         }
@@ -103652,18 +104091,23 @@ var PolygonIdSdk = (function (exports) {
             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) {
+            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;
         }
@@ -103682,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();
@@ -104172,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;
@@ -104282,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;