@0xpolygonid/js-sdk 1.17.8 → 1.18.1

package/dist/browser/esm/index.js

@@ -1281,6 +1281,13 @@ var sha3 = {exports: {}};
 
 var sha3Exports = sha3.exports;
 
+/**
+ * Supported DID Document Signatures
+ */
+var DIDDocumentSignature;
+(function (DIDDocumentSignature) {
+    DIDDocumentSignature["EthereumEip712Signature2021"] = "EthereumEip712Signature2021";
+})(DIDDocumentSignature || (DIDDocumentSignature = {}));
 /**
  * Checks if state is genesis state
  *
@@ -1344,6 +1351,34 @@ const resolveDIDDocumentAuth = async (did, resolveURL, state) => {
     const didResolutionRes = (await resp.json());
     return didResolutionRes.didDocument?.verificationMethod?.find((i) => i.type === 'Iden3StateInfo2023');
 };
+function emptyStateDID(did) {
+    const id = DID.idFromDID(did);
+    const didType = buildDIDType(DID.methodFromId(id), DID.blockchainFromId(id), DID.networkIdFromId(id));
+    const identifier = Id$1.idGenesisFromIdenState(didType, 0n);
+    const emptyDID = DID.parseFromId(identifier);
+    return emptyDID;
+}
+const resolveDidDocument = async (did, resolverUrl, opts) => {
+    let didString = did.string().replace(/:/g, '%3A');
+    // for gist resolve we have to `hide` user did (look into resolver implementation)
+    const isGistRequest = opts?.gist && !opts.state;
+    if (isGistRequest) {
+        didString = emptyStateDID(did).string();
+    }
+    let url = `${resolverUrl}/1.0/identifiers/${didString}`;
+    if (opts?.signature) {
+        url += `?signature=${opts.signature}`;
+    }
+    if (opts?.state) {
+        url += `${url.includes('?') ? '&' : '?'}state=${opts.state.hex()}`;
+    }
+    if (opts?.gist) {
+        url += `${url.includes('?') ? '&' : '?'}gist=${opts.gist.hex()}`;
+    }
+    const resp = await fetch(url);
+    const data = await resp.json();
+    return data;
+};
 const buildDIDFromEthPubKey = (didType, pubKeyEth) => {
     // Use Keccak-256 hash function to get public key hash
     const hashOfPublicKey = sha3Exports.keccak256(hexToBytes$3(pubKeyEth));
@@ -49793,6 +49828,16 @@ class AtomicQueryMTPV2OnChainPubSignals extends BaseConfig {
         fieldIdx++;
         return this;
     }
+    /** {@inheritDoc IStateInfoPubSignals.getStatesInfo} */
+    getStatesInfo() {
+        return {
+            states: [
+                { id: this.issuerID, state: this.issuerClaimIdenState },
+                { id: this.issuerID, state: this.issuerClaimNonRevState }
+            ],
+            gists: [{ id: this.userID, root: this.gistRoot }]
+        };
+    }
 }
 
 /**
@@ -50574,6 +50619,16 @@ class AtomicQueryV3OnChainPubSignals extends BaseConfig {
         this.isBJJAuthEnabled = parseInt(sVals[fieldIdx]);
         return this;
     }
+    /** {@inheritDoc IStateInfoPubSignals.getStatesInfo} */
+    getStatesInfo() {
+        return {
+            states: [
+                { id: this.issuerID, state: this.issuerState },
+                { id: this.issuerID, state: this.issuerClaimNonRevState }
+            ],
+            gists: [{ id: this.userID, root: this.gistRoot }]
+        };
+    }
 }
 
 /**
@@ -50799,6 +50854,16 @@ class AtomicQuerySigV2OnChainPubSignals extends BaseConfig {
         fieldIdx++;
         return this;
     }
+    /** {@inheritDoc IStateInfoPubSignals.getStatesInfo} */
+    getStatesInfo() {
+        return {
+            states: [
+                { id: this.issuerID, state: this.issuerAuthState },
+                { id: this.issuerID, state: this.issuerClaimNonRevState }
+            ],
+            gists: [{ id: this.userID, root: this.gistRoot }]
+        };
+    }
 }
 
 /**
@@ -52358,6 +52423,103 @@ class EthStateStorage {
 }
 
 var abi$1 = [
+	{
+		inputs: [
+		],
+		name: "InvalidInitialization",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "string",
+				name: "message",
+				type: "string"
+			},
+			{
+				internalType: "uint64",
+				name: "requestId",
+				type: "uint64"
+			},
+			{
+				internalType: "uint256",
+				name: "linkID",
+				type: "uint256"
+			},
+			{
+				internalType: "uint64",
+				name: "requestIdToCompare",
+				type: "uint64"
+			},
+			{
+				internalType: "uint256",
+				name: "linkIdToCompare",
+				type: "uint256"
+			}
+		],
+		name: "LinkedProofError",
+		type: "error"
+	},
+	{
+		inputs: [
+		],
+		name: "NotInitializing",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "owner",
+				type: "address"
+			}
+		],
+		name: "OwnableInvalidOwner",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "account",
+				type: "address"
+			}
+		],
+		name: "OwnableUnauthorizedAccount",
+		type: "error"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: false,
+				internalType: "uint64",
+				name: "version",
+				type: "uint64"
+			}
+		],
+		name: "Initialized",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "address",
+				name: "previousOwner",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "newOwner",
+				type: "address"
+			}
+		],
+		name: "OwnershipTransferStarted",
+		type: "event"
+	},
 	{
 		anonymous: false,
 		inputs: [
@@ -52377,6 +52539,62 @@ var abi$1 = [
 		name: "OwnershipTransferred",
 		type: "event"
 	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "uint64",
+				name: "requestId",
+				type: "uint64"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "requestOwner",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "string",
+				name: "metadata",
+				type: "string"
+			},
+			{
+				indexed: false,
+				internalType: "address",
+				name: "validator",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "bytes",
+				name: "data",
+				type: "bytes"
+			}
+		],
+		name: "ZKPRequestSet",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "uint64",
+				name: "requestId",
+				type: "uint64"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "caller",
+				type: "address"
+			}
+		],
+		name: "ZKPResponseSubmitted",
+		type: "event"
+	},
 	{
 		inputs: [
 		],
@@ -52391,6 +52609,165 @@ var abi$1 = [
 		stateMutability: "view",
 		type: "function"
 	},
+	{
+		inputs: [
+		],
+		name: "VERSION",
+		outputs: [
+			{
+				internalType: "string",
+				name: "",
+				type: "string"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "acceptOwnership",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "contract ICircuitValidator",
+				name: "validator",
+				type: "address"
+			}
+		],
+		name: "addValidatorToWhitelist",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "uint64",
+				name: "requestId",
+				type: "uint64"
+			}
+		],
+		name: "disableZKPRequest",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "uint64",
+				name: "requestId",
+				type: "uint64"
+			}
+		],
+		name: "enableZKPRequest",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "sender",
+				type: "address"
+			},
+			{
+				internalType: "uint64",
+				name: "requestId",
+				type: "uint64"
+			}
+		],
+		name: "getProofStatus",
+		outputs: [
+			{
+				components: [
+					{
+						internalType: "bool",
+						name: "isVerified",
+						type: "bool"
+					},
+					{
+						internalType: "string",
+						name: "validatorVersion",
+						type: "string"
+					},
+					{
+						internalType: "uint256",
+						name: "blockNumber",
+						type: "uint256"
+					},
+					{
+						internalType: "uint256",
+						name: "blockTimestamp",
+						type: "uint256"
+					}
+				],
+				internalType: "struct IZKPVerifier.ProofStatus",
+				name: "",
+				type: "tuple"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "user",
+				type: "address"
+			},
+			{
+				internalType: "uint64",
+				name: "requestId",
+				type: "uint64"
+			},
+			{
+				internalType: "string",
+				name: "key",
+				type: "string"
+			}
+		],
+		name: "getProofStorageField",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "uint64",
+				name: "requestId",
+				type: "uint64"
+			}
+		],
+		name: "getRequestOwner",
+		outputs: [
+			{
+				internalType: "address",
+				name: "",
+				type: "address"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
 	{
 		inputs: [
 			{
@@ -52420,7 +52797,7 @@ var abi$1 = [
 					}
 				],
 				internalType: "struct IZKPVerifier.ZKPRequest",
-				name: "",
+				name: "zkpRequest",
 				type: "tuple"
 			}
 		],
@@ -52482,6 +52859,82 @@ var abi$1 = [
 		stateMutability: "view",
 		type: "function"
 	},
+	{
+		inputs: [
+			{
+				internalType: "contract IStateCrossChain",
+				name: "stateCrossChain",
+				type: "address"
+			}
+		],
+		name: "initialize",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "sender",
+				type: "address"
+			},
+			{
+				internalType: "uint64",
+				name: "requestId",
+				type: "uint64"
+			}
+		],
+		name: "isProofVerified",
+		outputs: [
+			{
+				internalType: "bool",
+				name: "",
+				type: "bool"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "contract ICircuitValidator",
+				name: "validator",
+				type: "address"
+			}
+		],
+		name: "isWhitelistedValidator",
+		outputs: [
+			{
+				internalType: "bool",
+				name: "",
+				type: "bool"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "uint64",
+				name: "requestId",
+				type: "uint64"
+			}
+		],
+		name: "isZKPRequestEnabled",
+		outputs: [
+			{
+				internalType: "bool",
+				name: "",
+				type: "bool"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
 	{
 		inputs: [
 		],
@@ -52498,26 +52951,30 @@ var abi$1 = [
 	},
 	{
 		inputs: [
+		],
+		name: "pendingOwner",
+		outputs: [
 			{
 				internalType: "address",
 				name: "",
 				type: "address"
-			},
-			{
-				internalType: "uint64",
-				name: "",
-				type: "uint64"
 			}
 		],
-		name: "proofs",
-		outputs: [
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
 			{
-				internalType: "bool",
-				name: "",
-				type: "bool"
+				internalType: "contract ICircuitValidator",
+				name: "validator",
+				type: "address"
 			}
 		],
-		stateMutability: "view",
+		name: "removeValidatorFromWhitelist",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
 		type: "function"
 	},
 	{
@@ -52548,6 +53005,25 @@ var abi$1 = [
 		stateMutability: "view",
 		type: "function"
 	},
+	{
+		inputs: [
+			{
+				internalType: "uint64",
+				name: "requestId",
+				type: "uint64"
+			},
+			{
+				internalType: "address",
+				name: "requestOwner",
+				type: "address"
+			}
+		],
+		name: "setRequestOwner",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
 	{
 		inputs: [
 			{
@@ -52618,6 +53094,42 @@ var abi$1 = [
 		stateMutability: "nonpayable",
 		type: "function"
 	},
+	{
+		inputs: [
+			{
+				components: [
+					{
+						internalType: "uint64",
+						name: "requestId",
+						type: "uint64"
+					},
+					{
+						internalType: "bytes",
+						name: "zkProof",
+						type: "bytes"
+					},
+					{
+						internalType: "bytes",
+						name: "data",
+						type: "bytes"
+					}
+				],
+				internalType: "struct ZKPResponse[]",
+				name: "responses",
+				type: "tuple[]"
+			},
+			{
+				internalType: "bytes",
+				name: "crossChainProof",
+				type: "bytes"
+			}
+		],
+		name: "submitZKPResponseV2",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
 	{
 		inputs: [
 			{
@@ -52631,9 +53143,113 @@ var abi$1 = [
 		],
 		stateMutability: "nonpayable",
 		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "sender",
+				type: "address"
+			},
+			{
+				internalType: "uint64[]",
+				name: "requestIds",
+				type: "uint64[]"
+			}
+		],
+		name: "verifyLinkedProofs",
+		outputs: [
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "uint64",
+				name: "requestId",
+				type: "uint64"
+			},
+			{
+				internalType: "uint256[]",
+				name: "inputs",
+				type: "uint256[]"
+			},
+			{
+				internalType: "uint256[2]",
+				name: "a",
+				type: "uint256[2]"
+			},
+			{
+				internalType: "uint256[2][2]",
+				name: "b",
+				type: "uint256[2][2]"
+			},
+			{
+				internalType: "uint256[2]",
+				name: "c",
+				type: "uint256[2]"
+			},
+			{
+				internalType: "address",
+				name: "sender",
+				type: "address"
+			}
+		],
+		name: "verifyZKPResponse",
+		outputs: [
+			{
+				components: [
+					{
+						internalType: "string",
+						name: "key",
+						type: "string"
+					},
+					{
+						internalType: "uint256",
+						name: "inputValue",
+						type: "uint256"
+					}
+				],
+				internalType: "struct ICircuitValidator.KeyToInputValue[]",
+				name: "",
+				type: "tuple[]"
+			}
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "version",
+		outputs: [
+			{
+				internalType: "string",
+				name: "",
+				type: "string"
+			}
+		],
+		stateMutability: "pure",
+		type: "function"
 	}
 ];
 
+const maxGasLimit = 10000000n;
+/**
+ * Supported function signature for SubmitZKPResponse
+ */
+var FunctionSignatures;
+(function (FunctionSignatures) {
+    /**
+     * solidity identifier for function signature:
+     * function submitZKPResponse(uint64 requestId, uint256[] calldata inputs,
+     * uint256[2] calldata a, uint256[2][2] calldata b, uint256[2] calldata c) public
+     */
+    FunctionSignatures["SubmitZKPResponseV1"] = "b68967e2";
+    //function submitZKPResponseV2(tuple[](uint64 requestId,bytes zkProof,bytes data),bytes crossChainProof)
+    FunctionSignatures["SubmitZKPResponseV2"] = "ade09fcd";
+})(FunctionSignatures || (FunctionSignatures = {}));
 /**
  * OnChainZKPVerifier is a class that allows to interact with the OnChainZKPVerifier contract
  * and submitZKPResponse.
@@ -52648,71 +53264,303 @@ class OnChainZKPVerifier {
      * @beta
      * @param {EthConnectionConfig[]} - array of ETH configs
      */
-    constructor(_configs) {
+    constructor(_configs, _opts) {
         this._configs = _configs;
+        this._opts = _opts;
+        /**
+         * supported circuits
+         */
+        this._supportedCircuits = [
+            CircuitId.AtomicQueryMTPV2OnChain,
+            CircuitId.AtomicQuerySigV2OnChain,
+            CircuitId.AtomicQueryV3OnChain
+        ];
         /**
-         * solidity identifier for function signature:
-         * function submitZKPResponse(uint64 requestId, uint256[] calldata inputs,
-         * uint256[2] calldata a, uint256[2][2] calldata b, uint256[2] calldata c) public
+         * abi coder to encode/decode structures to solidity bytes
          */
-        this._supportedMethodId = 'b68967e2';
+        this._abiCoder = new AbiCoder();
     }
     /**
-     * Submit ZKP Responses to OnChainZKPVerifier contract.
-     * @beta
-     * @param {Signer} ethSigner - tx signer
-     * @param {txData} ContractInvokeTransactionData - transaction data
-     * @param {ZeroKnowledgeProofResponse[]} zkProofResponses - zkProofResponses
-     * @returns {Promise<Map<string, ZeroKnowledgeProofResponse>>} - map of transaction hash - ZeroKnowledgeProofResponse
+     * {@inheritDoc IOnChainZKPVerifier.prepareTxArgsSubmitV1}
+     */
+    async prepareTxArgsSubmitV1(txData, zkProofResponse) {
+        if (txData.method_id.replace('0x', '') !== FunctionSignatures.SubmitZKPResponseV1) {
+            throw new Error(`prepareTxArgsSubmitV1 function doesn't implement requested method id. Only '0x${FunctionSignatures.SubmitZKPResponseV1}' is supported.`);
+        }
+        const requestID = zkProofResponse.id;
+        const inputs = zkProofResponse.pub_signals;
+        const payload = [
+            requestID,
+            inputs,
+            zkProofResponse.proof.pi_a.slice(0, 2),
+            [
+                [zkProofResponse.proof.pi_b[0][1], zkProofResponse.proof.pi_b[0][0]],
+                [zkProofResponse.proof.pi_b[1][1], zkProofResponse.proof.pi_b[1][0]]
+            ],
+            zkProofResponse.proof.pi_c.slice(0, 2)
+        ];
+        return payload;
+    }
+    /**
+     * {@inheritDoc IOnChainZKPVerifier.submitZKPResponse}
      */
     async submitZKPResponse(ethSigner, txData, zkProofResponses) {
         const chainConfig = this._configs.find((i) => i.chainId == txData.chain_id);
         if (!chainConfig) {
             throw new Error(`config for chain id ${txData.chain_id} was not found`);
         }
-        if (txData.method_id.replace('0x', '') !== this._supportedMethodId) {
-            throw new Error(`submit doesn't implement requested method id. Only '0x${this._supportedMethodId}' is supported.`);
+        if (txData.method_id.replace('0x', '') !== FunctionSignatures.SubmitZKPResponseV1) {
+            throw new Error(`submitZKPResponse function doesn't implement requested method id. Only '0x${FunctionSignatures.SubmitZKPResponseV1}' is supported.`);
         }
         const provider = new JsonRpcProvider(chainConfig.url, chainConfig.chainId);
-        const verifierContract = new Contract(txData.contract_address, abi$1, provider);
         ethSigner = ethSigner.connect(provider);
-        const contract = verifierContract.connect(ethSigner);
         const response = new Map();
-        for (const zkProof of zkProofResponses) {
-            const requestID = zkProof.id;
-            const inputs = zkProof.pub_signals;
-            const payload = [
-                requestID,
-                inputs,
-                zkProof.proof.pi_a.slice(0, 2),
-                [
-                    [zkProof.proof.pi_b[0][1], zkProof.proof.pi_b[0][0]],
-                    [zkProof.proof.pi_b[1][1], zkProof.proof.pi_b[1][0]]
-                ],
-                zkProof.proof.pi_c.slice(0, 2)
-            ];
-            const feeData = await provider.getFeeData();
-            const maxFeePerGas = chainConfig.maxFeePerGas
-                ? BigInt(chainConfig.maxFeePerGas)
-                : feeData.maxFeePerGas;
-            const maxPriorityFeePerGas = chainConfig.maxPriorityFeePerGas
-                ? BigInt(chainConfig.maxPriorityFeePerGas)
-                : feeData.maxPriorityFeePerGas;
-            const gasLimit = await contract.submitZKPResponse.estimateGas(...payload);
-            const txData = await contract.submitZKPResponse.populateTransaction(...payload);
+        const feeData = await provider.getFeeData();
+        const maxFeePerGas = chainConfig.maxFeePerGas
+            ? BigInt(chainConfig.maxFeePerGas)
+            : feeData.maxFeePerGas;
+        const maxPriorityFeePerGas = chainConfig.maxPriorityFeePerGas
+            ? BigInt(chainConfig.maxPriorityFeePerGas)
+            : feeData.maxPriorityFeePerGas;
+        const verifierContract = new Contract(txData.contract_address, abi$1);
+        for (const zkProofResponse of zkProofResponses) {
+            const txArgs = await this.prepareTxArgsSubmitV1(txData, zkProofResponse);
+            const payload = await verifierContract.submitZKPResponse.populateTransaction(...txArgs);
             const request = {
-                to: txData.to,
-                data: txData.data,
-                gasLimit,
+                to: txData.contract_address,
+                data: payload.data,
                 maxFeePerGas,
                 maxPriorityFeePerGas
             };
+            let gasLimit;
+            try {
+                gasLimit = await ethSigner.estimateGas(request);
+            }
+            catch (e) {
+                gasLimit = maxGasLimit;
+            }
+            request.gasLimit = gasLimit;
             const transactionService = new TransactionService(provider);
             const { txnHash } = await transactionService.sendTransactionRequest(ethSigner, request);
-            response.set(txnHash, zkProof);
+            response.set(txnHash, zkProofResponse);
         }
         return response;
     }
+    /**
+     * {@inheritDoc IOnChainZKPVerifier.submitZKPResponseV2}
+     */
+    async submitZKPResponseV2(ethSigner, txData, zkProofResponses) {
+        const chainConfig = this._configs.find((i) => i.chainId == txData.chain_id);
+        if (!chainConfig) {
+            throw new Error(`config for chain id ${txData.chain_id} was not found`);
+        }
+        if (txData.method_id.replace('0x', '') !== FunctionSignatures.SubmitZKPResponseV2) {
+            throw new Error(`submitZKPResponseV2 function doesn't implement requested method id. Only '0x${FunctionSignatures.SubmitZKPResponseV2}' is supported.`);
+        }
+        if (!this._opts?.didResolverUrl) {
+            throw new Error(`did resolver url required for crosschain verification`);
+        }
+        const provider = new JsonRpcProvider(chainConfig.url, chainConfig.chainId);
+        ethSigner = ethSigner.connect(provider);
+        const txDataArgs = await this.prepareTxArgsSubmitV2(txData, zkProofResponses);
+        const feeData = await provider.getFeeData();
+        const maxFeePerGas = chainConfig.maxFeePerGas
+            ? BigInt(chainConfig.maxFeePerGas)
+            : feeData.maxFeePerGas;
+        const maxPriorityFeePerGas = chainConfig.maxPriorityFeePerGas
+            ? BigInt(chainConfig.maxPriorityFeePerGas)
+            : feeData.maxPriorityFeePerGas;
+        const verifierContract = new Contract(txData.contract_address, abi$1);
+        const txRequestData = await verifierContract.submitZKPResponseV2.populateTransaction(...txDataArgs);
+        const request = {
+            to: txData.contract_address,
+            data: txRequestData.data,
+            maxFeePerGas,
+            maxPriorityFeePerGas
+        };
+        let gasLimit;
+        try {
+            gasLimit = await ethSigner.estimateGas(request);
+        }
+        catch (e) {
+            gasLimit = maxGasLimit;
+        }
+        request.gasLimit = gasLimit;
+        const transactionService = new TransactionService(provider);
+        const { txnHash } = await transactionService.sendTransactionRequest(ethSigner, request);
+        return new Map().set(txnHash, zkProofResponses);
+    }
+    async prepareTxArgsSubmitV2(txData, zkProofResponses) {
+        if (txData.method_id.replace('0x', '') !== FunctionSignatures.SubmitZKPResponseV2) {
+            throw new Error(`submit cross chain doesn't implement requested method id. Only '0x${FunctionSignatures.SubmitZKPResponseV2}' is supported.`);
+        }
+        if (!this._opts?.didResolverUrl) {
+            throw new Error(`did resolver url required for crosschain verification`);
+        }
+        const gistUpdateArr = [];
+        const stateUpdateArr = [];
+        const payload = [];
+        // Resolved gists and states to avoid duplicate requests
+        const gistUpdateResolutionsPending = [];
+        const stateUpdateResolutionsPending = [];
+        for (const zkProof of zkProofResponses) {
+            const requestID = zkProof.id;
+            const inputs = zkProof.pub_signals;
+            if (!this._supportedCircuits.includes(zkProof.circuitId)) {
+                throw new Error(`Circuit ${zkProof.circuitId} not supported by OnChainZKPVerifier`);
+            }
+            const zkProofEncoded = this.packZkpProof(inputs, zkProof.proof.pi_a.slice(0, 2), [
+                [zkProof.proof.pi_b[0][1], zkProof.proof.pi_b[0][0]],
+                [zkProof.proof.pi_b[1][1], zkProof.proof.pi_b[1][0]]
+            ], zkProof.proof.pi_c.slice(0, 2));
+            const stateInfo = this.getOnChainGistRootStatePubSignals(zkProof.circuitId, zkProof.pub_signals);
+            const gistUpdateResolutions = [];
+            for (const gist of stateInfo.gists) {
+                const gistResolutionPending = gistUpdateResolutionsPending.find((g) => g == JSON.stringify(gist));
+                if (gistResolutionPending) {
+                    continue;
+                }
+                gistUpdateResolutionsPending.push(JSON.stringify(gist));
+                gistUpdateResolutions.push(this.resolveDidDocumentEip712MessageAndSignature(DID.parseFromId(gist.id), this._opts.didResolverUrl, { gist: gist.root }));
+            }
+            const stateUpdateResolutions = [];
+            for (const state of stateInfo.states) {
+                const stateResolutionPending = stateUpdateResolutionsPending.find((s) => s == JSON.stringify(state));
+                if (stateResolutionPending) {
+                    continue;
+                }
+                stateUpdateResolutionsPending.push(JSON.stringify(state));
+                stateUpdateResolutions.push(this.resolveDidDocumentEip712MessageAndSignature(DID.parseFromId(state.id), this._opts.didResolverUrl, {
+                    state: state.state
+                }));
+            }
+            if (gistUpdateResolutions.length > 0) {
+                gistUpdateArr.push(...(await Promise.all(gistUpdateResolutions)));
+            }
+            if (stateUpdateResolutions.length > 0) {
+                stateUpdateArr.push(...(await Promise.all(stateUpdateResolutions)));
+            }
+            const metadataArr = [];
+            if (zkProof.vp) {
+                for (const key in zkProof.vp.verifiableCredential.credentialSubject) {
+                    if (key === '@type') {
+                        continue;
+                    }
+                    const metadataValue = poseidon.hashBytes(byteEncoder.encode(JSON.stringify(zkProof.vp.verifiableCredential.credentialSubject[key])));
+                    const bytesValue = byteEncoder.encode(metadataValue.toString());
+                    metadataArr.push({
+                        key,
+                        value: bytesValue
+                    });
+                }
+            }
+            const metadata = this.packMetadatas(metadataArr);
+            payload.push({
+                requestId: requestID,
+                zkProof: zkProofEncoded,
+                data: metadata
+            });
+        }
+        const crossChainProofs = this.packCrossChainProofs(gistUpdateArr, stateUpdateArr);
+        return [payload, crossChainProofs];
+    }
+    packZkpProof(inputs, a, b, c) {
+        return this._abiCoder.encode(['uint256[] inputs', 'uint256[2]', 'uint256[2][2]', 'uint256[2]'], [inputs, a, b, c]);
+    }
+    packCrossChainProofs(gistUpdateArr, stateUpdateArr) {
+        const proofs = [];
+        for (const globalStateUpdate of gistUpdateArr) {
+            proofs.push({
+                proofType: 'globalStateProof',
+                proof: this.packGlobalStateMsg(globalStateUpdate)
+            });
+        }
+        for (const stateUpdate of stateUpdateArr) {
+            proofs.push({
+                proofType: 'stateProof',
+                proof: this.packIdentityStateMsg(stateUpdate)
+            });
+        }
+        return this._abiCoder.encode(['tuple(' + 'string proofType,' + 'bytes proof' + ')[]'], [proofs]);
+    }
+    packGlobalStateMsg(msg) {
+        return this._abiCoder.encode([
+            'tuple(' +
+                'tuple(' +
+                'uint256 timestamp,' +
+                'bytes2 idType,' +
+                'uint256 root,' +
+                'uint256 replacedAtTimestamp' +
+                ') globalStateMsg,' +
+                'bytes signature,' +
+                ')'
+        ], [msg]);
+    }
+    packIdentityStateMsg(msg) {
+        return this._abiCoder.encode([
+            'tuple(' +
+                'tuple(' +
+                'uint256 timestamp,' +
+                'uint256 id,' +
+                'uint256 state,' +
+                'uint256 replacedAtTimestamp' +
+                ') idStateMsg,' +
+                'bytes signature,' +
+                ')'
+        ], [msg]);
+    }
+    packMetadatas(metas) {
+        return this._abiCoder.encode(['tuple(' + 'string key,' + 'bytes value' + ')[]'], [metas]);
+    }
+    getOnChainGistRootStatePubSignals(onChainCircuitId, inputs) {
+        let atomicQueryPubSignals;
+        switch (onChainCircuitId) {
+            case CircuitId.AtomicQueryMTPV2OnChain:
+                atomicQueryPubSignals = new AtomicQueryMTPV2OnChainPubSignals();
+                break;
+            case CircuitId.AtomicQuerySigV2OnChain:
+                atomicQueryPubSignals = new AtomicQuerySigV2OnChainPubSignals();
+                break;
+            case CircuitId.AtomicQueryV3OnChain:
+                atomicQueryPubSignals = new AtomicQueryV3OnChainPubSignals();
+                break;
+        }
+        const encodedInputs = byteEncoder.encode(JSON.stringify(inputs));
+        atomicQueryPubSignals.pubSignalsUnmarshal(encodedInputs);
+        return atomicQueryPubSignals.getStatesInfo();
+    }
+    async resolveDidDocumentEip712MessageAndSignature(did, resolverUrl, opts) {
+        const didDoc = await resolveDidDocument(did, resolverUrl, {
+            ...opts,
+            signature: DIDDocumentSignature.EthereumEip712Signature2021
+        });
+        if (!didDoc.didResolutionMetadata.proof?.length) {
+            throw new Error('No proof found in resolved DID document');
+        }
+        const message = didDoc.didResolutionMetadata.proof[0].eip712.message;
+        const signature = didDoc.didResolutionMetadata.proof[0].proofValue;
+        const isGistRequest = opts?.gist && !opts.state;
+        if (isGistRequest) {
+            return {
+                globalStateMsg: {
+                    timestamp: message.timestamp,
+                    idType: message.idType,
+                    root: message.root,
+                    replacedAtTimestamp: message.replacedAtTimestamp
+                },
+                signature
+            };
+        }
+        return {
+            idStateMsg: {
+                timestamp: message.timestamp,
+                id: message.id,
+                state: message.state,
+                replacedAtTimestamp: message.replacedAtTimestamp
+            },
+            signature
+        };
+    }
 }
 
 var abi = [
@@ -54527,6 +55375,8 @@ const PROTOCOL_MESSAGE_TYPE = Object.freeze({
     REVOCATION_STATUS_RESPONSE_MESSAGE_TYPE: `${IDEN3_PROTOCOL}revocation/1.0/status`,
     // ContractInvokeRequestMessageType is type for request of contract invoke request
     CONTRACT_INVOKE_REQUEST_MESSAGE_TYPE: `${IDEN3_PROTOCOL}proofs/1.0/contract-invoke-request`,
+    // ContractInvokeResponseMessageType is type for response of contract invoke request
+    CONTRACT_INVOKE_RESPONSE_MESSAGE_TYPE: `${IDEN3_PROTOCOL}proofs/1.0/contract-invoke-response`,
     // CredentialOnchainOfferMessageType is type of message with credential onchain offering
     CREDENTIAL_ONCHAIN_OFFER_MESSAGE_TYPE: `${IDEN3_PROTOCOL}credentials/1.0/onchain-offer`,
     // ProposalRequestMessageType is type for proposal-request message
@@ -56827,9 +57677,11 @@ class ContractRequestHandler extends AbstractMessageHandler {
     }
     async handle(message, ctx) {
         switch (message.type) {
-            case PROTOCOL_MESSAGE_TYPE.CONTRACT_INVOKE_REQUEST_MESSAGE_TYPE:
-                await this.handleContractInvoke(message, ctx);
-                return null;
+            case PROTOCOL_MESSAGE_TYPE.CONTRACT_INVOKE_REQUEST_MESSAGE_TYPE: {
+                const ciMessage = message;
+                const txHashResponsesMap = await this.handleContractInvoke(ciMessage, ctx);
+                return this.createContractInvokeResponse(ciMessage, txHashResponsesMap);
+            }
             default:
                 return super.handle(message, ctx);
         }
@@ -56849,7 +57701,21 @@ class ContractRequestHandler extends AbstractMessageHandler {
         }
         const verifierDid = message.from ? DID.parse(message.from) : undefined;
         const zkpResponses = await processZeroKnowledgeProofRequests(did, message?.body?.scope, verifierDid, this._proofService, { ethSigner, challenge, supportedCircuits: this._supportedCircuits });
-        return this._zkpVerifier.submitZKPResponse(ethSigner, message.body.transaction_data, zkpResponses);
+        const methodId = message.body.transaction_data.method_id.replace('0x', '');
+        switch (methodId) {
+            case FunctionSignatures.SubmitZKPResponseV2:
+                return this._zkpVerifier.submitZKPResponseV2(ethSigner, message.body.transaction_data, zkpResponses);
+            case FunctionSignatures.SubmitZKPResponseV1: {
+                const txHashZkpResponseMap = await this._zkpVerifier.submitZKPResponse(ethSigner, message.body.transaction_data, zkpResponses);
+                const response = new Map();
+                for (const [txHash, zkpResponse] of txHashZkpResponseMap) {
+                    response.set(txHash, [zkpResponse]);
+                }
+                return response;
+            }
+            default:
+                throw new Error(`Not supported method id. Only '${FunctionSignatures.SubmitZKPResponseV1} and ${FunctionSignatures.SubmitZKPResponseV2} are supported.'`);
+        }
     }
     /**
      * unpacks contract-invoke request
@@ -56867,8 +57733,41 @@ class ContractRequestHandler extends AbstractMessageHandler {
         return ciRequest;
     }
     /**
-     * handle contract invoker request
+     * creates contract invoke response
+     * @private
      * @beta
+     * @param {ContractInvokeRequest} request - ContractInvokeRequest
+     * @param { Map<string, ZeroKnowledgeProofResponse[]>} responses - map tx hash to array of ZeroKnowledgeProofResponses
+     * @returns `Promise<ContractInvokeResponse>`
+     */
+    async createContractInvokeResponse(request, txHashToZkpResponseMap) {
+        const contractInvokeResponse = {
+            id: request.id,
+            thid: request.thid,
+            type: PROTOCOL_MESSAGE_TYPE.CONTRACT_INVOKE_RESPONSE_MESSAGE_TYPE,
+            from: request.to,
+            to: request.from,
+            body: {
+                transaction_data: request.body.transaction_data,
+                reason: request.body.reason,
+                scope: []
+            }
+        };
+        for (const [txHash, zkpResponses] of txHashToZkpResponseMap) {
+            for (const zkpResponse of zkpResponses) {
+                contractInvokeResponse.body.scope.push({
+                    txHash,
+                    ...zkpResponse
+                });
+            }
+        }
+        return contractInvokeResponse;
+    }
+    /**
+     * handle contract invoke request
+     * supports only 0xb68967e2 method id
+     * @beta
+     * @deprecated
      * @param {did} did  - sender DID
      * @param {ContractInvokeRequest} request  - contract invoke request
      * @param {ContractInvokeHandlerOptions} opts - handler options
@@ -56876,11 +57775,24 @@ class ContractRequestHandler extends AbstractMessageHandler {
      */
     async handleContractInvokeRequest(did, request, opts) {
         const ciRequest = await this.parseContractInvokeRequest(request);
-        return this.handleContractInvoke(ciRequest, {
-            senderDid: did,
-            ethSigner: opts.ethSigner,
-            challenge: opts.challenge
-        });
+        if (ciRequest.body.transaction_data.method_id !== FunctionSignatures.SubmitZKPResponseV1) {
+            throw new Error(`please use handle method to work with other method ids`);
+        }
+        if (ciRequest.type !== PROTOCOL_MESSAGE_TYPE.CONTRACT_INVOKE_REQUEST_MESSAGE_TYPE) {
+            throw new Error('Invalid message type for contract invoke request');
+        }
+        const { ethSigner, challenge } = opts;
+        if (!ethSigner) {
+            throw new Error("Can't sign transaction. Provide Signer in options.");
+        }
+        const { chain_id } = ciRequest.body.transaction_data;
+        const networkFlag = Object.keys(ChainIds).find((key) => ChainIds[key] === chain_id);
+        if (!networkFlag) {
+            throw new Error(`Invalid chain id ${chain_id}`);
+        }
+        const verifierDid = ciRequest.from ? DID.parse(ciRequest.from) : undefined;
+        const zkpResponses = await processZeroKnowledgeProofRequests(did, ciRequest?.body?.scope, verifierDid, this._proofService, { ethSigner, challenge, supportedCircuits: this._supportedCircuits });
+        return this._zkpVerifier.submitZKPResponse(ethSigner, ciRequest.body.transaction_data, zkpResponses);
     }
 }
 
@@ -59481,5 +60393,5 @@ class IdentityWallet {
     }
 }
 
-export { AbstractMessageHandler, AbstractPrivateKeyStore, AgentResolver, AtomicQueryMTPV2Inputs, AtomicQueryMTPV2OnChainInputs, AtomicQueryMTPV2OnChainPubSignals, AtomicQueryMTPV2PubSignals, AtomicQuerySigV2Inputs, AtomicQuerySigV2OnChainCircuitInputs, AtomicQuerySigV2OnChainInputs, AtomicQuerySigV2OnChainPubSignals, AtomicQuerySigV2PubSignals, AtomicQueryV3Inputs, AtomicQueryV3OnChainInputs, AtomicQueryV3OnChainPubSignals, AtomicQueryV3PubSignals, AuthHandler, AuthV2Inputs, AuthV2PubSignals, BJJSignatureProof2021, BaseConfig, BjjProvider, BrowserDataSource, CircuitClaim, CircuitError, CircuitId, CircuitStorage, ContractRequestHandler, CredentialOfferStatus, CredentialProposalHandler, CredentialStatusPublisherRegistry, CredentialStatusResolverRegistry, CredentialStatusType, CredentialStorage, CredentialWallet, DIDDocumentJSONSchema, DataPrepareHandlerFunc, DisplayMethodType, Ed25519Provider, ErrorEmptyAuthClaimNonRevProof, ErrorEmptyAuthClaimProof, ErrorEmptyChallengeSignature, ErrorEmptyClaimNonRevProof, ErrorEmptyClaimProof, ErrorEmptyClaimSignature, ErrorEmptyIssuerAuthClaimNonRevProof, ErrorEmptyIssuerAuthClaimProof, ErrorUserStateInRelayClaimProof, EthStateStorage, FSCircuitStorage, FetchHandler, FilterQuery, 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, Operators, constants as PROTOCOL_CONSTANTS, PackageManager, Parser, PaymentHandler, PaymentRequestDataType, PaymentRequestType, PaymentType, PlainPacker, ProofNode, ProofPurpose, ProofService, ProofType, PubSignalsVerifier, Query, QueryOperators, RHSResolver, RefreshHandler, RefreshServiceType, RevocationStatusHandler, SDK_EVENTS, Scalar, SearchError, Sec256k1Provider, StandardJSONCredentialsQueryFilter, StateTransitionInputs, StateTransitionPubSignals, SubjectPosition, SupportedCurrencies, TransactionService, ValueProof, Vector, VerifiableConstants, VerificationHandlerFunc, W3CCredential, XSDNS, ZKPPacker, availableTypesOperators, base58ToBytes$1 as base58ToBytes, base64ToBytes$1 as base64ToBytes, base64UrlToBytes, bigIntArrayToStringArray, bigIntCompare, buildDIDFromEthPubKey, buildFieldPath, buildTreeState, buildVerifierId, byteDecoder, byteEncoder, bytesToBase58$1 as bytesToBase58, bytesToBase64, bytesToBase64url$1 as bytesToBase64url, bytesToHex$3 as bytesToHex, cacheLoader, calculateCoreSchemaHash, calculateQueryHashV2, calculateQueryHashV3, checkCircuitOperator, checkCircuitQueriesLength, checkDataInField, checkQueryRequest, circuitValidator, comparatorOptions, createAuthorizationRequest, createAuthorizationRequestWithMessage, createPayment, createPaymentRequest, 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, getFieldSlotIndex, getKMSIdByAuthCredential, getNodeAuxValue, getNodesRepresentation, getOperatorNameByValue, getProperties, getSerializationAttrFromContext, getSerializationAttrFromParsedContext, getUserDIDFromCredential, hexToBytes$3 as hexToBytes, isEthereumIdentity, isGenesisState, isGenesisStateId, isIssuerGenesis, isValidOperation, keyPath, mergeObjects, parseCoreClaimSlots, parseCredentialSubject, parseQueriesMetadata, parseQueryMetadata, parseSerializationAttr, prepareCircuitArrayValues, prepareSiblingsStr, processZeroKnowledgeProofRequests, pushHashesToRHS, resolveDIDDocumentAuth, resolvePath, resolveVerificationMethods, strMTHex, stringByPath, subjectPositionIndex, swapEndianness, toClaimNonRevStatus, toGISTProof, toRevocationStatus, transformQueryValueToBigInts, userStateError, validateDIDDocumentAuth, validateDisclosureNativeSDSupport, validateDisclosureV2Circuit, validateEmptyCredentialSubjectNoopNativeSupport, validateEmptyCredentialSubjectV2Circuit, validateOperators, validateTreeState, verifyFieldValueInclusionNativeExistsSupport, verifyFieldValueInclusionV2, witnessBuilder };
+export { AbstractMessageHandler, AbstractPrivateKeyStore, AgentResolver, AtomicQueryMTPV2Inputs, AtomicQueryMTPV2OnChainInputs, AtomicQueryMTPV2OnChainPubSignals, AtomicQueryMTPV2PubSignals, AtomicQuerySigV2Inputs, AtomicQuerySigV2OnChainCircuitInputs, AtomicQuerySigV2OnChainInputs, AtomicQuerySigV2OnChainPubSignals, AtomicQuerySigV2PubSignals, AtomicQueryV3Inputs, AtomicQueryV3OnChainInputs, AtomicQueryV3OnChainPubSignals, AtomicQueryV3PubSignals, AuthHandler, AuthV2Inputs, AuthV2PubSignals, BJJSignatureProof2021, BaseConfig, BjjProvider, BrowserDataSource, CircuitClaim, CircuitError, CircuitId, CircuitStorage, ContractRequestHandler, CredentialOfferStatus, CredentialProposalHandler, CredentialStatusPublisherRegistry, CredentialStatusResolverRegistry, CredentialStatusType, CredentialStorage, CredentialWallet, DIDDocumentJSONSchema, DIDDocumentSignature, DataPrepareHandlerFunc, 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, Operators, constants as PROTOCOL_CONSTANTS, PackageManager, Parser, PaymentHandler, PaymentRequestDataType, PaymentRequestType, PaymentType, PlainPacker, ProofNode, ProofPurpose, ProofService, ProofType, PubSignalsVerifier, Query, QueryOperators, RHSResolver, RefreshHandler, RefreshServiceType, RevocationStatusHandler, SDK_EVENTS, Scalar, SearchError, Sec256k1Provider, StandardJSONCredentialsQueryFilter, StateTransitionInputs, StateTransitionPubSignals, SubjectPosition, SupportedCurrencies, TransactionService, ValueProof, Vector, VerifiableConstants, VerificationHandlerFunc, W3CCredential, XSDNS, ZKPPacker, availableTypesOperators, base58ToBytes$1 as base58ToBytes, base64ToBytes$1 as base64ToBytes, base64UrlToBytes, bigIntArrayToStringArray, bigIntCompare, buildDIDFromEthPubKey, buildFieldPath, buildTreeState, buildVerifierId, byteDecoder, byteEncoder, bytesToBase58$1 as bytesToBase58, bytesToBase64, bytesToBase64url$1 as bytesToBase64url, bytesToHex$3 as bytesToHex, cacheLoader, calculateCoreSchemaHash, calculateQueryHashV2, calculateQueryHashV3, checkCircuitOperator, checkCircuitQueriesLength, checkDataInField, checkQueryRequest, circuitValidator, comparatorOptions, createAuthorizationRequest, createAuthorizationRequestWithMessage, createPayment, createPaymentRequest, 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, getFieldSlotIndex, getKMSIdByAuthCredential, getNodeAuxValue, getNodesRepresentation, getOperatorNameByValue, getProperties, getSerializationAttrFromContext, getSerializationAttrFromParsedContext, getUserDIDFromCredential, hexToBytes$3 as hexToBytes, isEthereumIdentity, isGenesisState, isGenesisStateId, isIssuerGenesis, isValidOperation, keyPath, mergeObjects, parseCoreClaimSlots, parseCredentialSubject, parseQueriesMetadata, parseQueryMetadata, parseSerializationAttr, prepareCircuitArrayValues, prepareSiblingsStr, processZeroKnowledgeProofRequests, pushHashesToRHS, resolveDIDDocumentAuth, resolveDidDocument, resolvePath, resolveVerificationMethods, strMTHex, stringByPath, subjectPositionIndex, swapEndianness, toClaimNonRevStatus, toGISTProof, toRevocationStatus, transformQueryValueToBigInts, userStateError, validateDIDDocumentAuth, validateDisclosureNativeSDSupport, validateDisclosureV2Circuit, validateEmptyCredentialSubjectNoopNativeSupport, validateEmptyCredentialSubjectV2Circuit, validateOperators, validateTreeState, verifyFieldValueInclusionNativeExistsSupport, verifyFieldValueInclusionV2, witnessBuilder };
 //# sourceMappingURL=index.js.map