@0xpolygonid/js-sdk 1.31.1 → 1.31.3

package/dist/browser/esm/index.js

@@ -5,7 +5,7 @@ import { Path, Merklizer, getDocumentLoader } from '@iden3/js-jsonld-merklizatio
 import * as jsJsonldMerklization from '@iden3/js-jsonld-merklization';
 export { jsJsonldMerklization as jsonLDMerklizer };
 import { base58ToBytes as base58ToBytes$2, base58FromBytes, Hex, PrivateKey, PublicKey, Signature as Signature$1, sha256 as sha256$5, poseidon, getRandomBytes, Poseidon } from '@iden3/js-crypto';
-import { Hash as Hash$2, Proof, verifyProof, rootFromProof, ZERO_HASH, swapEndianness as swapEndianness$1, testBit, NodeLeaf, NODE_TYPE_LEAF, hashElems, Merkletree, InMemoryDB, str2Bytes, LocalStorageDB, IndexedDBStorage } from '@iden3/js-merkletree';
+import { Hash as Hash$2, Proof, verifyProof, rootFromProof, ZERO_HASH, swapEndianness as swapEndianness$1, Merkletree, InMemoryDB, str2Bytes, testBit, NodeLeaf, NODE_TYPE_LEAF, hashElems, LocalStorageDB, IndexedDBStorage } from '@iden3/js-merkletree';
 import { proving, Token, Header, ProvingMethodAlg, verifyGroth16Proof } from '@iden3/js-jwz';
 import { groth16 } from 'snarkjs';
 import { getCurveFromName } from 'ffjavascript';
@@ -8266,6 +8266,7 @@ const VerifiableConstants = Object.freeze({
         ID_WALLET_CORE_CLAIM_IS_NOT_SET: 'core claim is not set in credential proofs',
         ID_WALLET_PROFILE_OR_IDENTITY_NOT_FOUND: 'profile or identity not found',
         ID_WALLET_PROFILE_ALREADY_EXISTS: 'profile with given nonce or verifier already exists',
+        ID_WALLET_PROFILE_ALREADY_EXISTS_VERIFIER_TAGS: 'profile with given verifier and tags already exists',
         ID_WALLET_ISSUER_AUTH_BJJ_CRED_MUST_HAVE_ANY_PROOF: 'issuer auth credential must have proof',
         ID_WALLET_ISSUER_AUTH_BJJ_CRED_MUST_HAVE_MTP_PROOF: 'mtp is required for auth bjj key to issue new credentials',
         // proof service
@@ -8447,6 +8448,10 @@ var DisplayMethodType;
 (function (DisplayMethodType) {
     DisplayMethodType["Iden3BasicDisplayMethodV1"] = "Iden3BasicDisplayMethodV1";
 })(DisplayMethodType || (DisplayMethodType = {}));
+/**
+ * Default cache max size for in-memory cache
+ */
+const DEFAULT_CACHE_MAX_SIZE = 10000;
 
 /**
  * Iden3SparseMerkleProof is a iden3 protocol merkle tree proof
@@ -54316,186 +54321,471 @@ const prepareZkpProof = (proof) => {
     };
 };
 
-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}
+ */
+var MerkleTreeType;
+(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";
+})(MerkleTreeType || (MerkleTreeType = {}));
+
+const MERKLE_TREE_TYPES = [
+    MerkleTreeType.Claims,
+    MerkleTreeType.Revocations,
+    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.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
  *
@@ -56397,8 +56687,9 @@ class OnChainResolver {
      * @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.
@@ -56429,8 +56720,7 @@ class OnChainResolver {
         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');
             }
@@ -56496,13 +56786,6 @@ class OnChainResolver {
         }
         return network;
     }
-    // TODO: is dirty hack for mock in tests.
-    // need to pass to constructor list of state stores not list of network configs
-    _getStateStorageForIssuer(issuerId) {
-        const issuerChainId = 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);
@@ -58774,6 +59057,300 @@ function createProblemReportMessage(pthid, code, opts) {
     };
 }
 
+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.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: [
@@ -60109,7 +60686,7 @@ var IVerifierABI = [
 					},
 					{
 						internalType: "address",
-						name: "owner",
+						name: "creator",
 						type: "address"
 					}
 				],
@@ -63273,21 +63850,6 @@ async function getERC20Decimals(tokenAddress, runner) {
     return erc20Contract.decimals();
 }
 
-/**
- * Type of MerkleTree
- *
- * @enum {number}
- */
-var MerkleTreeType;
-(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";
-})(MerkleTreeType || (MerkleTreeType = {}));
-
 /**
  * search errors
  *
@@ -63558,136 +64120,6 @@ const detectDataFormat = (s) => regExBigInt.test(s)
                 ? SupportedDataFormat.Boolean
                 : SupportedDataFormat.String;
 
-const MERKLE_TREE_TYPES = [
-    MerkleTreeType.Claims,
-    MerkleTreeType.Revocations,
-    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
@@ -64139,9 +64571,16 @@ class IdentityStorage {
             await this._profileDataSource.save(element.id, element);
         }
     }
+    /**
+     *  @deprecated The method should not be used. It returns only one profile per verifier, which can potentially restrict business use cases
+     *   Use getProfilesByVerifier instead.
+     */
     async getProfileByVerifier(verifier) {
         return this._profileDataSource.get(verifier, 'verifier');
     }
+    async getProfilesByVerifier(verifier, tags) {
+        return (await this._profileDataSource.load()).filter((p) => p.verifier === verifier && (!tags || tags.every((tag) => p.tags?.includes(tag))));
+    }
     async getProfileById(profileId) {
         return this._profileDataSource.get(profileId);
     }
@@ -66344,18 +66783,23 @@ class IdentityWallet {
         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;
     }
@@ -66374,9 +66818,17 @@ class IdentityWallet {
         const key = await this._kms.createKeyFromSeed(keyType, getRandomBytes(32));
         return key;
     }
+    /**
+     * @deprecated The method should not be used. It returns only one profile per verifier, which can potentially restrict business use cases
+     * {@inheritDoc IIdentityWallet.getProfileByVerifier}
+     */
     async getProfileByVerifier(verifier) {
         return this._storage.identity.getProfileByVerifier(verifier);
     }
+    /** {@inheritDoc IIdentityWallet.getProfilesByVerifier} */
+    async getProfilesByVerifier(verifier, tags) {
+        return this._storage.identity.getProfilesByVerifier(verifier, tags);
+    }
     /** {@inheritDoc IIdentityWallet.getDIDTreeModel} */
     async getDIDTreeModel(did) {
         const didStr = did.string();
@@ -66833,5 +67285,5 @@ class IdentityWallet {
     }
 }
 
-export { AbstractMessageHandler, AbstractPrivateKeyStore, AgentResolver, AtomicQueryMTPV2Inputs, AtomicQueryMTPV2OnChainInputs, AtomicQueryMTPV2OnChainPubSignals, AtomicQueryMTPV2PubSignals, AtomicQuerySigV2Inputs, AtomicQuerySigV2OnChainCircuitInputs, AtomicQuerySigV2OnChainInputs, AtomicQuerySigV2OnChainPubSignals, AtomicQuerySigV2PubSignals, AtomicQueryV3Inputs, AtomicQueryV3OnChainInputs, AtomicQueryV3OnChainPubSignals, AtomicQueryV3PubSignals, AuthHandler, AuthMethod, AuthV2Inputs, AuthV2PubSignals, BJJSignatureProof2021, BaseConfig, BjjProvider, BrowserDataSource, CircuitClaim, CircuitError, CircuitId, CircuitStorage, ContractRequestHandler, CredentialOfferStatus, CredentialProposalHandler, CredentialStatusPublisherRegistry, CredentialStatusResolverRegistry, CredentialStatusType, CredentialStorage, CredentialWallet, DIDDocumentJSONSchema, DIDDocumentSignature, DataPrepareHandlerFunc, DidDocumentCredentialStatusResolver, DidResolverStateReadonlyStorage, DiscoverFeatureQueryType, DiscoveryProtocolFeatureType, DiscoveryProtocolHandler, DisplayMethodType, Ed25519Provider, ErrorEmptyAuthClaimNonRevProof, ErrorEmptyAuthClaimProof, ErrorEmptyChallengeSignature, ErrorEmptyClaimNonRevProof, ErrorEmptyClaimProof, ErrorEmptyClaimSignature, ErrorEmptyIssuerAuthClaimNonRevProof, ErrorEmptyIssuerAuthClaimProof, ErrorUserStateInRelayClaimProof, EthStateStorage, FSCircuitStorage, FetchHandler, FilterQuery, FunctionSignatures, Iden3OnchainSmtCredentialStatusPublisher, Iden3SmtRhsCredentialStatusPublisher, Iden3SparseMerkleTreeProof, IdentityStorage, IdentityWallet, InMemoryDataSource, InMemoryMerkleTreeStorage, InMemoryPrivateKeyStore, IndexedDBDataSource, IndexedDBPrivateKeyStore, InputGenerator, IssuerResolver, JSON_SCHEMA_VALIDATORS_REGISTRY, JWSPacker, JsonSchemaValidator, KMS, KmsKeyType, LDParser, LinkedMultiQueryInputs, LinkedMultiQueryPubSignals, LocalStoragePrivateKeyStore, MerkleTreeIndexedDBStorage, MerkleTreeLocalStorage, MerkleTreeType, MerklizedRootPosition, MessageBus, MessageHandler, NativeProver, OnChainResolver, OnChainRevocationStorage, OnChainZKPVerifier, OnchainIssuer, Operators, constants as PROTOCOL_CONSTANTS, PackageManager, Parser, PaymentFeatures, PaymentHandler, PaymentRequestDataType, PaymentType, PlainPacker, ProofNode, ProofPurpose, ProofService, ProofType, PubSignalsVerifier, Query, QueryOperators, RHSResolver, RefreshHandler, RefreshServiceType, RevocationStatusHandler, SDK_EVENTS, Scalar, SearchError, Sec256k1Provider, StandardJSONCredentialsQueryFilter, StateTransitionInputs, StateTransitionPubSignals, SubjectPosition, SupportedCurrencies, SupportedDataFormat, SupportedPaymentProofType, TransactionService, ValueProof, Vector, VerifiableConstants, VerificationHandlerFunc, W3CCredential, XSDNS, ZKPPacker, availableTypesOperators, base58ToBytes$1 as base58ToBytes, base64ToBytes$1 as base64ToBytes, base64UrlToBytes, bigIntArrayToStringArray, bigIntCompare, buildAccept, buildDIDFromEthPubKey, buildFieldPath, buildTreeState, buildVerifierId, byteDecoder, byteEncoder, bytesToBase58$1 as bytesToBase58, bytesToBase64, bytesToBase64url$1 as bytesToBase64url, bytesToHex$3 as bytesToHex, cacheLoader, calcChallengeAuthV2, calculateCoreSchemaHash, calculateGroupId, calculateMultiRequestId, calculateQueryHashV2, calculateQueryHashV3, calculateRequestId, checkCircuitOperator, checkCircuitQueriesLength, checkDataInField, checkQueryRequest, circuitValidator, comparatorOptions, createAuthorizationRequest, createAuthorizationRequestWithMessage, createDiscoveryFeatureDiscloseMessage, createDiscoveryFeatureQueryMessage, createPayment, createPaymentRequest, createProblemReportMessage, createProposal, createProposalRequest, createSchemaHash, createVerifiablePresentation, credentialSubjectKey, dataFillsSlot, decodeBase64url$1 as decodeBase64url, defaultEthConnectionConfig, defaultMTLevels, defaultMTLevelsClaim, defaultMTLevelsOnChain, defaultValueArraySize, defineMerklizedRootPosition, encodeBase64url, existenceToInt, extractProof, extractPublicKeyBytes, factoryComparer, fieldToByteArray, fieldValueFromVerifiablePresentation, fillCoreClaimSlot, fillSlot, findCredentialType, findValue, generateProfileDID, getERC20Decimals, getFieldSlotIndex, getKMSIdByAuthCredential, getNodeAuxValue, getNodesRepresentation, getOperatorNameByValue, getPermitSignature, getProperties, getSerializationAttrFromContext, getSerializationAttrFromParsedContext, getUserDIDFromCredential, hexToBytes$3 as hexToBytes, isEthereumIdentity, isGenesisState, isGenesisStateId, isIssuerGenesis, isValidOperation, keyPath, mergeObjects, packEthIdentityProof, packMetadatas, parseAcceptProfile, parseCoreClaimSlots, parseCredentialSubject, parseQueriesMetadata, parseQueryMetadata, parseSerializationAttr, prepareCircuitArrayValues, prepareSiblingsStr, processProofAuth, processProofResponse, processZeroKnowledgeProofRequests, pushHashesToRHS, resolveDIDDocumentAuth, resolveDidDocument, resolvePath, resolveVerificationMethods, strMTHex, stringByPath, subjectPositionIndex, swapEndianness, toClaimNonRevStatus, toGISTProof, toRevocationStatus, toTxDataArgs, transformQueryValueToBigInts, userStateError, validateDIDDocumentAuth, validateDisclosureNativeSDSupport, validateDisclosureV2Circuit, validateEmptyCredentialSubjectNoopNativeSupport, validateEmptyCredentialSubjectV2Circuit, validateOperators, validateTreeState, verifyEIP712TypedData, verifyExpiresTime, verifyFieldValueInclusionNativeExistsSupport, verifyFieldValueInclusionV2, witnessBuilder };
+export { AbstractMessageHandler, AbstractPrivateKeyStore, AgentResolver, AtomicQueryMTPV2Inputs, AtomicQueryMTPV2OnChainInputs, AtomicQueryMTPV2OnChainPubSignals, AtomicQueryMTPV2PubSignals, AtomicQuerySigV2Inputs, AtomicQuerySigV2OnChainCircuitInputs, AtomicQuerySigV2OnChainInputs, AtomicQuerySigV2OnChainPubSignals, AtomicQuerySigV2PubSignals, AtomicQueryV3Inputs, AtomicQueryV3OnChainInputs, AtomicQueryV3OnChainPubSignals, AtomicQueryV3PubSignals, AuthHandler, AuthMethod, AuthV2Inputs, AuthV2PubSignals, BJJSignatureProof2021, BaseConfig, BjjProvider, BrowserDataSource, CircuitClaim, CircuitError, CircuitId, CircuitStorage, ContractRequestHandler, CredentialOfferStatus, CredentialProposalHandler, CredentialStatusPublisherRegistry, CredentialStatusResolverRegistry, CredentialStatusType, CredentialStorage, CredentialWallet, DEFAULT_CACHE_MAX_SIZE, DIDDocumentJSONSchema, DIDDocumentSignature, DataPrepareHandlerFunc, DidDocumentCredentialStatusResolver, DidResolverStateReadonlyStorage, DiscoverFeatureQueryType, DiscoveryProtocolFeatureType, DiscoveryProtocolHandler, DisplayMethodType, Ed25519Provider, ErrorEmptyAuthClaimNonRevProof, ErrorEmptyAuthClaimProof, ErrorEmptyChallengeSignature, ErrorEmptyClaimNonRevProof, ErrorEmptyClaimProof, ErrorEmptyClaimSignature, ErrorEmptyIssuerAuthClaimNonRevProof, ErrorEmptyIssuerAuthClaimProof, ErrorUserStateInRelayClaimProof, EthStateStorage, FSCircuitStorage, FetchHandler, FilterQuery, FunctionSignatures, Iden3OnchainSmtCredentialStatusPublisher, Iden3SmtRhsCredentialStatusPublisher, Iden3SparseMerkleTreeProof, IdentityStorage, IdentityWallet, InMemoryDataSource, InMemoryMerkleTreeStorage, InMemoryPrivateKeyStore, IndexedDBDataSource, IndexedDBPrivateKeyStore, InputGenerator, IssuerResolver, JSON_SCHEMA_VALIDATORS_REGISTRY, JWSPacker, JsonSchemaValidator, KMS, KmsKeyType, LDParser, LinkedMultiQueryInputs, LinkedMultiQueryPubSignals, LocalStoragePrivateKeyStore, MerkleTreeIndexedDBStorage, MerkleTreeLocalStorage, MerkleTreeType, MerklizedRootPosition, MessageBus, MessageHandler, NativeProver, OnChainResolver, OnChainRevocationStorage, OnChainZKPVerifier, OnchainIssuer, Operators, constants as PROTOCOL_CONSTANTS, PackageManager, Parser, PaymentFeatures, PaymentHandler, PaymentRequestDataType, PaymentType, PlainPacker, ProofNode, ProofPurpose, ProofService, ProofType, PubSignalsVerifier, Query, QueryOperators, RHSResolver, RefreshHandler, RefreshServiceType, RevocationStatusHandler, SDK_EVENTS, Scalar, SearchError, Sec256k1Provider, StandardJSONCredentialsQueryFilter, StateTransitionInputs, StateTransitionPubSignals, SubjectPosition, SupportedCurrencies, SupportedDataFormat, SupportedPaymentProofType, TransactionService, ValueProof, Vector, VerifiableConstants, VerificationHandlerFunc, W3CCredential, XSDNS, ZKPPacker, availableTypesOperators, base58ToBytes$1 as base58ToBytes, base64ToBytes$1 as base64ToBytes, base64UrlToBytes, bigIntArrayToStringArray, bigIntCompare, buildAccept, buildDIDFromEthPubKey, buildFieldPath, buildTreeState, buildVerifierId, byteDecoder, byteEncoder, bytesToBase58$1 as bytesToBase58, bytesToBase64, bytesToBase64url$1 as bytesToBase64url, bytesToHex$3 as bytesToHex, cacheLoader, calcChallengeAuthV2, calculateCoreSchemaHash, calculateGroupId, calculateMultiRequestId, calculateQueryHashV2, calculateQueryHashV3, calculateRequestId, checkCircuitOperator, checkCircuitQueriesLength, checkDataInField, checkQueryRequest, circuitValidator, comparatorOptions, createAuthorizationRequest, createAuthorizationRequestWithMessage, createDiscoveryFeatureDiscloseMessage, createDiscoveryFeatureQueryMessage, createInMemoryCache, createPayment, createPaymentRequest, createProblemReportMessage, createProposal, createProposalRequest, createSchemaHash, createVerifiablePresentation, credentialSubjectKey, dataFillsSlot, decodeBase64url$1 as decodeBase64url, defaultEthConnectionConfig, defaultMTLevels, defaultMTLevelsClaim, defaultMTLevelsOnChain, defaultValueArraySize, defineMerklizedRootPosition, encodeBase64url, existenceToInt, extractProof, extractPublicKeyBytes, factoryComparer, fieldToByteArray, fieldValueFromVerifiablePresentation, fillCoreClaimSlot, fillSlot, findCredentialType, findValue, generateProfileDID, getERC20Decimals, getFieldSlotIndex, getKMSIdByAuthCredential, getNodeAuxValue, getNodesRepresentation, getOperatorNameByValue, getPermitSignature, getProperties, getSerializationAttrFromContext, getSerializationAttrFromParsedContext, getUserDIDFromCredential, hexToBytes$3 as hexToBytes, isEthereumIdentity, isGenesisState, isGenesisStateId, isIssuerGenesis, isValidOperation, keyPath, mergeObjects, packEthIdentityProof, packMetadatas, parseAcceptProfile, parseCoreClaimSlots, parseCredentialSubject, parseQueriesMetadata, parseQueryMetadata, parseSerializationAttr, prepareCircuitArrayValues, prepareSiblingsStr, processProofAuth, processProofResponse, processZeroKnowledgeProofRequests, pushHashesToRHS, resolveDIDDocumentAuth, resolveDidDocument, resolvePath, resolveVerificationMethods, strMTHex, stringByPath, subjectPositionIndex, swapEndianness, toClaimNonRevStatus, toGISTProof, toRevocationStatus, toTxDataArgs, transformQueryValueToBigInts, userStateError, validateDIDDocumentAuth, validateDisclosureNativeSDSupport, validateDisclosureV2Circuit, validateEmptyCredentialSubjectNoopNativeSupport, validateEmptyCredentialSubjectV2Circuit, validateOperators, validateTreeState, verifyEIP712TypedData, verifyExpiresTime, verifyFieldValueInclusionNativeExistsSupport, verifyFieldValueInclusionV2, witnessBuilder };
 //# sourceMappingURL=index.js.map