@0xpolygonid/js-sdk 1.21.3 → 1.23.0

package/dist/browser/umd/index.js

@@ -7838,15 +7838,6 @@ var PolygonIdSdk = (function (exports) {
     (function (RefreshServiceType) {
         RefreshServiceType["Iden3RefreshService2023"] = "Iden3RefreshService2023";
     })(exports.RefreshServiceType || (exports.RefreshServiceType = {}));
-    /**
-     * PaymentRequestType type for payment requests
-     * @beta
-     * @enum {string}
-     */
-    exports.PaymentRequestType = void 0;
-    (function (PaymentRequestType) {
-        PaymentRequestType["PaymentRequest"] = "PaymentRequest";
-    })(exports.PaymentRequestType || (exports.PaymentRequestType = {}));
     /**
      * PaymentRequestDataType type for payment requests
      * @beta
@@ -7855,6 +7846,8 @@ var PolygonIdSdk = (function (exports) {
     exports.PaymentRequestDataType = void 0;
     (function (PaymentRequestDataType) {
         PaymentRequestDataType["Iden3PaymentRequestCryptoV1"] = "Iden3PaymentRequestCryptoV1";
+        PaymentRequestDataType["Iden3PaymentRailsRequestV1"] = "Iden3PaymentRailsRequestV1";
+        PaymentRequestDataType["Iden3PaymentRailsERC20RequestV1"] = "Iden3PaymentRailsERC20RequestV1";
     })(exports.PaymentRequestDataType || (exports.PaymentRequestDataType = {}));
     /**
      * PaymentType type for payment responses
@@ -7864,17 +7857,41 @@ var PolygonIdSdk = (function (exports) {
     exports.PaymentType = void 0;
     (function (PaymentType) {
         PaymentType["Iden3PaymentCryptoV1"] = "Iden3PaymentCryptoV1";
+        PaymentType["Iden3PaymentRailsV1"] = "Iden3PaymentRailsV1";
+        PaymentType["Iden3PaymentRailsERC20V1"] = "Iden3PaymentRailsERC20V1";
     })(exports.PaymentType || (exports.PaymentType = {}));
+    /**
+     * SupportedPaymentProofType type for payment proofs
+     * @beta
+     * @enum {string}
+     */
+    exports.SupportedPaymentProofType = void 0;
+    (function (SupportedPaymentProofType) {
+        SupportedPaymentProofType["EthereumEip712Signature2021"] = "EthereumEip712Signature2021";
+    })(exports.SupportedPaymentProofType || (exports.SupportedPaymentProofType = {}));
     /**
      * Media types for Payment supported currencies
      * @beta
-     * @enum {number}
+     * @enum {string}
      */
     exports.SupportedCurrencies = void 0;
     (function (SupportedCurrencies) {
         SupportedCurrencies["ETH"] = "ETH";
+        SupportedCurrencies["ETH_WEI"] = "ETHWEI";
+        SupportedCurrencies["ETH_GWEI"] = "ETHGWEI";
         SupportedCurrencies["MATIC"] = "MATIC";
+        SupportedCurrencies["USDT"] = "USDT";
+        SupportedCurrencies["USDC"] = "USDC";
     })(exports.SupportedCurrencies || (exports.SupportedCurrencies = {}));
+    /**
+     * Supported features for payment-request
+     * @beta
+     * @enum {string}
+     */
+    exports.PaymentFeatures = void 0;
+    (function (PaymentFeatures) {
+        PaymentFeatures["EIP_2612"] = "EIP-2612";
+    })(exports.PaymentFeatures || (exports.PaymentFeatures = {}));
     /**
      * DisplayMethodType type for display method
      *
@@ -39986,6 +40003,12 @@ var PolygonIdSdk = (function (exports) {
             };
         }
     }
+    /**
+     *  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:
@@ -51463,7 +51486,7 @@ var PolygonIdSdk = (function (exports) {
         }
     }
 
-    var abi$2 = [
+    var abi$3 = [
     	{
     		inputs: [
     		],
@@ -52577,7 +52600,7 @@ var PolygonIdSdk = (function (exports) {
             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} */
@@ -52717,7 +52740,7 @@ var PolygonIdSdk = (function (exports) {
             const chainId = et$2(Q$2.blockchainFromId(idTyped), Q$2.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) {
@@ -52730,7 +52753,7 @@ var PolygonIdSdk = (function (exports) {
         }
     }
 
-    var abi$1 = [
+    var abi$2 = [
     	{
     		inputs: [
     		],
@@ -53630,7 +53653,7 @@ var PolygonIdSdk = (function (exports) {
             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);
@@ -53678,7 +53701,7 @@ var PolygonIdSdk = (function (exports) {
             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,
@@ -53871,7 +53894,7 @@ var PolygonIdSdk = (function (exports) {
         }
     }
 
-    var abi = [
+    var abi$1 = [
     	{
     		inputs: [
     		],
@@ -54159,7 +54182,7 @@ var PolygonIdSdk = (function (exports) {
             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);
@@ -54240,6 +54263,575 @@ var PolygonIdSdk = (function (exports) {
         }
     }
 
+    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
      *
@@ -55727,16 +56319,45 @@ var PolygonIdSdk = (function (exports) {
             '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
     });
 
     /**
@@ -77603,6 +78224,18 @@ var PolygonIdSdk = (function (exports) {
         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) => {
@@ -77675,212 +78308,6 @@ var PolygonIdSdk = (function (exports) {
         }
     }
 
-    const { getProvingMethod } = T;
-    /**
-     * 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 I(provingMethod, byteDecoder.decode(payload), (hash, circuitId) => {
-                return provingParams?.dataPreparer?.prepare(hash, params.senderDID, circuitId);
-            });
-            token.setHeader(p.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 I.parse(byteDecoder.decode(envelope));
-            const provingMethodAlg = new l(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 exports.CircuitId.AuthV2:
-                {
-                    if (!msg.from) {
-                        throw new Error(ErrSenderNotUsedTokenCreation);
-                    }
-                    const authSignals = new AuthV2PubSignals().pubSignalsUnmarshal(byteEncoder.encode(JSON.stringify(token.zkProof.pub_signals)));
-                    const did = Q$2.parseFromId(authSignals.userID);
-                    const msgHash = await token.getMessageHash();
-                    const challenge = R$2.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 || [];
@@ -77937,6 +78364,356 @@ var PolygonIdSdk = (function (exports) {
         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 } = T;
+    /**
+     * 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 I(provingMethod, byteDecoder.decode(payload), (hash, circuitId) => {
+                return provingParams?.dataPreparer?.prepare(hash, params.senderDID, circuitId);
+            });
+            token.setHeader(p.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 I.parse(byteDecoder.decode(envelope));
+            const provingMethodAlg = new l(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 exports.CircuitId.AuthV2:
+                {
+                    if (!msg.from) {
+                        throw new Error(ErrSenderNotUsedTokenCreation);
+                    }
+                    const authSignals = new AuthV2PubSignals().pubSignalsUnmarshal(byteEncoder.encode(JSON.stringify(token.zkProof.pub_signals)));
+                    const did = Q$2.parseFromId(authSignals.userID);
+                    const msgHash = await token.getMessageHash();
+                    const challenge = R$2.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
@@ -78015,6 +78792,26 @@ var PolygonIdSdk = (function (exports) {
         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 {
@@ -78169,6 +78966,16 @@ var PolygonIdSdk = (function (exports) {
         }
         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 < b$4(new Date())) {
+            throw new Error('Message expired');
+        }
+    };
 
     /**
      * Base implementation of protocol message handler
@@ -78184,6 +78991,9 @@ var PolygonIdSdk = (function (exports) {
             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');
@@ -78276,10 +79086,11 @@ var PolygonIdSdk = (function (exports) {
      * @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
@@ -78287,9 +79098,10 @@ var PolygonIdSdk = (function (exports) {
      * @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,
@@ -78298,11 +79110,14 @@ var PolygonIdSdk = (function (exports) {
             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: b$4(new Date()),
+            expires_time: opts?.expires_time ? b$4(opts.expires_time) : undefined
         };
         return request;
     }
@@ -78361,17 +79176,18 @@ var PolygonIdSdk = (function (exports) {
             }
             // override sender did if it's explicitly specified in the auth request
             const to = authRequest.to ? Q$2.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 = Q$2.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,
@@ -78386,6 +79202,9 @@ var PolygonIdSdk = (function (exports) {
          */
         async handleAuthorizationRequest(did, request, opts) {
             const authRequest = await this.parseAuthorizationRequest(request);
+            if (!opts?.allowExpiredMessages) {
+                verifyExpiresTime(authRequest);
+            }
             if (!opts) {
                 opts = {
                     mediaType: MediaType.ZKPMessage
@@ -78475,6 +79294,9 @@ var PolygonIdSdk = (function (exports) {
          * @inheritdoc IAuthHandler#handleAuthorizationResponse
          */
         async handleAuthorizationResponse(response, request, opts) {
+            if (!opts?.allowExpiredMessages) {
+                verifyExpiresTime(response);
+            }
             const authResp = (await this.handleAuthResponse(response, {
                 request,
                 acceptedStateTransitionDelay: opts?.acceptedStateTransitionDelay,
@@ -78508,6 +79330,37 @@ var PolygonIdSdk = (function (exports) {
                 }
             }
         }
+        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;
+        }
     }
 
     /**
@@ -78624,6 +79477,9 @@ var PolygonIdSdk = (function (exports) {
                 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,
@@ -78671,8 +79527,11 @@ var PolygonIdSdk = (function (exports) {
         /**
          * @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)), {});
         }
@@ -78689,8 +79548,11 @@ var PolygonIdSdk = (function (exports) {
         /**
          * @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([]);
         }
@@ -78810,7 +79672,8 @@ var PolygonIdSdk = (function (exports) {
                 body: {
                     transaction_data: request.body.transaction_data,
                     scope: []
-                }
+                },
+                created_time: b$4(new Date())
             };
             for (const [txHash, zkpResponses] of txHashToZkpResponseMap) {
                 for (const zkpResponse of zkpResponses) {
@@ -78834,6 +79697,9 @@ var PolygonIdSdk = (function (exports) {
          */
         async handleContractInvokeRequest(did, request, opts) {
             const ciRequest = await this.parseContractInvokeRequest(request);
+            if (!opts.allowExpiredMessages) {
+                verifyExpiresTime(ciRequest);
+            }
             if (ciRequest.body.transaction_data.method_id !== exports.FunctionSignatures.SubmitZKPResponseV1) {
                 throw new Error(`please use handle method to work with other method ids`);
             }
@@ -79012,6 +79878,9 @@ var PolygonIdSdk = (function (exports) {
                 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,
@@ -79051,7 +79920,9 @@ var PolygonIdSdk = (function (exports) {
             to: receiver.string(),
             typ: MediaType.PlainMessage,
             type: PROTOCOL_MESSAGE_TYPE.PROPOSAL_REQUEST_MESSAGE_TYPE,
-            body: opts
+            body: opts,
+            created_time: b$4(new Date()),
+            expires_time: opts?.expires_time ? b$4(opts.expires_time) : undefined
         };
         return request;
     }
@@ -79063,7 +79934,7 @@ var PolygonIdSdk = (function (exports) {
      * @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,
@@ -79074,7 +79945,9 @@ var PolygonIdSdk = (function (exports) {
             type: PROTOCOL_MESSAGE_TYPE.PROPOSAL_MESSAGE_TYPE,
             body: {
                 proposals: proposals || []
-            }
+            },
+            created_time: b$4(new Date()),
+            expires_time: opts?.expires_time ? b$4(opts.expires_time) : undefined
         };
         return request;
     }
@@ -79212,6 +80085,9 @@ var PolygonIdSdk = (function (exports) {
             if (!proposalRequest.from) {
                 throw new Error(`failed request. empty 'from' field`);
             }
+            if (!opts?.allowExpiredMessages) {
+                verifyExpiresTime(proposalRequest);
+            }
             const senderDID = Q$2.parse(proposalRequest.from);
             const message = await this.handleProposalRequestMessage(proposalRequest);
             const response = byteEncoder.encode(JSON.stringify(message));
@@ -79229,6 +80105,9 @@ var PolygonIdSdk = (function (exports) {
          * @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}`);
             }
@@ -79245,7 +80124,7 @@ var PolygonIdSdk = (function (exports) {
      * @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,
@@ -79257,19 +80136,57 @@ var PolygonIdSdk = (function (exports) {
             body: {
                 agent,
                 payments
-            }
+            },
+            created_time: b$4(new Date()),
+            expires_time: opts?.expires_time ? b$4(opts.expires_time) : undefined
         };
         return request;
     }
+    async function verifyEIP712TypedData(data, resolver) {
+        const paymentData = data.type === exports.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,
@@ -79280,7 +80197,9 @@ var PolygonIdSdk = (function (exports) {
             type: PROTOCOL_MESSAGE_TYPE.PAYMENT_MESSAGE_TYPE,
             body: {
                 payments
-            }
+            },
+            created_time: b$4(new Date()),
+            expires_time: opts?.expires_time ? b$4(opts.expires_time) : undefined
         };
         return request;
     }
@@ -79342,21 +80261,28 @@ var PolygonIdSdk = (function (exports) {
             const receiverDID = Q$2.parse(paymentRequest.from);
             const payments = [];
             for (let i = 0; i < paymentRequest.body.payments.length; i++) {
-                const paymentReq = paymentRequest.body.payments[i];
-                if (paymentReq.type !== exports.PaymentRequestType.PaymentRequest) {
-                    throw new Error(`failed request. not supported '${paymentReq.type}' payment type `);
-                }
-                if (paymentReq.data.type !== exports.PaymentRequestDataType.Iden3PaymentRequestCryptoV1) {
-                    throw new Error(`failed request. not supported '${paymentReq.data.type}' payment type `);
-                }
-                const txId = await ctx.paymentHandler(paymentReq.data);
-                payments.push({
-                    id: paymentReq.data.id,
-                    type: exports.PaymentType.Iden3PaymentCryptoV1,
-                    paymentData: {
-                        txId
-                    }
-                });
+                const { data } = paymentRequest.body.payments[i];
+                const selectedPayment = Array.isArray(data)
+                    ? data.find((p) => {
+                        return p.type === exports.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}`);
+                }
+                switch (selectedPayment.type) {
+                    case exports.PaymentRequestDataType.Iden3PaymentRequestCryptoV1:
+                        payments.push(await this.handleIden3PaymentRequestCryptoV1(selectedPayment, ctx.paymentHandler));
+                        break;
+                    case exports.PaymentRequestDataType.Iden3PaymentRailsRequestV1:
+                        payments.push(await this.handleIden3PaymentRailsRequestV1(selectedPayment, ctx.paymentHandler));
+                        break;
+                    case exports.PaymentRequestDataType.Iden3PaymentRailsERC20RequestV1:
+                        payments.push(await this.handleIden3PaymentRailsERC20RequestV1(selectedPayment, ctx.paymentHandler, ctx.erc20TokenApproveHandler));
+                        break;
+                }
             }
             const paymentMessage = createPayment(senderDID, receiverDID, payments);
             const response = await this.packMessage(paymentMessage, senderDID);
@@ -79389,6 +80315,9 @@ var PolygonIdSdk = (function (exports) {
             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;
@@ -79399,24 +80328,122 @@ var PolygonIdSdk = (function (exports) {
         /**
          * @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 === exports.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 === exports.PaymentRequestDataType.Iden3PaymentRequestCryptoV1
+                    ? r.id === nonce
+                    : r.nonce === nonce);
+                if (!requestData) {
+                    throw new Error(`can't find payment request for payment ${p.type === exports.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 === exports.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 === exports.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: exports.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: exports.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 === exports.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));
@@ -79430,6 +80457,67 @@ var PolygonIdSdk = (function (exports) {
                 ...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: exports.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: exports.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(exports.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: exports.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);
@@ -81573,6 +82661,7 @@ var PolygonIdSdk = (function (exports) {
     exports.base64UrlToBytes = base64UrlToBytes;
     exports.bigIntArrayToStringArray = bigIntArrayToStringArray;
     exports.bigIntCompare = bigIntCompare;
+    exports.buildAccept = buildAccept;
     exports.buildDIDFromEthPubKey = buildDIDFromEthPubKey;
     exports.buildFieldPath = buildFieldPath;
     exports.buildTreeState = buildTreeState;
@@ -81628,6 +82717,7 @@ var PolygonIdSdk = (function (exports) {
     exports.getNodeAuxValue = getNodeAuxValue;
     exports.getNodesRepresentation = getNodesRepresentation;
     exports.getOperatorNameByValue = getOperatorNameByValue;
+    exports.getPermitSignature = getPermitSignature;
     exports.getProperties = getProperties;
     exports.getSerializationAttrFromContext = getSerializationAttrFromContext;
     exports.getSerializationAttrFromParsedContext = getSerializationAttrFromParsedContext;
@@ -81641,6 +82731,7 @@ var PolygonIdSdk = (function (exports) {
     exports.jsonLDMerklizer = index;
     exports.keyPath = keyPath;
     exports.mergeObjects = mergeObjects;
+    exports.parseAcceptProfile = parseAcceptProfile;
     exports.parseCoreClaimSlots = parseCoreClaimSlots;
     exports.parseCredentialSubject = parseCredentialSubject;
     exports.parseQueriesMetadata = parseQueriesMetadata;
@@ -81670,6 +82761,8 @@ var PolygonIdSdk = (function (exports) {
     exports.validateEmptyCredentialSubjectV2Circuit = validateEmptyCredentialSubjectV2Circuit;
     exports.validateOperators = validateOperators;
     exports.validateTreeState = validateTreeState;
+    exports.verifyEIP712TypedData = verifyEIP712TypedData;
+    exports.verifyExpiresTime = verifyExpiresTime;
     exports.verifyFieldValueInclusionNativeExistsSupport = verifyFieldValueInclusionNativeExistsSupport;
     exports.verifyFieldValueInclusionV2 = verifyFieldValueInclusionV2;
     exports.witnessBuilder = witnessBuilder;