@0xpolygonid/js-sdk 1.33.1 → 1.34.0

package/src/iden3comm/handlers/payment.ts

@@ -1,22 +1,32 @@
 import { PROTOCOL_MESSAGE_TYPE } from '../constants';
 import { MediaType } from '../constants';
-import { BasicMessage, IPackageManager, PackerParams } from '../types';
+import {
+  BasicMessage,
+  IPackageManager,
+  JWSPackerParams,
+  PackerParams,
+  ZKPPackerParams
+} from '../types';
 
 import { DID, getUnixTimestamp } from '@iden3/js-iden3-core';
 import * as uuid from 'uuid';
-import { proving } from '@iden3/js-jwz';
-import { byteEncoder } from '../../utils';
+import { buildSolanaPayment, byteEncoder, verifyIden3SolanaPaymentRequest } from '../../utils';
 import {
   AbstractMessageHandler,
   BasicHandlerOptions,
-  IProtocolMessageHandler
+  IProtocolMessageHandler,
+  defaultProvingMethodAlg,
+  getProvingMethodAlgFromJWZ
 } from './message-handler';
 import {
-  EthereumEip712Signature2021,
   Iden3PaymentCryptoV1,
   Iden3PaymentRailsERC20RequestV1,
   Iden3PaymentRailsERC20V1,
   Iden3PaymentRailsRequestV1,
+  Iden3PaymentRailsSolanaRequestV1,
+  Iden3PaymentRailsSolanaSPLRequestV1,
+  Iden3PaymentRailsSolanaSPLV1,
+  Iden3PaymentRailsSolanaV1,
   Iden3PaymentRailsV1,
   Iden3PaymentRequestCryptoV1,
   MultiChainPaymentConfig,
@@ -26,15 +36,12 @@ import {
   PaymentRequestTypeUnion,
   PaymentTypeUnion
 } from '../types/protocol/payment';
-import {
-  PaymentFeatures,
-  PaymentRequestDataType,
-  PaymentType,
-  SupportedPaymentProofType
-} from '../../verifiable';
-import { Signer, ethers } from 'ethers';
+import { PaymentFeatures, PaymentRequestDataType, PaymentType } from '../../verifiable';
+import { Signer } from 'ethers';
 import { Resolvable } from 'did-resolver';
 import { verifyExpiresTime } from './common';
+import { Keypair } from '@solana/web3.js';
+import { buildEvmPayment, verifyEIP712TypedData } from '../../utils/payments/evm';
 
 /** @beta PaymentRequestCreationOptions represents payment-request creation options */
 export type PaymentRequestCreationOptions = {
@@ -46,6 +53,12 @@ export type PaymentCreationOptions = {
   expires_time?: Date;
 };
 
+/** @beta CreatePaymentRailsV1Options holds options for PaymentRailsV1 creation */
+export type CreatePaymentRailsV1Options = {
+  ethSigner?: Signer;
+  solSigner?: Keypair;
+};
+
 /**
  * @beta
  * createPaymentRequest is a function to create protocol payment-request message
@@ -80,55 +93,6 @@ export function createPaymentRequest(
   return request;
 }
 
-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`);
-}
-
 /**
  * @beta
  * PaymentRailsInfo represents payment info for payment rails
@@ -227,16 +191,18 @@ export interface IPaymentHandler {
    * @param {DID} sender - sender did
    * @param {DID} receiver - receiver did
    * @param {string} agent - agent URL
-   * @param {Signer} signer - receiver did
+   * @param {Signer} signer - ETH signer
    * @param payments - payment options
+   * @param {CreatePaymentRailsV1Options} createOptions - options for payment rails creation
    * @returns {Promise<PaymentRequestMessage>}
    */
   createPaymentRailsV1(
     sender: DID,
     receiver: DID,
     agent: string,
-    signer: Signer,
-    payments: PaymentRailsInfo[]
+    signer: Signer, // the same as createOptions.ethSigner (for compatibility)
+    payments: PaymentRailsInfo[],
+    createOptions?: CreatePaymentRailsV1Options
   ): Promise<PaymentRequestMessage>;
 }
 
@@ -248,6 +214,8 @@ export type PaymentRequestMessageHandlerOptions = BasicHandlerOptions & {
   */
   nonce: string;
   erc20TokenApproveHandler?: (data: Iden3PaymentRailsERC20RequestV1) => Promise<string>;
+  packerOptions?: JWSPackerParams | ZKPPackerParams;
+  mediaType?: MediaType;
 };
 
 /** @beta PaymentHandlerOptions represents payment handler options */
@@ -380,15 +348,36 @@ export class PaymentHandler
             )
           );
           break;
+        case PaymentRequestDataType.Iden3PaymentRailsSolanaRequestV1:
+          payments.push(
+            await this.handleIden3PaymentRailsSolanaRequestV1(selectedPayment, ctx.paymentHandler)
+          );
+          break;
+        case PaymentRequestDataType.Iden3PaymentRailsSolanaSPLRequestV1:
+          payments.push(
+            await this.handleIden3PaymentRailsSolanaSPLRequestV1(
+              {
+                ...selectedPayment,
+                type: PaymentRequestDataType.Iden3PaymentRailsSolanaSPLRequestV1
+              },
+              ctx.paymentHandler
+            )
+          );
+          break;
       }
     }
 
     const paymentMessage = createPayment(senderDID, receiverDID, payments);
-    const response = await this.packMessage(paymentMessage, senderDID);
+    const mediaType = ctx?.mediaType || this._params.packerParams.mediaType || MediaType.ZKPMessage;
+    const packerParams = ctx?.packerOptions || this._params.packerParams;
+    if (mediaType === MediaType.ZKPMessage && !packerParams?.provingMethodAlg) {
+      packerParams.provingMethodAlg = ctx.messageProvingMethodAlg;
+    }
+    const response = await this.packMessage(paymentMessage, senderDID, mediaType, packerParams);
 
     const agentResult = await fetch(paymentRequest.body.agent, {
       method: 'POST',
-      body: response,
+      body: response.buffer as ArrayBuffer,
       headers: {
         'Content-Type':
           this._params.packerParams.mediaType === MediaType.PlainMessage
@@ -430,13 +419,33 @@ export class PaymentHandler
     if (!opts?.allowExpiredMessages) {
       verifyExpiresTime(paymentRequest);
     }
+    if (!opts?.mediaType) {
+      opts.mediaType = this._params.packerParams.mediaType || MediaType.ZKPMessage;
+    }
+    if (!opts.packerOptions) {
+      opts.packerOptions = this._params.packerParams.packerOptions;
+    }
+    if (!opts?.packerOptions && opts.mediaType === MediaType.SignedMessage) {
+      throw new Error(`jws packer options are required for ${MediaType.SignedMessage}`);
+    }
+
+    const senderDID = DID.parse(paymentRequest.to);
+    if (opts.mediaType === MediaType.ZKPMessage && !opts.packerOptions?.provingMethodAlg) {
+      opts.packerOptions = {
+        provingMethodAlg: await getProvingMethodAlgFromJWZ(request),
+        senderDID
+      };
+    }
     const agentMessage = await this.handlePaymentRequestMessage(paymentRequest, opts);
     if (!agentMessage) {
       return null;
     }
-
-    const senderDID = DID.parse(paymentRequest.to);
-    return this.packMessage(agentMessage, senderDID);
+    return this.packMessage(
+      agentMessage,
+      senderDID,
+      opts.mediaType || MediaType.ZKPMessage,
+      opts.packerOptions
+    );
   }
 
   /**
@@ -490,12 +499,18 @@ export class PaymentHandler
     receiver: DID,
     agent: string,
     signer: Signer,
-    payments: PaymentRailsInfo[]
+    payments: PaymentRailsInfo[],
+    createOptions?: CreatePaymentRailsV1Options
   ): Promise<PaymentRequestMessage> {
     const paymentRequestInfo: PaymentRequestInfo[] = [];
     for (let i = 0; i < payments.length; i++) {
       const { credentials, description } = payments[i];
-      const dataArr: (Iden3PaymentRailsRequestV1 | Iden3PaymentRailsERC20RequestV1)[] = [];
+      const dataArr: (
+        | Iden3PaymentRailsRequestV1
+        | Iden3PaymentRailsERC20RequestV1
+        | Iden3PaymentRailsSolanaRequestV1
+        | Iden3PaymentRailsSolanaSPLRequestV1
+      )[] = [];
       for (let j = 0; j < payments[i].options.length; j++) {
         const { nonce, amount, chainId, optionId, expirationDate } = payments[i].options[j];
 
@@ -512,82 +527,51 @@ export class PaymentHandler
           throw new Error(`failed request. no option for id ${optionId}`);
         }
         if (
-          option.type === PaymentRequestDataType.Iden3PaymentRailsERC20RequestV1 &&
+          (option.type === PaymentRequestDataType.Iden3PaymentRailsERC20RequestV1 ||
+            option.type === PaymentRequestDataType.Iden3PaymentRailsSolanaSPLRequestV1) &&
           !option.contractAddress
         ) {
           throw new Error(`failed request. no token address for option id ${optionId}`);
         }
         const expirationDateRequired =
           expirationDate ?? new Date(new Date().setHours(new Date().getHours() + 1));
-        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
-            }
+
+        if (
+          option.type === PaymentRequestDataType.Iden3PaymentRailsSolanaRequestV1 ||
+          option.type === PaymentRequestDataType.Iden3PaymentRailsSolanaSPLRequestV1
+        ) {
+          if (!createOptions?.solSigner) {
+            throw new Error(
+              `please provide solana signer in context for ${option.type} payment type`
+            );
           }
-        ];
-
-        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
-        };
-        dataArr.push(
-          option.type === PaymentRequestDataType.Iden3PaymentRailsRequestV1
-            ? d
-            : {
-                ...d,
-                type: option.type,
-                tokenAddress: option.contractAddress || '',
-                features: option.features || []
-              }
-        );
+
+          const payment = await buildSolanaPayment(
+            createOptions.solSigner,
+            option,
+            chainId,
+            paymentRails,
+            recipient,
+            BigInt(amount),
+            expirationDateRequired,
+            nonce
+          );
+          dataArr.push(payment);
+        } else {
+          const payment = await buildEvmPayment(
+            signer,
+            option,
+            chainId,
+            paymentRails,
+            recipient,
+            BigInt(amount),
+            expirationDateRequired,
+            nonce
+          );
+          dataArr.push(payment);
+        }
       }
+
       paymentRequestInfo.push({
         data: dataArr,
         credentials,
@@ -597,15 +581,20 @@ export class PaymentHandler
     return createPaymentRequest(sender, receiver, agent, paymentRequestInfo);
   }
 
-  private async packMessage(message: BasicMessage, senderDID: DID): Promise<Uint8Array> {
+  private async packMessage(
+    message: BasicMessage,
+    senderDID: DID,
+    mediaType: MediaType,
+    packerParams?: PackerParams
+  ): Promise<Uint8Array> {
     const responseEncoded = byteEncoder.encode(JSON.stringify(message));
     const packerOpts =
-      this._params.packerParams.mediaType === MediaType.SignedMessage
-        ? this._params.packerParams.packerOptions
+      mediaType === MediaType.SignedMessage
+        ? packerParams
         : {
-            provingMethodAlg: proving.provingMethodGroth16AuthV2Instance.methodAlg
+            provingMethodAlg: packerParams?.provingMethodAlg || defaultProvingMethodAlg
           };
-    return await this._packerMgr.pack(this._params.packerParams.mediaType, responseEncoded, {
+    return await this._packerMgr.pack(mediaType, responseEncoded, {
       senderDID,
       ...packerOpts
     });
@@ -654,6 +643,63 @@ export class PaymentHandler
     };
   }
 
+  private async handleIden3PaymentRailsSolanaRequestV1(
+    data: Iden3PaymentRailsSolanaRequestV1,
+    paymentHandler: (data: Iden3PaymentRailsSolanaRequestV1) => Promise<string>
+  ): Promise<Iden3PaymentRailsSolanaV1> {
+    if (data.expirationDate && new Date(data.expirationDate) < new Date()) {
+      throw new Error(`failed request. expired request`);
+    }
+    const isValid = await verifyIden3SolanaPaymentRequest(data, this._params.documentResolver);
+    if (!isValid) {
+      throw new Error(`failed request. invalid Solana payment request signature`);
+    }
+    const proof = Array.isArray(data.proof) ? data.proof[0] : data.proof;
+    const signer = proof.verificationMethod.split(':').slice(-1)[0];
+    if (this._params.allowedSigners && !this._params.allowedSigners.includes(signer)) {
+      throw new Error(`failed request. signer is not in the allowed signers list`);
+    }
+    const txId = await paymentHandler(data);
+    return {
+      nonce: data.nonce,
+      type: PaymentType.Iden3PaymentRailsSolanaV1,
+      '@context': 'https://schema.iden3.io/core/jsonld/payment.jsonld#Iden3PaymentRailsSolanaV1',
+      paymentData: {
+        txId,
+        chainId: proof.domain.chainId
+      }
+    };
+  }
+
+  private async handleIden3PaymentRailsSolanaSPLRequestV1(
+    data: Iden3PaymentRailsSolanaSPLRequestV1,
+    paymentHandler: (data: Iden3PaymentRailsSolanaSPLRequestV1) => Promise<string>
+  ): Promise<Iden3PaymentRailsSolanaSPLV1> {
+    if (data.expirationDate && new Date(data.expirationDate) < new Date()) {
+      throw new Error(`failed request. expired request`);
+    }
+    const isValid = await verifyIden3SolanaPaymentRequest(data, this._params.documentResolver);
+    if (!isValid) {
+      throw new Error(`failed request. invalid Solana payment request signature`);
+    }
+    const proof = Array.isArray(data.proof) ? data.proof[0] : data.proof;
+    const signer = proof.verificationMethod.split(':').slice(-1)[0];
+    if (this._params.allowedSigners && !this._params.allowedSigners.includes(signer)) {
+      throw new Error(`failed request. signer is not in the allowed signers list`);
+    }
+    const txId = await paymentHandler(data);
+    return {
+      nonce: data.nonce,
+      type: PaymentType.Iden3PaymentRailsSolanaSPLV1,
+      '@context': 'https://schema.iden3.io/core/jsonld/payment.jsonld#Iden3PaymentRailsSolanaSPLV1',
+      paymentData: {
+        txId,
+        chainId: proof.domain.chainId,
+        tokenAddress: data.tokenAddress
+      }
+    };
+  }
+
   private async handleIden3PaymentRailsERC20RequestV1(
     data: Iden3PaymentRailsERC20RequestV1,
     paymentHandler: (data: Iden3PaymentRailsERC20RequestV1) => Promise<string>,

package/src/iden3comm/handlers/refresh.ts

@@ -5,16 +5,16 @@ import {
   CredentialIssuanceMessage,
   CredentialRefreshMessage,
   IPackageManager,
+  JWSPackerParams,
   ZKPPackerParams
 } from '../types';
 
 import { RefreshServiceType, W3CCredential } from '../../verifiable';
 import { byteEncoder } from '../../utils';
-import { proving, ProvingMethodAlg } from '@iden3/js-jwz';
 import { DID } from '@iden3/js-iden3-core';
 import { ICredentialWallet } from '../../credentials';
-import { CircuitId } from '../../circuits';
 import * as uuid from 'uuid';
+import { defaultProvingMethodAlg } from './message-handler';
 
 /**
  * RefreshHandlerOptions contains options for RefreshHandler
@@ -35,6 +35,8 @@ export interface RefreshHandlerOptions {
  */
 export interface RefreshOptions {
   reason?: string;
+  packerOptions?: JWSPackerParams | ZKPPackerParams;
+  mediaType?: MediaType;
 }
 
 /**
@@ -88,12 +90,10 @@ export class RefreshHandler implements IRefreshHandler {
 
     const senderDID = DID.parse(otherIdentifier);
 
-    const zkpParams: ZKPPackerParams = {
+    const mediaType = opts?.mediaType || MediaType.ZKPMessage;
+    const packerOptions = opts?.packerOptions ?? {
       senderDID,
-      provingMethodAlg: new ProvingMethodAlg(
-        proving.provingMethodGroth16AuthV2Instance.methodAlg.alg,
-        CircuitId.AuthV2
-      )
+      provingMethodAlg: defaultProvingMethodAlg
     };
 
     const refreshMsg: CredentialRefreshMessage = {
@@ -110,17 +110,13 @@ export class RefreshHandler implements IRefreshHandler {
     };
 
     const msgBytes = byteEncoder.encode(JSON.stringify(refreshMsg));
-    const jwzToken = await this._options.packageManager.pack(
-      MediaType.ZKPMessage,
-      msgBytes,
-      zkpParams
-    );
+    const token = await this._options.packageManager.pack(mediaType, msgBytes, packerOptions);
     const resp = await fetch(credential.refreshService.id, {
       method: 'post',
       headers: {
         'Content-Type': 'application/json'
       },
-      body: jwzToken
+      body: token.buffer as ArrayBuffer
     });
 
     if (resp.status !== 200) {

package/src/iden3comm/handlers/revocation-status.ts

@@ -5,7 +5,8 @@ import {
   IPackageManager,
   JWSPackerParams,
   RevocationStatusRequestMessage,
-  RevocationStatusResponseMessage
+  RevocationStatusResponseMessage,
+  ZKPPackerParams
 } from '../types';
 
 import { DID } from '@iden3/js-iden3-core';
@@ -13,12 +14,12 @@ import * as uuid from 'uuid';
 import { RevocationStatus } from '../../verifiable';
 import { TreeState } from '../../circuits';
 import { byteEncoder } from '../../utils';
-import { proving } from '@iden3/js-jwz';
 import { IIdentityWallet } from '../../identity';
 import {
   AbstractMessageHandler,
   BasicHandlerOptions,
-  IProtocolMessageHandler
+  IProtocolMessageHandler,
+  getProvingMethodAlgFromJWZ
 } from './message-handler';
 import { verifyExpiresTime } from './common';
 
@@ -29,10 +30,10 @@ import { verifyExpiresTime } from './common';
  * @property packerOptions - Optional parameters for the JWS packer.
  * @property treeState - Optional tree state to be used.
  */
-export type RevocationStatusMessageHandlerOptions = {
+export type RevocationStatusMessageHandlerOptions = BasicHandlerOptions & {
   senderDid: DID;
   mediaType: MediaType;
-  packerOptions?: JWSPackerParams;
+  packerOptions?: JWSPackerParams | ZKPPackerParams;
   treeState?: TreeState;
 };
 
@@ -66,7 +67,7 @@ export interface IRevocationStatusHandler {
 /** RevocationStatusHandlerOptions represents revocation status handler options */
 export type RevocationStatusHandlerOptions = BasicHandlerOptions & {
   mediaType: MediaType;
-  packerOptions?: JWSPackerParams;
+  packerOptions?: JWSPackerParams | ZKPPackerParams;
   treeState?: TreeState;
 };
 
@@ -212,7 +213,8 @@ export class RevocationStatusHandler
       opts.mediaType === MediaType.SignedMessage
         ? opts.packerOptions
         : {
-            provingMethodAlg: proving.provingMethodGroth16AuthV2Instance.methodAlg
+            provingMethodAlg:
+              opts.packerOptions?.provingMethodAlg || (await getProvingMethodAlgFromJWZ(request))
           };
 
     if (!rsRequest.to) {

package/src/iden3comm/packers/zkp.ts

@@ -9,7 +9,7 @@ import {
   ZKPPackerParams
 } from '../types';
 import { Token, Header, ProvingMethodAlg, proving } from '@iden3/js-jwz';
-import { AuthV2PubSignals, CircuitId } from '../../circuits/index';
+import { AuthV2PubSignals, AuthV3PubSignals, CircuitId } from '../../circuits/index';
 import { BytesHelper, DID } from '@iden3/js-iden3-core';
 import { bytesToProtocolMessage } from '../utils/envelope';
 import {
@@ -20,7 +20,7 @@ import {
   ErrStateVerificationFailed,
   ErrUnknownCircuitID
 } from '../errors';
-import { AcceptAuthCircuits, AcceptJwzAlgorithms, MediaType, ProtocolVersion } from '../constants';
+import { AcceptJwzAlgorithms, MediaType, ProtocolVersion } from '../constants';
 import { byteDecoder, byteEncoder } from '../../utils';
 import { DEFAULT_AUTH_VERIFY_DELAY } from '../constants';
 import { parseAcceptProfile } from '../utils';
@@ -88,8 +88,7 @@ export class VerificationHandlerFunc {
 export class ZKPPacker implements IPacker {
   private readonly supportedProtocolVersions = [ProtocolVersion.V1];
   private readonly supportedAlgorithms = [AcceptJwzAlgorithms.Groth16];
-  private readonly supportedCircuitIds = [AcceptAuthCircuits.AuthV2];
-
+  private readonly supportedCircuitIds: string[];
   /**
    * Creates an instance of ZKPPacker.
    * @param {Map<string, ProvingParams>} provingParamsMap - string is derived by JSON.parse(ProvingMethodAlg)
@@ -101,7 +100,16 @@ export class ZKPPacker implements IPacker {
     private readonly _opts: StateVerificationOpts = {
       acceptedStateTransitionDelay: DEFAULT_AUTH_VERIFY_DELAY
     }
-  ) {}
+  ) {
+    const supportedProvers = Array.from(this.provingParamsMap.keys()).map(
+      (alg) => alg.split(':')[1]
+    );
+
+    const supportedVerifiers = Array.from(this.verificationParamsMap.keys()).map(
+      (alg) => alg.split(':')[1]
+    );
+    this.supportedCircuitIds = [...new Set([...supportedProvers, ...supportedVerifiers])];
+  }
 
   /**
    * Packs a basic message using the specified parameters.
@@ -216,13 +224,15 @@ export class ZKPPacker implements IPacker {
 const verifySender = async (token: Token, msg: BasicMessage): Promise<void> => {
   switch (token.circuitId) {
     case CircuitId.AuthV2:
+    case CircuitId.AuthV3_8_32:
+    case CircuitId.AuthV3:
       {
         if (!msg.from) {
           throw new Error(ErrSenderNotUsedTokenCreation);
         }
-        const authSignals = new AuthV2PubSignals().pubSignalsUnmarshal(
-          byteEncoder.encode(JSON.stringify(token.zkProof.pub_signals))
-        );
+        const authSignals = (
+          token.circuitId === CircuitId.AuthV2 ? new AuthV2PubSignals() : new AuthV3PubSignals()
+        ).pubSignalsUnmarshal(byteEncoder.encode(JSON.stringify(token.zkProof.pub_signals)));
         const did = DID.parseFromId(authSignals.userID);
 
         const msgHash = await token.getMessageHash();