@0xpolygonid/js-sdk 1.29.1 → 1.29.2

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

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.packEthIdentityProof = exports.verifyExpiresTime = exports.processProofAuth = exports.processZeroKnowledgeProofRequests = void 0;
+exports.verifyExpiresTime = exports.packMetadatas = exports.calcChallengeAuthV2 = exports.processProofResponse = 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");
+const ethers_1 = require("ethers");
+const common_1 = require("../../storage/blockchain/common");
 /**
  * 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.
@@ -100,9 +100,6 @@ 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) {
@@ -112,17 +109,20 @@ const processProofAuth = async (to, proofService, opts) => {
                 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
-                        };
-                    }
+                if (!opts.senderAddress) {
+                    throw new Error('Sender address is not provided');
+                }
+                if (!opts.zkpResponses || opts.zkpResponses.length === 0) {
+                    throw new Error('ZKP responses are not provided');
                 }
+                const challengeAuth = (0, exports.calcChallengeAuthV2)(opts.senderAddress, opts.zkpResponses);
+                const zkpRes = await proofService.generateAuthProof(circuitId, to, { challenge: challengeAuth });
+                return {
+                    authProof: {
+                        authMethod: types_1.AuthMethod.AUTHV2,
+                        zkp: zkpRes
+                    }
+                };
             }
             throw new Error(`Auth method is not supported`);
         case constants_1.MediaType.SignedMessage:
@@ -130,10 +130,11 @@ const processProofAuth = async (to, proofService, opts) => {
                 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
+                    authProof: {
+                        authMethod: types_1.AuthMethod.ETH_IDENTITY,
+                        userDid: to
+                    }
                 };
             }
             throw new Error(`Algorithm ${opts.acceptProfile.alg[0]} not supported`);
@@ -142,6 +143,65 @@ const processProofAuth = async (to, proofService, opts) => {
     }
 };
 exports.processProofAuth = processProofAuth;
+/**
+ * Processes a ZeroKnowledgeProofResponse object and prepares it for further use.
+ * @param zkProof - The ZeroKnowledgeProofResponse object containing the proof data.
+ * @returns An object containing the requestId, zkProofEncoded, and metadata.
+ */
+const processProofResponse = (zkProof) => {
+    const requestId = zkProof.id;
+    const inputs = zkProof.pub_signals;
+    const emptyBytes = '0x';
+    if (inputs.length === 0) {
+        return { requestId, zkProofEncoded: emptyBytes, metadata: emptyBytes };
+    }
+    const preparedZkpProof = (0, common_1.prepareZkpProof)(zkProof.proof);
+    const zkProofEncoded = (0, common_1.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 ? (0, exports.packMetadatas)(metadataArr) : emptyBytes;
+    return { requestId, zkProofEncoded, metadata };
+};
+exports.processProofResponse = processProofResponse;
+/**
+ * Calculates the challenge authentication V2 value.
+ * @param senderAddress - The address of the sender.
+ * @param zkpResponses - An array of ZeroKnowledgeProofResponse objects.
+ * @returns A bigint representing the challenge authentication value.
+ */
+const calcChallengeAuthV2 = (senderAddress, zkpResponses) => {
+    const responses = zkpResponses.map((zkpResponse) => {
+        const response = (0, exports.processProofResponse)(zkpResponse);
+        return {
+            requestId: response.requestId,
+            proof: response.zkProofEncoded,
+            metadata: response.metadata
+        };
+    });
+    return (BigInt(ethers_1.ethers.keccak256(new ethers_1.ethers.AbiCoder().encode(['address', '(uint256 requestId,bytes proof,bytes metadata)[]'], [senderAddress, responses]))) & BigInt('0x0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'));
+};
+exports.calcChallengeAuthV2 = calcChallengeAuthV2;
+/**
+ * Packs metadata into a string format suitable for encoding in a transaction.
+ * @param metas - An array of objects containing key-value pairs to be packed.
+ * @returns A string representing the packed metadata.
+ */
+const packMetadatas = (metas) => {
+    return new ethers_1.ethers.AbiCoder().encode(['tuple(' + 'string key,' + 'bytes value' + ')[]'], [metas]);
+};
+exports.packMetadatas = packMetadatas;
 /**
  * Verifies that the expires_time field of a message is not in the past. Throws an error if it is.
  *
@@ -153,7 +213,3 @@ 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

@@ -8,6 +8,7 @@ const storage_1 = require("../../storage");
 const common_1 = require("./common");
 const message_handler_1 = require("./message-handler");
 const utils_1 = require("../utils");
+const utils_2 = require("../../utils");
 /**
  *
  * Allows to process ContractInvokeRequest protocol message
@@ -71,7 +72,7 @@ class ContractRequestHandler extends message_handler_1.AbstractMessageHandler {
         const { scope = [] } = message.body;
         const zkpResponses = await (0, common_1.processZeroKnowledgeProofRequests)(did, scope, verifierDid, this._proofService, {
             ethSigner,
-            challenge,
+            challenge: challenge ?? js_iden3_core_1.BytesHelper.bytesToInt((0, utils_2.hexToBytes)(await ethSigner.getAddress())),
             supportedCircuits: this._supportedCircuits
         });
         const methodId = message.body.transaction_data.method_id.replace('0x', '');
@@ -103,13 +104,13 @@ class ContractRequestHandler extends message_handler_1.AbstractMessageHandler {
                 // 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, {
+                const { authProof } = await (0, common_1.processProofAuth)(identifier, this._proofService, {
                     supportedCircuits: this._supportedCircuits,
                     acceptProfile,
-                    challenge: challenge,
-                    skipRevocation: true
+                    senderAddress: await ethSigner.getAddress(),
+                    zkpResponses: zkpResponses
                 });
-                return this._zkpVerifier.submitResponse(ethSigner, message.body.transaction_data, authResponse, zkpResponses);
+                return this._zkpVerifier.submitResponse(ethSigner, message.body.transaction_data, zkpResponses, authProof);
             }
             default:
                 throw new Error(`Not supported method id. Only '${storage_1.FunctionSignatures.SubmitZKPResponseV1}, ${storage_1.FunctionSignatures.SubmitZKPResponseV2} and ${storage_1.FunctionSignatures.SubmitResponse} are supported.'`);
@@ -180,8 +181,8 @@ class ContractRequestHandler extends message_handler_1.AbstractMessageHandler {
             }
             contractInvokeResponse.body = {
                 ...contractInvokeResponse.body,
-                crossChainProofs: zkpResponses.crossChainProofs ?? [],
-                authProofs: zkpResponses.authProofs ?? []
+                crossChainProof: zkpResponses.crossChainProof,
+                authProof: zkpResponses.authProof
             };
         }
         return contractInvokeResponse;

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

@@ -17,5 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./envelope"), exports);
 __exportStar(require("./message"), exports);
 __exportStar(require("./did"), exports);
-__exportStar(require("./contract-request.utils"), exports);
 __exportStar(require("./accept-profile"), exports);

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

@@ -135,7 +135,6 @@ class ProofService {
     async generateAuthProof(circuitId, identifier, opts) {
         if (!opts) {
             opts = {
-                skipRevocation: false,
                 challenge: 0n
             };
         }

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareZkpProof = exports.packZkpProof = void 0;
+const ethers_1 = require("ethers");
+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/storage/blockchain/onchain-zkp-verifier.js

@@ -3,8 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OnChainZKPVerifier = exports.FunctionSignatures = void 0;
+exports.packEthIdentityProof = exports.OnChainZKPVerifier = exports.toTxDataArgs = exports.FunctionSignatures = void 0;
 const ethers_1 = require("ethers");
+const iden3comm_1 = require("../../iden3comm");
 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");
@@ -12,9 +13,8 @@ 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 common_1 = require("./common");
 const maxGasLimit = 10000000n;
 /**
  * Supported function signature for SubmitZKPResponse
@@ -32,6 +32,23 @@ var FunctionSignatures;
     //function submitResponse(tuple(string authMethod,bytes proof),tuple(uint256 requestId,bytes proof,bytes metadata)[],bytes crossChainProof)
     FunctionSignatures["SubmitResponse"] = "06c86a91";
 })(FunctionSignatures = exports.FunctionSignatures || (exports.FunctionSignatures = {}));
+const toTxDataArgs = function (res) {
+    return [
+        {
+            authMethod: res.authProof.raw.authMethod,
+            proof: res.authProof.encoded
+        },
+        res.proofs.map((p) => {
+            return {
+                requestId: p.requestId,
+                proof: p.encoded,
+                metadata: p.metadata
+            };
+        }),
+        res.crossChainProof.encoded
+    ];
+};
+exports.toTxDataArgs = toTxDataArgs;
 /**
  * OnChainZKPVerifier is a class that allows to interact with the OnChainZKPVerifier contract
  * and submitZKPResponse.
@@ -56,7 +73,7 @@ class OnChainZKPVerifier {
         }
         const requestID = zkProofResponse.id;
         const inputs = zkProofResponse.pub_signals;
-        const preparedZkpProof = (0, utils_2.prepareZkpProof)(zkProofResponse.proof);
+        const preparedZkpProof = (0, common_1.prepareZkpProof)(zkProofResponse.proof);
         const payload = [requestID, inputs, preparedZkpProof.a, preparedZkpProof.b, preparedZkpProof.c];
         return payload;
     }
@@ -158,7 +175,7 @@ class OnChainZKPVerifier {
     /**
      * {@inheritDoc IOnChainVerifierMultiQuery.submitResponse}
      */
-    async submitResponse(ethSigner, txData, authResponse, responses) {
+    async submitResponse(ethSigner, txData, responses, authProof) {
         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`);
@@ -171,7 +188,7 @@ class OnChainZKPVerifier {
         }
         const provider = new ethers_1.JsonRpcProvider(chainConfig.url, chainConfig.chainId);
         ethSigner = ethSigner.connect(provider);
-        const txDataArgs = await this.prepareTxArgsSubmit(txData, authResponse, responses);
+        const txPreparationResult = await this.prepareTxArgsSubmit(txData, responses, authProof);
         const feeData = await provider.getFeeData();
         const maxFeePerGas = chainConfig.maxFeePerGas
             ? BigInt(chainConfig.maxFeePerGas)
@@ -180,7 +197,7 @@ class OnChainZKPVerifier {
             ? 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 txRequestData = await verifierContract.submitResponse.populateTransaction(...txPreparationResult.txDataArgs);
         const request = {
             to: txData.contract_address,
             data: txRequestData.data,
@@ -199,35 +216,90 @@ class OnChainZKPVerifier {
         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]]
+            authProof: txPreparationResult.result.authProof.raw,
+            crossChainProof: txPreparationResult.result.crossChainProof.raw,
+            responses: txPreparationResult.result.proofs.map((m) => m.proof)
         });
     }
-    static async prepareTxArgsSubmit(resolverUrl, txData, authResponse, responses) {
+    static async prepareTxArgsSubmit(resolverUrl, txData, responses, authProof) {
         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 gistUpdatesArr = [];
+        const stateUpdatesArr = [];
         const payloadResponses = [];
+        const emptyBytes = '0x';
+        let encodedAuthProof = '';
+        switch (authProof.authMethod) {
+            case iden3comm_1.AuthMethod.AUTHV2: {
+                const preparedZkpProof = (0, common_1.prepareZkpProof)(authProof.zkp.proof);
+                encodedAuthProof = (0, common_1.packZkpProof)(authProof.zkp.pub_signals, preparedZkpProof.a, preparedZkpProof.b, preparedZkpProof.c);
+                break;
+            }
+            case iden3comm_1.AuthMethod.ETH_IDENTITY: {
+                encodedAuthProof = (0, exports.packEthIdentityProof)(authProof.userDid);
+                break;
+            }
+            default:
+                throw new Error('auth proof must use method AuthV2 or ethIdentity');
+        }
         // Process all the responses
         for (const zkProof of responses) {
-            const { requestID, zkProofEncoded, metadata } = await this._processProof(zkProof);
+            this.checkSupportedCircuit(zkProof.circuitId);
+            const { requestId, zkProofEncoded, metadata } = (0, iden3comm_1.processProofResponse)(zkProof);
             payloadResponses.push({
-                requestId: requestID,
-                proof: zkProofEncoded,
+                proof: zkProof,
+                requestId: requestId,
+                encoded: zkProofEncoded,
                 metadata: metadata
             });
         }
-        const crossChainProofs = this.packCrossChainProofs(gistUpdateArr, stateUpdateArr);
-        return [authResponse, payloadResponses, crossChainProofs];
+        // Process all zkProofs and prepare cross chain proofs
+        const allZkProofs = responses.map((zkProof) => ({
+            circuitId: zkProof.circuitId,
+            pub_signals: zkProof.pub_signals
+        }));
+        if (authProof.authMethod == iden3comm_1.AuthMethod.AUTHV2) {
+            allZkProofs.push({
+                circuitId: authProof.zkp.circuitId,
+                pub_signals: authProof.zkp.pub_signals
+            });
+        }
+        for (const zkProof of allZkProofs) {
+            const { gistUpdateResolutions, stateUpdateResolutions } = this.getUpdateResolutions(resolverUrl, txData.chain_id, zkProof.circuitId, zkProof.pub_signals);
+            if (gistUpdateResolutions.length > 0) {
+                gistUpdatesArr.push(...(await Promise.all(gistUpdateResolutions)));
+            }
+            if (stateUpdateResolutions.length > 0) {
+                stateUpdatesArr.push(...(await Promise.all(stateUpdateResolutions)));
+            }
+        }
+        const encodedCrossChainProof = gistUpdatesArr.length || stateUpdatesArr.length
+            ? this.packCrossChainProofs(gistUpdatesArr, stateUpdatesArr)
+            : emptyBytes;
+        const preparationResult = {
+            authProof: { raw: authProof, encoded: encodedAuthProof },
+            proofs: payloadResponses,
+            crossChainProof: {
+                raw: {
+                    globalStateProofs: gistUpdatesArr || [],
+                    identityStateProofs: stateUpdatesArr || []
+                },
+                encoded: encodedCrossChainProof
+            }
+        };
+        return { result: preparationResult, txDataArgs: (0, exports.toTxDataArgs)(preparationResult) };
     }
-    async prepareTxArgsSubmit(txData, authResponse, responses) {
+    async prepareTxArgsSubmit(txData, responses, authProof) {
         if (!this._opts?.didResolverUrl) {
             throw new Error(`did resolver url required for crosschain verification`);
         }
-        return OnChainZKPVerifier.prepareTxArgsSubmit(this._opts.didResolverUrl, txData, authResponse, responses);
+        return OnChainZKPVerifier.prepareTxArgsSubmit(this._opts.didResolverUrl, txData, responses, authProof);
+    }
+    static checkSupportedCircuit(circuitId) {
+        if (!this._supportedCircuits.includes(circuitId)) {
+            throw new Error(`Circuit ${circuitId} not supported by OnChainZKPVerifier`);
+        }
     }
     static getCrossChainResolvers(source, txDataChainId, type, didResolverUrl) {
         return [
@@ -252,61 +324,30 @@ class OnChainZKPVerifier {
         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.`);
         }
-        const gistUpdates = [];
-        const stateUpdates = [];
-        const payload = [];
+        const gistUpdatesArr = [];
+        const stateUpdatesArr = [];
+        const payloadResponses = [];
         const emptyBytes = '0x';
         for (const zkProof of zkProofResponses) {
-            const { id: requestId, pub_signals: inputs } = zkProof;
-            const proofCircuitId = zkProof.circuitId;
-            if (!this._supportedCircuits.includes(proofCircuitId)) {
-                throw new Error(`Circuit ${zkProof.circuitId} not supported by OnChainZKPVerifier`);
-            }
-            if (inputs.length === 0) {
-                payload.push({
-                    requestId: requestId,
-                    zkProof: emptyBytes,
-                    data: emptyBytes
-                });
-                continue;
-            }
-            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);
-            const stateUpdateResolutions = this.getCrossChainResolvers(stateInfo.states, chainId, 'state', resolverUrl);
-            if (gistUpdateResolutions.length > 0) {
-                gistUpdates.push(...(await Promise.all(gistUpdateResolutions)));
-            }
-            if (stateUpdateResolutions.length > 0) {
-                stateUpdates.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 = metadataArr.length ? this.packMetadatas(metadataArr) : emptyBytes;
-            payload.push({
+            this.checkSupportedCircuit(zkProof.circuitId);
+            const { requestId, zkProofEncoded, metadata } = (0, iden3comm_1.processProofResponse)(zkProof);
+            payloadResponses.push({
                 requestId: requestId,
                 zkProof: zkProofEncoded,
                 data: metadata
             });
+            const { gistUpdateResolutions, stateUpdateResolutions } = this.getUpdateResolutions(resolverUrl, txData.chain_id, zkProof.circuitId, zkProof.pub_signals);
+            if (gistUpdateResolutions.length > 0) {
+                gistUpdatesArr.push(...(await Promise.all(gistUpdateResolutions)));
+            }
+            if (stateUpdateResolutions.length > 0) {
+                stateUpdatesArr.push(...(await Promise.all(stateUpdateResolutions)));
+            }
         }
-        const crossChainProofs = gistUpdates.length || stateUpdates.length
-            ? this.packCrossChainProofs(gistUpdates, stateUpdates)
+        const crossChainProofEncoded = gistUpdatesArr.length || stateUpdatesArr.length
+            ? this.packCrossChainProofs(gistUpdatesArr, stateUpdatesArr)
             : emptyBytes;
-        return [payload, crossChainProofs];
+        return [payloadResponses, crossChainProofEncoded];
     }
     async prepareTxArgsSubmitV2(txData, zkProofResponses) {
         if (!this._opts?.didResolverUrl) {
@@ -314,30 +355,11 @@ class OnChainZKPVerifier {
         }
         return OnChainZKPVerifier.prepareTxArgsSubmitV2(this._opts.didResolverUrl, txData, zkProofResponses);
     }
-    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 getUpdateResolutions(resolverUrl, chainId, proofCircuitId, inputs) {
+        const stateInfo = this.getOnChainGistRootStatePubSignals(proofCircuitId, inputs);
+        const gistUpdateResolutions = this.getCrossChainResolvers(stateInfo.gists, chainId, 'gist', resolverUrl);
+        const stateUpdateResolutions = this.getCrossChainResolvers(stateInfo.states, chainId, 'state', resolverUrl);
+        return { gistUpdateResolutions, stateUpdateResolutions };
     }
     static packCrossChainProofs(gistUpdateArr, stateUpdateArr) {
         const proofs = [];
@@ -381,9 +403,6 @@ class OnChainZKPVerifier {
                 ')'
         ], [msg]);
     }
-    static packMetadatas(metas) {
-        return new ethers_1.ethers.AbiCoder().encode(['tuple(' + 'string key,' + 'bytes value' + ')[]'], [metas]);
-    }
     static getOnChainGistRootStatePubSignals(onChainCircuitId, inputs) {
         const PubSignals = this._supportedCircuitsPubSignalsMap[onChainCircuitId];
         if (!PubSignals) {
@@ -443,3 +462,12 @@ OnChainZKPVerifier._supportedCircuitsPubSignalsMap = {
     [circuits_1.CircuitId.AtomicQueryV3OnChain]: circuits_1.AtomicQueryV3OnChainPubSignals,
     [circuits_1.CircuitId.AuthV2]: circuits_1.AuthV2PubSignals
 };
+/**
+ * Packs an Ethereum identity proof from a Decentralized Identifier (DID).
+ * @param did - Decentralized Identifier (DID) to pack.
+ * @returns A hexadecimal string representing the packed DID identity proof.
+ */
+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/storage/blockchain/state.js

@@ -10,7 +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");
+const common_1 = require("./common");
 exports.defaultEthConnectionConfig = {
     url: 'http://localhost:8545',
     defaultGasLimit: 600000,
@@ -80,7 +80,7 @@ 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 preparedZkpProof = (0, common_1.prepareZkpProof)(proof.proof);
         const payload = [
             userId.bigInt().toString(),
             oldUserState.bigInt().toString(),