@0xpolygonid/js-sdk 1.33.1 → 1.34.0

package/src/iden3comm/types/protocol/payment.ts

@@ -31,6 +31,8 @@ export type PaymentRequestInfo = {
         | Iden3PaymentRequestCryptoV1
         | Iden3PaymentRailsRequestV1
         | Iden3PaymentRailsERC20RequestV1
+        | Iden3PaymentRailsSolanaRequestV1
+        | Iden3PaymentRailsSolanaSPLRequestV1
       )[];
   description?: string;
 };
@@ -47,6 +49,7 @@ export type Iden3PaymentRequestCryptoV1 = {
   expiration?: string;
 };
 
+/** @beta Iden3PaymentRailsRequestV1 is struct the represents EVM native payment rails request */
 export type Iden3PaymentRailsRequestV1 = {
   type: PaymentRequestDataType.Iden3PaymentRailsRequestV1;
   '@context': string | (string | object)[];
@@ -58,12 +61,32 @@ export type Iden3PaymentRailsRequestV1 = {
   proof: EthereumEip712Signature2021 | EthereumEip712Signature2021[];
 };
 
+/** @beta Iden3PaymentRailsERC20RequestV1 is struct the represents EVM ERC 20 payment rails request */
 export type Iden3PaymentRailsERC20RequestV1 = Omit<Required<Iden3PaymentRailsRequestV1>, 'type'> & {
   tokenAddress: string;
   features?: PaymentFeatures[];
   type: PaymentRequestDataType.Iden3PaymentRailsERC20RequestV1;
 };
 
+/** @beta Iden3PaymentRailsSolanaRequestV1 is struct the represents Solana native payment rails request */
+export type Iden3PaymentRailsSolanaRequestV1 = Omit<
+  Required<Iden3PaymentRailsRequestV1>,
+  'type' | 'proof'
+> & {
+  type: PaymentRequestDataType.Iden3PaymentRailsSolanaRequestV1;
+  proof: Iden3SolanaEd25519SignatureV1 | Iden3SolanaEd25519SignatureV1[];
+};
+
+/** @beta Iden3PaymentRailsSolanaSPLRequestV1 is struct the represents Solana SPL payment rails request */
+export type Iden3PaymentRailsSolanaSPLRequestV1 = Omit<
+  Required<Iden3PaymentRailsERC20RequestV1>,
+  'type' | 'proof'
+> & {
+  type: PaymentRequestDataType.Iden3PaymentRailsSolanaSPLRequestV1;
+  proof: Iden3SolanaEd25519SignatureV1 | Iden3SolanaEd25519SignatureV1[];
+};
+
+/** @beta EthereumEip712Signature2021 is struct the represents EIP-712 signature for Ethereum */
 export type EthereumEip712Signature2021 = {
   type: SupportedPaymentProofType.EthereumEip712Signature2021;
   proofPurpose: string;
@@ -82,6 +105,20 @@ export type EthereumEip712Signature2021 = {
   };
 };
 
+/** @beta Iden3SolanaEd25519SignatureV1 is struct the represents Ed25519 signature for Solana Payment Instruction */
+export type Iden3SolanaEd25519SignatureV1 = {
+  type: SupportedPaymentProofType.SolanaEd25519Signature2025;
+  proofPurpose: string;
+  proofValue: string;
+  created: string;
+  verificationMethod: string;
+  domain: {
+    version: 'SolanaEd25519NativeV1' | 'SolanaEd25519SPLV1';
+    chainId: string;
+    verifyingContract: string;
+  };
+};
+
 /** @beta  PaymentMessage is struct the represents payment message */
 export type PaymentMessage = BasicMessage & {
   body: PaymentMessageBody;
@@ -128,19 +165,47 @@ export type Iden3PaymentRailsERC20V1 = {
   };
 };
 
+/** @beta Iden3PaymentRailsSolanaV1 is struct the represents payment info for Iden3PaymentRailsSolanaV1 */
+export type Iden3PaymentRailsSolanaV1 = {
+  nonce: string;
+  type: 'Iden3PaymentRailsSolanaV1';
+  '@context': string | (string | object)[];
+  paymentData: {
+    txId: string;
+    chainId: string;
+  };
+};
+
+/** @beta Iden3PaymentRailsSolanaSPLV1 is struct the represents payment info for Iden3PaymentRailsSolanaSPLV1 */
+export type Iden3PaymentRailsSolanaSPLV1 = {
+  nonce: string;
+  type: 'Iden3PaymentRailsSolanaSPLV1';
+  '@context': string | (string | object)[];
+  paymentData: {
+    txId: string;
+    chainId: string;
+    tokenAddress: string;
+  };
+};
+
 /** @beta MultiChainPaymentConfig is struct that represents payments contracts information for different chains */
 export type MultiChainPaymentConfig = {
   chainId: string;
   paymentRails: string;
   recipient: string;
-  options: {
-    id: string;
-    type:
-      | PaymentRequestDataType.Iden3PaymentRailsRequestV1
-      | PaymentRequestDataType.Iden3PaymentRailsERC20RequestV1;
-    contractAddress?: string;
-    features?: PaymentFeatures[];
-  }[];
+  options: MultiChainPaymentConfigOption[];
+};
+
+/** @beta MultiChainPaymentConfigOption is struct that represents payment options for different chains */
+export type MultiChainPaymentConfigOption = {
+  id: string;
+  type:
+    | PaymentRequestDataType.Iden3PaymentRailsRequestV1
+    | PaymentRequestDataType.Iden3PaymentRailsERC20RequestV1
+    | PaymentRequestDataType.Iden3PaymentRailsSolanaRequestV1
+    | PaymentRequestDataType.Iden3PaymentRailsSolanaSPLRequestV1;
+  contractAddress?: string;
+  features?: PaymentFeatures[];
 };
 
 /**
@@ -150,7 +215,9 @@ export type MultiChainPaymentConfig = {
 export type PaymentRequestTypeUnion =
   | Iden3PaymentRequestCryptoV1
   | Iden3PaymentRailsRequestV1
-  | Iden3PaymentRailsERC20RequestV1;
+  | Iden3PaymentRailsERC20RequestV1
+  | Iden3PaymentRailsSolanaRequestV1
+  | Iden3PaymentRailsSolanaSPLRequestV1;
 
 /**
  * @beta
@@ -159,4 +226,6 @@ export type PaymentRequestTypeUnion =
 export type PaymentTypeUnion =
   | Iden3PaymentCryptoV1
   | Iden3PaymentRailsV1
-  | Iden3PaymentRailsERC20V1;
+  | Iden3PaymentRailsERC20V1
+  | Iden3PaymentRailsSolanaV1
+  | Iden3PaymentRailsSolanaSPLV1;

package/src/iden3comm/utils/accept-profile.ts

@@ -1,3 +1,4 @@
+import { ProvingMethodAlg } from '@iden3/js-jwz';
 import {
   MediaType,
   ProtocolVersion,
@@ -27,6 +28,29 @@ function isAcceptJwzAlgorithms(value: string): boolean {
   return Object.values(AcceptJwzAlgorithms).includes(value as AcceptJwzAlgorithms);
 }
 
+export const buildAcceptFromProvingMethodAlg = (provingMethodAlg: ProvingMethodAlg): string => {
+  const [alg, circuitId] = provingMethodAlg.toString().split(':');
+  return `${ProtocolVersion.V1};env=${MediaType.ZKPMessage};circuitId=${circuitId};alg=${alg}`;
+};
+
+export const acceptHasProvingMethodAlg = (
+  accept: string[],
+  provingMethodAlg: ProvingMethodAlg
+): boolean => {
+  const [provingAlg, provingCircuitId] = provingMethodAlg.toString().split(':');
+  for (const profile of accept) {
+    const { env, circuits, alg } = parseAcceptProfile(profile);
+    if (
+      env === MediaType.ZKPMessage &&
+      circuits?.includes(provingCircuitId as AcceptAuthCircuits) &&
+      (!alg || (alg as unknown as AcceptJwzAlgorithms)?.includes(provingAlg as AcceptJwzAlgorithms))
+    ) {
+      return true;
+    }
+  }
+  return false;
+};
+
 export const buildAccept = (profiles: AcceptProfile[]): string[] => {
   const result = [];
   for (const profile of profiles) {

package/src/proof/proof-service.ts

@@ -7,6 +7,8 @@ import {
 import {
   AuthV2Inputs,
   AuthV2PubSignals,
+  AuthV3Inputs,
+  AuthV3PubSignals,
   CircuitId,
   Operators,
   Query,
@@ -125,6 +127,7 @@ export interface IProofService {
   ): Promise<ZeroKnowledgeProofResponse>;
 
   /**
+   * @deprecated, use generateAuthInputs with CircuitId.AuthV2 instead
    * generates auth inputs
    *
    * @param {Uint8Array} hash - challenge that will be signed
@@ -135,6 +138,17 @@ export interface IProofService {
   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
+   * @param {CircuitId} circuitId - circuit id for authentication
+   * @returns `Promise<Uint8Array>`
+   */
+  generateAuthInputs(hash: Uint8Array, did: DID, circuitId: CircuitId): Promise<Uint8Array>;
+
+  /**
+   * @deprecated, use generateAuthProof with CircuitId.AuthV2 instead
    * generates auth v2 proof from given identity
    *
    * @param {Uint8Array} hash - challenge that will be signed
@@ -397,30 +411,30 @@ export class ProofService implements IProofService {
     identifier: DID,
     opts?: AuthProofGenerationOptions
   ): Promise<ZeroKnowledgeProofAuthResponse> {
+    if (
+      circuitId !== CircuitId.AuthV2 &&
+      circuitId !== CircuitId.AuthV3 &&
+      circuitId !== CircuitId.AuthV3_8_32
+    ) {
+      throw new Error('CircuitId is not supported');
+    }
     if (!opts) {
       opts = {
         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`);
-    }
+    const challenge = opts.challenge
+      ? BytesHelper.intToBytes(opts.challenge).reverse()
+      : new Uint8Array(32);
+    const authInputs = await this.generateAuthInputs(challenge, identifier, circuitId);
+
+    const zkProof = await this._prover.generate(authInputs, circuitId);
+    return {
+      circuitId: circuitId,
+      proof: zkProof.proof,
+      pub_signals: zkProof.pub_signals
+    };
   }
 
   /** {@inheritdoc IProofService.transitState} */
@@ -550,9 +564,50 @@ export class ProofService implements IProofService {
     return authInputs.inputsMarshal();
   }
 
+  /** {@inheritdoc IProofService.generateAuthInputs} */
+  async generateAuthInputs(hash: Uint8Array, did: DID, circuitId: CircuitId): Promise<Uint8Array> {
+    if (
+      circuitId !== CircuitId.AuthV2 &&
+      circuitId !== CircuitId.AuthV3 &&
+      circuitId !== CircuitId.AuthV3_8_32
+    ) {
+      throw new Error('CircuitId is not supported');
+    }
+
+    const { nonce: authProfileNonce, genesisDID } =
+      await this._identityWallet.getGenesisDIDMetadata(did);
+
+    const challenge = BytesHelper.bytesToInt(hash.reverse());
+
+    const authPrepared = await this._inputsGenerator.prepareAuthBJJCredential(genesisDID);
+
+    const signature = await this._identityWallet.signChallenge(challenge, authPrepared.credential);
+    const id = DID.idFromDID(genesisDID);
+    const stateProof = await this._stateStorage.getGISTProof(id.bigInt());
+
+    const gistProof = toGISTProof(stateProof);
+
+    const authInputs = new AuthV3Inputs(); // works for both v3 and v2
+    if (circuitId === CircuitId.AuthV3_8_32) {
+      authInputs.mtLevel = 8;
+      authInputs.mtLevelOnChain = 32;
+    }
+
+    authInputs.genesisID = id;
+    authInputs.profileNonce = BigInt(authProfileNonce);
+    authInputs.authClaim = authPrepared.coreClaim;
+    authInputs.authClaimIncMtp = authPrepared.incProof.proof;
+    authInputs.authClaimNonRevMtp = authPrepared.nonRevProof.proof;
+    authInputs.treeState = authPrepared.incProof.treeState;
+    authInputs.signature = signature;
+    authInputs.challenge = challenge;
+    authInputs.gistProof = gistProof;
+    return authInputs.inputsMarshal();
+  }
+
   /** {@inheritdoc IProofService.generateAuthV2Proof} */
   async generateAuthV2Proof(challenge: Uint8Array, did: DID): Promise<ZKProof> {
-    const authInputs = await this.generateAuthV2Inputs(challenge, did, CircuitId.AuthV2);
+    const authInputs = await this.generateAuthInputs(challenge, did, CircuitId.AuthV2);
 
     const zkProof = await this._prover.generate(authInputs, CircuitId.AuthV2);
     return zkProof;
@@ -565,15 +620,28 @@ export class ProofService implements IProofService {
       acceptedStateTransitionDelay: PROTOCOL_CONSTANTS.DEFAULT_AUTH_VERIFY_DELAY
     }
   ): Promise<boolean> {
-    if (circuitId !== CircuitId.AuthV2) {
+    if (
+      circuitId !== CircuitId.AuthV2 &&
+      circuitId !== CircuitId.AuthV3 &&
+      circuitId !== CircuitId.AuthV3_8_32
+    ) {
       throw new Error(`CircuitId is not supported ${circuitId}`);
     }
 
-    const authV2PubSignals = new AuthV2PubSignals().pubSignalsUnmarshal(
-      byteEncoder.encode(JSON.stringify(pubSignals))
-    );
-    const gistRoot = authV2PubSignals.GISTRoot.bigInt();
-    const userId = authV2PubSignals.userID.bigInt();
+    let gistRoot, userId;
+    if (circuitId === CircuitId.AuthV2) {
+      const authV2PubSignals = new AuthV2PubSignals().pubSignalsUnmarshal(
+        byteEncoder.encode(JSON.stringify(pubSignals))
+      );
+      gistRoot = authV2PubSignals.GISTRoot.bigInt();
+      userId = authV2PubSignals.userID.bigInt();
+    } else {
+      const authV3PubSignals = new AuthV3PubSignals().pubSignalsUnmarshal(
+        byteEncoder.encode(JSON.stringify(pubSignals))
+      );
+      gistRoot = authV3PubSignals.GISTRoot.bigInt();
+      userId = authV3PubSignals.userID.bigInt();
+    }
     const globalStateInfo = await this._stateStorage.getGISTRootInfo(gistRoot, userId);
 
     if (globalStateInfo.root !== gistRoot) {

package/src/proof/provers/inputs-generator.ts

@@ -102,6 +102,8 @@ export const circuitValidator: {
   [CircuitId.AtomicQueryV3]: { maxQueriesCount: 1, supportedOperations: allOperations },
   [CircuitId.AtomicQueryV3OnChain]: { maxQueriesCount: 1, supportedOperations: allOperations },
   [CircuitId.AuthV2]: { maxQueriesCount: 0, supportedOperations: [] },
+  [CircuitId.AuthV3]: { maxQueriesCount: 0, supportedOperations: [] },
+  [CircuitId.AuthV3_8_32]: { maxQueriesCount: 0, supportedOperations: [] },
   [CircuitId.StateTransition]: { maxQueriesCount: 0, supportedOperations: [] },
   [CircuitId.LinkedMultiQuery10]: { maxQueriesCount: 10, supportedOperations: allOperations }
 };

package/src/proof/provers/prover.ts

@@ -77,7 +77,7 @@ export class NativeProver implements IZKProver {
       throw new Error(`wasm file doesn't exist for circuit ${circuitId}`);
     }
 
-    const witnessCalculator = await witnessBuilder(circuitData.wasm);
+    const witnessCalculator = await witnessBuilder(circuitData.wasm.buffer as ArrayBuffer);
 
     const parsedData = JSON.parse(byteDecoder.decode(inputs));
 

package/src/utils/index.ts

@@ -3,3 +3,5 @@ export * from './object';
 export * from './did-helper';
 export * from './message-bus';
 export * from './compare-func';
+export * from './payments/solana';
+export * from './payments/evm';

package/src/utils/payments/evm.ts

@@ -0,0 +1,152 @@
+import { Signer, ethers } from 'ethers';
+import {
+  EthereumEip712Signature2021,
+  Iden3PaymentRailsERC20RequestV1,
+  Iden3PaymentRailsRequestV1,
+  MultiChainPaymentConfigOption
+} from '../../iden3comm';
+import { PaymentRequestDataType, SupportedPaymentProofType } from '../../verifiable';
+import { getUnixTimestamp } from '@iden3/js-iden3-core';
+import { Resolvable } from 'did-resolver';
+
+/**
+ * @beta
+ * buildEvmPayment creates an EVM-based payment request and signs it using EIP-712.
+ * @param {Signer} signer - EIP-712 compatible signer
+ * @param {MultiChainPaymentConfigOption} option - payment option configuration
+ * @param {string} chainId - EVM chain ID
+ * @param {string} paymentRails - payment rails contract address
+ * @param {string} recipient - recipient address
+ * @param {bigint} amount - payment amount in smallest units
+ * @param {Date} expirationDateRequired - expiration date
+ * @param {bigint} nonce - unique nonce for the payment
+ * @returns {Promise<Iden3PaymentRailsRequestV1 | Iden3PaymentRailsERC20RequestV1>} payment request object
+ */
+export const buildEvmPayment = async (
+  signer: Signer,
+  option: MultiChainPaymentConfigOption,
+  chainId: string,
+  paymentRails: string,
+  recipient: string,
+  amount: bigint,
+  expirationDateRequired: Date,
+  nonce: bigint
+): Promise<Iden3PaymentRailsRequestV1 | Iden3PaymentRailsERC20RequestV1> => {
+  const typeUrl = `https://schema.iden3.io/core/json/${option.type}.json`;
+  const typesFetchResult = await fetch(typeUrl);
+  const types = await typesFetchResult.json();
+  delete types.EIP712Domain;
+  const paymentData =
+    option.type === PaymentRequestDataType.Iden3PaymentRailsRequestV1
+      ? {
+          recipient,
+          amount: amount,
+          expirationDate: getUnixTimestamp(expirationDateRequired),
+          nonce,
+          metadata: '0x'
+        }
+      : {
+          tokenAddress: option.contractAddress,
+          recipient,
+          amount: amount,
+          expirationDate: getUnixTimestamp(expirationDateRequired),
+          nonce,
+          metadata: '0x'
+        };
+
+  const domain = {
+    name: 'MCPayment',
+    version: '1.0.0',
+    chainId,
+    verifyingContract: paymentRails
+  };
+
+  const signature = await signer.signTypedData(domain, types, paymentData);
+
+  const proof: EthereumEip712Signature2021[] = [
+    {
+      type: SupportedPaymentProofType.EthereumEip712Signature2021,
+      proofPurpose: 'assertionMethod',
+      proofValue: signature,
+      verificationMethod: `did:pkh:eip155:${chainId}:${await signer.getAddress()}`,
+      created: new Date().toISOString(),
+      eip712: {
+        types: typeUrl,
+        primaryType: 'Iden3PaymentRailsRequestV1',
+        domain
+      }
+    }
+  ];
+  const d: Iden3PaymentRailsRequestV1 = {
+    type: PaymentRequestDataType.Iden3PaymentRailsRequestV1,
+    '@context': [
+      `https://schema.iden3.io/core/jsonld/payment.jsonld#${option.type}`,
+      'https://w3id.org/security/suites/eip712sig-2021/v1'
+    ],
+    recipient,
+    amount: amount.toString(),
+    expirationDate: expirationDateRequired.toISOString(),
+    nonce: nonce.toString(),
+    metadata: '0x',
+    proof
+  };
+
+  if (option.type === PaymentRequestDataType.Iden3PaymentRailsRequestV1) {
+    return d;
+  }
+  return {
+    ...d,
+    type: option.type,
+    tokenAddress: option.contractAddress || '',
+    features: option.features || []
+  } as Iden3PaymentRailsERC20RequestV1;
+};
+
+export async function verifyEIP712TypedData(
+  data: Iden3PaymentRailsRequestV1 | Iden3PaymentRailsERC20RequestV1,
+  resolver: Resolvable
+): Promise<string> {
+  const paymentData =
+    data.type === PaymentRequestDataType.Iden3PaymentRailsRequestV1
+      ? {
+          recipient: data.recipient,
+          amount: data.amount,
+          expirationDate: getUnixTimestamp(new Date(data.expirationDate)),
+          nonce: data.nonce,
+          metadata: '0x'
+        }
+      : {
+          tokenAddress: data.tokenAddress,
+          recipient: data.recipient,
+          amount: data.amount,
+          expirationDate: getUnixTimestamp(new Date(data.expirationDate)),
+          nonce: data.nonce,
+          metadata: '0x'
+        };
+  const proof = Array.isArray(data.proof) ? data.proof[0] : data.proof;
+  const typesFetchResult = await fetch(proof.eip712.types);
+  const types = await typesFetchResult.json();
+  delete types.EIP712Domain;
+  const recovered = ethers.verifyTypedData(
+    proof.eip712.domain,
+    types,
+    paymentData,
+    proof.proofValue
+  );
+
+  const { didDocument } = await resolver.resolve(proof.verificationMethod);
+  if (didDocument?.verificationMethod) {
+    for (const verificationMethod of didDocument.verificationMethod) {
+      if (
+        verificationMethod.blockchainAccountId?.split(':').slice(-1)[0].toLowerCase() ===
+        recovered.toLowerCase()
+      ) {
+        return recovered;
+      }
+    }
+  } else {
+    throw new Error('failed request. issuer DIDDocument does not contain any verificationMethods');
+  }
+
+  throw new Error(`failed request. no matching verificationMethod`);
+}