@atxp/client 0.8.3 → 0.9.1

package/dist/index.js

@@ -1,15 +1,7 @@
-import { crypto as crypto$1, OAuthResourceClient, ConsoleLogger, PAYMENT_REQUIRED_ERROR_CODE, isSSEResponse, parseMcpMessages, parsePaymentRequests, paymentRequiredError, DEFAULT_AUTHORIZATION_SERVER, getIsReactNative, createReactNativeSafeFetch, isEnumValue, ChainEnum, CurrencyEnum, NetworkEnum, assertNever, DEFAULT_ATXP_ACCOUNTS_SERVER, MemoryOAuthDb, ATXPAccount, generateJWT } from '@atxp/common';
+import { crypto as crypto$1, OAuthResourceClient, ConsoleLogger, getErrorRecoveryHint, PAYMENT_REQUIRED_ERROR_CODE, isSSEResponse, parseMcpMessages, parsePaymentRequests, paymentRequiredError, DEFAULT_AUTHORIZATION_SERVER, getIsReactNative, createReactNativeSafeFetch, isEnumValue, ChainEnum, CurrencyEnum, NetworkEnum, assertNever, DEFAULT_ATXP_ACCOUNTS_SERVER, MemoryOAuthDb, ATXPAccount } from '@atxp/common';
 export { ATXPAccount } from '@atxp/common';
 import * as oauth from 'oauth4webapi';
-import BigNumber$1, { BigNumber } from 'bignumber.js';
-import { PublicKey, ComputeBudgetProgram, sendAndConfirmTransaction, Connection, Keypair } from '@solana/web3.js';
-import { ValidateTransferError as ValidateTransferError$1, createTransfer } from '@solana/pay';
-import { getAssociatedTokenAddress, getAccount } from '@solana/spl-token';
-import bs58 from 'bs58';
-import { importJWK } from 'jose';
-import { publicActions, encodeFunctionData, parseEther, createWalletClient, http } from 'viem';
-import { base } from 'viem/chains';
-import { privateKeyToAccount } from 'viem/accounts';
+import { BigNumber } from 'bignumber.js';
 
 class OAuthAuthenticationRequiredError extends Error {
     constructor(url, resourceServerUrl, 
@@ -283,25 +275,153 @@ class OAuthClient extends OAuthResourceClient {
     }
 }
 
-class InsufficientFundsError extends Error {
+/**
+ * Base class for all ATXP payment errors with structured error codes and actionable guidance
+ */
+class ATXPPaymentError extends Error {
+    constructor(message, context) {
+        super(message);
+        this.context = context;
+        this.name = this.constructor.name;
+    }
+}
+/**
+ * Thrown when the user's wallet has insufficient funds for a payment
+ */
+class InsufficientFundsError extends ATXPPaymentError {
     constructor(currency, required, available, network) {
+        const shortfall = available ? required.minus(available).toString() : required.toString();
         const availableText = available ? `, Available: ${available}` : '';
         const networkText = network ? ` on ${network}` : '';
         super(`Payment failed due to insufficient ${currency} funds${networkText}. ` +
             `Required: ${required}${availableText}. ` +
-            `Please ensure your account has adequate balance before retrying.`);
+            `Please ensure your account has adequate balance before retrying.`, { currency, required: required.toString(), available: available?.toString(), network, shortfall });
         this.currency = currency;
         this.required = required;
         this.available = available;
         this.network = network;
-        this.name = 'InsufficientFundsError';
+        this.code = 'INSUFFICIENT_FUNDS';
+        this.retryable = true;
+        this.actionableMessage = available
+            ? `Add at least ${shortfall} ${currency} to your ${network} wallet and try again.`
+            : `Ensure your ${network} wallet has at least ${required} ${currency} and try again.`;
     }
 }
-class PaymentNetworkError extends Error {
-    constructor(message, originalError) {
-        super(`Payment failed due to network error: ${message}`);
+/**
+ * Thrown when a blockchain transaction is reverted
+ */
+class TransactionRevertedError extends ATXPPaymentError {
+    constructor(transactionHash, network, revertReason) {
+        super(`Transaction ${transactionHash} reverted on ${network}${revertReason ? `: ${revertReason}` : ''}`, { transactionHash, network, revertReason });
+        this.transactionHash = transactionHash;
+        this.network = network;
+        this.revertReason = revertReason;
+        this.code = 'TRANSACTION_REVERTED';
+        this.retryable = false;
+        // Provide specific guidance based on revert reason
+        if (revertReason?.toLowerCase().includes('allowance')) {
+            this.actionableMessage = 'Approve token spending before making the payment. You may need to increase the token allowance.';
+        }
+        else if (revertReason?.toLowerCase().includes('balance')) {
+            this.actionableMessage = 'Ensure your wallet has sufficient token balance and native token for gas fees.';
+        }
+        else {
+            this.actionableMessage = 'The transaction was rejected by the blockchain. Check the transaction details on a block explorer and verify your wallet settings.';
+        }
+    }
+}
+/**
+ * Thrown when an unsupported currency is requested
+ */
+class UnsupportedCurrencyError extends ATXPPaymentError {
+    constructor(currency, network, supportedCurrencies) {
+        super(`Currency ${currency} is not supported on ${network}`, { currency, network, supportedCurrencies });
+        this.currency = currency;
+        this.network = network;
+        this.supportedCurrencies = supportedCurrencies;
+        this.code = 'UNSUPPORTED_CURRENCY';
+        this.retryable = false;
+        this.actionableMessage = `Please use one of the supported currencies: ${supportedCurrencies.join(', ')}`;
+    }
+}
+/**
+ * Thrown when gas estimation fails for a transaction
+ */
+class GasEstimationError extends ATXPPaymentError {
+    constructor(network, reason) {
+        super(`Failed to estimate gas on ${network}${reason ? `: ${reason}` : ''}`, { network, reason });
+        this.network = network;
+        this.reason = reason;
+        this.code = 'GAS_ESTIMATION_FAILED';
+        this.retryable = true;
+        this.actionableMessage = 'Unable to estimate gas for this transaction. Ensure you have sufficient funds for both the payment amount and gas fees, then try again.';
+    }
+}
+/**
+ * Thrown when RPC/network connectivity fails
+ */
+class RpcError extends ATXPPaymentError {
+    constructor(network, rpcUrl, originalError) {
+        super(`RPC call failed on ${network}${rpcUrl ? ` (${rpcUrl})` : ''}`, { network, rpcUrl, originalError: originalError?.message });
+        this.network = network;
+        this.rpcUrl = rpcUrl;
         this.originalError = originalError;
-        this.name = 'PaymentNetworkError';
+        this.code = 'RPC_ERROR';
+        this.retryable = true;
+        this.actionableMessage = 'Unable to connect to the blockchain network. Please check your internet connection and try again.';
+    }
+}
+/**
+ * Thrown when the user rejects a transaction in their wallet
+ */
+class UserRejectedError extends ATXPPaymentError {
+    constructor(network) {
+        super(`User rejected transaction on ${network}`, { network });
+        this.network = network;
+        this.code = 'USER_REJECTED';
+        this.retryable = true;
+        this.actionableMessage = 'You cancelled the transaction. To complete the payment, please approve the transaction in your wallet.';
+    }
+}
+/**
+ * Thrown when the payment server returns an error
+ */
+class PaymentServerError extends ATXPPaymentError {
+    constructor(statusCode, endpoint, serverMessage, errorCode, details) {
+        super(`Payment server returned ${statusCode} from ${endpoint}${serverMessage ? `: ${serverMessage}` : ''}`, { statusCode, endpoint, serverMessage, errorCode, details });
+        this.statusCode = statusCode;
+        this.endpoint = endpoint;
+        this.serverMessage = serverMessage;
+        this.details = details;
+        this.retryable = true;
+        this.actionableMessage = 'The payment server encountered an error. Please try again in a few moments.';
+        this.code = errorCode || 'PAYMENT_SERVER_ERROR';
+    }
+}
+/**
+ * Thrown when a payment request has expired
+ */
+class PaymentExpiredError extends ATXPPaymentError {
+    constructor(paymentRequestId, expiresAt) {
+        super(`Payment request ${paymentRequestId} has expired`, { paymentRequestId, expiresAt: expiresAt?.toISOString() });
+        this.paymentRequestId = paymentRequestId;
+        this.expiresAt = expiresAt;
+        this.code = 'PAYMENT_EXPIRED';
+        this.retryable = false;
+        this.actionableMessage = 'This payment request has expired. Please make a new request to the service.';
+    }
+}
+/**
+ * Generic network error for backward compatibility and uncategorized errors
+ */
+class PaymentNetworkError extends ATXPPaymentError {
+    constructor(network, message, originalError) {
+        super(`Payment failed on ${network} network: ${message}`, { network, originalError: originalError?.message });
+        this.network = network;
+        this.originalError = originalError;
+        this.code = 'NETWORK_ERROR';
+        this.retryable = true;
+        this.actionableMessage = 'A network error occurred during payment processing. Please try again.';
     }
 }
 
@@ -326,27 +446,41 @@ function atxpFetch(config) {
         onAuthorize: config.onAuthorize,
         onAuthorizeFailure: config.onAuthorizeFailure,
         onPayment: config.onPayment,
-        onPaymentFailure: config.onPaymentFailure
+        onPaymentFailure: config.onPaymentFailure,
+        onPaymentAttemptFailed: config.onPaymentAttemptFailed
     });
     return fetcher.fetch;
 }
 class ATXPFetcher {
     constructor(config) {
-        this.defaultPaymentFailureHandler = async ({ payment, error }) => {
+        this.defaultPaymentFailureHandler = async (context) => {
+            const { payment, error, attemptedNetworks, retryable } = context;
+            const recoveryHint = getErrorRecoveryHint(error);
+            this.logger.info(`PAYMENT FAILED: ${recoveryHint.title}`);
+            this.logger.info(`Description: ${recoveryHint.description}`);
+            if (attemptedNetworks.length > 0) {
+                this.logger.info(`Attempted networks: ${attemptedNetworks.join(', ')}`);
+            }
+            this.logger.info(`Account: ${payment.accountId}`);
+            // Log actionable guidance
+            if (recoveryHint.actions.length > 0) {
+                this.logger.info(`What to do:`);
+                recoveryHint.actions.forEach((action, index) => {
+                    this.logger.info(`  ${index + 1}. ${action}`);
+                });
+            }
+            if (retryable) {
+                this.logger.info(`This payment can be retried.`);
+            }
+            // Log additional context for specific error types
             if (error instanceof InsufficientFundsError) {
-                const networkText = error.network ? ` on ${error.network}` : '';
-                this.logger.info(`PAYMENT FAILED: Insufficient ${error.currency} funds${networkText}`);
                 this.logger.info(`Required: ${error.required} ${error.currency}`);
                 if (error.available) {
                     this.logger.info(`Available: ${error.available} ${error.currency}`);
                 }
-                this.logger.info(`Account: ${payment.accountId}`);
             }
-            else if (error instanceof PaymentNetworkError) {
-                this.logger.info(`PAYMENT FAILED: Network error: ${error.message}`);
-            }
-            else {
-                this.logger.info(`PAYMENT FAILED: ${error.message}`);
+            else if (error instanceof ATXPPaymentError && error.context) {
+                this.logger.debug(`Error context: ${JSON.stringify(error.context)}`);
             }
         };
         this.handleMultiDestinationPayment = async (paymentRequest, paymentRequestUrl, paymentRequestId) => {
@@ -391,9 +525,11 @@ class ATXPFetcher {
                 this.logger.info(`ATXP: payment request denied by callback function`);
                 return false;
             }
-            // Try each payment maker in order
+            // Try each payment maker in order, tracking attempts
             let lastPaymentError = null;
             let paymentAttempted = false;
+            const attemptedNetworks = [];
+            const failureReasons = new Map();
             for (const paymentMaker of this.account.paymentMakers) {
                 try {
                     // Pass all destinations to payment maker - it will filter and pick the one it can handle
@@ -405,7 +541,11 @@ class ATXPFetcher {
                     paymentAttempted = true;
                     // Payment was successful
                     this.logger.info(`ATXP: made payment of ${firstDest.amount.toString()} ${firstDest.currency} on ${result.chain}: ${result.transactionId}`);
-                    await this.onPayment({ payment: prospectivePayment });
+                    await this.onPayment({
+                        payment: prospectivePayment,
+                        transactionHash: result.transactionId,
+                        network: result.chain
+                    });
                     // Submit payment to the server
                     const jwt = await paymentMaker.generateJWT({ paymentRequestId, codeChallenge: '', accountId: this.account.accountId });
                     const response = await this.sideChannelFetch(paymentRequestUrl.toString(), {
@@ -433,13 +573,41 @@ class ATXPFetcher {
                     const typedError = error;
                     paymentAttempted = true;
                     lastPaymentError = typedError;
-                    this.logger.warn(`ATXP: payment maker failed: ${typedError.message}`);
-                    await this.onPaymentFailure({ payment: prospectivePayment, error: typedError });
+                    // Extract network from error context if available
+                    let network = 'unknown';
+                    if (typedError instanceof ATXPPaymentError && typedError.context?.network) {
+                        network = typeof typedError.context.network === 'string' ? typedError.context.network : 'unknown';
+                    }
+                    attemptedNetworks.push(network);
+                    failureReasons.set(network, typedError);
+                    this.logger.warn(`ATXP: payment maker failed on ${network}: ${typedError.message}`);
+                    // Call optional per-attempt failure callback
+                    if (this.onPaymentAttemptFailed) {
+                        const remainingMakers = this.account.paymentMakers.length - (attemptedNetworks.length);
+                        const remainingNetworks = remainingMakers > 0 ? ['next available'] : [];
+                        await this.onPaymentAttemptFailed({
+                            network,
+                            error: typedError,
+                            remainingNetworks
+                        });
+                    }
                     // Continue to next payment maker
                 }
             }
-            // If payment was attempted but all failed, rethrow the last error
+            // If payment was attempted but all failed, create full context and call onPaymentFailure
             if (paymentAttempted && lastPaymentError) {
+                const isRetryable = lastPaymentError instanceof ATXPPaymentError
+                    ? lastPaymentError.retryable
+                    : true; // Default to retryable for unknown errors
+                const failureContext = {
+                    payment: prospectivePayment,
+                    error: lastPaymentError,
+                    attemptedNetworks,
+                    failureReasons,
+                    retryable: isRetryable,
+                    timestamp: new Date()
+                };
+                await this.onPaymentFailure(failureContext);
                 throw lastPaymentError;
             }
             this.logger.info(`ATXP: no payment maker could handle these destinations`);
@@ -687,7 +855,7 @@ class ATXPFetcher {
                 throw error;
             }
         };
-        const { account, db, destinationMakers, fetchFn = fetch, sideChannelFetch = fetchFn, strict = true, allowInsecureRequests = process.env.NODE_ENV === 'development', allowedAuthorizationServers = [DEFAULT_AUTHORIZATION_SERVER], approvePayment = async () => true, logger = new ConsoleLogger(), onAuthorize = async () => { }, onAuthorizeFailure = async () => { }, onPayment = async () => { }, onPaymentFailure = async () => { } } = config;
+        const { account, db, destinationMakers, fetchFn = fetch, sideChannelFetch = fetchFn, strict = true, allowInsecureRequests = process.env.NODE_ENV === 'development', allowedAuthorizationServers = [DEFAULT_AUTHORIZATION_SERVER], approvePayment = async () => true, logger = new ConsoleLogger(), onAuthorize = async () => { }, onAuthorizeFailure = async () => { }, onPayment = async () => { }, onPaymentFailure, onPaymentAttemptFailed } = config;
         // Use React Native safe fetch if in React Native environment
         const safeFetchFn = getIsReactNative() ? createReactNativeSafeFetch(fetchFn) : fetchFn;
         const safeSideChannelFetch = getIsReactNative() ? createReactNativeSafeFetch(sideChannelFetch) : sideChannelFetch;
@@ -716,6 +884,7 @@ class ATXPFetcher {
         this.onAuthorizeFailure = onAuthorizeFailure;
         this.onPayment = onPayment;
         this.onPaymentFailure = onPaymentFailure || this.defaultPaymentFailureHandler;
+        this.onPaymentAttemptFailed = onPaymentAttemptFailed;
     }
 }
 
@@ -16012,7 +16181,8 @@ const DEFAULT_CLIENT_CONFIG = {
     onAuthorize: async () => { },
     onAuthorizeFailure: async () => { },
     onPayment: async () => { },
-    onPaymentFailure: async () => { }
+    onPaymentFailure: async () => { },
+    onPaymentAttemptFailed: async () => { }
 };
 function buildClientConfig(args) {
     // Use fetchFn for oAuthChannelFetch if the latter isn't explicitly set
@@ -16058,310 +16228,6 @@ async function atxpClient(args) {
     return client;
 }
 
-// this is a global public key for USDC on the solana mainnet
-const USDC_MINT = new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
-const ValidateTransferError = ValidateTransferError$1;
-class SolanaPaymentMaker {
-    constructor(solanaEndpoint, sourceSecretKey, logger) {
-        this.generateJWT = async ({ paymentRequestId, codeChallenge, accountId }) => {
-            // Solana/Web3.js secretKey is 64 bytes:
-            // first 32 bytes are the private scalar, last 32 are the public key.
-            // JWK expects only the 32-byte private scalar for 'd'
-            const jwk = {
-                kty: 'OKP',
-                crv: 'Ed25519',
-                d: Buffer.from(this.source.secretKey.slice(0, 32)).toString('base64url'),
-                x: Buffer.from(this.source.publicKey.toBytes()).toString('base64url'),
-            };
-            const privateKey = await importJWK(jwk, 'EdDSA');
-            if (!(privateKey instanceof CryptoKey)) {
-                throw new Error('Expected CryptoKey from importJWK');
-            }
-            return generateJWT(this.source.publicKey.toBase58(), privateKey, paymentRequestId || '', codeChallenge || '', accountId);
-        };
-        this.makePayment = async (destinations, memo, _paymentRequestId) => {
-            // Filter to solana chain destinations
-            const solanaDestinations = destinations.filter(d => d.chain === 'solana');
-            if (solanaDestinations.length === 0) {
-                this.logger.debug('SolanaPaymentMaker: No solana destinations found, cannot handle payment');
-                return null; // Cannot handle these destinations
-            }
-            // Pick first solana destination
-            const dest = solanaDestinations[0];
-            const amount = dest.amount;
-            const currency = dest.currency;
-            const receiver = dest.address;
-            if (currency.toUpperCase() !== 'USDC') {
-                throw new PaymentNetworkError('Only USDC currency is supported; received ' + currency);
-            }
-            const receiverKey = new PublicKey(receiver);
-            this.logger.info(`Making payment of ${amount} ${currency} to ${receiver} on Solana from ${this.source.publicKey.toBase58()}`);
-            try {
-                // Check balance before attempting payment
-                const tokenAccountAddress = await getAssociatedTokenAddress(USDC_MINT, this.source.publicKey);
-                const tokenAccount = await getAccount(this.connection, tokenAccountAddress);
-                const balance = new BigNumber$1(tokenAccount.amount.toString()).dividedBy(10 ** 6); // USDC has 6 decimals
-                if (balance.lt(amount)) {
-                    this.logger.warn(`Insufficient ${currency} balance for payment. Required: ${amount}, Available: ${balance}`);
-                    throw new InsufficientFundsError(currency, amount, balance, 'solana');
-                }
-                // Get the destination token account address (this will be the transactionId)
-                const destinationTokenAccount = await getAssociatedTokenAddress(USDC_MINT, receiverKey);
-                // Increase compute units to handle both memo and token transfer
-                // Memo uses ~6000 CUs, token transfer needs ~6500 CUs
-                const modifyComputeUnits = ComputeBudgetProgram.setComputeUnitLimit({
-                    units: 50000,
-                });
-                const addPriorityFee = ComputeBudgetProgram.setComputeUnitPrice({
-                    microLamports: 20000,
-                });
-                const transaction = await createTransfer(this.connection, this.source.publicKey, {
-                    amount: amount,
-                    recipient: receiverKey,
-                    splToken: USDC_MINT,
-                    memo,
-                });
-                transaction.add(modifyComputeUnits);
-                transaction.add(addPriorityFee);
-                const transactionSignature = await sendAndConfirmTransaction(this.connection, transaction, [this.source]);
-                // Return transaction signature as transactionId and token account address as transactionSubId
-                return {
-                    transactionId: transactionSignature,
-                    transactionSubId: destinationTokenAccount.toBase58(),
-                    chain: 'solana',
-                    currency: 'USDC'
-                };
-            }
-            catch (error) {
-                if (error instanceof InsufficientFundsError || error instanceof PaymentNetworkError) {
-                    throw error;
-                }
-                // Wrap other errors in PaymentNetworkError
-                throw new PaymentNetworkError(`Payment failed on Solana network: ${error.message}`, error);
-            }
-        };
-        if (!solanaEndpoint) {
-            throw new Error('Solana endpoint is required');
-        }
-        if (!sourceSecretKey) {
-            throw new Error('Source secret key is required');
-        }
-        this.connection = new Connection(solanaEndpoint, { commitment: 'confirmed' });
-        this.source = Keypair.fromSecretKey(bs58.decode(sourceSecretKey));
-        this.logger = logger ?? new ConsoleLogger();
-    }
-    getSourceAddress(_params) {
-        return this.source.publicKey.toBase58();
-    }
-}
-
-const USDC_CONTRACT_ADDRESS_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"; // USDC on Base mainnet
-const USDC_CONTRACT_ADDRESS_BASE_SEPOLIA = "0x036CbD53842c5426634e7929541eC2318f3dCF7e"; // USDC on Base Sepolia testnet
-/**
- * Get USDC contract address for Base chain by chain ID
- * @param chainId - Chain ID (8453 for mainnet, 84532 for sepolia)
- * @returns USDC contract address
- * @throws Error if chain ID is not supported
- */
-const getBaseUSDCAddress = (chainId) => {
-    switch (chainId) {
-        case 8453: // Base mainnet
-            return USDC_CONTRACT_ADDRESS_BASE;
-        case 84532: // Base Sepolia
-            return USDC_CONTRACT_ADDRESS_BASE_SEPOLIA;
-        default:
-            throw new Error(`Unsupported Base Chain ID: ${chainId}. Supported chains: 8453 (mainnet), 84532 (sepolia)`);
-    }
-};
-
-// Helper function to convert to base64url that works in both Node.js and browsers
-function toBase64Url(data) {
-    // Convert string to base64
-    const base64 = typeof Buffer !== 'undefined'
-        ? Buffer.from(data).toString('base64')
-        : btoa(data);
-    // Convert base64 to base64url
-    return base64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
-}
-const USDC_DECIMALS = 6;
-const ERC20_ABI = [
-    {
-        constant: false,
-        inputs: [
-            { name: "_to", type: "address" },
-            { name: "_value", type: "uint256" },
-        ],
-        name: "transfer",
-        outputs: [{ name: "", type: "bool" }],
-        type: "function",
-    },
-    {
-        "constant": true,
-        "inputs": [
-            {
-                "name": "_owner",
-                "type": "address"
-            }
-        ],
-        "name": "balanceOf",
-        "outputs": [
-            {
-                "name": "balance",
-                "type": "uint256"
-            }
-        ],
-        "payable": false,
-        "stateMutability": "view",
-        "type": "function"
-    }
-];
-class BasePaymentMaker {
-    constructor(baseRPCUrl, walletClient, logger) {
-        if (!baseRPCUrl) {
-            throw new Error('baseRPCUrl was empty');
-        }
-        if (!walletClient) {
-            throw new Error('walletClient was empty');
-        }
-        if (!walletClient.account) {
-            throw new Error('walletClient.account was empty');
-        }
-        this.signingClient = walletClient.extend(publicActions);
-        this.logger = logger ?? new ConsoleLogger();
-    }
-    getSourceAddress(_params) {
-        return this.signingClient.account.address;
-    }
-    async generateJWT({ paymentRequestId, codeChallenge, accountId }) {
-        const headerObj = { alg: 'ES256K' };
-        const payloadObj = {
-            sub: this.signingClient.account.address,
-            iss: 'accounts.atxp.ai',
-            aud: 'https://auth.atxp.ai',
-            iat: Math.floor(Date.now() / 1000),
-            exp: Math.floor(Date.now() / 1000) + 60 * 60,
-            ...(codeChallenge ? { code_challenge: codeChallenge } : {}),
-            ...(paymentRequestId ? { payment_request_id: paymentRequestId } : {}),
-            ...(accountId ? { account_id: accountId } : {}),
-        };
-        const header = toBase64Url(JSON.stringify(headerObj));
-        const payload = toBase64Url(JSON.stringify(payloadObj));
-        const message = `${header}.${payload}`;
-        const messageBytes = typeof Buffer !== 'undefined'
-            ? Buffer.from(message, 'utf8')
-            : new TextEncoder().encode(message);
-        const signResult = await this.signingClient.signMessage({
-            account: this.signingClient.account,
-            message: { raw: messageBytes },
-        });
-        // For ES256K, signature is typically 65 bytes (r,s,v)
-        // Server expects the hex signature string (with 0x prefix) to be base64url encoded
-        // This creates: base64url("0x6eb2565...") not base64url(rawBytes)
-        // Pass the hex string directly to toBase64Url which will UTF-8 encode and base64url it
-        const signature = toBase64Url(signResult);
-        const jwt = `${header}.${payload}.${signature}`;
-        this.logger.info(`Generated ES256K JWT: ${jwt}`);
-        return jwt;
-    }
-    async makePayment(destinations, _memo, _paymentRequestId) {
-        // Filter to base chain destinations
-        const baseDestinations = destinations.filter(d => d.chain === 'base');
-        if (baseDestinations.length === 0) {
-            this.logger.debug('BasePaymentMaker: No base destinations found, cannot handle payment');
-            return null; // Cannot handle these destinations
-        }
-        // Pick first base destination
-        const dest = baseDestinations[0];
-        const amount = dest.amount;
-        const currency = dest.currency;
-        const receiver = dest.address;
-        if (currency.toUpperCase() !== 'USDC') {
-            throw new PaymentNetworkError('Only USDC currency is supported; received ' + currency);
-        }
-        this.logger.info(`Making payment of ${amount} ${currency} to ${receiver} on Base from ${this.signingClient.account.address}`);
-        try {
-            // Check balance before attempting payment
-            const balanceRaw = await this.signingClient.readContract({
-                address: USDC_CONTRACT_ADDRESS_BASE,
-                abi: ERC20_ABI,
-                functionName: 'balanceOf',
-                args: [this.signingClient.account.address],
-            });
-            const balance = new BigNumber(balanceRaw.toString()).dividedBy(10 ** USDC_DECIMALS);
-            if (balance.lt(amount)) {
-                this.logger.warn(`Insufficient ${currency} balance for payment. Required: ${amount}, Available: ${balance}`);
-                throw new InsufficientFundsError(currency, amount, balance, 'base');
-            }
-            // Convert amount to USDC units (6 decimals) as BigInt
-            const amountInUSDCUnits = BigInt(amount.multipliedBy(10 ** USDC_DECIMALS).toFixed(0));
-            const data = encodeFunctionData({
-                abi: ERC20_ABI,
-                functionName: "transfer",
-                args: [receiver, amountInUSDCUnits],
-            });
-            const hash = await this.signingClient.sendTransaction({
-                chain: base,
-                account: this.signingClient.account,
-                to: USDC_CONTRACT_ADDRESS_BASE,
-                data: data,
-                value: parseEther('0'),
-                maxPriorityFeePerGas: parseEther('0.000000001')
-            });
-            // Wait for transaction confirmation with more blocks to ensure propagation
-            this.logger.info(`Waiting for transaction confirmation: ${hash}`);
-            const receipt = await this.signingClient.waitForTransactionReceipt({
-                hash: hash,
-                confirmations: 1
-            });
-            if (receipt.status === 'reverted') {
-                throw new PaymentNetworkError(`Transaction reverted: ${hash}`, new Error('Transaction reverted on chain'));
-            }
-            this.logger.info(`Transaction confirmed: ${hash} in block ${receipt.blockNumber}`);
-            // Return payment result with chain and currency
-            return {
-                transactionId: hash,
-                chain: 'base',
-                currency: 'USDC'
-            };
-        }
-        catch (error) {
-            if (error instanceof InsufficientFundsError || error instanceof PaymentNetworkError) {
-                throw error;
-            }
-            // Wrap other errors in PaymentNetworkError
-            throw new PaymentNetworkError(`Payment failed on Base network: ${error.message}`, error);
-        }
-    }
-}
-
-class SolanaAccount {
-    constructor(solanaEndpoint, sourceSecretKey) {
-        if (!solanaEndpoint) {
-            throw new Error('Solana endpoint is required');
-        }
-        if (!sourceSecretKey) {
-            throw new Error('Source secret key is required');
-        }
-        const source = Keypair.fromSecretKey(bs58.decode(sourceSecretKey));
-        this.sourcePublicKey = source.publicKey.toBase58();
-        // Format accountId as network:address
-        this.accountId = `solana:${this.sourcePublicKey}`;
-        this.paymentMakers = [
-            new SolanaPaymentMaker(solanaEndpoint, sourceSecretKey)
-        ];
-    }
-    /**
-     * Get sources for this account
-     */
-    async getSources() {
-        return [{
-                address: this.sourcePublicKey,
-                chain: 'solana',
-                walletType: 'eoa'
-            }];
-    }
-}
-
 const USDC_CONTRACT_ADDRESS_WORLD_MAINNET = "0x79A02482A880bCE3F13e09Da970dC34db4CD24d1"; // USDC.e on World Chain mainnet
 const USDC_CONTRACT_ADDRESS_WORLD_SEPOLIA = "0x79A02482A880bCE3F13e09Da970dC34db4CD24d1"; // USDC.e on World Chain Sepolia (placeholder - update with actual address)
 // World Chain Mainnet (Chain ID: 480)
@@ -16524,45 +16390,6 @@ const getPolygonUSDCAddress = (chainId) => {
     }
 };
 
-class BaseAccount {
-    constructor(baseRPCUrl, sourceSecretKey) {
-        if (!baseRPCUrl) {
-            throw new Error('Base RPC URL is required');
-        }
-        if (!sourceSecretKey) {
-            throw new Error('Source secret key is required');
-        }
-        this.account = privateKeyToAccount(sourceSecretKey);
-        // Format accountId as network:address
-        this.accountId = `base:${this.account.address}`;
-        this.walletClient = createWalletClient({
-            account: this.account,
-            chain: base,
-            transport: http(baseRPCUrl),
-        });
-        this.paymentMakers = [
-            new BasePaymentMaker(baseRPCUrl, this.walletClient)
-        ];
-    }
-    /**
-     * Get the LocalAccount (signer) for this account.
-     * This can be used with the x402 library or other signing operations.
-     */
-    getLocalAccount() {
-        return this.account;
-    }
-    /**
-     * Get sources for this account
-     */
-    async getSources() {
-        return [{
-                address: this.account.address,
-                chain: 'base',
-                walletType: 'eoa'
-            }];
-    }
-}
-
 function toBasicAuth(token) {
     // Basic auth is base64("username:password"), password is blank
     const b64 = Buffer.from(`${token}:`).toString('base64');
@@ -16663,5 +16490,5 @@ class ATXPLocalAccount {
     }
 }
 
-export { ATXPDestinationMaker, ATXPLocalAccount, BaseAccount, BasePaymentMaker, DEFAULT_CLIENT_CONFIG, InsufficientFundsError, OAuthAuthenticationRequiredError, OAuthClient, POLYGON_AMOY, POLYGON_MAINNET, PassthroughDestinationMaker, PaymentNetworkError, SolanaAccount, SolanaPaymentMaker, USDC_CONTRACT_ADDRESS_BASE, USDC_CONTRACT_ADDRESS_BASE_SEPOLIA, USDC_CONTRACT_ADDRESS_POLYGON_AMOY, USDC_CONTRACT_ADDRESS_POLYGON_MAINNET, USDC_CONTRACT_ADDRESS_WORLD_MAINNET, USDC_CONTRACT_ADDRESS_WORLD_SEPOLIA, ValidateTransferError, WORLD_CHAIN_MAINNET, WORLD_CHAIN_SEPOLIA, atxpClient, atxpFetch, buildClientConfig, buildStreamableTransport, getBaseUSDCAddress, getPolygonAmoyWithRPC, getPolygonByChainId, getPolygonMainnetWithRPC, getPolygonUSDCAddress, getWorldChainByChainId, getWorldChainMainnetWithRPC, getWorldChainSepoliaWithRPC, getWorldChainUSDCAddress };
+export { ATXPDestinationMaker, ATXPLocalAccount, ATXPPaymentError, DEFAULT_CLIENT_CONFIG, GasEstimationError, InsufficientFundsError, OAuthAuthenticationRequiredError, OAuthClient, POLYGON_AMOY, POLYGON_MAINNET, PassthroughDestinationMaker, PaymentExpiredError, PaymentNetworkError, PaymentServerError, RpcError, TransactionRevertedError, USDC_CONTRACT_ADDRESS_POLYGON_AMOY, USDC_CONTRACT_ADDRESS_POLYGON_MAINNET, USDC_CONTRACT_ADDRESS_WORLD_MAINNET, USDC_CONTRACT_ADDRESS_WORLD_SEPOLIA, UnsupportedCurrencyError, UserRejectedError, WORLD_CHAIN_MAINNET, WORLD_CHAIN_SEPOLIA, atxpClient, atxpFetch, buildClientConfig, buildStreamableTransport, getPolygonAmoyWithRPC, getPolygonByChainId, getPolygonMainnetWithRPC, getPolygonUSDCAddress, getWorldChainByChainId, getWorldChainMainnetWithRPC, getWorldChainSepoliaWithRPC, getWorldChainUSDCAddress };
 //# sourceMappingURL=index.js.map