@0xpolygonid/js-sdk 1.30.0 → 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';
@@ -8255,7 +8255,27 @@ const VerifiableConstants = Object.freeze({
         CONTEXT_TYPE_IS_EMPTY: 'ctxType is empty',
         // ErrStateNotFound issuer state is genesis state.
         IDENTITY_DOES_NOT_EXIST: 'Identity does not exist',
-        NO_AUTH_CRED_FOUND: 'no auth credentials found'
+        NO_AUTH_CRED_FOUND: 'no auth credentials found',
+        // identity wallet
+        ID_WALLET_NO_CREDENTIAL_SATISFIED_QUERY: 'no credential satisfied query',
+        ID_WALLET_SIGNER_IS_REQUIRED: 'Ethereum signer is required to create Ethereum identities in order to transit state',
+        ID_WALLET_PROVER_IS_REQUIRED: 'prover is required to generate proofs for non ethereum identities',
+        ID_WALLET_CORE_CLAIM_REQUIRED_IN_SIG_PROOF: 'credential must have coreClaim representation in the signature proof',
+        ID_WALLET_CORE_CLAIM_REQUIRED_IN_ANY_PROOF: 'credential must have coreClaim representation in proofs',
+        ID_WALLET_CORE_CLAIM_MISMATCH: 'core claim representations is set in both proofs but they are not equal',
+        ID_WALLET_CORE_CLAIM_IS_NOT_SET: 'core claim is not set in credential proofs',
+        ID_WALLET_PROFILE_OR_IDENTITY_NOT_FOUND: 'profile or identity not found',
+        ID_WALLET_PROFILE_ALREADY_EXISTS: 'profile with given nonce or verifier already exists',
+        ID_WALLET_PROFILE_ALREADY_EXISTS_VERIFIER_TAGS: 'profile with given verifier and tags already exists',
+        ID_WALLET_ISSUER_AUTH_BJJ_CRED_MUST_HAVE_ANY_PROOF: 'issuer auth credential must have proof',
+        ID_WALLET_ISSUER_AUTH_BJJ_CRED_MUST_HAVE_MTP_PROOF: 'mtp is required for auth bjj key to issue new credentials',
+        // proof service
+        PROOF_SERVICE_NO_CREDENTIAL_FOR_IDENTITY_OR_PROFILE: 'no credentials belong to did or its profiles',
+        PROOF_SERVICE_NO_CREDENTIAL_FOR_QUERY: 'credential not found for query',
+        PROOF_SERVICE_PROFILE_GENESIS_DID_MISMATCH: 'subject and auth profiles are not derived from the same did',
+        PROOF_SERVICE_NO_QUERIES_IN_ZKP_REQUEST: 'no queries in zkp request',
+        // credential wallet
+        CREDENTIAL_WALLET_ALL_CREDENTIALS_ARE_REVOKED: 'all claims are revoked'
     },
     CREDENTIAL_TYPE: {
         // VerifiableCredential is a W3C verifiable credential type
@@ -8428,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
@@ -21245,12 +21269,12 @@ const createVerifiablePresentation = (context, tp, credential, queries) => {
     }
     const skeleton = {
         '@context': baseContext,
-        '@type': VerifiableConstants.CREDENTIAL_TYPE.W3C_VERIFIABLE_PRESENTATION,
+        type: VerifiableConstants.CREDENTIAL_TYPE.W3C_VERIFIABLE_PRESENTATION,
         verifiableCredential: {
             '@context': ldContext,
-            '@type': vcTypes,
+            type: vcTypes,
             credentialSubject: {
-                '@type': tp
+                type: tp
             }
         }
     };
@@ -31682,6 +31706,7 @@ class JsonSchemaValidator {
         validator = ajv ?? defaultJSONSchemaValidator;
         if (validator.formats && !Object.keys(validator.formats).length) {
             addFormats(validator);
+            addCustomFormats(validator);
         }
         const validate = (schema.$id ? validator.getSchema(schema.$id) : undefined) || validator.compile(schema);
         const valid = validate(data);
@@ -31692,6 +31717,16 @@ class JsonSchemaValidator {
         return true;
     }
 }
+function addCustomFormats(validator) {
+    validator.addFormat('positive-integer', {
+        type: 'string',
+        validate: (positiveIntegerStr) => /^[1-9]\d*$/.test(positiveIntegerStr)
+    });
+    validator.addFormat('non-negative-integer', {
+        type: 'string',
+        validate: (nonNegativeIntegerStr) => /^(0|[1-9]\d*)$/.test(nonNegativeIntegerStr)
+    });
+}
 
 /* eslint-disable @typescript-eslint/no-var-requires */
 /**
@@ -41047,6 +41082,82 @@ function dnsEncode(name, _maxLength) {
     }))) + "00";
 }
 
+const regexBytes = new RegExp("^bytes([0-9]+)$");
+const regexNumber = new RegExp("^(u?int)([0-9]*)$");
+const regexArray = new RegExp("^(.*)\\[([0-9]*)\\]$");
+function _pack(type, value, isArray) {
+    switch (type) {
+        case "address":
+            if (isArray) {
+                return getBytes(zeroPadValue(value, 32));
+            }
+            return getBytes(getAddress(value));
+        case "string":
+            return toUtf8Bytes(value);
+        case "bytes":
+            return getBytes(value);
+        case "bool":
+            value = (!!value ? "0x01" : "0x00");
+            if (isArray) {
+                return getBytes(zeroPadValue(value, 32));
+            }
+            return getBytes(value);
+    }
+    let match = type.match(regexNumber);
+    if (match) {
+        let signed = (match[1] === "int");
+        let size = parseInt(match[2] || "256");
+        assertArgument((!match[2] || match[2] === String(size)) && (size % 8 === 0) && size !== 0 && size <= 256, "invalid number type", "type", type);
+        if (isArray) {
+            size = 256;
+        }
+        if (signed) {
+            value = toTwos(value, size);
+        }
+        return getBytes(zeroPadValue(toBeArray(value), size / 8));
+    }
+    match = type.match(regexBytes);
+    if (match) {
+        const size = parseInt(match[1]);
+        assertArgument(String(size) === match[1] && size !== 0 && size <= 32, "invalid bytes type", "type", type);
+        assertArgument(dataLength(value) === size, `invalid value for ${type}`, "value", value);
+        if (isArray) {
+            return getBytes(zeroPadBytes(value, 32));
+        }
+        return value;
+    }
+    match = type.match(regexArray);
+    if (match && Array.isArray(value)) {
+        const baseType = match[1];
+        const count = parseInt(match[2] || String(value.length));
+        assertArgument(count === value.length, `invalid array length for ${type}`, "value", value);
+        const result = [];
+        value.forEach(function (value) {
+            result.push(_pack(baseType, value, true));
+        });
+        return getBytes(concat(result));
+    }
+    assertArgument(false, "invalid type", "type", type);
+}
+// @TODO: Array Enum
+/**
+ *   Computes the [[link-solc-packed]] representation of %%values%%
+ *   respectively to their %%types%%.
+ *
+ *   @example:
+ *       addr = "0x8ba1f109551bd432803012645ac136ddd64dba72"
+ *       solidityPacked([ "address", "uint" ], [ addr, 45 ]);
+ *       //_result:
+ */
+function solidityPacked(types, values) {
+    assertArgument(types.length === values.length, "wrong number of values; expected ${ types.length }", "values", values);
+    const tight = [];
+    types.forEach(function (type, index) {
+        tight.push(_pack(type, values[index]));
+    });
+    return hexlify(concat(tight));
+}
+
 //import { TypedDataDomain, TypedDataField } from "@ethersproject/providerabstract-signer";
 const padding = new Uint8Array(32);
 padding.fill(0);
@@ -54210,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
  *
@@ -55368,34 +55764,60 @@ const processZeroKnowledgeProofRequests = async (to, requests, from, proofServic
     const groupedCredentialsCache = new Map();
     const zkpResponses = [];
     for (const proofReq of requestScope) {
-        if (!opts.supportedCircuits.includes(proofReq.circuitId)) {
-            throw new Error(`Circuit ${proofReq.circuitId} is not allowed`);
-        }
-        const query = proofReq.query;
-        const groupId = query.groupId;
-        const combinedQueryData = combinedQueries.get(groupId);
-        if (groupId) {
-            if (!combinedQueryData) {
-                throw new Error(`Invalid group id ${query.groupId}`);
-            }
-            const combinedQuery = combinedQueryData.query;
-            if (!groupedCredentialsCache.has(groupId)) {
-                const credWithRevStatus = await proofService.findCredentialByProofQuery(to, combinedQueryData.query);
-                if (!credWithRevStatus.cred) {
-                    throw new Error(`Credential not found for query ${JSON.stringify(combinedQuery)}`);
+        let zkpRes;
+        try {
+            const isCircuitSupported = opts.supportedCircuits.includes(proofReq.circuitId);
+            if (!isCircuitSupported) {
+                if (proofReq.optional) {
+                    continue;
+                }
+                throw new Error(`Circuit ${proofReq.circuitId} is not allowed`);
+            }
+            const query = proofReq.query;
+            const groupId = query.groupId;
+            const combinedQueryData = combinedQueries.get(groupId);
+            if (groupId) {
+                if (!combinedQueryData) {
+                    throw new Error(`Invalid group id ${query.groupId}`);
+                }
+                const combinedQuery = combinedQueryData.query;
+                if (!groupedCredentialsCache.has(groupId)) {
+                    const credWithRevStatus = await proofService.findCredentialByProofQuery(to, combinedQueryData.query);
+                    if (!credWithRevStatus.cred) {
+                        if (proofReq.optional) {
+                            continue;
+                        }
+                        throw new Error(VerifiableConstants.ERRORS.PROOF_SERVICE_NO_CREDENTIAL_FOR_QUERY +
+                            `${JSON.stringify(combinedQuery)}`);
+                    }
+                    groupedCredentialsCache.set(groupId, credWithRevStatus);
                 }
-                groupedCredentialsCache.set(groupId, credWithRevStatus);
             }
+            const credWithRevStatus = groupedCredentialsCache.get(groupId);
+            zkpRes = await proofService.generateProof(proofReq, to, {
+                verifierDid: from,
+                challenge: opts.challenge,
+                skipRevocation: Boolean(query.skipClaimRevocationCheck),
+                credential: credWithRevStatus?.cred,
+                credentialRevocationStatus: credWithRevStatus?.revStatus,
+                linkNonce: combinedQueryData?.linkNonce ? BigInt(combinedQueryData.linkNonce) : undefined
+            });
+        }
+        catch (error) {
+            const expectedErrors = [
+                VerifiableConstants.ERRORS.PROOF_SERVICE_NO_CREDENTIAL_FOR_IDENTITY_OR_PROFILE,
+                VerifiableConstants.ERRORS.ID_WALLET_NO_CREDENTIAL_SATISFIED_QUERY,
+                VerifiableConstants.ERRORS.CREDENTIAL_WALLET_ALL_CREDENTIALS_ARE_REVOKED
+            ];
+            // handle only errors in case credential is not found and it is optional proof request - otherwise throw
+            if (error instanceof Error &&
+                (expectedErrors.includes(error.message) ||
+                    error.message.includes(VerifiableConstants.ERRORS.PROOF_SERVICE_NO_CREDENTIAL_FOR_QUERY)) &&
+                proofReq.optional) {
+                continue;
+            }
+            throw error;
         }
-        const credWithRevStatus = groupedCredentialsCache.get(groupId);
-        const zkpRes = await proofService.generateProof(proofReq, to, {
-            verifierDid: from,
-            challenge: opts.challenge,
-            skipRevocation: Boolean(query.skipClaimRevocationCheck),
-            credential: credWithRevStatus?.cred,
-            credentialRevocationStatus: credWithRevStatus?.revStatus,
-            linkNonce: combinedQueryData?.linkNonce ? BigInt(combinedQueryData.linkNonce) : undefined
-        });
         zkpResponses.push(zkpRes);
     }
     return zkpResponses;
@@ -56265,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.
@@ -56297,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');
             }
@@ -56364,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);
@@ -57063,7 +57478,7 @@ class CredentialWallet {
             }
             return { cred, revStatus };
         }
-        throw new Error('all claims are revoked');
+        throw new Error(VerifiableConstants.ERRORS.CREDENTIAL_WALLET_ALL_CREDENTIALS_ARE_REVOKED);
     }
 }
 
@@ -58642,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: [
@@ -59977,7 +60686,7 @@ var IVerifierABI = [
 					},
 					{
 						internalType: "address",
-						name: "owner",
+						name: "creator",
 						type: "address"
 					}
 				],
@@ -63141,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
  *
@@ -63426,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
@@ -64007,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);
     }
@@ -65216,6 +65787,26 @@ const fieldValueFromVerifiablePresentation = async (fieldName, verifiablePresent
     }
     return await value.mtEntry();
 };
+function calculateGroupId(requestIds) {
+    const types = Array(requestIds.length).fill('uint256');
+    const groupID = BigInt(keccak256(solidityPacked(types, requestIds))) &
+        // It should fit in a field number in the circuit (max 253 bits). With this we truncate to 252 bits for the group ID
+        BigInt('0x0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF');
+    return groupID;
+}
+function calculateRequestId(requestParams, creatorAddress) {
+    // 0x0000000000000000FFFF...FF. Reserved first 8 bytes for the request Id type and future use
+    // 0x00010000000000000000...00. First 2 bytes for the request Id type
+    //    - 0x0000... for old request Ids with uint64
+    //    - 0x0001... for new request Ids with uint256
+    const requestId = (BigInt(keccak256(solidityPacked(['bytes', 'address'], [requestParams, creatorAddress]))) &
+        BigInt('0x0000000000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF')) +
+        BigInt('0x0001000000000000000000000000000000000000000000000000000000000000');
+    return requestId;
+}
+function calculateMultiRequestId(requestIds, groupIds, creatorAddress) {
+    return BigInt(keccak256(solidityPacked(['uint256[]', 'uint256[]', 'address'], [requestIds, groupIds, creatorAddress])));
+}
 
 function calculateQueryHashV2(values, schema, slotIndex, operator, claimPathKey, claimPathNotExists) {
     const expValue = prepareCircuitArrayValues(values, 64);
@@ -65749,7 +66340,8 @@ class ProofService {
             credentialWithRevStatus = { cred: opts.credential, revStatus };
         }
         if (!credentialWithRevStatus.cred) {
-            throw new Error(`credential not found for query ${JSON.stringify(proofReq.query)}`);
+            throw new Error(VerifiableConstants.ERRORS.PROOF_SERVICE_NO_CREDENTIAL_FOR_QUERY +
+                ` ${JSON.stringify(proofReq.query)}`);
         }
         const credentialCoreClaim = await this._identityWallet.getCoreClaimFromCredential(credentialWithRevStatus.cred);
         const { nonce: authProfileNonce, genesisDID } = await this._identityWallet.getGenesisDIDMetadata(identifier);
@@ -65761,11 +66353,11 @@ class ProofService {
         const subjectDID = DID.parse(preparedCredential.credential.credentialSubject['id']);
         const { nonce: credentialSubjectProfileNonce, genesisDID: subjectGenesisDID } = await this._identityWallet.getGenesisDIDMetadata(subjectDID);
         if (subjectGenesisDID.string() !== genesisDID.string()) {
-            throw new Error('subject and auth profiles are not derived from the same did');
+            throw new Error(VerifiableConstants.ERRORS.PROOF_SERVICE_PROFILE_GENESIS_DID_MISMATCH);
         }
         const propertiesMetadata = parseCredentialSubject(proofReq.query.credentialSubject);
         if (!propertiesMetadata.length) {
-            throw new Error('no queries in zkp request');
+            throw new Error(VerifiableConstants.ERRORS.PROOF_SERVICE_NO_QUERIES_IN_ZKP_REQUEST);
         }
         const mtPosition = preparedCredential.credentialCoreClaim.getMerklizedPosition();
         let mk;
@@ -65949,7 +66541,7 @@ class ProofService {
     async findCredentialByProofQuery(did, query) {
         const credentials = await this._identityWallet.findOwnedCredentialsByDID(did, query);
         if (!credentials.length) {
-            throw new Error(`no credentials belong to did or its profiles`);
+            throw new Error(VerifiableConstants.ERRORS.PROOF_SERVICE_NO_CREDENTIAL_FOR_IDENTITY_OR_PROFILE);
         }
         //  For EQ / IN / NIN / LT / GT operations selective if credential satisfies query - we can get any.
         // TODO: choose credential for selective credentials
@@ -66148,7 +66740,7 @@ class IdentityWallet {
         let credential;
         const ethSigner = opts.ethSigner;
         if (opts.createBjjCredential && !ethSigner) {
-            throw new Error('Ethereum signer is required to create Ethereum identities in order to transit state');
+            throw new Error(VerifiableConstants.ERRORS.ID_WALLET_SIGNER_IS_REQUIRED);
         }
         const currentState = ZERO_HASH; // In Ethereum identities we don't have an initial state with the auth credential
         const didType = buildDIDType(opts.method || DidMethod.Iden3, opts.blockchain || Blockchain.Polygon, opts.networkId || NetworkId.Amoy);
@@ -66186,23 +66778,28 @@ class IdentityWallet {
         }
         const profile = await this._storage.identity.getProfileById(did.string());
         if (!profile) {
-            throw new Error('profile or identity not found');
+            throw new Error(VerifiableConstants.ERRORS.ID_WALLET_PROFILE_OR_IDENTITY_NOT_FOUND);
         }
         return { nonce: profile.nonce, genesisDID: DID.parse(profile.genesisIdentifier) };
     }
     /** {@inheritDoc IIdentityWallet.createProfile} */
-    async createProfile(did, nonce, verifier) {
+    async createProfile(did, nonce, verifier, tags) {
         const profileDID = generateProfileDID(did, nonce);
         const identityProfiles = await this._storage.identity.getProfilesByGenesisIdentifier(did.string());
-        const existingProfile = identityProfiles.find((p) => p.nonce == nonce || p.verifier == verifier);
-        if (existingProfile) {
-            throw new Error('profile with given nonce or verifier already exists');
+        const profilesForTagAndVerifier = await this._storage.identity.getProfilesByVerifier(verifier, tags);
+        if (profilesForTagAndVerifier.length) {
+            throw new Error(VerifiableConstants.ERRORS.ID_WALLET_PROFILE_ALREADY_EXISTS_VERIFIER_TAGS);
+        }
+        const existingProfileWithNonce = identityProfiles.find((p) => p.nonce == nonce);
+        if (existingProfileWithNonce) {
+            throw new Error(VerifiableConstants.ERRORS.ID_WALLET_PROFILE_ALREADY_EXISTS);
         }
         await this._storage.identity.saveProfile({
             id: profileDID.string(),
             nonce,
             genesisIdentifier: did.string(),
-            verifier
+            verifier,
+            tags
         });
         return profileDID;
     }
@@ -66221,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();
@@ -66345,11 +66950,11 @@ class IdentityWallet {
         const coreClaimHash = poseidon.hash([hi, hv]);
         const signature = await this.signChallenge(coreClaimHash, issuerAuthBJJCredential);
         if (!issuerAuthBJJCredential.proof) {
-            throw new Error('issuer auth credential must have proof');
+            throw new Error(VerifiableConstants.ERRORS.ID_WALLET_ISSUER_AUTH_BJJ_CRED_MUST_HAVE_ANY_PROOF);
         }
         const mtpAuthBJJProof = issuerAuthBJJCredential.getIden3SparseMerkleTreeProof();
         if (!mtpAuthBJJProof) {
-            throw new Error('mtp is required for auth bjj key to issue new credentials');
+            throw new Error(VerifiableConstants.ERRORS.ID_WALLET_ISSUER_AUTH_BJJ_CRED_MUST_HAVE_MTP_PROOF);
         }
         const sigProof = new BJJSignatureProof2021({
             issuerData: {
@@ -66389,7 +66994,7 @@ class IdentityWallet {
         const issuerTree = await this.getDIDTreeModel(issuerDID);
         const coreClaim = await this.getCoreClaimFromCredential(credential);
         if (!coreClaim) {
-            throw new Error('credential must have coreClaim representation in proofs');
+            throw new Error(VerifiableConstants.ERRORS.ID_WALLET_CORE_CLAIM_REQUIRED_IN_ANY_PROOF);
         }
         const nonce = coreClaim.getRevocationNonce();
         await issuerTree.revocationTree.add(nonce, BigInt(0));
@@ -66412,7 +67017,7 @@ class IdentityWallet {
             // credential must have a bjj signature proof
             const coreClaim = credential.getCoreClaimFromProof(ProofType.BJJSignature);
             if (!coreClaim) {
-                throw new Error('credential must have coreClaim representation in the signature proof');
+                throw new Error(VerifiableConstants.ERRORS.ID_WALLET_CORE_CLAIM_REQUIRED_IN_SIG_PROOF);
             }
             await this._storage.mt.addToMerkleTree(issuerDID.string(), MerkleTreeType.Claims, coreClaim.hIndex(), coreClaim.hValue());
         }
@@ -66444,7 +67049,7 @@ class IdentityWallet {
             const coreClaim = credential.getCoreClaimFromProof(ProofType.BJJSignature) ||
                 (await credential.toCoreClaim(opts));
             if (!coreClaim) {
-                throw new Error('credential must have coreClaim representation in the signature proof');
+                throw new Error(VerifiableConstants.ERRORS.ID_WALLET_CORE_CLAIM_REQUIRED_IN_SIG_PROOF);
             }
             const mtpWithProof = await this.generateCoreClaimMtp(issuerDID, coreClaim, treeState);
             const mtpProof = new Iden3SparseMerkleTreeProof({
@@ -66512,10 +67117,10 @@ class IdentityWallet {
         if (coreClaimFromMtpProof &&
             coreClaimFromSigProof &&
             coreClaimFromMtpProof.hex() !== coreClaimFromSigProof.hex()) {
-            throw new Error('core claim representations is set in both proofs but they are not equal');
+            throw new Error(VerifiableConstants.ERRORS.ID_WALLET_CORE_CLAIM_MISMATCH);
         }
         if (!coreClaimFromMtpProof && !coreClaimFromSigProof) {
-            throw new Error('core claim is not set in credential proofs');
+            throw new Error(VerifiableConstants.ERRORS.ID_WALLET_CORE_CLAIM_IS_NOT_SET);
         }
         //eslint-disable-next-line  @typescript-eslint/no-non-null-assertion
         const coreClaim = coreClaimFromMtpProof ?? coreClaimFromSigProof;
@@ -66524,7 +67129,7 @@ class IdentityWallet {
     async findOwnedCredentialsByDID(did, query) {
         const credentials = await this._credentialWallet.findByQuery(query);
         if (!credentials.length) {
-            throw new Error(`no credential satisfied query`);
+            throw new Error(VerifiableConstants.ERRORS.ID_WALLET_NO_CREDENTIAL_SATISFIED_QUERY);
         }
         const { genesisDID } = await this.getGenesisDIDMetadata(did);
         const profiles = await this.getProfilesByDID(genesisDID);
@@ -66564,7 +67169,7 @@ class IdentityWallet {
         let txId;
         if (!isEthIdentity) {
             if (!prover) {
-                throw new Error('prover is required to generate proofs for non ethereum identities');
+                throw new Error(VerifiableConstants.ERRORS.ID_WALLET_PROVER_IS_REQUIRED);
             }
             // generate the proof
             const authInfo = await this._inputsGenerator.prepareAuthBJJCredential(did, oldTreeState);
@@ -66680,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, calculateQueryHashV2, calculateQueryHashV3, 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