feat: add support of submitZKPResponseCrossChain (#254)

feat: add support of  submitZKPResponseV2 and prepareTxArgsSubmit

Author: volodymyr-basiuk

src/circuits/atomic-query-mtp-v2-on-chain.ts

@@ -7,6 +7,8 @@ import {
   bigIntArrayToStringArray,
   existenceToInt,
   getNodeAuxValue,
+  IStateInfoPubSignals,
+  StatesInfo,
   prepareCircuitArrayValues,
   prepareSiblingsStr
 } from './common';
@@ -240,7 +242,7 @@ interface atomicQueryMTPV2OnChainCircuitInputs {
  * @class AtomicQueryMTPV2OnChainPubSignals
  * @extends {BaseConfig}
  */
-export class AtomicQueryMTPV2OnChainPubSignals extends BaseConfig {
+export class AtomicQueryMTPV2OnChainPubSignals extends BaseConfig implements IStateInfoPubSignals {
   requestID!: bigint;
   userID!: Id;
   issuerID!: Id;
@@ -322,4 +324,15 @@ export class AtomicQueryMTPV2OnChainPubSignals extends BaseConfig {
 
     return this;
   }
+
+  /** {@inheritDoc IStateInfoPubSignals.getStatesInfo} */
+  getStatesInfo(): StatesInfo {
+    return {
+      states: [
+        { id: this.issuerID, state: this.issuerClaimIdenState },
+        { id: this.issuerID, state: this.issuerClaimNonRevState }
+      ],
+      gists: [{ id: this.userID, root: this.gistRoot }]
+    };
+  }
 }

src/circuits/atomic-query-sig-v2-on-chain.ts

@@ -7,8 +7,10 @@ import {
   bigIntArrayToStringArray,
   existenceToInt,
   getNodeAuxValue,
+  IStateInfoPubSignals,
   prepareCircuitArrayValues,
-  prepareSiblingsStr
+  prepareSiblingsStr,
+  StatesInfo
 } from './common';
 import { byteDecoder, byteEncoder } from '../utils';
 
@@ -312,7 +314,7 @@ export class AtomicQuerySigV2OnChainCircuitInputs {
  * @class AtomicQuerySigV2OnChainPubSignals
  * @extends {BaseConfig}
  */
-export class AtomicQuerySigV2OnChainPubSignals extends BaseConfig {
+export class AtomicQuerySigV2OnChainPubSignals extends BaseConfig implements IStateInfoPubSignals {
   requestID!: bigint;
   userID!: Id;
   issuerID!: Id;
@@ -397,4 +399,15 @@ export class AtomicQuerySigV2OnChainPubSignals extends BaseConfig {
 
     return this;
   }
+
+  /** {@inheritDoc IStateInfoPubSignals.getStatesInfo} */
+  getStatesInfo(): StatesInfo {
+    return {
+      states: [
+        { id: this.issuerID, state: this.issuerAuthState },
+        { id: this.issuerID, state: this.issuerClaimNonRevState }
+      ],
+      gists: [{ id: this.userID, root: this.gistRoot }]
+    };
+  }
 }

src/circuits/atomic-query-v3-on-chain.ts

@@ -4,7 +4,9 @@ import {
   bigIntArrayToStringArray,
   prepareSiblingsStr,
   getNodeAuxValue,
-  prepareCircuitArrayValues
+  prepareCircuitArrayValues,
+  IStateInfoPubSignals,
+  StatesInfo
 } from './common';
 import { BJJSignatureProof, CircuitError, GISTProof, Query, TreeState, ValueProof } from './models';
 import { Hash, Proof, ZERO_HASH } from '@iden3/js-merkletree';
@@ -420,7 +422,7 @@ interface AtomicQueryV3OnChainCircuitInputs {
  * @beta
  * AtomicQueryV3OnChainPubSignals public inputs
  */
-export class AtomicQueryV3OnChainPubSignals extends BaseConfig {
+export class AtomicQueryV3OnChainPubSignals extends BaseConfig implements IStateInfoPubSignals {
   requestID!: bigint;
   userID!: Id;
   issuerID!: Id;
@@ -515,4 +517,15 @@ export class AtomicQueryV3OnChainPubSignals extends BaseConfig {
 
     return this;
   }
+
+  /** {@inheritDoc IStateInfoPubSignals.getStatesInfo} */
+  getStatesInfo(): StatesInfo {
+    return {
+      states: [
+        { id: this.issuerID, state: this.issuerState },
+        { id: this.issuerID, state: this.issuerClaimNonRevState }
+      ],
+      gists: [{ id: this.userID, root: this.gistRoot }]
+    };
+  }
 }

src/circuits/common.ts

@@ -1,6 +1,7 @@
 import { Hex } from '@iden3/js-crypto';
 import { Hash, ZERO_HASH, Proof, swapEndianness } from '@iden3/js-merkletree';
 import { TreeState } from './models';
+import { Id } from '@iden3/js-iden3-core';
 
 export const defaultMTLevels = 40; // max MT levels, default value for identity circuits
 export const defaultValueArraySize = 64; // max value array size, default value for identity circuits
@@ -226,3 +227,35 @@ export function getProperties(obj: object): object {
   }
   return result;
 }
+
+/**
+ * states info from pub signals
+ *
+ * @public
+ * @type   StatesInfo
+ */
+export type StatesInfo = {
+  states: {
+    id: Id;
+    state: Hash;
+  }[];
+  gists: {
+    id: Id;
+    root: Hash;
+  }[];
+};
+
+/**
+ * state pub signals
+ *
+ * @public
+ * @interface   IStatePubSignals
+ */
+export interface IStateInfoPubSignals {
+  /**
+   * return object with state params
+   *
+   * @returns {OnChainStateInfo}
+   */
+  getStatesInfo(): StatesInfo;
+}

src/iden3comm/constants.ts

@@ -36,6 +36,9 @@ export const PROTOCOL_MESSAGE_TYPE = Object.freeze({
   // ContractInvokeRequestMessageType is type for request of contract invoke request
   CONTRACT_INVOKE_REQUEST_MESSAGE_TYPE:
     `${IDEN3_PROTOCOL}proofs/1.0/contract-invoke-request` as const,
+  // ContractInvokeResponseMessageType is type for response of contract invoke request
+  CONTRACT_INVOKE_RESPONSE_MESSAGE_TYPE:
+    `${IDEN3_PROTOCOL}proofs/1.0/contract-invoke-response` as const,
   // CredentialOnchainOfferMessageType is type of message with credential onchain offering
   CREDENTIAL_ONCHAIN_OFFER_MESSAGE_TYPE: `${IDEN3_PROTOCOL}credentials/1.0/onchain-offer` as const,
   // ProposalRequestMessageType is type for proposal-request message

src/iden3comm/handlers/contract-request.ts

@@ -2,9 +2,9 @@ import { CircuitId } from '../../circuits/models';
 import { IProofService } from '../../proof/proof-service';
 import { PROTOCOL_MESSAGE_TYPE } from '../constants';
 import { BasicMessage, IPackageManager, ZeroKnowledgeProofResponse } from '../types';
-import { ContractInvokeRequest } from '../types/protocol/contract-request';
+import { ContractInvokeRequest, ContractInvokeResponse } from '../types/protocol/contract-request';
 import { DID, ChainIds } from '@iden3/js-iden3-core';
-import { IOnChainZKPVerifier } from '../../storage';
+import { FunctionSignatures, IOnChainZKPVerifier } from '../../storage';
 import { Signer } from 'ethers';
 import { processZeroKnowledgeProofRequests } from './common';
 import { AbstractMessageHandler, IProtocolMessageHandler } from './message-handler';
@@ -17,15 +17,15 @@ import { AbstractMessageHandler, IProtocolMessageHandler } from './message-handl
  */
 export interface IContractRequestHandler {
   /**
-   * unpacks contract invoker request
+   * unpacks contract invoke request
    * @beta
    * @param {Uint8Array} request - raw byte message
    * @returns `Promise<ContractInvokeRequest>`
    */
   parseContractInvokeRequest(request: Uint8Array): Promise<ContractInvokeRequest>;
 
   /**
-   * handle contract invoker request
+   * handle contract invoke request
    * @beta
    * @param {did} did  - sender DID
    * @param {Uint8Array} request - raw byte message
@@ -91,9 +91,11 @@ export class ContractRequestHandler
     ctx: ContractMessageHandlerOptions
   ): Promise<BasicMessage | null> {
     switch (message.type) {
-      case PROTOCOL_MESSAGE_TYPE.CONTRACT_INVOKE_REQUEST_MESSAGE_TYPE:
-        await this.handleContractInvoke(message as ContractInvokeRequest, ctx);
-        return null;
+      case PROTOCOL_MESSAGE_TYPE.CONTRACT_INVOKE_REQUEST_MESSAGE_TYPE: {
+        const ciMessage = message as ContractInvokeRequest;
+        const txHashResponsesMap = await this.handleContractInvoke(ciMessage, ctx);
+        return this.createContractInvokeResponse(ciMessage, txHashResponsesMap);
+      }
       default:
         return super.handle(message, ctx);
     }
@@ -102,7 +104,7 @@ export class ContractRequestHandler
   private async handleContractInvoke(
     message: ContractInvokeRequest,
     ctx: ContractMessageHandlerOptions
-  ): Promise<Map<string, ZeroKnowledgeProofResponse>> {
+  ): Promise<Map<string, ZeroKnowledgeProofResponse[]>> {
     if (message.type !== PROTOCOL_MESSAGE_TYPE.CONTRACT_INVOKE_REQUEST_MESSAGE_TYPE) {
       throw new Error('Invalid message type for contract invoke request');
     }
@@ -127,11 +129,31 @@ export class ContractRequestHandler
       { ethSigner, challenge, supportedCircuits: this._supportedCircuits }
     );
 
-    return this._zkpVerifier.submitZKPResponse(
-      ethSigner,
-      message.body.transaction_data,
-      zkpResponses
-    );
+    const methodId = message.body.transaction_data.method_id.replace('0x', '');
+    switch (methodId) {
+      case FunctionSignatures.SumbitZKPResponseV2:
+        return this._zkpVerifier.submitZKPResponseV2(
+          ethSigner,
+          message.body.transaction_data,
+          zkpResponses
+        );
+      case FunctionSignatures.SumbitZKPResponseV1: {
+        const txHashZkpResponseMap = await this._zkpVerifier.submitZKPResponse(
+          ethSigner,
+          message.body.transaction_data,
+          zkpResponses
+        );
+        const response = new Map<string, ZeroKnowledgeProofResponse[]>();
+        for (const [txHash, zkpResponse] of txHashZkpResponseMap) {
+          response.set(txHash, [zkpResponse]);
+        }
+        return response;
+      }
+      default:
+        throw new Error(
+          `Not supported method id. Only '${FunctionSignatures.SumbitZKPResponseV1} and ${FunctionSignatures.SumbitZKPResponseV2} are supported.'`
+        );
+    }
   }
 
   /**
@@ -151,8 +173,45 @@ export class ContractRequestHandler
   }
 
   /**
-   * handle contract invoker request
+   * creates contract invoke response
+   * @private
+   * @beta
+   * @param {ContractInvokeRequest} request - ContractInvokeRequest
+   * @param { Map<string, ZeroKnowledgeProofResponse[]>} responses - map tx hash to array of ZeroKnowledgeProofResponses
+   * @returns `Promise<ContractInvokeResponse>`
+   */
+  private async createContractInvokeResponse(
+    request: ContractInvokeRequest,
+    txHashToZkpResponseMap: Map<string, ZeroKnowledgeProofResponse[]>
+  ): Promise<ContractInvokeResponse> {
+    const contractInvokeResponse: ContractInvokeResponse = {
+      id: request.id,
+      thid: request.thid,
+      type: PROTOCOL_MESSAGE_TYPE.CONTRACT_INVOKE_RESPONSE_MESSAGE_TYPE,
+      from: request.to,
+      to: request.from,
+      body: {
+        transaction_data: request.body.transaction_data,
+        reason: request.body.reason,
+        scope: []
+      }
+    };
+    for (const [txHash, zkpResponses] of txHashToZkpResponseMap) {
+      for (const zkpResponse of zkpResponses) {
+        contractInvokeResponse.body.scope.push({
+          txHash,
+          ...zkpResponse
+        });
+      }
+    }
+    return contractInvokeResponse;
+  }
+
+  /**
+   * handle contract invoke request
+   * supports only 0xb68967e2 method id
    * @beta
+   * @deprecated
    * @param {did} did  - sender DID
    * @param {ContractInvokeRequest} request  - contract invoke request
    * @param {ContractInvokeHandlerOptions} opts - handler options
@@ -165,10 +224,37 @@ export class ContractRequestHandler
   ): Promise<Map<string, ZeroKnowledgeProofResponse>> {
     const ciRequest = await this.parseContractInvokeRequest(request);
 
-    return this.handleContractInvoke(ciRequest, {
-      senderDid: did,
-      ethSigner: opts.ethSigner,
-      challenge: opts.challenge
-    });
+    if (ciRequest.body.transaction_data.method_id !== FunctionSignatures.SumbitZKPResponseV1) {
+      throw new Error(`please use handle method to work with other method ids`);
+    }
+
+    if (ciRequest.type !== PROTOCOL_MESSAGE_TYPE.CONTRACT_INVOKE_REQUEST_MESSAGE_TYPE) {
+      throw new Error('Invalid message type for contract invoke request');
+    }
+
+    const { ethSigner, challenge } = opts;
+    if (!ethSigner) {
+      throw new Error("Can't sign transaction. Provide Signer in options.");
+    }
+
+    const { chain_id } = ciRequest.body.transaction_data;
+    const networkFlag = Object.keys(ChainIds).find((key) => ChainIds[key] === chain_id);
+
+    if (!networkFlag) {
+      throw new Error(`Invalid chain id ${chain_id}`);
+    }
+    const verifierDid = ciRequest.from ? DID.parse(ciRequest.from) : undefined;
+    const zkpResponses = await processZeroKnowledgeProofRequests(
+      did,
+      ciRequest?.body?.scope,
+      verifierDid,
+      this._proofService,
+      { ethSigner, challenge, supportedCircuits: this._supportedCircuits }
+    );
+    return this._zkpVerifier.submitZKPResponse(
+      ethSigner,
+      ciRequest.body.transaction_data,
+      zkpResponses
+    );
   }
 }

src/iden3comm/types/protocol/auth.ts

@@ -49,5 +49,16 @@ export type ZeroKnowledgeProofRequest = {
 export type ZeroKnowledgeProofResponse = {
   id: number;
   circuitId: string;
-  vp?: object;
+  vp?: VerifiablePresentation;
 } & ZKProof;
+
+/** VerifiablePresentation represents structure of Verifiable Presentation */
+export type VerifiablePresentation = {
+  '@context': string | (string | object)[];
+  '@type': string;
+  verifiableCredential: {
+    '@context': string | string[];
+    '@type': string | string[];
+    credentialSubject: JsonDocumentObject;
+  };
+};

src/iden3comm/types/protocol/contract-request.ts

@@ -1,6 +1,6 @@
 import { PROTOCOL_MESSAGE_TYPE } from '../../constants';
 import { BasicMessage } from '../packer';
-import { ZeroKnowledgeProofRequest } from './auth';
+import { ZeroKnowledgeProofRequest, ZeroKnowledgeProofResponse } from './auth';
 
 /** ContractInvokeRequest represents structure of contract invoke request object */
 export type ContractInvokeRequest = BasicMessage & {
@@ -15,6 +15,24 @@ export type ContractInvokeRequestBody = {
   scope: Array<ZeroKnowledgeProofRequest>;
 };
 
+/** ContractInvokeResponse represents structure of contract invoke response object */
+export type ContractInvokeResponse = BasicMessage & {
+  body: ContractInvokeResponseBody;
+  type: typeof PROTOCOL_MESSAGE_TYPE.CONTRACT_INVOKE_RESPONSE_MESSAGE_TYPE;
+};
+
+/** ContractInvokeResponseBody represents structure of contract invoke response body object */
+export type ContractInvokeResponseBody = {
+  scope: Array<OnChainZeroKnowledgeProofResponse>;
+  transaction_data: ContractInvokeTransactionData;
+  reason: string;
+};
+
+/** OnChainZeroKnowledgeProofResponse represents structure of onchain zero knowledge proof response */
+export type OnChainZeroKnowledgeProofResponse = ZeroKnowledgeProofResponse & {
+  txHash: string;
+};
+
 /** ContractInvokeTransactionData represents structure of contract invoke transaction data object */
 export type ContractInvokeTransactionData = {
   contract_address: string;