@0xpolygonid/js-sdk 1.21.1 → 1.23.0

package/dist/node/esm/storage/blockchain/erc20-permit-sig.js

@@ -0,0 +1,39 @@
+import { Contract } from 'ethers';
+import abi from './abi/ERC20Permit.json';
+/**
+ * @beta
+ * getPermitSignature is a function to create EIP712 Permit signature
+ * @param {Signer} signer - User who owns the tokens
+ * @param {string} tokenAddress - EIP-2612 contract address
+ * @param {string} spender -  The contract address that will spend tokens
+ * @param {bigint} value - Amount of tokens to approve
+ * @param {number} deadline - Timestamp when the permit expires
+ * @returns {Promise<PaymentRequestMessage>}
+ */
+export async function getPermitSignature(signer, tokenAddress, spender, value, deadline) {
+    const erc20PermitContract = new Contract(tokenAddress, abi, signer);
+    const nonce = await erc20PermitContract.nonces(await signer.getAddress());
+    const domainData = await erc20PermitContract.eip712Domain();
+    const domain = {
+        version: domainData[2],
+        chainId: domainData[3],
+        verifyingContract: tokenAddress
+    };
+    const types = {
+        Permit: [
+            { name: 'owner', type: 'address' },
+            { name: 'spender', type: 'address' },
+            { name: 'value', type: 'uint256' },
+            { name: 'nonce', type: 'uint256' },
+            { name: 'deadline', type: 'uint256' }
+        ]
+    };
+    const message = {
+        owner: await signer.getAddress(),
+        spender: spender,
+        value: value,
+        nonce: nonce,
+        deadline: deadline
+    };
+    return signer.signTypedData(domain, types, message);
+}

package/dist/node/esm/storage/blockchain/index.js

@@ -1,3 +1,4 @@
 export * from './state';
 export * from './onchain-zkp-verifier';
 export * from './onchain-revocation';
+export * from './erc20-permit-sig';

package/dist/node/esm/storage/filters/jsonQuery.js

@@ -95,10 +95,12 @@ const betweenOperator = (a, b) => {
     if (!Array.isArray(b) || b.length !== 2) {
         throw new Error('$between/$nonbetween operator value should be 2 elements array');
     }
+    const [min, max] = b.map(BigInt);
+    const predicate = (val) => val >= min && val <= max;
     if (Array.isArray(a)) {
-        return a.every((val) => val >= b[0] && val <= b[1]);
+        return a.map(BigInt).every(predicate);
     }
-    return a >= b[0] && a <= b[1];
+    return predicate(BigInt(a));
 };
 export const comparatorOptions = {
     $noop: () => true,
@@ -108,7 +110,7 @@ export const comparatorOptions = {
     $in: (a, b) => inOperator(a, b),
     $nin: (a, b) => !inOperator(a, b),
     $gt: (a, b) => greaterThan(a, b),
-    $lt: (a, b) => !greaterThan(a, b),
+    $lt: (a, b) => !greaterThanOrEqual(a, b),
     $ne: (a, b) => !equalsComparator(a, b),
     $gte: (a, b) => greaterThanOrEqual(a, b),
     $lte: (a, b) => lessThanOrEqual(a, b),

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

@@ -112,15 +112,6 @@ export var RefreshServiceType;
 (function (RefreshServiceType) {
     RefreshServiceType["Iden3RefreshService2023"] = "Iden3RefreshService2023";
 })(RefreshServiceType || (RefreshServiceType = {}));
-/**
- * PaymentRequestType type for payment requests
- * @beta
- * @enum {string}
- */
-export var PaymentRequestType;
-(function (PaymentRequestType) {
-    PaymentRequestType["PaymentRequest"] = "PaymentRequest";
-})(PaymentRequestType || (PaymentRequestType = {}));
 /**
  * PaymentRequestDataType type for payment requests
  * @beta
@@ -129,6 +120,8 @@ export var PaymentRequestType;
 export var PaymentRequestDataType;
 (function (PaymentRequestDataType) {
     PaymentRequestDataType["Iden3PaymentRequestCryptoV1"] = "Iden3PaymentRequestCryptoV1";
+    PaymentRequestDataType["Iden3PaymentRailsRequestV1"] = "Iden3PaymentRailsRequestV1";
+    PaymentRequestDataType["Iden3PaymentRailsERC20RequestV1"] = "Iden3PaymentRailsERC20RequestV1";
 })(PaymentRequestDataType || (PaymentRequestDataType = {}));
 /**
  * PaymentType type for payment responses
@@ -138,17 +131,41 @@ export var PaymentRequestDataType;
 export var PaymentType;
 (function (PaymentType) {
     PaymentType["Iden3PaymentCryptoV1"] = "Iden3PaymentCryptoV1";
+    PaymentType["Iden3PaymentRailsV1"] = "Iden3PaymentRailsV1";
+    PaymentType["Iden3PaymentRailsERC20V1"] = "Iden3PaymentRailsERC20V1";
 })(PaymentType || (PaymentType = {}));
+/**
+ * SupportedPaymentProofType type for payment proofs
+ * @beta
+ * @enum {string}
+ */
+export var SupportedPaymentProofType;
+(function (SupportedPaymentProofType) {
+    SupportedPaymentProofType["EthereumEip712Signature2021"] = "EthereumEip712Signature2021";
+})(SupportedPaymentProofType || (SupportedPaymentProofType = {}));
 /**
  * Media types for Payment supported currencies
  * @beta
- * @enum {number}
+ * @enum {string}
  */
 export var SupportedCurrencies;
 (function (SupportedCurrencies) {
     SupportedCurrencies["ETH"] = "ETH";
+    SupportedCurrencies["ETH_WEI"] = "ETHWEI";
+    SupportedCurrencies["ETH_GWEI"] = "ETHGWEI";
     SupportedCurrencies["MATIC"] = "MATIC";
+    SupportedCurrencies["USDT"] = "USDT";
+    SupportedCurrencies["USDC"] = "USDC";
 })(SupportedCurrencies || (SupportedCurrencies = {}));
+/**
+ * Supported features for payment-request
+ * @beta
+ * @enum {string}
+ */
+export var PaymentFeatures;
+(function (PaymentFeatures) {
+    PaymentFeatures["EIP_2612"] = "EIP-2612";
+})(PaymentFeatures || (PaymentFeatures = {}));
 /**
  * DisplayMethodType type for display method
  *

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

@@ -1,3 +1,4 @@
+import { AcceptProfile } from './types';
 /**
  * Constants for Iden3 protocol
  */
@@ -37,5 +38,20 @@ export declare const SUPPORTED_PUBLIC_KEY_TYPES: {
     ES256K: string[];
     'ES256K-R': string[];
 };
+export declare enum ProtocolVersion {
+    V1 = "iden3comm/v1"
+}
+export declare enum AcceptAuthCircuits {
+    AuthV2 = "authV2",
+    AuthV3 = "authV3"
+}
+export declare enum AcceptJwzAlgorithms {
+    Groth16 = "groth16"
+}
+export declare enum AcceptJwsAlgorithms {
+    ES256K = "ES256K",
+    ES256KR = "ES256K-R"
+}
+export declare const defaultAcceptProfile: AcceptProfile;
 export declare const DEFAULT_PROOF_VERIFY_DELAY: number;
 export declare const DEFAULT_AUTH_VERIFY_DELAY: number;

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

@@ -1,32 +1,43 @@
 import { MediaType } from '../constants';
 import { IProofService } from '../../proof/proof-service';
-import { StateVerificationOpts, AuthorizationRequestMessage, AuthorizationResponseMessage, BasicMessage, IPackageManager, JWSPackerParams } from '../types';
+import { StateVerificationOpts, AuthorizationRequestMessage, AuthorizationResponseMessage, BasicMessage, IPackageManager, JWSPackerParams, ZeroKnowledgeProofRequest } from '../types';
 import { DID } from '@iden3/js-iden3-core';
-import { AbstractMessageHandler, IProtocolMessageHandler } from './message-handler';
+import { AbstractMessageHandler, BasicHandlerOptions, IProtocolMessageHandler } from './message-handler';
+/**
+ * Options to pass to createAuthorizationRequest function
+ * @public
+ */
+export type AuthorizationRequestCreateOptions = {
+    accept?: string[];
+    scope?: ZeroKnowledgeProofRequest[];
+    expires_time?: Date;
+};
 /**
  *  createAuthorizationRequest is a function to create protocol authorization request
  * @param {string} reason - reason to request proof
  * @param {string} sender - sender did
  * @param {string} callbackUrl - callback that user should use to send response
+ * @param {AuthorizationRequestCreateOptions} opts - authorization request options
  * @returns `Promise<AuthorizationRequestMessage>`
  */
-export declare function createAuthorizationRequest(reason: string, sender: string, callbackUrl: string): AuthorizationRequestMessage;
+export declare function createAuthorizationRequest(reason: string, sender: string, callbackUrl: string, opts?: AuthorizationRequestCreateOptions): AuthorizationRequestMessage;
 /**
  *  createAuthorizationRequestWithMessage is a function to create protocol authorization request with explicit message to sign
  * @param {string} reason - reason to request proof
  * @param {string} message - message to sign in the response
  * @param {string} sender - sender did
  * @param {string} callbackUrl - callback that user should use to send response
+ * @param {AuthorizationRequestCreateOptions} opts - authorization request options
  * @returns `Promise<AuthorizationRequestMessage>`
  */
-export declare function createAuthorizationRequestWithMessage(reason: string, message: string, sender: string, callbackUrl: string): AuthorizationRequestMessage;
+export declare function createAuthorizationRequestWithMessage(reason: string, message: string, sender: string, callbackUrl: string, opts?: AuthorizationRequestCreateOptions): AuthorizationRequestMessage;
 /**
  *
  * Options to pass to auth response handler
  *
  * @public
  */
-export type AuthResponseHandlerOptions = StateVerificationOpts & {
+export type AuthResponseHandlerOptions = StateVerificationOpts & BasicHandlerOptions & {
     acceptedProofGenerationDelay?: number;
 };
 /**
@@ -92,10 +103,10 @@ export type AuthMessageHandlerOptions = AuthReqOptions | AuthRespOptions;
  * @public
  * @interface AuthHandlerOptions
  */
-export interface AuthHandlerOptions {
+export type AuthHandlerOptions = BasicHandlerOptions & {
     mediaType: MediaType;
     packerOptions?: JWSPackerParams;
-}
+};
 /**
  *
  * Allows to process AuthorizationRequest protocol message and produce JWZ response.
@@ -139,5 +150,6 @@ export declare class AuthHandler extends AbstractMessageHandler implements IAuth
         response: AuthorizationResponseMessage;
     }>;
     private verifyAuthRequest;
+    private getSupportedMediaTypeByProfile;
 }
 export {};

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

@@ -1,4 +1,4 @@
-import { JWSPackerParams, ZeroKnowledgeProofRequest, ZeroKnowledgeProofResponse } from '../types';
+import { BasicMessage, JWSPackerParams, ZeroKnowledgeProofRequest, ZeroKnowledgeProofResponse } from '../types';
 import { DID } from '@iden3/js-iden3-core';
 import { IProofService } from '../../proof';
 import { CircuitId } from '../../circuits';
@@ -21,3 +21,9 @@ export declare const processZeroKnowledgeProofRequests: (to: DID, requests: Zero
     ethSigner?: Signer;
     challenge?: bigint;
 }) => Promise<ZeroKnowledgeProofResponse[]>;
+/**
+ * Verifies that the expires_time field of a message is not in the past. Throws an error if it is.
+ *
+ * @param message - Basic message to verify.
+ */
+export declare const verifyExpiresTime: (message: BasicMessage) => void;

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

@@ -4,7 +4,7 @@ import { ContractInvokeRequest } from '../types/protocol/contract-request';
 import { DID } from '@iden3/js-iden3-core';
 import { IOnChainZKPVerifier } from '../../storage';
 import { Signer } from 'ethers';
-import { AbstractMessageHandler, IProtocolMessageHandler } from './message-handler';
+import { AbstractMessageHandler, BasicHandlerOptions, IProtocolMessageHandler } from './message-handler';
 /**
  * Interface that allows the processing of the contract request
  *
@@ -30,7 +30,7 @@ export interface IContractRequestHandler {
     handleContractInvokeRequest(did: DID, request: Uint8Array, opts?: ContractInvokeHandlerOptions): Promise<Map<string, ZeroKnowledgeProofResponse>>;
 }
 /** ContractInvokeHandlerOptions represents contract invoke handler options */
-export type ContractInvokeHandlerOptions = {
+export type ContractInvokeHandlerOptions = BasicHandlerOptions & {
     ethSigner: Signer;
     challenge?: bigint;
 };

package/dist/types/iden3comm/handlers/credential-proposal.d.ts

@@ -2,7 +2,7 @@ import { BasicMessage, DIDDocument, IPackageManager, JsonDocumentObject, PackerP
 import { DID } from '@iden3/js-iden3-core';
 import { Proposal, ProposalRequestCredential, ProposalRequestMessage, ProposalMessage } from '../types/protocol/proposal-request';
 import { IIdentityWallet } from '../../identity';
-import { AbstractMessageHandler, IProtocolMessageHandler } from './message-handler';
+import { AbstractMessageHandler, BasicHandlerOptions, IProtocolMessageHandler } from './message-handler';
 /** @beta ProposalRequestCreationOptions represents proposal-request creation options */
 export type ProposalRequestCreationOptions = {
     credentials: ProposalRequestCredential[];
@@ -11,6 +11,11 @@ export type ProposalRequestCreationOptions = {
         data?: JsonDocumentObject;
     };
     did_doc?: DIDDocument;
+    expires_time?: Date;
+};
+/** @beta ProposalCreationOptions represents proposal creation options */
+export type ProposalCreationOptions = {
+    expires_time?: Date;
 };
 /**
  * @beta
@@ -29,7 +34,7 @@ export declare function createProposalRequest(sender: DID, receiver: DID, opts:
  * @param {Proposal[]} proposals - proposals
  * @returns `Promise<ProposalRequestMessage>`
  */
-export declare function createProposal(sender: DID, receiver: DID, proposals?: Proposal[]): ProposalMessage;
+export declare function createProposal(sender: DID, receiver: DID, proposals?: Proposal[], opts?: ProposalCreationOptions): ProposalMessage;
 /**
  * @beta
  * Interface that allows the processing of the proposal-request
@@ -66,9 +71,9 @@ export interface ICredentialProposalHandler {
     }>;
 }
 /** @beta ProposalRequestHandlerOptions represents proposal-request handler options */
-export type ProposalRequestHandlerOptions = object;
+export type ProposalRequestHandlerOptions = BasicHandlerOptions;
 /** @beta ProposalHandlerOptions represents proposal handler options */
-export type ProposalHandlerOptions = {
+export type ProposalHandlerOptions = BasicHandlerOptions & {
     proposalRequest?: ProposalRequestMessage;
 };
 /** @beta CredentialProposalHandlerParams represents credential proposal handler params */

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

@@ -2,7 +2,7 @@ import { MediaType } from '../constants';
 import { BasicMessage, IPackageManager, JWSPackerParams } from '../types';
 import { W3CCredential } from '../../verifiable';
 import { ICredentialWallet } from '../../credentials';
-import { AbstractMessageHandler, IProtocolMessageHandler } from './message-handler';
+import { AbstractMessageHandler, BasicHandlerOptions, IProtocolMessageHandler } from './message-handler';
 /**
  *
  * Options to pass to fetch handler
@@ -10,13 +10,29 @@ import { AbstractMessageHandler, IProtocolMessageHandler } from './message-handl
  * @public
  * @interface FetchHandlerOptions
  */
-export type FetchHandlerOptions = {
+export type FetchHandlerOptions = BasicHandlerOptions & {
     mediaType: MediaType;
     packerOptions?: JWSPackerParams;
     headers?: {
         [key: string]: string;
     };
 };
+/**
+ *
+ * Options to pass to fetch request handler
+ *
+ * @public
+ * @interface FetchRequestOptions
+ */
+export type FetchRequestOptions = BasicHandlerOptions;
+/**
+ *
+ * Options to pass to issuance response handler
+ *
+ * @public
+ * @interface IssuanceResponseOptions
+ */
+export type IssuanceResponseOptions = BasicHandlerOptions;
 export type FetchMessageHandlerOptions = FetchHandlerOptions;
 /**
  * Interface that allows the processing of the credential offer in the raw format for given identifier
@@ -44,7 +60,7 @@ export interface IFetchHandler {
      * @returns A promise that resolves to the response message.
      * @throws An error if the request is invalid or if the credential is not found.
      */
-    handleCredentialFetchRequest(basicMessage: Uint8Array): Promise<Uint8Array>;
+    handleCredentialFetchRequest(basicMessage: Uint8Array, opts?: FetchRequestOptions): Promise<Uint8Array>;
     /**
      * Handles the issuance response message.
      *
@@ -52,7 +68,7 @@ export interface IFetchHandler {
      * @returns A promise that resolves to a Uint8Array.
      * @throws An error if the credential wallet is not provided in the options or if the credential is missing in the issuance response message.
      */
-    handleIssuanceResponseMessage(basicMessage: Uint8Array): Promise<Uint8Array>;
+    handleIssuanceResponseMessage(basicMessage: Uint8Array, opts?: IssuanceResponseOptions): Promise<Uint8Array>;
 }
 /**
  *
@@ -92,12 +108,12 @@ export declare class FetchHandler extends AbstractMessageHandler implements IFet
     /**
      * @inheritdoc IFetchHandler#handleCredentialFetchRequest
      */
-    handleCredentialFetchRequest(envelope: Uint8Array): Promise<Uint8Array>;
+    handleCredentialFetchRequest(envelope: Uint8Array, opts?: FetchRequestOptions): Promise<Uint8Array>;
     private handleIssuanceResponseMsg;
     /**
      * @inheritdoc IFetchHandler#handleIssuanceResponseMessage
      */
-    handleIssuanceResponseMessage(envelop: Uint8Array): Promise<Uint8Array>;
+    handleIssuanceResponseMessage(envelop: Uint8Array, opts?: IssuanceResponseOptions): Promise<Uint8Array>;
     /**
      * @inheritdoc IFetchHandler#unpackMessage
      */

package/dist/types/iden3comm/handlers/message-handler.d.ts

@@ -4,6 +4,12 @@ import { RevocationStatusMessageHandlerOptions } from './revocation-status';
 import { ContractMessageHandlerOptions } from './contract-request';
 import { PaymentHandlerOptions, PaymentRequestMessageHandlerOptions } from './payment';
 import { DID } from '@iden3/js-iden3-core';
+/**
+ * iden3 Basic protocol message handler options
+ */
+export type BasicHandlerOptions = {
+    allowExpiredMessages?: boolean;
+};
 /**
  * iden3  Protocol message handler interface
  */

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

@@ -1,7 +1,18 @@
 import { BasicMessage, IPackageManager, PackerParams } from '../types';
 import { DID } from '@iden3/js-iden3-core';
-import { AbstractMessageHandler, IProtocolMessageHandler } from './message-handler';
-import { PaymentInfo, PaymentMessage, PaymentRequestDataInfo, PaymentRequestInfo, PaymentRequestMessage } from '../types/protocol/payment';
+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 */
+export type PaymentRequestCreationOptions = {
+    expires_time?: Date;
+};
+/** @beta PaymentCreationOptions represents payment creation options */
+export type PaymentCreationOptions = {
+    expires_time?: Date;
+};
 /**
  * @beta
  * createPaymentRequest is a function to create protocol payment-request message
@@ -11,16 +22,42 @@ import { PaymentInfo, PaymentMessage, PaymentRequestDataInfo, PaymentRequestInfo
  * @param {PaymentRequestInfo[]} payments - payments
  * @returns `PaymentRequestMessage`
  */
-export declare function createPaymentRequest(sender: DID, receiver: DID, agent: string, payments: PaymentRequestInfo[]): PaymentRequestMessage;
+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>;
+/**
+ * @beta
+ * PaymentRailsInfo represents payment info for payment rails
+ */
+export type PaymentRailsInfo = {
+    credentials: {
+        type: string;
+        context: string;
+    }[];
+    description?: string;
+    chains: PaymentRailsChainInfo[];
+};
+/**
+ * @beta
+ * PaymentRailsChainInfo represents chain info for payment rails
+ */
+export type PaymentRailsChainInfo = {
+    nonce: bigint;
+    amount: bigint;
+    currency: SupportedCurrencies | string;
+    chainId: string;
+    expirationDate?: string;
+    features?: PaymentFeatures[];
+    type: PaymentRequestDataType.Iden3PaymentRailsRequestV1 | PaymentRequestDataType.Iden3PaymentRailsERC20RequestV1;
+};
 /**
  * @beta
  * createPayment is a function to create protocol payment message
  * @param {DID} sender - sender did
  * @param {DID} receiver - receiver did
- * @param {PaymentInfo[]} payments - payments
+ * @param {PaymentMessageBody} body - payments
  * @returns `PaymentMessage`
  */
-export declare function createPayment(sender: DID, receiver: DID, payments: PaymentInfo[]): PaymentMessage;
+export declare function createPayment(sender: DID, receiver: DID, payments: PaymentTypeUnion[], opts?: PaymentCreationOptions): PaymentMessage;
 /**
  * @beta
  * Interface that allows the processing of the payment-request and payment protocol messages
@@ -51,19 +88,35 @@ export interface IPaymentHandler {
      * @returns `Promise<void>`
      */
     handlePayment(payment: PaymentMessage, opts: PaymentHandlerOptions): Promise<void>;
+    /**
+     * @beta
+     * createPaymentRailsV1 is a function to create protocol payment message
+     * @param {DID} sender - sender did
+     * @param {DID} receiver - receiver did
+     * @param {string} agent - agent URL
+     * @param {Signer} signer - receiver did
+     * @param payments - payment options
+     * @returns {Promise<PaymentRequestMessage>}
+     */
+    createPaymentRailsV1(sender: DID, receiver: DID, agent: string, signer: Signer, payments: PaymentRailsInfo[]): Promise<PaymentRequestMessage>;
 }
 /** @beta PaymentRequestMessageHandlerOptions represents payment-request handler options */
-export type PaymentRequestMessageHandlerOptions = {
-    paymentHandler: (data: PaymentRequestDataInfo) => Promise<string>;
+export type PaymentRequestMessageHandlerOptions = BasicHandlerOptions & {
+    paymentHandler: (data: PaymentRequestTypeUnion) => Promise<string>;
+    nonce: string;
+    erc20TokenApproveHandler?: (data: Iden3PaymentRailsERC20RequestV1) => Promise<string>;
 };
 /** @beta PaymentHandlerOptions represents payment handler options */
-export type PaymentHandlerOptions = {
+export type PaymentHandlerOptions = BasicHandlerOptions & {
     paymentRequest: PaymentRequestMessage;
-    paymentValidationHandler: (txId: string, data: PaymentRequestDataInfo) => Promise<void>;
+    paymentValidationHandler: (txId: string, data: PaymentRequestTypeUnion) => Promise<void>;
 };
 /** @beta PaymentHandlerParams represents payment handler params */
 export type PaymentHandlerParams = {
     packerParams: PackerParams;
+    documentResolver: Resolvable;
+    multiChainPaymentConfig?: MultiChainPaymentConfig[];
+    allowedSigners?: string[];
 };
 /**
  *
@@ -95,6 +148,13 @@ export declare class PaymentHandler extends AbstractMessageHandler implements IP
     /**
      * @inheritdoc IPaymentHandler#handlePayment
      */
-    handlePayment(payment: PaymentMessage, opts: PaymentHandlerOptions): Promise<void>;
+    handlePayment(payment: PaymentMessage, params: PaymentHandlerOptions): Promise<void>;
+    /**
+     * @inheritdoc IPaymentHandler#createPaymentRailsV1
+     */
+    createPaymentRailsV1(sender: DID, receiver: DID, agent: string, signer: Signer, payments: PaymentRailsInfo[]): Promise<PaymentRequestMessage>;
     private packMessage;
+    private handleIden3PaymentRequestCryptoV1;
+    private handleIden3PaymentRailsRequestV1;
+    private handleIden3PaymentRailsERC20RequestV1;
 }

package/dist/types/iden3comm/handlers/revocation-status.d.ts

@@ -3,7 +3,7 @@ import { BasicMessage, IPackageManager, JWSPackerParams, RevocationStatusRequest
 import { DID } from '@iden3/js-iden3-core';
 import { TreeState } from '../../circuits';
 import { IIdentityWallet } from '../../identity';
-import { AbstractMessageHandler, IProtocolMessageHandler } from './message-handler';
+import { AbstractMessageHandler, BasicHandlerOptions, IProtocolMessageHandler } from './message-handler';
 /**
  * Defines the options for a RevocationStatusMessageHandler.
  * @property senderDid - The DID (Decentralized Identifier) to be used.
@@ -39,7 +39,7 @@ export interface IRevocationStatusHandler {
     handleRevocationStatusRequest(did: DID, request: Uint8Array, opts?: RevocationStatusHandlerOptions): Promise<Uint8Array>;
 }
 /** RevocationStatusHandlerOptions represents revocation status handler options */
-export type RevocationStatusHandlerOptions = {
+export type RevocationStatusHandlerOptions = BasicHandlerOptions & {
     mediaType: MediaType;
     packerOptions?: JWSPackerParams;
     treeState?: TreeState;

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

@@ -3,5 +3,6 @@ export * from './packers';
 export * from './types';
 export * from './handlers';
 export * from './utils/did';
+export * from './utils/accept-profile';
 import * as PROTOCOL_CONSTANTS from './constants';
 export { PROTOCOL_CONSTANTS };

package/dist/types/iden3comm/packageManager.d.ts

@@ -13,6 +13,10 @@ export declare class PackageManager implements IPackageManager {
      * Creates an instance of PackageManager.
      */
     constructor();
+    /** {@inheritDoc IPackageManager.isProfileSupported} */
+    isProfileSupported(mediaType: MediaType, profile: string): boolean;
+    /** {@inheritDoc IPackageManager.getSupportedMediaTypes} */
+    getSupportedMediaTypes(): MediaType[];
     /** {@inheritDoc IPackageManager.registerPackers} */
     registerPackers(packers: Array<IPacker>): void;
     /** {@inheritDoc IPackageManager.pack} */

package/dist/types/iden3comm/packers/jws.d.ts

@@ -44,6 +44,11 @@ export declare class JWSPacker implements IPacker {
      */
     unpack(envelope: Uint8Array): Promise<BasicMessage>;
     mediaType(): MediaType;
+    /** {@inheritDoc IPacker.getSupportedProfiles} */
+    getSupportedProfiles(): string[];
+    /** {@inheritDoc IPacker.isProfileSupported} */
+    isProfileSupported(profile: string): boolean;
+    private getSupportedAlgorithms;
     private resolveDidDoc;
     private packInternal;
 }

package/dist/types/iden3comm/packers/plain.d.ts

@@ -38,4 +38,8 @@ export declare class PlainPacker implements IPacker {
      * @returns MediaType
      */
     mediaType(): MediaType;
+    /** {@inheritDoc IPacker.getSupportedProfiles} */
+    getSupportedProfiles(): string[];
+    /** {@inheritDoc IPacker.isProfileSupported} */
+    isProfileSupported(profile: string): boolean;
 }

package/dist/types/iden3comm/packers/zkp.d.ts

@@ -87,4 +87,10 @@ export declare class ZKPPacker implements IPacker {
      */
     unpack(envelope: Uint8Array): Promise<BasicMessage>;
     mediaType(): MediaType;
+    /** {@inheritDoc IPacker.getSupportedProfiles} */
+    getSupportedProfiles(): string[];
+    /** {@inheritDoc IPacker.isProfileSupported} */
+    isProfileSupported(profile: string): boolean;
+    private getSupportedAlgorithms;
+    private getSupportedCircuitIds;
 }

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

@@ -6,6 +6,7 @@ export * from './protocol/revocation';
 export * from './protocol/contract-request';
 export * from './protocol/proposal-request';
 export * from './protocol/payment';
+export * from './protocol/accept-profile';
 export * from './packer';
 export * from './models';
 export * from './packageManager';

package/dist/types/iden3comm/types/packageManager.d.ts

@@ -64,6 +64,20 @@ export interface IPackageManager {
      * @returns MediaType
      */
     getMediaType(envelope: string): MediaType;
+    /**
+     * gets supported media types by packer manager
+     *
+     * @returns MediaType[]
+     */
+    getSupportedMediaTypes(): MediaType[];
+    /**
+     * returns true if media type and algorithms supported by packer manager
+     *
+     * @param {MediaType} mediaType
+     * @param {string} profile
+     * @returns {boolean}
+     */
+    isProfileSupported(mediaType: MediaType, profile: string): boolean;
 }
 /**
  * EnvelopeStub is used to stub the jwt based envelops