@atxp/client 0.7.4 → 0.8.1

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,6 +15820,191 @@ class StreamableHTTPClientTransport {
     }
 }
 
+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');
+}
+function isDestinationsApiResponse(obj) {
+    return (typeof obj === 'object' &&
+        obj !== null &&
+        'destinations' in obj &&
+        'paymentRequestId' in obj &&
+        Array.isArray(obj.destinations) &&
+        typeof obj.paymentRequestId === 'string');
+}
+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
+        };
+    });
+}
+/**
+ * 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}`);
+            }
+            else {
+                logger.debug(`ATXPDestinationMaker: Got ${destinations.length} destinations for account ${accountId}`);
+            }
+            return destinations;
+        }
+        catch (error) {
+            logger.error(`ATXPDestinationMaker: Failed to make ATXP destinations: ${error}`);
+            throw error;
+        }
+    }
+    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;
+        }
+    }
+}
+
+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.PolygonAmoy:
+                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;
+}
+
 // Detect if we're in a browser environment and bind fetch appropriately
 const getFetch = () => {
     if (typeof window !== 'undefined' && typeof window.fetch === 'function') {
@@ -15965,6 +16016,7 @@ const getFetch = () => {
 };
 const DEFAULT_CLIENT_CONFIG = {
     allowedAuthorizationServers: [common.DEFAULT_AUTHORIZATION_SERVER],
+    atxpAccountsServer: common.DEFAULT_ATXP_ACCOUNTS_SERVER,
     approvePayment: async (_p) => true,
     fetchFn: getFetch(),
     oAuthChannelFetch: getFetch(),
@@ -15994,7 +16046,20 @@ function buildClientConfig(args) {
     const withDefaults = { ...envDefaults, ...args };
     const logger = withDefaults.logger ?? new common.ConsoleLogger();
     const oAuthDb = withDefaults.oAuthDb ?? new common.MemoryOAuthDb({ logger });
-    const built = { oAuthDb, 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 common.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) {
@@ -16017,7 +16082,7 @@ const USDC_MINT = new web3_js.PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwy
 const ValidateTransferError = pay.ValidateTransferError;
 class SolanaPaymentMaker {
     constructor(solanaEndpoint, sourceSecretKey, logger) {
-        this.generateJWT = async ({ paymentRequestId, codeChallenge }) => {
+        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'
@@ -16031,9 +16096,20 @@ class SolanaPaymentMaker {
             if (!(privateKey instanceof CryptoKey)) {
                 throw new Error('Expected CryptoKey from importJWK');
             }
-            return common.generateJWT(this.source.publicKey.toBase58(), privateKey, paymentRequestId || '', codeChallenge || '');
+            return common.generateJWT(this.source.publicKey.toBase58(), privateKey, paymentRequestId || '', codeChallenge || '', accountId);
         };
-        this.makePayment = async (amount, currency, receiver, memo) => {
+        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);
             }
@@ -16048,6 +16124,8 @@ class SolanaPaymentMaker {
                     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({
@@ -16064,8 +16142,14 @@ class SolanaPaymentMaker {
                 });
                 transaction.add(modifyComputeUnits);
                 transaction.add(addPriorityFee);
-                const transactionHash = await web3_js.sendAndConfirmTransaction(this.connection, transaction, [this.source]);
-                return transactionHash;
+                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) {
@@ -16167,7 +16251,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 +16261,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 +16282,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 +16336,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 +16362,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
+     * Get sources for this account
      */
-    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');
-    }
-    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 +16461,88 @@ const getWorldChainUSDCAddress = (chainId) => {
     }
 };
 
+const USDC_CONTRACT_ADDRESS_POLYGON_MAINNET = "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359"; // Native USDC on Polygon mainnet
+const USDC_CONTRACT_ADDRESS_POLYGON_AMOY = "0x41E94Eb019C0762f9Bfcf9Fb1E58725BfB0e7582"; // USDC on Polygon Amoy testnet
+// Polygon Mainnet (Chain ID: 137)
+// Note: Native currency upgraded from MATIC to POL on September 4, 2024
+const POLYGON_MAINNET = {
+    id: 137,
+    name: 'Polygon',
+    nativeCurrency: { name: 'POL', symbol: 'POL', decimals: 18 },
+    rpcUrls: {
+        default: { http: ['https://polygon-rpc.com'] }
+    },
+    blockExplorers: {
+        default: { name: 'PolygonScan', url: 'https://polygonscan.com' }
+    }
+};
+// Polygon Amoy Testnet (Chain ID: 80002)
+// Note: Amoy testnet also uses POL as native currency (following mainnet upgrade)
+const POLYGON_AMOY = {
+    id: 80002,
+    name: 'Polygon Amoy',
+    nativeCurrency: { name: 'POL', symbol: 'POL', decimals: 18 },
+    rpcUrls: {
+        default: { http: ['https://rpc-amoy.polygon.technology'] }
+    },
+    blockExplorers: {
+        default: { name: 'PolygonScan Amoy', url: 'https://amoy.polygonscan.com' }
+    },
+    testnet: true
+};
+/**
+ * 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 Amoy Testnet configuration with custom RPC URL (e.g., with API key)
+ * @param rpcUrl - Custom RPC URL, e.g., 'https://polygon-amoy.g.alchemy.com/v2/YOUR_API_KEY'
+ */
+const getPolygonAmoyWithRPC = (rpcUrl) => ({
+    ...POLYGON_AMOY,
+    rpcUrls: {
+        default: { http: [rpcUrl] }
+    }
+});
+/**
+ * Get Polygon Chain configuration by chain ID
+ * @param chainId - Chain ID (137 for mainnet, 80002 for Amoy testnet)
+ * @returns Polygon Chain configuration
+ * @throws Error if chain ID is not supported
+ */
+const getPolygonByChainId = (chainId) => {
+    switch (chainId) {
+        case 137:
+            return POLYGON_MAINNET;
+        case 80002:
+            return POLYGON_AMOY;
+        default:
+            throw new Error(`Unsupported Polygon Chain ID: ${chainId}. Supported chains: 137 (mainnet), 80002 (Amoy testnet)`);
+    }
+};
+/**
+ * Get USDC contract address for Polygon by chain ID
+ * @param chainId - Chain ID (137 for mainnet, 80002 for Amoy testnet)
+ * @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;
+        case 80002:
+            return USDC_CONTRACT_ADDRESS_POLYGON_AMOY;
+        default:
+            throw new Error(`Unsupported Polygon Chain ID: ${chainId}. Supported chains: 137 (mainnet), 80002 (Amoy testnet)`);
+    }
+};
+
 class BaseAccount {
     constructor(baseRPCUrl, sourceSecretKey) {
         if (!baseRPCUrl) {
@@ -16575,27 +16552,141 @@ 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
-     * This is only available for EVM-based accounts
+     * Get the LocalAccount (signer) for this account.
+     * This can be used with the x402 library or other signing operations.
      */
-    getSigner() {
-        // Return the viem account directly - it implements LocalAccount interface
+    getLocalAccount() {
         return this.account;
     }
+    /**
+     * Get sources for this account
+     */
+    async getSources() {
+        return [{
+                address: this.account.address,
+                chain: 'base',
+                walletType: 'eoa'
+            }];
+    }
 }
 
-exports.ATXPAccount = ATXPAccount;
+function toBasicAuth(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(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(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');
+    }
+}
+
+Object.defineProperty(exports, "ATXPAccount", {
+    enumerable: true,
+    get: function () { return common.ATXPAccount; }
+});
+exports.ATXPDestinationMaker = ATXPDestinationMaker;
 exports.ATXPLocalAccount = ATXPLocalAccount;
 exports.BaseAccount = BaseAccount;
 exports.BasePaymentMaker = BasePaymentMaker;
@@ -16603,11 +16694,16 @@ exports.DEFAULT_CLIENT_CONFIG = DEFAULT_CLIENT_CONFIG;
 exports.InsufficientFundsError = InsufficientFundsError;
 exports.OAuthAuthenticationRequiredError = OAuthAuthenticationRequiredError;
 exports.OAuthClient = OAuthClient;
+exports.POLYGON_AMOY = POLYGON_AMOY;
+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_AMOY = USDC_CONTRACT_ADDRESS_POLYGON_AMOY;
+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 +16714,10 @@ exports.atxpFetch = atxpFetch;
 exports.buildClientConfig = buildClientConfig;
 exports.buildStreamableTransport = buildStreamableTransport;
 exports.getBaseUSDCAddress = getBaseUSDCAddress;
+exports.getPolygonAmoyWithRPC = getPolygonAmoyWithRPC;
+exports.getPolygonByChainId = getPolygonByChainId;
+exports.getPolygonMainnetWithRPC = getPolygonMainnetWithRPC;
+exports.getPolygonUSDCAddress = getPolygonUSDCAddress;
 exports.getWorldChainByChainId = getWorldChainByChainId;
 exports.getWorldChainMainnetWithRPC = getWorldChainMainnetWithRPC;
 exports.getWorldChainSepoliaWithRPC = getWorldChainSepoliaWithRPC;