@0xpolygonid/js-sdk 1.29.0 → 1.29.2

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

@@ -1,6 +1,8 @@
+import { GlobalStateUpdate, IdentityStateUpdate } from '../../../storage/entities/state';
 import { PROTOCOL_MESSAGE_TYPE } from '../../constants';
 import { BasicMessage } from '../packer';
-import { DIDDocument, ZeroKnowledgeProofRequest, ZeroKnowledgeProofResponse } from './auth';
+import { DIDDocument, ZeroKnowledgeProofAuthResponse, ZeroKnowledgeProofRequest, ZeroKnowledgeProofResponse } from './auth';
+import { DID } from '@iden3/js-iden3-core';
 /** ContractInvokeRequest represents structure of contract invoke request object */
 export type ContractInvokeRequest = BasicMessage & {
     body: ContractInvokeRequestBody;
@@ -24,8 +26,8 @@ export type ContractInvokeResponseBody = {
     scope: Array<OnChainZeroKnowledgeProofResponse>;
     transaction_data: ContractInvokeTransactionData;
     did_doc?: DIDDocument;
-    crossChainProofs?: string[];
-    authProofs?: AuthProofResponse[];
+    crossChainProof?: CrossChainProof;
+    authProof?: AuthProof;
 };
 /** OnChainZeroKnowledgeProofResponse represents structure of onchain zero knowledge proof response */
 export type OnChainZeroKnowledgeProofResponse = ZeroKnowledgeProofResponse & {
@@ -38,10 +40,19 @@ export type ContractInvokeTransactionData = {
     chain_id: number;
     network?: string;
 };
+export type AuthProofEthIdentity = {
+    userDid: DID;
+};
+export type AuthProofZKP = {
+    zkp: ZeroKnowledgeProofAuthResponse;
+};
 /** AuthProofResponse represents structure of zkp response */
-export type AuthProofResponse = {
+export type AuthProof = {
     authMethod: AuthMethod;
-    proof: string;
+} & (AuthProofEthIdentity | AuthProofZKP);
+export type CrossChainProof = {
+    globalStateProofs: GlobalStateUpdate[];
+    identityStateProofs: IdentityStateUpdate[];
 };
 export declare enum AuthMethod {
     AUTHV2 = "authV2",

package/dist/types/iden3comm/utils/index.d.ts

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

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

@@ -9,7 +9,7 @@ import { ZKProof } from '@iden3/js-jwz';
 import { Signer } from 'ethers';
 import { StateVerificationOpts, JSONObject, ZeroKnowledgeProofRequest, ZeroKnowledgeProofResponse, ZeroKnowledgeProofAuthResponse } from '../iden3comm';
 import { ICircuitStorage, IStateStorage } from '../storage';
-import { ProofGenerationOptions } from './provers/inputs-generator';
+import { AuthProofGenerationOptions, ProofGenerationOptions } from './provers/inputs-generator';
 import { VerifyOpts } from './verifiers';
 export interface QueryWithFieldName {
     query: Query;
@@ -90,7 +90,7 @@ export interface IProofService {
      *
      * @returns `Promise<ZeroKnowledgeProofResponse>`
      */
-    generateAuthProof(circuitId: CircuitId, identifier: DID, opts?: ProofGenerationOptions): Promise<ZeroKnowledgeProofAuthResponse>;
+    generateAuthProof(circuitId: CircuitId, identifier: DID, opts?: AuthProofGenerationOptions): Promise<ZeroKnowledgeProofAuthResponse>;
     /**
      * state verification function
      *
@@ -149,7 +149,7 @@ export declare class ProofService implements IProofService {
     /** {@inheritdoc IProofService.generateProof} */
     generateProof(proofReq: ZeroKnowledgeProofRequest, identifier: DID, opts?: ProofGenerationOptions): Promise<ZeroKnowledgeProofResponse>;
     /** {@inheritdoc IProofService.generateAuthProof} */
-    generateAuthProof(circuitId: CircuitId, identifier: DID, opts?: ProofGenerationOptions): Promise<ZeroKnowledgeProofAuthResponse>;
+    generateAuthProof(circuitId: CircuitId, identifier: DID, opts?: AuthProofGenerationOptions): 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/proof/provers/inputs-generator.d.ts

@@ -18,6 +18,9 @@ export type ProofGenerationOptions = {
     verifierDid?: DID;
     linkNonce?: bigint;
 };
+export type AuthProofGenerationOptions = {
+    challenge?: bigint;
+};
 export type ProofInputsParams = ProofGenerationOptions & DIDProfileMetadata;
 type InputContext = {
     preparedCredential: PreparedCredential;

package/dist/types/storage/blockchain/common.d.ts

@@ -0,0 +1,7 @@
+import { ProofData } from '@iden3/js-jwz';
+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/storage/blockchain/onchain-zkp-verifier.d.ts

@@ -1,7 +1,8 @@
 import { Signer } from 'ethers';
 import { EthConnectionConfig } from './state';
 import { IOnChainZKPVerifier } from '../interfaces/onchain-zkp-verifier';
-import { AuthProofResponse, ContractInvokeTransactionData, JsonDocumentObjectValue, ZeroKnowledgeInvokeResponse, ZeroKnowledgeProofResponse } from '../../iden3comm';
+import { AuthMethod, AuthProof, ContractInvokeTransactionData, CrossChainProof, JsonDocumentObjectValue, ZeroKnowledgeInvokeResponse, ZeroKnowledgeProofResponse } from '../../iden3comm';
+import { DID } from '@iden3/js-iden3-core';
 import { GlobalStateUpdate } from '../entities/state';
 /**
  * Supported function signature for SubmitZKPResponse
@@ -22,6 +23,31 @@ export declare enum FunctionSignatures {
 export type OnChainZKPVerifierOptions = {
     didResolverUrl?: string;
 };
+type ProofPreparationResult = {
+    requestId: string | number;
+    proof: ZeroKnowledgeProofResponse;
+    encoded: string;
+    metadata: string;
+};
+export type TxPreparationResultSubmitResponse = {
+    authProof: {
+        raw: AuthProof;
+        encoded: string;
+    };
+    crossChainProof: {
+        raw: CrossChainProof;
+        encoded: string;
+    };
+    proofs: ProofPreparationResult[];
+};
+export declare const toTxDataArgs: (res: TxPreparationResultSubmitResponse) => (string | {
+    requestId: string | number;
+    proof: string;
+    metadata: string;
+}[] | {
+    authMethod: AuthMethod;
+    proof: string;
+})[];
 /**
  * OnChainZKPVerifier is a class that allows to interact with the OnChainZKPVerifier contract
  * and submitZKPResponse.
@@ -60,17 +86,30 @@ export declare class OnChainZKPVerifier implements IOnChainZKPVerifier {
     /**
      * {@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[]>;
+    submitResponse(ethSigner: Signer, txData: ContractInvokeTransactionData, responses: ZeroKnowledgeProofResponse[], authProof: AuthProof): Promise<Map<string, ZeroKnowledgeInvokeResponse>>;
+    static prepareTxArgsSubmit(resolverUrl: string, txData: ContractInvokeTransactionData, responses: ZeroKnowledgeProofResponse[], authProof: AuthProof): Promise<{
+        result: TxPreparationResultSubmitResponse;
+        txDataArgs: JsonDocumentObjectValue[];
+    }>;
+    prepareTxArgsSubmit(txData: ContractInvokeTransactionData, responses: ZeroKnowledgeProofResponse[], authProof: AuthProof): Promise<{
+        result: TxPreparationResultSubmitResponse;
+        txDataArgs: JsonDocumentObjectValue[];
+    }>;
+    private static checkSupportedCircuit;
     private static getCrossChainResolvers;
     static prepareTxArgsSubmitV2(resolverUrl: string, txData: ContractInvokeTransactionData, zkProofResponses: ZeroKnowledgeProofResponse[]): Promise<JsonDocumentObjectValue[]>;
     prepareTxArgsSubmitV2(txData: ContractInvokeTransactionData, zkProofResponses: ZeroKnowledgeProofResponse[]): Promise<JsonDocumentObjectValue[]>;
-    private static _processProof;
+    private static getUpdateResolutions;
     private static packCrossChainProofs;
     static packGlobalStateMsg(msg: GlobalStateUpdate): string;
     private static packIdentityStateMsg;
-    private static packMetadatas;
     private static getOnChainGistRootStatePubSignals;
     private static resolveDidDocumentEip712MessageAndSignature;
 }
+/**
+ * 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 declare const packEthIdentityProof: (did: DID) => string;
+export {};

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

@@ -1,5 +1,6 @@
 import { Signer } from 'ethers';
-import { AuthProofResponse, ContractInvokeTransactionData, JsonDocumentObjectValue, ZeroKnowledgeInvokeResponse, ZeroKnowledgeProofResponse } from '../../iden3comm';
+import { AuthProof, ContractInvokeTransactionData, JsonDocumentObjectValue, ZeroKnowledgeInvokeResponse, ZeroKnowledgeProofResponse } from '../../iden3comm';
+import { TxPreparationResultSubmitResponse } from '../blockchain/onchain-zkp-verifier';
 /**
  * Interface that defines methods for ZKP verifier
  *
@@ -32,9 +33,10 @@ export interface IOnChainZKPVerifier {
      * @param {txData} ContractInvokeTransactionData - transaction data
      * @param {AuthProofResponse} authResponse - authResponse
      * @param {ZeroKnowledgeProofMultiQueryResponse[]} responses - singleResponses and groupedResponses
+     * @param {ZeroKnowledgeProofAuthResponse} [authProof] - authProof in case of authV2
      * @returns {Promise<Map<string, ZeroKnowledgeInvokeResponse>>} - map of transaction hash - ZeroKnowledgeInvokeResponse
      */
-    submitResponse(ethSigner: Signer, txData: ContractInvokeTransactionData, authResponse: AuthProofResponse, responses: ZeroKnowledgeProofResponse[]): Promise<Map<string, ZeroKnowledgeInvokeResponse>>;
+    submitResponse(ethSigner: Signer, txData: ContractInvokeTransactionData, responses: ZeroKnowledgeProofResponse[], authProof: AuthProof): Promise<Map<string, ZeroKnowledgeInvokeResponse>>;
     /**
      * Returns tx args for the ZKP verifier contract submission (singe tx args for each response).
      * @param txData
@@ -50,8 +52,11 @@ export interface IOnChainZKPVerifier {
     /**
      * 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 {authProof} AuthProof - AuthProof
      * @param {ZeroKnowledgeProofMultiQueryResponse[]} responses - singleResponses and groupedResponses
      */
-    prepareTxArgsSubmit(txData: ContractInvokeTransactionData, authResponse: AuthProofResponse, responses: ZeroKnowledgeProofResponse[]): Promise<JsonDocumentObjectValue[]>;
+    prepareTxArgsSubmit(txData: ContractInvokeTransactionData, responses: ZeroKnowledgeProofResponse[], authProof: AuthProof): Promise<{
+        result: TxPreparationResultSubmitResponse;
+        txDataArgs: JsonDocumentObjectValue[];
+    }>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xpolygonid/js-sdk",
-  "version": "1.29.0",
+  "version": "1.29.2",
   "description": "SDK to work with Polygon ID",
   "main": "dist/node/cjs/index.js",
   "module": "dist/node/esm/index.js",

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

@@ -1,74 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.prepareZkpProof = exports.packZkpProof = exports.prepareAuthV2ZeroKnowledgeResponse = exports.calculateRequestIdForCircuit = void 0;
-const ethers_1 = require("ethers");
-const utils_1 = require("../../utils");
-const circuits_1 = require("../../circuits");
-const js_crypto_1 = require("@iden3/js-crypto");
-/**
- * @beta
- * Retrieves the request ID from circuit string.
- * CircuitId.AuthV2 - 940499666
- * @returns The request ID.
- */
-function calculateRequestIdForCircuit(circuitId) {
-    const circuitHash = (0, ethers_1.keccak256)(utils_1.byteEncoder.encode(circuitId));
-    const dataView = new DataView(js_crypto_1.Hex.decodeString(circuitHash.replace('0x', '')).buffer);
-    const id = dataView.getUint32(0);
-    return id;
-}
-exports.calculateRequestIdForCircuit = calculateRequestIdForCircuit;
-/**
- * Prepares the zero-knowledge proof response for the AuthV2 circuit.
- * @beta
- * @param address - The address associated with the request.
- * @param senderDid - The sender's decentralized identifier (DID).
- * @param proofService - The proof service used to generate the proof.
- * @returns A promise that resolves to an array of ZeroKnowledgeProofResponse objects.
- */
-async function prepareAuthV2ZeroKnowledgeResponse(address, senderDid, proofService) {
-    const circuitId = circuits_1.CircuitId.AuthV2;
-    //  this is now hardcoded calculated value for 'authV2' that can be changed in the future.
-    const id = 940499666;
-    if ((0, utils_1.isEthereumIdentity)(senderDid)) {
-        return [
-            {
-                circuitId,
-                id,
-                pub_signals: [],
-                proof: {
-                    pi_a: [],
-                    pi_b: [],
-                    pi_c: [],
-                    protocol: 'groth16'
-                }
-            }
-        ];
-    }
-    const hash = Uint8Array.from([...(0, utils_1.hexToBytes)(address), ...new Uint8Array(12)]).reverse();
-    const { proof, pub_signals } = await proofService.generateAuthV2Proof(hash, senderDid);
-    return [
-        {
-            circuitId,
-            id,
-            pub_signals,
-            proof
-        }
-    ];
-}
-exports.prepareAuthV2ZeroKnowledgeResponse = prepareAuthV2ZeroKnowledgeResponse;
-const packZkpProof = (inputs, a, b, c) => {
-    return new ethers_1.ethers.AbiCoder().encode(['uint256[] inputs', 'uint256[2]', 'uint256[2][2]', 'uint256[2]'], [inputs, a, b, c]);
-};
-exports.packZkpProof = packZkpProof;
-const prepareZkpProof = (proof) => {
-    return {
-        a: proof.pi_a.slice(0, 2),
-        b: [
-            [proof.pi_b[0][1], proof.pi_b[0][0]],
-            [proof.pi_b[1][1], proof.pi_b[1][0]]
-        ],
-        c: proof.pi_c.slice(0, 2)
-    };
-};
-exports.prepareZkpProof = prepareZkpProof;

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

@@ -1,67 +0,0 @@
-import { ethers, keccak256 } from 'ethers';
-import { byteEncoder, hexToBytes, isEthereumIdentity } from '../../utils';
-import { CircuitId } from '../../circuits';
-import { Hex } from '@iden3/js-crypto';
-/**
- * @beta
- * Retrieves the request ID from circuit string.
- * CircuitId.AuthV2 - 940499666
- * @returns The request ID.
- */
-export function calculateRequestIdForCircuit(circuitId) {
-    const circuitHash = keccak256(byteEncoder.encode(circuitId));
-    const dataView = new DataView(Hex.decodeString(circuitHash.replace('0x', '')).buffer);
-    const id = dataView.getUint32(0);
-    return id;
-}
-/**
- * Prepares the zero-knowledge proof response for the AuthV2 circuit.
- * @beta
- * @param address - The address associated with the request.
- * @param senderDid - The sender's decentralized identifier (DID).
- * @param proofService - The proof service used to generate the proof.
- * @returns A promise that resolves to an array of ZeroKnowledgeProofResponse objects.
- */
-export async function prepareAuthV2ZeroKnowledgeResponse(address, senderDid, proofService) {
-    const circuitId = CircuitId.AuthV2;
-    //  this is now hardcoded calculated value for 'authV2' that can be changed in the future.
-    const id = 940499666;
-    if (isEthereumIdentity(senderDid)) {
-        return [
-            {
-                circuitId,
-                id,
-                pub_signals: [],
-                proof: {
-                    pi_a: [],
-                    pi_b: [],
-                    pi_c: [],
-                    protocol: 'groth16'
-                }
-            }
-        ];
-    }
-    const hash = Uint8Array.from([...hexToBytes(address), ...new Uint8Array(12)]).reverse();
-    const { proof, pub_signals } = await proofService.generateAuthV2Proof(hash, senderDid);
-    return [
-        {
-            circuitId,
-            id,
-            pub_signals,
-            proof
-        }
-    ];
-}
-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/types/iden3comm/utils/contract-request.utils.d.ts

@@ -1,27 +0,0 @@
-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.
- * CircuitId.AuthV2 - 940499666
- * @returns The request ID.
- */
-export declare function calculateRequestIdForCircuit(circuitId: CircuitId): number;
-/**
- * Prepares the zero-knowledge proof response for the AuthV2 circuit.
- * @beta
- * @param address - The address associated with the request.
- * @param senderDid - The sender's decentralized identifier (DID).
- * @param proofService - The proof service used to generate the proof.
- * @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[];
-};