@0xpolygonid/js-sdk 1.21.3 → 1.24.1

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

@@ -2,7 +2,8 @@ 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';
+import { IOnchainIssuer } from '../../storage';
 /**
  *
  * Options to pass to fetch handler
@@ -10,13 +11,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 +61,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 +69,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>;
 }
 /**
  *
@@ -75,8 +92,10 @@ export declare class FetchHandler extends AbstractMessageHandler implements IFet
      */
     constructor(_packerMgr: IPackageManager, opts?: {
         credentialWallet: ICredentialWallet;
+        onchainIssuer?: IOnchainIssuer | undefined;
     } | undefined);
     handle(message: BasicMessage, ctx: FetchMessageHandlerOptions): Promise<BasicMessage | null>;
+    private handleOnchainOfferMessage;
     private handleOfferMessage;
     /**
      * Handles only messages with credentials/1.0/offer type
@@ -88,16 +107,21 @@ export declare class FetchHandler extends AbstractMessageHandler implements IFet
      * @returns `Promise<W3CCredential[]>`
      */
     handleCredentialOffer(offer: Uint8Array, opts?: FetchHandlerOptions): Promise<W3CCredential[]>;
+    /**
+     * Handles only messages with credentials/1.0/onchain-offer type
+     * @beta
+     */
+    handleOnchainOffer(offer: Uint8Array): Promise<W3CCredential[]>;
     private handleFetchRequest;
     /**
      * @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,43 @@ 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>;
+export declare function convertPaymentAmount(amount: string, currency: SupportedCurrencies): Promise<bigint>;
+/**
+ * @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: string;
+    currency: SupportedCurrencies | string;
+    chainId: string;
+    expirationDate?: Date;
+    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 +89,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 +149,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

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

@@ -29,6 +29,9 @@ export type JsonDocumentObject = {
  * JSON document object allowed values
  */
 export type JsonDocumentObjectValue = string | number | boolean | JsonDocumentObject | JsonDocumentObjectValue[];
+/**
+ * Basic message with all possible fields optional
+ */
 export type BasicMessage = {
     id: string;
     typ?: MediaType;
@@ -37,6 +40,15 @@ export type BasicMessage = {
     body?: unknown;
     from?: string;
     to?: string;
+    created_time?: number;
+    expires_time?: number;
+};
+/**
+ * Basic message with all possible fields required
+ */
+export type RequiredBasicMessage = Omit<Required<BasicMessage>, 'created_time' | 'expires_time'> & {
+    created_time?: number;
+    expires_time?: number;
 };
 /**
  *  parameters for any packer
@@ -111,6 +123,19 @@ export interface IPacker {
      * @returns The media type as a MediaType.
      */
     mediaType(): MediaType;
+    /**
+     * gets packer envelope (supported profiles) with options
+     *
+     * @returns {string}
+     */
+    getSupportedProfiles(): string[];
+    /**
+     * returns true if profile is supported by packer
+     *
+     * @param {string} profile
+     * @returns {boolean}
+     */
+    isProfileSupported(profile: string): boolean;
 }
 /**
  * Params for verification of auth circuit public signals

package/dist/types/iden3comm/types/protocol/accept-profile.d.ts

@@ -0,0 +1,7 @@
+import { AcceptAuthCircuits, AcceptJwsAlgorithms, AcceptJwzAlgorithms, MediaType, ProtocolVersion } from '../../constants';
+export type AcceptProfile = {
+    protocolVersion: ProtocolVersion;
+    env: MediaType;
+    circuits?: AcceptAuthCircuits[];
+    alg?: AcceptJwsAlgorithms[] | AcceptJwzAlgorithms[];
+};

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

@@ -31,6 +31,7 @@ export type AuthorizationRequestMessageBody = {
     message?: string;
     did_doc?: DIDDocument;
     scope: Array<ZeroKnowledgeProofRequest>;
+    accept?: string[];
 };
 /** ZeroKnowledgeProofRequest represents structure of zkp request object */
 export type ZeroKnowledgeProofRequest = {

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

@@ -1,6 +1,6 @@
 import { W3CCredential } from '../../../verifiable';
 import { PROTOCOL_MESSAGE_TYPE } from '../../constants';
-import { BasicMessage, JsonDocumentObject } from '../packer';
+import { BasicMessage, JsonDocumentObject, RequiredBasicMessage } from '../packer';
 import { ContractInvokeTransactionData } from './contract-request';
 /** CredentialIssuanceRequestMessageBody represents data for credential issuance request */
 export type CredentialIssuanceRequestMessageBody = {
@@ -9,12 +9,12 @@ export type CredentialIssuanceRequestMessageBody = {
     expiration: number;
 };
 /** CredentialIssuanceRequestMessage represent Iden3message for credential request */
-export type CredentialIssuanceRequestMessage = Required<BasicMessage> & {
+export type CredentialIssuanceRequestMessage = RequiredBasicMessage & {
     body: CredentialIssuanceRequestMessageBody;
     type: typeof PROTOCOL_MESSAGE_TYPE.CREDENTIAL_ISSUANCE_REQUEST_MESSAGE_TYPE;
 };
 /** CredentialsOfferMessage represent Iden3message for credential offer */
-export type CredentialsOfferMessage = Required<BasicMessage> & {
+export type CredentialsOfferMessage = RequiredBasicMessage & {
     body: CredentialsOfferMessageBody;
     type: typeof PROTOCOL_MESSAGE_TYPE.CREDENTIAL_OFFER_MESSAGE_TYPE;
 };
@@ -24,7 +24,7 @@ export type CredentialsOfferMessageBody = {
     credentials: CredentialOffer[];
 };
 /** CredentialsOnchainOfferMessage represent Iden3message for credential onchain offer message */
-export type CredentialsOnchainOfferMessage = Required<BasicMessage> & {
+export type CredentialsOnchainOfferMessage = RequiredBasicMessage & {
     body: CredentialsOnchainOfferMessageBody;
     type: typeof PROTOCOL_MESSAGE_TYPE.CREDENTIAL_ONCHAIN_OFFER_MESSAGE_TYPE;
 };
@@ -46,7 +46,7 @@ export type CredentialOffer = {
     status?: CredentialOfferStatus;
 };
 /** CredentialIssuanceMessage represent Iden3message for credential issuance */
-export type CredentialIssuanceMessage = Required<BasicMessage> & {
+export type CredentialIssuanceMessage = RequiredBasicMessage & {
     body: IssuanceMessageBody;
     type: typeof PROTOCOL_MESSAGE_TYPE.CREDENTIAL_ISSUANCE_RESPONSE_MESSAGE_TYPE;
 };
@@ -70,7 +70,7 @@ export type Schema = {
     type: string;
 };
 /** CredentialRefreshMessage represent Iden3message for credential refresh request */
-export type CredentialRefreshMessage = Required<BasicMessage> & {
+export type CredentialRefreshMessage = RequiredBasicMessage & {
     body: CredentialRefreshMessageBody;
     type: typeof PROTOCOL_MESSAGE_TYPE.CREDENTIAL_REFRESH_MESSAGE_TYPE;
 };

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

@@ -1,7 +1,7 @@
-import { BasicMessage } from '../';
+import { RequiredBasicMessage } from '../';
 import { PROTOCOL_MESSAGE_TYPE } from '../../constants';
 /**  MessageFetchRequestMessage represent Iden3message for message fetch request. */
-export type MessageFetchRequestMessage = Required<BasicMessage> & {
+export type MessageFetchRequestMessage = RequiredBasicMessage & {
     body: MessageFetchRequestMessageBody;
     type: typeof PROTOCOL_MESSAGE_TYPE.CREDENTIAL_FETCH_REQUEST_MESSAGE_TYPE;
 };

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

@@ -1,5 +1,5 @@
 import { BasicMessage } from '../';
-import { PaymentRequestDataType, PaymentRequestType, PaymentType, SupportedCurrencies } from '../../../verifiable';
+import { PaymentFeatures, PaymentRequestDataType, SupportedCurrencies, SupportedPaymentProofType } from '../../../verifiable';
 import { PROTOCOL_MESSAGE_TYPE } from '../../constants';
 /** @beta PaymentRequestMessage is struct the represents payment-request message */
 export type PaymentRequestMessage = BasicMessage & {
@@ -17,20 +17,52 @@ export type PaymentRequestInfo = {
         type: string;
         context: string;
     }[];
-    type: PaymentRequestType;
-    data: PaymentRequestDataInfo;
-    expiration?: string;
+    data: Iden3PaymentRequestCryptoV1 | (Iden3PaymentRequestCryptoV1 | Iden3PaymentRailsRequestV1 | Iden3PaymentRailsERC20RequestV1)[];
     description?: string;
 };
-/** @beta PaymentRequestDataInfo is struct the represents payment data info for payment-request */
-export type PaymentRequestDataInfo = {
-    type: PaymentRequestDataType;
+/** @beta Iden3PaymentRequestCryptoV1 is struct the represents payment data info for payment-request */
+export type Iden3PaymentRequestCryptoV1 = {
+    type: PaymentRequestDataType.Iden3PaymentRequestCryptoV1;
+    '@context'?: string | (string | object)[];
     amount: string;
     id: string;
     chainId: string;
     address: string;
-    currency: SupportedCurrencies;
-    signature?: string;
+    currency: SupportedCurrencies | string;
+    expiration?: string;
+};
+export type Iden3PaymentRailsRequestV1 = {
+    type: PaymentRequestDataType.Iden3PaymentRailsRequestV1;
+    '@context': string | (string | object)[];
+    recipient: string;
+    amount: string;
+    currency: SupportedCurrencies | string;
+    expirationDate: string;
+    nonce: string;
+    metadata: string;
+    proof: EthereumEip712Signature2021 | EthereumEip712Signature2021[];
+};
+export type Iden3PaymentRailsERC20RequestV1 = Omit<Required<Iden3PaymentRailsRequestV1>, 'type'> & {
+    tokenAddress: string;
+    features?: PaymentFeatures[];
+    type: PaymentRequestDataType.Iden3PaymentRailsERC20RequestV1;
+};
+export type EthereumEip712Signature2021 = {
+    type: SupportedPaymentProofType.EthereumEip712Signature2021;
+    proofPurpose: string;
+    proofValue: string;
+    verificationMethod: string;
+    created: string;
+    eip712: {
+        types: string;
+        primaryType: string;
+        domain: {
+            name: string;
+            version: string;
+            chainId: string;
+            verifyingContract: string;
+        };
+    };
 };
 /** @beta  PaymentMessage is struct the represents payment message */
 export type PaymentMessage = BasicMessage & {
@@ -39,13 +71,55 @@ export type PaymentMessage = BasicMessage & {
 };
 /** @beta  PaymentMessageBody is struct the represents body for payment message */
 export type PaymentMessageBody = {
-    payments: PaymentInfo[];
+    payments: PaymentTypeUnion[];
 };
-/** @beta PaymentInfo is struct the represents payment info for payment */
-export type PaymentInfo = {
+/** @beta Iden3PaymentCryptoV1 is struct the represents payment info for payment */
+export type Iden3PaymentCryptoV1 = {
     id: string;
-    type: PaymentType;
+    type: 'Iden3PaymentCryptoV1';
+    '@context'?: string | (string | object)[];
+    paymentData: {
+        txId: string;
+    };
+};
+/** @beta Iden3PaymentRailsV1 is struct the represents payment info for Iden3PaymentRailsRequestV1 */
+export type Iden3PaymentRailsV1 = {
+    nonce: string;
+    type: 'Iden3PaymentRailsV1';
+    '@context': string | (string | object)[];
     paymentData: {
         txId: string;
+        chainId: string;
     };
 };
+/** @beta Iden3PaymentRailsERC20V1 is struct the represents payment info for Iden3PaymentRailsERC20RequestV1 */
+export type Iden3PaymentRailsERC20V1 = {
+    nonce: string;
+    type: 'Iden3PaymentRailsERC20V1';
+    '@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;
+    paymentContract: string;
+    recipient: string;
+    erc20TokenAddressArr: {
+        symbol: string;
+        address: string;
+    }[];
+};
+/**
+ * @beta
+ * PaymentRequestTypeUnion is a type of supported payment request types
+ */
+export type PaymentRequestTypeUnion = Iden3PaymentRequestCryptoV1 | Iden3PaymentRailsRequestV1 | Iden3PaymentRailsERC20RequestV1;
+/**
+ * @beta
+ * PaymentTypeUnion is a type of supported payment types
+ */
+export type PaymentTypeUnion = Iden3PaymentCryptoV1 | Iden3PaymentRailsV1 | Iden3PaymentRailsERC20V1;

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

@@ -1,8 +1,8 @@
-import { BasicMessage } from '../';
+import { RequiredBasicMessage } from '../';
 import { PROTOCOL_MESSAGE_TYPE } from '../../constants';
 import { ZeroKnowledgeProofRequest, ZeroKnowledgeProofResponse } from './auth';
 /** ProofGenerationRequestMessage is struct the represents body for proof generation request */
-export type ProofGenerationRequestMessage = Required<BasicMessage> & {
+export type ProofGenerationRequestMessage = RequiredBasicMessage & {
     body: ProofGenerationRequestMessageBody;
     type: typeof PROTOCOL_MESSAGE_TYPE.PROOF_GENERATION_REQUEST_MESSAGE_TYPE;
 };
@@ -11,7 +11,7 @@ export type ProofGenerationRequestMessageBody = {
     scope: Array<ZeroKnowledgeProofRequest>;
 };
 /** ProofGenerationResponseMessage is struct the represents body for proof generation request */
-export type ProofGenerationResponseMessage = Required<BasicMessage> & {
+export type ProofGenerationResponseMessage = RequiredBasicMessage & {
     body: ResponseMessageBody;
     type: typeof PROTOCOL_MESSAGE_TYPE.PROOF_GENERATION_RESPONSE_MESSAGE_TYPE;
 };

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

@@ -1,4 +1,4 @@
-import { BasicMessage } from '../';
+import { BasicMessage, RequiredBasicMessage } from '../';
 import { RevocationStatus } from '../../../verifiable';
 import { PROTOCOL_MESSAGE_TYPE } from '../../constants';
 /** RevocationStatusRequestMessage is struct the represents body for proof generation request */
@@ -11,7 +11,7 @@ export type RevocationStatusRequestMessageBody = {
     revocation_nonce: number;
 };
 /** RevocationStatusResponseMessage is struct the represents body for proof generation request */
-export type RevocationStatusResponseMessage = Required<BasicMessage> & {
+export type RevocationStatusResponseMessage = RequiredBasicMessage & {
     body: RevocationStatusResponseMessageBody;
     type: typeof PROTOCOL_MESSAGE_TYPE.REVOCATION_STATUS_RESPONSE_MESSAGE_TYPE;
 };

package/dist/types/iden3comm/utils/accept-profile.d.ts

@@ -0,0 +1,3 @@
+import { AcceptProfile } from '../types';
+export declare const buildAccept: (profiles: AcceptProfile[]) => string[];
+export declare const parseAcceptProfile: (profile: string) => AcceptProfile;

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

@@ -1,3 +1,4 @@
 export * from './envelope';
 export * from './message';
 export * from './did';
+export * from './accept-profile';

package/dist/types/storage/blockchain/did-resolver-readonly-storage.d.ts

@@ -0,0 +1,16 @@
+import { RootInfo, StateInfo, StateProof } from '../entities';
+import { IStateStorage } from '../interfaces';
+import { JsonRpcProvider } from 'ethers';
+export declare class DidResolverStateReadonlyStorage implements IStateStorage {
+    private readonly resolverUrl;
+    constructor(resolverUrl: string);
+    getLatestStateById(id: bigint): Promise<StateInfo>;
+    getStateInfoByIdAndState(id: bigint, state: bigint): Promise<StateInfo>;
+    getGISTProof(id: bigint): Promise<StateProof>;
+    getGISTRootInfo(root: bigint, userId: bigint): Promise<RootInfo>;
+    getRpcProvider(): JsonRpcProvider;
+    publishState(): Promise<string>;
+    publishStateGeneric(): Promise<string>;
+    private getStateInfo;
+    private getIden3StateInfo2023;
+}