@wtflabs/x402 0.0.1-beta.0 → 0.0.1-beta.10

package/dist/esm/schemes/index.d.mts

@@ -0,0 +1,605 @@
+import { Address, Transport, Chain, LocalAccount, Hex, Account, PublicClient } from 'viem';
+import { S as SignerWallet, C as ConnectedClient } from '../wallet-SJKJpUgQ.mjs';
+import { P as PaymentRequirements, p as UnsignedEip3009PaymentPayload, o as Eip3009PaymentPayload, e as ExactEvmPayloadAuthorization, J as VerifyResponse, S as SettleResponse, r as UnsignedPermitPaymentPayload, q as PermitPaymentPayload, g as PermitEvmPayloadAuthorization, u as UnsignedPermit2PaymentPayload, t as Permit2PaymentPayload, i as Permit2EvmPayloadAuthorization, a as PaymentPayload, b as ErrorReasons, E as ExactSvmPayload } from '../x402Specs-BtRXj67U.mjs';
+import { X as X402Config } from '../config-Dfuvno71.mjs';
+import { KeyPairSigner, signTransaction, RpcDevnet, SolanaRpcApiDevnet, RpcMainnet, SolanaRpcApiMainnet, SendTransactionApi, CompilableTransactionMessage, Instruction, AccountLookupMeta, AccountMeta } from '@solana/kit';
+import { b as getRpcSubscriptions } from '../rpc-DyKXu0SX.mjs';
+import * as _solana_program_token from '@solana-program/token';
+import { parseTransferCheckedInstruction } from '@solana-program/token-2022';
+import 'viem/chains';
+import 'zod';
+import '../network-FrFmmiyj.mjs';
+
+/**
+ * Prepares an unsigned EIP-3009 payment header with the given sender address and payment requirements.
+ *
+ * @param from - The sender's address from which the payment will be made
+ * @param x402Version - The version of the X402 protocol to use
+ * @param paymentRequirements - The payment requirements containing scheme and network information
+ * @returns An unsigned EIP-3009 payment payload containing authorization details
+ */
+declare function preparePaymentHeader$2(from: Address, x402Version: number, paymentRequirements: PaymentRequirements): UnsignedEip3009PaymentPayload;
+/**
+ * Signs an EIP-3009 payment header using the provided client and payment requirements.
+ *
+ * @param client - The signer wallet instance used to sign the payment header
+ * @param paymentRequirements - The payment requirements containing scheme and network information
+ * @param unsignedPaymentHeader - The unsigned EIP-3009 payment payload to be signed
+ * @returns A promise that resolves to the signed EIP-3009 payment payload
+ */
+declare function signPaymentHeader$2<transport extends Transport, chain extends Chain>(client: SignerWallet<chain, transport> | LocalAccount, paymentRequirements: PaymentRequirements, unsignedPaymentHeader: UnsignedEip3009PaymentPayload): Promise<Eip3009PaymentPayload>;
+/**
+ * Creates a complete EIP-3009 payment payload by preparing and signing a payment header.
+ *
+ * @param client - The signer wallet instance used to create and sign the payment
+ * @param x402Version - The version of the X402 protocol to use
+ * @param paymentRequirements - The payment requirements containing scheme and network information
+ * @returns A promise that resolves to the complete signed EIP-3009 payment payload
+ */
+declare function createPayment$2<transport extends Transport, chain extends Chain>(client: SignerWallet<chain, transport> | LocalAccount, x402Version: number, paymentRequirements: PaymentRequirements): Promise<Eip3009PaymentPayload>;
+/**
+ * Creates and encodes an EIP-3009 payment header for the given client and payment requirements.
+ *
+ * @param client - The signer wallet instance used to create the payment header
+ * @param x402Version - The version of the X402 protocol to use
+ * @param paymentRequirements - The payment requirements containing scheme and network information
+ * @returns A promise that resolves to the encoded EIP-3009 payment header string
+ */
+declare function createPaymentHeader$3(client: SignerWallet | LocalAccount, x402Version: number, paymentRequirements: PaymentRequirements): Promise<string>;
+
+/**
+ * Signs an EIP-3009 authorization for USDC transfer
+ *
+ * @param walletClient - The wallet client that will sign the authorization
+ * @param params - The authorization parameters containing transfer details
+ * @param params.from - The address tokens will be transferred from
+ * @param params.to - The address tokens will be transferred to
+ * @param params.value - The amount of USDC tokens to transfer (in base units)
+ * @param params.validAfter - Unix timestamp after which the authorization becomes valid
+ * @param params.validBefore - Unix timestamp before which the authorization is valid
+ * @param params.nonce - Random 32-byte nonce to prevent replay attacks
+ * @param paymentRequirements - The payment requirements containing asset and network information
+ * @param paymentRequirements.asset - The address of the USDC contract
+ * @param paymentRequirements.network - The network where the USDC contract exists
+ * @param paymentRequirements.extra - The extra information containing the name and version of the ERC20 contract
+ * @returns The signature for the authorization
+ */
+declare function signAuthorization<transport extends Transport, chain extends Chain>(walletClient: SignerWallet<chain, transport> | LocalAccount, { from, to, value, validAfter, validBefore, nonce }: ExactEvmPayloadAuthorization, { asset, network, extra }: PaymentRequirements): Promise<{
+    signature: Hex;
+}>;
+/**
+ * Generates a random 32-byte nonce for use in authorization signatures
+ *
+ * @returns A random 32-byte nonce as a hex string
+ */
+declare function createNonce(): Hex;
+
+/**
+ * Verifies an EIP-3009 payment payload against the required payment details
+ *
+ * This function performs several verification steps:
+ * - Verifies protocol version compatibility
+ * - Validates the permit signature
+ * - Confirms USDC contract address is correct for the chain
+ * - Checks permit deadline is sufficiently in the future
+ * - Verifies client has sufficient USDC balance
+ * - Ensures payment amount meets required minimum
+ *
+ * @param client - The public client used for blockchain interactions
+ * @param payload - The signed payment payload containing transfer parameters and signature
+ * @param paymentRequirements - The payment requirements that the payload must satisfy
+ * @returns A ValidPaymentRequest indicating if the payment is valid and any invalidation reason
+ */
+declare function verify$4<transport extends Transport, chain extends Chain, account extends Account | undefined>(client: ConnectedClient<transport, chain, account>, payload: Eip3009PaymentPayload, paymentRequirements: PaymentRequirements): Promise<VerifyResponse>;
+/**
+ * Settles an EIP-3009 payment by executing a USDC transferWithAuthorization transaction
+ *
+ * This function executes the actual USDC transfer using the signed authorization from the user.
+ * The facilitator wallet submits the transaction but does not need to hold or transfer any tokens itself.
+ *
+ * @param wallet - The facilitator wallet that will submit the transaction
+ * @param paymentPayload - The signed payment payload containing the transfer parameters and signature
+ * @param paymentRequirements - The original payment details that were used to create the payload
+ * @returns A PaymentExecutionResponse containing the transaction status and hash
+ */
+declare function settle$4<transport extends Transport, chain extends Chain>(wallet: SignerWallet<chain, transport>, paymentPayload: Eip3009PaymentPayload, paymentRequirements: PaymentRequirements): Promise<SettleResponse>;
+
+declare const index$5_createNonce: typeof createNonce;
+declare const index$5_signAuthorization: typeof signAuthorization;
+declare namespace index$5 {
+  export { index$5_createNonce as createNonce, createPayment$2 as createPayment, createPaymentHeader$3 as createPaymentHeader, preparePaymentHeader$2 as preparePaymentHeader, settle$4 as settle, index$5_signAuthorization as signAuthorization, signPaymentHeader$2 as signPaymentHeader, verify$4 as verify };
+}
+
+/**
+ * Prepares an unsigned EIP-2612 Permit payment header
+ *
+ * @param from - The token owner's address
+ * @param x402Version - The version of the X402 protocol to use
+ * @param paymentRequirements - The payment requirements containing scheme and network information
+ * @returns An unsigned Permit payment payload containing permit authorization details
+ */
+declare function preparePaymentHeader$1(from: Address, x402Version: number, paymentRequirements: PaymentRequirements): UnsignedPermitPaymentPayload;
+/**
+ * Signs a Permit payment header using the provided client and payment requirements.
+ *
+ * @param client - The signer wallet instance used to sign the permit
+ * @param paymentRequirements - The payment requirements containing scheme and network information
+ * @param unsignedPaymentHeader - The unsigned Permit payment payload to be signed
+ * @returns A promise that resolves to the signed Permit payment payload
+ */
+declare function signPaymentHeader$1<transport extends Transport, chain extends Chain>(client: SignerWallet<chain, transport> | LocalAccount, paymentRequirements: PaymentRequirements, unsignedPaymentHeader: UnsignedPermitPaymentPayload): Promise<PermitPaymentPayload>;
+/**
+ * Creates a complete Permit payment payload by preparing and signing a payment header.
+ *
+ * @param client - The signer wallet instance used to create and sign the payment
+ * @param x402Version - The version of the X402 protocol to use
+ * @param paymentRequirements - The payment requirements containing scheme and network information
+ * @returns A promise that resolves to the complete signed Permit payment payload
+ */
+declare function createPayment$1<transport extends Transport, chain extends Chain>(client: SignerWallet<chain, transport> | LocalAccount, x402Version: number, paymentRequirements: PaymentRequirements): Promise<PermitPaymentPayload>;
+/**
+ * Creates and encodes a Permit payment header for the given client and payment requirements.
+ *
+ * @param client - The signer wallet instance used to create the payment header
+ * @param x402Version - The version of the X402 protocol to use
+ * @param paymentRequirements - The payment requirements containing scheme and network information
+ * @returns A promise that resolves to the encoded payment header string
+ */
+declare function createPaymentHeader$2(client: SignerWallet | LocalAccount, x402Version: number, paymentRequirements: PaymentRequirements): Promise<string>;
+
+/**
+ * Signs an EIP-2612 Permit authorization for ERC20 approval
+ *
+ * @param walletClient - The wallet client that will sign the permit
+ * @param params - The permit parameters
+ * @param params.owner - The address of the token owner
+ * @param params.spender - The address authorized to spend tokens
+ * @param params.value - The amount of tokens to approve (in base units)
+ * @param params.deadline - Unix timestamp after which the permit is no longer valid
+ * @param paymentRequirements - The payment requirements containing asset and network information
+ * @param paymentRequirements.asset - The address of the ERC20 token contract
+ * @param paymentRequirements.network - The network where the token exists
+ * @returns The signature and nonce for the permit
+ */
+declare function signPermit<transport extends Transport, chain extends Chain>(walletClient: SignerWallet<chain, transport> | LocalAccount, { owner, spender, value, deadline }: Omit<PermitEvmPayloadAuthorization, "nonce">, { asset, network }: PaymentRequirements): Promise<{
+    signature: Hex;
+    nonce: string;
+}>;
+/**
+ * Helper function to split signature into v, r, s components
+ * Required for calling the permit function on-chain
+ *
+ * @param signature - The signature to split
+ * @returns The v, r, s components of the signature
+ */
+declare function splitSignature(signature: Hex): {
+    v: number;
+    r: Hex;
+    s: Hex;
+};
+
+/**
+ * Verifies an EIP-2612 Permit payment payload
+ *
+ * @param client - The public client used for blockchain interactions
+ * @param payload - The signed payment payload containing permit parameters and signature
+ * @param paymentRequirements - The payment requirements that the payload must satisfy
+ * @returns A VerifyResponse indicating if the payment is valid and any invalidation reason
+ */
+declare function verify$3<transport extends Transport, chain extends Chain, account extends Account | undefined>(client: ConnectedClient<transport, chain, account>, payload: PermitPaymentPayload, paymentRequirements: PaymentRequirements): Promise<VerifyResponse>;
+/**
+ * Settles an EIP-2612 Permit payment by calling permit() then transferFrom()
+ *
+ * @param wallet - The facilitator wallet that will execute the permit and transfer
+ * @param paymentPayload - The signed payment payload containing permit parameters and signature
+ * @param paymentRequirements - The payment requirements
+ * @returns A SettleResponse containing the transaction status and hash
+ */
+declare function settle$3<transport extends Transport, chain extends Chain>(wallet: SignerWallet<chain, transport>, paymentPayload: PermitPaymentPayload, paymentRequirements: PaymentRequirements): Promise<SettleResponse>;
+
+declare const index$4_signPermit: typeof signPermit;
+declare const index$4_splitSignature: typeof splitSignature;
+declare namespace index$4 {
+  export { createPayment$1 as createPayment, createPaymentHeader$2 as createPaymentHeader, preparePaymentHeader$1 as preparePaymentHeader, settle$3 as settle, signPaymentHeader$1 as signPaymentHeader, index$4_signPermit as signPermit, index$4_splitSignature as splitSignature, verify$3 as verify };
+}
+
+/**
+ * Prepares an unsigned Permit2 payment header with witness support
+ *
+ * By default, this function enables witness mode which binds the recipient address
+ * to the signature, preventing the facilitator from changing the payment destination.
+ *
+ * @param from - The token owner's address
+ * @param x402Version - The version of the X402 protocol to use
+ * @param paymentRequirements - The payment requirements containing scheme and network information
+ * @returns An unsigned Permit2 payment payload containing permit2 authorization details with witness
+ */
+declare function preparePaymentHeader(from: Address, x402Version: number, paymentRequirements: PaymentRequirements): UnsignedPermit2PaymentPayload;
+/**
+ * Signs a Permit2 payment header using the provided client and payment requirements.
+ *
+ * Supports both witness and non-witness modes based on the presence of the `to` field
+ * in the unsigned payment header.
+ *
+ * @param client - The signer wallet instance used to sign the permit2
+ * @param paymentRequirements - The payment requirements containing scheme and network information
+ * @param unsignedPaymentHeader - The unsigned Permit2 payment payload to be signed
+ * @returns A promise that resolves to the signed Permit2 payment payload
+ */
+declare function signPaymentHeader<transport extends Transport, chain extends Chain>(client: SignerWallet<chain, transport> | LocalAccount, paymentRequirements: PaymentRequirements, unsignedPaymentHeader: UnsignedPermit2PaymentPayload): Promise<Permit2PaymentPayload>;
+/**
+ * Creates a complete Permit2 payment payload by preparing and signing a payment header.
+ *
+ * @param client - The signer wallet instance used to create and sign the payment
+ * @param x402Version - The version of the X402 protocol to use
+ * @param paymentRequirements - The payment requirements containing scheme and network information
+ * @returns A promise that resolves to the complete signed Permit2 payment payload
+ */
+declare function createPayment<transport extends Transport, chain extends Chain>(client: SignerWallet<chain, transport> | LocalAccount, x402Version: number, paymentRequirements: PaymentRequirements): Promise<Permit2PaymentPayload>;
+/**
+ * Creates and encodes a Permit2 payment header for the given client and payment requirements.
+ *
+ * @param client - The signer wallet instance used to create the payment header
+ * @param x402Version - The version of the X402 protocol to use
+ * @param paymentRequirements - The payment requirements containing scheme and network information
+ * @returns A promise that resolves to the encoded payment header string
+ */
+declare function createPaymentHeader$1(client: SignerWallet | LocalAccount, x402Version: number, paymentRequirements: PaymentRequirements): Promise<string>;
+
+/**
+ * Signs a Permit2 authorization (PermitTransferFrom or PermitWitnessTransferFrom)
+ *
+ * Automatically detects witness mode based on the presence of the `to` field.
+ * - If `to` is provided: Uses PermitWitnessTransferFrom (binds recipient to signature)
+ * - If `to` is omitted: Uses PermitTransferFrom (legacy mode)
+ *
+ * @param walletClient - The wallet client that will sign the permit
+ * @param params - The permit2 parameters
+ * @param params.owner - The address of the token owner
+ * @param params.spender - The address authorized to transfer tokens
+ * @param params.token - The address of the token to transfer
+ * @param params.amount - The amount of tokens to transfer (in base units)
+ * @param params.deadline - Unix timestamp after which the permit is no longer valid
+ * @param params.to - Optional recipient address for witness mode
+ * @param paymentRequirements - The payment requirements containing network information
+ * @param paymentRequirements.network - The network where the token exists
+ * @returns The signature and nonce for the permit2
+ */
+declare function signPermit2<transport extends Transport, chain extends Chain>(walletClient: SignerWallet<chain, transport> | LocalAccount, { owner, spender, token, amount, deadline, to }: Omit<Permit2EvmPayloadAuthorization, "nonce">, { network }: PaymentRequirements): Promise<{
+    signature: Hex;
+    nonce: string;
+}>;
+/**
+ * Generates a unique nonce for Permit2 SignatureTransfer
+ * Uses timestamp-based approach with nonceBitmap verification
+ *
+ * @param walletClient - The wallet client used to check nonce bitmap
+ * @param ownerAddress - The address of the token owner
+ * @returns A unique nonce for the permit2 authorization
+ */
+declare function createPermit2Nonce<transport extends Transport, chain extends Chain>(walletClient: SignerWallet<chain, transport> | LocalAccount, ownerAddress: `0x${string}`): Promise<bigint>;
+
+/**
+ * Verifies a Permit2 payment payload (with or without witness)
+ *
+ * Supports both witness and non-witness modes:
+ * - Witness mode: Verifies that the recipient address is bound to the signature
+ * - Non-witness mode: Uses standard PermitTransferFrom verification
+ *
+ * @param client - The public client used for blockchain interactions
+ * @param payload - The signed payment payload containing permit2 parameters and signature
+ * @param paymentRequirements - The payment requirements that the payload must satisfy
+ * @returns A VerifyResponse indicating if the payment is valid and any invalidation reason
+ */
+declare function verify$2<transport extends Transport, chain extends Chain, account extends Account | undefined>(client: ConnectedClient<transport, chain, account>, payload: Permit2PaymentPayload, paymentRequirements: PaymentRequirements): Promise<VerifyResponse>;
+/**
+ * Settles a Permit2 payment by calling permitTransferFrom() or permitWitnessTransferFrom()
+ *
+ * Automatically selects the appropriate function based on whether the payment includes
+ * a witness (recipient address binding).
+ *
+ * @param wallet - The facilitator wallet that will execute the permit transfer
+ * @param paymentPayload - The signed payment payload containing permit2 parameters and signature
+ * @param paymentRequirements - The payment requirements
+ * @returns A SettleResponse containing the transaction status and hash
+ */
+declare function settle$2<transport extends Transport, chain extends Chain>(wallet: SignerWallet<chain, transport>, paymentPayload: Permit2PaymentPayload, paymentRequirements: PaymentRequirements): Promise<SettleResponse>;
+
+declare const index$3_createPayment: typeof createPayment;
+declare const index$3_createPermit2Nonce: typeof createPermit2Nonce;
+declare const index$3_preparePaymentHeader: typeof preparePaymentHeader;
+declare const index$3_signPaymentHeader: typeof signPaymentHeader;
+declare const index$3_signPermit2: typeof signPermit2;
+declare namespace index$3 {
+  export { index$3_createPayment as createPayment, createPaymentHeader$1 as createPaymentHeader, index$3_createPermit2Nonce as createPermit2Nonce, index$3_preparePaymentHeader as preparePaymentHeader, settle$2 as settle, index$3_signPaymentHeader as signPaymentHeader, index$3_signPermit2 as signPermit2, verify$2 as verify };
+}
+
+/**
+ * Encodes a payment payload into a base64 string, ensuring bigint values are properly stringified
+ *
+ * @param payment - The payment payload to encode
+ * @returns A base64 encoded string representation of the payment payload
+ */
+declare function encodePayment(payment: PaymentPayload): string;
+/**
+ * Decodes a base64 encoded payment string back into a PaymentPayload object
+ *
+ * @param payment - The base64 encoded payment string to decode
+ * @returns The decoded and validated PaymentPayload object
+ */
+declare function decodePayment(payment: string): PaymentPayload;
+
+/**
+ * Token 信息
+ */
+interface TokenInfo {
+    name: string;
+    version: string;
+}
+/**
+ * 支持的支付方式
+ */
+type PaymentMethod = "eip3009" | "permit" | "permit2" | "permit2-witness";
+/**
+ * 检测结果
+ */
+interface TokenPaymentCapabilities {
+    address: string;
+    supportedMethods: PaymentMethod[];
+    details: {
+        hasEIP3009: boolean;
+        hasPermit: boolean;
+        hasPermit2Approval: boolean;
+    };
+}
+/**
+ * detect the payment methods supported by the token
+ *
+ * @param tokenAddress - token address
+ * @param client - viem PublicClient
+ * @returns the payment capabilities of the token
+ */
+declare function detectTokenPaymentMethods(tokenAddress: string, client: PublicClient): Promise<TokenPaymentCapabilities>;
+/**
+ * get the recommended payment method for the token
+ *
+ * @param tokenAddress - token address
+ * @param client - viem PublicClient
+ * @returns the recommended payment method
+ */
+declare function getRecommendedPaymentMethod(tokenAddress: string, client: PublicClient): Promise<"eip3009" | "permit" | "permit2" | null>;
+/**
+ * get the name and version information of the token (for EIP-712 signing)
+ *
+ * @param tokenAddress - token address
+ * @param client - viem PublicClient
+ * @returns the name and version information of the token
+ */
+declare function getTokenInfo(tokenAddress: string, client: PublicClient): Promise<TokenInfo>;
+
+/**
+ * Unified verify function that routes to the appropriate authorization type handler
+ *
+ * @param client - The public client used for blockchain interactions
+ * @param payload - The signed payment payload
+ * @param paymentRequirements - The payment requirements that the payload must satisfy
+ * @returns A VerifyResponse indicating if the payment is valid
+ */
+declare function verify$1<transport extends Transport, chain extends Chain, account extends Account | undefined>(client: ConnectedClient<transport, chain, account>, payload: PaymentPayload, paymentRequirements: PaymentRequirements): Promise<VerifyResponse>;
+/**
+ * Unified settle function that routes to the appropriate authorization type handler
+ *
+ * @param wallet - The facilitator wallet that will execute the transaction
+ * @param paymentPayload - The signed payment payload
+ * @param paymentRequirements - The payment requirements
+ * @returns A SettleResponse containing the transaction status and hash
+ */
+declare function settle$1<transport extends Transport, chain extends Chain>(wallet: SignerWallet<chain, transport>, paymentPayload: PaymentPayload, paymentRequirements: PaymentRequirements): Promise<SettleResponse>;
+
+type index$2_PaymentMethod = PaymentMethod;
+type index$2_TokenInfo = TokenInfo;
+type index$2_TokenPaymentCapabilities = TokenPaymentCapabilities;
+declare const index$2_decodePayment: typeof decodePayment;
+declare const index$2_detectTokenPaymentMethods: typeof detectTokenPaymentMethods;
+declare const index$2_encodePayment: typeof encodePayment;
+declare const index$2_getRecommendedPaymentMethod: typeof getRecommendedPaymentMethod;
+declare const index$2_getTokenInfo: typeof getTokenInfo;
+declare namespace index$2 {
+  export { type index$2_PaymentMethod as PaymentMethod, type index$2_TokenInfo as TokenInfo, type index$2_TokenPaymentCapabilities as TokenPaymentCapabilities, index$2_decodePayment as decodePayment, index$2_detectTokenPaymentMethods as detectTokenPaymentMethods, index$5 as eip3009, index$2_encodePayment as encodePayment, index$2_getRecommendedPaymentMethod as getRecommendedPaymentMethod, index$2_getTokenInfo as getTokenInfo, index$4 as permit, index$3 as permit2, settle$1 as settle, verify$1 as verify };
+}
+
+/**
+ * Settle the payment payload against the payment requirements.
+ * TODO: handle durable nonce lifetime transactions
+ *
+ * @param signer - The signer that will sign the transaction
+ * @param payload - The payment payload to settle
+ * @param paymentRequirements - The payment requirements to settle against
+ * @param config - Optional configuration for X402 operations (e.g., custom RPC URLs)
+ * @returns A SettleResponse indicating if the payment is settled and any error reason
+ */
+declare function settle(signer: KeyPairSigner, payload: PaymentPayload, paymentRequirements: PaymentRequirements, config?: X402Config): Promise<SettleResponse>;
+/**
+ * Send a signed transaction to the RPC.
+ * TODO: should this be moved to the shared/svm/rpc.ts file?
+ *
+ * @param signedTransaction - The signed transaction to send
+ * @param rpc - The RPC client to use to send the transaction
+ * @param sendTxConfig - The configuration for the transaction send
+ * @returns The signature of the sent transaction
+ */
+declare function sendSignedTransaction(signedTransaction: Awaited<ReturnType<typeof signTransaction>>, rpc: RpcDevnet<SolanaRpcApiDevnet> | RpcMainnet<SolanaRpcApiMainnet>, sendTxConfig?: Parameters<SendTransactionApi["sendTransaction"]>[1]): Promise<string>;
+/**
+ * Confirm a signed transaction.
+ * TODO: can some of this be refactored to be moved to the shared/svm/rpc.ts file?
+ * TODO: should the commitment and the timeout be passed in as parameters?
+ *
+ * @param signedTransaction - The signed transaction to confirm
+ * @param rpc - The RPC client to use to confirm the transaction
+ * @param rpcSubscriptions - The RPC subscriptions to use to confirm the transaction
+ * @returns The success and signature of the confirmed transaction
+ */
+declare function confirmSignedTransaction(signedTransaction: Awaited<ReturnType<typeof signTransaction>>, rpc: RpcDevnet<SolanaRpcApiDevnet> | RpcMainnet<SolanaRpcApiMainnet>, rpcSubscriptions: ReturnType<typeof getRpcSubscriptions>): Promise<{
+    success: boolean;
+    errorReason?: (typeof ErrorReasons)[number];
+    signature: string;
+}>;
+/**
+ * Send and confirm a signed transaction.
+ *
+ * @param signedTransaction - The signed transaction to send and confirm
+ * @param rpc - The RPC client to use to send and confirm the transaction
+ * @param rpcSubscriptions - The RPC subscriptions to use to send and confirm the transaction
+ * @returns The success and signature of the confirmed transaction
+ */
+declare function sendAndConfirmSignedTransaction(signedTransaction: Awaited<ReturnType<typeof signTransaction>>, rpc: RpcDevnet<SolanaRpcApiDevnet> | RpcMainnet<SolanaRpcApiMainnet>, rpcSubscriptions: ReturnType<typeof getRpcSubscriptions>): Promise<{
+    success: boolean;
+    errorReason?: (typeof ErrorReasons)[number];
+    signature: string;
+}>;
+
+/**
+ * Verify the payment payload against the payment requirements.
+ *
+ * @param signer - The signer that will sign and simulate the transaction
+ * @param payload - The payment payload to verify
+ * @param paymentRequirements - The payment requirements to verify against
+ * @param config - Optional configuration for X402 operations (e.g., custom RPC URLs)
+ * @returns A VerifyResponse indicating if the payment is valid and any invalidation reason
+ */
+declare function verify(signer: KeyPairSigner, payload: PaymentPayload, paymentRequirements: PaymentRequirements, config?: X402Config): Promise<VerifyResponse>;
+/**
+ * Verify that the scheme and network are supported.
+ *
+ * @param payload - The payment payload to verify
+ * @param paymentRequirements - The payment requirements to verify against
+ */
+declare function verifySchemesAndNetworks(payload: PaymentPayload, paymentRequirements: PaymentRequirements): void;
+/**
+ * Perform transaction introspection to validate the transaction structure and transfer details.
+ * This function handles decoding the transaction, validating the transfer instruction,
+ * and verifying all transfer details against the payment requirements.
+ *
+ * @param svmPayload - The SVM payload containing the transaction
+ * @param paymentRequirements - The payment requirements to verify against
+ * @param config - Optional configuration for X402 operations (e.g., custom RPC URLs)
+ */
+declare function transactionIntrospection(svmPayload: ExactSvmPayload, paymentRequirements: PaymentRequirements, config?: X402Config): Promise<void>;
+/**
+ * Verify that the transaction contains the expected instructions.
+ *
+ * @param transactionMessage - The transaction message to verify
+ * @param paymentRequirements - The payment requirements to verify against
+ * @param rpc - The RPC client to use for verifying account existence
+ * @throws Error if the transaction does not contain the expected instructions
+ */
+declare function verifyTransactionInstructions(transactionMessage: CompilableTransactionMessage, paymentRequirements: PaymentRequirements, rpc: RpcDevnet<SolanaRpcApiDevnet> | RpcMainnet<SolanaRpcApiMainnet>): Promise<void>;
+/**
+ * Verify that the compute limit instruction is valid.
+ *
+ * @param instruction - The compute limit instruction to verify
+ * @throws Error if the compute limit instruction is invalid
+ */
+declare function verifyComputeLimitInstruction(instruction: Instruction<string, readonly (AccountLookupMeta<string, string> | AccountMeta<string>)[]>): void;
+/**
+ * Verify that the compute price instruction is valid.
+ * This function throws an error if the compute unit price is greater than 5 lamports,
+ * to protect the facilitator against gas fee abuse from the client.
+ *
+ * @param instruction - The compute price instruction to verify
+ * @throws Error if the compute price instruction is invalid
+ */
+declare function verifyComputePriceInstruction(instruction: Instruction<string, readonly (AccountLookupMeta<string, string> | AccountMeta<string>)[]>): void;
+/**
+ * Verify that the create ATA instruction is valid.
+ *
+ * @param instruction - The create ATA instruction to verify
+ * @param paymentRequirements - The payment requirements to verify against
+ * @throws Error if the create ATA instruction is invalid
+ */
+declare function verifyCreateATAInstruction(instruction: Instruction<string, readonly (AccountLookupMeta<string, string> | AccountMeta<string>)[]>, paymentRequirements: PaymentRequirements): void;
+/**
+ * Verify that the transfer instruction is valid.
+ *
+ * @param instruction - The transfer instruction to verify
+ * @param paymentRequirements - The payment requirements to verify against
+ * @param {object} options - The options for the verification of the transfer instruction
+ * @param {boolean} options.txHasCreateDestATAInstruction - Whether the transaction has a create destination ATA instruction
+ * @param rpc - The RPC client to use for verifying account existence
+ * @throws Error if the transfer instruction is invalid
+ */
+declare function verifyTransferInstruction(instruction: Instruction<string, readonly (AccountLookupMeta<string, string> | AccountMeta<string>)[]>, paymentRequirements: PaymentRequirements, { txHasCreateDestATAInstruction }: {
+    txHasCreateDestATAInstruction: boolean;
+}, rpc: RpcDevnet<SolanaRpcApiDevnet> | RpcMainnet<SolanaRpcApiMainnet>): Promise<void>;
+/**
+ * Verify that the transfer checked instruction is valid.
+ *
+ * @param parsedInstruction - The parsed transfer checked instruction to verify
+ * @param paymentRequirements - The payment requirements to verify against
+ * @param {object} options - The options for the verification of the transfer checked instruction
+ * @param {boolean} options.txHasCreateDestATAInstruction - Whether the transaction has a create destination ATA instruction
+ * @param rpc - The RPC client to use for verifying account existence
+ * @throws Error if the transfer checked instruction is invalid
+ */
+declare function verifyTransferCheckedInstruction(parsedInstruction: ReturnType<typeof parseTransferCheckedInstruction>, paymentRequirements: PaymentRequirements, { txHasCreateDestATAInstruction }: {
+    txHasCreateDestATAInstruction: boolean;
+}, rpc: RpcDevnet<SolanaRpcApiDevnet> | RpcMainnet<SolanaRpcApiMainnet>): Promise<void>;
+/**
+ * Inspect the decompiled transaction message to make sure that it is a valid
+ * transfer instruction.
+ *
+ * @param instruction - The instruction to get the transfer instruction from
+ * @returns The validated transfer instruction
+ * @throws Error if the instruction is not a valid transfer checked instruction
+ */
+declare function getValidatedTransferCheckedInstruction(instruction: Instruction<string, readonly (AccountLookupMeta<string, string> | AccountMeta<string>)[]>): _solana_program_token.ParsedTransferCheckedInstruction<string, readonly (AccountLookupMeta<string, string> | AccountMeta<string>)[]>;
+
+/**
+ * Creates and encodes a payment header for the given client and payment requirements.
+ *
+ * @param client - The signer instance used to create the payment header
+ * @param x402Version - The version of the X402 protocol to use
+ * @param paymentRequirements - The payment requirements containing scheme and network information
+ * @param config - Optional configuration for X402 operations (e.g., custom RPC URLs)
+ * @returns A promise that resolves to a base64 encoded payment header string
+ */
+declare function createPaymentHeader(client: KeyPairSigner, x402Version: number, paymentRequirements: PaymentRequirements, config?: X402Config): Promise<string>;
+/**
+ * Creates and signs a payment for the given client and payment requirements.
+ *
+ * @param client - The signer instance used to create and sign the payment tx
+ * @param x402Version - The version of the X402 protocol to use
+ * @param paymentRequirements - The payment requirements
+ * @param config - Optional configuration for X402 operations (e.g., custom RPC URLs)
+ * @returns A promise that resolves to a payment payload containing a base64 encoded solana token transfer tx
+ */
+declare function createAndSignPayment(client: KeyPairSigner, x402Version: number, paymentRequirements: PaymentRequirements, config?: X402Config): Promise<PaymentPayload>;
+
+declare const index$1_confirmSignedTransaction: typeof confirmSignedTransaction;
+declare const index$1_createAndSignPayment: typeof createAndSignPayment;
+declare const index$1_createPaymentHeader: typeof createPaymentHeader;
+declare const index$1_getValidatedTransferCheckedInstruction: typeof getValidatedTransferCheckedInstruction;
+declare const index$1_sendAndConfirmSignedTransaction: typeof sendAndConfirmSignedTransaction;
+declare const index$1_sendSignedTransaction: typeof sendSignedTransaction;
+declare const index$1_settle: typeof settle;
+declare const index$1_transactionIntrospection: typeof transactionIntrospection;
+declare const index$1_verify: typeof verify;
+declare const index$1_verifyComputeLimitInstruction: typeof verifyComputeLimitInstruction;
+declare const index$1_verifyComputePriceInstruction: typeof verifyComputePriceInstruction;
+declare const index$1_verifyCreateATAInstruction: typeof verifyCreateATAInstruction;
+declare const index$1_verifySchemesAndNetworks: typeof verifySchemesAndNetworks;
+declare const index$1_verifyTransactionInstructions: typeof verifyTransactionInstructions;
+declare const index$1_verifyTransferCheckedInstruction: typeof verifyTransferCheckedInstruction;
+declare const index$1_verifyTransferInstruction: typeof verifyTransferInstruction;
+declare namespace index$1 {
+  export { index$1_confirmSignedTransaction as confirmSignedTransaction, index$1_createAndSignPayment as createAndSignPayment, index$1_createPaymentHeader as createPaymentHeader, index$1_getValidatedTransferCheckedInstruction as getValidatedTransferCheckedInstruction, index$1_sendAndConfirmSignedTransaction as sendAndConfirmSignedTransaction, index$1_sendSignedTransaction as sendSignedTransaction, index$1_settle as settle, index$1_transactionIntrospection as transactionIntrospection, index$1_verify as verify, index$1_verifyComputeLimitInstruction as verifyComputeLimitInstruction, index$1_verifyComputePriceInstruction as verifyComputePriceInstruction, index$1_verifyCreateATAInstruction as verifyCreateATAInstruction, index$1_verifySchemesAndNetworks as verifySchemesAndNetworks, index$1_verifyTransactionInstructions as verifyTransactionInstructions, index$1_verifyTransferCheckedInstruction as verifyTransferCheckedInstruction, index$1_verifyTransferInstruction as verifyTransferInstruction };
+}
+
+declare const SCHEME = "exact";
+
+declare const index_SCHEME: typeof SCHEME;
+declare namespace index {
+  export { index_SCHEME as SCHEME, index$2 as evm, index$1 as svm };
+}
+
+export { decodePayment, encodePayment, index as exact };

package/dist/esm/schemes/index.mjs

@@ -1,11 +1,11 @@
 import {
   exact_exports
-} from "../chunk-57UEJN5U.mjs";
+} from "../chunk-XGQBEMP7.mjs";
 import {
   decodePayment,
   encodePayment
-} from "../chunk-RX2JKK4O.mjs";
-import "../chunk-UCBE7FDY.mjs";
+} from "../chunk-VTLJOZXM.mjs";
+import "../chunk-NPWDNT2P.mjs";
 import "../chunk-5LTKIVOA.mjs";
 import "../chunk-AQQR4PXH.mjs";
 export {