@0xpolygonid/js-sdk 1.29.1 → 1.29.3

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

@@ -1,10 +1,10 @@
-import { getRandomBytes } from '@iden3/js-crypto';
+import { getRandomBytes, poseidon } from '@iden3/js-crypto';
 import { AuthMethod } from '../types';
-import { bytesToHex, mergeObjects } from '../../utils';
-import { BytesHelper, DID, getUnixTimestamp } from '@iden3/js-iden3-core';
-import { CircuitId } from '../../circuits';
+import { byteEncoder, mergeObjects } from '../../utils';
+import { getUnixTimestamp } from '@iden3/js-iden3-core';
 import { AcceptJwsAlgorithms, defaultAcceptProfile, MediaType } from '../constants';
-import { packZkpProof, prepareZkpProof } from '../utils';
+import { ethers } from 'ethers';
+import { packZkpProof, prepareZkpProof } from '../../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.
@@ -96,9 +96,6 @@ export const processProofAuth = async (to, proofService, opts) => {
     if (!opts.acceptProfile) {
         opts.acceptProfile = defaultAcceptProfile;
     }
-    if (!opts.skipRevocation) {
-        opts.skipRevocation = true;
-    }
     switch (opts.acceptProfile.env) {
         case MediaType.ZKPMessage:
             if (!opts.acceptProfile.circuits) {
@@ -108,17 +105,17 @@ export 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 CircuitId.AuthV2: {
-                        const preparedZkpProof = prepareZkpProof(zkpRes.proof);
-                        const zkProofEncoded = packZkpProof(zkpRes.pub_signals, preparedZkpProof.a, preparedZkpProof.b, preparedZkpProof.c);
-                        return {
-                            authMethod: AuthMethod.AUTHV2,
-                            proof: zkProofEncoded
-                        };
-                    }
+                if (!opts.senderAddress) {
+                    throw new Error('Sender address is not provided');
                 }
+                const challengeAuth = calcChallengeAuthV2(opts.senderAddress, opts.zkpResponses);
+                const zkpRes = await proofService.generateAuthProof(circuitId, to, { challenge: challengeAuth });
+                return {
+                    authProof: {
+                        authMethod: AuthMethod.AUTHV2,
+                        zkp: zkpRes
+                    }
+                };
             }
             throw new Error(`Auth method is not supported`);
         case MediaType.SignedMessage:
@@ -126,10 +123,11 @@ export const processProofAuth = async (to, proofService, opts) => {
                 throw new Error('Algorithm not specified');
             }
             if (opts.acceptProfile.alg[0] === AcceptJwsAlgorithms.ES256KR) {
-                const ethIdProof = packEthIdentityProof(to);
                 return {
-                    authMethod: AuthMethod.ETH_IDENTITY,
-                    proof: ethIdProof
+                    authProof: {
+                        authMethod: AuthMethod.ETH_IDENTITY,
+                        userDid: to
+                    }
                 };
             }
             throw new Error(`Algorithm ${opts.acceptProfile.alg[0]} not supported`);
@@ -137,6 +135,62 @@ export const processProofAuth = async (to, proofService, opts) => {
             throw new Error('Accept env not supported');
     }
 };
+/**
+ * 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.
+ */
+export 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 = prepareZkpProof(zkProof.proof);
+    const zkProofEncoded = 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 = poseidon.hashBytes(byteEncoder.encode(JSON.stringify(zkProof.vp.verifiableCredential.credentialSubject[key])));
+            const bytesValue = byteEncoder.encode(metadataValue.toString());
+            metadataArr.push({
+                key,
+                value: bytesValue
+            });
+        }
+    }
+    const metadata = metadataArr.length ? packMetadatas(metadataArr) : emptyBytes;
+    return { requestId, zkProofEncoded, metadata };
+};
+/**
+ * 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.
+ */
+export const calcChallengeAuthV2 = (senderAddress, zkpResponses) => {
+    const responses = zkpResponses.map((zkpResponse) => {
+        const response = processProofResponse(zkpResponse);
+        return {
+            requestId: response.requestId,
+            proof: response.zkProofEncoded,
+            metadata: response.metadata
+        };
+    });
+    return (BigInt(ethers.keccak256(new ethers.AbiCoder().encode(['address', '(uint256 requestId,bytes proof,bytes metadata)[]'], [senderAddress, responses]))) & BigInt('0x0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'));
+};
+/**
+ * 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.
+ */
+export const packMetadatas = (metas) => {
+    return new ethers.AbiCoder().encode(['tuple(' + 'string key,' + 'bytes value' + ')[]'], [metas]);
+};
 /**
  * Verifies that the expires_time field of a message is not in the past. Throws an error if it is.
  *
@@ -147,6 +201,3 @@ export const verifyExpiresTime = (message) => {
         throw new Error('Message expired');
     }
 };
-export const packEthIdentityProof = (did) => {
-    return `0x${bytesToHex(BytesHelper.intToBytes(DID.idFromDID(did).bigInt()))}`;
-};

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

@@ -1,10 +1,11 @@
 import { CircuitId } from '../../circuits/models';
 import { defaultAcceptProfile, PROTOCOL_MESSAGE_TYPE, ProtocolVersion } from '../constants';
-import { DID, ChainIds, getUnixTimestamp } from '@iden3/js-iden3-core';
+import { DID, ChainIds, getUnixTimestamp, BytesHelper } from '@iden3/js-iden3-core';
 import { FunctionSignatures } from '../../storage';
 import { processProofAuth, processZeroKnowledgeProofRequests, verifyExpiresTime } from './common';
 import { AbstractMessageHandler } from './message-handler';
 import { parseAcceptProfile } from '../utils';
+import { hexToBytes } from '../../utils';
 /**
  *
  * Allows to process ContractInvokeRequest protocol message
@@ -68,7 +69,7 @@ export class ContractRequestHandler extends AbstractMessageHandler {
         const { scope = [] } = message.body;
         const zkpResponses = await processZeroKnowledgeProofRequests(did, scope, verifierDid, this._proofService, {
             ethSigner,
-            challenge,
+            challenge: challenge ?? BytesHelper.bytesToInt(hexToBytes(await ethSigner.getAddress())),
             supportedCircuits: this._supportedCircuits
         });
         const methodId = message.body.transaction_data.method_id.replace('0x', '');
@@ -79,6 +80,8 @@ export class ContractRequestHandler extends AbstractMessageHandler {
                 for (const [txHash, zkpResponses] of txHashZkpResponsesMap) {
                     response.set(txHash, { responses: zkpResponses });
                 }
+                // set txHash of the first response
+                message.body.transaction_data.txHash = txHashZkpResponsesMap.keys().next().value;
                 return response;
             }
             case FunctionSignatures.SubmitZKPResponseV1: {
@@ -87,6 +90,8 @@ export class ContractRequestHandler extends AbstractMessageHandler {
                 for (const [txHash, zkpResponse] of txHashZkpResponseMap) {
                     response.set(txHash, { responses: [zkpResponse] });
                 }
+                // set txHash of the first response
+                message.body.transaction_data.txHash = txHashZkpResponseMap.keys().next().value;
                 return response;
             }
             case FunctionSignatures.SubmitResponse: {
@@ -100,13 +105,16 @@ export class ContractRequestHandler extends AbstractMessageHandler {
                 // Get first supported accept profile and pass it to processProofAuth
                 const acceptProfile = this.getFirstSupportedProfile(PROTOCOL_MESSAGE_TYPE.CONTRACT_INVOKE_REQUEST_MESSAGE_TYPE, message.body.accept);
                 const identifier = DID.parse(message.to);
-                const authResponse = await processProofAuth(identifier, this._proofService, {
+                const { authProof } = await 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);
+                // we return txHash because responsesMap could be empty if there are no queries in scope
+                const txHashZkpResponsesMap = await this._zkpVerifier.submitResponse(ethSigner, message.body.transaction_data, zkpResponses, authProof);
+                message.body.transaction_data.txHash = txHashZkpResponsesMap.keys().next().value;
+                return txHashZkpResponsesMap;
             }
             default:
                 throw new Error(`Not supported method id. Only '${FunctionSignatures.SubmitZKPResponseV1}, ${FunctionSignatures.SubmitZKPResponseV2} and ${FunctionSignatures.SubmitResponse} are supported.'`);
@@ -177,8 +185,8 @@ export class ContractRequestHandler extends AbstractMessageHandler {
             }
             contractInvokeResponse.body = {
                 ...contractInvokeResponse.body,
-                crossChainProofs: zkpResponses.crossChainProofs ?? [],
-                authProofs: zkpResponses.authProofs ?? []
+                crossChainProof: zkpResponses.crossChainProof,
+                authProof: zkpResponses.authProof
             };
         }
         return contractInvokeResponse;

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

@@ -1,5 +1,4 @@
 export * from './envelope';
 export * from './message';
 export * from './did';
-export * from './contract-request.utils';
 export * from './accept-profile';

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

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

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

@@ -0,0 +1,14 @@
+import { ethers } from 'ethers';
+export const packZkpProof = (inputs, a, b, c) => {
+    return new ethers.AbiCoder().encode(['uint256[] inputs', 'uint256[2]', 'uint256[2][2]', 'uint256[2]'], [inputs, a, b, c]);
+};
+export 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)
+    };
+};

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

@@ -1,14 +1,14 @@
 import { JsonRpcProvider, Contract, ethers } from 'ethers';
+import { AuthMethod, processProofResponse } from '../../iden3comm';
 import abi from './abi/ZkpVerifier.json';
 //import { UniversalVerifier } from '@iden3/universal-verifier-v2-abi';
 import { IVerifierABI } from '@iden3/universal-verifier-v2-abi';
 import { TransactionService } from '../../blockchain';
-import { chainIDfromDID, DID, Id } from '@iden3/js-iden3-core';
+import { BytesHelper, chainIDfromDID, DID, Id } from '@iden3/js-iden3-core';
 import { AtomicQueryMTPV2OnChainPubSignals, AtomicQuerySigV2OnChainPubSignals, AtomicQueryV3OnChainPubSignals, AuthV2PubSignals, CircuitId } from '../../circuits';
-import { byteEncoder, DIDDocumentSignature, resolveDidDocument } from '../../utils';
-import { poseidon } from '@iden3/js-crypto';
+import { byteEncoder, bytesToHex, DIDDocumentSignature, resolveDidDocument } from '../../utils';
 import { Hash } from '@iden3/js-merkletree';
-import { packZkpProof, prepareZkpProof } from '../../iden3comm/utils';
+import { packZkpProof, prepareZkpProof } from './common';
 const maxGasLimit = 10000000n;
 /**
  * Supported function signature for SubmitZKPResponse
@@ -26,6 +26,22 @@ export var FunctionSignatures;
     //function submitResponse(tuple(string authMethod,bytes proof),tuple(uint256 requestId,bytes proof,bytes metadata)[],bytes crossChainProof)
     FunctionSignatures["SubmitResponse"] = "06c86a91";
 })(FunctionSignatures || (FunctionSignatures = {}));
+export 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
+    ];
+};
 /**
  * OnChainZKPVerifier is a class that allows to interact with the OnChainZKPVerifier contract
  * and submitZKPResponse.
@@ -152,7 +168,7 @@ export 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`);
@@ -165,7 +181,7 @@ export class OnChainZKPVerifier {
         }
         const provider = new 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)
@@ -174,7 +190,7 @@ export class OnChainZKPVerifier {
             ? BigInt(chainConfig.maxPriorityFeePerGas)
             : feeData.maxPriorityFeePerGas;
         const verifierContract = new Contract(txData.contract_address, 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,
@@ -193,35 +209,90 @@ export 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 AuthMethod.AUTHV2: {
+                const preparedZkpProof = prepareZkpProof(authProof.zkp.proof);
+                encodedAuthProof = packZkpProof(authProof.zkp.pub_signals, preparedZkpProof.a, preparedZkpProof.b, preparedZkpProof.c);
+                break;
+            }
+            case AuthMethod.ETH_IDENTITY: {
+                encodedAuthProof = 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 } = 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 == 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: 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 [
@@ -246,61 +317,30 @@ export 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 = prepareZkpProof(zkProof.proof);
-            const zkProofEncoded = 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 = poseidon.hashBytes(byteEncoder.encode(JSON.stringify(zkProof.vp.verifiableCredential.credentialSubject[key])));
-                    const bytesValue = 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 } = 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) {
@@ -308,30 +348,11 @@ export 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 = prepareZkpProof(zkProof.proof);
-        const zkProofEncoded = 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 = poseidon.hashBytes(byteEncoder.encode(JSON.stringify(zkProof.vp.verifiableCredential.credentialSubject[key])));
-                const bytesValue = 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 = [];
@@ -375,9 +396,6 @@ export class OnChainZKPVerifier {
                 ')'
         ], [msg]);
     }
-    static packMetadatas(metas) {
-        return new ethers.AbiCoder().encode(['tuple(' + 'string key,' + 'bytes value' + ')[]'], [metas]);
-    }
     static getOnChainGistRootStatePubSignals(onChainCircuitId, inputs) {
         const PubSignals = this._supportedCircuitsPubSignalsMap[onChainCircuitId];
         if (!PubSignals) {
@@ -436,3 +454,11 @@ OnChainZKPVerifier._supportedCircuitsPubSignalsMap = {
     [CircuitId.AtomicQueryV3OnChain]: AtomicQueryV3OnChainPubSignals,
     [CircuitId.AuthV2]: 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.
+ */
+export const packEthIdentityProof = (did) => {
+    return `0x${bytesToHex(BytesHelper.intToBytes(DID.idFromDID(did).bigInt()))}`;
+};

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

@@ -4,7 +4,7 @@ import { byteEncoder } from '../../utils';
 import abi from './abi/State.json';
 import { DID, getChainId, Id } from '@iden3/js-iden3-core';
 import { TransactionService } from '../../blockchain';
-import { prepareZkpProof } from '../../iden3comm/utils';
+import { prepareZkpProof } from './common';
 export /** @type {EthConnectionConfig} - default configuration for EthConnectionConfig */ const defaultEthConnectionConfig = {
     url: 'http://localhost:8545',
     defaultGasLimit: 600000,

package/dist/types/iden3comm/handlers/common.d.ts

@@ -1,4 +1,4 @@
-import { AcceptProfile, AuthProofResponse, BasicMessage, JWSPackerParams, ZeroKnowledgeProofRequest, ZeroKnowledgeProofResponse } from '../types';
+import { AcceptProfile, AuthProof, BasicMessage, JWSPackerParams, ZeroKnowledgeProofRequest, ZeroKnowledgeProofResponse } from '../types';
 import { DID } from '@iden3/js-iden3-core';
 import { IProofService } from '../../proof';
 import { CircuitId } from '../../circuits';
@@ -32,13 +32,40 @@ export declare const processZeroKnowledgeProofRequests: (to: DID, requests: Zero
 export declare const processProofAuth: (to: DID, proofService: IProofService, opts: {
     supportedCircuits: CircuitId[];
     acceptProfile?: AcceptProfile;
-    challenge?: bigint;
-    skipRevocation?: boolean;
-}) => Promise<AuthProofResponse>;
+    senderAddress: string;
+    zkpResponses: ZeroKnowledgeProofResponse[];
+}) => Promise<{
+    authProof: AuthProof;
+}>;
+/**
+ * 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.
+ */
+export declare const processProofResponse: (zkProof: ZeroKnowledgeProofResponse) => {
+    requestId: string | number;
+    zkProofEncoded: string;
+    metadata: string;
+};
+/**
+ * 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.
+ */
+export declare const calcChallengeAuthV2: (senderAddress: string, zkpResponses: ZeroKnowledgeProofResponse[]) => bigint;
+/**
+ * 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.
+ */
+export declare const packMetadatas: (metas: {
+    key: string;
+    value: Uint8Array;
+}[]) => string;
 /**
  * Verifies that the expires_time field of a message is not in the past. Throws an error if it is.
  *
  * @param message - Basic message to verify.
  */
 export declare const verifyExpiresTime: (message: BasicMessage) => void;
-export declare const packEthIdentityProof: (did: DID) => string;

package/dist/types/iden3comm/types/protocol/auth.d.ts

@@ -5,7 +5,7 @@ import { ProofType } from '../../../verifiable';
 import { CircuitId } from '../../../circuits';
 import { DIDDocument as DidResolverDidDocument, VerificationMethod as DidResolverVerificationMethod } from 'did-resolver';
 import { RootInfo, StateInfo } from '../../../storage';
-import { AuthProofResponse } from './contract-request';
+import { AuthProof, CrossChainProof } from './contract-request';
 /** AuthorizationResponseMessage is struct the represents iden3message authorization response */
 export type AuthorizationResponseMessage = BasicMessage & {
     body: AuthorizationMessageResponseBody;
@@ -56,8 +56,8 @@ export type ZeroKnowledgeProofQuery = {
 };
 export type ZeroKnowledgeInvokeResponse = {
     responses: ZeroKnowledgeProofResponse[];
-    crossChainProofs?: string[];
-    authProofs?: AuthProofResponse[];
+    crossChainProof?: CrossChainProof;
+    authProof?: AuthProof;
 };
 /** ZeroKnowledgeProofResponse represents structure of zkp response */
 export type ZeroKnowledgeProofResponse = {