add anago support

kevinfaveri · kevinfaveri · commit dfa42d3a4c33 · 2025-11-26T13:29:25.000+09:00
diff --git a/packages/backend/src/config/chains.ts b/packages/backend/src/config/chains.ts
@@ -29,7 +29,9 @@ export const CHAINS = {
     rpcUrl: process.env.BASE_RPC_URL?.replace('/base', '/monad') || 'https://rpc.monad.xyz',
     usdcAddress: '0x754704Bc059F8C67012fEd69BC8A327a5aafb603', // USDC on Monad
     wmonAddress: '0x3bd359C1119dA7Da1D913D1C4D2B7c461115433A', // WMON on Monad
+    anagoAddress: '0x99ae2dc76c43979e3bcc0ae8d69f1fca077c8888', // ANAGO on Monad
     universalRouterAddress: '0x0D97Dc33264bfC1c226207428A79b26757fb9dc3', // Uniswap Universal Router on Monad
+    quoterV2Address: '0x661E93cca42AfacB172121EF892830cA3b70F08d', // Uniswap QuoterV2 on Monad
     permit2Address: '0x000000000022D473030F116dDEE9F6B43aC78BA3', // Permit2 (same on all chains)
     cctpMessageTransmitter: '0x81D40F21F12A8F0E3252Bccb954D722d4c464B64', // CCTP v2 MessageTransmitter on Monad
     chainId: 143,
diff --git a/packages/backend/src/config/uniswap-abis.ts b/packages/backend/src/config/uniswap-abis.ts
@@ -71,3 +71,25 @@ export enum UniversalRouterCommand {
   UNWRAP_WETH = 0x0c,
   PERMIT2_TRANSFER_FROM_BATCH = 0x0d,
 }
+
+// Uniswap V3 QuoterV2 ABI for quoting swaps
+export const QUOTER_V2_ABI = [
+  {
+    inputs: [
+      { name: 'path', type: 'bytes' },
+      { name: 'amountIn', type: 'uint256' },
+    ],
+    name: 'quoteExactInput',
+    outputs: [
+      { name: 'amountOut', type: 'uint256' },
+      { name: 'sqrtPriceX96AfterList', type: 'uint160[]' },
+      { name: 'initializedTicksCrossedList', type: 'uint32[]' },
+      { name: 'gasEstimate', type: 'uint256' },
+    ],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+] as const;
+
+// Common fee tiers to try (in order of preference)
+export const FEE_TIERS = [500, 3000, 10000, 100] as const; // 0.05%, 0.3%, 1%, 0.01%
diff --git a/packages/backend/src/services/claim-queue-processor.ts b/packages/backend/src/services/claim-queue-processor.ts
@@ -259,14 +259,20 @@ export class ClaimQueueProcessor {
         throw new Error(`Unsupported destination chain: ${destChain}. Supported: ${Object.keys(KNOWN_CCTP_CONTRACTS).join(', ')}`);
       }
 
-      // Determine if we need to swap to native token (supported on Base and Monad)
+      // Determine if we need to swap (supported on Base and Monad)
+      // - Native tokens: MON, ETH
+      // - ERC20 tokens: ANAGO
       const isNativeTokenSwap = transaction.selectedDestinationToken &&
         (transaction.selectedDestinationToken === 'ETH' ||
          transaction.selectedDestinationToken === 'ETH_BASE' ||
          transaction.selectedDestinationToken === 'MON' ||
          transaction.selectedDestinationToken === 'MON_MON');
 
-      const shouldSwapToNative = isNativeTokenSwap &&
+      const isTokenSwap = transaction.selectedDestinationToken &&
+        (transaction.selectedDestinationToken === 'ANAGO' ||
+         transaction.selectedDestinationToken === 'ANAGO_MON');
+
+      const shouldSwapToNative = (isNativeTokenSwap || isTokenSwap) &&
         (destChain === 'base' || destChain === 'monad');
 
       // Update status to processing claim
diff --git a/packages/backend/src/services/swap-queue-processor.ts b/packages/backend/src/services/swap-queue-processor.ts
@@ -265,6 +265,7 @@ export class SwapQueueProcessor {
         userDestination,
         estimatedUsdcAmount,
         chain: destChain,
+        targetToken: transaction.selectedDestinationToken || undefined,
       });
 
       const swapTxHash = result.txHash;
diff --git a/packages/backend/src/services/transaction-signer.ts b/packages/backend/src/services/transaction-signer.ts
@@ -2,8 +2,8 @@ import { createWalletClient, createPublicClient, defineChain, http, type Hex, ty
 import { base } from 'viem/chains';
 import { privateKeyToAccount } from 'viem/accounts';
 import { CHAINS } from '../config/chains';
-import { buildUsdcToNativeSwapCommands } from './uniswap-swap';
-import { ERC20_ABI } from '../config/uniswap-abis';
+import { buildUsdcToNativeSwapCommands, buildUsdcToAnagoSwapCommands, buildMultiHopPath } from './uniswap-swap';
+import { ERC20_ABI, QUOTER_V2_ABI, FEE_TIERS } from '../config/uniswap-abis';
 
 // Define Monad chain for viem
 const monad = defineChain({
@@ -63,6 +63,7 @@ interface SwapParams {
   userDestination: Hex;
   estimatedUsdcAmount: bigint;
   chain: 'base' | 'monad';
+  targetToken?: string; // e.g., 'MON', 'MON_MON', 'ANAGO', 'ANAGO_MON', 'ETH', 'ETH_BASE'
 }
 
 interface GasFees {
@@ -257,6 +258,91 @@ export class TransactionSigner {
     }
   }
 
+  // Cache for valid fee tiers (token path -> fee tiers)
+  // Key format: "token0-token1-token2"
+  private feeTierCache: Map<string, { feeTiers: number[]; timestamp: number }> = new Map();
+  private readonly FEE_TIER_CACHE_TTL_MS = 30 * 60 * 1000; // 30 minutes cache
+
+  /**
+   * Find valid fee tiers for a multi-hop swap by trying different combinations with the quoter
+   * Returns the first valid fee tier combination that returns a quote
+   * Results are cached for 30 minutes
+   */
+  async findValidFeeTiers(
+    tokens: `0x${string}`[],
+    amountIn: bigint,
+    chain: 'monad'
+  ): Promise<{ feeTiers: number[]; amountOut: bigint } | null> {
+    const { publicClient } = this.getClients(chain);
+    const quoterAddress = CHAINS.monad.quoterV2Address as Hex;
+
+    // Check cache first
+    const cacheKey = tokens.map(t => t.toLowerCase()).join('-');
+    const now = Date.now();
+    const cached = this.feeTierCache.get(cacheKey);
+
+    if (cached && (now - cached.timestamp) < this.FEE_TIER_CACHE_TTL_MS) {
+      console.info(`⚡ [TX SIGNER] Using cached fee tiers: ${cached.feeTiers.join('/')}`);
+
+      // Still need to get a fresh quote for the amount
+      try {
+        const path = buildMultiHopPath(tokens, cached.feeTiers);
+        const result = await publicClient.simulateContract({
+          address: quoterAddress,
+          abi: QUOTER_V2_ABI,
+          functionName: 'quoteExactInput',
+          args: [path, amountIn],
+        });
+        const amountOut = result.result[0] as bigint;
+        return { feeTiers: cached.feeTiers, amountOut };
+      } catch {
+        // Cache might be stale, clear it and re-discover
+        console.info(`⚠️ [TX SIGNER] Cached fee tiers no longer valid, re-discovering...`);
+        this.feeTierCache.delete(cacheKey);
+      }
+    }
+
+    console.info(`🔍 [TX SIGNER] Finding valid fee tiers for ${tokens.length}-token path...`);
+
+    // For a 3-token path (e.g., USDC -> WMON -> ANAGO), we need 2 fee tiers
+    // Try all combinations of fee tiers
+    for (const firstFee of FEE_TIERS) {
+      for (const secondFee of FEE_TIERS) {
+        try {
+          const path = buildMultiHopPath(tokens, [firstFee, secondFee]);
+
+          // Use simulate instead of call for nonpayable function
+          const result = await publicClient.simulateContract({
+            address: quoterAddress,
+            abi: QUOTER_V2_ABI,
+            functionName: 'quoteExactInput',
+            args: [path, amountIn],
+          });
+
+          const amountOut = result.result[0] as bigint;
+
+          if (amountOut > 0n) {
+            console.info(`✅ [TX SIGNER] Found valid path with fee tiers: ${firstFee}/${secondFee}, amountOut: ${amountOut}`);
+
+            // Cache the result
+            this.feeTierCache.set(cacheKey, {
+              feeTiers: [firstFee, secondFee],
+              timestamp: now,
+            });
+
+            return { feeTiers: [firstFee, secondFee], amountOut };
+          }
+        } catch {
+          // This fee tier combination doesn't work, try next
+          continue;
+        }
+      }
+    }
+
+    console.error('❌ [TX SIGNER] No valid fee tier combination found');
+    return null;
+  }
+
   async signAndSubmitMint(params: SignAndSubmitParams): Promise<{ txHash: Hex; confirmed?: boolean; error?: string }> {
     const chainLower = params.chain.toLowerCase();
 
@@ -486,12 +572,41 @@ export class TransactionSigner {
       }) as [bigint, bigint, bigint];
       console.info(`🔍 [TX SIGNER] Pre-swap Permit2→Router allowance: ${permit2Allowance[0].toString()}, expires: ${permit2Allowance[1].toString()}`);
 
-      // Build Uniswap swap commands
-      const { commands, inputs, deadline } = buildUsdcToNativeSwapCommands({
-        amountIn: usdcAmount,
-        recipient: params.userDestination,
-        chain: chainName,
-      });
+      // Determine if we're swapping to ANAGO or native token
+      const isAnagoSwap = params.targetToken === 'ANAGO' || params.targetToken === 'ANAGO_MON';
+
+      // For ANAGO swaps, find valid fee tiers first (ANAGO only exists on Monad)
+      let feeTiers: { first: number; second: number } | undefined;
+      if (isAnagoSwap) {
+        const monadConfig = CHAINS.monad;
+        const tokens: `0x${string}`[] = [
+          monadConfig.usdcAddress as `0x${string}`,
+          monadConfig.wmonAddress as `0x${string}`,
+          monadConfig.anagoAddress as `0x${string}`,
+        ];
+
+        const validPath = await this.findValidFeeTiers(tokens, usdcAmount, 'monad');
+        if (validPath) {
+          feeTiers = { first: validPath.feeTiers[0], second: validPath.feeTiers[1] };
+          console.info(`💰 [TX SIGNER] Expected output: ${validPath.amountOut} ANAGO (raw)`);
+        } else {
+          throw new Error('No valid liquidity pool found for USDC → WMON → ANAGO swap path');
+        }
+      }
+
+      // Build Uniswap swap commands based on target token
+      const { commands, inputs, deadline } = isAnagoSwap
+        ? buildUsdcToAnagoSwapCommands({
+            amountIn: usdcAmount,
+            recipient: params.userDestination,
+            targetToken: 'ANAGO',
+            feeTiers,
+          })
+        : buildUsdcToNativeSwapCommands({
+            amountIn: usdcAmount,
+            recipient: params.userDestination,
+            chain: chainName,
+          });
 
       const universalRouterAddress = chainConfig.universalRouterAddress as Hex;
       const universalRouterAbi: Abi = [
@@ -548,7 +663,8 @@ export class TransactionSigner {
         throw new Error('Uniswap swap transaction failed');
       }
 
-      console.info(`✅ [TX SIGNER] Swap completed - ${nativeSymbol} sent to user`);
+      const swapTargetSymbol = isAnagoSwap ? 'ANAGO' : nativeSymbol;
+      console.info(`✅ [TX SIGNER] Swap completed - ${swapTargetSymbol} sent to user`);
 
       return { txHash: swapTxHash, confirmed: true };
     } catch (error) {
diff --git a/packages/backend/src/services/uniswap-swap.ts b/packages/backend/src/services/uniswap-swap.ts
@@ -1,13 +1,44 @@
-import { encodePacked, encodeAbiParameters } from 'viem';
+import { encodePacked, encodeAbiParameters, type Hex } from 'viem';
 import { UniversalRouterCommand } from '../config/uniswap-abis';
 import { CHAINS } from '../config/chains';
 
+/**
+ * Builds a multi-hop path encoding for Uniswap V3
+ */
+export function buildMultiHopPath(tokens: `0x${string}`[], feeTiers: number[]): Hex {
+  if (tokens.length < 2 || feeTiers.length !== tokens.length - 1) {
+    throw new Error('Invalid path: need at least 2 tokens and feeTiers.length = tokens.length - 1');
+  }
+
+  // Build types and values arrays for encodePacked
+  const types: string[] = [];
+  const values: (string | number)[] = [];
+
+  for (let i = 0; i < tokens.length; i++) {
+    types.push('address');
+    values.push(tokens[i]);
+    if (i < feeTiers.length) {
+      types.push('uint24');
+      values.push(feeTiers[i]);
+    }
+  }
+
+  return encodePacked(types as any, values as any);
+}
+
 interface SwapParams {
   amountIn: bigint; // Amount of USDC to swap (in USDC decimals, typically 6)
   recipient: `0x${string}`; // Final recipient of native token
   chain: 'base' | 'monad'; // Destination chain for the swap
 }
 
+interface TokenSwapParams {
+  amountIn: bigint; // Amount of USDC to swap (in USDC decimals, typically 6)
+  recipient: `0x${string}`; // Final recipient of tokens
+  targetToken: 'ANAGO'; // Target token to swap to
+  feeTiers?: { first: number; second: number }; // Fee tiers for the two-hop swap
+}
+
 // Chain-specific swap configurations
 const SWAP_CONFIGS = {
   base: {
@@ -111,3 +142,71 @@ export function buildUsdcToEthSwapCommands(params: Omit<SwapParams, 'chain'>) {
   return buildUsdcToNativeSwapCommands({ ...params, chain: 'base' });
 }
 
+/**
+ * Builds Universal Router commands for swapping USDC to ANAGO on Monad
+ *
+ * Flow (two-hop swap via V3):
+ * 1. V3_SWAP_EXACT_IN: USDC → WMON → ANAGO (multi-hop path)
+ * 2. ANAGO is sent directly to recipient
+ *
+ * Note: This uses a single V3_SWAP_EXACT_IN with a multi-hop path encoding
+ */
+export function buildUsdcToAnagoSwapCommands(params: TokenSwapParams) {
+  const { amountIn, recipient, feeTiers } = params;
+
+  const usdcAddress = CHAINS.monad.usdcAddress as `0x${string}`;
+  const wmonAddress = CHAINS.monad.wmonAddress as `0x${string}`;
+  const anagoAddress = CHAINS.monad.anagoAddress as `0x${string}`;
+
+  // Fee tiers from params or defaults
+  const usdcWmonFeeTier = feeTiers?.first ?? 500;   // Default: 0.05%
+  const wmonAnagoFeeTier = feeTiers?.second ?? 3000; // Default: 0.3%
+
+  console.info(`🔧 [SWAP] Building USDC→WMON→ANAGO path with fee tiers: ${usdcWmonFeeTier}/${wmonAnagoFeeTier}`);
+
+  // Minimum amount out with slippage (0 for now, let Uniswap handle it)
+  const minAmountOut = 0n;
+
+  // Multi-hop path encoding: USDC -> WMON -> ANAGO
+  // Path format: tokenIn + fee + tokenIntermediate + fee + tokenOut
+  const path = encodePacked(
+    ['address', 'uint24', 'address', 'uint24', 'address'],
+    [usdcAddress, usdcWmonFeeTier, wmonAddress, wmonAnagoFeeTier, anagoAddress]
+  );
+
+  // V3_SWAP_EXACT_IN command - swap USDC to ANAGO via WMON
+  const v3SwapInput = encodeAbiParameters(
+    [
+      { name: 'recipient', type: 'address' },
+      { name: 'amountIn', type: 'uint256' },
+      { name: 'amountOutMin', type: 'uint256' },
+      { name: 'path', type: 'bytes' },
+      { name: 'payerIsUser', type: 'bool' },
+    ],
+    [
+      recipient, // ANAGO goes directly to user
+      amountIn,
+      minAmountOut,
+      path,
+      true, // Payer is the caller (our processing wallet)
+    ]
+  );
+
+  // Single command: V3_SWAP_EXACT_IN (no unwrap needed since ANAGO is ERC20)
+  const commands = encodePacked(
+    ['uint8'],
+    [UniversalRouterCommand.V3_SWAP_EXACT_IN]
+  );
+
+  const inputs = [v3SwapInput];
+
+  // Deadline: 20 minutes from now
+  const deadline = BigInt(Math.floor(Date.now() / 1000) + 1200);
+
+  return {
+    commands,
+    inputs,
+    deadline,
+  };
+}
+
diff --git a/packages/frontend/public/chain_icons/anago.png b/packages/frontend/public/chain_icons/anago.png
diff --git a/packages/frontend/src/components/ToTokenSelector.tsx b/packages/frontend/src/components/ToTokenSelector.tsx
@@ -17,6 +17,7 @@ const SOLANA_TOKENS: ToTokenOption[] = [
 
 const EVM_TOKENS: ToTokenOption[] = [
   { symbol: 'MON_MON', name: 'MON (Monad)', address: '0x0000000000000000000000000000000000000000', chain: 'evm', iconPath: '/chain_icons/mon.png' },
+  { symbol: 'ANAGO_MON', name: 'ANAGO (Monad)', address: '0x99ae2dc76c43979e3bcc0ae8d69f1fca077c8888', chain: 'evm', iconPath: '/chain_icons/anago.png' },
   { symbol: 'USDC_MON', name: 'USDC (Monad)', address: '0x754704Bc059F8C67012fEd69BC8A327a5aafb603', chain: 'evm', iconPath: '/chain_icons/usdc.png' },
 ];
 
diff --git a/packages/frontend/src/routes/$transactionId.tsx b/packages/frontend/src/routes/$transactionId.tsx
