@0xpolygonid/js-sdk 1.21.3 → 1.23.0

package/dist/browser/esm/index.js

@@ -1,4 +1,4 @@
-import { DID, buildDIDType, Id as Id$1, genesisFromEthAddress, BytesHelper, checkBigIntInField, Claim, SchemaHash, ClaimOptions, MerklizedRootPosition as MerklizedRootPosition$1, IdPosition, getChainId, ChainIds, getUnixTimestamp, getDateFromUnixTimestamp, DidMethod, Blockchain, NetworkId } from '@iden3/js-iden3-core';
+import { DID, buildDIDType, Id as Id$1, genesisFromEthAddress, BytesHelper, checkBigIntInField, Claim, SchemaHash, ClaimOptions, MerklizedRootPosition as MerklizedRootPosition$1, IdPosition, getChainId, getUnixTimestamp, ChainIds, getDateFromUnixTimestamp, DidMethod, Blockchain, NetworkId } from '@iden3/js-iden3-core';
 import * as jsIden3Core from '@iden3/js-iden3-core';
 export { jsIden3Core as core };
 import { Path, Merklizer, getDocumentLoader } from '@iden3/js-jsonld-merklization';
@@ -7785,15 +7785,6 @@ var RefreshServiceType;
 (function (RefreshServiceType) {
     RefreshServiceType["Iden3RefreshService2023"] = "Iden3RefreshService2023";
 })(RefreshServiceType || (RefreshServiceType = {}));
-/**
- * PaymentRequestType type for payment requests
- * @beta
- * @enum {string}
- */
-var PaymentRequestType;
-(function (PaymentRequestType) {
-    PaymentRequestType["PaymentRequest"] = "PaymentRequest";
-})(PaymentRequestType || (PaymentRequestType = {}));
 /**
  * PaymentRequestDataType type for payment requests
  * @beta
@@ -7802,6 +7793,8 @@ var PaymentRequestType;
 var PaymentRequestDataType;
 (function (PaymentRequestDataType) {
     PaymentRequestDataType["Iden3PaymentRequestCryptoV1"] = "Iden3PaymentRequestCryptoV1";
+    PaymentRequestDataType["Iden3PaymentRailsRequestV1"] = "Iden3PaymentRailsRequestV1";
+    PaymentRequestDataType["Iden3PaymentRailsERC20RequestV1"] = "Iden3PaymentRailsERC20RequestV1";
 })(PaymentRequestDataType || (PaymentRequestDataType = {}));
 /**
  * PaymentType type for payment responses
@@ -7811,17 +7804,41 @@ var PaymentRequestDataType;
 var PaymentType;
 (function (PaymentType) {
     PaymentType["Iden3PaymentCryptoV1"] = "Iden3PaymentCryptoV1";
+    PaymentType["Iden3PaymentRailsV1"] = "Iden3PaymentRailsV1";
+    PaymentType["Iden3PaymentRailsERC20V1"] = "Iden3PaymentRailsERC20V1";
 })(PaymentType || (PaymentType = {}));
+/**
+ * SupportedPaymentProofType type for payment proofs
+ * @beta
+ * @enum {string}
+ */
+var SupportedPaymentProofType;
+(function (SupportedPaymentProofType) {
+    SupportedPaymentProofType["EthereumEip712Signature2021"] = "EthereumEip712Signature2021";
+})(SupportedPaymentProofType || (SupportedPaymentProofType = {}));
 /**
  * Media types for Payment supported currencies
  * @beta
- * @enum {number}
+ * @enum {string}
  */
 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}
+ */
+var PaymentFeatures;
+(function (PaymentFeatures) {
+    PaymentFeatures["EIP_2612"] = "EIP-2612";
+})(PaymentFeatures || (PaymentFeatures = {}));
 /**
  * DisplayMethodType type for display method
  *
@@ -39847,6 +39864,12 @@ class TypedDataEncoder {
         };
     }
 }
+/**
+ *  Compute the address used to sign the typed data for the %%signature%%.
+ */
+function verifyTypedData(domain, types, value, signature) {
+    return recoverAddress(TypedDataEncoder.hash(domain, types, value), signature);
+}
 
 /**
  *  A fragment is a single item from an ABI, which may represent any of:
@@ -51324,7 +51347,7 @@ class LinkedMultiQueryPubSignals {
     }
 }
 
-var abi$2 = [
+var abi$3 = [
 	{
 		inputs: [
 		],
@@ -52438,7 +52461,7 @@ class EthStateStorage {
         this.ethConfig = ethConfig;
         const config = Array.isArray(ethConfig) ? ethConfig[0] : ethConfig;
         this.provider = new JsonRpcProvider(config.url);
-        this.stateContract = new Contract(config.contractAddress, abi$2, this.provider);
+        this.stateContract = new Contract(config.contractAddress, abi$3, this.provider);
         this._transactionService = new TransactionService(this.getRpcProvider());
     }
     /** {@inheritdoc IStateStorage.getLatestStateById} */
@@ -52578,7 +52601,7 @@ class EthStateStorage {
         const chainId = getChainId(DID.blockchainFromId(idTyped), DID.networkIdFromId(idTyped));
         const config = this.networkByChainId(chainId);
         const provider = new JsonRpcProvider(config.url);
-        const stateContract = new Contract(config.contractAddress, abi$2, provider);
+        const stateContract = new Contract(config.contractAddress, abi$3, provider);
         return { stateContract, provider };
     }
     networkByChainId(chainId) {
@@ -52591,7 +52614,7 @@ class EthStateStorage {
     }
 }
 
-var abi$1 = [
+var abi$2 = [
 	{
 		inputs: [
 		],
@@ -53491,7 +53514,7 @@ class OnChainZKPVerifier {
         const maxPriorityFeePerGas = chainConfig.maxPriorityFeePerGas
             ? BigInt(chainConfig.maxPriorityFeePerGas)
             : feeData.maxPriorityFeePerGas;
-        const verifierContract = new Contract(txData.contract_address, abi$1);
+        const verifierContract = new Contract(txData.contract_address, abi$2);
         for (const zkProofResponse of zkProofResponses) {
             const txArgs = await this.prepareTxArgsSubmitV1(txData, zkProofResponse);
             const payload = await verifierContract.submitZKPResponse.populateTransaction(...txArgs);
@@ -53539,7 +53562,7 @@ class OnChainZKPVerifier {
         const maxPriorityFeePerGas = chainConfig.maxPriorityFeePerGas
             ? BigInt(chainConfig.maxPriorityFeePerGas)
             : feeData.maxPriorityFeePerGas;
-        const verifierContract = new Contract(txData.contract_address, abi$1);
+        const verifierContract = new Contract(txData.contract_address, abi$2);
         const txRequestData = await verifierContract.submitZKPResponseV2.populateTransaction(...txDataArgs);
         const request = {
             to: txData.contract_address,
@@ -53732,7 +53755,7 @@ class OnChainZKPVerifier {
     }
 }
 
-var abi = [
+var abi$1 = [
 	{
 		inputs: [
 		],
@@ -54020,7 +54043,7 @@ class OnChainRevocationStorage {
         this._config = _config;
         this._signer = _signer;
         this._provider = new JsonRpcProvider(_config.url);
-        let contract = new Contract(contractAddress, abi, this._provider);
+        let contract = new Contract(contractAddress, abi$1, this._provider);
         if (this._signer) {
             this._signer = this._signer.connect(this._provider);
             contract = contract.connect(this._signer);
@@ -54101,6 +54124,575 @@ class OnChainRevocationStorage {
     }
 }
 
+var abi = [
+	{
+		inputs: [
+		],
+		name: "ECDSAInvalidSignature",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "uint256",
+				name: "length",
+				type: "uint256"
+			}
+		],
+		name: "ECDSAInvalidSignatureLength",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "bytes32",
+				name: "s",
+				type: "bytes32"
+			}
+		],
+		name: "ECDSAInvalidSignatureS",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "spender",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "allowance",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "needed",
+				type: "uint256"
+			}
+		],
+		name: "ERC20InsufficientAllowance",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "sender",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "balance",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "needed",
+				type: "uint256"
+			}
+		],
+		name: "ERC20InsufficientBalance",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "approver",
+				type: "address"
+			}
+		],
+		name: "ERC20InvalidApprover",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "receiver",
+				type: "address"
+			}
+		],
+		name: "ERC20InvalidReceiver",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "sender",
+				type: "address"
+			}
+		],
+		name: "ERC20InvalidSender",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "spender",
+				type: "address"
+			}
+		],
+		name: "ERC20InvalidSpender",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "uint256",
+				name: "deadline",
+				type: "uint256"
+			}
+		],
+		name: "ERC2612ExpiredSignature",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "signer",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "owner",
+				type: "address"
+			}
+		],
+		name: "ERC2612InvalidSigner",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "account",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "currentNonce",
+				type: "uint256"
+			}
+		],
+		name: "InvalidAccountNonce",
+		type: "error"
+	},
+	{
+		inputs: [
+		],
+		name: "InvalidShortString",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "string",
+				name: "str",
+				type: "string"
+			}
+		],
+		name: "StringTooLong",
+		type: "error"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "address",
+				name: "owner",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "spender",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "value",
+				type: "uint256"
+			}
+		],
+		name: "Approval",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+		],
+		name: "EIP712DomainChanged",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "address",
+				name: "from",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "to",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "value",
+				type: "uint256"
+			}
+		],
+		name: "Transfer",
+		type: "event"
+	},
+	{
+		inputs: [
+		],
+		name: "DOMAIN_SEPARATOR",
+		outputs: [
+			{
+				internalType: "bytes32",
+				name: "",
+				type: "bytes32"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "owner",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "spender",
+				type: "address"
+			}
+		],
+		name: "allowance",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "spender",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "value",
+				type: "uint256"
+			}
+		],
+		name: "approve",
+		outputs: [
+			{
+				internalType: "bool",
+				name: "",
+				type: "bool"
+			}
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "account",
+				type: "address"
+			}
+		],
+		name: "balanceOf",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "decimals",
+		outputs: [
+			{
+				internalType: "uint8",
+				name: "",
+				type: "uint8"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "eip712Domain",
+		outputs: [
+			{
+				internalType: "bytes1",
+				name: "fields",
+				type: "bytes1"
+			},
+			{
+				internalType: "string",
+				name: "name",
+				type: "string"
+			},
+			{
+				internalType: "string",
+				name: "version",
+				type: "string"
+			},
+			{
+				internalType: "uint256",
+				name: "chainId",
+				type: "uint256"
+			},
+			{
+				internalType: "address",
+				name: "verifyingContract",
+				type: "address"
+			},
+			{
+				internalType: "bytes32",
+				name: "salt",
+				type: "bytes32"
+			},
+			{
+				internalType: "uint256[]",
+				name: "extensions",
+				type: "uint256[]"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "name",
+		outputs: [
+			{
+				internalType: "string",
+				name: "",
+				type: "string"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "owner",
+				type: "address"
+			}
+		],
+		name: "nonces",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "owner",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "spender",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "value",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "deadline",
+				type: "uint256"
+			},
+			{
+				internalType: "uint8",
+				name: "v",
+				type: "uint8"
+			},
+			{
+				internalType: "bytes32",
+				name: "r",
+				type: "bytes32"
+			},
+			{
+				internalType: "bytes32",
+				name: "s",
+				type: "bytes32"
+			}
+		],
+		name: "permit",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "symbol",
+		outputs: [
+			{
+				internalType: "string",
+				name: "",
+				type: "string"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "totalSupply",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "to",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "value",
+				type: "uint256"
+			}
+		],
+		name: "transfer",
+		outputs: [
+			{
+				internalType: "bool",
+				name: "",
+				type: "bool"
+			}
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "from",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "to",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "value",
+				type: "uint256"
+			}
+		],
+		name: "transferFrom",
+		outputs: [
+			{
+				internalType: "bool",
+				name: "",
+				type: "bool"
+			}
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	}
+];
+
+/**
+ * @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>}
+ */
+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);
+}
+
 /**
  * Type of MerkleTree
  *
@@ -55588,16 +56180,45 @@ const SUPPORTED_PUBLIC_KEY_TYPES = {
         'JsonWebKey2020'
     ]
 };
+var ProtocolVersion;
+(function (ProtocolVersion) {
+    ProtocolVersion["V1"] = "iden3comm/v1";
+})(ProtocolVersion || (ProtocolVersion = {}));
+var AcceptAuthCircuits;
+(function (AcceptAuthCircuits) {
+    AcceptAuthCircuits["AuthV2"] = "authV2";
+    AcceptAuthCircuits["AuthV3"] = "authV3";
+})(AcceptAuthCircuits || (AcceptAuthCircuits = {}));
+var AcceptJwzAlgorithms;
+(function (AcceptJwzAlgorithms) {
+    AcceptJwzAlgorithms["Groth16"] = "groth16";
+})(AcceptJwzAlgorithms || (AcceptJwzAlgorithms = {}));
+var AcceptJwsAlgorithms;
+(function (AcceptJwsAlgorithms) {
+    AcceptJwsAlgorithms["ES256K"] = "ES256K";
+    AcceptJwsAlgorithms["ES256KR"] = "ES256K-R";
+})(AcceptJwsAlgorithms || (AcceptJwsAlgorithms = {}));
+const defaultAcceptProfile = {
+    protocolVersion: ProtocolVersion.V1,
+    env: MediaType.ZKPMessage,
+    circuits: [AcceptAuthCircuits.AuthV2],
+    alg: [AcceptJwzAlgorithms.Groth16]
+};
 const DEFAULT_PROOF_VERIFY_DELAY = 1 * 60 * 60 * 1000; // 1 hour
 const DEFAULT_AUTH_VERIFY_DELAY = 5 * 60 * 1000; // 5 minutes
 
 var constants = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    get AcceptAuthCircuits () { return AcceptAuthCircuits; },
+    get AcceptJwsAlgorithms () { return AcceptJwsAlgorithms; },
+    get AcceptJwzAlgorithms () { return AcceptJwzAlgorithms; },
     DEFAULT_AUTH_VERIFY_DELAY: DEFAULT_AUTH_VERIFY_DELAY,
     DEFAULT_PROOF_VERIFY_DELAY: DEFAULT_PROOF_VERIFY_DELAY,
     get MediaType () { return MediaType; },
     PROTOCOL_MESSAGE_TYPE: PROTOCOL_MESSAGE_TYPE,
-    SUPPORTED_PUBLIC_KEY_TYPES: SUPPORTED_PUBLIC_KEY_TYPES
+    get ProtocolVersion () { return ProtocolVersion; },
+    SUPPORTED_PUBLIC_KEY_TYPES: SUPPORTED_PUBLIC_KEY_TYPES,
+    defaultAcceptProfile: defaultAcceptProfile
 });
 
 /**
@@ -56721,6 +57342,18 @@ class PackageManager {
     constructor() {
         this.packers = new Map();
     }
+    /** {@inheritDoc IPackageManager.isProfileSupported} */
+    isProfileSupported(mediaType, profile) {
+        const p = this.packers.get(mediaType);
+        if (!p) {
+            return false;
+        }
+        return p.isProfileSupported(profile);
+    }
+    /** {@inheritDoc IPackageManager.getSupportedMediaTypes} */
+    getSupportedMediaTypes() {
+        return [...this.packers.keys()];
+    }
     /** {@inheritDoc IPackageManager.registerPackers} */
     registerPackers(packers) {
         packers.forEach((p) => {
@@ -56793,212 +57426,6 @@ class PackageManager {
     }
 }
 
-const { getProvingMethod } = proving;
-/**
- * Handler to
- *
- * @public
- * @class DataPrepareHandlerFunc
- */
-class DataPrepareHandlerFunc {
-    /**
-     * Creates an instance of DataPrepareHandlerFunc.
-     * @param {AuthDataPrepareFunc} dataPrepareFunc - function that produces marshaled inputs for auth circuits
-     */
-    constructor(dataPrepareFunc) {
-        this.dataPrepareFunc = dataPrepareFunc;
-    }
-    /**
-     *
-     *
-     * @param {Uint8Array} hash - challenge that will be signed
-     * @param {DID} did - did of identity that will prepare inputs
-     * @param {CircuitId} circuitId - circuit id
-     * @returns `Promise<Uint8Array>`
-     */
-    prepare(hash, did, circuitId) {
-        return this.dataPrepareFunc(hash, did, circuitId);
-    }
-}
-/**
- * Handler to verify public signals of authorization circuits
- *
- * @public
- * @class VerificationHandlerFunc
- */
-class VerificationHandlerFunc {
-    /**
-     * Creates an instance of VerificationHandlerFunc.
-     * @param {StateVerificationFunc} stateVerificationFunc - state verification function
-     */
-    constructor(stateVerificationFunc) {
-        this.stateVerificationFunc = stateVerificationFunc;
-    }
-    /**
-     *
-     *
-     * @param {string} id  - id of circuit
-     * @param {Array<string>} pubSignals - signals that must contain user id and state
-     * @returns `Promise<boolean>`
-     */
-    verify(id, pubSignals, opts) {
-        return this.stateVerificationFunc(id, pubSignals, opts);
-    }
-}
-/**
- * Packer that can pack message to JWZ token,
- * and unpack and validate JWZ envelope
- * @public
- * @class ZKPPacker
- * @implements implements IPacker interface
- */
-class ZKPPacker {
-    /**
-     * Creates an instance of ZKPPacker.
-     * @param {Map<string, ProvingParams>} provingParamsMap - string is derived by JSON.parse(ProvingMethodAlg)
-     * @param {Map<string, VerificationParams>} verificationParamsMap - string is derived by JSON.parse(ProvingMethodAlg)
-     */
-    constructor(provingParamsMap, verificationParamsMap, _opts = {
-        acceptedStateTransitionDelay: DEFAULT_AUTH_VERIFY_DELAY
-    }) {
-        this.provingParamsMap = provingParamsMap;
-        this.verificationParamsMap = verificationParamsMap;
-        this._opts = _opts;
-    }
-    /**
-     * Packs a basic message using the specified parameters.
-     * @param msg - The basic message to pack.
-     * @param param - The parameters for the ZKPPacker.
-     * @returns A promise that resolves to a Uint8Array representing the packed message.
-     */
-    packMessage(msg, param) {
-        return this.pack(byteEncoder.encode(JSON.stringify(msg)), param);
-    }
-    /**
-     * creates JSON Web Zeroknowledge token
-     *
-     * @param {Uint8Array} payload - serialized message
-     * @param {ZKPPackerParams} params - sender id and proving alg are required
-     * @returns `Promise<Uint8Array>`
-     */
-    async pack(payload, params) {
-        const provingMethod = await getProvingMethod(params.provingMethodAlg);
-        const provingParams = this.provingParamsMap.get(params.provingMethodAlg.toString());
-        if (!provingParams) {
-            throw new Error(ErrNoProvingMethodAlg);
-        }
-        const token = new Token(provingMethod, byteDecoder.decode(payload), (hash, circuitId) => {
-            return provingParams?.dataPreparer?.prepare(hash, params.senderDID, circuitId);
-        });
-        token.setHeader(Header.Type, MediaType.ZKPMessage);
-        const tokenStr = await token.prove(provingParams.provingKey, provingParams.wasm);
-        return byteEncoder.encode(tokenStr);
-    }
-    /**
-     * validate envelope which is jwz token
-     *
-     * @param {Uint8Array} envelope
-     * @returns `Promise<BasicMessage>`
-     */
-    async unpack(envelope) {
-        const token = await Token.parse(byteDecoder.decode(envelope));
-        const provingMethodAlg = new ProvingMethodAlg(token.alg, token.circuitId);
-        const verificationParams = this.verificationParamsMap.get(provingMethodAlg.toString());
-        if (!verificationParams?.key) {
-            throw new Error(ErrPackedWithUnsupportedCircuit);
-        }
-        const isValid = await token.verify(verificationParams?.key);
-        if (!isValid) {
-            throw new Error(ErrProofIsInvalid);
-        }
-        const verificationResult = await verificationParams?.verificationFn?.verify(token.circuitId, token.zkProof.pub_signals, this._opts);
-        if (!verificationResult) {
-            throw new Error(ErrStateVerificationFailed);
-        }
-        const message = bytesToProtocolMessage(byteEncoder.encode(token.getPayload()));
-        // should throw if error
-        verifySender(token, message);
-        return message;
-    }
-    mediaType() {
-        return MediaType.ZKPMessage;
-    }
-}
-const verifySender = async (token, msg) => {
-    switch (token.circuitId) {
-        case CircuitId.AuthV2:
-            {
-                if (!msg.from) {
-                    throw new Error(ErrSenderNotUsedTokenCreation);
-                }
-                const authSignals = new AuthV2PubSignals().pubSignalsUnmarshal(byteEncoder.encode(JSON.stringify(token.zkProof.pub_signals)));
-                const did = DID.parseFromId(authSignals.userID);
-                const msgHash = await token.getMessageHash();
-                const challenge = BytesHelper.bytesToInt(msgHash.reverse());
-                if (challenge !== authSignals.challenge) {
-                    throw new Error(ErrSenderNotUsedTokenCreation);
-                }
-                if (msg.from !== did.string()) {
-                    throw new Error(ErrSenderNotUsedTokenCreation);
-                }
-            }
-            break;
-        default:
-            throw new Error(ErrUnknownCircuitID);
-    }
-};
-
-/**
- * Plain packer just serializes bytes to JSON and adds media type
- *
- * @public
- * @class PlainPacker
- * @implements implements IPacker interface
- */
-class PlainPacker {
-    /**
-     * Packs a basic message using the specified parameters.
-     *
-     * @param msg - The basic message to pack.
-     * @param param - The packer parameters.
-     * @returns A promise that resolves to a Uint8Array representing the packed message.
-     * @throws An error if the method is not implemented.
-     */
-    packMessage(msg) {
-        msg.typ = MediaType.PlainMessage;
-        return Promise.resolve(byteEncoder.encode(JSON.stringify(msg)));
-    }
-    /**
-     * Pack returns packed message to transport envelope
-     *
-     * @param {Uint8Array} payload - json message serialized
-     * @param {PlainPackerParams} _params - not used here
-     * @returns `Promise<Uint8Array>`
-     */
-    async pack(payload) {
-        const msg = JSON.parse(byteDecoder.decode(payload));
-        msg.typ = MediaType.PlainMessage;
-        return Promise.resolve(byteEncoder.encode(JSON.stringify(msg)));
-    }
-    /**
-     * Unpack returns unpacked message from transport envelope
-     *
-     * @param {Uint8Array} envelope - packed envelope (serialized json with media type)
-     * @returns `Promise<BasicMessage>`
-     */
-    async unpack(envelope) {
-        return JSON.parse(byteDecoder.decode(envelope));
-    }
-    /**
-     * returns media type for plain message
-     *
-     * @returns MediaType
-     */
-    mediaType() {
-        return MediaType.PlainMessage;
-    }
-}
-
 const DIDAuthenticationSection = 'authentication';
 const resolveVerificationMethods = (didDocument) => {
     const vms = didDocument.verificationMethod || [];
@@ -57055,6 +57482,356 @@ const extractPublicKeyBytes = (vm) => {
     return { publicKeyBytes: null };
 };
 
+function isProtocolVersion(value) {
+    return Object.values(ProtocolVersion).includes(value);
+}
+function isMediaType(value) {
+    return Object.values(MediaType).includes(value);
+}
+function isAcceptAuthCircuits(value) {
+    return Object.values(AcceptAuthCircuits).includes(value);
+}
+function isAcceptJwsAlgorithms(value) {
+    return Object.values(AcceptJwsAlgorithms).includes(value);
+}
+function isAcceptJwzAlgorithms(value) {
+    return Object.values(AcceptJwzAlgorithms).includes(value);
+}
+const buildAccept = (profiles) => {
+    const result = [];
+    for (const profile of profiles) {
+        let accept = `${profile.protocolVersion};env=${profile.env}`;
+        if (profile.circuits?.length) {
+            accept += `;circuitId=${profile.circuits.join(',')}`;
+        }
+        if (profile.alg?.length) {
+            accept += `;alg=${profile.alg.join(',')}`;
+        }
+        result.push(accept);
+    }
+    return result;
+};
+const parseAcceptProfile = (profile) => {
+    const params = profile.split(';');
+    if (params.length < 2) {
+        throw new Error('Invalid accept profile');
+    }
+    const protocolVersion = params[0].trim();
+    if (!isProtocolVersion(protocolVersion)) {
+        throw new Error(`Protocol version '${protocolVersion}' not supported`);
+    }
+    const envParam = params[1].split('=');
+    if (envParam.length !== 2) {
+        throw new Error(`Invalid accept profile 'env' parameter`);
+    }
+    const env = params[1].split('=')[1].trim();
+    if (!isMediaType(env)) {
+        throw new Error(`Envelop '${env}' not supported`);
+    }
+    const circuitsIndex = params.findIndex((i) => i.includes('circuitId='));
+    if (env !== MediaType.ZKPMessage && circuitsIndex > 0) {
+        throw new Error(`Circuits not supported for env '${env}'`);
+    }
+    let circuits = undefined;
+    if (circuitsIndex > 0) {
+        circuits = params[circuitsIndex]
+            .split('=')[1]
+            .split(',')
+            .map((i) => i.trim())
+            .map((i) => {
+            if (!isAcceptAuthCircuits(i)) {
+                throw new Error(`Circuit '${i}' not supported`);
+            }
+            return i;
+        });
+    }
+    const algIndex = params.findIndex((i) => i.includes('alg='));
+    let alg = undefined;
+    if (algIndex > 0) {
+        if (env === MediaType.ZKPMessage) {
+            alg = params[algIndex]
+                .split('=')[1]
+                .split(',')
+                .map((i) => {
+                i = i.trim();
+                if (!isAcceptJwzAlgorithms(i)) {
+                    throw new Error(`Algorithm '${i}' not supported for '${env}'`);
+                }
+                return i;
+            });
+        }
+        else if (env === MediaType.SignedMessage) {
+            alg = params[algIndex]
+                .split('=')[1]
+                .split(',')
+                .map((i) => {
+                i = i.trim();
+                if (!isAcceptJwsAlgorithms(i)) {
+                    throw new Error(`Algorithm '${i}' not supported for '${env}'`);
+                }
+                return i;
+            });
+        }
+        else {
+            throw new Error(`Algorithm not supported for '${env}'`);
+        }
+    }
+    return {
+        protocolVersion,
+        env,
+        circuits,
+        alg
+    };
+};
+
+const { getProvingMethod } = proving;
+/**
+ * Handler to
+ *
+ * @public
+ * @class DataPrepareHandlerFunc
+ */
+class DataPrepareHandlerFunc {
+    /**
+     * Creates an instance of DataPrepareHandlerFunc.
+     * @param {AuthDataPrepareFunc} dataPrepareFunc - function that produces marshaled inputs for auth circuits
+     */
+    constructor(dataPrepareFunc) {
+        this.dataPrepareFunc = dataPrepareFunc;
+    }
+    /**
+     *
+     *
+     * @param {Uint8Array} hash - challenge that will be signed
+     * @param {DID} did - did of identity that will prepare inputs
+     * @param {CircuitId} circuitId - circuit id
+     * @returns `Promise<Uint8Array>`
+     */
+    prepare(hash, did, circuitId) {
+        return this.dataPrepareFunc(hash, did, circuitId);
+    }
+}
+/**
+ * Handler to verify public signals of authorization circuits
+ *
+ * @public
+ * @class VerificationHandlerFunc
+ */
+class VerificationHandlerFunc {
+    /**
+     * Creates an instance of VerificationHandlerFunc.
+     * @param {StateVerificationFunc} stateVerificationFunc - state verification function
+     */
+    constructor(stateVerificationFunc) {
+        this.stateVerificationFunc = stateVerificationFunc;
+    }
+    /**
+     *
+     *
+     * @param {string} id  - id of circuit
+     * @param {Array<string>} pubSignals - signals that must contain user id and state
+     * @returns `Promise<boolean>`
+     */
+    verify(id, pubSignals, opts) {
+        return this.stateVerificationFunc(id, pubSignals, opts);
+    }
+}
+/**
+ * Packer that can pack message to JWZ token,
+ * and unpack and validate JWZ envelope
+ * @public
+ * @class ZKPPacker
+ * @implements implements IPacker interface
+ */
+class ZKPPacker {
+    /**
+     * Creates an instance of ZKPPacker.
+     * @param {Map<string, ProvingParams>} provingParamsMap - string is derived by JSON.parse(ProvingMethodAlg)
+     * @param {Map<string, VerificationParams>} verificationParamsMap - string is derived by JSON.parse(ProvingMethodAlg)
+     */
+    constructor(provingParamsMap, verificationParamsMap, _opts = {
+        acceptedStateTransitionDelay: DEFAULT_AUTH_VERIFY_DELAY
+    }) {
+        this.provingParamsMap = provingParamsMap;
+        this.verificationParamsMap = verificationParamsMap;
+        this._opts = _opts;
+    }
+    /**
+     * Packs a basic message using the specified parameters.
+     * @param msg - The basic message to pack.
+     * @param param - The parameters for the ZKPPacker.
+     * @returns A promise that resolves to a Uint8Array representing the packed message.
+     */
+    packMessage(msg, param) {
+        return this.pack(byteEncoder.encode(JSON.stringify(msg)), param);
+    }
+    /**
+     * creates JSON Web Zeroknowledge token
+     *
+     * @param {Uint8Array} payload - serialized message
+     * @param {ZKPPackerParams} params - sender id and proving alg are required
+     * @returns `Promise<Uint8Array>`
+     */
+    async pack(payload, params) {
+        const provingMethod = await getProvingMethod(params.provingMethodAlg);
+        const provingParams = this.provingParamsMap.get(params.provingMethodAlg.toString());
+        if (!provingParams) {
+            throw new Error(ErrNoProvingMethodAlg);
+        }
+        const token = new Token(provingMethod, byteDecoder.decode(payload), (hash, circuitId) => {
+            return provingParams?.dataPreparer?.prepare(hash, params.senderDID, circuitId);
+        });
+        token.setHeader(Header.Type, MediaType.ZKPMessage);
+        const tokenStr = await token.prove(provingParams.provingKey, provingParams.wasm);
+        return byteEncoder.encode(tokenStr);
+    }
+    /**
+     * validate envelope which is jwz token
+     *
+     * @param {Uint8Array} envelope
+     * @returns `Promise<BasicMessage>`
+     */
+    async unpack(envelope) {
+        const token = await Token.parse(byteDecoder.decode(envelope));
+        const provingMethodAlg = new ProvingMethodAlg(token.alg, token.circuitId);
+        const verificationParams = this.verificationParamsMap.get(provingMethodAlg.toString());
+        if (!verificationParams?.key) {
+            throw new Error(ErrPackedWithUnsupportedCircuit);
+        }
+        const isValid = await token.verify(verificationParams?.key);
+        if (!isValid) {
+            throw new Error(ErrProofIsInvalid);
+        }
+        const verificationResult = await verificationParams?.verificationFn?.verify(token.circuitId, token.zkProof.pub_signals, this._opts);
+        if (!verificationResult) {
+            throw new Error(ErrStateVerificationFailed);
+        }
+        const message = bytesToProtocolMessage(byteEncoder.encode(token.getPayload()));
+        // should throw if error
+        verifySender(token, message);
+        return message;
+    }
+    mediaType() {
+        return MediaType.ZKPMessage;
+    }
+    /** {@inheritDoc IPacker.getSupportedProfiles} */
+    getSupportedProfiles() {
+        return [
+            `env=${this.mediaType()}&alg=${this.getSupportedAlgorithms().join(',')}&circuitIds=${this.getSupportedCircuitIds().join(',')}`
+        ];
+    }
+    /** {@inheritDoc IPacker.isProfileSupported} */
+    isProfileSupported(profile) {
+        const { env, circuits, alg } = parseAcceptProfile(profile);
+        if (env !== this.mediaType()) {
+            return false;
+        }
+        const supportedCircuitIds = this.getSupportedCircuitIds();
+        const circuitIdSupported = !circuits?.length || circuits.some((c) => supportedCircuitIds.includes(c));
+        const supportedAlgArr = this.getSupportedAlgorithms();
+        const algSupported = !alg?.length || alg.some((a) => supportedAlgArr.includes(a));
+        return algSupported && circuitIdSupported;
+    }
+    getSupportedAlgorithms() {
+        return [AcceptJwzAlgorithms.Groth16];
+    }
+    getSupportedCircuitIds() {
+        return [AcceptAuthCircuits.AuthV2];
+    }
+}
+const verifySender = async (token, msg) => {
+    switch (token.circuitId) {
+        case CircuitId.AuthV2:
+            {
+                if (!msg.from) {
+                    throw new Error(ErrSenderNotUsedTokenCreation);
+                }
+                const authSignals = new AuthV2PubSignals().pubSignalsUnmarshal(byteEncoder.encode(JSON.stringify(token.zkProof.pub_signals)));
+                const did = DID.parseFromId(authSignals.userID);
+                const msgHash = await token.getMessageHash();
+                const challenge = BytesHelper.bytesToInt(msgHash.reverse());
+                if (challenge !== authSignals.challenge) {
+                    throw new Error(ErrSenderNotUsedTokenCreation);
+                }
+                if (msg.from !== did.string()) {
+                    throw new Error(ErrSenderNotUsedTokenCreation);
+                }
+            }
+            break;
+        default:
+            throw new Error(ErrUnknownCircuitID);
+    }
+};
+
+/**
+ * Plain packer just serializes bytes to JSON and adds media type
+ *
+ * @public
+ * @class PlainPacker
+ * @implements implements IPacker interface
+ */
+class PlainPacker {
+    /**
+     * Packs a basic message using the specified parameters.
+     *
+     * @param msg - The basic message to pack.
+     * @param param - The packer parameters.
+     * @returns A promise that resolves to a Uint8Array representing the packed message.
+     * @throws An error if the method is not implemented.
+     */
+    packMessage(msg) {
+        msg.typ = MediaType.PlainMessage;
+        return Promise.resolve(byteEncoder.encode(JSON.stringify(msg)));
+    }
+    /**
+     * Pack returns packed message to transport envelope
+     *
+     * @param {Uint8Array} payload - json message serialized
+     * @param {PlainPackerParams} _params - not used here
+     * @returns `Promise<Uint8Array>`
+     */
+    async pack(payload) {
+        const msg = JSON.parse(byteDecoder.decode(payload));
+        msg.typ = MediaType.PlainMessage;
+        return Promise.resolve(byteEncoder.encode(JSON.stringify(msg)));
+    }
+    /**
+     * Unpack returns unpacked message from transport envelope
+     *
+     * @param {Uint8Array} envelope - packed envelope (serialized json with media type)
+     * @returns `Promise<BasicMessage>`
+     */
+    async unpack(envelope) {
+        return JSON.parse(byteDecoder.decode(envelope));
+    }
+    /**
+     * returns media type for plain message
+     *
+     * @returns MediaType
+     */
+    mediaType() {
+        return MediaType.PlainMessage;
+    }
+    /** {@inheritDoc IPacker.getSupportedProfiles} */
+    getSupportedProfiles() {
+        return [`env=${this.mediaType()}`];
+    }
+    /** {@inheritDoc IPacker.isProfileSupported} */
+    isProfileSupported(profile) {
+        const { env, circuits, alg } = parseAcceptProfile(profile);
+        if (env !== this.mediaType()) {
+            return false;
+        }
+        if (circuits) {
+            throw new Error(`Circuits are not supported for ${env} media type`);
+        }
+        if (alg) {
+            throw new Error(`Algorithms are not supported for ${env} media type`);
+        }
+        return true;
+    }
+}
+
 /**
  * Packer that can pack message to JWZ token,
  * and unpack and validate JWZ envelope
@@ -57133,6 +57910,26 @@ class JWSPacker {
     mediaType() {
         return MediaType.SignedMessage;
     }
+    /** {@inheritDoc IPacker.getSupportedProfiles} */
+    getSupportedProfiles() {
+        return [`env=${this.mediaType()}&alg=${this.getSupportedAlgorithms().join(',')}`];
+    }
+    /** {@inheritDoc IPacker.isProfileSupported} */
+    isProfileSupported(profile) {
+        const { env, circuits, alg } = parseAcceptProfile(profile);
+        if (env !== this.mediaType()) {
+            return false;
+        }
+        if (circuits) {
+            throw new Error(`Circuits are not supported for ${env} media type`);
+        }
+        const supportedAlgArr = this.getSupportedAlgorithms();
+        const algSupported = !alg?.length || alg.some((a) => supportedAlgArr.includes(a));
+        return algSupported;
+    }
+    getSupportedAlgorithms() {
+        return [AcceptJwsAlgorithms.ES256K, AcceptJwsAlgorithms.ES256KR];
+    }
     async resolveDidDoc(from) {
         let didDocument;
         try {
@@ -57287,6 +58084,16 @@ const processZeroKnowledgeProofRequests = async (to, requests, from, proofServic
     }
     return zkpResponses;
 };
+/**
+ * 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.
+ */
+const verifyExpiresTime = (message) => {
+    if (message?.expires_time && message.expires_time < getUnixTimestamp(new Date())) {
+        throw new Error('Message expired');
+    }
+};
 
 /**
  * Base implementation of protocol message handler
@@ -57302,6 +58109,9 @@ class AbstractMessageHandler {
         return messageHandler;
     }
     async handle(message, context) {
+        if (!context.allowExpiredMessages) {
+            verifyExpiresTime(message);
+        }
         if (this.nextMessageHandler)
             return this.nextMessageHandler.handle(message, context);
         return Promise.reject('Message handler not provided or message not supported');
@@ -57394,10 +58204,11 @@ class MessageHandler {
  * @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>`
  */
-function createAuthorizationRequest(reason, sender, callbackUrl) {
-    return createAuthorizationRequestWithMessage(reason, '', sender, callbackUrl);
+function createAuthorizationRequest(reason, sender, callbackUrl, opts) {
+    return createAuthorizationRequestWithMessage(reason, '', sender, callbackUrl, opts);
 }
 /**
  *  createAuthorizationRequestWithMessage is a function to create protocol authorization request with explicit message to sign
@@ -57405,9 +58216,10 @@ function createAuthorizationRequest(reason, sender, callbackUrl) {
  * @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>`
  */
-function createAuthorizationRequestWithMessage(reason, message, sender, callbackUrl) {
+function createAuthorizationRequestWithMessage(reason, message, sender, callbackUrl, opts) {
     const uuidv4 = v4();
     const request = {
         id: uuidv4,
@@ -57416,11 +58228,14 @@ function createAuthorizationRequestWithMessage(reason, message, sender, callback
         typ: MediaType.PlainMessage,
         type: PROTOCOL_MESSAGE_TYPE.AUTHORIZATION_REQUEST_MESSAGE_TYPE,
         body: {
+            accept: opts?.accept,
             reason: reason,
             message: message,
             callbackUrl: callbackUrl,
-            scope: []
-        }
+            scope: opts?.scope ?? []
+        },
+        created_time: getUnixTimestamp(new Date()),
+        expires_time: opts?.expires_time ? getUnixTimestamp(opts.expires_time) : undefined
     };
     return request;
 }
@@ -57479,17 +58294,18 @@ class AuthHandler extends AbstractMessageHandler {
         }
         // override sender did if it's explicitly specified in the auth request
         const to = authRequest.to ? DID.parse(authRequest.to) : ctx.senderDid;
-        const mediaType = ctx.mediaType || MediaType.ZKPMessage;
         const guid = v4();
         if (!authRequest.from) {
             throw new Error('auth request should contain from field');
         }
+        const responseType = PROTOCOL_MESSAGE_TYPE.AUTHORIZATION_RESPONSE_MESSAGE_TYPE;
+        const mediaType = this.getSupportedMediaTypeByProfile(ctx, responseType, authRequest.body.accept);
         const from = DID.parse(authRequest.from);
         const responseScope = await processZeroKnowledgeProofRequests(to, authRequest?.body.scope, from, this._proofService, { mediaType, supportedCircuits: this._supportedCircuits });
         return {
             id: guid,
-            typ: ctx.mediaType,
-            type: PROTOCOL_MESSAGE_TYPE.AUTHORIZATION_RESPONSE_MESSAGE_TYPE,
+            typ: mediaType,
+            type: responseType,
             thid: authRequest.thid ?? guid,
             body: {
                 message: authRequest?.body?.message,
@@ -57504,6 +58320,9 @@ class AuthHandler extends AbstractMessageHandler {
      */
     async handleAuthorizationRequest(did, request, opts) {
         const authRequest = await this.parseAuthorizationRequest(request);
+        if (!opts?.allowExpiredMessages) {
+            verifyExpiresTime(authRequest);
+        }
         if (!opts) {
             opts = {
                 mediaType: MediaType.ZKPMessage
@@ -57593,6 +58412,9 @@ class AuthHandler extends AbstractMessageHandler {
      * @inheritdoc IAuthHandler#handleAuthorizationResponse
      */
     async handleAuthorizationResponse(response, request, opts) {
+        if (!opts?.allowExpiredMessages) {
+            verifyExpiresTime(response);
+        }
         const authResp = (await this.handleAuthResponse(response, {
             request,
             acceptedStateTransitionDelay: opts?.acceptedStateTransitionDelay,
@@ -57626,6 +58448,37 @@ class AuthHandler extends AbstractMessageHandler {
             }
         }
     }
+    getSupportedMediaTypeByProfile(ctx, responseType, profile) {
+        let mediaType;
+        if (profile?.length) {
+            const supportedMediaTypes = [];
+            for (const acceptProfile of profile) {
+                // 1. check protocol version
+                const { protocolVersion, env } = parseAcceptProfile(acceptProfile);
+                const responseTypeVersion = Number(responseType.split('/').at(-2));
+                if (protocolVersion !== ProtocolVersion.V1 ||
+                    (protocolVersion === ProtocolVersion.V1 &&
+                        (responseTypeVersion < 1 || responseTypeVersion >= 2))) {
+                    continue;
+                }
+                // 2. check packer support
+                if (this._packerMgr.isProfileSupported(env, acceptProfile)) {
+                    supportedMediaTypes.push(env);
+                }
+            }
+            if (!supportedMediaTypes.length) {
+                throw new Error('no packer with profile which meets `accept` header requirements');
+            }
+            mediaType = supportedMediaTypes[0];
+            if (ctx.mediaType && supportedMediaTypes.includes(ctx.mediaType)) {
+                mediaType = ctx.mediaType;
+            }
+        }
+        else {
+            mediaType = ctx.mediaType || MediaType.ZKPMessage;
+        }
+        return mediaType;
+    }
 }
 
 /**
@@ -57742,6 +58595,9 @@ class FetchHandler extends AbstractMessageHandler {
             throw new Error(`jws packer options are required for ${MediaType.SignedMessage}`);
         }
         const offerMessage = await FetchHandler.unpackMessage(this._packerMgr, offer, PROTOCOL_MESSAGE_TYPE.CREDENTIAL_OFFER_MESSAGE_TYPE);
+        if (!opts?.allowExpiredMessages) {
+            verifyExpiresTime(offerMessage);
+        }
         const result = await this.handleOfferMessage(offerMessage, {
             mediaType: opts?.mediaType,
             headers: opts?.headers,
@@ -57789,8 +58645,11 @@ class FetchHandler extends AbstractMessageHandler {
     /**
      * @inheritdoc IFetchHandler#handleCredentialFetchRequest
      */
-    async handleCredentialFetchRequest(envelope) {
+    async handleCredentialFetchRequest(envelope, opts) {
         const msgRequest = await FetchHandler.unpackMessage(this._packerMgr, envelope, PROTOCOL_MESSAGE_TYPE.CREDENTIAL_FETCH_REQUEST_MESSAGE_TYPE);
+        if (!opts?.allowExpiredMessages) {
+            verifyExpiresTime(msgRequest);
+        }
         const request = await this.handleFetchRequest(msgRequest);
         return this._packerMgr.pack(MediaType.PlainMessage, byteEncoder.encode(JSON.stringify(request)), {});
     }
@@ -57807,8 +58666,11 @@ class FetchHandler extends AbstractMessageHandler {
     /**
      * @inheritdoc IFetchHandler#handleIssuanceResponseMessage
      */
-    async handleIssuanceResponseMessage(envelop) {
+    async handleIssuanceResponseMessage(envelop, opts) {
         const issuanceMsg = await FetchHandler.unpackMessage(this._packerMgr, envelop, PROTOCOL_MESSAGE_TYPE.CREDENTIAL_ISSUANCE_RESPONSE_MESSAGE_TYPE);
+        if (!opts?.allowExpiredMessages) {
+            verifyExpiresTime(issuanceMsg);
+        }
         await this.handleIssuanceResponseMsg(issuanceMsg);
         return Uint8Array.from([]);
     }
@@ -57928,7 +58790,8 @@ class ContractRequestHandler extends AbstractMessageHandler {
             body: {
                 transaction_data: request.body.transaction_data,
                 scope: []
-            }
+            },
+            created_time: getUnixTimestamp(new Date())
         };
         for (const [txHash, zkpResponses] of txHashToZkpResponseMap) {
             for (const zkpResponse of zkpResponses) {
@@ -57952,6 +58815,9 @@ class ContractRequestHandler extends AbstractMessageHandler {
      */
     async handleContractInvokeRequest(did, request, opts) {
         const ciRequest = await this.parseContractInvokeRequest(request);
+        if (!opts.allowExpiredMessages) {
+            verifyExpiresTime(ciRequest);
+        }
         if (ciRequest.body.transaction_data.method_id !== FunctionSignatures.SubmitZKPResponseV1) {
             throw new Error(`please use handle method to work with other method ids`);
         }
@@ -58130,6 +58996,9 @@ class RevocationStatusHandler extends AbstractMessageHandler {
             throw new Error(`jws packer options are required for ${MediaType.SignedMessage}`);
         }
         const rsRequest = await this.parseRevocationStatusRequest(request);
+        if (!opts.allowExpiredMessages) {
+            verifyExpiresTime(rsRequest);
+        }
         const response = await this.handleRevocationStatusRequestMessage(rsRequest, {
             senderDid: did,
             mediaType: opts.mediaType,
@@ -58169,7 +59038,9 @@ function createProposalRequest(sender, receiver, opts) {
         to: receiver.string(),
         typ: MediaType.PlainMessage,
         type: PROTOCOL_MESSAGE_TYPE.PROPOSAL_REQUEST_MESSAGE_TYPE,
-        body: opts
+        body: opts,
+        created_time: getUnixTimestamp(new Date()),
+        expires_time: opts?.expires_time ? getUnixTimestamp(opts.expires_time) : undefined
     };
     return request;
 }
@@ -58181,7 +59052,7 @@ function createProposalRequest(sender, receiver, opts) {
  * @param {Proposal[]} proposals - proposals
  * @returns `Promise<ProposalRequestMessage>`
  */
-function createProposal(sender, receiver, proposals) {
+function createProposal(sender, receiver, proposals, opts) {
     const uuidv4 = v4();
     const request = {
         id: uuidv4,
@@ -58192,7 +59063,9 @@ function createProposal(sender, receiver, proposals) {
         type: PROTOCOL_MESSAGE_TYPE.PROPOSAL_MESSAGE_TYPE,
         body: {
             proposals: proposals || []
-        }
+        },
+        created_time: getUnixTimestamp(new Date()),
+        expires_time: opts?.expires_time ? getUnixTimestamp(opts.expires_time) : undefined
     };
     return request;
 }
@@ -58330,6 +59203,9 @@ class CredentialProposalHandler extends AbstractMessageHandler {
         if (!proposalRequest.from) {
             throw new Error(`failed request. empty 'from' field`);
         }
+        if (!opts?.allowExpiredMessages) {
+            verifyExpiresTime(proposalRequest);
+        }
         const senderDID = DID.parse(proposalRequest.from);
         const message = await this.handleProposalRequestMessage(proposalRequest);
         const response = byteEncoder.encode(JSON.stringify(message));
@@ -58347,6 +59223,9 @@ class CredentialProposalHandler extends AbstractMessageHandler {
      * @inheritdoc ICredentialProposalHandler#handleProposal
      */
     async handleProposal(proposal, opts) {
+        if (!opts?.allowExpiredMessages) {
+            verifyExpiresTime(proposal);
+        }
         if (opts?.proposalRequest && opts.proposalRequest.from !== proposal.to) {
             throw new Error(`sender of the request is not a target of response - expected ${opts.proposalRequest.from}, given ${proposal.to}`);
         }
@@ -58363,7 +59242,7 @@ class CredentialProposalHandler extends AbstractMessageHandler {
  * @param {PaymentRequestInfo[]} payments - payments
  * @returns `PaymentRequestMessage`
  */
-function createPaymentRequest(sender, receiver, agent, payments) {
+function createPaymentRequest(sender, receiver, agent, payments, opts) {
     const uuidv4 = v4();
     const request = {
         id: uuidv4,
@@ -58375,19 +59254,57 @@ function createPaymentRequest(sender, receiver, agent, payments) {
         body: {
             agent,
             payments
-        }
+        },
+        created_time: getUnixTimestamp(new Date()),
+        expires_time: opts?.expires_time ? getUnixTimestamp(opts.expires_time) : undefined
     };
     return request;
 }
+async function verifyEIP712TypedData(data, resolver) {
+    const paymentData = data.type === PaymentRequestDataType.Iden3PaymentRailsRequestV1
+        ? {
+            recipient: data.recipient,
+            amount: data.amount,
+            expirationDate: new Date(data.expirationDate).getTime(),
+            nonce: data.nonce,
+            metadata: '0x'
+        }
+        : {
+            tokenAddress: data.tokenAddress,
+            recipient: data.recipient,
+            amount: data.amount,
+            expirationDate: new Date(data.expirationDate).getTime(),
+            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 = 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
  * 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`
  */
-function createPayment(sender, receiver, payments) {
+function createPayment(sender, receiver, payments, opts) {
     const uuidv4 = v4();
     const request = {
         id: uuidv4,
@@ -58398,7 +59315,9 @@ function createPayment(sender, receiver, payments) {
         type: PROTOCOL_MESSAGE_TYPE.PAYMENT_MESSAGE_TYPE,
         body: {
             payments
-        }
+        },
+        created_time: getUnixTimestamp(new Date()),
+        expires_time: opts?.expires_time ? getUnixTimestamp(opts.expires_time) : undefined
     };
     return request;
 }
@@ -58460,21 +59379,28 @@ class PaymentHandler extends AbstractMessageHandler {
         const receiverDID = DID.parse(paymentRequest.from);
         const payments = [];
         for (let i = 0; i < paymentRequest.body.payments.length; i++) {
-            const paymentReq = paymentRequest.body.payments[i];
-            if (paymentReq.type !== PaymentRequestType.PaymentRequest) {
-                throw new Error(`failed request. not supported '${paymentReq.type}' payment type `);
+            const { data } = paymentRequest.body.payments[i];
+            const selectedPayment = Array.isArray(data)
+                ? data.find((p) => {
+                    return p.type === PaymentRequestDataType.Iden3PaymentRequestCryptoV1
+                        ? p.id === ctx.nonce
+                        : p.nonce === ctx.nonce;
+                })
+                : data;
+            if (!selectedPayment) {
+                throw new Error(`failed request. no payment in request for nonce ${ctx.nonce}`);
             }
-            if (paymentReq.data.type !== PaymentRequestDataType.Iden3PaymentRequestCryptoV1) {
-                throw new Error(`failed request. not supported '${paymentReq.data.type}' payment type `);
+            switch (selectedPayment.type) {
+                case PaymentRequestDataType.Iden3PaymentRequestCryptoV1:
+                    payments.push(await this.handleIden3PaymentRequestCryptoV1(selectedPayment, ctx.paymentHandler));
+                    break;
+                case PaymentRequestDataType.Iden3PaymentRailsRequestV1:
+                    payments.push(await this.handleIden3PaymentRailsRequestV1(selectedPayment, ctx.paymentHandler));
+                    break;
+                case PaymentRequestDataType.Iden3PaymentRailsERC20RequestV1:
+                    payments.push(await this.handleIden3PaymentRailsERC20RequestV1(selectedPayment, ctx.paymentHandler, ctx.erc20TokenApproveHandler));
+                    break;
             }
-            const txId = await ctx.paymentHandler(paymentReq.data);
-            payments.push({
-                id: paymentReq.data.id,
-                type: PaymentType.Iden3PaymentCryptoV1,
-                paymentData: {
-                    txId
-                }
-            });
         }
         const paymentMessage = createPayment(senderDID, receiverDID, payments);
         const response = await this.packMessage(paymentMessage, senderDID);
@@ -58507,6 +59433,9 @@ class PaymentHandler extends AbstractMessageHandler {
         if (!paymentRequest.to) {
             throw new Error(`failed request. empty 'to' field`);
         }
+        if (!opts?.allowExpiredMessages) {
+            verifyExpiresTime(paymentRequest);
+        }
         const agentMessage = await this.handlePaymentRequestMessage(paymentRequest, opts);
         if (!agentMessage) {
             return null;
@@ -58517,24 +59446,122 @@ class PaymentHandler extends AbstractMessageHandler {
     /**
      * @inheritdoc IPaymentHandler#handlePayment
      */
-    async handlePayment(payment, opts) {
-        if (opts.paymentRequest.from !== payment.to) {
-            throw new Error(`sender of the request is not a target of response - expected ${opts.paymentRequest.from}, given ${payment.to}`);
+    async handlePayment(payment, params) {
+        if (!params?.allowExpiredMessages) {
+            verifyExpiresTime(payment);
+        }
+        if (params.paymentRequest.from !== payment.to) {
+            throw new Error(`sender of the request is not a target of response - expected ${params.paymentRequest.from}, given ${payment.to}`);
         }
         if (!payment.body.payments.length) {
             throw new Error(`failed request. empty 'payments' field in body`);
         }
+        if (!params.paymentValidationHandler) {
+            throw new Error(`please provide payment validation handler in options`);
+        }
         for (let i = 0; i < payment.body.payments.length; i++) {
             const p = payment.body.payments[i];
-            const paymentRequestData = opts.paymentRequest.body.payments.find((r) => r.data.id === p.id);
-            if (!paymentRequestData) {
-                throw new Error(`can't find payment request for payment id ${p.id}`);
-            }
-            if (!opts.paymentValidationHandler) {
-                throw new Error(`please provide payment validation handler in options`);
-            }
-            await opts.paymentValidationHandler(p.paymentData.txId, paymentRequestData.data);
+            const nonce = p.type === PaymentType.Iden3PaymentCryptoV1 ? p.id : p.nonce;
+            const requestDataArr = params.paymentRequest.body.payments
+                .map((r) => (Array.isArray(r.data) ? r.data : [r.data]))
+                .flat();
+            const requestData = requestDataArr.find((r) => r.type === PaymentRequestDataType.Iden3PaymentRequestCryptoV1
+                ? r.id === nonce
+                : r.nonce === nonce);
+            if (!requestData) {
+                throw new Error(`can't find payment request for payment ${p.type === PaymentType.Iden3PaymentCryptoV1 ? 'id' : 'nonce'} ${nonce}`);
+            }
+            await params.paymentValidationHandler(p.paymentData.txId, requestData);
+        }
+    }
+    /**
+     * @inheritdoc IPaymentHandler#createPaymentRailsV1
+     */
+    async createPaymentRailsV1(sender, receiver, agent, signer, payments) {
+        const paymentRequestInfo = [];
+        for (let i = 0; i < payments.length; i++) {
+            const { credentials, description } = payments[i];
+            const dataArr = [];
+            for (let j = 0; j < payments[i].chains.length; j++) {
+                const { features, nonce, amount, currency, chainId, expirationDate, type } = payments[i].chains[j];
+                const multiChainConfig = this._params.multiChainPaymentConfig?.find((c) => c.chainId === chainId);
+                if (!multiChainConfig) {
+                    throw new Error(`failed request. no config for chain ${chainId}`);
+                }
+                const { recipient, paymentContract, erc20TokenAddressArr } = multiChainConfig;
+                const tokenAddress = erc20TokenAddressArr.find((t) => t.symbol === currency)?.address;
+                if (type === PaymentRequestDataType.Iden3PaymentRailsERC20RequestV1 && !tokenAddress) {
+                    throw new Error(`failed request. no token address for currency ${currency}`);
+                }
+                const expirationTime = expirationDate
+                    ? new Date(expirationDate).getTime()
+                    : new Date(new Date().setHours(new Date().getHours() + 1)).getTime();
+                const typeUrl = `https://schema.iden3.io/core/json/${type}.json`;
+                const typesFetchResult = await fetch(typeUrl);
+                const types = await typesFetchResult.json();
+                delete types.EIP712Domain;
+                const paymentData = type === PaymentRequestDataType.Iden3PaymentRailsRequestV1
+                    ? {
+                        recipient,
+                        amount,
+                        expirationDate: expirationTime,
+                        nonce,
+                        metadata: '0x'
+                    }
+                    : {
+                        tokenAddress,
+                        recipient,
+                        amount,
+                        expirationDate: expirationTime,
+                        nonce,
+                        metadata: '0x'
+                    };
+                const domain = {
+                    name: 'MCPayment',
+                    version: '1.0.0',
+                    chainId,
+                    verifyingContract: paymentContract
+                };
+                const signature = await signer.signTypedData(domain, types, paymentData);
+                const proof = [
+                    {
+                        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 = {
+                    type: PaymentRequestDataType.Iden3PaymentRailsRequestV1,
+                    '@context': [
+                        `https://schema.iden3.io/core/jsonld/payment.jsonld#${type}`,
+                        'https://w3id.org/security/suites/eip712sig-2021/v1'
+                    ],
+                    recipient,
+                    amount: amount.toString(),
+                    currency,
+                    expirationDate: new Date(expirationTime).toISOString(),
+                    nonce: nonce.toString(),
+                    metadata: '0x',
+                    proof
+                };
+                dataArr.push(type === PaymentRequestDataType.Iden3PaymentRailsRequestV1
+                    ? d
+                    : { ...d, type, tokenAddress: tokenAddress || '', features: features || [] });
+            }
+            paymentRequestInfo.push({
+                data: dataArr,
+                credentials,
+                description
+            });
         }
+        return createPaymentRequest(sender, receiver, agent, paymentRequestInfo);
     }
     async packMessage(message, senderDID) {
         const responseEncoded = byteEncoder.encode(JSON.stringify(message));
@@ -58548,6 +59575,67 @@ class PaymentHandler extends AbstractMessageHandler {
             ...packerOpts
         });
     }
+    async handleIden3PaymentRequestCryptoV1(data, paymentHandler) {
+        if (data.expiration && new Date(data.expiration) < new Date()) {
+            throw new Error(`failed request. expired request`);
+        }
+        const txId = await paymentHandler(data);
+        return {
+            id: data.id,
+            '@context': 'https://schema.iden3.io/core/jsonld/payment.jsonld#Iden3PaymentCryptoV1',
+            type: PaymentType.Iden3PaymentCryptoV1,
+            paymentData: {
+                txId
+            }
+        };
+    }
+    async handleIden3PaymentRailsRequestV1(data, paymentHandler) {
+        if (data.expirationDate && new Date(data.expirationDate) < new Date()) {
+            throw new Error(`failed request. expired request`);
+        }
+        const signer = await verifyEIP712TypedData(data, this._params.documentResolver);
+        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);
+        const proof = Array.isArray(data.proof) ? data.proof[0] : data.proof;
+        return {
+            nonce: data.nonce,
+            type: PaymentType.Iden3PaymentRailsV1,
+            '@context': 'https://schema.iden3.io/core/jsonld/payment.jsonld#Iden3PaymentRailsV1',
+            paymentData: {
+                txId,
+                chainId: proof.eip712.domain.chainId
+            }
+        };
+    }
+    async handleIden3PaymentRailsERC20RequestV1(data, paymentHandler, approveHandler) {
+        if (data.expirationDate && new Date(data.expirationDate) < new Date()) {
+            throw new Error(`failed request. expired request`);
+        }
+        const signer = await verifyEIP712TypedData(data, this._params.documentResolver);
+        if (this._params.allowedSigners && !this._params.allowedSigners.includes(signer)) {
+            throw new Error(`failed request. signer is not in the allowed signers list`);
+        }
+        if (!data.features?.includes(PaymentFeatures.EIP_2612) && !approveHandler) {
+            throw new Error(`please provide erc20TokenApproveHandler in context for ERC-20 payment type`);
+        }
+        if (approveHandler) {
+            await approveHandler(data);
+        }
+        const txId = await paymentHandler(data);
+        const proof = Array.isArray(data.proof) ? data.proof[0] : data.proof;
+        return {
+            nonce: data.nonce,
+            type: PaymentType.Iden3PaymentRailsERC20V1,
+            '@context': 'https://schema.iden3.io/core/jsonld/payment.jsonld#Iden3PaymentRailsERC20V1',
+            paymentData: {
+                txId,
+                chainId: proof.eip712.domain.chainId,
+                tokenAddress: data.tokenAddress
+            }
+        };
+    }
 }
 
 const allOperations = Object.values(QueryOperators);
@@ -60584,5 +61672,5 @@ class IdentityWallet {
     }
 }
 
-export { AbstractMessageHandler, AbstractPrivateKeyStore, AgentResolver, AtomicQueryMTPV2Inputs, AtomicQueryMTPV2OnChainInputs, AtomicQueryMTPV2OnChainPubSignals, AtomicQueryMTPV2PubSignals, AtomicQuerySigV2Inputs, AtomicQuerySigV2OnChainCircuitInputs, AtomicQuerySigV2OnChainInputs, AtomicQuerySigV2OnChainPubSignals, AtomicQuerySigV2PubSignals, AtomicQueryV3Inputs, AtomicQueryV3OnChainInputs, AtomicQueryV3OnChainPubSignals, AtomicQueryV3PubSignals, AuthHandler, AuthV2Inputs, AuthV2PubSignals, BJJSignatureProof2021, BaseConfig, BjjProvider, BrowserDataSource, CircuitClaim, CircuitError, CircuitId, CircuitStorage, ContractRequestHandler, CredentialOfferStatus, CredentialProposalHandler, CredentialStatusPublisherRegistry, CredentialStatusResolverRegistry, CredentialStatusType, CredentialStorage, CredentialWallet, DIDDocumentJSONSchema, DIDDocumentSignature, DataPrepareHandlerFunc, DisplayMethodType, Ed25519Provider, ErrorEmptyAuthClaimNonRevProof, ErrorEmptyAuthClaimProof, ErrorEmptyChallengeSignature, ErrorEmptyClaimNonRevProof, ErrorEmptyClaimProof, ErrorEmptyClaimSignature, ErrorEmptyIssuerAuthClaimNonRevProof, ErrorEmptyIssuerAuthClaimProof, ErrorUserStateInRelayClaimProof, EthStateStorage, FSCircuitStorage, FetchHandler, FilterQuery, FunctionSignatures, Iden3OnchainSmtCredentialStatusPublisher, Iden3SmtRhsCredentialStatusPublisher, Iden3SparseMerkleTreeProof, IdentityStorage, IdentityWallet, InMemoryDataSource, InMemoryMerkleTreeStorage, InMemoryPrivateKeyStore, IndexedDBDataSource, IndexedDBPrivateKeyStore, InputGenerator, IssuerResolver, JSON_SCHEMA_VALIDATORS_REGISTRY, JWSPacker, JsonSchemaValidator, KMS, KmsKeyType, LDParser, LinkedMultiQueryInputs, LinkedMultiQueryPubSignals, LocalStoragePrivateKeyStore, MerkleTreeIndexedDBStorage, MerkleTreeLocalStorage, MerkleTreeType, MerklizedRootPosition, MessageBus, MessageHandler, NativeProver, OnChainResolver, OnChainRevocationStorage, OnChainZKPVerifier, Operators, constants as PROTOCOL_CONSTANTS, PackageManager, Parser, PaymentHandler, PaymentRequestDataType, PaymentRequestType, PaymentType, PlainPacker, ProofNode, ProofPurpose, ProofService, ProofType, PubSignalsVerifier, Query, QueryOperators, RHSResolver, RefreshHandler, RefreshServiceType, RevocationStatusHandler, SDK_EVENTS, Scalar, SearchError, Sec256k1Provider, StandardJSONCredentialsQueryFilter, StateTransitionInputs, StateTransitionPubSignals, SubjectPosition, SupportedCurrencies, TransactionService, ValueProof, Vector, VerifiableConstants, VerificationHandlerFunc, W3CCredential, XSDNS, ZKPPacker, availableTypesOperators, base58ToBytes$1 as base58ToBytes, base64ToBytes$1 as base64ToBytes, base64UrlToBytes, bigIntArrayToStringArray, bigIntCompare, buildDIDFromEthPubKey, buildFieldPath, buildTreeState, buildVerifierId, byteDecoder, byteEncoder, bytesToBase58$1 as bytesToBase58, bytesToBase64, bytesToBase64url$1 as bytesToBase64url, bytesToHex$3 as bytesToHex, cacheLoader, calculateCoreSchemaHash, calculateQueryHashV2, calculateQueryHashV3, checkCircuitOperator, checkCircuitQueriesLength, checkDataInField, checkQueryRequest, circuitValidator, comparatorOptions, createAuthorizationRequest, createAuthorizationRequestWithMessage, createPayment, createPaymentRequest, createProposal, createProposalRequest, createSchemaHash, createVerifiablePresentation, credentialSubjectKey, dataFillsSlot, decodeBase64url$1 as decodeBase64url, defaultEthConnectionConfig, defaultMTLevels, defaultMTLevelsClaim, defaultMTLevelsOnChain, defaultValueArraySize, defineMerklizedRootPosition, encodeBase64url, existenceToInt, extractProof, extractPublicKeyBytes, factoryComparer, fieldToByteArray, fieldValueFromVerifiablePresentation, fillCoreClaimSlot, fillSlot, findCredentialType, findValue, generateProfileDID, getFieldSlotIndex, getKMSIdByAuthCredential, getNodeAuxValue, getNodesRepresentation, getOperatorNameByValue, getProperties, getSerializationAttrFromContext, getSerializationAttrFromParsedContext, getUserDIDFromCredential, hexToBytes$3 as hexToBytes, isEthereumIdentity, isGenesisState, isGenesisStateId, isIssuerGenesis, isValidOperation, keyPath, mergeObjects, parseCoreClaimSlots, parseCredentialSubject, parseQueriesMetadata, parseQueryMetadata, parseSerializationAttr, prepareCircuitArrayValues, prepareSiblingsStr, processZeroKnowledgeProofRequests, pushHashesToRHS, resolveDIDDocumentAuth, resolveDidDocument, resolvePath, resolveVerificationMethods, strMTHex, stringByPath, subjectPositionIndex, swapEndianness, toClaimNonRevStatus, toGISTProof, toRevocationStatus, transformQueryValueToBigInts, userStateError, validateDIDDocumentAuth, validateDisclosureNativeSDSupport, validateDisclosureV2Circuit, validateEmptyCredentialSubjectNoopNativeSupport, validateEmptyCredentialSubjectV2Circuit, validateOperators, validateTreeState, verifyFieldValueInclusionNativeExistsSupport, verifyFieldValueInclusionV2, witnessBuilder };
+export { AbstractMessageHandler, AbstractPrivateKeyStore, AgentResolver, AtomicQueryMTPV2Inputs, AtomicQueryMTPV2OnChainInputs, AtomicQueryMTPV2OnChainPubSignals, AtomicQueryMTPV2PubSignals, AtomicQuerySigV2Inputs, AtomicQuerySigV2OnChainCircuitInputs, AtomicQuerySigV2OnChainInputs, AtomicQuerySigV2OnChainPubSignals, AtomicQuerySigV2PubSignals, AtomicQueryV3Inputs, AtomicQueryV3OnChainInputs, AtomicQueryV3OnChainPubSignals, AtomicQueryV3PubSignals, AuthHandler, AuthV2Inputs, AuthV2PubSignals, BJJSignatureProof2021, BaseConfig, BjjProvider, BrowserDataSource, CircuitClaim, CircuitError, CircuitId, CircuitStorage, ContractRequestHandler, CredentialOfferStatus, CredentialProposalHandler, CredentialStatusPublisherRegistry, CredentialStatusResolverRegistry, CredentialStatusType, CredentialStorage, CredentialWallet, DIDDocumentJSONSchema, DIDDocumentSignature, DataPrepareHandlerFunc, DisplayMethodType, Ed25519Provider, ErrorEmptyAuthClaimNonRevProof, ErrorEmptyAuthClaimProof, ErrorEmptyChallengeSignature, ErrorEmptyClaimNonRevProof, ErrorEmptyClaimProof, ErrorEmptyClaimSignature, ErrorEmptyIssuerAuthClaimNonRevProof, ErrorEmptyIssuerAuthClaimProof, ErrorUserStateInRelayClaimProof, EthStateStorage, FSCircuitStorage, FetchHandler, FilterQuery, FunctionSignatures, Iden3OnchainSmtCredentialStatusPublisher, Iden3SmtRhsCredentialStatusPublisher, Iden3SparseMerkleTreeProof, IdentityStorage, IdentityWallet, InMemoryDataSource, InMemoryMerkleTreeStorage, InMemoryPrivateKeyStore, IndexedDBDataSource, IndexedDBPrivateKeyStore, InputGenerator, IssuerResolver, JSON_SCHEMA_VALIDATORS_REGISTRY, JWSPacker, JsonSchemaValidator, KMS, KmsKeyType, LDParser, LinkedMultiQueryInputs, LinkedMultiQueryPubSignals, LocalStoragePrivateKeyStore, MerkleTreeIndexedDBStorage, MerkleTreeLocalStorage, MerkleTreeType, MerklizedRootPosition, MessageBus, MessageHandler, NativeProver, OnChainResolver, OnChainRevocationStorage, OnChainZKPVerifier, Operators, constants as PROTOCOL_CONSTANTS, PackageManager, Parser, PaymentFeatures, PaymentHandler, PaymentRequestDataType, PaymentType, PlainPacker, ProofNode, ProofPurpose, ProofService, ProofType, PubSignalsVerifier, Query, QueryOperators, RHSResolver, RefreshHandler, RefreshServiceType, RevocationStatusHandler, SDK_EVENTS, Scalar, SearchError, Sec256k1Provider, StandardJSONCredentialsQueryFilter, StateTransitionInputs, StateTransitionPubSignals, SubjectPosition, SupportedCurrencies, SupportedPaymentProofType, TransactionService, ValueProof, Vector, VerifiableConstants, VerificationHandlerFunc, W3CCredential, XSDNS, ZKPPacker, availableTypesOperators, base58ToBytes$1 as base58ToBytes, base64ToBytes$1 as base64ToBytes, base64UrlToBytes, bigIntArrayToStringArray, bigIntCompare, buildAccept, buildDIDFromEthPubKey, buildFieldPath, buildTreeState, buildVerifierId, byteDecoder, byteEncoder, bytesToBase58$1 as bytesToBase58, bytesToBase64, bytesToBase64url$1 as bytesToBase64url, bytesToHex$3 as bytesToHex, cacheLoader, calculateCoreSchemaHash, calculateQueryHashV2, calculateQueryHashV3, checkCircuitOperator, checkCircuitQueriesLength, checkDataInField, checkQueryRequest, circuitValidator, comparatorOptions, createAuthorizationRequest, createAuthorizationRequestWithMessage, createPayment, createPaymentRequest, createProposal, createProposalRequest, createSchemaHash, createVerifiablePresentation, credentialSubjectKey, dataFillsSlot, decodeBase64url$1 as decodeBase64url, defaultEthConnectionConfig, defaultMTLevels, defaultMTLevelsClaim, defaultMTLevelsOnChain, defaultValueArraySize, defineMerklizedRootPosition, encodeBase64url, existenceToInt, extractProof, extractPublicKeyBytes, factoryComparer, fieldToByteArray, fieldValueFromVerifiablePresentation, fillCoreClaimSlot, fillSlot, findCredentialType, findValue, generateProfileDID, getFieldSlotIndex, getKMSIdByAuthCredential, getNodeAuxValue, getNodesRepresentation, getOperatorNameByValue, getPermitSignature, getProperties, getSerializationAttrFromContext, getSerializationAttrFromParsedContext, getUserDIDFromCredential, hexToBytes$3 as hexToBytes, isEthereumIdentity, isGenesisState, isGenesisStateId, isIssuerGenesis, isValidOperation, keyPath, mergeObjects, parseAcceptProfile, parseCoreClaimSlots, parseCredentialSubject, parseQueriesMetadata, parseQueryMetadata, parseSerializationAttr, prepareCircuitArrayValues, prepareSiblingsStr, processZeroKnowledgeProofRequests, pushHashesToRHS, resolveDIDDocumentAuth, resolveDidDocument, resolvePath, resolveVerificationMethods, strMTHex, stringByPath, subjectPositionIndex, swapEndianness, toClaimNonRevStatus, toGISTProof, toRevocationStatus, transformQueryValueToBigInts, userStateError, validateDIDDocumentAuth, validateDisclosureNativeSDSupport, validateDisclosureV2Circuit, validateEmptyCredentialSubjectNoopNativeSupport, validateEmptyCredentialSubjectV2Circuit, validateOperators, validateTreeState, verifyEIP712TypedData, verifyExpiresTime, verifyFieldValueInclusionNativeExistsSupport, verifyFieldValueInclusionV2, witnessBuilder };
 //# sourceMappingURL=index.js.map