@atxp/client 0.7.3 → 0.8.0

package/dist/index.js

@@ -1,6 +1,6 @@
-import { crypto as crypto$1, OAuthResourceClient, ConsoleLogger, PAYMENT_REQUIRED_ERROR_CODE, isSSEResponse, parseMcpMessages, parsePaymentRequests, paymentRequiredError, DEFAULT_AUTHORIZATION_SERVER, getIsReactNative, createReactNativeSafeFetch, MemoryOAuthDb, generateJWT } from '@atxp/common';
-import BigNumber$1, { BigNumber } from 'bignumber.js';
+import { crypto as crypto$1, OAuthResourceClient, ConsoleLogger, PAYMENT_REQUIRED_ERROR_CODE, isSSEResponse, parseMcpMessages, parsePaymentRequests, paymentRequiredError, DEFAULT_AUTHORIZATION_SERVER, getIsReactNative, createReactNativeSafeFetch, isEnumValue, ChainEnum, CurrencyEnum, NetworkEnum, assertNever, DEFAULT_ATXP_ACCOUNTS_SERVER, MemoryOAuthDb, generateJWT } from '@atxp/common';
 import * as oauth from 'oauth4webapi';
+import BigNumber$1, { BigNumber } from 'bignumber.js';
 import { PublicKey, ComputeBudgetProgram, sendAndConfirmTransaction, Connection, Keypair } from '@solana/web3.js';
 import { ValidateTransferError as ValidateTransferError$1, createTransfer } from '@solana/pay';
 import { getAssociatedTokenAddress, getAccount } from '@solana/spl-token';
@@ -312,9 +312,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,
@@ -332,7 +332,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}`);
@@ -340,7 +341,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}`);
@@ -350,35 +351,61 @@ class ATXPFetcher {
             if (!paymentRequestData.destinations || paymentRequestData.destinations.length === 0) {
                 return false;
             }
-            // Try each destination in order
-            for (const dest of paymentRequestData.destinations) {
-                const paymentMaker = this.paymentMakers.get(dest.network);
-                if (!paymentMaker) {
-                    this.logger.debug(`ATXP: payment network '${dest.network}' 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;
                 }
-                // Convert amount to BigNumber since it comes as a string from JSON
-                const amount = new BigNumber(dest.amount);
-                const prospectivePayment = {
-                    accountId: this.accountId,
-                    resourceUrl: paymentRequestData.resource?.toString() ?? '',
-                    resourceName: paymentRequestData.resourceName ?? '',
-                    network: dest.network,
-                    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 ${dest.network}`);
-                    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, dest.address, paymentRequestData.iss);
-                    this.logger.info(`ATXP: made payment of ${amount.toString()} ${dest.currency} on ${dest.network}: ${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: {
@@ -386,9 +413,10 @@ class ATXPFetcher {
                             'Content-Type': 'application/json'
                         },
                         body: JSON.stringify({
-                            transactionId: paymentId,
-                            network: dest.network,
-                            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}`);
@@ -401,13 +429,18 @@ class ATXPFetcher {
                 }
                 catch (error) {
                     const typedError = error;
-                    this.logger.warn(`ATXP: payment failed on ${dest.network}: ${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) => {
@@ -434,94 +467,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(0);
-            if (!paymentRequestData.amount) {
-                throw new Error(`amount not provided`);
-            }
-            try {
-                amount = new 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`);
-            }
-            const paymentMaker = this.paymentMakers.get(requestedNetwork);
-            if (!paymentMaker) {
-                this.logger.info(`ATXP: payment network '${requestedNetwork}' 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: requestedNetwork,
-                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, destination, paymentRequestData.iss);
-                this.logger.info(`ATXP: made payment of ${amount} ${currency} on ${requestedNetwork}: ${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: requestedNetwork,
-                    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);
@@ -529,6 +476,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(dest.amount);
+                    }
+                }
+            }
             return paymentRequest;
         };
         this.isAllowedAuthServer = (url) => {
@@ -542,15 +497,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
@@ -596,11 +551,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
@@ -615,14 +570,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;
@@ -633,13 +588,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) => {
@@ -730,15 +685,15 @@ class ATXPFetcher {
                 throw error;
             }
         };
-        const { accountId, db, paymentMakers, fetchFn = fetch, sideChannelFetch = fetchFn, strict = true, allowInsecureRequests = process.env.NODE_ENV === 'development', allowedAuthorizationServers = [DEFAULT_AUTHORIZATION_SERVER], approvePayment = async () => true, logger = new ConsoleLogger(), onAuthorize = async () => { }, onAuthorizeFailure = async () => { }, onPayment = async () => { }, onPaymentFailure = async () => { } } = config;
+        const { account, db, destinationMakers, fetchFn = fetch, sideChannelFetch = fetchFn, strict = true, allowInsecureRequests = process.env.NODE_ENV === 'development', allowedAuthorizationServers = [DEFAULT_AUTHORIZATION_SERVER], approvePayment = async () => true, logger = new ConsoleLogger(), onAuthorize = async () => { }, onAuthorizeFailure = async () => { }, onPayment = async () => { }, onPaymentFailure = async () => { } } = config;
         // Use React Native safe fetch if in React Native environment
         const safeFetchFn = getIsReactNative() ? createReactNativeSafeFetch(fetchFn) : fetchFn;
         const safeSideChannelFetch = getIsReactNative() ? 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,
@@ -748,10 +703,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;
@@ -15844,312 +15799,186 @@ 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: [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 ConsoleLogger();
-    const oAuthDb = withDefaults.oAuthDb ?? new MemoryOAuthDb({ logger });
-    const built = { oAuthDb, logger };
-    return Object.freeze({ ...withDefaults, ...built });
+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 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;
+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 PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
-const ValidateTransferError = ValidateTransferError$1;
-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 importJWK(jwk, 'EdDSA');
-            if (!(privateKey instanceof CryptoKey)) {
-                throw new Error('Expected CryptoKey from importJWK');
-            }
-            return 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 (!isEnumValue(ChainEnum, dest.chain)) {
+            const validChains = Object.values(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 (!isEnumValue(CurrencyEnum, dest.currency)) {
+            const validCurrencies = Object.values(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(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);
+    });
+}
+/**
+ * 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}`);
             }
-            const receiverKey = new PublicKey(receiver);
-            this.logger.info(`Making payment of ${amount} ${currency} to ${receiver} on Solana from ${this.source.publicKey.toBase58()}`);
-            try {
-                // Check balance before attempting payment
-                const tokenAccountAddress = await getAssociatedTokenAddress(USDC_MINT, this.source.publicKey);
-                const tokenAccount = await getAccount(this.connection, tokenAccountAddress);
-                const balance = new BigNumber$1(tokenAccount.amount.toString()).dividedBy(10 ** 6); // USDC has 6 decimals
-                if (balance.lt(amount)) {
-                    this.logger.warn(`Insufficient ${currency} balance for payment. Required: ${amount}, Available: ${balance}`);
-                    throw new InsufficientFundsError(currency, amount, balance, 'solana');
-                }
-                // Increase compute units to handle both memo and token transfer
-                // Memo uses ~6000 CUs, token transfer needs ~6500 CUs
-                const modifyComputeUnits = ComputeBudgetProgram.setComputeUnitLimit({
-                    units: 50000,
-                });
-                const addPriorityFee = ComputeBudgetProgram.setComputeUnitPrice({
-                    microLamports: 20000,
-                });
-                const transaction = await createTransfer(this.connection, this.source.publicKey, {
-                    amount: amount,
-                    recipient: receiverKey,
-                    splToken: USDC_MINT,
-                    memo,
-                });
-                transaction.add(modifyComputeUnits);
-                transaction.add(addPriorityFee);
-                const transactionHash = await sendAndConfirmTransaction(this.connection, transaction, [this.source]);
-                return transactionHash;
+            else {
+                logger.debug(`ATXPDestinationMaker: Got ${destinations.length} destinations 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);
+            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}`);
             }
-        };
-        if (!solanaEndpoint) {
-            throw new Error('Solana endpoint is required');
+            const data = await response.json();
+            return parseDestinationsResponse(data);
         }
-        if (!sourceSecretKey) {
-            throw new Error('Source secret key is required');
+        catch (error) {
+            logger?.error(`ATXPDestinationMaker: Error fetching destinations: ${error}`);
+            throw error;
         }
-        this.connection = new Connection(solanaEndpoint, { commitment: 'confirmed' });
-        this.source = Keypair.fromSecretKey(bs58.decode(sourceSecretKey));
-        this.logger = logger ?? new ConsoleLogger();
     }
 }
 
-const USDC_CONTRACT_ADDRESS_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"; // USDC on Base mainnet
-const USDC_CONTRACT_ADDRESS_BASE_SEPOLIA = "0x036CbD53842c5426634e7929541eC2318f3dCF7e"; // USDC on Base Sepolia testnet
-/**
- * Get USDC contract address for Base chain by chain ID
- * @param chainId - Chain ID (8453 for mainnet, 84532 for sepolia)
- * @returns USDC contract address
- * @throws Error if chain ID is not supported
- */
-const getBaseUSDCAddress = (chainId) => {
-    switch (chainId) {
-        case 8453: // Base mainnet
-            return USDC_CONTRACT_ADDRESS_BASE;
-        case 84532: // Base Sepolia
-            return USDC_CONTRACT_ADDRESS_BASE_SEPOLIA;
-        default:
-            throw new Error(`Unsupported Base Chain ID: ${chainId}. Supported chains: 8453 (mainnet), 84532 (sepolia)`);
+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(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 [];
+    }
+}
 
-// Helper function to convert to base64url that works in both Node.js and browsers
-function toBase64Url(data) {
-    // Convert string to base64
-    const base64 = typeof Buffer !== 'undefined'
-        ? Buffer.from(data).toString('base64')
-        : btoa(data);
-    // Convert base64 to base64url
-    return base64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
-}
-const USDC_DECIMALS = 6;
-const ERC20_ABI = [
-    {
-        constant: false,
-        inputs: [
-            { name: "_to", type: "address" },
-            { name: "_value", type: "uint256" },
-        ],
-        name: "transfer",
-        outputs: [{ name: "", type: "bool" }],
-        type: "function",
-    },
-    {
-        "constant": true,
-        "inputs": [
-            {
-                "name": "_owner",
-                "type": "address"
-            }
-        ],
-        "name": "balanceOf",
-        "outputs": [
-            {
-                "name": "balance",
-                "type": "uint256"
-            }
-        ],
-        "payable": false,
-        "stateMutability": "view",
-        "type": "function"
-    }
-];
-class BasePaymentMaker {
-    constructor(baseRPCUrl, walletClient, logger) {
-        if (!baseRPCUrl) {
-            throw new Error('baseRPCUrl was empty');
-        }
-        if (!walletClient) {
-            throw new Error('walletClient was empty');
-        }
-        if (!walletClient.account) {
-            throw new Error('walletClient.account was empty');
-        }
-        this.signingClient = walletClient.extend(publicActions);
-        this.logger = logger ?? new ConsoleLogger();
-    }
-    async generateJWT({ paymentRequestId, codeChallenge }) {
-        const headerObj = { alg: 'ES256K' };
-        const payloadObj = {
-            sub: this.signingClient.account.address,
-            iss: 'accounts.atxp.ai',
-            aud: 'https://auth.atxp.ai',
-            iat: Math.floor(Date.now() / 1000),
-            exp: Math.floor(Date.now() / 1000) + 60 * 60,
-            ...(codeChallenge ? { code_challenge: codeChallenge } : {}),
-            ...(paymentRequestId ? { payment_request_id: paymentRequestId } : {}),
-        };
-        const header = toBase64Url(JSON.stringify(headerObj));
-        const payload = toBase64Url(JSON.stringify(payloadObj));
-        const message = `${header}.${payload}`;
-        const messageBytes = typeof Buffer !== 'undefined'
-            ? Buffer.from(message, 'utf8')
-            : new TextEncoder().encode(message);
-        const signResult = await this.signingClient.signMessage({
-            account: this.signingClient.account,
-            message: { raw: messageBytes },
-        });
-        // For ES256K, signature is typically 65 bytes (r,s,v)
-        // Server expects the hex signature string (with 0x prefix) to be base64url encoded
-        // This creates: base64url("0x6eb2565...") not base64url(rawBytes)
-        // Pass the hex string directly to toBase64Url which will UTF-8 encode and base64url it
-        const signature = toBase64Url(signResult);
-        const jwt = `${header}.${payload}.${signature}`;
-        this.logger.info(`Generated ES256K JWT: ${jwt}`);
-        return jwt;
-    }
-    async makePayment(amount, currency, receiver) {
-        if (currency.toUpperCase() !== 'USDC') {
-            throw new PaymentNetworkError('Only USDC currency is supported; received ' + currency);
-        }
-        this.logger.info(`Making payment of ${amount} ${currency} to ${receiver} on Base from ${this.signingClient.account.address}`);
-        try {
-            // Check balance before attempting payment
-            const balanceRaw = await this.signingClient.readContract({
-                address: USDC_CONTRACT_ADDRESS_BASE,
-                abi: ERC20_ABI,
-                functionName: 'balanceOf',
-                args: [this.signingClient.account.address],
-            });
-            const balance = new BigNumber(balanceRaw.toString()).dividedBy(10 ** USDC_DECIMALS);
-            if (balance.lt(amount)) {
-                this.logger.warn(`Insufficient ${currency} balance for payment. Required: ${amount}, Available: ${balance}`);
-                throw new InsufficientFundsError(currency, amount, balance, 'base');
-            }
-            // Convert amount to USDC units (6 decimals) as BigInt
-            const amountInUSDCUnits = BigInt(amount.multipliedBy(10 ** USDC_DECIMALS).toFixed(0));
-            const data = encodeFunctionData({
-                abi: ERC20_ABI,
-                functionName: "transfer",
-                args: [receiver, amountInUSDCUnits],
-            });
-            const hash = await this.signingClient.sendTransaction({
-                chain: base,
-                account: this.signingClient.account,
-                to: USDC_CONTRACT_ADDRESS_BASE,
-                data: data,
-                value: parseEther('0'),
-                maxPriorityFeePerGas: parseEther('0.000000001')
-            });
-            // Wait for transaction confirmation with more blocks to ensure propagation
-            this.logger.info(`Waiting for transaction confirmation: ${hash}`);
-            const receipt = await this.signingClient.waitForTransactionReceipt({
-                hash: hash,
-                confirmations: 1
-            });
-            if (receipt.status === 'reverted') {
-                throw new PaymentNetworkError(`Transaction reverted: ${hash}`, new Error('Transaction reverted on chain'));
-            }
-            this.logger.info(`Transaction confirmed: ${hash} in block ${receipt.blockNumber}`);
-            return hash;
-        }
-        catch (error) {
-            if (error instanceof InsufficientFundsError || error instanceof PaymentNetworkError) {
-                throw error;
-            }
-            // Wrap other errors in PaymentNetworkError
-            throw new PaymentNetworkError(`Payment failed on Base network: ${error.message}`, error);
-        }
-    }
-}
-
-class SolanaAccount {
-    constructor(solanaEndpoint, sourceSecretKey) {
-        if (!solanaEndpoint) {
-            throw new Error('Solana endpoint is required');
-        }
-        if (!sourceSecretKey) {
-            throw new Error('Source secret key is required');
-        }
-        const source = Keypair.fromSecretKey(bs58.decode(sourceSecretKey));
-        this.accountId = source.publicKey.toBase58();
-        this.paymentMakers = {
-            'solana': new SolanaPaymentMaker(solanaEndpoint, sourceSecretKey),
-        };
-    }
+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(NetworkEnum)) {
+        // Exhaustiveness check using switch with assertNever
+        switch (network) {
+            case NetworkEnum.Solana:
+                makers.set(network, new PassthroughDestinationMaker(network));
+                break;
+            case NetworkEnum.Base:
+                makers.set(network, new PassthroughDestinationMaker(network));
+                break;
+            case NetworkEnum.World:
+                makers.set(network, new PassthroughDestinationMaker(network));
+                break;
+            case NetworkEnum.Polygon:
+                makers.set(network, new PassthroughDestinationMaker(network));
+                break;
+            case NetworkEnum.BaseSepolia:
+                makers.set(network, new PassthroughDestinationMaker(network));
+                break;
+            case NetworkEnum.WorldSepolia:
+                makers.set(network, new PassthroughDestinationMaker(network));
+                break;
+            case 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
+                assertNever(network);
+        }
+    }
+    return makers;
 }
 
 function toBasicAuth$1(token) {
@@ -16265,6 +16094,9 @@ function parseConnectionString(connectionString) {
     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 {
@@ -16273,8 +16105,33 @@ class ATXPHttpPaymentMaker {
         this.token = token;
         this.fetchFn = fetchFn;
     }
-    async makePayment(amount, currency, receiver, memo) {
-        // Make a regular payment via the /pay endpoint
+    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: {
@@ -16282,10 +16139,14 @@ class ATXPHttpPaymentMaker {
                 'Content-Type': 'application/json',
             },
             body: JSON.stringify({
-                amount: amount.toString(),
-                currency,
-                receiver,
+                destinations: destinations.map(d => ({
+                    chain: d.chain,
+                    address: d.address,
+                    amount: d.amount.toString(),
+                    currency: d.currency
+                })),
                 memo,
+                ...(paymentRequestId && { paymentRequestId })
             }),
         });
         if (!response.ok) {
@@ -16293,10 +16154,22 @@ class ATXPHttpPaymentMaker {
             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');
+        const transactionId = json.transactionId;
+        if (!transactionId) {
+            throw new Error('ATXPAccount: /pay did not return transactionId or txHash');
         }
-        return json.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`, {
@@ -16308,6 +16181,7 @@ class ATXPHttpPaymentMaker {
             body: JSON.stringify({
                 paymentRequestId: params.paymentRequestId,
                 codeChallenge: params.codeChallenge,
+                ...(params.accountId ? { accountId: params.accountId } : {}),
             }),
         });
         if (!response.ok) {
@@ -16325,23 +16199,418 @@ 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}`;
+        // 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}`);
         }
-        else {
-            this.accountId = `atxp:${crypto$1.randomUUID()}`;
+        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: [DEFAULT_AUTHORIZATION_SERVER],
+    atxpAccountsServer: 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 ConsoleLogger();
+    const oAuthDb = withDefaults.oAuthDb ?? new 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 PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
+const ValidateTransferError = ValidateTransferError$1;
+class SolanaPaymentMaker {
+    constructor(solanaEndpoint, sourceSecretKey, logger) {
+        this.generateJWT = async ({ paymentRequestId, codeChallenge, accountId }) => {
+            // Solana/Web3.js secretKey is 64 bytes:
+            // first 32 bytes are the private scalar, last 32 are the public key.
+            // JWK expects only the 32-byte private scalar for 'd'
+            const jwk = {
+                kty: 'OKP',
+                crv: 'Ed25519',
+                d: Buffer.from(this.source.secretKey.slice(0, 32)).toString('base64url'),
+                x: Buffer.from(this.source.publicKey.toBytes()).toString('base64url'),
+            };
+            const privateKey = await importJWK(jwk, 'EdDSA');
+            if (!(privateKey instanceof CryptoKey)) {
+                throw new Error('Expected CryptoKey from importJWK');
+            }
+            return generateJWT(this.source.publicKey.toBase58(), privateKey, paymentRequestId || '', codeChallenge || '', accountId);
+        };
+        this.makePayment = async (destinations, memo, _paymentRequestId) => {
+            // Filter to solana chain destinations
+            const solanaDestinations = destinations.filter(d => d.chain === 'solana');
+            if (solanaDestinations.length === 0) {
+                this.logger.debug('SolanaPaymentMaker: No solana destinations found, cannot handle payment');
+                return null; // Cannot handle these destinations
+            }
+            // Pick first solana destination
+            const dest = solanaDestinations[0];
+            const amount = dest.amount;
+            const currency = dest.currency;
+            const receiver = dest.address;
+            if (currency.toUpperCase() !== 'USDC') {
+                throw new PaymentNetworkError('Only USDC currency is supported; received ' + currency);
+            }
+            const receiverKey = new PublicKey(receiver);
+            this.logger.info(`Making payment of ${amount} ${currency} to ${receiver} on Solana from ${this.source.publicKey.toBase58()}`);
+            try {
+                // Check balance before attempting payment
+                const tokenAccountAddress = await getAssociatedTokenAddress(USDC_MINT, this.source.publicKey);
+                const tokenAccount = await getAccount(this.connection, tokenAccountAddress);
+                const balance = new BigNumber$1(tokenAccount.amount.toString()).dividedBy(10 ** 6); // USDC has 6 decimals
+                if (balance.lt(amount)) {
+                    this.logger.warn(`Insufficient ${currency} balance for payment. Required: ${amount}, Available: ${balance}`);
+                    throw new InsufficientFundsError(currency, amount, balance, 'solana');
+                }
+                // Get the destination token account address (this will be the transactionId)
+                const destinationTokenAccount = await getAssociatedTokenAddress(USDC_MINT, receiverKey);
+                // Increase compute units to handle both memo and token transfer
+                // Memo uses ~6000 CUs, token transfer needs ~6500 CUs
+                const modifyComputeUnits = ComputeBudgetProgram.setComputeUnitLimit({
+                    units: 50000,
+                });
+                const addPriorityFee = ComputeBudgetProgram.setComputeUnitPrice({
+                    microLamports: 20000,
+                });
+                const transaction = await createTransfer(this.connection, this.source.publicKey, {
+                    amount: amount,
+                    recipient: receiverKey,
+                    splToken: USDC_MINT,
+                    memo,
+                });
+                transaction.add(modifyComputeUnits);
+                transaction.add(addPriorityFee);
+                const transactionSignature = await sendAndConfirmTransaction(this.connection, transaction, [this.source]);
+                // Return transaction signature as transactionId and token account address as transactionSubId
+                return {
+                    transactionId: transactionSignature,
+                    transactionSubId: destinationTokenAccount.toBase58(),
+                    chain: 'solana',
+                    currency: 'USDC'
+                };
+            }
+            catch (error) {
+                if (error instanceof InsufficientFundsError || error instanceof PaymentNetworkError) {
+                    throw error;
+                }
+                // Wrap other errors in PaymentNetworkError
+                throw new PaymentNetworkError(`Payment failed on Solana network: ${error.message}`, error);
+            }
+        };
+        if (!solanaEndpoint) {
+            throw new Error('Solana endpoint is required');
+        }
+        if (!sourceSecretKey) {
+            throw new Error('Source secret key is required');
+        }
+        this.connection = new Connection(solanaEndpoint, { commitment: 'confirmed' });
+        this.source = Keypair.fromSecretKey(bs58.decode(sourceSecretKey));
+        this.logger = logger ?? new ConsoleLogger();
+    }
+    getSourceAddress(_params) {
+        return this.source.publicKey.toBase58();
+    }
+}
+
+const USDC_CONTRACT_ADDRESS_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"; // USDC on Base mainnet
+const USDC_CONTRACT_ADDRESS_BASE_SEPOLIA = "0x036CbD53842c5426634e7929541eC2318f3dCF7e"; // USDC on Base Sepolia testnet
+/**
+ * Get USDC contract address for Base chain by chain ID
+ * @param chainId - Chain ID (8453 for mainnet, 84532 for sepolia)
+ * @returns USDC contract address
+ * @throws Error if chain ID is not supported
+ */
+const getBaseUSDCAddress = (chainId) => {
+    switch (chainId) {
+        case 8453: // Base mainnet
+            return USDC_CONTRACT_ADDRESS_BASE;
+        case 84532: // Base Sepolia
+            return USDC_CONTRACT_ADDRESS_BASE_SEPOLIA;
+        default:
+            throw new Error(`Unsupported Base Chain ID: ${chainId}. Supported chains: 8453 (mainnet), 84532 (sepolia)`);
+    }
+};
+
+// Helper function to convert to base64url that works in both Node.js and browsers
+function toBase64Url(data) {
+    // Convert string to base64
+    const base64 = typeof Buffer !== 'undefined'
+        ? Buffer.from(data).toString('base64')
+        : btoa(data);
+    // Convert base64 to base64url
+    return base64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
+}
+const USDC_DECIMALS = 6;
+const ERC20_ABI = [
+    {
+        constant: false,
+        inputs: [
+            { name: "_to", type: "address" },
+            { name: "_value", type: "uint256" },
+        ],
+        name: "transfer",
+        outputs: [{ name: "", type: "bool" }],
+        type: "function",
+    },
+    {
+        "constant": true,
+        "inputs": [
+            {
+                "name": "_owner",
+                "type": "address"
+            }
+        ],
+        "name": "balanceOf",
+        "outputs": [
+            {
+                "name": "balance",
+                "type": "uint256"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "view",
+        "type": "function"
+    }
+];
+class BasePaymentMaker {
+    constructor(baseRPCUrl, walletClient, logger) {
+        if (!baseRPCUrl) {
+            throw new Error('baseRPCUrl was empty');
+        }
+        if (!walletClient) {
+            throw new Error('walletClient was empty');
+        }
+        if (!walletClient.account) {
+            throw new Error('walletClient.account was empty');
         }
-        this.paymentMakers = {
-            [network]: new ATXPHttpPaymentMaker(origin, token, fetchFn),
+        this.signingClient = walletClient.extend(publicActions);
+        this.logger = logger ?? new ConsoleLogger();
+    }
+    getSourceAddress(_params) {
+        return this.signingClient.account.address;
+    }
+    async generateJWT({ paymentRequestId, codeChallenge, accountId }) {
+        const headerObj = { alg: 'ES256K' };
+        const payloadObj = {
+            sub: this.signingClient.account.address,
+            iss: 'accounts.atxp.ai',
+            aud: 'https://auth.atxp.ai',
+            iat: Math.floor(Date.now() / 1000),
+            exp: Math.floor(Date.now() / 1000) + 60 * 60,
+            ...(codeChallenge ? { code_challenge: codeChallenge } : {}),
+            ...(paymentRequestId ? { payment_request_id: paymentRequestId } : {}),
+            ...(accountId ? { account_id: accountId } : {}),
         };
+        const header = toBase64Url(JSON.stringify(headerObj));
+        const payload = toBase64Url(JSON.stringify(payloadObj));
+        const message = `${header}.${payload}`;
+        const messageBytes = typeof Buffer !== 'undefined'
+            ? Buffer.from(message, 'utf8')
+            : new TextEncoder().encode(message);
+        const signResult = await this.signingClient.signMessage({
+            account: this.signingClient.account,
+            message: { raw: messageBytes },
+        });
+        // For ES256K, signature is typically 65 bytes (r,s,v)
+        // Server expects the hex signature string (with 0x prefix) to be base64url encoded
+        // This creates: base64url("0x6eb2565...") not base64url(rawBytes)
+        // Pass the hex string directly to toBase64Url which will UTF-8 encode and base64url it
+        const signature = toBase64Url(signResult);
+        const jwt = `${header}.${payload}.${signature}`;
+        this.logger.info(`Generated ES256K JWT: ${jwt}`);
+        return jwt;
     }
-    async getSigner() {
-        return ATXPLocalAccount.create(this.origin, this.token, this.fetchFn);
+    async makePayment(destinations, _memo, _paymentRequestId) {
+        // Filter to base chain destinations
+        const baseDestinations = destinations.filter(d => d.chain === 'base');
+        if (baseDestinations.length === 0) {
+            this.logger.debug('BasePaymentMaker: No base destinations found, cannot handle payment');
+            return null; // Cannot handle these destinations
+        }
+        // Pick first base destination
+        const dest = baseDestinations[0];
+        const amount = dest.amount;
+        const currency = dest.currency;
+        const receiver = dest.address;
+        if (currency.toUpperCase() !== 'USDC') {
+            throw new PaymentNetworkError('Only USDC currency is supported; received ' + currency);
+        }
+        this.logger.info(`Making payment of ${amount} ${currency} to ${receiver} on Base from ${this.signingClient.account.address}`);
+        try {
+            // Check balance before attempting payment
+            const balanceRaw = await this.signingClient.readContract({
+                address: USDC_CONTRACT_ADDRESS_BASE,
+                abi: ERC20_ABI,
+                functionName: 'balanceOf',
+                args: [this.signingClient.account.address],
+            });
+            const balance = new BigNumber(balanceRaw.toString()).dividedBy(10 ** USDC_DECIMALS);
+            if (balance.lt(amount)) {
+                this.logger.warn(`Insufficient ${currency} balance for payment. Required: ${amount}, Available: ${balance}`);
+                throw new InsufficientFundsError(currency, amount, balance, 'base');
+            }
+            // Convert amount to USDC units (6 decimals) as BigInt
+            const amountInUSDCUnits = BigInt(amount.multipliedBy(10 ** USDC_DECIMALS).toFixed(0));
+            const data = encodeFunctionData({
+                abi: ERC20_ABI,
+                functionName: "transfer",
+                args: [receiver, amountInUSDCUnits],
+            });
+            const hash = await this.signingClient.sendTransaction({
+                chain: base,
+                account: this.signingClient.account,
+                to: USDC_CONTRACT_ADDRESS_BASE,
+                data: data,
+                value: parseEther('0'),
+                maxPriorityFeePerGas: parseEther('0.000000001')
+            });
+            // Wait for transaction confirmation with more blocks to ensure propagation
+            this.logger.info(`Waiting for transaction confirmation: ${hash}`);
+            const receipt = await this.signingClient.waitForTransactionReceipt({
+                hash: hash,
+                confirmations: 1
+            });
+            if (receipt.status === 'reverted') {
+                throw new PaymentNetworkError(`Transaction reverted: ${hash}`, new Error('Transaction reverted on chain'));
+            }
+            this.logger.info(`Transaction confirmed: ${hash} in block ${receipt.blockNumber}`);
+            // Return payment result with chain and currency
+            return {
+                transactionId: hash,
+                chain: 'base',
+                currency: 'USDC'
+            };
+        }
+        catch (error) {
+            if (error instanceof InsufficientFundsError || error instanceof PaymentNetworkError) {
+                throw error;
+            }
+            // Wrap other errors in PaymentNetworkError
+            throw new PaymentNetworkError(`Payment failed on Base network: ${error.message}`, error);
+        }
+    }
+}
+
+class SolanaAccount {
+    constructor(solanaEndpoint, sourceSecretKey) {
+        if (!solanaEndpoint) {
+            throw new Error('Solana endpoint is required');
+        }
+        if (!sourceSecretKey) {
+            throw new Error('Source secret key is required');
+        }
+        const source = Keypair.fromSecretKey(bs58.decode(sourceSecretKey));
+        this.sourcePublicKey = source.publicKey.toBase58();
+        // Format accountId as network:address
+        this.accountId = `solana:${this.sourcePublicKey}`;
+        this.paymentMakers = [
+            new SolanaPaymentMaker(solanaEndpoint, sourceSecretKey)
+        ];
+    }
+    /**
+     * Get sources for this account
+     */
+    async getSources() {
+        return [{
+                address: this.sourcePublicKey,
+                chain: 'solana',
+                walletType: 'eoa'
+            }];
     }
 }
 
@@ -16425,6 +16694,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) {
@@ -16434,15 +16755,16 @@ class BaseAccount {
             throw new Error('Source secret key is required');
         }
         this.account = privateKeyToAccount(sourceSecretKey);
-        this.accountId = this.account.address;
+        // Format accountId as network:address
+        this.accountId = `base:${this.account.address}`;
         this.walletClient = createWalletClient({
             account: this.account,
             chain: base,
             transport: 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
@@ -16452,7 +16774,17 @@ 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'
+            }];
+    }
 }
 
-export { ATXPAccount, ATXPLocalAccount, BaseAccount, BasePaymentMaker, DEFAULT_CLIENT_CONFIG, InsufficientFundsError, OAuthAuthenticationRequiredError, OAuthClient, PaymentNetworkError, SolanaAccount, SolanaPaymentMaker, USDC_CONTRACT_ADDRESS_BASE, USDC_CONTRACT_ADDRESS_BASE_SEPOLIA, USDC_CONTRACT_ADDRESS_WORLD_MAINNET, USDC_CONTRACT_ADDRESS_WORLD_SEPOLIA, ValidateTransferError, WORLD_CHAIN_MAINNET, WORLD_CHAIN_SEPOLIA, atxpClient, atxpFetch, buildClientConfig, buildStreamableTransport, getBaseUSDCAddress, getWorldChainByChainId, getWorldChainMainnetWithRPC, getWorldChainSepoliaWithRPC, getWorldChainUSDCAddress };
+export { ATXPAccount, ATXPDestinationMaker, ATXPLocalAccount, BaseAccount, BasePaymentMaker, DEFAULT_CLIENT_CONFIG, InsufficientFundsError, OAuthAuthenticationRequiredError, OAuthClient, POLYGON_MAINNET, PassthroughDestinationMaker, PaymentNetworkError, SolanaAccount, SolanaPaymentMaker, USDC_CONTRACT_ADDRESS_BASE, USDC_CONTRACT_ADDRESS_BASE_SEPOLIA, USDC_CONTRACT_ADDRESS_POLYGON_MAINNET, USDC_CONTRACT_ADDRESS_WORLD_MAINNET, USDC_CONTRACT_ADDRESS_WORLD_SEPOLIA, ValidateTransferError, WORLD_CHAIN_MAINNET, WORLD_CHAIN_SEPOLIA, atxpClient, atxpFetch, buildClientConfig, buildStreamableTransport, getBaseUSDCAddress, getPolygonByChainId, getPolygonMainnetWithRPC, getPolygonUSDCAddress, getWorldChainByChainId, getWorldChainMainnetWithRPC, getWorldChainSepoliaWithRPC, getWorldChainUSDCAddress };
 //# sourceMappingURL=index.js.map