@atxp/client 0.8.0 → 0.8.2

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { Account, Network, DestinationMaker, AuthorizationServerUrl, AccountId, Currency, OAuthDb, FetchLike, Logger, OAuthResourceClient, ClientCredentials, PKCEValues, AccessToken, PaymentMaker, Destination, PaymentIdentifier, Source, PaymentRequestOption } from '@atxp/common';
-export { Account, PaymentMaker } from '@atxp/common';
+export { ATXPAccount, Account, PaymentMaker } from '@atxp/common';
 import { ClientOptions, Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { Implementation } from '@modelcontextprotocol/sdk/types.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
@@ -175,23 +175,6 @@ declare class SolanaAccount implements Account {
     getSources(): Promise<Source[]>;
 }
 
-declare class ATXPAccount implements Account {
-    accountId: AccountId;
-    paymentMakers: PaymentMaker[];
-    origin: string;
-    token: string;
-    fetchFn: FetchLike;
-    private unqualifiedAccountId;
-    constructor(connectionString: string, opts?: {
-        fetchFn?: FetchLike;
-    });
-    getSigner(): Promise<LocalAccount>;
-    /**
-     * Get sources for this account by calling the accounts service
-     */
-    getSources(): Promise<Source[]>;
-}
-
 declare const USDC_CONTRACT_ADDRESS_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
 declare const USDC_CONTRACT_ADDRESS_BASE_SEPOLIA = "0x036CbD53842c5426634e7929541eC2318f3dCF7e";
 /**
@@ -280,22 +263,29 @@ type PolygonChain = {
     readonly testnet?: boolean;
 };
 declare const USDC_CONTRACT_ADDRESS_POLYGON_MAINNET = "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359";
+declare const USDC_CONTRACT_ADDRESS_POLYGON_AMOY = "0x41E94Eb019C0762f9Bfcf9Fb1E58725BfB0e7582";
 declare const POLYGON_MAINNET: PolygonChain;
+declare const POLYGON_AMOY: PolygonChain;
 /**
  * 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'
  */
 declare const getPolygonMainnetWithRPC: (rpcUrl: string) => PolygonChain;
+/**
+ * Get Polygon Amoy Testnet configuration with custom RPC URL (e.g., with API key)
+ * @param rpcUrl - Custom RPC URL, e.g., 'https://polygon-amoy.g.alchemy.com/v2/YOUR_API_KEY'
+ */
+declare const getPolygonAmoyWithRPC: (rpcUrl: string) => PolygonChain;
 /**
  * Get Polygon Chain configuration by chain ID
- * @param chainId - Chain ID (137 for mainnet)
+ * @param chainId - Chain ID (137 for mainnet, 80002 for Amoy testnet)
  * @returns Polygon Chain configuration
  * @throws Error if chain ID is not supported
  */
 declare const getPolygonByChainId: (chainId: number) => PolygonChain;
 /**
  * Get USDC contract address for Polygon by chain ID
- * @param chainId - Chain ID (137 for mainnet)
+ * @param chainId - Chain ID (137 for mainnet, 80002 for Amoy testnet)
  * @returns USDC contract address
  * @throws Error if chain ID is not supported
  */
@@ -308,10 +298,10 @@ declare class BaseAccount implements Account {
     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
+     * Get the LocalAccount (signer) for this account.
+     * This can be used with the x402 library or other signing operations.
      */
-    getSigner(): LocalAccount;
+    getLocalAccount(): LocalAccount;
     /**
      * Get sources for this account
      */
@@ -385,5 +375,5 @@ declare class PassthroughDestinationMaker implements DestinationMaker {
     makeDestinations(option: PaymentRequestOption, _logger: Logger, _paymentRequestId: string, _sources: Source[]): Promise<Destination[]>;
 }
 
-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 };
+export { ATXPDestinationMaker, ATXPLocalAccount, BaseAccount, BasePaymentMaker, DEFAULT_CLIENT_CONFIG, InsufficientFundsError, OAuthAuthenticationRequiredError, OAuthClient, POLYGON_AMOY, POLYGON_MAINNET, PassthroughDestinationMaker, PaymentNetworkError, SolanaAccount, SolanaPaymentMaker, USDC_CONTRACT_ADDRESS_BASE, USDC_CONTRACT_ADDRESS_BASE_SEPOLIA, USDC_CONTRACT_ADDRESS_POLYGON_AMOY, USDC_CONTRACT_ADDRESS_POLYGON_MAINNET, USDC_CONTRACT_ADDRESS_WORLD_MAINNET, USDC_CONTRACT_ADDRESS_WORLD_SEPOLIA, ValidateTransferError, WORLD_CHAIN_MAINNET, WORLD_CHAIN_SEPOLIA, atxpClient, atxpFetch, buildClientConfig, buildStreamableTransport, getBaseUSDCAddress, getPolygonAmoyWithRPC, getPolygonByChainId, getPolygonMainnetWithRPC, getPolygonUSDCAddress, getWorldChainByChainId, getWorldChainMainnetWithRPC, getWorldChainSepoliaWithRPC, getWorldChainUSDCAddress };
 export type { AccountIdString, ClientArgs, ClientConfig, FetchWrapper, Hex, OAuthClientConfig, PolygonChain, ProspectivePayment, WorldChain };

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,qBAAqB,EACrB,iBAAiB,EACjB,wBAAwB,EACxB,UAAU,EACX,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EACL,gCAAgC,EAChC,KAAK,iBAAiB,EACtB,WAAW,EACZ,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,SAAS,EACV,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EACL,qBAAqB,EACrB,kBAAkB,EACnB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EACL,gBAAgB,EACjB,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EACL,aAAa,EACd,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EACL,WAAW,EACZ,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EACL,0BAA0B,EAC1B,kCAAkC,EAClC,kBAAkB,EACnB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EACL,mCAAmC,EACnC,mCAAmC,EACnC,mBAAmB,EACnB,mBAAmB,EACnB,2BAA2B,EAC3B,2BAA2B,EAC3B,sBAAsB,EACtB,wBAAwB,EACxB,KAAK,UAAU,EAChB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACL,qCAAqC,EACrC,eAAe,EACf,wBAAwB,EACxB,mBAAmB,EACnB,qBAAqB,EACrB,KAAK,YAAY,EAClB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EACL,WAAW,EACZ,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EACL,KAAK,GAAG,EACR,KAAK,eAAe,EACpB,KAAK,OAAO,EACZ,KAAK,kBAAkB,EACvB,KAAK,YAAY,EACjB,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,sBAAsB,EACtB,mBAAmB,EACnB,KAAK,YAAY,EAClB,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,gBAAgB,EACjB,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EACL,oBAAoB,EACpB,2BAA2B,GAC5B,MAAM,8BAA8B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,qBAAqB,EACrB,iBAAiB,EACjB,wBAAwB,EACxB,UAAU,EACX,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EACL,gCAAgC,EAChC,KAAK,iBAAiB,EACtB,WAAW,EACZ,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,SAAS,EACV,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EACL,qBAAqB,EACrB,kBAAkB,EACnB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EACL,gBAAgB,EACjB,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EACL,aAAa,EACd,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EACL,WAAW,EACZ,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,0BAA0B,EAC1B,kCAAkC,EAClC,kBAAkB,EACnB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EACL,mCAAmC,EACnC,mCAAmC,EACnC,mBAAmB,EACnB,mBAAmB,EACnB,2BAA2B,EAC3B,2BAA2B,EAC3B,sBAAsB,EACtB,wBAAwB,EACxB,KAAK,UAAU,EAChB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACL,qCAAqC,EACrC,kCAAkC,EAClC,eAAe,EACf,YAAY,EACZ,wBAAwB,EACxB,qBAAqB,EACrB,mBAAmB,EACnB,qBAAqB,EACrB,KAAK,YAAY,EAClB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EACL,WAAW,EACZ,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EACL,KAAK,GAAG,EACR,KAAK,eAAe,EACpB,KAAK,OAAO,EACZ,KAAK,kBAAkB,EACvB,KAAK,YAAY,EACjB,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,sBAAsB,EACtB,mBAAmB,EACnB,KAAK,YAAY,EAClB,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,gBAAgB,EACjB,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EACL,oBAAoB,EACpB,2BAA2B,GAC5B,MAAM,8BAA8B,CAAC"}

package/dist/index.js

@@ -1,4 +1,5 @@
-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 { crypto as crypto$1, OAuthResourceClient, ConsoleLogger, PAYMENT_REQUIRED_ERROR_CODE, isSSEResponse, parseMcpMessages, parsePaymentRequests, paymentRequiredError, DEFAULT_AUTHORIZATION_SERVER, getIsReactNative, createReactNativeSafeFetch, isEnumValue, ChainEnum, CurrencyEnum, NetworkEnum, assertNever, DEFAULT_ATXP_ACCOUNTS_SERVER, MemoryOAuthDb, ATXPAccount, generateJWT } from '@atxp/common';
+export { ATXPAccount } from '@atxp/common';
 import * as oauth from 'oauth4webapi';
 import BigNumber$1, { BigNumber } from 'bignumber.js';
 import { PublicKey, ComputeBudgetProgram, sendAndConfirmTransaction, Connection, Keypair } from '@solana/web3.js';
@@ -15970,6 +15971,9 @@ function createDestinationMakers(config) {
             case NetworkEnum.WorldSepolia:
                 makers.set(network, new PassthroughDestinationMaker(network));
                 break;
+            case NetworkEnum.PolygonAmoy:
+                makers.set(network, new PassthroughDestinationMaker(network));
+                break;
             case NetworkEnum.ATXP:
                 makers.set(network, new ATXPDestinationMaker(atxpAccountsServer, fetchFn));
                 break;
@@ -15981,263 +15985,6 @@ function createDestinationMakers(config) {
     return makers;
 }
 
-function toBasicAuth$1(token) {
-    // Basic auth is base64("username:password"), password is blank
-    const b64 = Buffer.from(`${token}:`).toString('base64');
-    return `Basic ${b64}`;
-}
-/**
- * ATXP implementation of viem's LocalAccount interface.
- * Delegates signing operations to the accounts-x402 API.
- * Includes properties needed by x402 library for wallet client compatibility.
- */
-class ATXPLocalAccount {
-    constructor(address, origin, token, fetchFn = fetch) {
-        this.address = address;
-        this.origin = origin;
-        this.token = token;
-        this.fetchFn = fetchFn;
-        this.type = 'local';
-        /**
-         * Get public key - required by LocalAccount interface
-         */
-        this.publicKey = '0x0000000000000000000000000000000000000000000000000000000000000000';
-        /**
-         * Source - required by LocalAccount interface (set to 'custom')
-         */
-        this.source = 'custom';
-        // x402 library expects these properties for wallet client compatibility
-        this.account = this; // Self-reference for x402's isSignerWallet check
-        this.chain = { id: 8453 }; // Base mainnet - could make this configurable
-        this.transport = {}; // Empty transport object for x402 compatibility
-    }
-    /**
-     * Fetch the wallet address from the /address endpoint
-     */
-    static async create(origin, token, fetchFn = fetch) {
-        // The /address endpoint uses Basic auth like other authenticated endpoints
-        // For X402, we need the Ethereum/Base address with USDC currency
-        const url = new URL(`${origin}/address`);
-        url.searchParams.set('network', 'base'); // X402 operates on Base
-        url.searchParams.set('currency', 'USDC'); // Always USDC for X402
-        const response = await fetchFn(url.toString(), {
-            method: 'GET',
-            headers: {
-                'Authorization': toBasicAuth$1(token)
-            }
-        });
-        if (!response.ok) {
-            const errorText = await response.text();
-            throw new Error(`Failed to fetch destination address: ${response.status} ${response.statusText} ${errorText}`);
-        }
-        const data = await response.json();
-        const address = data.address;
-        if (!address) {
-            throw new Error('Address endpoint did not return an address');
-        }
-        // Check that the account is an Ethereum/Base account (required for X402/EVM operations)
-        const network = data.network;
-        if (!network) {
-            throw new Error('Address endpoint did not return a network');
-        }
-        if (network !== 'ethereum' && network !== 'base') {
-            throw new Error(`ATXPLocalAccount requires an Ethereum/Base account, but got ${network} account`);
-        }
-        return new ATXPLocalAccount(address, origin, token, fetchFn);
-    }
-    /**
-     * Sign a typed data structure using EIP-712
-     * This is what x402 library will call for EIP-3009 authorization
-     */
-    async signTypedData(typedData) {
-        const response = await this.fetchFn(`${this.origin}/sign-typed-data`, {
-            method: 'POST',
-            headers: {
-                'Authorization': toBasicAuth$1(this.token),
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify({
-                typedData
-            })
-        });
-        if (!response.ok) {
-            const errorText = await response.text();
-            throw new Error(`Failed to sign typed data: ${response.status} ${response.statusText} ${errorText}`);
-        }
-        const result = await response.json();
-        return result.signature;
-    }
-    /**
-     * Sign a message - required by LocalAccount interface but not used for X402
-     */
-    async signMessage(_) {
-        throw new Error('Message signing not implemented for ATXP local account');
-    }
-    /**
-     * Sign a transaction - required by LocalAccount interface but not used for X402
-     */
-    async signTransaction(_transaction, _args) {
-        throw new Error('Transaction signing not implemented for ATXP local account');
-    }
-}
-
-function toBasicAuth(token) {
-    // Basic auth is base64("username:password"), password is blank
-    const b64 = Buffer.from(`${token}:`).toString('base64');
-    return `Basic ${b64}`;
-}
-function parseConnectionString(connectionString) {
-    const url = new URL(connectionString);
-    const origin = url.origin;
-    const token = url.searchParams.get('connection_token') || '';
-    const accountId = url.searchParams.get('account_id');
-    if (!token) {
-        throw new Error('ATXPAccount: connection string missing connection token');
-    }
-    if (!accountId) {
-        throw new Error('ATXPAccount: connection string missing account id');
-    }
-    return { origin, token, accountId };
-}
-class ATXPHttpPaymentMaker {
-    constructor(origin, token, fetchFn = fetch) {
-        this.origin = origin;
-        this.token = token;
-        this.fetchFn = fetchFn;
-    }
-    async getSourceAddress(params) {
-        // Call the /address_for_payment endpoint to get the source address for this account
-        const response = await this.fetchFn(`${this.origin}/address_for_payment`, {
-            method: 'POST',
-            headers: {
-                'Authorization': toBasicAuth(this.token),
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify({
-                amount: params.amount.toString(),
-                currency: params.currency,
-                receiver: params.receiver,
-                memo: params.memo,
-            }),
-        });
-        if (!response.ok) {
-            const text = await response.text();
-            throw new Error(`ATXPAccount: /address_for_payment failed: ${response.status} ${response.statusText} ${text}`);
-        }
-        const json = await response.json();
-        if (!json?.sourceAddress) {
-            throw new Error('ATXPAccount: /address_for_payment did not return sourceAddress');
-        }
-        return json.sourceAddress;
-    }
-    async makePayment(destinations, memo, paymentRequestId) {
-        // Make a payment via the /pay endpoint with multiple destinations
-        const response = await this.fetchFn(`${this.origin}/pay`, {
-            method: 'POST',
-            headers: {
-                'Authorization': toBasicAuth(this.token),
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify({
-                destinations: destinations.map(d => ({
-                    chain: d.chain,
-                    address: d.address,
-                    amount: d.amount.toString(),
-                    currency: d.currency
-                })),
-                memo,
-                ...(paymentRequestId && { paymentRequestId })
-            }),
-        });
-        if (!response.ok) {
-            const text = await response.text();
-            throw new Error(`ATXPAccount: /pay failed: ${response.status} ${response.statusText} ${text}`);
-        }
-        const json = await response.json();
-        const transactionId = json.transactionId;
-        if (!transactionId) {
-            throw new Error('ATXPAccount: /pay did not return transactionId or txHash');
-        }
-        if (!json?.chain) {
-            throw new Error('ATXPAccount: /pay did not return chain');
-        }
-        if (!json?.currency) {
-            throw new Error('ATXPAccount: /pay did not return currency');
-        }
-        return {
-            transactionId,
-            ...(json.transactionSubId ? { transactionSubId: json.transactionSubId } : {}),
-            chain: json.chain,
-            currency: json.currency
-        };
-    }
-    async generateJWT(params) {
-        const response = await this.fetchFn(`${this.origin}/sign`, {
-            method: 'POST',
-            headers: {
-                'Authorization': toBasicAuth(this.token),
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify({
-                paymentRequestId: params.paymentRequestId,
-                codeChallenge: params.codeChallenge,
-                ...(params.accountId ? { accountId: params.accountId } : {}),
-            }),
-        });
-        if (!response.ok) {
-            const text = await response.text();
-            throw new Error(`ATXPAccount: /sign failed: ${response.status} ${response.statusText} ${text}`);
-        }
-        const json = await response.json();
-        if (!json?.jwt) {
-            throw new Error('ATXPAccount: /sign did not return jwt');
-        }
-        return json.jwt;
-    }
-}
-class ATXPAccount {
-    constructor(connectionString, opts) {
-        const { origin, token, accountId } = parseConnectionString(connectionString);
-        const fetchFn = opts?.fetchFn ?? fetch;
-        // Store for use in X402 payment creation
-        this.origin = origin;
-        this.token = token;
-        this.fetchFn = fetchFn;
-        // Format accountId as network:address
-        // Connection string provides just the atxp_acct_xxx part (no prefix for UI)
-        this.unqualifiedAccountId = accountId;
-        this.accountId = `atxp:${accountId}`;
-        this.paymentMakers = [
-            new ATXPHttpPaymentMaker(origin, token, fetchFn)
-        ];
-    }
-    async getSigner() {
-        return ATXPLocalAccount.create(this.origin, this.token, this.fetchFn);
-    }
-    /**
-     * Get sources for this account by calling the accounts service
-     */
-    async getSources() {
-        // Use the unqualified account ID (without atxp: prefix) for the API call
-        const response = await this.fetchFn(`${this.origin}/account/${this.unqualifiedAccountId}/sources`, {
-            method: 'GET',
-            headers: {
-                'Accept': 'application/json',
-            }
-        });
-        if (!response.ok) {
-            const text = await response.text();
-            throw new Error(`ATXPAccount: /account/${this.unqualifiedAccountId}/sources failed: ${response.status} ${response.statusText} ${text}`);
-        }
-        const json = await response.json();
-        // The accounts service returns the sources array directly, not wrapped in an object
-        if (!Array.isArray(json)) {
-            throw new Error(`ATXPAccount: /account/${this.unqualifiedAccountId}/sources did not return sources array`);
-        }
-        return json;
-    }
-}
-
 // Detect if we're in a browser environment and bind fetch appropriately
 const getFetch = () => {
     if (typeof window !== 'undefined' && typeof window.fetch === 'function') {
@@ -16695,11 +16442,13 @@ const getWorldChainUSDCAddress = (chainId) => {
 };
 
 const USDC_CONTRACT_ADDRESS_POLYGON_MAINNET = "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359"; // Native USDC on Polygon mainnet
+const USDC_CONTRACT_ADDRESS_POLYGON_AMOY = "0x41E94Eb019C0762f9Bfcf9Fb1E58725BfB0e7582"; // USDC on Polygon Amoy testnet
 // Polygon Mainnet (Chain ID: 137)
+// Note: Native currency upgraded from MATIC to POL on September 4, 2024
 const POLYGON_MAINNET = {
     id: 137,
     name: 'Polygon',
-    nativeCurrency: { name: 'MATIC', symbol: 'MATIC', decimals: 18 },
+    nativeCurrency: { name: 'POL', symbol: 'POL', decimals: 18 },
     rpcUrls: {
         default: { http: ['https://polygon-rpc.com'] }
     },
@@ -16707,6 +16456,20 @@ const POLYGON_MAINNET = {
         default: { name: 'PolygonScan', url: 'https://polygonscan.com' }
     }
 };
+// Polygon Amoy Testnet (Chain ID: 80002)
+// Note: Amoy testnet also uses POL as native currency (following mainnet upgrade)
+const POLYGON_AMOY = {
+    id: 80002,
+    name: 'Polygon Amoy',
+    nativeCurrency: { name: 'POL', symbol: 'POL', decimals: 18 },
+    rpcUrls: {
+        default: { http: ['https://rpc-amoy.polygon.technology'] }
+    },
+    blockExplorers: {
+        default: { name: 'PolygonScan Amoy', url: 'https://amoy.polygonscan.com' }
+    },
+    testnet: true
+};
 /**
  * Get Polygon Mainnet configuration with custom RPC URL (e.g., with API key)
  * @param rpcUrl - Custom RPC URL, e.g., 'https://polygon-mainnet.g.alchemy.com/v2/YOUR_API_KEY'
@@ -16717,9 +16480,19 @@ const getPolygonMainnetWithRPC = (rpcUrl) => ({
         default: { http: [rpcUrl] }
     }
 });
+/**
+ * Get Polygon Amoy Testnet configuration with custom RPC URL (e.g., with API key)
+ * @param rpcUrl - Custom RPC URL, e.g., 'https://polygon-amoy.g.alchemy.com/v2/YOUR_API_KEY'
+ */
+const getPolygonAmoyWithRPC = (rpcUrl) => ({
+    ...POLYGON_AMOY,
+    rpcUrls: {
+        default: { http: [rpcUrl] }
+    }
+});
 /**
  * Get Polygon Chain configuration by chain ID
- * @param chainId - Chain ID (137 for mainnet)
+ * @param chainId - Chain ID (137 for mainnet, 80002 for Amoy testnet)
  * @returns Polygon Chain configuration
  * @throws Error if chain ID is not supported
  */
@@ -16727,13 +16500,15 @@ const getPolygonByChainId = (chainId) => {
     switch (chainId) {
         case 137:
             return POLYGON_MAINNET;
+        case 80002:
+            return POLYGON_AMOY;
         default:
-            throw new Error(`Unsupported Polygon Chain ID: ${chainId}. Supported chains: 137 (mainnet)`);
+            throw new Error(`Unsupported Polygon Chain ID: ${chainId}. Supported chains: 137 (mainnet), 80002 (Amoy testnet)`);
     }
 };
 /**
  * Get USDC contract address for Polygon by chain ID
- * @param chainId - Chain ID (137 for mainnet)
+ * @param chainId - Chain ID (137 for mainnet, 80002 for Amoy testnet)
  * @returns USDC contract address
  * @throws Error if chain ID is not supported
  */
@@ -16741,8 +16516,10 @@ const getPolygonUSDCAddress = (chainId) => {
     switch (chainId) {
         case 137:
             return USDC_CONTRACT_ADDRESS_POLYGON_MAINNET;
+        case 80002:
+            return USDC_CONTRACT_ADDRESS_POLYGON_AMOY;
         default:
-            throw new Error(`Unsupported Polygon Chain ID: ${chainId}. Supported chains: 137 (mainnet)`);
+            throw new Error(`Unsupported Polygon Chain ID: ${chainId}. Supported chains: 137 (mainnet), 80002 (Amoy testnet)`);
     }
 };
 
@@ -16767,11 +16544,10 @@ class BaseAccount {
         ];
     }
     /**
-     * Get a signer that can be used with the x402 library
-     * This is only available for EVM-based accounts
+     * Get the LocalAccount (signer) for this account.
+     * This can be used with the x402 library or other signing operations.
      */
-    getSigner() {
-        // Return the viem account directly - it implements LocalAccount interface
+    getLocalAccount() {
         return this.account;
     }
     /**
@@ -16786,5 +16562,105 @@ class BaseAccount {
     }
 }
 
-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 };
+function toBasicAuth(token) {
+    // Basic auth is base64("username:password"), password is blank
+    const b64 = Buffer.from(`${token}:`).toString('base64');
+    return `Basic ${b64}`;
+}
+/**
+ * ATXP implementation of viem's LocalAccount interface.
+ * Delegates signing operations to the accounts-x402 API.
+ * Includes properties needed by x402 library for wallet client compatibility.
+ */
+class ATXPLocalAccount {
+    constructor(address, origin, token, fetchFn = fetch) {
+        this.address = address;
+        this.origin = origin;
+        this.token = token;
+        this.fetchFn = fetchFn;
+        this.type = 'local';
+        /**
+         * Get public key - required by LocalAccount interface
+         */
+        this.publicKey = '0x0000000000000000000000000000000000000000000000000000000000000000';
+        /**
+         * Source - required by LocalAccount interface (set to 'custom')
+         */
+        this.source = 'custom';
+        // x402 library expects these properties for wallet client compatibility
+        this.account = this; // Self-reference for x402's isSignerWallet check
+        this.chain = { id: 8453 }; // Base mainnet - could make this configurable
+        this.transport = {}; // Empty transport object for x402 compatibility
+    }
+    /**
+     * Fetch the wallet address from the /address endpoint
+     */
+    static async create(origin, token, fetchFn = fetch) {
+        // The /address endpoint uses Basic auth like other authenticated endpoints
+        // For X402, we need the Ethereum/Base address with USDC currency
+        const url = new URL(`${origin}/address`);
+        url.searchParams.set('network', 'base'); // X402 operates on Base
+        url.searchParams.set('currency', 'USDC'); // Always USDC for X402
+        const response = await fetchFn(url.toString(), {
+            method: 'GET',
+            headers: {
+                'Authorization': toBasicAuth(token)
+            }
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Failed to fetch destination address: ${response.status} ${response.statusText} ${errorText}`);
+        }
+        const data = await response.json();
+        const address = data.address;
+        if (!address) {
+            throw new Error('Address endpoint did not return an address');
+        }
+        // Check that the account is an Ethereum/Base account (required for X402/EVM operations)
+        const network = data.network;
+        if (!network) {
+            throw new Error('Address endpoint did not return a network');
+        }
+        if (network !== 'ethereum' && network !== 'base') {
+            throw new Error(`ATXPLocalAccount requires an Ethereum/Base account, but got ${network} account`);
+        }
+        return new ATXPLocalAccount(address, origin, token, fetchFn);
+    }
+    /**
+     * Sign a typed data structure using EIP-712
+     * This is what x402 library will call for EIP-3009 authorization
+     */
+    async signTypedData(typedData) {
+        const response = await this.fetchFn(`${this.origin}/sign-typed-data`, {
+            method: 'POST',
+            headers: {
+                'Authorization': toBasicAuth(this.token),
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                typedData
+            })
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Failed to sign typed data: ${response.status} ${response.statusText} ${errorText}`);
+        }
+        const result = await response.json();
+        return result.signature;
+    }
+    /**
+     * Sign a message - required by LocalAccount interface but not used for X402
+     */
+    async signMessage(_) {
+        throw new Error('Message signing not implemented for ATXP local account');
+    }
+    /**
+     * Sign a transaction - required by LocalAccount interface but not used for X402
+     */
+    async signTransaction(_transaction, _args) {
+        throw new Error('Transaction signing not implemented for ATXP local account');
+    }
+}
+
+export { ATXPDestinationMaker, ATXPLocalAccount, BaseAccount, BasePaymentMaker, DEFAULT_CLIENT_CONFIG, InsufficientFundsError, OAuthAuthenticationRequiredError, OAuthClient, POLYGON_AMOY, POLYGON_MAINNET, PassthroughDestinationMaker, PaymentNetworkError, SolanaAccount, SolanaPaymentMaker, USDC_CONTRACT_ADDRESS_BASE, USDC_CONTRACT_ADDRESS_BASE_SEPOLIA, USDC_CONTRACT_ADDRESS_POLYGON_AMOY, USDC_CONTRACT_ADDRESS_POLYGON_MAINNET, USDC_CONTRACT_ADDRESS_WORLD_MAINNET, USDC_CONTRACT_ADDRESS_WORLD_SEPOLIA, ValidateTransferError, WORLD_CHAIN_MAINNET, WORLD_CHAIN_SEPOLIA, atxpClient, atxpFetch, buildClientConfig, buildStreamableTransport, getBaseUSDCAddress, getPolygonAmoyWithRPC, getPolygonByChainId, getPolygonMainnetWithRPC, getPolygonUSDCAddress, getWorldChainByChainId, getWorldChainMainnetWithRPC, getWorldChainSepoliaWithRPC, getWorldChainUSDCAddress };
 //# sourceMappingURL=index.js.map