@atxp/client 0.7.4 → 0.8.0

package/dist/index.cjs

@@ -1,8 +1,8 @@
 'use strict';
 
 var common = require('@atxp/common');
-var BigNumber = require('bignumber.js');
 var oauth = require('oauth4webapi');
+var BigNumber = require('bignumber.js');
 var web3_js = require('@solana/web3.js');
 var pay = require('@solana/pay');
 var splToken = require('@solana/spl-token');
@@ -333,9 +333,9 @@ class PaymentNetworkError extends Error {
  */
 function atxpFetch(config) {
     const fetcher = new ATXPFetcher({
-        accountId: config.account.accountId,
+        account: config.account,
         db: config.oAuthDb,
-        paymentMakers: config.account.paymentMakers,
+        destinationMakers: config.destinationMakers,
         fetchFn: config.fetchFn,
         sideChannelFetch: config.oAuthChannelFetch,
         allowInsecureRequests: config.allowHttp,
@@ -353,7 +353,8 @@ class ATXPFetcher {
     constructor(config) {
         this.defaultPaymentFailureHandler = async ({ payment, error }) => {
             if (error instanceof InsufficientFundsError) {
-                this.logger.info(`PAYMENT FAILED: Insufficient ${error.currency} funds on ${payment.network}`);
+                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}`);
@@ -361,7 +362,7 @@ class ATXPFetcher {
                 this.logger.info(`Account: ${payment.accountId}`);
             }
             else if (error instanceof PaymentNetworkError) {
-                this.logger.info(`PAYMENT FAILED: Network error on ${payment.network}: ${error.message}`);
+                this.logger.info(`PAYMENT FAILED: Network error: ${error.message}`);
             }
             else {
                 this.logger.info(`PAYMENT FAILED: ${error.message}`);
@@ -371,43 +372,61 @@ class ATXPFetcher {
             if (!paymentRequestData.destinations || paymentRequestData.destinations.length === 0) {
                 return false;
             }
-            // Try each destination in order
-            for (const dest of paymentRequestData.destinations) {
-                // Convert amount to BigNumber since it comes as a string from JSON
-                const amount = new BigNumber.BigNumber(dest.amount);
-                // Resolve atxp_base destinations to real base network destinations
-                let destinationAddress = dest.address;
-                let destinationNetwork = dest.network;
-                const resolved = await this.resolveAtxpBaseDestination(dest.network, dest.address, paymentRequestId, amount, dest.currency, dest.address, paymentRequestData.iss);
-                if (resolved) {
-                    destinationAddress = resolved.destinationAddress;
-                    destinationNetwork = resolved.network;
-                }
-                const paymentMaker = this.paymentMakers.get(destinationNetwork);
-                if (!paymentMaker) {
-                    this.logger.debug(`ATXP: payment network '${destinationNetwork}' not available, trying next destination`);
+            // Get sources from the account
+            const sources = await this.account.getSources();
+            // Apply destination mappers to transform destinations
+            // Convert PaymentRequestDestination[] to Destination[] for mapper compatibility
+            const mappedDestinations = [];
+            for (const option of paymentRequestData.destinations) {
+                const destinationMaker = this.destinationMakers.get(option.network);
+                if (!destinationMaker) {
+                    this.logger.debug(`ATXP: destination maker for network '${option.network}' not available, trying next destination`);
                     continue;
                 }
-                const prospectivePayment = {
-                    accountId: this.accountId,
-                    resourceUrl: paymentRequestData.resource?.toString() ?? '',
-                    resourceName: paymentRequestData.resourceName ?? '',
-                    network: destinationNetwork,
-                    currency: dest.currency,
-                    amount: amount,
-                    iss: paymentRequestData.iss ?? '',
-                };
-                if (!await this.approvePayment(prospectivePayment)) {
-                    this.logger.info(`ATXP: payment request denied by callback function for destination on ${destinationNetwork}`);
-                    continue;
+                mappedDestinations.push(...(await destinationMaker.makeDestinations(option, this.logger, paymentRequestId, sources)));
+            }
+            if (mappedDestinations.length === 0) {
+                this.logger.info(`ATXP: no destinations found after mapping`);
+                return false;
+            }
+            // Validate amounts are not negative
+            for (const dest of mappedDestinations) {
+                if (dest.amount.isLessThan(0)) {
+                    throw new Error(`ATXP: payment amount cannot be negative: ${dest.amount.toString()} ${dest.currency}`);
                 }
-                let paymentId;
+            }
+            // Create prospective payment for approval (using first destination for display)
+            const firstDest = mappedDestinations[0];
+            const prospectivePayment = {
+                accountId: this.account.accountId,
+                resourceUrl: paymentRequestData.resource?.toString() ?? '',
+                resourceName: paymentRequestData.resourceName ?? '',
+                currency: firstDest.currency,
+                amount: firstDest.amount,
+                iss: paymentRequestData.iss ?? '',
+            };
+            // Ask for approval once for all payment attempts
+            if (!await this.approvePayment(prospectivePayment)) {
+                this.logger.info(`ATXP: payment request denied by callback function`);
+                return false;
+            }
+            // Try each payment maker in order
+            let lastPaymentError = null;
+            let paymentAttempted = false;
+            for (const paymentMaker of this.account.paymentMakers) {
                 try {
-                    paymentId = await paymentMaker.makePayment(amount, dest.currency, destinationAddress, paymentRequestData.iss);
-                    this.logger.info(`ATXP: made payment of ${amount.toString()} ${dest.currency} on ${destinationNetwork}: ${paymentId}`);
+                    // Pass all destinations to payment maker - it will filter and pick the one it can handle
+                    const result = await paymentMaker.makePayment(mappedDestinations, paymentRequestData.iss, paymentRequestId);
+                    if (result === null) {
+                        this.logger.debug(`ATXP: payment maker cannot handle these destinations, trying next`);
+                        continue; // Try next payment maker
+                    }
+                    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 });
                     // Submit payment to the server
-                    const jwt = await paymentMaker.generateJWT({ paymentRequestId, codeChallenge: '' });
+                    const jwt = await paymentMaker.generateJWT({ paymentRequestId, codeChallenge: '', accountId: this.account.accountId });
                     const response = await this.sideChannelFetch(paymentRequestUrl.toString(), {
                         method: 'PUT',
                         headers: {
@@ -415,9 +434,10 @@ class ATXPFetcher {
                             'Content-Type': 'application/json'
                         },
                         body: JSON.stringify({
-                            transactionId: paymentId,
-                            network: destinationNetwork,
-                            currency: dest.currency
+                            transactionId: result.transactionId,
+                            ...(result.transactionSubId ? { transactionSubId: result.transactionSubId } : {}),
+                            chain: result.chain,
+                            currency: result.currency
                         })
                     });
                     this.logger.debug(`ATXP: payment was ${response.ok ? 'successfully' : 'not successfully'} PUT to ${paymentRequestUrl} : status ${response.status} ${response.statusText}`);
@@ -430,13 +450,18 @@ class ATXPFetcher {
                 }
                 catch (error) {
                     const typedError = error;
-                    this.logger.warn(`ATXP: payment failed on ${destinationNetwork}: ${typedError.message}`);
+                    paymentAttempted = true;
+                    lastPaymentError = typedError;
+                    this.logger.warn(`ATXP: payment maker failed: ${typedError.message}`);
                     await this.onPaymentFailure({ payment: prospectivePayment, error: typedError });
-                    // Try next destination
-                    continue;
+                    // Continue to next payment maker
                 }
             }
-            this.logger.info(`ATXP: no suitable payment destination found among ${paymentRequestData.destinations.length} options`);
+            // If payment was attempted but all failed, rethrow the last error
+            if (paymentAttempted && lastPaymentError) {
+                throw lastPaymentError;
+            }
+            this.logger.info(`ATXP: no payment maker could handle these destinations`);
             return false;
         };
         this.handlePaymentRequestError = async (paymentRequestError) => {
@@ -463,102 +488,8 @@ class ATXPFetcher {
             if (paymentRequestData.destinations && paymentRequestData.destinations.length > 0) {
                 return this.handleMultiDestinationPayment(paymentRequestData, paymentRequestUrl, paymentRequestId);
             }
-            // Handle legacy single destination format
-            const requestedNetwork = paymentRequestData.network;
-            if (!requestedNetwork) {
-                throw new Error(`Payment network not provided`);
-            }
-            const destination = paymentRequestData.destination;
-            if (!destination) {
-                throw new Error(`destination not provided`);
-            }
-            let amount = new BigNumber.BigNumber(0);
-            if (!paymentRequestData.amount) {
-                throw new Error(`amount not provided`);
-            }
-            try {
-                amount = new BigNumber.BigNumber(paymentRequestData.amount);
-            }
-            catch {
-                throw new Error(`Invalid amount ${paymentRequestData.amount}`);
-            }
-            if (amount.lte(0)) {
-                throw new Error(`Invalid amount ${paymentRequestData.amount}`);
-            }
-            const currency = paymentRequestData.currency;
-            if (!currency) {
-                throw new Error(`Currency not provided`);
-            }
-            // Resolve atxp_base destinations to real base network destinations
-            let destinationAddress = destination;
-            let destinationNetwork = requestedNetwork;
-            const resolved = await this.resolveAtxpBaseDestination(requestedNetwork, destination, paymentRequestId, amount, currency, destination, paymentRequestData.iss);
-            if (resolved) {
-                destinationAddress = resolved.destinationAddress;
-                destinationNetwork = resolved.network;
-            }
-            const paymentMaker = this.paymentMakers.get(destinationNetwork);
-            if (!paymentMaker) {
-                this.logger.info(`ATXP: payment network '${destinationNetwork}' not set up for this client (available networks: ${Array.from(this.paymentMakers.keys()).join(', ')})`);
-                return false;
-            }
-            const prospectivePayment = {
-                accountId: this.accountId,
-                resourceUrl: paymentRequestData.resource?.toString() ?? '',
-                resourceName: paymentRequestData.resourceName ?? '',
-                network: destinationNetwork,
-                currency,
-                amount,
-                iss: paymentRequestData.iss ?? '',
-            };
-            if (!await this.approvePayment(prospectivePayment)) {
-                this.logger.info(`ATXP: payment request denied by callback function`);
-                return false;
-            }
-            let paymentId;
-            try {
-                paymentId = await paymentMaker.makePayment(amount, currency, destinationAddress, paymentRequestData.iss);
-                this.logger.info(`ATXP: made payment of ${amount} ${currency} on ${destinationNetwork}: ${paymentId}`);
-                // Call onPayment callback after successful payment
-                await this.onPayment({ payment: prospectivePayment });
-            }
-            catch (paymentError) {
-                // Call onPaymentFailure callback if payment fails
-                await this.onPaymentFailure({
-                    payment: prospectivePayment,
-                    error: paymentError
-                });
-                throw paymentError;
-            }
-            const jwt = await paymentMaker.generateJWT({ paymentRequestId, codeChallenge: '' });
-            // Make a fetch call to the authorization URL with the payment ID
-            // redirect=false is a hack
-            // The OAuth spec calls for the authorization url to return with a redirect, but fetch
-            // on mobile will automatically follow the redirect (it doesn't support the redirect=manual option)
-            // We want the redirect URL so we can extract the code from it, not the contents of the 
-            // redirect URL (which might not even exist for agentic ATXP clients)
-            //   So ATXP servers are set up to instead return a 200 with the redirect URL in the body
-            // if we pass redirect=false.
-            // TODO: Remove the redirect=false hack once we have a way to handle the redirect on mobile
-            const response = await this.sideChannelFetch(paymentRequestUrl.toString(), {
-                method: 'PUT',
-                headers: {
-                    'Authorization': `Bearer ${jwt}`,
-                    'Content-Type': 'application/json'
-                },
-                body: JSON.stringify({
-                    transactionId: paymentId,
-                    network: destinationNetwork,
-                    currency: currency
-                })
-            });
-            this.logger.debug(`ATXP: payment was ${response.ok ? 'successfully' : 'not successfully'} PUT to ${paymentRequestUrl} : status ${response.status} ${response.statusText}`);
-            if (!response.ok) {
-                const msg = `ATXP: payment to ${paymentRequestUrl} failed: HTTP ${response.status} ${await response.text()}`;
-                this.logger.info(msg);
-                throw new Error(msg);
-            }
-            return true;
+            // Payment request doesn't have destinations - this shouldn't happen with new SDK
+            throw new Error(`ATXP: payment request does not contain destinations array`);
         };
         this.getPaymentRequestData = async (paymentRequestUrl) => {
             const prRequest = await this.sideChannelFetch(paymentRequestUrl);
@@ -566,6 +497,14 @@ class ATXPFetcher {
                 throw new Error(`ATXP: GET ${paymentRequestUrl} failed: ${prRequest.status} ${prRequest.statusText}`);
             }
             const paymentRequest = await prRequest.json();
+            // Parse amount strings to BigNumber objects
+            if (paymentRequest.destinations) {
+                for (const dest of paymentRequest.destinations) {
+                    if (typeof dest.amount === 'string' || typeof dest.amount === 'number') {
+                        dest.amount = new BigNumber.BigNumber(dest.amount);
+                    }
+                }
+            }
             return paymentRequest;
         };
         this.isAllowedAuthServer = (url) => {
@@ -579,15 +518,15 @@ class ATXPFetcher {
                 throw new Error(`Code challenge not provided`);
             }
             if (!paymentMaker) {
-                const availableNetworks = Array.from(this.paymentMakers.keys()).join(', ');
-                throw new Error(`Payment maker is null/undefined. Available payment makers: [${availableNetworks}]. This usually indicates a payment maker object was not properly instantiated.`);
+                const paymentMakerCount = this.account.paymentMakers.length;
+                throw new Error(`Payment maker is null/undefined. Available payment maker count: ${paymentMakerCount}. This usually indicates a payment maker object was not properly instantiated.`);
             }
             // TypeScript should prevent this, but add runtime check for edge cases (untyped JS, version mismatches, etc.)
             if (!paymentMaker.generateJWT) {
-                const availableNetworks = Array.from(this.paymentMakers.keys()).join(', ');
-                throw new Error(`Payment maker is missing generateJWT method. Available payment makers: [${availableNetworks}]. This indicates the payment maker object does not implement the PaymentMaker interface. If using TypeScript, ensure your payment maker properly implements the PaymentMaker interface.`);
+                const paymentMakerCount = this.account.paymentMakers.length;
+                throw new Error(`Payment maker is missing generateJWT method. Available payment maker count: ${paymentMakerCount}. This indicates the payment maker object does not implement the PaymentMaker interface. If using TypeScript, ensure your payment maker properly implements the PaymentMaker interface.`);
             }
-            const authToken = await paymentMaker.generateJWT({ paymentRequestId: '', codeChallenge: codeChallenge });
+            const authToken = await paymentMaker.generateJWT({ paymentRequestId: '', codeChallenge: codeChallenge, accountId: this.account.accountId });
             // Make a fetch call to the authorization URL with the payment ID
             // redirect=false is a hack
             // The OAuth spec calls for the authorization url to return with a redirect, but fetch
@@ -633,11 +572,11 @@ class ATXPFetcher {
             throw new Error(`Expected redirect response from authorization URL, got ${response.status}`);
         };
         this.authToService = async (error) => {
-            // TODO: We need to generalize this - we can't assume that there's a single paymentMaker for the auth flow. 
-            if (this.paymentMakers.size > 1) {
+            // TODO: We need to generalize this - we can't assume that there's a single paymentMaker for the auth flow.
+            if (this.account.paymentMakers.length > 1) {
                 throw new Error(`ATXP: multiple payment makers found - cannot determine which one to use for auth`);
             }
-            const paymentMaker = Array.from(this.paymentMakers.values())[0];
+            const paymentMaker = this.account.paymentMakers[0];
             if (paymentMaker) {
                 // We can do the full OAuth flow - we'll generate a signed JWT and call /authorize on the
                 // AS to get a code, then exchange the code for an access token
@@ -652,14 +591,14 @@ class ATXPFetcher {
                     // Call onAuthorize callback after successful authorization
                     await this.onAuthorize({
                         authorizationServer: authorizationUrl.origin,
-                        userId: this.accountId
+                        userId: this.account.accountId
                     });
                 }
                 catch (authError) {
                     // Call onAuthorizeFailure callback if authorization fails
                     await this.onAuthorizeFailure({
                         authorizationServer: authorizationUrl.origin,
-                        userId: this.accountId,
+                        userId: this.account.accountId,
                         error: authError
                     });
                     throw authError;
@@ -670,13 +609,13 @@ class ATXPFetcher {
                 // If we do, we'll use it to auth to the downstream resource
                 // (In pass-through scenarios, the atxpServer() middleware stores the incoming
                 // token in the DB under the '' resource URL).
-                const existingToken = await this.db.getAccessToken(this.accountId, '');
+                const existingToken = await this.db.getAccessToken(this.account.accountId, '');
                 if (!existingToken) {
                     this.logger.info(`ATXP: no token found for the current server - we can't exchange a token if we don't have one`);
                     throw error;
                 }
                 const newToken = await this.exchangeToken(existingToken, error.resourceServerUrl);
-                this.db.saveAccessToken(this.accountId, error.resourceServerUrl, newToken);
+                this.db.saveAccessToken(this.account.accountId, error.resourceServerUrl, newToken);
             }
         };
         this.exchangeToken = async (myToken, newResourceUrl) => {
@@ -767,15 +706,15 @@ class ATXPFetcher {
                 throw error;
             }
         };
-        const { accountId, db, paymentMakers, fetchFn = fetch, sideChannelFetch = fetchFn, strict = true, allowInsecureRequests = process.env.NODE_ENV === 'development', allowedAuthorizationServers = [common.DEFAULT_AUTHORIZATION_SERVER], approvePayment = async () => true, logger = new common.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 = [common.DEFAULT_AUTHORIZATION_SERVER], approvePayment = async () => true, logger = new common.ConsoleLogger(), onAuthorize = async () => { }, onAuthorizeFailure = async () => { }, onPayment = async () => { }, onPaymentFailure = async () => { } } = config;
         // Use React Native safe fetch if in React Native environment
         const safeFetchFn = common.getIsReactNative() ? common.createReactNativeSafeFetch(fetchFn) : fetchFn;
         const safeSideChannelFetch = common.getIsReactNative() ? common.createReactNativeSafeFetch(sideChannelFetch) : sideChannelFetch;
-        // ATXPClient should never actually use the callback url - instead of redirecting the user to 
+        // ATXPClient should never actually use the callback url - instead of redirecting the user to
         // an authorization url which redirects back to the callback url, ATXPClient posts the payment
         // directly to the authorization server, then does the token exchange itself
         this.oauthClient = new OAuthClient({
-            userId: accountId,
+            userId: account.accountId,
             db,
             callbackUrl: 'http://localhost:3000/unused-dummy-atxp-callback',
             isPublic: false,
@@ -785,10 +724,10 @@ class ATXPFetcher {
             allowInsecureRequests,
             logger: logger
         });
-        this.paymentMakers = new Map(Object.entries(paymentMakers));
+        this.account = account;
+        this.destinationMakers = destinationMakers;
         this.sideChannelFetch = safeSideChannelFetch;
         this.db = db;
-        this.accountId = accountId;
         this.allowedAuthorizationServers = allowedAuthorizationServers;
         this.approvePayment = approvePayment;
         this.logger = logger;
@@ -797,79 +736,6 @@ class ATXPFetcher {
         this.onPayment = onPayment;
         this.onPaymentFailure = onPaymentFailure || this.defaultPaymentFailureHandler;
     }
-    /**
-     * Resolves atxp_base or atxp_base_sepolia destinations to real base network destinations
-     * by calling the payment_info endpoint to get the destination address and network
-     */
-    async resolveAtxpBaseDestination(network, paymentInfoUrl, paymentRequestId, amount, currency, receiver, memo) {
-        // Check if this is an atxp_base network that needs resolution
-        if (network !== 'atxp_base' && network !== 'atxp_base_sepolia') {
-            return null;
-        }
-        // Map atxp_base networks to their real counterparts
-        const realNetwork = network === 'atxp_base' ? 'base' : 'base_sepolia';
-        // Get the payment maker for the real network
-        const paymentMaker = this.paymentMakers.get(realNetwork);
-        if (!paymentMaker) {
-            this.logger.debug(`ATXP: payment network '${realNetwork}' not available for atxp_base resolution`);
-            return null;
-        }
-        // Get the buyer address (source address) from the payment maker
-        let buyerAddress;
-        try {
-            buyerAddress = await paymentMaker.getSourceAddress({
-                amount,
-                currency,
-                receiver,
-                memo
-            });
-        }
-        catch (error) {
-            this.logger.warn(`ATXP: failed to get source address from payment maker for ${realNetwork}: ${error.message}`);
-            return null;
-        }
-        // Call the payment_info endpoint
-        this.logger.debug(`ATXP: resolving ${network} destination via ${paymentInfoUrl}`);
-        try {
-            const response = await this.sideChannelFetch(paymentInfoUrl, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({
-                    paymentRequestId,
-                    buyerAddress,
-                }),
-            });
-            if (!response.ok) {
-                const text = await response.text();
-                this.logger.warn(`ATXP: payment_info endpoint failed: ${response.status} ${response.statusText} ${text}`);
-                return null;
-            }
-            const data = await response.json();
-            if (data.status !== 'success') {
-                this.logger.warn(`ATXP: payment_info endpoint returned non-success status: ${JSON.stringify(data)}`);
-                return null;
-            }
-            if (!data.destinationAddress) {
-                this.logger.warn(`ATXP: payment_info endpoint did not return destinationAddress`);
-                return null;
-            }
-            if (!data.network) {
-                this.logger.warn(`ATXP: payment_info endpoint did not return network`);
-                return null;
-            }
-            this.logger.info(`ATXP: resolved ${network} destination to ${data.destinationAddress} on ${data.network}`);
-            return {
-                destinationAddress: data.destinationAddress,
-                network: data.network,
-            };
-        }
-        catch (error) {
-            this.logger.warn(`ATXP: failed to resolve ${network} destination: ${error.message}`);
-            return null;
-        }
-    }
 }
 
 var util$1;
@@ -15954,146 +15820,618 @@ class StreamableHTTPClientTransport {
     }
 }
 
-// Detect if we're in a browser environment and bind fetch appropriately
-const getFetch = () => {
-    if (typeof window !== 'undefined' && typeof window.fetch === 'function') {
-        // In browser, bind fetch to window to avoid "Illegal invocation" errors
-        return fetch.bind(window);
-    }
-    // In Node.js or other environments, use fetch as-is
-    return fetch;
-};
-const DEFAULT_CLIENT_CONFIG = {
-    allowedAuthorizationServers: [common.DEFAULT_AUTHORIZATION_SERVER],
-    approvePayment: async (_p) => true,
-    fetchFn: getFetch(),
-    oAuthChannelFetch: getFetch(),
-    allowHttp: false, // may be overridden in buildClientConfig by process.env.NODE_ENV
-    clientInfo: {
-        name: 'ATXPClient',
-        version: '0.0.1'
-    },
-    clientOptions: {
-        capabilities: {}
-    },
-    onAuthorize: async () => { },
-    onAuthorizeFailure: async () => { },
-    onPayment: async () => { },
-    onPaymentFailure: async () => { }
-};
-function buildClientConfig(args) {
-    // Use fetchFn for oAuthChannelFetch if the latter isn't explicitly set
-    if (args.fetchFn && !args.oAuthChannelFetch) {
-        args.oAuthChannelFetch = args.fetchFn;
-    }
-    // Read environment variable at runtime, not module load time
-    const envDefaults = {
-        ...DEFAULT_CLIENT_CONFIG,
-        allowHttp: process.env.NODE_ENV === 'development',
-    };
-    const withDefaults = { ...envDefaults, ...args };
-    const logger = withDefaults.logger ?? new common.ConsoleLogger();
-    const oAuthDb = withDefaults.oAuthDb ?? new common.MemoryOAuthDb({ logger });
-    const built = { oAuthDb, logger };
-    return Object.freeze({ ...withDefaults, ...built });
-}
-function buildStreamableTransport(args) {
-    const config = buildClientConfig(args);
-    // Apply the ATXP wrapper to the fetch function
-    const wrappedFetch = atxpFetch(config);
-    const transport = new StreamableHTTPClientTransport(new URL(args.mcpServer), { fetch: wrappedFetch });
-    return transport;
+function isDestinationResponse(obj) {
+    return (typeof obj === 'object' &&
+        obj !== null &&
+        'chain' in obj &&
+        'address' in obj &&
+        'currency' in obj &&
+        'amount' in obj &&
+        typeof obj.chain === 'string' &&
+        typeof obj.address === 'string' &&
+        typeof obj.currency === 'string' &&
+        typeof obj.amount === 'string');
 }
-async function atxpClient(args) {
-    const config = buildClientConfig(args);
-    const transport = buildStreamableTransport(config);
-    const client = new Client(config.clientInfo, config.clientOptions);
-    await client.connect(transport);
-    return client;
+function isDestinationsApiResponse(obj) {
+    return (typeof obj === 'object' &&
+        obj !== null &&
+        'destinations' in obj &&
+        'paymentRequestId' in obj &&
+        Array.isArray(obj.destinations) &&
+        typeof obj.paymentRequestId === 'string');
 }
-
-// this is a global public key for USDC on the solana mainnet
-const USDC_MINT = new web3_js.PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
-const ValidateTransferError = pay.ValidateTransferError;
-class SolanaPaymentMaker {
-    constructor(solanaEndpoint, sourceSecretKey, logger) {
-        this.generateJWT = async ({ paymentRequestId, codeChallenge }) => {
-            // 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 jose.importJWK(jwk, 'EdDSA');
-            if (!(privateKey instanceof CryptoKey)) {
-                throw new Error('Expected CryptoKey from importJWK');
-            }
-            return common.generateJWT(this.source.publicKey.toBase58(), privateKey, paymentRequestId || '', codeChallenge || '');
+function parseDestinationsResponse(data) {
+    // Validate response structure
+    if (!isDestinationsApiResponse(data)) {
+        throw new Error('Invalid response: expected object with destinations array and paymentRequestId');
+    }
+    // Validate and convert each destination
+    return data.destinations.map((dest, index) => {
+        if (!isDestinationResponse(dest)) {
+            throw new Error(`Invalid destination at index ${index}: missing required fields (chain, address, currency, amount)`);
+        }
+        // Validate chain is a valid Chain enum value
+        if (!common.isEnumValue(common.ChainEnum, dest.chain)) {
+            const validChains = Object.values(common.ChainEnum).join(', ');
+            throw new Error(`Invalid destination at index ${index}: chain "${dest.chain}" is not a valid chain. Valid chains are: ${validChains}`);
+        }
+        // Validate currency is a valid Currency enum value
+        if (!common.isEnumValue(common.CurrencyEnum, dest.currency)) {
+            const validCurrencies = Object.values(common.CurrencyEnum).join(', ');
+            throw new Error(`Invalid destination at index ${index}: currency "${dest.currency}" is not a valid currency. Valid currencies are: ${validCurrencies}`);
+        }
+        // Validate amount is a valid number
+        const amount = new BigNumber.BigNumber(dest.amount);
+        if (amount.isNaN()) {
+            throw new Error(`Invalid destination at index ${index}: amount "${dest.amount}" is not a valid number`);
+        }
+        return {
+            chain: dest.chain,
+            currency: dest.currency,
+            address: dest.address,
+            amount: amount
         };
-        this.makePayment = async (amount, currency, receiver, memo) => {
-            if (currency.toUpperCase() !== 'USDC') {
-                throw new PaymentNetworkError('Only USDC currency is supported; received ' + currency);
-            }
-            const receiverKey = new web3_js.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 splToken.getAssociatedTokenAddress(USDC_MINT, this.source.publicKey);
-                const tokenAccount = await splToken.getAccount(this.connection, tokenAccountAddress);
-                const balance = new BigNumber(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');
-                }
-                // Increase compute units to handle both memo and token transfer
-                // Memo uses ~6000 CUs, token transfer needs ~6500 CUs
-                const modifyComputeUnits = web3_js.ComputeBudgetProgram.setComputeUnitLimit({
-                    units: 50000,
-                });
-                const addPriorityFee = web3_js.ComputeBudgetProgram.setComputeUnitPrice({
-                    microLamports: 20000,
-                });
-                const transaction = await pay.createTransfer(this.connection, this.source.publicKey, {
-                    amount: amount,
-                    recipient: receiverKey,
-                    splToken: USDC_MINT,
-                    memo,
-                });
-                transaction.add(modifyComputeUnits);
-                transaction.add(addPriorityFee);
-                const transactionHash = await web3_js.sendAndConfirmTransaction(this.connection, transaction, [this.source]);
-                return transactionHash;
+    });
+}
+/**
+ * Destination mapper for ATXP network destinations.
+ * Converts destinations with network='atxp' to actual blockchain network destinations
+ * by resolving the account ID to its associated blockchain addresses.
+ */
+class ATXPDestinationMaker {
+    constructor(accountsServiceUrl, fetchFn = fetch) {
+        this.accountsServiceUrl = accountsServiceUrl;
+        this.fetchFn = fetchFn;
+    }
+    async makeDestinations(option, logger, paymentRequestId, sources) {
+        if (option.network !== 'atxp') {
+            return [];
+        }
+        try {
+            // The address field contains the account ID (e.g., atxp_acct_xxx) for atxp options
+            const accountId = option.address;
+            // Always use the destinations endpoint
+            const destinations = await this.getDestinations(accountId, paymentRequestId, option, sources, logger);
+            if (destinations.length === 0) {
+                logger.warn(`ATXPDestinationMaker: No destinations found for account ${accountId}`);
             }
-            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);
+            else {
+                logger.debug(`ATXPDestinationMaker: Got ${destinations.length} destinations for account ${accountId}`);
             }
-        };
-        if (!solanaEndpoint) {
-            throw new Error('Solana endpoint is required');
+            return destinations;
         }
-        if (!sourceSecretKey) {
-            throw new Error('Source secret key is required');
+        catch (error) {
+            logger.error(`ATXPDestinationMaker: Failed to make ATXP destinations: ${error}`);
+            throw error;
         }
-        this.connection = new web3_js.Connection(solanaEndpoint, { commitment: 'confirmed' });
-        this.source = web3_js.Keypair.fromSecretKey(bs58.decode(sourceSecretKey));
-        this.logger = logger ?? new common.ConsoleLogger();
     }
-    getSourceAddress(_params) {
-        return this.source.publicKey.toBase58();
+    async getDestinations(accountId, paymentRequestId, option, sources, logger) {
+        // Strip any network prefix if present
+        const unqualifiedId = accountId.includes(':') ? accountId.split(':')[1] : accountId;
+        const url = `${this.accountsServiceUrl}/account/${unqualifiedId}/destinations`;
+        logger?.debug(`ATXPDestinationMaker: Fetching destinations from ${url}`);
+        try {
+            const requestBody = {
+                paymentRequestId,
+                options: [{
+                        network: option.network,
+                        currency: option.currency.toString(),
+                        address: option.address,
+                        amount: option.amount.toString()
+                    }],
+                sources: sources
+            };
+            const response = await this.fetchFn(url, {
+                method: 'POST',
+                headers: {
+                    'Accept': 'application/json',
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(requestBody),
+            });
+            if (!response.ok) {
+                const text = await response.text();
+                throw new Error(`Failed to fetch destinations: ${response.status} ${response.statusText} - ${text}`);
+            }
+            const data = await response.json();
+            return parseDestinationsResponse(data);
+        }
+        catch (error) {
+            logger?.error(`ATXPDestinationMaker: Error fetching destinations: ${error}`);
+            throw error;
+        }
     }
 }
 
-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
+class PassthroughDestinationMaker {
+    constructor(network) {
+        this.network = network;
+    }
+    async makeDestinations(option, _logger, _paymentRequestId, _sources) {
+        if (option.network !== this.network) {
+            return [];
+        }
+        // Check if option.network is also a Chain by inspecting the ChainEnum values
+        if (Object.values(common.ChainEnum).includes(option.network)) {
+            // It's a chain, so return a single passthrough destination
+            const destination = {
+                chain: option.network,
+                currency: option.currency,
+                address: option.address,
+                amount: option.amount
+            };
+            return [destination];
+        }
+        return [];
+    }
+}
+
+function createDestinationMakers(config) {
+    const { atxpAccountsServer, fetchFn = fetch } = config;
+    // Build the map by exhaustively checking all Network values
+    const makers = new Map();
+    for (const network of Object.values(common.NetworkEnum)) {
+        // Exhaustiveness check using switch with assertNever
+        switch (network) {
+            case common.NetworkEnum.Solana:
+                makers.set(network, new PassthroughDestinationMaker(network));
+                break;
+            case common.NetworkEnum.Base:
+                makers.set(network, new PassthroughDestinationMaker(network));
+                break;
+            case common.NetworkEnum.World:
+                makers.set(network, new PassthroughDestinationMaker(network));
+                break;
+            case common.NetworkEnum.Polygon:
+                makers.set(network, new PassthroughDestinationMaker(network));
+                break;
+            case common.NetworkEnum.BaseSepolia:
+                makers.set(network, new PassthroughDestinationMaker(network));
+                break;
+            case common.NetworkEnum.WorldSepolia:
+                makers.set(network, new PassthroughDestinationMaker(network));
+                break;
+            case common.NetworkEnum.ATXP:
+                makers.set(network, new ATXPDestinationMaker(atxpAccountsServer, fetchFn));
+                break;
+            default:
+                // This will cause a compilation error if a new Network is added but not handled above
+                common.assertNever(network);
+        }
+    }
+    return makers;
+}
+
+function toBasicAuth$1(token) {
+    // Basic auth is base64("username:password"), password is blank
+    const b64 = Buffer.from(`${token}:`).toString('base64');
+    return `Basic ${b64}`;
+}
+/**
+ * ATXP implementation of viem's LocalAccount interface.
+ * Delegates signing operations to the accounts-x402 API.
+ * Includes properties needed by x402 library for wallet client compatibility.
+ */
+class ATXPLocalAccount {
+    constructor(address, origin, token, fetchFn = fetch) {
+        this.address = address;
+        this.origin = origin;
+        this.token = token;
+        this.fetchFn = fetchFn;
+        this.type = 'local';
+        /**
+         * Get public key - required by LocalAccount interface
+         */
+        this.publicKey = '0x0000000000000000000000000000000000000000000000000000000000000000';
+        /**
+         * Source - required by LocalAccount interface (set to 'custom')
+         */
+        this.source = 'custom';
+        // x402 library expects these properties for wallet client compatibility
+        this.account = this; // Self-reference for x402's isSignerWallet check
+        this.chain = { id: 8453 }; // Base mainnet - could make this configurable
+        this.transport = {}; // Empty transport object for x402 compatibility
+    }
+    /**
+     * Fetch the wallet address from the /address endpoint
+     */
+    static async create(origin, token, fetchFn = fetch) {
+        // The /address endpoint uses Basic auth like other authenticated endpoints
+        // For X402, we need the Ethereum/Base address with USDC currency
+        const url = new URL(`${origin}/address`);
+        url.searchParams.set('network', 'base'); // X402 operates on Base
+        url.searchParams.set('currency', 'USDC'); // Always USDC for X402
+        const response = await fetchFn(url.toString(), {
+            method: 'GET',
+            headers: {
+                'Authorization': toBasicAuth$1(token)
+            }
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Failed to fetch destination address: ${response.status} ${response.statusText} ${errorText}`);
+        }
+        const data = await response.json();
+        const address = data.address;
+        if (!address) {
+            throw new Error('Address endpoint did not return an address');
+        }
+        // Check that the account is an Ethereum/Base account (required for X402/EVM operations)
+        const network = data.network;
+        if (!network) {
+            throw new Error('Address endpoint did not return a network');
+        }
+        if (network !== 'ethereum' && network !== 'base') {
+            throw new Error(`ATXPLocalAccount requires an Ethereum/Base account, but got ${network} account`);
+        }
+        return new ATXPLocalAccount(address, origin, token, fetchFn);
+    }
+    /**
+     * Sign a typed data structure using EIP-712
+     * This is what x402 library will call for EIP-3009 authorization
+     */
+    async signTypedData(typedData) {
+        const response = await this.fetchFn(`${this.origin}/sign-typed-data`, {
+            method: 'POST',
+            headers: {
+                'Authorization': toBasicAuth$1(this.token),
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                typedData
+            })
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Failed to sign typed data: ${response.status} ${response.statusText} ${errorText}`);
+        }
+        const result = await response.json();
+        return result.signature;
+    }
+    /**
+     * Sign a message - required by LocalAccount interface but not used for X402
+     */
+    async signMessage(_) {
+        throw new Error('Message signing not implemented for ATXP local account');
+    }
+    /**
+     * Sign a transaction - required by LocalAccount interface but not used for X402
+     */
+    async signTransaction(_transaction, _args) {
+        throw new Error('Transaction signing not implemented for ATXP local account');
+    }
+}
+
+function toBasicAuth(token) {
+    // Basic auth is base64("username:password"), password is blank
+    const b64 = Buffer.from(`${token}:`).toString('base64');
+    return `Basic ${b64}`;
+}
+function parseConnectionString(connectionString) {
+    const url = new URL(connectionString);
+    const origin = url.origin;
+    const token = url.searchParams.get('connection_token') || '';
+    const accountId = url.searchParams.get('account_id');
+    if (!token) {
+        throw new Error('ATXPAccount: connection string missing connection token');
+    }
+    if (!accountId) {
+        throw new Error('ATXPAccount: connection string missing account id');
+    }
+    return { origin, token, accountId };
+}
+class ATXPHttpPaymentMaker {
+    constructor(origin, token, fetchFn = fetch) {
+        this.origin = origin;
+        this.token = token;
+        this.fetchFn = fetchFn;
+    }
+    async getSourceAddress(params) {
+        // Call the /address_for_payment endpoint to get the source address for this account
+        const response = await this.fetchFn(`${this.origin}/address_for_payment`, {
+            method: 'POST',
+            headers: {
+                'Authorization': toBasicAuth(this.token),
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                amount: params.amount.toString(),
+                currency: params.currency,
+                receiver: params.receiver,
+                memo: params.memo,
+            }),
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`ATXPAccount: /address_for_payment failed: ${response.status} ${response.statusText} ${text}`);
+        }
+        const json = await response.json();
+        if (!json?.sourceAddress) {
+            throw new Error('ATXPAccount: /address_for_payment did not return sourceAddress');
+        }
+        return json.sourceAddress;
+    }
+    async makePayment(destinations, memo, paymentRequestId) {
+        // Make a payment via the /pay endpoint with multiple destinations
+        const response = await this.fetchFn(`${this.origin}/pay`, {
+            method: 'POST',
+            headers: {
+                'Authorization': toBasicAuth(this.token),
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                destinations: destinations.map(d => ({
+                    chain: d.chain,
+                    address: d.address,
+                    amount: d.amount.toString(),
+                    currency: d.currency
+                })),
+                memo,
+                ...(paymentRequestId && { paymentRequestId })
+            }),
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`ATXPAccount: /pay failed: ${response.status} ${response.statusText} ${text}`);
+        }
+        const json = await response.json();
+        const transactionId = json.transactionId;
+        if (!transactionId) {
+            throw new Error('ATXPAccount: /pay did not return transactionId or txHash');
+        }
+        if (!json?.chain) {
+            throw new Error('ATXPAccount: /pay did not return chain');
+        }
+        if (!json?.currency) {
+            throw new Error('ATXPAccount: /pay did not return currency');
+        }
+        return {
+            transactionId,
+            ...(json.transactionSubId ? { transactionSubId: json.transactionSubId } : {}),
+            chain: json.chain,
+            currency: json.currency
+        };
+    }
+    async generateJWT(params) {
+        const response = await this.fetchFn(`${this.origin}/sign`, {
+            method: 'POST',
+            headers: {
+                'Authorization': toBasicAuth(this.token),
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                paymentRequestId: params.paymentRequestId,
+                codeChallenge: params.codeChallenge,
+                ...(params.accountId ? { accountId: params.accountId } : {}),
+            }),
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`ATXPAccount: /sign failed: ${response.status} ${response.statusText} ${text}`);
+        }
+        const json = await response.json();
+        if (!json?.jwt) {
+            throw new Error('ATXPAccount: /sign did not return jwt');
+        }
+        return json.jwt;
+    }
+}
+class ATXPAccount {
+    constructor(connectionString, opts) {
+        const { origin, token, accountId } = parseConnectionString(connectionString);
+        const fetchFn = opts?.fetchFn ?? fetch;
+        // Store for use in X402 payment creation
+        this.origin = origin;
+        this.token = token;
+        this.fetchFn = fetchFn;
+        // Format accountId as network:address
+        // Connection string provides just the atxp_acct_xxx part (no prefix for UI)
+        this.unqualifiedAccountId = accountId;
+        this.accountId = `atxp:${accountId}`;
+        this.paymentMakers = [
+            new ATXPHttpPaymentMaker(origin, token, fetchFn)
+        ];
+    }
+    async getSigner() {
+        return ATXPLocalAccount.create(this.origin, this.token, this.fetchFn);
+    }
+    /**
+     * Get sources for this account by calling the accounts service
+     */
+    async getSources() {
+        // Use the unqualified account ID (without atxp: prefix) for the API call
+        const response = await this.fetchFn(`${this.origin}/account/${this.unqualifiedAccountId}/sources`, {
+            method: 'GET',
+            headers: {
+                'Accept': 'application/json',
+            }
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`ATXPAccount: /account/${this.unqualifiedAccountId}/sources failed: ${response.status} ${response.statusText} ${text}`);
+        }
+        const json = await response.json();
+        // The accounts service returns the sources array directly, not wrapped in an object
+        if (!Array.isArray(json)) {
+            throw new Error(`ATXPAccount: /account/${this.unqualifiedAccountId}/sources did not return sources array`);
+        }
+        return json;
+    }
+}
+
+// Detect if we're in a browser environment and bind fetch appropriately
+const getFetch = () => {
+    if (typeof window !== 'undefined' && typeof window.fetch === 'function') {
+        // In browser, bind fetch to window to avoid "Illegal invocation" errors
+        return fetch.bind(window);
+    }
+    // In Node.js or other environments, use fetch as-is
+    return fetch;
+};
+const DEFAULT_CLIENT_CONFIG = {
+    allowedAuthorizationServers: [common.DEFAULT_AUTHORIZATION_SERVER],
+    atxpAccountsServer: common.DEFAULT_ATXP_ACCOUNTS_SERVER,
+    approvePayment: async (_p) => true,
+    fetchFn: getFetch(),
+    oAuthChannelFetch: getFetch(),
+    allowHttp: false, // may be overridden in buildClientConfig by process.env.NODE_ENV
+    clientInfo: {
+        name: 'ATXPClient',
+        version: '0.0.1'
+    },
+    clientOptions: {
+        capabilities: {}
+    },
+    onAuthorize: async () => { },
+    onAuthorizeFailure: async () => { },
+    onPayment: async () => { },
+    onPaymentFailure: async () => { }
+};
+function buildClientConfig(args) {
+    // Use fetchFn for oAuthChannelFetch if the latter isn't explicitly set
+    if (args.fetchFn && !args.oAuthChannelFetch) {
+        args.oAuthChannelFetch = args.fetchFn;
+    }
+    // Read environment variable at runtime, not module load time
+    const envDefaults = {
+        ...DEFAULT_CLIENT_CONFIG,
+        allowHttp: process.env.NODE_ENV === 'development',
+    };
+    const withDefaults = { ...envDefaults, ...args };
+    const logger = withDefaults.logger ?? new common.ConsoleLogger();
+    const oAuthDb = withDefaults.oAuthDb ?? new common.MemoryOAuthDb({ logger });
+    const fetchFn = withDefaults.fetchFn;
+    // Build destination makers if not provided
+    let accountsServer = withDefaults.atxpAccountsServer;
+    // QoL hack for unspecified accounts server - if the caller is passing an atxpAccount, then assume the origin for that
+    // is what we should use for the accounts server. In practice, the only option is accounts.atxp.ai,
+    // but this supports staging environment
+    if (args.atxpAccountsServer === undefined && withDefaults.account && withDefaults.account instanceof ATXPAccount) {
+        accountsServer = withDefaults.account.origin;
+    }
+    const destinationMakers = withDefaults.destinationMakers ?? createDestinationMakers({
+        atxpAccountsServer: accountsServer,
+        fetchFn
+    });
+    const built = { oAuthDb, logger, destinationMakers };
+    return Object.freeze({ ...withDefaults, ...built });
+}
+function buildStreamableTransport(args) {
+    const config = buildClientConfig(args);
+    // Apply the ATXP wrapper to the fetch function
+    const wrappedFetch = atxpFetch(config);
+    const transport = new StreamableHTTPClientTransport(new URL(args.mcpServer), { fetch: wrappedFetch });
+    return transport;
+}
+async function atxpClient(args) {
+    const config = buildClientConfig(args);
+    const transport = buildStreamableTransport(config);
+    const client = new Client(config.clientInfo, config.clientOptions);
+    await client.connect(transport);
+    return client;
+}
+
+// this is a global public key for USDC on the solana mainnet
+const USDC_MINT = new web3_js.PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
+const ValidateTransferError = pay.ValidateTransferError;
+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 jose.importJWK(jwk, 'EdDSA');
+            if (!(privateKey instanceof CryptoKey)) {
+                throw new Error('Expected CryptoKey from importJWK');
+            }
+            return common.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 web3_js.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 splToken.getAssociatedTokenAddress(USDC_MINT, this.source.publicKey);
+                const tokenAccount = await splToken.getAccount(this.connection, tokenAccountAddress);
+                const balance = new BigNumber(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 splToken.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 = web3_js.ComputeBudgetProgram.setComputeUnitLimit({
+                    units: 50000,
+                });
+                const addPriorityFee = web3_js.ComputeBudgetProgram.setComputeUnitPrice({
+                    microLamports: 20000,
+                });
+                const transaction = await pay.createTransfer(this.connection, this.source.publicKey, {
+                    amount: amount,
+                    recipient: receiverKey,
+                    splToken: USDC_MINT,
+                    memo,
+                });
+                transaction.add(modifyComputeUnits);
+                transaction.add(addPriorityFee);
+                const transactionSignature = await web3_js.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 web3_js.Connection(solanaEndpoint, { commitment: 'confirmed' });
+        this.source = web3_js.Keypair.fromSecretKey(bs58.decode(sourceSecretKey));
+        this.logger = logger ?? new common.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
@@ -16167,7 +16505,7 @@ class BasePaymentMaker {
     getSourceAddress(_params) {
         return this.signingClient.account.address;
     }
-    async generateJWT({ paymentRequestId, codeChallenge }) {
+    async generateJWT({ paymentRequestId, codeChallenge, accountId }) {
         const headerObj = { alg: 'ES256K' };
         const payloadObj = {
             sub: this.signingClient.account.address,
@@ -16177,6 +16515,7 @@ class BasePaymentMaker {
             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));
@@ -16197,7 +16536,18 @@ class BasePaymentMaker {
         this.logger.info(`Generated ES256K JWT: ${jwt}`);
         return jwt;
     }
-    async makePayment(amount, currency, receiver) {
+    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);
         }
@@ -16240,7 +16590,12 @@ class BasePaymentMaker {
                 throw new PaymentNetworkError(`Transaction reverted: ${hash}`, new Error('Transaction reverted on chain'));
             }
             this.logger.info(`Transaction confirmed: ${hash} in block ${receipt.blockNumber}`);
-            return hash;
+            // Return payment result with chain and currency
+            return {
+                transactionId: hash,
+                chain: 'base',
+                currency: 'USDC'
+            };
         }
         catch (error) {
             if (error instanceof InsufficientFundsError || error instanceof PaymentNetworkError) {
@@ -16261,228 +16616,22 @@ class SolanaAccount {
             throw new Error('Source secret key is required');
         }
         const source = web3_js.Keypair.fromSecretKey(bs58.decode(sourceSecretKey));
-        this.accountId = source.publicKey.toBase58();
-        this.paymentMakers = {
-            'solana': new SolanaPaymentMaker(solanaEndpoint, sourceSecretKey),
-        };
-    }
-}
-
-function toBasicAuth$1(token) {
-    // Basic auth is base64("username:password"), password is blank
-    const b64 = Buffer.from(`${token}:`).toString('base64');
-    return `Basic ${b64}`;
-}
-/**
- * ATXP implementation of viem's LocalAccount interface.
- * Delegates signing operations to the accounts-x402 API.
- * Includes properties needed by x402 library for wallet client compatibility.
- */
-class ATXPLocalAccount {
-    constructor(address, origin, token, fetchFn = fetch) {
-        this.address = address;
-        this.origin = origin;
-        this.token = token;
-        this.fetchFn = fetchFn;
-        this.type = 'local';
-        /**
-         * Get public key - required by LocalAccount interface
-         */
-        this.publicKey = '0x0000000000000000000000000000000000000000000000000000000000000000';
-        /**
-         * Source - required by LocalAccount interface (set to 'custom')
-         */
-        this.source = 'custom';
-        // x402 library expects these properties for wallet client compatibility
-        this.account = this; // Self-reference for x402's isSignerWallet check
-        this.chain = { id: 8453 }; // Base mainnet - could make this configurable
-        this.transport = {}; // Empty transport object for x402 compatibility
-    }
-    /**
-     * Fetch the wallet address from the /address endpoint
-     */
-    static async create(origin, token, fetchFn = fetch) {
-        // The /address endpoint uses Basic auth like other authenticated endpoints
-        // For X402, we need the Ethereum/Base address with USDC currency
-        const url = new URL(`${origin}/address`);
-        url.searchParams.set('network', 'base'); // X402 operates on Base
-        url.searchParams.set('currency', 'USDC'); // Always USDC for X402
-        const response = await fetchFn(url.toString(), {
-            method: 'GET',
-            headers: {
-                'Authorization': toBasicAuth$1(token)
-            }
-        });
-        if (!response.ok) {
-            const errorText = await response.text();
-            throw new Error(`Failed to fetch destination address: ${response.status} ${response.statusText} ${errorText}`);
-        }
-        const data = await response.json();
-        const address = data.address;
-        if (!address) {
-            throw new Error('Address endpoint did not return an address');
-        }
-        // Check that the account is an Ethereum/Base account (required for X402/EVM operations)
-        const network = data.network;
-        if (!network) {
-            throw new Error('Address endpoint did not return a network');
-        }
-        if (network !== 'ethereum' && network !== 'base') {
-            throw new Error(`ATXPLocalAccount requires an Ethereum/Base account, but got ${network} account`);
-        }
-        return new ATXPLocalAccount(address, origin, token, fetchFn);
-    }
-    /**
-     * Sign a typed data structure using EIP-712
-     * This is what x402 library will call for EIP-3009 authorization
-     */
-    async signTypedData(typedData) {
-        const response = await this.fetchFn(`${this.origin}/sign-typed-data`, {
-            method: 'POST',
-            headers: {
-                'Authorization': toBasicAuth$1(this.token),
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify({
-                typedData
-            })
-        });
-        if (!response.ok) {
-            const errorText = await response.text();
-            throw new Error(`Failed to sign typed data: ${response.status} ${response.statusText} ${errorText}`);
-        }
-        const result = await response.json();
-        return result.signature;
+        this.sourcePublicKey = source.publicKey.toBase58();
+        // Format accountId as network:address
+        this.accountId = `solana:${this.sourcePublicKey}`;
+        this.paymentMakers = [
+            new SolanaPaymentMaker(solanaEndpoint, sourceSecretKey)
+        ];
     }
     /**
-     * Sign a message - required by LocalAccount interface but not used for X402
-     */
-    async signMessage(_) {
-        throw new Error('Message signing not implemented for ATXP local account');
-    }
-    /**
-     * Sign a transaction - required by LocalAccount interface but not used for X402
+     * Get sources for this account
      */
-    async signTransaction(_transaction, _args) {
-        throw new Error('Transaction signing not implemented for ATXP local account');
-    }
-}
-
-function toBasicAuth(token) {
-    // Basic auth is base64("username:password"), password is blank
-    const b64 = Buffer.from(`${token}:`).toString('base64');
-    return `Basic ${b64}`;
-}
-function parseConnectionString(connectionString) {
-    const url = new URL(connectionString);
-    const origin = url.origin;
-    const token = url.searchParams.get('connection_token') || '';
-    const accountId = url.searchParams.get('account_id');
-    if (!token) {
-        throw new Error('ATXPAccount: connection string missing connection token');
-    }
-    return { origin, token, accountId };
-}
-class ATXPHttpPaymentMaker {
-    constructor(origin, token, fetchFn = fetch) {
-        this.origin = origin;
-        this.token = token;
-        this.fetchFn = fetchFn;
-    }
-    async getSourceAddress(params) {
-        // Call the /address_for_payment endpoint to get the source address for this account
-        const response = await this.fetchFn(`${this.origin}/address_for_payment`, {
-            method: 'POST',
-            headers: {
-                'Authorization': toBasicAuth(this.token),
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify({
-                amount: params.amount.toString(),
-                currency: params.currency,
-                receiver: params.receiver,
-                memo: params.memo,
-            }),
-        });
-        if (!response.ok) {
-            const text = await response.text();
-            throw new Error(`ATXPAccount: /address_for_payment failed: ${response.status} ${response.statusText} ${text}`);
-        }
-        const json = await response.json();
-        if (!json?.sourceAddress) {
-            throw new Error('ATXPAccount: /address_for_payment did not return sourceAddress');
-        }
-        return json.sourceAddress;
-    }
-    async makePayment(amount, currency, receiver, memo) {
-        // Make a regular payment via the /pay endpoint
-        const response = await this.fetchFn(`${this.origin}/pay`, {
-            method: 'POST',
-            headers: {
-                'Authorization': toBasicAuth(this.token),
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify({
-                amount: amount.toString(),
-                currency,
-                receiver,
-                memo,
-            }),
-        });
-        if (!response.ok) {
-            const text = await response.text();
-            throw new Error(`ATXPAccount: /pay failed: ${response.status} ${response.statusText} ${text}`);
-        }
-        const json = await response.json();
-        if (!json?.txHash) {
-            throw new Error('ATXPAccount: /pay did not return txHash');
-        }
-        return json.txHash;
-    }
-    async generateJWT(params) {
-        const response = await this.fetchFn(`${this.origin}/sign`, {
-            method: 'POST',
-            headers: {
-                'Authorization': toBasicAuth(this.token),
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify({
-                paymentRequestId: params.paymentRequestId,
-                codeChallenge: params.codeChallenge,
-            }),
-        });
-        if (!response.ok) {
-            const text = await response.text();
-            throw new Error(`ATXPAccount: /sign failed: ${response.status} ${response.statusText} ${text}`);
-        }
-        const json = await response.json();
-        if (!json?.jwt) {
-            throw new Error('ATXPAccount: /sign did not return jwt');
-        }
-        return json.jwt;
-    }
-}
-class ATXPAccount {
-    constructor(connectionString, opts) {
-        const { origin, token, accountId } = parseConnectionString(connectionString);
-        const fetchFn = opts?.fetchFn ?? fetch;
-        const network = opts?.network ?? 'base';
-        // Store for use in X402 payment creation
-        this.origin = origin;
-        this.token = token;
-        this.fetchFn = fetchFn;
-        if (accountId) {
-            this.accountId = `atxp:${accountId}`;
-        }
-        else {
-            this.accountId = `atxp:${common.crypto.randomUUID()}`;
-        }
-        this.paymentMakers = {
-            [network]: new ATXPHttpPaymentMaker(origin, token, fetchFn),
-        };
-    }
-    async getSigner() {
-        return ATXPLocalAccount.create(this.origin, this.token, this.fetchFn);
+    async getSources() {
+        return [{
+                address: this.sourcePublicKey,
+                chain: 'solana',
+                walletType: 'eoa'
+            }];
     }
 }
 
@@ -16566,6 +16715,58 @@ const getWorldChainUSDCAddress = (chainId) => {
     }
 };
 
+const USDC_CONTRACT_ADDRESS_POLYGON_MAINNET = "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359"; // Native USDC on Polygon mainnet
+// Polygon Mainnet (Chain ID: 137)
+const POLYGON_MAINNET = {
+    id: 137,
+    name: 'Polygon',
+    nativeCurrency: { name: 'MATIC', symbol: 'MATIC', decimals: 18 },
+    rpcUrls: {
+        default: { http: ['https://polygon-rpc.com'] }
+    },
+    blockExplorers: {
+        default: { name: 'PolygonScan', url: 'https://polygonscan.com' }
+    }
+};
+/**
+ * Get Polygon Mainnet configuration with custom RPC URL (e.g., with API key)
+ * @param rpcUrl - Custom RPC URL, e.g., 'https://polygon-mainnet.g.alchemy.com/v2/YOUR_API_KEY'
+ */
+const getPolygonMainnetWithRPC = (rpcUrl) => ({
+    ...POLYGON_MAINNET,
+    rpcUrls: {
+        default: { http: [rpcUrl] }
+    }
+});
+/**
+ * Get Polygon Chain configuration by chain ID
+ * @param chainId - Chain ID (137 for mainnet)
+ * @returns Polygon Chain configuration
+ * @throws Error if chain ID is not supported
+ */
+const getPolygonByChainId = (chainId) => {
+    switch (chainId) {
+        case 137:
+            return POLYGON_MAINNET;
+        default:
+            throw new Error(`Unsupported Polygon Chain ID: ${chainId}. Supported chains: 137 (mainnet)`);
+    }
+};
+/**
+ * Get USDC contract address for Polygon by chain ID
+ * @param chainId - Chain ID (137 for mainnet)
+ * @returns USDC contract address
+ * @throws Error if chain ID is not supported
+ */
+const getPolygonUSDCAddress = (chainId) => {
+    switch (chainId) {
+        case 137:
+            return USDC_CONTRACT_ADDRESS_POLYGON_MAINNET;
+        default:
+            throw new Error(`Unsupported Polygon Chain ID: ${chainId}. Supported chains: 137 (mainnet)`);
+    }
+};
+
 class BaseAccount {
     constructor(baseRPCUrl, sourceSecretKey) {
         if (!baseRPCUrl) {
@@ -16575,15 +16776,16 @@ class BaseAccount {
             throw new Error('Source secret key is required');
         }
         this.account = accounts.privateKeyToAccount(sourceSecretKey);
-        this.accountId = this.account.address;
+        // Format accountId as network:address
+        this.accountId = `base:${this.account.address}`;
         this.walletClient = viem.createWalletClient({
             account: this.account,
             chain: chains.base,
             transport: viem.http(baseRPCUrl),
         });
-        this.paymentMakers = {
-            'base': new BasePaymentMaker(baseRPCUrl, this.walletClient),
-        };
+        this.paymentMakers = [
+            new BasePaymentMaker(baseRPCUrl, this.walletClient)
+        ];
     }
     /**
      * Get a signer that can be used with the x402 library
@@ -16593,9 +16795,20 @@ class BaseAccount {
         // Return the viem account directly - it implements LocalAccount interface
         return this.account;
     }
+    /**
+     * Get sources for this account
+     */
+    async getSources() {
+        return [{
+                address: this.account.address,
+                chain: 'base',
+                walletType: 'eoa'
+            }];
+    }
 }
 
 exports.ATXPAccount = ATXPAccount;
+exports.ATXPDestinationMaker = ATXPDestinationMaker;
 exports.ATXPLocalAccount = ATXPLocalAccount;
 exports.BaseAccount = BaseAccount;
 exports.BasePaymentMaker = BasePaymentMaker;
@@ -16603,11 +16816,14 @@ exports.DEFAULT_CLIENT_CONFIG = DEFAULT_CLIENT_CONFIG;
 exports.InsufficientFundsError = InsufficientFundsError;
 exports.OAuthAuthenticationRequiredError = OAuthAuthenticationRequiredError;
 exports.OAuthClient = OAuthClient;
+exports.POLYGON_MAINNET = POLYGON_MAINNET;
+exports.PassthroughDestinationMaker = PassthroughDestinationMaker;
 exports.PaymentNetworkError = PaymentNetworkError;
 exports.SolanaAccount = SolanaAccount;
 exports.SolanaPaymentMaker = SolanaPaymentMaker;
 exports.USDC_CONTRACT_ADDRESS_BASE = USDC_CONTRACT_ADDRESS_BASE;
 exports.USDC_CONTRACT_ADDRESS_BASE_SEPOLIA = USDC_CONTRACT_ADDRESS_BASE_SEPOLIA;
+exports.USDC_CONTRACT_ADDRESS_POLYGON_MAINNET = USDC_CONTRACT_ADDRESS_POLYGON_MAINNET;
 exports.USDC_CONTRACT_ADDRESS_WORLD_MAINNET = USDC_CONTRACT_ADDRESS_WORLD_MAINNET;
 exports.USDC_CONTRACT_ADDRESS_WORLD_SEPOLIA = USDC_CONTRACT_ADDRESS_WORLD_SEPOLIA;
 exports.ValidateTransferError = ValidateTransferError;
@@ -16618,6 +16834,9 @@ exports.atxpFetch = atxpFetch;
 exports.buildClientConfig = buildClientConfig;
 exports.buildStreamableTransport = buildStreamableTransport;
 exports.getBaseUSDCAddress = getBaseUSDCAddress;
+exports.getPolygonByChainId = getPolygonByChainId;
+exports.getPolygonMainnetWithRPC = getPolygonMainnetWithRPC;
+exports.getPolygonUSDCAddress = getPolygonUSDCAddress;
 exports.getWorldChainByChainId = getWorldChainByChainId;
 exports.getWorldChainMainnetWithRPC = getWorldChainMainnetWithRPC;
 exports.getWorldChainSepoliaWithRPC = getWorldChainSepoliaWithRPC;