@0xpolygonid/js-sdk 1.17.8 → 1.18.1

package/dist/node/cjs/storage/blockchain/onchain-zkp-verifier.js

@@ -3,10 +3,29 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OnChainZKPVerifier = void 0;
+exports.OnChainZKPVerifier = exports.FunctionSignatures = void 0;
 const ethers_1 = require("ethers");
 const ZkpVerifier_json_1 = __importDefault(require("./abi/ZkpVerifier.json"));
 const blockchain_1 = require("../../blockchain");
+const js_iden3_core_1 = require("@iden3/js-iden3-core");
+const circuits_1 = require("../../circuits");
+const utils_1 = require("../../utils");
+const js_crypto_1 = require("@iden3/js-crypto");
+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 = exports.FunctionSignatures || (exports.FunctionSignatures = {}));
 /**
  * OnChainZKPVerifier is a class that allows to interact with the OnChainZKPVerifier contract
  * and submitZKPResponse.
@@ -21,70 +40,302 @@ class OnChainZKPVerifier {
      * @beta
      * @param {EthConnectionConfig[]} - array of ETH configs
      */
-    constructor(_configs) {
+    constructor(_configs, _opts) {
         this._configs = _configs;
+        this._opts = _opts;
+        /**
+         * supported circuits
+         */
+        this._supportedCircuits = [
+            circuits_1.CircuitId.AtomicQueryMTPV2OnChain,
+            circuits_1.CircuitId.AtomicQuerySigV2OnChain,
+            circuits_1.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 ethers_1.ethers.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 ethers_1.JsonRpcProvider(chainConfig.url, chainConfig.chainId);
-        const verifierContract = new ethers_1.Contract(txData.contract_address, ZkpVerifier_json_1.default, 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 ethers_1.Contract(txData.contract_address, ZkpVerifier_json_1.default);
+        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 blockchain_1.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 ethers_1.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 ethers_1.Contract(txData.contract_address, ZkpVerifier_json_1.default);
+        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 blockchain_1.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(js_iden3_core_1.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(js_iden3_core_1.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 = js_crypto_1.poseidon.hashBytes(utils_1.byteEncoder.encode(JSON.stringify(zkProof.vp.verifiableCredential.credentialSubject[key])));
+                    const bytesValue = utils_1.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 circuits_1.CircuitId.AtomicQueryMTPV2OnChain:
+                atomicQueryPubSignals = new circuits_1.AtomicQueryMTPV2OnChainPubSignals();
+                break;
+            case circuits_1.CircuitId.AtomicQuerySigV2OnChain:
+                atomicQueryPubSignals = new circuits_1.AtomicQuerySigV2OnChainPubSignals();
+                break;
+            case circuits_1.CircuitId.AtomicQueryV3OnChain:
+                atomicQueryPubSignals = new circuits_1.AtomicQueryV3OnChainPubSignals();
+                break;
+        }
+        const encodedInputs = utils_1.byteEncoder.encode(JSON.stringify(inputs));
+        atomicQueryPubSignals.pubSignalsUnmarshal(encodedInputs);
+        return atomicQueryPubSignals.getStatesInfo();
+    }
+    async resolveDidDocumentEip712MessageAndSignature(did, resolverUrl, opts) {
+        const didDoc = await (0, utils_1.resolveDidDocument)(did, resolverUrl, {
+            ...opts,
+            signature: utils_1.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
+        };
+    }
 }
 exports.OnChainZKPVerifier = OnChainZKPVerifier;

package/dist/node/cjs/utils/did-helper.js

@@ -1,11 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildDIDFromEthPubKey = exports.resolveDIDDocumentAuth = exports.validateDIDDocumentAuth = exports.buildVerifierId = exports.isEthereumIdentity = exports.isGenesisState = void 0;
+exports.buildDIDFromEthPubKey = exports.resolveDidDocument = exports.resolveDIDDocumentAuth = exports.validateDIDDocumentAuth = exports.buildVerifierId = exports.isEthereumIdentity = exports.isGenesisState = exports.DIDDocumentSignature = void 0;
 const js_crypto_1 = require("@iden3/js-crypto");
 const js_iden3_core_1 = require("@iden3/js-iden3-core");
 const js_merkletree_1 = require("@iden3/js-merkletree");
 const js_sha3_1 = require("js-sha3");
 const encoding_1 = require("./encoding");
+/**
+ * Supported DID Document Signatures
+ */
+var DIDDocumentSignature;
+(function (DIDDocumentSignature) {
+    DIDDocumentSignature["EthereumEip712Signature2021"] = "EthereumEip712Signature2021";
+})(DIDDocumentSignature = exports.DIDDocumentSignature || (exports.DIDDocumentSignature = {}));
 /**
  * Checks if state is genesis state
  *
@@ -74,6 +81,35 @@ const resolveDIDDocumentAuth = async (did, resolveURL, state) => {
     return didResolutionRes.didDocument?.verificationMethod?.find((i) => i.type === 'Iden3StateInfo2023');
 };
 exports.resolveDIDDocumentAuth = resolveDIDDocumentAuth;
+function emptyStateDID(did) {
+    const id = js_iden3_core_1.DID.idFromDID(did);
+    const didType = (0, js_iden3_core_1.buildDIDType)(js_iden3_core_1.DID.methodFromId(id), js_iden3_core_1.DID.blockchainFromId(id), js_iden3_core_1.DID.networkIdFromId(id));
+    const identifier = js_iden3_core_1.Id.idGenesisFromIdenState(didType, 0n);
+    const emptyDID = js_iden3_core_1.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;
+};
+exports.resolveDidDocument = resolveDidDocument;
 const buildDIDFromEthPubKey = (didType, pubKeyEth) => {
     // Use Keccak-256 hash function to get public key hash
     const hashOfPublicKey = (0, js_sha3_1.keccak256)((0, encoding_1.hexToBytes)(pubKeyEth));

package/dist/node/esm/circuits/atomic-query-mtp-v2-on-chain.js

@@ -177,4 +177,14 @@ export 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 }]
+        };
+    }
 }

package/dist/node/esm/circuits/atomic-query-sig-v2-on-chain.js

@@ -226,4 +226,14 @@ export 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 }]
+        };
+    }
 }

package/dist/node/esm/circuits/atomic-query-v3-on-chain.js

@@ -303,4 +303,14 @@ export 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 }]
+        };
+    }
 }

package/dist/node/esm/iden3comm/constants.js

@@ -31,6 +31,8 @@ export 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

package/dist/node/esm/iden3comm/handlers/contract-request.js

@@ -1,6 +1,7 @@
 import { CircuitId } from '../../circuits/models';
 import { PROTOCOL_MESSAGE_TYPE } from '../constants';
 import { DID, ChainIds } from '@iden3/js-iden3-core';
+import { FunctionSignatures } from '../../storage';
 import { processZeroKnowledgeProofRequests } from './common';
 import { AbstractMessageHandler } from './message-handler';
 /**
@@ -33,9 +34,11 @@ export 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);
         }
@@ -55,7 +58,21 @@ export 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
@@ -73,8 +90,41 @@ export 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
@@ -82,10 +132,23 @@ export 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);
     }
 }