@0xpolygonid/js-sdk 1.28.1 → 1.29.0

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

@@ -1,9 +1,10 @@
 import { CircuitId } from '../../circuits/models';
-import { PROTOCOL_MESSAGE_TYPE } from '../constants';
+import { defaultAcceptProfile, PROTOCOL_MESSAGE_TYPE, ProtocolVersion } from '../constants';
 import { DID, ChainIds, getUnixTimestamp } from '@iden3/js-iden3-core';
 import { FunctionSignatures } from '../../storage';
-import { processZeroKnowledgeProofRequests, verifyExpiresTime } from './common';
+import { processProofAuth, processZeroKnowledgeProofRequests, verifyExpiresTime } from './common';
 import { AbstractMessageHandler } from './message-handler';
+import { parseAcceptProfile } from '../utils';
 /**
  *
  * Allows to process ContractInvokeRequest protocol message
@@ -19,6 +20,7 @@ export class ContractRequestHandler extends 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) {
@@ -30,7 +32,12 @@ export class ContractRequestHandler extends AbstractMessageHandler {
             CircuitId.AuthV2,
             CircuitId.AtomicQueryMTPV2OnChain,
             CircuitId.AtomicQuerySigV2OnChain,
-            CircuitId.AtomicQueryV3OnChain
+            CircuitId.AtomicQueryV3OnChain,
+            // Now we support off-chain circuits on-chain
+            // TODO: We need to create validators for them
+            CircuitId.AuthV2,
+            CircuitId.AtomicQueryV3,
+            CircuitId.LinkedMultiQuery10
         ];
     }
     async handle(message, ctx) {
@@ -66,19 +73,64 @@ export class ContractRequestHandler extends AbstractMessageHandler {
         });
         const methodId = message.body.transaction_data.method_id.replace('0x', '');
         switch (methodId) {
-            case FunctionSignatures.SubmitZKPResponseV2:
-                return this._zkpVerifier.submitZKPResponseV2(ethSigner, message.body.transaction_data, zkpResponses);
+            case FunctionSignatures.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 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 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(PROTOCOL_MESSAGE_TYPE.CONTRACT_INVOKE_REQUEST_MESSAGE_TYPE, message.body.accept);
+                const identifier = DID.parse(message.to);
+                const authResponse = await 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 '${FunctionSignatures.SubmitZKPResponseV1} and ${FunctionSignatures.SubmitZKPResponseV2} are supported.'`);
+                throw new Error(`Not supported method id. Only '${FunctionSignatures.SubmitZKPResponseV1}, ${FunctionSignatures.SubmitZKPResponseV2} and ${FunctionSignatures.SubmitResponse} are supported.'`);
+        }
+    }
+    getFirstSupportedProfile(responseType, profile) {
+        if (profile?.length) {
+            for (const acceptProfileString of profile) {
+                // 1. check protocol version
+                const acceptProfile = parseAcceptProfile(acceptProfileString);
+                const responseTypeVersion = Number(responseType.split('/').at(-2));
+                if (acceptProfile.protocolVersion !== ProtocolVersion.V1 ||
+                    (acceptProfile.protocolVersion === 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 defaultAcceptProfile;
     }
     /**
      * unpacks contract-invoke request
@@ -100,7 +152,7 @@ export class ContractRequestHandler extends 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) {
@@ -117,12 +169,17 @@ export class ContractRequestHandler extends AbstractMessageHandler {
             created_time: 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/esm/iden3comm/types/protocol/contract-request.js

@@ -1 +1,5 @@
-export {};
+export var AuthMethod;
+(function (AuthMethod) {
+    AuthMethod["AUTHV2"] = "authV2";
+    AuthMethod["ETH_IDENTITY"] = "ethIdentity";
+})(AuthMethod || (AuthMethod = {}));

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

@@ -1,4 +1,4 @@
-import { keccak256 } from 'ethers';
+import { ethers, keccak256 } from 'ethers';
 import { byteEncoder, hexToBytes, isEthereumIdentity } from '../../utils';
 import { CircuitId } from '../../circuits';
 import { Hex } from '@iden3/js-crypto';
@@ -52,3 +52,16 @@ export async function prepareAuthV2ZeroKnowledgeResponse(address, senderDid, pro
         }
     ];
 }
+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/proof/proof-service.js

@@ -128,6 +128,32 @@ export class ProofService {
             pub_signals
         };
     }
+    /** {@inheritdoc IProofService.generateAuthProof} */
+    async generateAuthProof(circuitId, identifier, opts) {
+        if (!opts) {
+            opts = {
+                skipRevocation: false,
+                challenge: 0n
+            };
+        }
+        let zkProof;
+        switch (circuitId) {
+            case CircuitId.AuthV2:
+                {
+                    const challenge = opts.challenge
+                        ? 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/esm/storage/blockchain/onchain-zkp-verifier.js

@@ -1,11 +1,14 @@
 import { JsonRpcProvider, Contract, ethers } from 'ethers';
 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 { AtomicQueryMTPV2OnChainPubSignals, AtomicQuerySigV2OnChainPubSignals, AtomicQueryV3OnChainPubSignals, AuthV2PubSignals, CircuitId } from '../../circuits';
 import { byteEncoder, DIDDocumentSignature, resolveDidDocument } from '../../utils';
 import { poseidon } from '@iden3/js-crypto';
 import { Hash } from '@iden3/js-merkletree';
+import { packZkpProof, prepareZkpProof } from '../../iden3comm/utils';
 const maxGasLimit = 10000000n;
 /**
  * Supported function signature for SubmitZKPResponse
@@ -20,6 +23,8 @@ export 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 || (FunctionSignatures = {}));
 /**
  * OnChainZKPVerifier is a class that allows to interact with the OnChainZKPVerifier contract
@@ -45,16 +50,8 @@ export 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 = prepareZkpProof(zkProofResponse.proof);
+        const payload = [requestID, inputs, preparedZkpProof.a, preparedZkpProof.b, preparedZkpProof.c];
         return payload;
     }
     /**
@@ -152,6 +149,80 @@ export 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 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 Contract(txData.contract_address, 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 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({
@@ -193,10 +264,8 @@ export 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 = 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);
@@ -239,8 +308,30 @@ export class OnChainZKPVerifier {
         }
         return OnChainZKPVerifier.prepareTxArgsSubmitV2(this._opts.didResolverUrl, txData, zkProofResponses);
     }
-    static packZkpProof(inputs, a, b, c) {
-        return new 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 = 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 packCrossChainProofs(gistUpdateArr, stateUpdateArr) {
         const proofs = [];

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

@@ -4,6 +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';
 export /** @type {EthConnectionConfig} - default configuration for EthConnectionConfig */ const defaultEthConnectionConfig = {
     url: 'http://localhost:8545',
     defaultGasLimit: 600000,
@@ -73,17 +74,15 @@ export class EthStateStorage {
         const { userId, oldUserState, newUserState, isOldStateGenesis } = stateTransitionPubSig;
         const { stateContract, provider } = this.getStateContractAndProviderForId(userId.bigInt());
         const contract = stateContract.connect(signer);
+        const preparedZkpProof = 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 = defaultEthConnectionConfig.maxFeePerGas

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

@@ -1,4 +1,4 @@
-import { BasicMessage, JWSPackerParams, ZeroKnowledgeProofRequest, ZeroKnowledgeProofResponse } from '../types';
+import { AcceptProfile, AuthProofResponse, BasicMessage, JWSPackerParams, ZeroKnowledgeProofRequest, ZeroKnowledgeProofResponse } from '../types';
 import { DID } from '@iden3/js-iden3-core';
 import { IProofService } from '../../proof';
 import { CircuitId } from '../../circuits';
@@ -21,9 +21,24 @@ export declare const processZeroKnowledgeProofRequests: (to: DID, requests: Zero
     ethSigner?: Signer;
     challenge?: bigint;
 }) => Promise<ZeroKnowledgeProofResponse[]>;
+/**
+ * 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.
+ */
+export declare const processProofAuth: (to: DID, proofService: IProofService, opts: {
+    supportedCircuits: CircuitId[];
+    acceptProfile?: AcceptProfile;
+    challenge?: bigint;
+    skipRevocation?: boolean;
+}) => Promise<AuthProofResponse>;
 /**
  * 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/handlers/contract-request.d.ts

@@ -58,11 +58,13 @@ export declare class ContractRequestHandler extends AbstractMessageHandler imple
      * @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: IPackageManager, _proofService: IProofService, _zkpVerifier: IOnChainZKPVerifier);
     handle(message: BasicMessage, ctx: ContractMessageHandlerOptions): Promise<BasicMessage | null>;
     private handleContractInvoke;
+    private getFirstSupportedProfile;
     /**
      * unpacks contract-invoke request
      * @beta
@@ -75,7 +77,7 @@ export declare class ContractRequestHandler extends AbstractMessageHandler imple
      * @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>`
      */
     private createContractInvokeResponse;

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

@@ -5,6 +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';
 /** AuthorizationResponseMessage is struct the represents iden3message authorization response */
 export type AuthorizationResponseMessage = BasicMessage & {
     body: AuthorizationMessageResponseBody;
@@ -53,12 +54,19 @@ export type ZeroKnowledgeProofQuery = {
     groupId?: number;
     type: string;
 };
+export type ZeroKnowledgeInvokeResponse = {
+    responses: ZeroKnowledgeProofResponse[];
+    crossChainProofs?: string[];
+    authProofs?: AuthProofResponse[];
+};
 /** ZeroKnowledgeProofResponse represents structure of zkp response */
 export type ZeroKnowledgeProofResponse = {
     id: number;
     circuitId: string;
     vp?: VerifiablePresentation;
 } & ZKProof;
+/** ZeroKnowledgeProofAuthResponse represents structure of zkp auth response */
+export type ZeroKnowledgeProofAuthResponse = Omit<ZeroKnowledgeProofResponse, 'id' | 'vp'>;
 /** VerifiablePresentation represents structure of Verifiable Presentation */
 export type VerifiablePresentation = {
     '@context': string | (string | object)[];

package/dist/types/iden3comm/types/protocol/contract-request.d.ts

@@ -12,6 +12,7 @@ export type ContractInvokeRequestBody = {
     transaction_data: ContractInvokeTransactionData;
     scope: Array<ZeroKnowledgeProofRequest>;
     did_doc?: DIDDocument;
+    accept?: string[];
 };
 /** ContractInvokeResponse represents structure of contract invoke response object */
 export type ContractInvokeResponse = BasicMessage & {
@@ -23,6 +24,8 @@ export type ContractInvokeResponseBody = {
     scope: Array<OnChainZeroKnowledgeProofResponse>;
     transaction_data: ContractInvokeTransactionData;
     did_doc?: DIDDocument;
+    crossChainProofs?: string[];
+    authProofs?: AuthProofResponse[];
 };
 /** OnChainZeroKnowledgeProofResponse represents structure of onchain zero knowledge proof response */
 export type OnChainZeroKnowledgeProofResponse = ZeroKnowledgeProofResponse & {
@@ -35,3 +38,12 @@ export type ContractInvokeTransactionData = {
     chain_id: number;
     network?: string;
 };
+/** AuthProofResponse represents structure of zkp response */
+export type AuthProofResponse = {
+    authMethod: AuthMethod;
+    proof: string;
+};
+export declare enum AuthMethod {
+    AUTHV2 = "authV2",
+    ETH_IDENTITY = "ethIdentity"
+}

package/dist/types/iden3comm/utils/contract-request.utils.d.ts

@@ -2,6 +2,7 @@ import { CircuitId } from '../../circuits';
 import { DID } from '@iden3/js-iden3-core';
 import { IProofService } from '../../proof';
 import { ZeroKnowledgeProofResponse } from '../types';
+import { ProofData } from '@iden3/js-jwz';
 /**
  * @beta
  * Retrieves the request ID from circuit string.
@@ -18,3 +19,9 @@ export declare function calculateRequestIdForCircuit(circuitId: CircuitId): numb
  * @returns A promise that resolves to an array of ZeroKnowledgeProofResponse objects.
  */
 export declare function prepareAuthV2ZeroKnowledgeResponse(address: string, senderDid: DID, proofService: IProofService): Promise<ZeroKnowledgeProofResponse[]>;
+export declare const packZkpProof: (inputs: string[], a: string[], b: string[][], c: string[]) => string;
+export declare const prepareZkpProof: (proof: ProofData) => {
+    a: string[];
+    b: string[][];
+    c: string[];
+};

package/dist/types/proof/proof-service.d.ts

@@ -7,7 +7,7 @@ import { IZKProver } from './provers/prover';
 import { Options } from '@iden3/js-jsonld-merklization';
 import { ZKProof } from '@iden3/js-jwz';
 import { Signer } from 'ethers';
-import { StateVerificationOpts, JSONObject, ZeroKnowledgeProofRequest, ZeroKnowledgeProofResponse } from '../iden3comm';
+import { StateVerificationOpts, JSONObject, ZeroKnowledgeProofRequest, ZeroKnowledgeProofResponse, ZeroKnowledgeProofAuthResponse } from '../iden3comm';
 import { ICircuitStorage, IStateStorage } from '../storage';
 import { ProofGenerationOptions } from './provers/inputs-generator';
 import { VerifyOpts } from './verifiers';
@@ -74,13 +74,23 @@ export interface IProofService {
      */
     generateAuthV2Inputs(hash: Uint8Array, did: DID, circuitId: CircuitId): Promise<Uint8Array>;
     /**
-     * generates auth inputs
+     * generates auth v2 proof from given identity
      *
      * @param {Uint8Array} hash - challenge that will be signed
      * @param {DID} did - identity that will generate a proof
      * @returns `Promise<ZKProof>`
      */
     generateAuthV2Proof(hash: Uint8Array, did: DID): Promise<ZKProof>;
+    /**
+     * Generate auth proof from given identity with generic params
+     *
+     * @param {CircuitId} circuitId - circuitId for the proof generation
+     * @param {DID} identifier - did that will generate proof
+     * @param {ProofGenerationOptions} opts - options that will be used for proof generation
+     *
+     * @returns `Promise<ZeroKnowledgeProofResponse>`
+     */
+    generateAuthProof(circuitId: CircuitId, identifier: DID, opts?: ProofGenerationOptions): Promise<ZeroKnowledgeProofAuthResponse>;
     /**
      * state verification function
      *
@@ -138,6 +148,8 @@ export declare class ProofService implements IProofService {
     verifyZKPResponse(proofResp: ZeroKnowledgeProofResponse, opts: ProofVerifyOpts): Promise<VerificationResultMetadata>;
     /** {@inheritdoc IProofService.generateProof} */
     generateProof(proofReq: ZeroKnowledgeProofRequest, identifier: DID, opts?: ProofGenerationOptions): Promise<ZeroKnowledgeProofResponse>;
+    /** {@inheritdoc IProofService.generateAuthProof} */
+    generateAuthProof(circuitId: CircuitId, identifier: DID, opts?: ProofGenerationOptions): Promise<ZeroKnowledgeProofAuthResponse>;
     /** {@inheritdoc IProofService.transitState} */
     transitState(did: DID, oldTreeState: TreeState, isOldStateGenesis: boolean, stateStorage: IStateStorage, // for compatibility with previous versions we leave this parameter
     ethSigner: Signer): Promise<string>;

package/dist/types/storage/blockchain/onchain-zkp-verifier.d.ts

@@ -1,7 +1,7 @@
 import { Signer } from 'ethers';
 import { EthConnectionConfig } from './state';
 import { IOnChainZKPVerifier } from '../interfaces/onchain-zkp-verifier';
-import { ContractInvokeTransactionData, JsonDocumentObjectValue, ZeroKnowledgeProofResponse } from '../../iden3comm';
+import { AuthProofResponse, ContractInvokeTransactionData, JsonDocumentObjectValue, ZeroKnowledgeInvokeResponse, ZeroKnowledgeProofResponse } from '../../iden3comm';
 import { GlobalStateUpdate } from '../entities/state';
 /**
  * Supported function signature for SubmitZKPResponse
@@ -13,7 +13,8 @@ export declare enum FunctionSignatures {
      * uint256[2] calldata a, uint256[2][2] calldata b, uint256[2] calldata c) public
      */
     SubmitZKPResponseV1 = "b68967e2",
-    SubmitZKPResponseV2 = "ade09fcd"
+    SubmitZKPResponseV2 = "ade09fcd",
+    SubmitResponse = "06c86a91"
 }
 /**
  * OnChainZKPVerifierOptions represents OnChainZKPVerifier options
@@ -56,10 +57,16 @@ export declare class OnChainZKPVerifier implements IOnChainZKPVerifier {
      * {@inheritDoc IOnChainZKPVerifier.submitZKPResponseV2}
      */
     submitZKPResponseV2(ethSigner: Signer, txData: ContractInvokeTransactionData, zkProofResponses: ZeroKnowledgeProofResponse[]): Promise<Map<string, ZeroKnowledgeProofResponse[]>>;
+    /**
+     * {@inheritDoc IOnChainVerifierMultiQuery.submitResponse}
+     */
+    submitResponse(ethSigner: Signer, txData: ContractInvokeTransactionData, authResponse: AuthProofResponse, responses: ZeroKnowledgeProofResponse[]): Promise<Map<string, ZeroKnowledgeInvokeResponse>>;
+    static prepareTxArgsSubmit(resolverUrl: string, txData: ContractInvokeTransactionData, authResponse: AuthProofResponse, responses: ZeroKnowledgeProofResponse[]): Promise<JsonDocumentObjectValue[]>;
+    prepareTxArgsSubmit(txData: ContractInvokeTransactionData, authResponse: AuthProofResponse, responses: ZeroKnowledgeProofResponse[]): Promise<JsonDocumentObjectValue[]>;
     private static getCrossChainResolvers;
     static prepareTxArgsSubmitV2(resolverUrl: string, txData: ContractInvokeTransactionData, zkProofResponses: ZeroKnowledgeProofResponse[]): Promise<JsonDocumentObjectValue[]>;
     prepareTxArgsSubmitV2(txData: ContractInvokeTransactionData, zkProofResponses: ZeroKnowledgeProofResponse[]): Promise<JsonDocumentObjectValue[]>;
-    private static packZkpProof;
+    private static _processProof;
     private static packCrossChainProofs;
     static packGlobalStateMsg(msg: GlobalStateUpdate): string;
     private static packIdentityStateMsg;

package/dist/types/storage/interfaces/onchain-zkp-verifier.d.ts

@@ -1,5 +1,5 @@
 import { Signer } from 'ethers';
-import { ContractInvokeTransactionData, JsonDocumentObjectValue, ZeroKnowledgeProofResponse } from '../../iden3comm';
+import { AuthProofResponse, ContractInvokeTransactionData, JsonDocumentObjectValue, ZeroKnowledgeInvokeResponse, ZeroKnowledgeProofResponse } from '../../iden3comm';
 /**
  * Interface that defines methods for ZKP verifier
  *
@@ -25,6 +25,16 @@ export interface IOnChainZKPVerifier {
      * @returns {Promise<Map<string, ZeroKnowledgeProofResponse[]>>} - map of transaction hash - ZeroKnowledgeProofResponse[]
      */
     submitZKPResponseV2(ethSigner: Signer, txData: ContractInvokeTransactionData, zkProofResponses: ZeroKnowledgeProofResponse[]): Promise<Map<string, ZeroKnowledgeProofResponse[]>>;
+    /**
+     * Submit Response to OnChainZKPVerifier contract.
+     * @beta
+     * @param {Signer} ethSigner - tx signer
+     * @param {txData} ContractInvokeTransactionData - transaction data
+     * @param {AuthProofResponse} authResponse - authResponse
+     * @param {ZeroKnowledgeProofMultiQueryResponse[]} responses - singleResponses and groupedResponses
+     * @returns {Promise<Map<string, ZeroKnowledgeInvokeResponse>>} - map of transaction hash - ZeroKnowledgeInvokeResponse
+     */
+    submitResponse(ethSigner: Signer, txData: ContractInvokeTransactionData, authResponse: AuthProofResponse, responses: ZeroKnowledgeProofResponse[]): Promise<Map<string, ZeroKnowledgeInvokeResponse>>;
     /**
      * Returns tx args for the ZKP verifier contract submission (singe tx args for each response).
      * @param txData
@@ -37,4 +47,11 @@ export interface IOnChainZKPVerifier {
      * @param zkProofResponses
      */
     prepareTxArgsSubmitV2(txData: ContractInvokeTransactionData, zkProofResponses: ZeroKnowledgeProofResponse[]): Promise<JsonDocumentObjectValue[]>;
+    /**
+     * Returns args for the verifier multi-query contract submission (single tx args for an array of responses).
+     * @param {txData} ContractInvokeTransactionData - transaction data
+     * @param {AuthProofResponse} authResponse - authResponse
+     * @param {ZeroKnowledgeProofMultiQueryResponse[]} responses - singleResponses and groupedResponses
+     */
+    prepareTxArgsSubmit(txData: ContractInvokeTransactionData, authResponse: AuthProofResponse, responses: ZeroKnowledgeProofResponse[]): Promise<JsonDocumentObjectValue[]>;
 }