@0xpolygonid/js-sdk 1.28.0 → 1.29.0

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

@@ -50,7 +50,9 @@ exports.PROTOCOL_MESSAGE_TYPE = Object.freeze({
     // DiscoveryProtocolQueriesMessageType is type for didcomm discovery protocol queries
     DISCOVERY_PROTOCOL_QUERIES_MESSAGE_TYPE: `${DIDCOMM_PROTOCOL}discover-features/2.0/queries`,
     // DiscoveryProtocolDiscloseMessageType is type for didcomm discovery protocol disclose
-    DISCOVERY_PROTOCOL_DISCLOSE_MESSAGE_TYPE: `${DIDCOMM_PROTOCOL}discover-features/2.0/disclose`
+    DISCOVERY_PROTOCOL_DISCLOSE_MESSAGE_TYPE: `${DIDCOMM_PROTOCOL}discover-features/2.0/disclose`,
+    // ProblemReportMessageType is type for didcomm problem report
+    PROBLEM_REPORT_MESSAGE_TYPE: `${DIDCOMM_PROTOCOL}report-problem/2.0/problem-report`
 });
 /**
  * Media types for iden3 comm communication protocol

package/dist/node/cjs/iden3comm/handlers/common.js

@@ -1,9 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.verifyExpiresTime = exports.processZeroKnowledgeProofRequests = void 0;
+exports.packEthIdentityProof = exports.verifyExpiresTime = exports.processProofAuth = exports.processZeroKnowledgeProofRequests = void 0;
 const js_crypto_1 = require("@iden3/js-crypto");
+const types_1 = require("../types");
 const utils_1 = require("../../utils");
 const js_iden3_core_1 = require("@iden3/js-iden3-core");
+const circuits_1 = require("../../circuits");
+const constants_1 = require("../constants");
+const utils_2 = require("../utils");
 /**
  * Groups the ZeroKnowledgeProofRequest objects based on their groupId.
  * Returns a Map where the key is the groupId and the value is an object containing the query and linkNonce.
@@ -84,6 +88,60 @@ const processZeroKnowledgeProofRequests = async (to, requests, from, proofServic
     return zkpResponses;
 };
 exports.processZeroKnowledgeProofRequests = processZeroKnowledgeProofRequests;
+/**
+ * Processes auth proof requests.
+ *
+ * @param to - The identifier of the recipient.
+ * @param proofService - The proof service.
+ * @param opts - Additional options for processing the requests.
+ * @returns A promise that resolves to an auth proof response.
+ */
+const processProofAuth = async (to, proofService, opts) => {
+    if (!opts.acceptProfile) {
+        opts.acceptProfile = constants_1.defaultAcceptProfile;
+    }
+    if (!opts.skipRevocation) {
+        opts.skipRevocation = true;
+    }
+    switch (opts.acceptProfile.env) {
+        case constants_1.MediaType.ZKPMessage:
+            if (!opts.acceptProfile.circuits) {
+                throw new Error('Circuit not specified in accept profile');
+            }
+            for (const circuitId of opts.acceptProfile.circuits) {
+                if (!opts.supportedCircuits.includes(circuitId)) {
+                    throw new Error(`Circuit ${circuitId} is not supported`);
+                }
+                const zkpRes = await proofService.generateAuthProof(circuitId, to, { challenge: opts.challenge, skipRevocation: opts.skipRevocation });
+                switch (circuitId) {
+                    case circuits_1.CircuitId.AuthV2: {
+                        const preparedZkpProof = (0, utils_2.prepareZkpProof)(zkpRes.proof);
+                        const zkProofEncoded = (0, utils_2.packZkpProof)(zkpRes.pub_signals, preparedZkpProof.a, preparedZkpProof.b, preparedZkpProof.c);
+                        return {
+                            authMethod: types_1.AuthMethod.AUTHV2,
+                            proof: zkProofEncoded
+                        };
+                    }
+                }
+            }
+            throw new Error(`Auth method is not supported`);
+        case constants_1.MediaType.SignedMessage:
+            if (!opts.acceptProfile.alg || opts.acceptProfile.alg.length === 0) {
+                throw new Error('Algorithm not specified');
+            }
+            if (opts.acceptProfile.alg[0] === constants_1.AcceptJwsAlgorithms.ES256KR) {
+                const ethIdProof = (0, exports.packEthIdentityProof)(to);
+                return {
+                    authMethod: types_1.AuthMethod.ETH_IDENTITY,
+                    proof: ethIdProof
+                };
+            }
+            throw new Error(`Algorithm ${opts.acceptProfile.alg[0]} not supported`);
+        default:
+            throw new Error('Accept env not supported');
+    }
+};
+exports.processProofAuth = processProofAuth;
 /**
  * Verifies that the expires_time field of a message is not in the past. Throws an error if it is.
  *
@@ -95,3 +153,7 @@ const verifyExpiresTime = (message) => {
     }
 };
 exports.verifyExpiresTime = verifyExpiresTime;
+const packEthIdentityProof = (did) => {
+    return `0x${(0, utils_1.bytesToHex)(js_iden3_core_1.BytesHelper.intToBytes(js_iden3_core_1.DID.idFromDID(did).bigInt()))}`;
+};
+exports.packEthIdentityProof = packEthIdentityProof;

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

@@ -7,6 +7,7 @@ const js_iden3_core_1 = require("@iden3/js-iden3-core");
 const storage_1 = require("../../storage");
 const common_1 = require("./common");
 const message_handler_1 = require("./message-handler");
+const utils_1 = require("../utils");
 /**
  *
  * Allows to process ContractInvokeRequest protocol message
@@ -22,6 +23,7 @@ class ContractRequestHandler extends message_handler_1.AbstractMessageHandler {
      * @param {IPackageManager} _packerMgr - package manager to unpack message envelope
      * @param {IProofService} _proofService -  proof service to verify zk proofs
      * @param {IOnChainZKPVerifier} _zkpVerifier - zkp verifier to submit response
+     * @param {IOnChainVerifierMultiQuery} _verifierMultiQuery - verifier multi-query to submit response
      *
      */
     constructor(_packerMgr, _proofService, _zkpVerifier) {
@@ -33,7 +35,12 @@ class ContractRequestHandler extends message_handler_1.AbstractMessageHandler {
             models_1.CircuitId.AuthV2,
             models_1.CircuitId.AtomicQueryMTPV2OnChain,
             models_1.CircuitId.AtomicQuerySigV2OnChain,
-            models_1.CircuitId.AtomicQueryV3OnChain
+            models_1.CircuitId.AtomicQueryV3OnChain,
+            // Now we support off-chain circuits on-chain
+            // TODO: We need to create validators for them
+            models_1.CircuitId.AuthV2,
+            models_1.CircuitId.AtomicQueryV3,
+            models_1.CircuitId.LinkedMultiQuery10
         ];
     }
     async handle(message, ctx) {
@@ -69,19 +76,64 @@ class ContractRequestHandler extends message_handler_1.AbstractMessageHandler {
         });
         const methodId = message.body.transaction_data.method_id.replace('0x', '');
         switch (methodId) {
-            case storage_1.FunctionSignatures.SubmitZKPResponseV2:
-                return this._zkpVerifier.submitZKPResponseV2(ethSigner, message.body.transaction_data, zkpResponses);
+            case storage_1.FunctionSignatures.SubmitZKPResponseV2: {
+                const txHashZkpResponsesMap = await this._zkpVerifier.submitZKPResponseV2(ethSigner, message.body.transaction_data, zkpResponses);
+                const response = new Map();
+                for (const [txHash, zkpResponses] of txHashZkpResponsesMap) {
+                    response.set(txHash, { responses: zkpResponses });
+                }
+                return response;
+            }
             case storage_1.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]);
+                    response.set(txHash, { responses: [zkpResponse] });
                 }
                 return response;
             }
+            case storage_1.FunctionSignatures.SubmitResponse: {
+                // We need to
+                // 1. Generate auth proof from message.body.accept -> authResponse
+                // 2. Generate proofs for each query in scope -> zkpResponses
+                // Build auth response from accept
+                if (!message.to) {
+                    throw new Error(`failed message. empty 'to' field`);
+                }
+                // Get first supported accept profile and pass it to processProofAuth
+                const acceptProfile = this.getFirstSupportedProfile(constants_1.PROTOCOL_MESSAGE_TYPE.CONTRACT_INVOKE_REQUEST_MESSAGE_TYPE, message.body.accept);
+                const identifier = js_iden3_core_1.DID.parse(message.to);
+                const authResponse = await (0, common_1.processProofAuth)(identifier, this._proofService, {
+                    supportedCircuits: this._supportedCircuits,
+                    acceptProfile,
+                    challenge: challenge,
+                    skipRevocation: true
+                });
+                return this._zkpVerifier.submitResponse(ethSigner, message.body.transaction_data, authResponse, zkpResponses);
+            }
             default:
-                throw new Error(`Not supported method id. Only '${storage_1.FunctionSignatures.SubmitZKPResponseV1} and ${storage_1.FunctionSignatures.SubmitZKPResponseV2} are supported.'`);
+                throw new Error(`Not supported method id. Only '${storage_1.FunctionSignatures.SubmitZKPResponseV1}, ${storage_1.FunctionSignatures.SubmitZKPResponseV2} and ${storage_1.FunctionSignatures.SubmitResponse} are supported.'`);
+        }
+    }
+    getFirstSupportedProfile(responseType, profile) {
+        if (profile?.length) {
+            for (const acceptProfileString of profile) {
+                // 1. check protocol version
+                const acceptProfile = (0, utils_1.parseAcceptProfile)(acceptProfileString);
+                const responseTypeVersion = Number(responseType.split('/').at(-2));
+                if (acceptProfile.protocolVersion !== constants_1.ProtocolVersion.V1 ||
+                    (acceptProfile.protocolVersion === constants_1.ProtocolVersion.V1 &&
+                        (responseTypeVersion < 1 || responseTypeVersion >= 2))) {
+                    continue;
+                }
+                // 2. check packer support
+                if (this._packerMgr.isProfileSupported(acceptProfile.env, acceptProfileString)) {
+                    return acceptProfile;
+                }
+            }
         }
+        // if we don't have supported profiles, we use default
+        return constants_1.defaultAcceptProfile;
     }
     /**
      * unpacks contract-invoke request
@@ -103,7 +155,7 @@ class ContractRequestHandler extends message_handler_1.AbstractMessageHandler {
      * @private
      * @beta
      * @param {ContractInvokeRequest} request - ContractInvokeRequest
-     * @param { Map<string, ZeroKnowledgeProofResponse[]>} responses - map tx hash to array of ZeroKnowledgeProofResponses
+     * @param { Map<string, ZeroKnowledgeInvokeResponse>} responses - map tx hash to array of ZeroKnowledgeInvokeResponse
      * @returns `Promise<ContractInvokeResponse>`
      */
     async createContractInvokeResponse(request, txHashToZkpResponseMap) {
@@ -120,12 +172,17 @@ class ContractRequestHandler extends message_handler_1.AbstractMessageHandler {
             created_time: (0, js_iden3_core_1.getUnixTimestamp)(new Date())
         };
         for (const [txHash, zkpResponses] of txHashToZkpResponseMap) {
-            for (const zkpResponse of zkpResponses) {
+            for (const zkpResponse of zkpResponses.responses) {
                 contractInvokeResponse.body.scope.push({
                     txHash,
                     ...zkpResponse
                 });
             }
+            contractInvokeResponse.body = {
+                ...contractInvokeResponse.body,
+                crossChainProofs: zkpResponses.crossChainProofs ?? [],
+                authProofs: zkpResponses.authProofs ?? []
+            };
         }
         return contractInvokeResponse;
     }

package/dist/node/cjs/iden3comm/handlers/index.js

@@ -24,3 +24,4 @@ __exportStar(require("./credential-proposal"), exports);
 __exportStar(require("./message-handler"), exports);
 __exportStar(require("./payment"), exports);
 __exportStar(require("./discovery-protocol"), exports);
+__exportStar(require("./problem-report"), exports);

package/dist/node/cjs/iden3comm/handlers/problem-report.js

@@ -0,0 +1,55 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProblemReportMessage = void 0;
+const uuid = __importStar(require("uuid"));
+const constants_1 = require("../constants");
+/**
+ * @beta
+ * createProblemReportMessage is a function to create didcomm protocol problem report message
+ * @param pthid - parent thread id
+ * @param code - problem report code
+ * @param opts - problem report options
+ * @returns `ProblemReportMessage`
+ */
+function createProblemReportMessage(pthid, code, opts) {
+    const uuidv4 = uuid.v4();
+    return {
+        id: uuidv4,
+        pthid: pthid,
+        typ: constants_1.MediaType.PlainMessage,
+        type: constants_1.PROTOCOL_MESSAGE_TYPE.PROBLEM_REPORT_MESSAGE_TYPE,
+        ack: opts?.ack,
+        body: {
+            code: code,
+            comment: opts?.comment,
+            args: opts?.args,
+            escalate_to: opts?.escalate_to
+        },
+        from: opts?.from,
+        to: opts?.to
+    };
+}
+exports.createProblemReportMessage = createProblemReportMessage;

package/dist/node/cjs/iden3comm/types/index.js

@@ -24,6 +24,7 @@ __exportStar(require("./protocol/proposal-request"), exports);
 __exportStar(require("./protocol/payment"), exports);
 __exportStar(require("./protocol/accept-profile"), exports);
 __exportStar(require("./protocol/discovery-protocol"), exports);
+__exportStar(require("./protocol/problem-report"), exports);
 __exportStar(require("./packer"), exports);
 __exportStar(require("./models"), exports);
 __exportStar(require("./packageManager"), exports);

package/dist/node/cjs/iden3comm/types/protocol/contract-request.js

@@ -1,2 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthMethod = void 0;
+var AuthMethod;
+(function (AuthMethod) {
+    AuthMethod["AUTHV2"] = "authV2";
+    AuthMethod["ETH_IDENTITY"] = "ethIdentity";
+})(AuthMethod = exports.AuthMethod || (exports.AuthMethod = {}));

package/dist/node/cjs/iden3comm/types/protocol/problem-report.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/node/cjs/iden3comm/utils/contract-request.utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.prepareAuthV2ZeroKnowledgeResponse = exports.calculateRequestIdForCircuit = void 0;
+exports.prepareZkpProof = exports.packZkpProof = exports.prepareAuthV2ZeroKnowledgeResponse = exports.calculateRequestIdForCircuit = void 0;
 const ethers_1 = require("ethers");
 const utils_1 = require("../../utils");
 const circuits_1 = require("../../circuits");
@@ -57,3 +57,18 @@ async function prepareAuthV2ZeroKnowledgeResponse(address, senderDid, proofServi
     ];
 }
 exports.prepareAuthV2ZeroKnowledgeResponse = prepareAuthV2ZeroKnowledgeResponse;
+const packZkpProof = (inputs, a, b, c) => {
+    return new ethers_1.ethers.AbiCoder().encode(['uint256[] inputs', 'uint256[2]', 'uint256[2][2]', 'uint256[2]'], [inputs, a, b, c]);
+};
+exports.packZkpProof = packZkpProof;
+const prepareZkpProof = (proof) => {
+    return {
+        a: proof.pi_a.slice(0, 2),
+        b: [
+            [proof.pi_b[0][1], proof.pi_b[0][0]],
+            [proof.pi_b[1][1], proof.pi_b[1][0]]
+        ],
+        c: proof.pi_c.slice(0, 2)
+    };
+};
+exports.prepareZkpProof = prepareZkpProof;

package/dist/node/cjs/proof/proof-service.js

@@ -131,6 +131,32 @@ class ProofService {
             pub_signals
         };
     }
+    /** {@inheritdoc IProofService.generateAuthProof} */
+    async generateAuthProof(circuitId, identifier, opts) {
+        if (!opts) {
+            opts = {
+                skipRevocation: false,
+                challenge: 0n
+            };
+        }
+        let zkProof;
+        switch (circuitId) {
+            case circuits_1.CircuitId.AuthV2:
+                {
+                    const challenge = opts.challenge
+                        ? js_iden3_core_1.BytesHelper.intToBytes(opts.challenge).reverse()
+                        : new Uint8Array(32);
+                    zkProof = await this.generateAuthV2Proof(challenge, identifier);
+                }
+                return {
+                    circuitId: circuitId,
+                    proof: zkProof.proof,
+                    pub_signals: zkProof.pub_signals
+                };
+            default:
+                throw new Error(`CircuitId ${circuitId} is not supported`);
+        }
+    }
     /** {@inheritdoc IProofService.transitState} */
     async transitState(did, oldTreeState, isOldStateGenesis, stateStorage, // for compatibility with previous versions we leave this parameter
     ethSigner) {

package/dist/node/cjs/schema-processor/jsonld/cache.js

@@ -10,12 +10,27 @@ const verifiable_1 = require("../../verifiable");
  * @returns Promise<DocumentLoader>
  */
 const doc = JSON.parse(verifiable_1.VerifiableConstants.JSONLD_SCHEMA.W3C_VC_DOCUMENT_2018);
+const docIden3Proofs = JSON.parse(verifiable_1.VerifiableConstants.JSONLD_SCHEMA.IDEN3_PROOFS_DEFINITION_DOCUMENT);
+const docIden3DisplayMethod = JSON.parse(verifiable_1.VerifiableConstants.JSONLD_SCHEMA.IDEN3_DISPLAY_METHOD_DEFINITION_DOCUMENT);
+const docIden3AuthBJJ = JSON.parse(verifiable_1.VerifiableConstants.AUTH.AUTH_BJJ_CREDENTIAL_SCHEMA_JSONLD);
 const cacheLoader = (opts) => {
     const cache = new Map();
     cache.set(verifiable_1.VerifiableConstants.JSONLD_SCHEMA.W3C_CREDENTIAL_2018, {
         document: doc,
         documentUrl: verifiable_1.VerifiableConstants.JSONLD_SCHEMA.W3C_CREDENTIAL_2018
     });
+    cache.set(verifiable_1.VerifiableConstants.JSONLD_SCHEMA.IDEN3_CREDENTIAL, {
+        document: docIden3Proofs,
+        documentUrl: verifiable_1.VerifiableConstants.JSONLD_SCHEMA.IDEN3_PROOFS_DEFINITION_DOCUMENT
+    });
+    cache.set(verifiable_1.VerifiableConstants.JSONLD_SCHEMA.IDEN3_DISPLAY_METHOD, {
+        document: docIden3DisplayMethod,
+        documentUrl: verifiable_1.VerifiableConstants.JSONLD_SCHEMA.IDEN3_DISPLAY_METHOD_DEFINITION_DOCUMENT
+    });
+    cache.set(verifiable_1.VerifiableConstants.AUTH.AUTH_BJJ_CREDENTIAL_SCHEMA_JSONLD_URL, {
+        document: docIden3AuthBJJ,
+        documentUrl: verifiable_1.VerifiableConstants.AUTH.AUTH_BJJ_CREDENTIAL_SCHEMA_JSONLD
+    });
     return async (url) => {
         let remoteDoc = cache.get(url);
         if (remoteDoc) {

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

@@ -6,12 +6,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.OnChainZKPVerifier = exports.FunctionSignatures = void 0;
 const ethers_1 = require("ethers");
 const ZkpVerifier_json_1 = __importDefault(require("./abi/ZkpVerifier.json"));
+//import { UniversalVerifier } from '@iden3/universal-verifier-v2-abi';
+const universal_verifier_v2_abi_1 = require("@iden3/universal-verifier-v2-abi");
 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 js_merkletree_1 = require("@iden3/js-merkletree");
+const utils_2 = require("../../iden3comm/utils");
 const maxGasLimit = 10000000n;
 /**
  * Supported function signature for SubmitZKPResponse
@@ -26,6 +29,8 @@ var FunctionSignatures;
     FunctionSignatures["SubmitZKPResponseV1"] = "b68967e2";
     //function submitZKPResponseV2(tuple[](uint64 requestId,bytes zkProof,bytes data),bytes crossChainProof)
     FunctionSignatures["SubmitZKPResponseV2"] = "ade09fcd";
+    //function submitResponse(tuple(string authMethod,bytes proof),tuple(uint256 requestId,bytes proof,bytes metadata)[],bytes crossChainProof)
+    FunctionSignatures["SubmitResponse"] = "06c86a91";
 })(FunctionSignatures = exports.FunctionSignatures || (exports.FunctionSignatures = {}));
 /**
  * OnChainZKPVerifier is a class that allows to interact with the OnChainZKPVerifier contract
@@ -51,16 +56,8 @@ class OnChainZKPVerifier {
         }
         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)
-        ];
+        const preparedZkpProof = (0, utils_2.prepareZkpProof)(zkProofResponse.proof);
+        const payload = [requestID, inputs, preparedZkpProof.a, preparedZkpProof.b, preparedZkpProof.c];
         return payload;
     }
     /**
@@ -158,6 +155,80 @@ class OnChainZKPVerifier {
         const { txnHash } = await transactionService.sendTransactionRequest(ethSigner, request);
         return new Map().set(txnHash, zkProofResponses);
     }
+    /**
+     * {@inheritDoc IOnChainVerifierMultiQuery.submitResponse}
+     */
+    async submitResponse(ethSigner, txData, authResponse, responses) {
+        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.SubmitResponse) {
+            throw new Error(`submitResponse function doesn't implement requested method id. Only '0x${FunctionSignatures.SubmitResponse}' 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.prepareTxArgsSubmit(txData, authResponse, responses);
+        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, universal_verifier_v2_abi_1.IVerifierABI);
+        const txRequestData = await verifierContract.submitResponse.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 multiple responses for all the responses (single and grouped)
+        return new Map().set(txnHash, {
+            responses: responses,
+            authProofs: [authResponse],
+            crossChainProofs: [txDataArgs[2]]
+        });
+    }
+    static async prepareTxArgsSubmit(resolverUrl, txData, authResponse, responses) {
+        if (txData.method_id.replace('0x', '') !== FunctionSignatures.SubmitResponse) {
+            throw new Error(`submit cross chain doesn't implement requested method id. Only '0x${FunctionSignatures.SubmitResponse}' is supported.`);
+        }
+        const gistUpdateArr = [];
+        const stateUpdateArr = [];
+        const payloadResponses = [];
+        // Process all the responses
+        for (const zkProof of responses) {
+            const { requestID, zkProofEncoded, metadata } = await this._processProof(zkProof);
+            payloadResponses.push({
+                requestId: requestID,
+                proof: zkProofEncoded,
+                metadata: metadata
+            });
+        }
+        const crossChainProofs = this.packCrossChainProofs(gistUpdateArr, stateUpdateArr);
+        return [authResponse, payloadResponses, crossChainProofs];
+    }
+    async prepareTxArgsSubmit(txData, authResponse, responses) {
+        if (!this._opts?.didResolverUrl) {
+            throw new Error(`did resolver url required for crosschain verification`);
+        }
+        return OnChainZKPVerifier.prepareTxArgsSubmit(this._opts.didResolverUrl, txData, authResponse, responses);
+    }
     static getCrossChainResolvers(source, txDataChainId, type, didResolverUrl) {
         return [
             ...new Set(source.map((info) => JSON.stringify({
@@ -199,10 +270,8 @@ class OnChainZKPVerifier {
                 });
                 continue;
             }
-            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 preparedZkpProof = (0, utils_2.prepareZkpProof)(zkProof.proof);
+            const zkProofEncoded = (0, utils_2.packZkpProof)(inputs, preparedZkpProof.a, preparedZkpProof.b, preparedZkpProof.c);
             const stateInfo = this.getOnChainGistRootStatePubSignals(proofCircuitId, inputs);
             const chainId = txData.chain_id;
             const gistUpdateResolutions = this.getCrossChainResolvers(stateInfo.gists, chainId, 'gist', resolverUrl);
@@ -245,8 +314,30 @@ class OnChainZKPVerifier {
         }
         return OnChainZKPVerifier.prepareTxArgsSubmitV2(this._opts.didResolverUrl, txData, zkProofResponses);
     }
-    static packZkpProof(inputs, a, b, c) {
-        return new ethers_1.ethers.AbiCoder().encode(['uint256[] inputs', 'uint256[2]', 'uint256[2][2]', 'uint256[2]'], [inputs, a, b, c]);
+    static async _processProof(zkProof) {
+        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 preparedZkpProof = (0, utils_2.prepareZkpProof)(zkProof.proof);
+        const zkProofEncoded = (0, utils_2.packZkpProof)(inputs, preparedZkpProof.a, preparedZkpProof.b, preparedZkpProof.c);
+        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 = metadataArr.length ? this.packMetadatas(metadataArr) : '0x';
+        return { requestID, zkProofEncoded, metadata };
     }
     static packCrossChainProofs(gistUpdateArr, stateUpdateArr) {
         const proofs = [];

package/dist/node/cjs/storage/blockchain/state.js

@@ -10,6 +10,7 @@ const utils_1 = require("../../utils");
 const State_json_1 = __importDefault(require("./abi/State.json"));
 const js_iden3_core_1 = require("@iden3/js-iden3-core");
 const blockchain_1 = require("../../blockchain");
+const utils_2 = require("../../iden3comm/utils");
 exports.defaultEthConnectionConfig = {
     url: 'http://localhost:8545',
     defaultGasLimit: 600000,
@@ -79,17 +80,15 @@ class EthStateStorage {
         const { userId, oldUserState, newUserState, isOldStateGenesis } = stateTransitionPubSig;
         const { stateContract, provider } = this.getStateContractAndProviderForId(userId.bigInt());
         const contract = stateContract.connect(signer);
+        const preparedZkpProof = (0, utils_2.prepareZkpProof)(proof.proof);
         const payload = [
             userId.bigInt().toString(),
             oldUserState.bigInt().toString(),
             newUserState.bigInt().toString(),
             isOldStateGenesis,
-            proof.proof.pi_a.slice(0, 2),
-            [
-                [proof.proof.pi_b[0][1], proof.proof.pi_b[0][0]],
-                [proof.proof.pi_b[1][1], proof.proof.pi_b[1][0]]
-            ],
-            proof.proof.pi_c.slice(0, 2)
+            preparedZkpProof.a,
+            preparedZkpProof.b,
+            preparedZkpProof.c
         ];
         const feeData = await provider.getFeeData();
         const maxFeePerGas = exports.defaultEthConnectionConfig.maxFeePerGas