@0xpolygonid/js-sdk 1.17.8 → 1.18.1

package/dist/browser/umd/index.js

@@ -1334,6 +1334,13 @@ var PolygonIdSdk = (function (exports) {
 
     var sha3Exports = sha3$1.exports;
 
+    /**
+     * Supported DID Document Signatures
+     */
+    exports.DIDDocumentSignature = void 0;
+    (function (DIDDocumentSignature) {
+        DIDDocumentSignature["EthereumEip712Signature2021"] = "EthereumEip712Signature2021";
+    })(exports.DIDDocumentSignature || (exports.DIDDocumentSignature = {}));
     /**
      * Checks if state is genesis state
      *
@@ -1397,6 +1404,34 @@ var PolygonIdSdk = (function (exports) {
         const didResolutionRes = (await resp.json());
         return didResolutionRes.didDocument?.verificationMethod?.find((i) => i.type === 'Iden3StateInfo2023');
     };
+    function emptyStateDID(did) {
+        const id = Z$2.idFromDID(did);
+        const didType = G$2(Z$2.methodFromId(id), Z$2.blockchainFromId(id), Z$2.networkIdFromId(id));
+        const identifier = H$2.idGenesisFromIdenState(didType, 0n);
+        const emptyDID = Z$2.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));
@@ -49932,6 +49967,16 @@ var PolygonIdSdk = (function (exports) {
             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 }]
+            };
+        }
     }
 
     /**
@@ -50713,6 +50758,16 @@ var PolygonIdSdk = (function (exports) {
             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 }]
+            };
+        }
     }
 
     /**
@@ -50938,6 +50993,16 @@ var PolygonIdSdk = (function (exports) {
             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 }]
+            };
+        }
     }
 
     /**
@@ -52497,6 +52562,103 @@ var PolygonIdSdk = (function (exports) {
     }
 
     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: [
@@ -52516,6 +52678,62 @@ var PolygonIdSdk = (function (exports) {
     		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: [
     		],
@@ -52530,6 +52748,165 @@ var PolygonIdSdk = (function (exports) {
     		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: [
     			{
@@ -52559,7 +52936,7 @@ var PolygonIdSdk = (function (exports) {
     					}
     				],
     				internalType: "struct IZKPVerifier.ZKPRequest",
-    				name: "",
+    				name: "zkpRequest",
     				type: "tuple"
     			}
     		],
@@ -52621,6 +52998,82 @@ var PolygonIdSdk = (function (exports) {
     		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: [
     		],
@@ -52637,26 +53090,30 @@ var PolygonIdSdk = (function (exports) {
     	},
     	{
     		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"
     	},
     	{
@@ -52687,6 +53144,25 @@ var PolygonIdSdk = (function (exports) {
     		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: [
     			{
@@ -52757,6 +53233,42 @@ var PolygonIdSdk = (function (exports) {
     		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: [
     			{
@@ -52770,9 +53282,113 @@ var PolygonIdSdk = (function (exports) {
     		],
     		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
+     */
+    exports.FunctionSignatures = void 0;
+    (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";
+    })(exports.FunctionSignatures || (exports.FunctionSignatures = {}));
     /**
      * OnChainZKPVerifier is a class that allows to interact with the OnChainZKPVerifier contract
      * and submitZKPResponse.
@@ -52787,71 +53403,303 @@ var PolygonIdSdk = (function (exports) {
          * @beta
          * @param {EthConnectionConfig[]} - array of ETH configs
          */
-        constructor(_configs) {
+        constructor(_configs, _opts) {
             this._configs = _configs;
+            this._opts = _opts;
+            /**
+             * supported circuits
+             */
+            this._supportedCircuits = [
+                exports.CircuitId.AtomicQueryMTPV2OnChain,
+                exports.CircuitId.AtomicQuerySigV2OnChain,
+                exports.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', '') !== exports.FunctionSignatures.SubmitZKPResponseV1) {
+                throw new Error(`prepareTxArgsSubmitV1 function doesn't implement requested method id. Only '0x${exports.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', '') !== exports.FunctionSignatures.SubmitZKPResponseV1) {
+                throw new Error(`submitZKPResponse function doesn't implement requested method id. Only '0x${exports.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', '') !== exports.FunctionSignatures.SubmitZKPResponseV2) {
+                throw new Error(`submitZKPResponseV2 function doesn't implement requested method id. Only '0x${exports.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', '') !== exports.FunctionSignatures.SubmitZKPResponseV2) {
+                throw new Error(`submit cross chain doesn't implement requested method id. Only '0x${exports.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(Z$2.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(Z$2.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 = $$2.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 exports.CircuitId.AtomicQueryMTPV2OnChain:
+                    atomicQueryPubSignals = new AtomicQueryMTPV2OnChainPubSignals();
+                    break;
+                case exports.CircuitId.AtomicQuerySigV2OnChain:
+                    atomicQueryPubSignals = new AtomicQuerySigV2OnChainPubSignals();
+                    break;
+                case exports.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: exports.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 = [
@@ -54666,6 +55514,8 @@ var PolygonIdSdk = (function (exports) {
         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
@@ -77709,9 +78559,11 @@ var PolygonIdSdk = (function (exports) {
         }
         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);
             }
@@ -77731,7 +78583,21 @@ var PolygonIdSdk = (function (exports) {
             }
             const verifierDid = message.from ? Z$2.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 exports.FunctionSignatures.SubmitZKPResponseV2:
+                    return this._zkpVerifier.submitZKPResponseV2(ethSigner, message.body.transaction_data, zkpResponses);
+                case exports.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 '${exports.FunctionSignatures.SubmitZKPResponseV1} and ${exports.FunctionSignatures.SubmitZKPResponseV2} are supported.'`);
+            }
         }
         /**
          * unpacks contract-invoke request
@@ -77749,8 +78615,41 @@ var PolygonIdSdk = (function (exports) {
             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
@@ -77758,11 +78657,24 @@ var PolygonIdSdk = (function (exports) {
          */
         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 !== exports.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(u$2).find((key) => u$2[key] === chain_id);
+            if (!networkFlag) {
+                throw new Error(`Invalid chain id ${chain_id}`);
+            }
+            const verifierDid = ciRequest.from ? Z$2.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);
         }
     }
 
@@ -80548,6 +81460,7 @@ var PolygonIdSdk = (function (exports) {
     exports.processZeroKnowledgeProofRequests = processZeroKnowledgeProofRequests;
     exports.pushHashesToRHS = pushHashesToRHS;
     exports.resolveDIDDocumentAuth = resolveDIDDocumentAuth;
+    exports.resolveDidDocument = resolveDidDocument;
     exports.resolvePath = resolvePath;
     exports.resolveVerificationMethods = resolveVerificationMethods;
     exports.strMTHex = strMTHex;