uvd-x402-sdk 2.0.3 → 2.2.0

package/src/adapters/wagmi.ts

@@ -0,0 +1,294 @@
+/**
+ * uvd-x402-sdk - Wagmi/Viem Adapter
+ *
+ * Provides integration with wagmi/viem for projects using RainbowKit,
+ * ConnectKit, or other wagmi-based wallet connection libraries.
+ *
+ * @example
+ * ```tsx
+ * import { useWalletClient } from 'wagmi';
+ * import { createPaymentFromWalletClient } from 'uvd-x402-sdk/wagmi';
+ *
+ * function PayButton() {
+ *   const { data: walletClient } = useWalletClient();
+ *
+ *   const handlePay = async () => {
+ *     const paymentHeader = await createPaymentFromWalletClient(walletClient, {
+ *       recipient: '0x...',
+ *       amount: '1.00',
+ *       chainName: 'base',
+ *     });
+ *
+ *     // Use in your API request
+ *     await fetch('/api/paid-endpoint', {
+ *       headers: { 'X-PAYMENT': paymentHeader }
+ *     });
+ *   };
+ *
+ *   return <button onClick={handlePay}>Pay $1.00</button>;
+ * }
+ * ```
+ */
+
+import { getChainByName } from '../chains';
+import { createX402V1Header, encodeX402Header } from '../utils';
+import { X402Error } from '../types';
+import type { PaymentResult } from '../types';
+
+/**
+ * Viem WalletClient interface (minimal type to avoid viem dependency)
+ */
+export interface WalletClient {
+  account: {
+    address: `0x${string}`;
+  };
+  signTypedData: (args: {
+    domain: {
+      name: string;
+      version: string;
+      chainId: number;
+      verifyingContract: `0x${string}`;
+    };
+    types: Record<string, Array<{ name: string; type: string }>>;
+    primaryType: string;
+    message: Record<string, unknown>;
+  }) => Promise<`0x${string}`>;
+}
+
+/**
+ * Payment options for wagmi adapter
+ */
+export interface WagmiPaymentOptions {
+  /** Recipient address */
+  recipient: string;
+  /** Amount in USDC (e.g., "1.00", "10.50") */
+  amount: string;
+  /** Chain name (default: 'base') */
+  chainName?: string;
+  /** Validity window in seconds (default: 300 = 5 minutes) */
+  validitySeconds?: number;
+}
+
+/**
+ * Generate a random 32-byte nonce as hex string
+ */
+function generateNonce(): `0x${string}` {
+  const bytes = new Uint8Array(32);
+  if (typeof globalThis !== 'undefined' && globalThis.crypto?.getRandomValues) {
+    globalThis.crypto.getRandomValues(bytes);
+  } else if (typeof window !== 'undefined' && window.crypto?.getRandomValues) {
+    window.crypto.getRandomValues(bytes);
+  } else {
+    // Fallback for non-browser environments
+    for (let i = 0; i < 32; i++) {
+      bytes[i] = Math.floor(Math.random() * 256);
+    }
+  }
+  return ('0x' + Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('')) as `0x${string}`;
+}
+
+/**
+ * Parse amount string to atomic units (BigInt)
+ */
+function parseUnits(amount: string, decimals: number): bigint {
+  const [integer, fraction = ''] = amount.split('.');
+  const paddedFraction = fraction.padEnd(decimals, '0').slice(0, decimals);
+  return BigInt(integer + paddedFraction);
+}
+
+/**
+ * Create an x402 payment header using a wagmi/viem WalletClient
+ *
+ * This function allows you to use the x402 SDK with wagmi-based wallet
+ * connections (RainbowKit, ConnectKit, etc.) instead of the built-in
+ * wallet connection.
+ *
+ * @param walletClient - The WalletClient from wagmi's useWalletClient hook
+ * @param options - Payment options (recipient, amount, chainName)
+ * @returns Base64-encoded payment header ready for X-PAYMENT HTTP header
+ *
+ * @example
+ * ```tsx
+ * import { useWalletClient } from 'wagmi';
+ * import { createPaymentFromWalletClient } from 'uvd-x402-sdk/wagmi';
+ *
+ * const { data: walletClient } = useWalletClient();
+ *
+ * const paymentHeader = await createPaymentFromWalletClient(walletClient, {
+ *   recipient: '0xRecipientAddress',
+ *   amount: '5.00',
+ *   chainName: 'base',
+ * });
+ * ```
+ */
+export async function createPaymentFromWalletClient(
+  walletClient: WalletClient | undefined | null,
+  options: WagmiPaymentOptions
+): Promise<string> {
+  if (!walletClient) {
+    throw new X402Error('WalletClient is not available. Make sure wallet is connected.', 'WALLET_NOT_CONNECTED');
+  }
+
+  const {
+    recipient,
+    amount,
+    chainName = 'base',
+    validitySeconds = 300,
+  } = options;
+
+  // Get chain configuration
+  const chain = getChainByName(chainName);
+  if (!chain) {
+    throw new X402Error(`Unsupported chain: ${chainName}`, 'CHAIN_NOT_SUPPORTED');
+  }
+
+  if (chain.networkType !== 'evm') {
+    throw new X402Error(
+      `wagmi adapter only supports EVM chains. For ${chain.networkType}, use the appropriate provider.`,
+      'CHAIN_NOT_SUPPORTED'
+    );
+  }
+
+  const from = walletClient.account.address;
+  const to = recipient as `0x${string}`;
+  const nonce = generateNonce();
+  const validAfter = 0;
+  const validBefore = Math.floor(Date.now() / 1000) + validitySeconds;
+  const value = parseUnits(amount, chain.usdc.decimals);
+
+  // EIP-712 domain
+  const domain = {
+    name: chain.usdc.name,
+    version: chain.usdc.version,
+    chainId: chain.chainId,
+    verifyingContract: chain.usdc.address as `0x${string}`,
+  };
+
+  // EIP-712 types for TransferWithAuthorization (ERC-3009)
+  const types = {
+    TransferWithAuthorization: [
+      { name: 'from', type: 'address' },
+      { name: 'to', type: 'address' },
+      { name: 'value', type: 'uint256' },
+      { name: 'validAfter', type: 'uint256' },
+      { name: 'validBefore', type: 'uint256' },
+      { name: 'nonce', type: 'bytes32' },
+    ],
+  };
+
+  // Message to sign
+  const message = {
+    from,
+    to,
+    value,
+    validAfter: BigInt(validAfter),
+    validBefore: BigInt(validBefore),
+    nonce,
+  };
+
+  // Sign with viem
+  let signature: `0x${string}`;
+  try {
+    signature = await walletClient.signTypedData({
+      domain,
+      types,
+      primaryType: 'TransferWithAuthorization',
+      message,
+    });
+  } catch (error: unknown) {
+    if (error instanceof Error) {
+      if (error.message.includes('User rejected') || error.message.includes('denied')) {
+        throw new X402Error('Signature rejected by user', 'SIGNATURE_REJECTED');
+      }
+    }
+    throw new X402Error(
+      `Failed to sign payment: ${error instanceof Error ? error.message : 'Unknown error'}`,
+      'PAYMENT_FAILED',
+      error
+    );
+  }
+
+  // Create x402 header with correct format
+  // IMPORTANT: validAfter, validBefore, and value must be STRINGS
+  const header = createX402V1Header(chainName, {
+    signature,
+    authorization: {
+      from,
+      to: recipient,
+      value: value.toString(),
+      validAfter: validAfter.toString(),
+      validBefore: validBefore.toString(),
+      nonce,
+    },
+  });
+
+  return encodeX402Header(header);
+}
+
+/**
+ * Create payment with full result object (includes metadata)
+ *
+ * Same as createPaymentFromWalletClient but returns a PaymentResult
+ * object with additional metadata.
+ *
+ * @param walletClient - The WalletClient from wagmi
+ * @param options - Payment options
+ * @returns PaymentResult with paymentHeader and metadata
+ */
+export async function createPaymentWithResult(
+  walletClient: WalletClient | undefined | null,
+  options: WagmiPaymentOptions
+): Promise<PaymentResult> {
+  const paymentHeader = await createPaymentFromWalletClient(walletClient, options);
+
+  return {
+    success: true,
+    paymentHeader,
+    network: options.chainName || 'base',
+    payer: walletClient?.account.address,
+  };
+}
+
+/**
+ * React hook helper for wagmi integration
+ *
+ * Returns a function that creates payments using the connected wallet.
+ * This is a simple wrapper - for more control, use createPaymentFromWalletClient directly.
+ *
+ * @example
+ * ```tsx
+ * import { useWalletClient } from 'wagmi';
+ * import { useX402Wagmi } from 'uvd-x402-sdk/wagmi';
+ *
+ * function PayButton() {
+ *   const { data: walletClient } = useWalletClient();
+ *   const { createPayment, isReady } = useX402Wagmi(walletClient);
+ *
+ *   return (
+ *     <button
+ *       disabled={!isReady}
+ *       onClick={() => createPayment({ recipient: '0x...', amount: '1.00' })}
+ *     >
+ *       Pay
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export function useX402Wagmi(walletClient: WalletClient | undefined | null) {
+  const isReady = !!walletClient;
+
+  const createPayment = async (options: WagmiPaymentOptions): Promise<string> => {
+    return createPaymentFromWalletClient(walletClient, options);
+  };
+
+  const createPaymentFull = async (options: WagmiPaymentOptions): Promise<PaymentResult> => {
+    return createPaymentWithResult(walletClient, options);
+  };
+
+  return {
+    isReady,
+    createPayment,
+    createPaymentFull,
+  };
+}

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,