sf-x402x 0.6.6-patch.3

package/dist/esm/rpc-22QIQWIu.d.mts

@@ -0,0 +1,35 @@
+import { RpcDevnet, SolanaRpcApiDevnet, RpcMainnet, SolanaRpcApiMainnet, RpcSubscriptionsFromTransport, SolanaRpcSubscriptionsApi, RpcSubscriptionsTransportFromClusterUrl, ClusterUrl } from '@solana/kit';
+import { N as Network } from './network--RYzQfBg.mjs';
+
+/**
+ * Creates a Solana RPC client for the devnet network.
+ *
+ * @param url - Optional URL of the devnet network.
+ * @returns A Solana RPC client.
+ */
+declare function createDevnetRpcClient(url?: string): RpcDevnet<SolanaRpcApiDevnet>;
+/**
+ * Creates a Solana RPC client for the mainnet network.
+ *
+ * @param url - Optional URL of the mainnet network.
+ * @returns A Solana RPC client.
+ */
+declare function createMainnetRpcClient(url?: string): RpcMainnet<SolanaRpcApiMainnet>;
+/**
+ * Gets the RPC client for the given network.
+ *
+ * @param network - The network to get the RPC client for
+ * @param url - Optional URL of the network. If not provided, the default URL will be used.
+ * @returns The RPC client for the given network
+ */
+declare function getRpcClient(network: Network, url?: string): RpcDevnet<SolanaRpcApiDevnet> | RpcMainnet<SolanaRpcApiMainnet>;
+/**
+ * Gets the RPC subscriptions for the given network.
+ *
+ * @param network - The network to get the RPC subscriptions for
+ * @param url - Optional URL of the network. If not provided, the default URL will be used.
+ * @returns The RPC subscriptions for the given network
+ */
+declare function getRpcSubscriptions(network: Network, url?: string): RpcSubscriptionsFromTransport<SolanaRpcSubscriptionsApi, RpcSubscriptionsTransportFromClusterUrl<ClusterUrl>>;
+
+export { createMainnetRpcClient as a, getRpcSubscriptions as b, createDevnetRpcClient as c, getRpcClient as g };

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

@@ -0,0 +1,298 @@
+import { Address, Transport, Chain, LocalAccount, Account } from 'viem';
+import { S as SignerWallet, C as ConnectedClient } from '../wallet-BReyvAJs.mjs';
+import { P as PaymentRequirements, U as UnsignedPaymentPayload, a as PaymentPayload, u as VerifyResponse, S as SettleResponse, b as ErrorReasons, E as ExactSvmPayload } from '../x402Specs-7OH8g851.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-22QIQWIu.mjs';
+import * as _solana_program_token from '@solana-program/token';
+import { parseTransferCheckedInstruction } from '@solana-program/token-2022';
+import 'viem/chains';
+import 'zod';
+import '../network--RYzQfBg.mjs';
+
+/**
+ * Prepares an unsigned 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 payment payload containing authorization details
+ */
+declare function preparePaymentHeader(from: Address, x402Version: number, paymentRequirements: PaymentRequirements): UnsignedPaymentPayload;
+/**
+ * Signs a 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 payment payload to be signed
+ * @returns A promise that resolves to the signed payment payload
+ */
+declare function signPaymentHeader<transport extends Transport, chain extends Chain>(client: SignerWallet<chain, transport> | LocalAccount, paymentRequirements: PaymentRequirements, unsignedPaymentHeader: UnsignedPaymentPayload): Promise<PaymentPayload>;
+/**
+ * Creates a complete 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 payment payload
+ */
+declare function createPayment<transport extends Transport, chain extends Chain>(client: SignerWallet<chain, transport> | LocalAccount, x402Version: number, paymentRequirements: PaymentRequirements): Promise<PaymentPayload>;
+/**
+ * Creates and encodes a 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>;
+
+/**
+ * Verifies a 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$1<transport extends Transport, chain extends Chain, account extends Account | undefined>(client: ConnectedClient<transport, chain, account>, payload: PaymentPayload, paymentRequirements: PaymentRequirements): Promise<VerifyResponse>;
+/**
+ * Settles a 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$1<transport extends Transport, chain extends Chain>(wallet: SignerWallet<chain, transport>, paymentPayload: PaymentPayload, paymentRequirements: PaymentRequirements): Promise<SettleResponse>;
+
+/**
+ * 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;
+
+declare const index$2_createPayment: typeof createPayment;
+declare const index$2_decodePayment: typeof decodePayment;
+declare const index$2_encodePayment: typeof encodePayment;
+declare const index$2_preparePaymentHeader: typeof preparePaymentHeader;
+declare const index$2_signPaymentHeader: typeof signPaymentHeader;
+declare namespace index$2 {
+  export { index$2_createPayment as createPayment, createPaymentHeader$1 as createPaymentHeader, index$2_decodePayment as decodePayment, index$2_encodePayment as encodePayment, index$2_preparePaymentHeader as preparePaymentHeader, settle$1 as settle, index$2_signPaymentHeader as signPaymentHeader, 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

@@ -0,0 +1,16 @@
+import {
+  exact_exports
+} from "../chunk-MWDK4RSB.mjs";
+import {
+  decodePayment,
+  encodePayment
+} from "../chunk-R2NI44QI.mjs";
+import "../chunk-XZA3USQF.mjs";
+import "../chunk-7CWEZNFA.mjs";
+import "../chunk-5UPAZUO6.mjs";
+export {
+  decodePayment,
+  encodePayment,
+  exact_exports as exact
+};
+//# sourceMappingURL=index.mjs.map

package/dist/esm/schemes/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/esm/shared/evm/index.d.mts

@@ -0,0 +1,55 @@
+import { Transport, Chain, Account, Client, Address } from 'viem';
+import { C as ChainConfig } from '../../config-CFBSAuxW.mjs';
+import { C as ConnectedClient } from '../../wallet-BReyvAJs.mjs';
+import '@solana/kit';
+import 'viem/chains';
+
+/**
+ * Gets the USDC contract address for the current chain from the client
+ *
+ * @param client - The Viem client instance connected to the blockchain
+ * @returns The USDC contract address for the current chain
+ */
+declare function getUsdcAddress<transport extends Transport, chain extends Chain | undefined = undefined, account extends Account | undefined = undefined>(client: Client<transport, chain, account>): Address;
+/**
+ * Gets the USDC contract address for a specific chain ID
+ *
+ * @deprecated Use `getUsdcChainConfigForChain` instead
+ * @param chainId - The chain ID to get the USDC contract address for
+ * @returns The USDC contract address for the specified chain
+ */
+declare function getUsdcAddressForChain(chainId: number): Address;
+/**
+ * Gets the USDC address and eip712 domain name for a specific chain ID
+ *
+ * @param chainId - The chain ID
+ * @returns The USDC contract address and eip712 domain name  for the specified chain
+ */
+declare function getUsdcChainConfigForChain(chainId: number): ChainConfig | undefined;
+/**
+ * Gets the version of the USDC contract, using a cache to avoid repeated calls
+ *
+ * @param client - The Viem client instance connected to the blockchain
+ * @returns A promise that resolves to the USDC contract version string
+ */
+declare function getVersion<transport extends Transport, chain extends Chain, account extends Account | undefined = undefined>(client: ConnectedClient<transport, chain, account>): Promise<string>;
+/**
+ * Gets the USDC balance for a specific address
+ *
+ * @param client - The Viem client instance connected to the blockchain
+ * @param address - The address to check the USDC balance for
+ * @returns A promise that resolves to the USDC balance as a bigint
+ */
+declare function getUSDCBalance<transport extends Transport, chain extends Chain, account extends Account | undefined = undefined>(client: ConnectedClient<transport, chain, account>, address: Address): Promise<bigint>;
+
+/**
+ * Gets the USDC balance for a specific address
+ *
+ * @param client - The Viem client instance connected to the blockchain
+ * @param erc20Address - The address of the ERC20 contract
+ * @param address - The address to check the USDC balance for
+ * @returns A promise that resolves to the USDC balance as a bigint
+ */
+declare function getERC20Balance<transport extends Transport, chain extends Chain, account extends Account | undefined = undefined>(client: ConnectedClient<transport, chain, account>, erc20Address: Address, address: Address): Promise<bigint>;
+
+export { getERC20Balance, getUSDCBalance, getUsdcAddress, getUsdcAddressForChain, getUsdcChainConfigForChain, getVersion };

package/dist/esm/shared/evm/index.mjs

@@ -0,0 +1,18 @@
+import {
+  getERC20Balance,
+  getUSDCBalance,
+  getUsdcAddress,
+  getUsdcAddressForChain,
+  getUsdcChainConfigForChain,
+  getVersion
+} from "../../chunk-7CWEZNFA.mjs";
+import "../../chunk-5UPAZUO6.mjs";
+export {
+  getERC20Balance,
+  getUSDCBalance,
+  getUsdcAddress,
+  getUsdcAddressForChain,
+  getUsdcChainConfigForChain,
+  getVersion
+};
+//# sourceMappingURL=index.mjs.map

package/dist/esm/shared/evm/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

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

@@ -0,0 +1,181 @@
+import { N as Network } from '../network--RYzQfBg.mjs';
+import * as _solana_kit from '@solana/kit';
+import { Transaction, KeyPairSigner, RpcDevnet, SolanaRpcApiDevnet, RpcMainnet, SolanaRpcApiMainnet } from '@solana/kit';
+import { Hex, Address } from 'viem';
+import { R as RoutesConfig, a as RoutePattern, P as Price, E as ERC20TokenAmount, S as SPLTokenAmount } from '../middleware-CAOp-bv4.mjs';
+import { P as PaymentRequirements, a as PaymentPayload, E as ExactSvmPayload } from '../x402Specs-7OH8g851.mjs';
+import { c as createDevnetRpcClient, a as createMainnetRpcClient, g as getRpcClient, b as getRpcSubscriptions } from '../rpc-22QIQWIu.mjs';
+import { a as SvmConnectedClient, S as SvmSigner, c as createSignerFromBase58, b as createSvmConnectedClient, i as isSignerWallet } from '../wallet-BTqCm9Zp.mjs';
+import 'zod';
+import '../wallet-BReyvAJs.mjs';
+import 'viem/chains';
+
+/**
+ * Converts an object to a JSON-safe format by converting bigint values to strings
+ * and recursively processing nested objects and arrays
+ *
+ * @param data - The object to convert to JSON-safe format
+ * @returns A new object with all bigint values converted to strings
+ */
+declare function toJsonSafe<T extends object>(data: T): object;
+
+declare const Base64EncodedRegex: RegExp;
+/**
+ * Encodes a string to base64 format
+ *
+ * @param data - The string to be encoded to base64
+ * @returns The base64 encoded string
+ */
+declare function safeBase64Encode(data: string): string;
+/**
+ * Decodes a base64 string back to its original format
+ *
+ * @param data - The base64 encoded string to be decoded
+ * @returns The decoded string in UTF-8 format
+ */
+declare function safeBase64Decode(data: string): string;
+
+/**
+ * Converts a network name to its corresponding chain ID
+ *
+ * @param network - The network name to convert to a chain ID
+ * @returns The chain ID for the specified network
+ * @throws Error if the network is not supported
+ */
+declare function getNetworkId(network: Network): number;
+
+/**
+ * Computes the route patterns for the given routes config
+ *
+ * @param routes - The routes config to compute the patterns for
+ * @returns The route patterns
+ */
+declare function computeRoutePatterns(routes: RoutesConfig): RoutePattern[];
+/**
+ * Finds the matching route pattern for the given path and method
+ *
+ * @param routePatterns - The route patterns to search through
+ * @param path - The path to match against
+ * @param method - The HTTP method to match against
+ * @returns The matching route pattern or undefined if no match is found
+ */
+declare function findMatchingRoute(routePatterns: RoutePattern[], path: string, method: string): RoutePattern | undefined;
+/**
+ * Gets the default asset (USDC) for the given network
+ *
+ * @param network - The network to get the default asset for
+ * @returns The default asset
+ */
+declare function getDefaultAsset(network: Network): {
+    address: `0x${string}` | _solana_kit.Address;
+    decimals: number;
+    eip712: {
+        name: string;
+        version: string;
+    };
+};
+/**
+ * Parses the amount from the given price
+ *
+ * @param price - The price to parse
+ * @param network - The network to get the default asset for
+ * @returns The parsed amount or an error message
+ */
+declare function processPriceToAtomicAmount(price: Price, network: Network): {
+    maxAmountRequired: string;
+    asset: ERC20TokenAmount["asset"] | SPLTokenAmount["asset"];
+} | {
+    error: string;
+};
+/**
+ * Finds the matching payment requirements for the given payment
+ *
+ * @param paymentRequirements - The payment requirements to search through
+ * @param payment - The payment to match against
+ * @returns The matching payment requirements or undefined if no match is found
+ */
+declare function findMatchingPaymentRequirements(paymentRequirements: PaymentRequirements[], payment: PaymentPayload): {
+    scheme: "exact";
+    description: string;
+    asset: string;
+    maxAmountRequired: string;
+    network: "base-sepolia" | "avalanche-fuji" | "base" | "avalanche" | "sei" | "sei-testnet" | "polygon" | "polygon-amoy" | "peaq" | "iotex" | "x-layer" | "x-layer-testnet" | "solana-devnet" | "solana" | "sepolia" | "filecoin-calibration";
+    resource: string;
+    mimeType: string;
+    payTo: string;
+    maxTimeoutSeconds: number;
+    outputSchema?: Record<string, any> | undefined;
+    extra?: Record<string, any> | undefined;
+} | undefined;
+/**
+ * Decodes the X-PAYMENT-RESPONSE header
+ *
+ * @param header - The X-PAYMENT-RESPONSE header to decode
+ * @returns The decoded payment response
+ */
+declare function decodeXPaymentResponse(header: string): {
+    success: boolean;
+    transaction: Hex;
+    network: Network;
+    payer: Address;
+};
+
+/**
+ * Given an object with a base64 encoded transaction, decode the
+ * base64 encoded transaction into a solana transaction object.
+ *
+ * @param svmPayload - The SVM payload to decode
+ * @returns The decoded transaction
+ */
+declare function decodeTransactionFromPayload(svmPayload: ExactSvmPayload): Transaction;
+/**
+ * Extract the token sender (owner of the source token account)
+ * from the TransferChecked instruction.
+ *
+ * @param transaction - The transaction to extract the token payer from
+ * @returns The token payer address as a base58 string
+ */
+declare function getTokenPayerFromTransaction(transaction: Transaction): string;
+/**
+ * Sign and simulate a transaction.
+ *
+ * @param signer - The signer that will sign the transaction
+ * @param transaction - The transaction to sign and simulate
+ * @param rpc - The RPC client to use to simulate the transaction
+ * @returns The transaction simulation result
+ */
+declare function signAndSimulateTransaction(signer: KeyPairSigner, transaction: Transaction, rpc: RpcDevnet<SolanaRpcApiDevnet> | RpcMainnet<SolanaRpcApiMainnet>): Promise<Readonly<{
+    context: Readonly<{
+        slot: _solana_kit.Slot;
+    }>;
+    value: Readonly<{
+        readonly accounts: null;
+    }> & Readonly<{
+        err: _solana_kit.TransactionError | null;
+        logs: string[] | null;
+        returnData: Readonly<{
+            data: _solana_kit.Base64EncodedDataResponse;
+            programId: _solana_kit.Address;
+        }> | null;
+        unitsConsumed?: bigint;
+    }>;
+}>>;
+
+declare const index_KeyPairSigner: typeof KeyPairSigner;
+declare const index_SvmConnectedClient: typeof SvmConnectedClient;
+declare const index_SvmSigner: typeof SvmSigner;
+declare const index_createDevnetRpcClient: typeof createDevnetRpcClient;
+declare const index_createMainnetRpcClient: typeof createMainnetRpcClient;
+declare const index_createSignerFromBase58: typeof createSignerFromBase58;
+declare const index_createSvmConnectedClient: typeof createSvmConnectedClient;
+declare const index_decodeTransactionFromPayload: typeof decodeTransactionFromPayload;
+declare const index_getRpcClient: typeof getRpcClient;
+declare const index_getRpcSubscriptions: typeof getRpcSubscriptions;
+declare const index_getTokenPayerFromTransaction: typeof getTokenPayerFromTransaction;
+declare const index_isSignerWallet: typeof isSignerWallet;
+declare const index_signAndSimulateTransaction: typeof signAndSimulateTransaction;
+declare namespace index {
+  export { index_KeyPairSigner as KeyPairSigner, index_SvmConnectedClient as SvmConnectedClient, index_SvmSigner as SvmSigner, index_createDevnetRpcClient as createDevnetRpcClient, index_createMainnetRpcClient as createMainnetRpcClient, index_createSignerFromBase58 as createSignerFromBase58, index_createSvmConnectedClient as createSvmConnectedClient, index_decodeTransactionFromPayload as decodeTransactionFromPayload, index_getRpcClient as getRpcClient, index_getRpcSubscriptions as getRpcSubscriptions, index_getTokenPayerFromTransaction as getTokenPayerFromTransaction, index_isSignerWallet as isSignerWallet, index_signAndSimulateTransaction as signAndSimulateTransaction };
+}
+
+export { Base64EncodedRegex, computeRoutePatterns, decodeXPaymentResponse, findMatchingPaymentRequirements, findMatchingRoute, getDefaultAsset, getNetworkId, processPriceToAtomicAmount, safeBase64Decode, safeBase64Encode, index as svm, toJsonSafe };

package/dist/esm/shared/index.mjs

@@ -0,0 +1,31 @@
+import {
+  Base64EncodedRegex,
+  computeRoutePatterns,
+  decodeXPaymentResponse,
+  findMatchingPaymentRequirements,
+  findMatchingRoute,
+  getDefaultAsset,
+  getNetworkId,
+  processPriceToAtomicAmount,
+  safeBase64Decode,
+  safeBase64Encode,
+  svm_exports2 as svm_exports,
+  toJsonSafe
+} from "../chunk-XZA3USQF.mjs";
+import "../chunk-7CWEZNFA.mjs";
+import "../chunk-5UPAZUO6.mjs";
+export {
+  Base64EncodedRegex,
+  computeRoutePatterns,
+  decodeXPaymentResponse,
+  findMatchingPaymentRequirements,
+  findMatchingRoute,
+  getDefaultAsset,
+  getNetworkId,
+  processPriceToAtomicAmount,
+  safeBase64Decode,
+  safeBase64Encode,
+  svm_exports as svm,
+  toJsonSafe
+};
+//# sourceMappingURL=index.mjs.map

package/dist/esm/shared/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}