uvd-x402-sdk 2.1.0 → 2.2.0

package/src/chains/index.ts

@@ -8,7 +8,7 @@
  * NEAR (1): Uses NEP-366 meta-transactions
  */
 
-import type { ChainConfig, NetworkType } from '../types';
+import type { ChainConfig, NetworkType, TokenType, TokenConfig } from '../types';
 
 /**
  * Default facilitator URL for x402 payments
@@ -47,6 +47,26 @@ export const SUPPORTED_CHAINS: Record<string, ChainConfig> = {
       name: 'USD Coin',
       version: '2',
     },
+    tokens: {
+      usdc: {
+        address: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
+        decimals: 6,
+        name: 'USD Coin',
+        version: '2',
+      },
+      eurc: {
+        address: '0x60a3E35Cc302bFA44Cb288Bc5a4F316Fdb1adb42',
+        decimals: 6,
+        name: 'EURC',
+        version: '2',
+      },
+      gho: {
+        address: '0x6Bb7a212910682DCFdbd5BCBb3e28FB4E8da10Ee',
+        decimals: 18,
+        name: 'Gho Token',
+        version: '1',
+      },
+    },
     x402: {
       facilitatorUrl: DEFAULT_FACILITATOR_URL,
       enabled: true,
@@ -72,6 +92,26 @@ export const SUPPORTED_CHAINS: Record<string, ChainConfig> = {
       name: 'USD Coin',
       version: '2',
     },
+    tokens: {
+      usdc: {
+        address: '0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E',
+        decimals: 6,
+        name: 'USD Coin',
+        version: '2',
+      },
+      eurc: {
+        address: '0xC891EB4cbdEFf6e073e859e987815Ed1505c2ACD',
+        decimals: 6,
+        name: 'EURC',
+        version: '2',
+      },
+      ausd: {
+        address: '0x00000000eFE302BEAA2b3e6e1b18d08D69a9012a',
+        decimals: 6,
+        name: 'Agora USD',
+        version: '1',
+      },
+    },
     x402: {
       facilitatorUrl: DEFAULT_FACILITATOR_URL,
       enabled: true,
@@ -97,6 +137,44 @@ export const SUPPORTED_CHAINS: Record<string, ChainConfig> = {
       name: 'USD Coin',
       version: '2',
     },
+    tokens: {
+      usdc: {
+        address: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+        decimals: 6,
+        name: 'USD Coin',
+        version: '2',
+      },
+      eurc: {
+        address: '0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c',
+        decimals: 6,
+        name: 'EURC',
+        version: '2',
+      },
+      ausd: {
+        address: '0x00000000eFE302BEAA2b3e6e1b18d08D69a9012a',
+        decimals: 6,
+        name: 'Agora USD',
+        version: '1',
+      },
+      pyusd: {
+        address: '0x6c3ea9036406852006290770BEdFcAbA0e23A0e8',
+        decimals: 6,
+        name: 'PayPal USD',
+        version: '1',
+      },
+      gho: {
+        address: '0x40D16FC0246aD3160Ccc09B8D0D3A2cD28aE6C2f',
+        decimals: 18,
+        name: 'Gho Token',
+        version: '1',
+      },
+      crvusd: {
+        address: '0xf939E0A03FB07F59A73314E73794Be0E57ac1b4E',
+        decimals: 18,
+        name: 'Curve.Fi USD Stablecoin',
+        version: '1',
+      },
+    },
     x402: {
       facilitatorUrl: DEFAULT_FACILITATOR_URL,
       enabled: true,
@@ -122,6 +200,20 @@ export const SUPPORTED_CHAINS: Record<string, ChainConfig> = {
       name: 'USD Coin',
       version: '2',
     },
+    tokens: {
+      usdc: {
+        address: '0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359',
+        decimals: 6,
+        name: 'USD Coin',
+        version: '2',
+      },
+      ausd: {
+        address: '0x00000000eFE302BEAA2b3e6e1b18d08D69a9012a',
+        decimals: 6,
+        name: 'Agora USD',
+        version: '1',
+      },
+    },
     x402: {
       facilitatorUrl: DEFAULT_FACILITATOR_URL,
       enabled: true,
@@ -147,6 +239,32 @@ export const SUPPORTED_CHAINS: Record<string, ChainConfig> = {
       name: 'USD Coin',
       version: '2',
     },
+    tokens: {
+      usdc: {
+        address: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
+        decimals: 6,
+        name: 'USD Coin',
+        version: '2',
+      },
+      ausd: {
+        address: '0x00000000eFE302BEAA2b3e6e1b18d08D69a9012a',
+        decimals: 6,
+        name: 'Agora USD',
+        version: '1',
+      },
+      gho: {
+        address: '0x7dfF72693f6A4149b17e7C6314655f6A9F7c8B33',
+        decimals: 18,
+        name: 'Gho Token',
+        version: '1',
+      },
+      crvusd: {
+        address: '0x498Bf2B1e120FeD3ad3D42EA2165E9b73f99C1e5',
+        decimals: 18,
+        name: 'Curve.Fi USD Stablecoin',
+        version: '1',
+      },
+    },
     x402: {
       facilitatorUrl: DEFAULT_FACILITATOR_URL,
       enabled: true,
@@ -172,6 +290,14 @@ export const SUPPORTED_CHAINS: Record<string, ChainConfig> = {
       name: 'USD Coin',
       version: '2',
     },
+    tokens: {
+      usdc: {
+        address: '0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85',
+        decimals: 6,
+        name: 'USD Coin',
+        version: '2',
+      },
+    },
     x402: {
       facilitatorUrl: DEFAULT_FACILITATOR_URL,
       enabled: true,
@@ -197,6 +323,14 @@ export const SUPPORTED_CHAINS: Record<string, ChainConfig> = {
       name: 'USDC',  // Celo uses "USDC" not "USD Coin" for EIP-712
       version: '2',
     },
+    tokens: {
+      usdc: {
+        address: '0xcebA9300f2b948710d2653dD7B07f33A8B32118C',
+        decimals: 6,
+        name: 'USDC',  // Celo uses "USDC" not "USD Coin" for EIP-712
+        version: '2',
+      },
+    },
     x402: {
       facilitatorUrl: DEFAULT_FACILITATOR_URL,
       enabled: true,
@@ -222,6 +356,14 @@ export const SUPPORTED_CHAINS: Record<string, ChainConfig> = {
       name: 'USDC',  // HyperEVM uses "USDC" not "USD Coin"
       version: '2',
     },
+    tokens: {
+      usdc: {
+        address: '0xb88339CB7199b77E23DB6E890353E22632Ba630f',
+        decimals: 6,
+        name: 'USDC',  // HyperEVM uses "USDC" not "USD Coin"
+        version: '2',
+      },
+    },
     x402: {
       facilitatorUrl: DEFAULT_FACILITATOR_URL,
       enabled: true,
@@ -247,6 +389,14 @@ export const SUPPORTED_CHAINS: Record<string, ChainConfig> = {
       name: 'USDC',  // Unichain uses "USDC" not "USD Coin"
       version: '2',
     },
+    tokens: {
+      usdc: {
+        address: '0x078d782b760474a361dda0af3839290b0ef57ad6',
+        decimals: 6,
+        name: 'USDC',  // Unichain uses "USDC" not "USD Coin"
+        version: '2',
+      },
+    },
     x402: {
       facilitatorUrl: DEFAULT_FACILITATOR_URL,
       enabled: true,
@@ -272,6 +422,20 @@ export const SUPPORTED_CHAINS: Record<string, ChainConfig> = {
       name: 'USDC',  // Monad uses "USDC" not "USD Coin"
       version: '2',
     },
+    tokens: {
+      usdc: {
+        address: '0x754704bc059f8c67012fed69bc8a327a5aafb603',
+        decimals: 6,
+        name: 'USDC',  // Monad uses "USDC" not "USD Coin"
+        version: '2',
+      },
+      ausd: {
+        address: '0x00000000eFE302BEAA2b3e6e1b18d08D69a9012a',
+        decimals: 6,
+        name: 'Agora USD',
+        version: '1',
+      },
+    },
     x402: {
       facilitatorUrl: DEFAULT_FACILITATOR_URL,
       enabled: true,
@@ -511,3 +675,93 @@ export function getExplorerAddressUrl(chainName: string, address: string): strin
       return null;
   }
 }
+
+// ============================================================================
+// MULTI-TOKEN SUPPORT FUNCTIONS
+// ============================================================================
+
+/**
+ * Get token configuration for a specific chain and token type
+ * Falls back to USDC config if token not found (for backward compatibility)
+ *
+ * @param chainName - Chain name (e.g., 'ethereum', 'base')
+ * @param tokenType - Token type (e.g., 'usdc', 'eurc', 'gho')
+ * @returns Token configuration or undefined if chain not found
+ */
+export function getTokenConfig(
+  chainName: string,
+  tokenType: TokenType = 'usdc'
+): TokenConfig | undefined {
+  const chain = getChainByName(chainName);
+  if (!chain) return undefined;
+
+  // Try to get from tokens map first (new multi-token support)
+  if (chain.tokens && chain.tokens[tokenType]) {
+    return chain.tokens[tokenType];
+  }
+
+  // Fall back to usdc config for backward compatibility
+  if (tokenType === 'usdc') {
+    return chain.usdc;
+  }
+
+  return undefined;
+}
+
+/**
+ * Get list of supported tokens for a chain
+ *
+ * @param chainName - Chain name (e.g., 'ethereum', 'base')
+ * @returns Array of supported token types, or empty array if chain not found
+ */
+export function getSupportedTokens(chainName: string): TokenType[] {
+  const chain = getChainByName(chainName);
+  if (!chain) return [];
+
+  // If tokens map exists, return its keys
+  if (chain.tokens) {
+    return Object.keys(chain.tokens) as TokenType[];
+  }
+
+  // Default to just USDC for chains without explicit tokens map
+  return ['usdc'];
+}
+
+/**
+ * Check if a token is supported on a specific chain
+ *
+ * @param chainName - Chain name (e.g., 'ethereum', 'base')
+ * @param tokenType - Token type (e.g., 'usdc', 'eurc', 'gho')
+ * @returns true if token is supported on the chain
+ */
+export function isTokenSupported(chainName: string, tokenType: TokenType): boolean {
+  const chain = getChainByName(chainName);
+  if (!chain) return false;
+
+  // Check tokens map
+  if (chain.tokens && chain.tokens[tokenType]) {
+    return true;
+  }
+
+  // USDC is always supported (backward compatibility)
+  if (tokenType === 'usdc') {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Get all chains that support a specific token
+ *
+ * @param tokenType - Token type (e.g., 'usdc', 'eurc', 'gho')
+ * @returns Array of chain configs that support the token
+ */
+export function getChainsByToken(tokenType: TokenType): ChainConfig[] {
+  return Object.values(SUPPORTED_CHAINS).filter(chain => {
+    if (!chain.x402.enabled) return false;
+    if (chain.tokens && chain.tokens[tokenType]) return true;
+    if (tokenType === 'usdc') return true; // USDC is universal
+    return false;
+  });
+}

package/src/index.ts

@@ -95,6 +95,11 @@ export {
   getNetworkType,
   getExplorerTxUrl,
   getExplorerAddressUrl,
+  // Multi-token support functions
+  getTokenConfig,
+  getSupportedTokens,
+  isTokenSupported,
+  getChainsByToken,
 } from './chains';
 
 // x402 utilities
@@ -121,6 +126,10 @@ export type {
   NativeCurrency,
   NetworkType,
 
+  // Token types (multi-token support)
+  TokenType,
+  TokenConfig,
+
   // Wallet types
   WalletState,
   WalletAdapter,

package/src/providers/evm/index.ts

@@ -27,9 +27,11 @@ import type {
   PaymentInfo,
   EVMPaymentPayload,
   WalletAdapter,
+  TokenType,
+  TokenConfig,
 } from '../../types';
 import { X402Error } from '../../types';
-import { getChainByName, getChainById } from '../../chains';
+import { getChainByName, getChainById, getTokenConfig } from '../../chains';
 
 /**
  * Ethereum provider interface
@@ -197,22 +199,48 @@ export class EVMProvider implements WalletAdapter {
   }
 
   /**
-   * Get USDC balance
+   * Get token balance (defaults to USDC for backward compatibility)
+   *
+   * @param chainConfig - Chain configuration
+   * @param tokenType - Token type to check balance for (defaults to 'usdc')
+   * @returns Formatted balance string
    */
-  async getBalance(chainConfig: ChainConfig): Promise<string> {
+  async getBalance(chainConfig: ChainConfig, tokenType: TokenType = 'usdc'): Promise<string> {
     if (!this.address) {
       throw new X402Error('Wallet not connected', 'WALLET_NOT_CONNECTED');
     }
 
+    // Get token config for the specified token type
+    const tokenConfig = getTokenConfig(chainConfig.name, tokenType);
+    if (!tokenConfig) {
+      // Fall back to USDC config for backward compatibility
+      const fallbackConfig = chainConfig.usdc;
+      if (!fallbackConfig) {
+        throw new X402Error(`Token ${tokenType} not supported on ${chainConfig.name}`, 'INVALID_CONFIG');
+      }
+      return this.getBalanceWithConfig(chainConfig.rpcUrl, fallbackConfig);
+    }
+
+    return this.getBalanceWithConfig(chainConfig.rpcUrl, tokenConfig);
+  }
+
+  /**
+   * Internal helper to get balance using a token config
+   */
+  private async getBalanceWithConfig(rpcUrl: string, tokenConfig: TokenConfig): Promise<string> {
+    if (!this.address) {
+      return '0.00';
+    }
+
     // Use public RPC for balance check
-    const publicProvider = new ethers.JsonRpcProvider(chainConfig.rpcUrl);
+    const publicProvider = new ethers.JsonRpcProvider(rpcUrl);
 
-    const usdcAbi = ['function balanceOf(address owner) view returns (uint256)'];
-    const usdcContract = new ethers.Contract(chainConfig.usdc.address, usdcAbi, publicProvider);
+    const tokenAbi = ['function balanceOf(address owner) view returns (uint256)'];
+    const tokenContract = new ethers.Contract(tokenConfig.address, tokenAbi, publicProvider);
 
     try {
-      const balance = await usdcContract.balanceOf(this.address);
-      const formatted = ethers.formatUnits(balance, chainConfig.usdc.decimals);
+      const balance = await tokenContract.balanceOf(this.address);
+      const formatted = ethers.formatUnits(balance, tokenConfig.decimals);
       return parseFloat(formatted).toFixed(2);
     } catch {
       return '0.00';
@@ -221,12 +249,32 @@ export class EVMProvider implements WalletAdapter {
 
   /**
    * Create EVM payment (EIP-712 TransferWithAuthorization)
+   *
+   * Supports multi-token payments. If paymentInfo.tokenType is specified,
+   * it will use the appropriate token configuration. Defaults to USDC
+   * for backward compatibility.
+   *
+   * @param paymentInfo - Payment details including amount and recipient
+   * @param chainConfig - Chain configuration
+   * @returns JSON-encoded payment payload
    */
   async signPayment(paymentInfo: PaymentInfo, chainConfig: ChainConfig): Promise<string> {
     if (!this.signer || !this.address) {
       throw new X402Error('Wallet not connected', 'WALLET_NOT_CONNECTED');
     }
 
+    // Determine token type (default to 'usdc' for backward compatibility)
+    const tokenType: TokenType = paymentInfo.tokenType || 'usdc';
+
+    // Get token configuration for the specified token type
+    const tokenConfig = getTokenConfig(chainConfig.name, tokenType);
+    if (!tokenConfig) {
+      throw new X402Error(
+        `Token ${tokenType} not supported on ${chainConfig.name}`,
+        'CHAIN_NOT_SUPPORTED'
+      );
+    }
+
     // Get recipient
     const recipient = paymentInfo.recipients?.evm || paymentInfo.recipient;
 
@@ -246,12 +294,12 @@ export class EVMProvider implements WalletAdapter {
     const validityWindowSeconds = chainConfig.name === 'base' ? 300 : 60;
     const validBefore = Math.floor(Date.now() / 1000) + validityWindowSeconds;
 
-    // EIP-712 domain
+    // EIP-712 domain using the selected token's configuration
     const domain = {
-      name: chainConfig.usdc.name,
-      version: chainConfig.usdc.version,
+      name: tokenConfig.name,
+      version: tokenConfig.version,
       chainId: chainConfig.chainId,
-      verifyingContract: chainConfig.usdc.address,
+      verifyingContract: tokenConfig.address,
     };
 
     // EIP-712 types for TransferWithAuthorization (ERC-3009)
@@ -266,8 +314,8 @@ export class EVMProvider implements WalletAdapter {
       ],
     };
 
-    // Parse amount
-    const value = ethers.parseUnits(paymentInfo.amount, chainConfig.usdc.decimals);
+    // Parse amount using the token's decimals
+    const value = ethers.parseUnits(paymentInfo.amount, tokenConfig.decimals);
     const from = this.address;
     const to = ethers.getAddress(recipient);
 
@@ -298,7 +346,7 @@ export class EVMProvider implements WalletAdapter {
 
     const sig = ethers.Signature.from(signature);
 
-    // Construct payload
+    // Construct payload with the selected token address
     const payload: EVMPaymentPayload = {
       from,
       to,
@@ -310,7 +358,7 @@ export class EVMProvider implements WalletAdapter {
       r: sig.r,
       s: sig.s,
       chainId: chainConfig.chainId,
-      token: chainConfig.usdc.address,
+      token: tokenConfig.address,
     };
 
     return JSON.stringify(payload);

package/src/types/index.ts

@@ -20,8 +20,34 @@
  */
 export type NetworkType = 'evm' | 'svm' | 'solana' | 'stellar' | 'near';
 
+/**
+ * Supported stablecoin token types
+ * - usdc: USD Coin (Circle) - 6 decimals
+ * - eurc: Euro Coin (Circle) - 6 decimals
+ * - ausd: Agora USD (Agora Finance) - 6 decimals
+ * - pyusd: PayPal USD (PayPal/Paxos) - 6 decimals
+ * - gho: GHO Stablecoin (Aave) - 18 decimals
+ * - crvusd: Curve USD (Curve Finance) - 18 decimals
+ */
+export type TokenType = 'usdc' | 'eurc' | 'ausd' | 'pyusd' | 'gho' | 'crvusd';
+
+/**
+ * Token configuration for EIP-712 signing and transfers
+ */
+export interface TokenConfig {
+  /** Contract/mint address */
+  address: string;
+  /** Token decimals (6 for most stablecoins, 18 for GHO/crvUSD) */
+  decimals: number;
+  /** Token name for EIP-712 domain (e.g., "USD Coin" or "USDC") */
+  name: string;
+  /** Token version for EIP-712 domain */
+  version: string;
+}
+
 /**
  * USDC token configuration for a specific chain
+ * @deprecated Use TokenConfig instead. This is kept for backward compatibility.
  */
 export interface USDCConfig {
   /** Contract/mint address */
@@ -65,6 +91,12 @@ export interface ChainConfig {
   nativeCurrency: NativeCurrency;
   /** USDC token configuration */
   usdc: USDCConfig;
+  /**
+   * Multi-token configurations (EVM chains only)
+   * Maps token type to its configuration for this chain.
+   * Not all tokens are available on all chains.
+   */
+  tokens?: Partial<Record<TokenType, TokenConfig>>;
   /** x402 facilitator configuration */
   x402: {
     facilitatorUrl: string;
@@ -117,11 +149,17 @@ export interface WalletAdapter {
   /** Switch to a different chain (EVM only) */
   switchChain?(chainName: string): Promise<void>;
 
-  /** Sign a payment payload */
+  /**
+   * Sign a payment payload
+   * For EVM chains, supports multi-token via paymentInfo.tokenType
+   */
   signPayment(paymentInfo: PaymentInfo, chainConfig: ChainConfig): Promise<string>;
 
-  /** Check USDC balance */
-  getBalance(chainConfig: ChainConfig): Promise<string>;
+  /**
+   * Check token balance (defaults to USDC for backward compatibility)
+   * EVM providers may accept optional tokenType parameter
+   */
+  getBalance(chainConfig: ChainConfig, tokenType?: TokenType): Promise<string>;
 
   /** Get current address */
   getAddress(): string | null;
@@ -170,6 +208,11 @@ export interface PaymentInfo {
   amount: string;
   /** Token symbol (usually "USDC") */
   token?: string;
+  /**
+   * Token type for multi-token support
+   * Defaults to 'usdc' if not specified for backward compatibility
+   */
+  tokenType?: TokenType;
   /** Network hint from backend */
   network?: string;
   /** Supported chain IDs */