@0xpolygonid/js-sdk 1.24.1 → 1.25.1

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

@@ -0,0 +1,54 @@
+import { 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
+        }
+    ];
+}

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

@@ -1,4 +1,5 @@
 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

@@ -213,6 +213,12 @@ export class ProofService {
         authInputs.gistProof = gistProof;
         return authInputs.inputsMarshal();
     }
+    /** {@inheritdoc IProofService.generateAuthV2Proof} */
+    async generateAuthV2Proof(challenge, did) {
+        const authInputs = await this.generateAuthV2Inputs(challenge, did, CircuitId.AuthV2);
+        const zkProof = await this._prover.generate(authInputs, CircuitId.AuthV2);
+        return zkProof;
+    }
     async verifyState(circuitId, pubSignals, opts = {
         acceptedStateTransitionDelay: PROTOCOL_CONSTANTS.DEFAULT_AUTH_VERIFY_DELAY
     }) {

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

@@ -1,10 +1,11 @@
 import { JsonRpcProvider, Contract, ethers } from 'ethers';
 import abi from './abi/ZkpVerifier.json';
 import { TransactionService } from '../../blockchain';
-import { DID } from '@iden3/js-iden3-core';
-import { AtomicQueryMTPV2OnChainPubSignals, AtomicQuerySigV2OnChainPubSignals, AtomicQueryV3OnChainPubSignals, CircuitId } from '../../circuits';
+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';
 const maxGasLimit = 10000000n;
 /**
  * Supported function signature for SubmitZKPResponse
@@ -151,54 +152,60 @@ export class OnChainZKPVerifier {
         const { txnHash } = await transactionService.sendTransactionRequest(ethSigner, request);
         return new Map().set(txnHash, zkProofResponses);
     }
+    static getCrossChainResolvers(source, txDataChainId, type, didResolverUrl) {
+        return [
+            ...new Set(source.map((info) => JSON.stringify({
+                id: info.id.string(),
+                [type]: type === 'gist' ? info.root?.string() : info.state?.string()
+            })))
+        ].reduce((acc, s) => {
+            const info = JSON.parse(s);
+            const id = Id.fromString(info.id);
+            const chainId = chainIDfromDID(DID.parseFromId(id));
+            if (txDataChainId === chainId) {
+                return acc;
+            }
+            const promise = this.resolveDidDocumentEip712MessageAndSignature(DID.parseFromId(Id.fromString(info.id)), didResolverUrl, {
+                [type]: Hash.fromString(info[type])
+            });
+            return [...acc, promise];
+        }, []);
+    }
     static async prepareTxArgsSubmitV2(resolverUrl, txData, zkProofResponses) {
         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 gistUpdateArr = [];
-        const stateUpdateArr = [];
+        const gistUpdates = [];
+        const stateUpdates = [];
         const payload = [];
-        // Resolved gists and states to avoid duplicate requests
-        const gistUpdateResolutionsPending = [];
-        const stateUpdateResolutionsPending = [];
+        const emptyBytes = '0x';
         for (const zkProof of zkProofResponses) {
-            const requestID = zkProof.id;
-            const inputs = zkProof.pub_signals;
-            if (!this._supportedCircuits.includes(zkProof.circuitId)) {
+            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 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 stateInfo = this.getOnChainGistRootStatePubSignals(zkProof.circuitId, zkProof.pub_signals);
-            const gistUpdateResolutions = [];
-            for (const gist of stateInfo.gists) {
-                const gistResolutionPending = gistUpdateResolutionsPending.find((g) => g == JSON.stringify(gist));
-                if (gistResolutionPending) {
-                    continue;
-                }
-                gistUpdateResolutionsPending.push(JSON.stringify(gist));
-                gistUpdateResolutions.push(this.resolveDidDocumentEip712MessageAndSignature(DID.parseFromId(gist.id), resolverUrl, {
-                    gist: gist.root
-                }));
-            }
-            const stateUpdateResolutions = [];
-            for (const state of stateInfo.states) {
-                const stateResolutionPending = stateUpdateResolutionsPending.find((s) => s == JSON.stringify(state));
-                if (stateResolutionPending) {
-                    continue;
-                }
-                stateUpdateResolutionsPending.push(JSON.stringify(state));
-                stateUpdateResolutions.push(this.resolveDidDocumentEip712MessageAndSignature(DID.parseFromId(state.id), resolverUrl, {
-                    state: state.state
-                }));
-            }
+            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) {
-                gistUpdateArr.push(...(await Promise.all(gistUpdateResolutions)));
+                gistUpdates.push(...(await Promise.all(gistUpdateResolutions)));
             }
             if (stateUpdateResolutions.length > 0) {
-                stateUpdateArr.push(...(await Promise.all(stateUpdateResolutions)));
+                stateUpdates.push(...(await Promise.all(stateUpdateResolutions)));
             }
             const metadataArr = [];
             if (zkProof.vp) {
@@ -214,14 +221,16 @@ export class OnChainZKPVerifier {
                     });
                 }
             }
-            const metadata = metadataArr.length ? this.packMetadatas(metadataArr) : '0x';
+            const metadata = metadataArr.length ? this.packMetadatas(metadataArr) : emptyBytes;
             payload.push({
-                requestId: requestID,
+                requestId: requestId,
                 zkProof: zkProofEncoded,
                 data: metadata
             });
         }
-        const crossChainProofs = this.packCrossChainProofs(gistUpdateArr, stateUpdateArr);
+        const crossChainProofs = gistUpdates.length || stateUpdates.length
+            ? this.packCrossChainProofs(gistUpdates, stateUpdates)
+            : emptyBytes;
         return [payload, crossChainProofs];
     }
     async prepareTxArgsSubmitV2(txData, zkProofResponses) {
@@ -279,18 +288,11 @@ export class OnChainZKPVerifier {
         return new ethers.AbiCoder().encode(['tuple(' + 'string key,' + 'bytes value' + ')[]'], [metas]);
     }
     static getOnChainGistRootStatePubSignals(onChainCircuitId, inputs) {
-        let atomicQueryPubSignals;
-        switch (onChainCircuitId) {
-            case CircuitId.AtomicQueryMTPV2OnChain:
-                atomicQueryPubSignals = new AtomicQueryMTPV2OnChainPubSignals();
-                break;
-            case CircuitId.AtomicQuerySigV2OnChain:
-                atomicQueryPubSignals = new AtomicQuerySigV2OnChainPubSignals();
-                break;
-            case CircuitId.AtomicQueryV3OnChain:
-                atomicQueryPubSignals = new AtomicQueryV3OnChainPubSignals();
-                break;
+        const PubSignals = this._supportedCircuitsPubSignalsMap[onChainCircuitId];
+        if (!PubSignals) {
+            throw new Error(`Circuit ${onChainCircuitId} not supported by OnChainZKPVerifier`);
         }
+        const atomicQueryPubSignals = new PubSignals();
         const encodedInputs = byteEncoder.encode(JSON.stringify(inputs));
         atomicQueryPubSignals.pubSignalsUnmarshal(encodedInputs);
         return atomicQueryPubSignals.getStatesInfo();
@@ -332,7 +334,14 @@ export class OnChainZKPVerifier {
  * supported circuits
  */
 OnChainZKPVerifier._supportedCircuits = [
+    CircuitId.AuthV2,
     CircuitId.AtomicQueryMTPV2OnChain,
     CircuitId.AtomicQuerySigV2OnChain,
     CircuitId.AtomicQueryV3OnChain
 ];
+OnChainZKPVerifier._supportedCircuitsPubSignalsMap = {
+    [CircuitId.AtomicQueryMTPV2OnChain]: AtomicQueryMTPV2OnChainPubSignals,
+    [CircuitId.AtomicQuerySigV2OnChain]: AtomicQuerySigV2OnChainPubSignals,
+    [CircuitId.AtomicQueryV3OnChain]: AtomicQueryV3OnChainPubSignals,
+    [CircuitId.AuthV2]: AuthV2PubSignals
+};

package/dist/node/esm/utils/did-helper.js

@@ -97,9 +97,14 @@ export const resolveDidDocument = async (did, resolverUrl, opts) => {
     if (opts?.gist) {
         url += `${url.includes('?') ? '&' : '?'}gist=${opts.gist.hex()}`;
     }
-    const resp = await fetch(url);
-    const data = await resp.json();
-    return data;
+    try {
+        const resp = await fetch(url);
+        const data = await resp.json();
+        return data;
+    }
+    catch (e) {
+        throw new Error(`Failed to resolve DID document for ${did} ${e}`);
+    }
 };
 export const buildDIDFromEthPubKey = (didType, pubKeyEth) => {
     // Use Keccak-256 hash function to get public key hash

package/dist/node/esm/verifiable/constants.js

@@ -146,6 +146,7 @@ export var SupportedPaymentProofType;
 /**
  * Media types for Payment supported currencies
  * @beta
+ * @deprecated
  * @enum {string}
  */
 export var SupportedCurrencies;
@@ -155,8 +156,6 @@ export var SupportedCurrencies;
     SupportedCurrencies["ETH_GWEI"] = "ETHGWEI";
     SupportedCurrencies["MATIC"] = "MATIC";
     SupportedCurrencies["POL"] = "POL";
-    SupportedCurrencies["USDT"] = "USDT";
-    SupportedCurrencies["USDC"] = "USDC";
 })(SupportedCurrencies || (SupportedCurrencies = {}));
 /**
  * Supported features for payment-request

package/dist/types/circuits/auth-v2.d.ts

@@ -1,7 +1,7 @@
 import { Hash, Proof } from '@iden3/js-merkletree';
 import { Claim, Id } from '@iden3/js-iden3-core';
 import { GISTProof, TreeState } from './models';
-import { BaseConfig } from './common';
+import { BaseConfig, IStateInfoPubSignals, StatesInfo } from './common';
 import { Signature } from '@iden3/js-crypto';
 /**
  * Auth v2 circuit representation
@@ -30,7 +30,7 @@ export declare class AuthV2Inputs extends BaseConfig {
  * @public
  * @class AuthV2PubSignals
  */
-export declare class AuthV2PubSignals {
+export declare class AuthV2PubSignals implements IStateInfoPubSignals {
     userID: Id;
     challenge: bigint;
     GISTRoot: Hash;
@@ -41,4 +41,5 @@ export declare class AuthV2PubSignals {
      * @returns AuthV2PubSignals
      */
     pubSignalsUnmarshal(data: Uint8Array): AuthV2PubSignals;
+    getStatesInfo(): StatesInfo;
 }

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

@@ -2,7 +2,6 @@ import { BasicMessage, IPackageManager, PackerParams } from '../types';
 import { DID } from '@iden3/js-iden3-core';
 import { AbstractMessageHandler, BasicHandlerOptions, IProtocolMessageHandler } from './message-handler';
 import { Iden3PaymentRailsERC20RequestV1, Iden3PaymentRailsRequestV1, MultiChainPaymentConfig, PaymentMessage, PaymentRequestInfo, PaymentRequestMessage, PaymentRequestTypeUnion, PaymentTypeUnion } from '../types/protocol/payment';
-import { PaymentFeatures, PaymentRequestDataType, SupportedCurrencies } from '../../verifiable';
 import { Signer } from 'ethers';
 import { Resolvable } from 'did-resolver';
 /** @beta PaymentRequestCreationOptions represents payment-request creation options */
@@ -24,7 +23,6 @@ export type PaymentCreationOptions = {
  */
 export declare function createPaymentRequest(sender: DID, receiver: DID, agent: string, payments: PaymentRequestInfo[], opts?: PaymentRequestCreationOptions): PaymentRequestMessage;
 export declare function verifyEIP712TypedData(data: Iden3PaymentRailsRequestV1 | Iden3PaymentRailsERC20RequestV1, resolver: Resolvable): Promise<string>;
-export declare function convertPaymentAmount(amount: string, currency: SupportedCurrencies): Promise<bigint>;
 /**
  * @beta
  * PaymentRailsInfo represents payment info for payment rails
@@ -35,20 +33,18 @@ export type PaymentRailsInfo = {
         context: string;
     }[];
     description?: string;
-    chains: PaymentRailsChainInfo[];
+    options: PaymentRailsOptionInfo[];
 };
 /**
  * @beta
- * PaymentRailsChainInfo represents chain info for payment rails
+ * PaymentRailsOptionInfo represents option info for payment rails
  */
-export type PaymentRailsChainInfo = {
+export type PaymentRailsOptionInfo = {
+    optionId: string;
+    chainId: string;
     nonce: bigint;
     amount: string;
-    currency: SupportedCurrencies | string;
-    chainId: string;
     expirationDate?: Date;
-    features?: PaymentFeatures[];
-    type: PaymentRequestDataType.Iden3PaymentRailsRequestV1 | PaymentRequestDataType.Iden3PaymentRailsERC20RequestV1;
 };
 /**
  * @beta

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

@@ -36,7 +36,6 @@ export type Iden3PaymentRailsRequestV1 = {
     '@context': string | (string | object)[];
     recipient: string;
     amount: string;
-    currency: SupportedCurrencies | string;
     expirationDate: string;
     nonce: string;
     metadata: string;
@@ -106,11 +105,13 @@ export type Iden3PaymentRailsERC20V1 = {
 /** @beta MultiChainPaymentConfig is struct that represents payments contracts information for different chains */
 export type MultiChainPaymentConfig = {
     chainId: string;
-    paymentContract: string;
+    paymentRails: string;
     recipient: string;
-    erc20TokenAddressArr: {
-        symbol: string;
-        address: string;
+    options: {
+        id: string;
+        type: PaymentRequestDataType.Iden3PaymentRailsRequestV1 | PaymentRequestDataType.Iden3PaymentRailsERC20RequestV1;
+        contractAddress?: string;
+        features?: PaymentFeatures[];
     }[];
 };
 /**

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

@@ -0,0 +1,20 @@
+import { CircuitId } from '../../circuits';
+import { DID } from '@iden3/js-iden3-core';
+import { IProofService } from '../../proof';
+import { ZeroKnowledgeProofResponse } from '../types';
+/**
+ * @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[]>;

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

@@ -1,4 +1,5 @@
 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

@@ -73,6 +73,14 @@ export interface IProofService {
      * @returns `Promise<Uint8Array>`
      */
     generateAuthV2Inputs(hash: Uint8Array, did: DID, circuitId: CircuitId): Promise<Uint8Array>;
+    /**
+     * generates auth inputs
+     *
+     * @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>;
     /**
      * state verification function
      *
@@ -138,6 +146,8 @@ export declare class ProofService implements IProofService {
     private loadLdContext;
     /** {@inheritdoc IProofService.generateAuthV2Inputs} */
     generateAuthV2Inputs(hash: Uint8Array, did: DID, circuitId: CircuitId): Promise<Uint8Array>;
+    /** {@inheritdoc IProofService.generateAuthV2Proof} */
+    generateAuthV2Proof(challenge: Uint8Array, did: DID): Promise<ZKProof>;
     verifyState(circuitId: string, pubSignals: string[], opts?: StateVerificationOpts): Promise<boolean>;
     findCredentialByProofQuery(did: DID, query: ProofQuery): Promise<{
         cred: W3CCredential;

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

@@ -35,6 +35,7 @@ export declare class OnChainZKPVerifier implements IOnChainZKPVerifier {
      * supported circuits
      */
     private static readonly _supportedCircuits;
+    private static readonly _supportedCircuitsPubSignalsMap;
     /**
      *
      * Creates an instance of OnChainZKPVerifier.
@@ -55,6 +56,7 @@ export declare class OnChainZKPVerifier implements IOnChainZKPVerifier {
      * {@inheritDoc IOnChainZKPVerifier.submitZKPResponseV2}
      */
     submitZKPResponseV2(ethSigner: Signer, txData: ContractInvokeTransactionData, zkProofResponses: ZeroKnowledgeProofResponse[]): Promise<Map<string, ZeroKnowledgeProofResponse[]>>;
+    private static getCrossChainResolvers;
     static prepareTxArgsSubmitV2(resolverUrl: string, txData: ContractInvokeTransactionData, zkProofResponses: ZeroKnowledgeProofResponse[]): Promise<JsonDocumentObjectValue[]>;
     prepareTxArgsSubmitV2(txData: ContractInvokeTransactionData, zkProofResponses: ZeroKnowledgeProofResponse[]): Promise<JsonDocumentObjectValue[]>;
     private static packZkpProof;

package/dist/types/verifiable/constants.d.ts

@@ -117,6 +117,7 @@ export declare enum SupportedPaymentProofType {
 /**
  * Media types for Payment supported currencies
  * @beta
+ * @deprecated
  * @enum {string}
  */
 export declare enum SupportedCurrencies {
@@ -124,9 +125,7 @@ export declare enum SupportedCurrencies {
     ETH_WEI = "ETHWEI",
     ETH_GWEI = "ETHGWEI",
     MATIC = "MATIC",
-    POL = "POL",
-    USDT = "USDT",
-    USDC = "USDC"
+    POL = "POL"
 }
 /**
  * Supported features for payment-request

package/package.json

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