@atxp/client 0.5.1 → 0.6.0

package/dist/index.d.ts

@@ -1,11 +1,11 @@
-import { Currency, AuthorizationServerUrl, Network, OAuthDb, FetchLike, Logger, OAuthResourceClient, ClientCredentials, PKCEValues, AccessToken, PaymentRequestData } from '@atxp/common';
+import { Currency, AuthorizationServerUrl, Network, OAuthDb, FetchLike, Logger, OAuthResourceClient, ClientCredentials, PKCEValues, AccessToken } from '@atxp/common';
 import { ClientOptions, Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { Implementation, McpError } from '@modelcontextprotocol/sdk/types.js';
+import { Implementation } from '@modelcontextprotocol/sdk/types.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import * as oauth from 'oauth4webapi';
 import { ValidateTransferError as ValidateTransferError$1 } from '@solana/pay';
 import BigNumber$1 from 'bignumber.js';
-import { WalletClient, PublicActions } from 'viem';
+import { WalletClient, PublicActions, LocalAccount, Address, TypedData, Hex as Hex$1, SignableMessage, TransactionSerializable } from 'viem';
 
 type Hex = `0x${string}`;
 type AccountPrefix = Network;
@@ -54,6 +54,11 @@ type ClientConfig = {
         error: Error;
     }) => Promise<void>;
 };
+type RequiredClientConfigFields$1 = 'mcpServer' | 'account';
+type RequiredClientConfig = Pick<ClientConfig, RequiredClientConfigFields$1>;
+type OptionalClientConfig$1 = Omit<ClientConfig, RequiredClientConfigFields$1>;
+type ClientArgs = RequiredClientConfig & Partial<OptionalClientConfig$1>;
+type FetchWrapper = (config: ClientArgs) => FetchLike;
 declare class InsufficientFundsError extends Error {
     readonly currency: Currency;
     readonly required: BigNumber;
@@ -74,9 +79,7 @@ interface PaymentMaker {
 }
 
 type RequiredClientConfigFields = 'mcpServer' | 'account';
-type RequiredClientConfig = Pick<ClientConfig, RequiredClientConfigFields>;
 type OptionalClientConfig = Omit<ClientConfig, RequiredClientConfigFields>;
-type ClientArgs = RequiredClientConfig & Partial<OptionalClientConfig>;
 type BuildableClientConfigFields = 'oAuthDb' | 'logger';
 declare const DEFAULT_CLIENT_CONFIG: Required<Omit<OptionalClientConfig, BuildableClientConfigFields>>;
 declare function buildClientConfig(args: ClientArgs): ClientConfig;
@@ -124,73 +127,14 @@ declare class OAuthClient extends OAuthResourceClient {
     protected _doFetch: FetchLike;
 }
 
-interface ATXPFetcherConfig {
-    accountId: string;
-    db: OAuthDb;
-    paymentMakers: {
-        [key: string]: PaymentMaker;
-    };
-    fetchFn?: FetchLike;
-    sideChannelFetch?: FetchLike;
-    strict?: boolean;
-    allowInsecureRequests?: boolean;
-    allowedAuthorizationServers?: AuthorizationServerUrl[];
-    approvePayment?: (payment: ProspectivePayment) => Promise<boolean>;
-    logger?: Logger;
-    onAuthorize?: (args: {
-        authorizationServer: AuthorizationServerUrl;
-        userId: string;
-    }) => Promise<void>;
-    onAuthorizeFailure?: (args: {
-        authorizationServer: AuthorizationServerUrl;
-        userId: string;
-        error: Error;
-    }) => Promise<void>;
-    onPayment?: (args: {
-        payment: ProspectivePayment;
-    }) => Promise<void>;
-    onPaymentFailure?: (args: {
-        payment: ProspectivePayment;
-        error: Error;
-    }) => Promise<void>;
-}
-declare function atxpFetch(config: ATXPFetcherConfig): FetchLike;
-declare class ATXPFetcher {
-    protected oauthClient: OAuthClient;
-    protected paymentMakers: Map<string, PaymentMaker>;
-    protected sideChannelFetch: FetchLike;
-    protected db: OAuthDb;
-    protected accountId: string;
-    protected allowedAuthorizationServers: AuthorizationServerUrl[];
-    protected approvePayment: (payment: ProspectivePayment) => Promise<boolean>;
-    protected logger: Logger;
-    protected onAuthorize: (args: {
-        authorizationServer: AuthorizationServerUrl;
-        userId: string;
-    }) => Promise<void>;
-    protected onAuthorizeFailure: (args: {
-        authorizationServer: AuthorizationServerUrl;
-        userId: string;
-        error: Error;
-    }) => Promise<void>;
-    protected onPayment: (args: {
-        payment: ProspectivePayment;
-    }) => Promise<void>;
-    protected onPaymentFailure: (args: {
-        payment: ProspectivePayment;
-        error: Error;
-    }) => Promise<void>;
-    constructor({ accountId, db, paymentMakers, fetchFn, sideChannelFetch, strict, allowInsecureRequests, allowedAuthorizationServers, approvePayment, logger, onAuthorize, onAuthorizeFailure, onPayment, onPaymentFailure }: ATXPFetcherConfig);
-    private defaultPaymentFailureHandler;
-    protected handlePaymentRequestError: (paymentRequestError: McpError) => Promise<boolean>;
-    protected getPaymentRequestData: (paymentRequestUrl: string) => Promise<PaymentRequestData | null>;
-    protected isAllowedAuthServer: (url: string | URL) => boolean;
-    protected makeAuthRequestWithPaymentMaker: (authorizationUrl: URL, paymentMaker: PaymentMaker) => Promise<string>;
-    protected authToService: (error: OAuthAuthenticationRequiredError) => Promise<void>;
-    protected exchangeToken: (myToken: AccessToken, newResourceUrl: string) => Promise<AccessToken>;
-    protected checkForATXPResponse: (response: Response) => Promise<void>;
-    fetch: FetchLike;
-}
+/**
+ * Creates an ATXP fetch wrapper that handles OAuth authentication and payments.
+ * This follows the wrapper pattern for fetch functions.
+ *
+ * @param config - The client configuration
+ * @returns A wrapped fetch function that handles ATXP protocol
+ */
+declare function atxpFetch(config: ClientConfig): FetchLike;
 
 declare const ValidateTransferError: typeof ValidateTransferError$1;
 declare class SolanaPaymentMaker implements PaymentMaker {
@@ -230,10 +174,14 @@ declare class ATXPAccount implements Account {
     paymentMakers: {
         [key: string]: PaymentMaker;
     };
+    origin: string;
+    token: string;
+    fetchFn: FetchLike;
     constructor(connectionString: string, opts?: {
         fetchFn?: FetchLike;
         network?: Network;
     });
+    getSigner(): Promise<LocalAccount>;
 }
 
 declare const USDC_CONTRACT_ADDRESS_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
@@ -243,8 +191,63 @@ declare class BaseAccount implements Account {
     paymentMakers: {
         [key: string]: PaymentMaker;
     };
+    private walletClient;
+    private account;
     constructor(baseRPCUrl: string, sourceSecretKey: string);
+    /**
+     * Get a signer that can be used with the x402 library
+     * This is only available for EVM-based accounts
+     */
+    getSigner(): LocalAccount;
+}
+
+/**
+ * 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.
+ */
+declare class ATXPLocalAccount implements LocalAccount {
+    readonly address: Address;
+    private origin;
+    private token;
+    private fetchFn;
+    readonly type: "local";
+    readonly account: LocalAccount;
+    readonly chain: {
+        id: number;
+    };
+    readonly transport: object;
+    constructor(address: Address, origin: string, token: string, fetchFn?: FetchLike);
+    /**
+     * Fetch the wallet address from the /address endpoint
+     */
+    static create(origin: string, token: string, fetchFn?: FetchLike): Promise<ATXPLocalAccount>;
+    /**
+     * Sign a typed data structure using EIP-712
+     * This is what x402 library will call for EIP-3009 authorization
+     */
+    signTypedData<const TTypedData extends TypedData | {
+        [key: string]: unknown;
+    }>(typedData: TTypedData): Promise<Hex$1>;
+    /**
+     * Sign a message - required by LocalAccount interface but not used for X402
+     */
+    signMessage(_: {
+        message: SignableMessage;
+    }): Promise<Hex$1>;
+    /**
+     * Sign a transaction - required by LocalAccount interface but not used for X402
+     */
+    signTransaction(_transaction: TransactionSerializable, _args?: unknown): Promise<Hex$1>;
+    /**
+     * Get public key - required by LocalAccount interface
+     */
+    readonly publicKey: Hex$1;
+    /**
+     * Source - required by LocalAccount interface (set to 'custom')
+     */
+    readonly source: "custom";
 }
 
-export { ATXPAccount, ATXPFetcher, BaseAccount, BasePaymentMaker, DEFAULT_CLIENT_CONFIG, InsufficientFundsError, OAuthAuthenticationRequiredError, OAuthClient, PaymentNetworkError, SolanaAccount, SolanaPaymentMaker, USDC_CONTRACT_ADDRESS_BASE, ValidateTransferError, atxpClient, atxpFetch, buildClientConfig, buildStreamableTransport };
-export type { ATXPFetcherConfig, Account, AccountIdString, ClientArgs, ClientConfig, Hex, OAuthClientConfig, PaymentMaker, ProspectivePayment };
+export { ATXPAccount, ATXPLocalAccount, BaseAccount, BasePaymentMaker, DEFAULT_CLIENT_CONFIG, InsufficientFundsError, OAuthAuthenticationRequiredError, OAuthClient, PaymentNetworkError, SolanaAccount, SolanaPaymentMaker, USDC_CONTRACT_ADDRESS_BASE, ValidateTransferError, atxpClient, atxpFetch, buildClientConfig, buildStreamableTransport };
+export type { Account, AccountIdString, ClientArgs, ClientConfig, FetchWrapper, Hex, OAuthClientConfig, PaymentMaker, ProspectivePayment };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { crypto as crypto$1, OAuthResourceClient, ConsoleLogger, PAYMENT_REQUIRED_ERROR_CODE, isSSEResponse, parseMcpMessages, parsePaymentRequests, paymentRequiredError, getIsReactNative, createReactNativeSafeFetch, DEFAULT_AUTHORIZATION_SERVER, MemoryOAuthDb, generateJWT } from '@atxp/common';
+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 * as oauth from 'oauth4webapi';
 import { PublicKey, ComputeBudgetProgram, sendAndConfirmTransaction, Connection, Keypair } from '@solana/web3.js';
@@ -297,18 +297,39 @@ class InsufficientFundsError extends Error {
 }
 class PaymentNetworkError extends Error {
     constructor(message, originalError) {
-        super(`Payment failed due to network error: ${message}. Please check your network connection and try again.`);
+        super(`Payment failed due to network error: ${message}`);
         this.originalError = originalError;
         this.name = 'PaymentNetworkError';
     }
 }
 
+/**
+ * Creates an ATXP fetch wrapper that handles OAuth authentication and payments.
+ * This follows the wrapper pattern for fetch functions.
+ *
+ * @param config - The client configuration
+ * @returns A wrapped fetch function that handles ATXP protocol
+ */
 function atxpFetch(config) {
-    const fetcher = new ATXPFetcher(config);
+    const fetcher = new ATXPFetcher({
+        accountId: config.account.accountId,
+        db: config.oAuthDb,
+        paymentMakers: config.account.paymentMakers,
+        fetchFn: config.fetchFn,
+        sideChannelFetch: config.oAuthChannelFetch,
+        allowInsecureRequests: config.allowHttp,
+        allowedAuthorizationServers: config.allowedAuthorizationServers,
+        approvePayment: config.approvePayment,
+        logger: config.logger,
+        onAuthorize: config.onAuthorize,
+        onAuthorizeFailure: config.onAuthorizeFailure,
+        onPayment: config.onPayment,
+        onPaymentFailure: config.onPaymentFailure
+    });
     return fetcher.fetch;
 }
 class ATXPFetcher {
-    constructor({ 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 () => { } }) {
+    constructor(config) {
         this.defaultPaymentFailureHandler = async ({ payment, error }) => {
             if (error instanceof InsufficientFundsError) {
                 this.logger.info(`PAYMENT FAILED: Insufficient ${error.currency} funds on ${payment.network}`);
@@ -325,6 +346,70 @@ class ATXPFetcher {
                 this.logger.info(`PAYMENT FAILED: ${error.message}`);
             }
         };
+        this.handleMultiDestinationPayment = async (paymentRequestData, paymentRequestUrl, paymentRequestId) => {
+            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`);
+                    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;
+                }
+                let paymentId;
+                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}`);
+                    await this.onPayment({ payment: prospectivePayment });
+                    // Submit payment to the server
+                    const jwt = await paymentMaker.generateJWT({ paymentRequestId, codeChallenge: '' });
+                    const response = await this.sideChannelFetch(paymentRequestUrl.toString(), {
+                        method: 'PUT',
+                        headers: {
+                            'Authorization': `Bearer ${jwt}`,
+                            'Content-Type': 'application/json'
+                        },
+                        body: JSON.stringify({
+                            transactionId: paymentId,
+                            network: dest.network,
+                            currency: dest.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;
+                }
+                catch (error) {
+                    const typedError = error;
+                    this.logger.warn(`ATXP: payment failed on ${dest.network}: ${typedError.message}`);
+                    await this.onPaymentFailure({ payment: prospectivePayment, error: typedError });
+                    // Try next destination
+                    continue;
+                }
+            }
+            this.logger.info(`ATXP: no suitable payment destination found among ${paymentRequestData.destinations.length} options`);
+            return false;
+        };
         this.handlePaymentRequestError = async (paymentRequestError) => {
             if (paymentRequestError.code !== PAYMENT_REQUIRED_ERROR_CODE) {
                 throw new Error(`ATXP: expected payment required error (code ${PAYMENT_REQUIRED_ERROR_CODE}); got code ${paymentRequestError.code}`);
@@ -345,6 +430,11 @@ class ATXPFetcher {
             if (!paymentRequestData) {
                 throw new Error(`ATXP: payment request ${paymentRequestId} not found on server ${paymentRequestUrl}`);
             }
+            // Handle multi-destination format
+            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`);
@@ -421,7 +511,8 @@ class ATXPFetcher {
                 },
                 body: JSON.stringify({
                     transactionId: paymentId,
-                    network: requestedNetwork
+                    network: requestedNetwork,
+                    currency: currency
                 })
             });
             this.logger.debug(`ATXP: payment was ${response.ok ? 'successfully' : 'not successfully'} PUT to ${paymentRequestUrl} : status ${response.status} ${response.statusText}`);
@@ -640,6 +731,7 @@ 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;
         // Use React Native safe fetch if in React Native environment
         const safeFetchFn = getIsReactNative() ? createReactNativeSafeFetch(fetchFn) : fetchFn;
         const safeSideChannelFetch = getIsReactNative() ? createReactNativeSafeFetch(sideChannelFetch) : sideChannelFetch;
@@ -15798,22 +15890,9 @@ function buildClientConfig(args) {
 }
 function buildStreamableTransport(args) {
     const config = buildClientConfig(args);
-    const fetcher = new ATXPFetcher({
-        accountId: args.account.accountId,
-        db: config.oAuthDb,
-        paymentMakers: args.account.paymentMakers,
-        fetchFn: config.fetchFn,
-        sideChannelFetch: config.oAuthChannelFetch,
-        allowInsecureRequests: config.allowHttp,
-        allowedAuthorizationServers: config.allowedAuthorizationServers,
-        approvePayment: config.approvePayment,
-        logger: config.logger,
-        onAuthorize: config.onAuthorize,
-        onAuthorizeFailure: config.onAuthorizeFailure,
-        onPayment: config.onPayment,
-        onPaymentFailure: config.onPaymentFailure
-    });
-    const transport = new StreamableHTTPClientTransport(new URL(args.mcpServer), { fetch: fetcher.fetch });
+    // 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) {
@@ -15830,7 +15909,7 @@ const ValidateTransferError = ValidateTransferError$1;
 class SolanaPaymentMaker {
     constructor(solanaEndpoint, sourceSecretKey, logger) {
         this.generateJWT = async ({ paymentRequestId, codeChallenge }) => {
-            // Solana/Web3.js secretKey is 64 bytes: 
+            // 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 = {
@@ -15860,8 +15939,10 @@ class SolanaPaymentMaker {
                     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: 10000,
+                    units: 50000,
                 });
                 const addPriorityFee = ComputeBudgetProgram.setComputeUnitPrice({
                     microLamports: 20000,
@@ -16055,6 +16136,106 @@ class SolanaAccount {
     }
 }
 
+function toBasicAuth$1(token) {
+    // Basic auth is base64("username:password"), password is blank
+    const b64 = Buffer.from(`${token}:`).toString('base64');
+    return `Basic ${b64}`;
+}
+/**
+ * ATXP implementation of viem's LocalAccount interface.
+ * Delegates signing operations to the accounts-x402 API.
+ * Includes properties needed by x402 library for wallet client compatibility.
+ */
+class ATXPLocalAccount {
+    constructor(address, origin, token, fetchFn = fetch) {
+        this.address = address;
+        this.origin = origin;
+        this.token = token;
+        this.fetchFn = fetchFn;
+        this.type = 'local';
+        /**
+         * Get public key - required by LocalAccount interface
+         */
+        this.publicKey = '0x0000000000000000000000000000000000000000000000000000000000000000';
+        /**
+         * Source - required by LocalAccount interface (set to 'custom')
+         */
+        this.source = 'custom';
+        // x402 library expects these properties for wallet client compatibility
+        this.account = this; // Self-reference for x402's isSignerWallet check
+        this.chain = { id: 8453 }; // Base mainnet - could make this configurable
+        this.transport = {}; // Empty transport object for x402 compatibility
+    }
+    /**
+     * Fetch the wallet address from the /address endpoint
+     */
+    static async create(origin, token, fetchFn = fetch) {
+        // The /address endpoint uses Basic auth like other authenticated endpoints
+        // For X402, we need the Ethereum/Base address with USDC currency
+        const url = new URL(`${origin}/address`);
+        url.searchParams.set('network', 'base'); // X402 operates on Base
+        url.searchParams.set('currency', 'USDC'); // Always USDC for X402
+        const response = await fetchFn(url.toString(), {
+            method: 'GET',
+            headers: {
+                'Authorization': toBasicAuth$1(token)
+            }
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Failed to fetch destination address: ${response.status} ${response.statusText} ${errorText}`);
+        }
+        const data = await response.json();
+        const address = data.address;
+        if (!address) {
+            throw new Error('Address endpoint did not return an address');
+        }
+        // Check that the account is an Ethereum/Base account (required for X402/EVM operations)
+        const network = data.network;
+        if (!network) {
+            throw new Error('Address endpoint did not return a network');
+        }
+        if (network !== 'ethereum' && network !== 'base') {
+            throw new Error(`ATXPLocalAccount requires an Ethereum/Base account, but got ${network} account`);
+        }
+        return new ATXPLocalAccount(address, origin, token, fetchFn);
+    }
+    /**
+     * Sign a typed data structure using EIP-712
+     * This is what x402 library will call for EIP-3009 authorization
+     */
+    async signTypedData(typedData) {
+        const response = await this.fetchFn(`${this.origin}/sign-typed-data`, {
+            method: 'POST',
+            headers: {
+                'Authorization': toBasicAuth$1(this.token),
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                typedData
+            })
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Failed to sign typed data: ${response.status} ${response.statusText} ${errorText}`);
+        }
+        const result = await response.json();
+        return result.signature;
+    }
+    /**
+     * Sign a message - required by LocalAccount interface but not used for X402
+     */
+    async signMessage(_) {
+        throw new Error('Message signing not implemented for ATXP local account');
+    }
+    /**
+     * Sign a transaction - required by LocalAccount interface but not used for X402
+     */
+    async signTransaction(_transaction, _args) {
+        throw new Error('Transaction signing not implemented for ATXP local account');
+    }
+}
+
 function toBasicAuth(token) {
     // Basic auth is base64("username:password"), password is blank
     const b64 = Buffer.from(`${token}:`).toString('base64');
@@ -16064,10 +16245,11 @@ 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 };
+    return { origin, token, accountId };
 }
 class ATXPHttpPaymentMaker {
     constructor(origin, token, fetchFn = fetch) {
@@ -16076,19 +16258,19 @@ class ATXPHttpPaymentMaker {
         this.fetchFn = fetchFn;
     }
     async makePayment(amount, currency, receiver, memo) {
-        const body = {
-            amount: amount.toString(),
-            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(body),
+            body: JSON.stringify({
+                amount: amount.toString(),
+                currency,
+                receiver,
+                memo,
+            }),
         });
         if (!response.ok) {
             const text = await response.text();
@@ -16125,15 +16307,26 @@ class ATXPHttpPaymentMaker {
 }
 class ATXPAccount {
     constructor(connectionString, opts) {
-        const { origin, token } = parseConnectionString(connectionString);
+        const { origin, token, accountId } = parseConnectionString(connectionString);
         const fetchFn = opts?.fetchFn ?? fetch;
         const network = opts?.network ?? 'base';
-        // Use token as a stable accountId namespace to keep OAuth/ATXP state per-connection
-        this.accountId = `atxp:${token}`;
+        // 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:${crypto$1.randomUUID()}`;
+        }
         this.paymentMakers = {
             [network]: new ATXPHttpPaymentMaker(origin, token, fetchFn),
         };
     }
+    async getSigner() {
+        return ATXPLocalAccount.create(this.origin, this.token, this.fetchFn);
+    }
 }
 
 class BaseAccount {
@@ -16144,18 +16337,26 @@ class BaseAccount {
         if (!sourceSecretKey) {
             throw new Error('Source secret key is required');
         }
-        const account = privateKeyToAccount(sourceSecretKey);
-        this.accountId = account.address;
-        const walletClient = createWalletClient({
-            account: account,
+        this.account = privateKeyToAccount(sourceSecretKey);
+        this.accountId = this.account.address;
+        this.walletClient = createWalletClient({
+            account: this.account,
             chain: base,
             transport: http(baseRPCUrl),
         });
         this.paymentMakers = {
-            'base': new BasePaymentMaker(baseRPCUrl, walletClient),
+            'base': new BasePaymentMaker(baseRPCUrl, this.walletClient),
         };
     }
+    /**
+     * Get a signer that can be used with the x402 library
+     * This is only available for EVM-based accounts
+     */
+    getSigner() {
+        // Return the viem account directly - it implements LocalAccount interface
+        return this.account;
+    }
 }
 
-export { ATXPAccount, ATXPFetcher, BaseAccount, BasePaymentMaker, DEFAULT_CLIENT_CONFIG, InsufficientFundsError, OAuthAuthenticationRequiredError, OAuthClient, PaymentNetworkError, SolanaAccount, SolanaPaymentMaker, USDC_CONTRACT_ADDRESS_BASE, ValidateTransferError, atxpClient, atxpFetch, buildClientConfig, buildStreamableTransport };
+export { ATXPAccount, ATXPLocalAccount, BaseAccount, BasePaymentMaker, DEFAULT_CLIENT_CONFIG, InsufficientFundsError, OAuthAuthenticationRequiredError, OAuthClient, PaymentNetworkError, SolanaAccount, SolanaPaymentMaker, USDC_CONTRACT_ADDRESS_BASE, ValidateTransferError, atxpClient, atxpFetch, buildClientConfig, buildStreamableTransport };
 //# sourceMappingURL=index.js.map