@eth-optimism/actions-sdk 0.3.0 → 0.4.0

package/src/swap/providers/velodrome/__tests__/VelodromeSwapProvider.network.test.ts

@@ -0,0 +1,341 @@
+/**
+ * Network fork tests for VelodromeSwapProvider.
+ *
+ * Forks real networks via Anvil to verify swap quoting and encoding
+ * against deployed Velodrome/Aerodrome contracts.
+ *
+ * Run: pnpm test:network
+ * Requires: anvil (from foundry) and network access
+ */
+import { type ChildProcess, spawn } from 'node:child_process'
+
+import type { Address } from 'viem'
+import { createPublicClient, http } from 'viem'
+import { base, optimism } from 'viem/chains'
+import { afterAll, beforeAll, describe, expect, it } from 'vitest'
+
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+import type { ChainManager } from '@/services/ChainManager.js'
+import type { VelodromeSwapProviderConfig } from '@/swap/providers/velodrome/types.js'
+import { VelodromeSwapProvider } from '@/swap/providers/velodrome/VelodromeSwapProvider.js'
+import type { Asset } from '@/types/asset.js'
+
+// ── Real mainnet assets ──
+
+const OP_USDC: Asset = {
+  type: 'erc20',
+  address: {
+    [optimism.id]: '0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85' as Address,
+  },
+  metadata: { name: 'USD Coin', symbol: 'USDC', decimals: 6 },
+}
+
+const OP_WETH: Asset = {
+  type: 'erc20',
+  address: {
+    [optimism.id]: '0x4200000000000000000000000000000000000006' as Address,
+  },
+  metadata: { name: 'Wrapped Ether', symbol: 'WETH', decimals: 18 },
+}
+
+const OP_OP: Asset = {
+  type: 'erc20',
+  address: {
+    [optimism.id]: '0x4200000000000000000000000000000000000042' as Address,
+  },
+  metadata: { name: 'Optimism', symbol: 'OP', decimals: 18 },
+}
+
+const BASE_USDC: Asset = {
+  type: 'erc20',
+  address: {
+    [base.id]: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913' as Address,
+  },
+  metadata: { name: 'USD Coin', symbol: 'USDC', decimals: 6 },
+}
+
+const BASE_WETH: Asset = {
+  type: 'erc20',
+  address: {
+    [base.id]: '0x4200000000000000000000000000000000000006' as Address,
+  },
+  metadata: { name: 'Wrapped Ether', symbol: 'WETH', decimals: 18 },
+}
+
+// ── Anvil fork helpers ──
+
+interface AnvilFork {
+  port: number
+  process: ChildProcess
+  rpcUrl: string
+}
+
+async function startAnvilFork(
+  forkUrl: string,
+  port: number,
+): Promise<AnvilFork> {
+  const proc = spawn(
+    'anvil',
+    ['--fork-url', forkUrl, '--port', String(port), '--silent'],
+    {
+      stdio: 'ignore',
+    },
+  )
+
+  const rpcUrl = `http://127.0.0.1:${port}`
+  for (let i = 0; i < 30; i++) {
+    try {
+      const res = await fetch(rpcUrl, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          jsonrpc: '2.0',
+          method: 'eth_blockNumber',
+          params: [],
+          id: 1,
+        }),
+      })
+      if (res.ok) return { port, process: proc, rpcUrl }
+    } catch {
+      // not ready yet
+    }
+    await new Promise((r) => setTimeout(r, 500))
+  }
+  proc.kill()
+  throw new Error(`Anvil fork on port ${port} did not start in time`)
+}
+
+function stopAnvilFork(fork: AnvilFork) {
+  fork.process.kill()
+}
+
+function createForkChainManager(
+  rpcUrl: string,
+  chain: typeof optimism | typeof base,
+): ChainManager {
+  const client = createPublicClient({ chain, transport: http(rpcUrl) })
+  return {
+    getPublicClient: () => client,
+    getSupportedChains: () => [chain.id],
+  } as unknown as ChainManager
+}
+
+function createProvider(
+  chainId: SupportedChainId,
+  chainManager: ChainManager,
+  config: Partial<VelodromeSwapProviderConfig> = {},
+): VelodromeSwapProvider {
+  return new VelodromeSwapProvider(
+    { defaultSlippage: 0.005, ...config },
+    chainManager,
+  )
+}
+
+// ── Tests ──
+
+describe('VelodromeSwapProvider network fork tests', () => {
+  let opFork: AnvilFork
+  let baseFork: AnvilFork
+
+  beforeAll(async () => {
+    const opRpc = process.env.OP_MAINNET_RPC || 'https://mainnet.optimism.io'
+    const baseRpc = process.env.BASE_MAINNET_RPC || 'https://mainnet.base.org'
+
+    ;[opFork, baseFork] = await Promise.all([
+      startAnvilFork(opRpc, 18545),
+      startAnvilFork(baseRpc, 18546),
+    ])
+  }, 60_000)
+
+  afterAll(() => {
+    if (opFork) stopAnvilFork(opFork)
+    if (baseFork) stopAnvilFork(baseFork)
+  })
+
+  describe('Optimism — v2 router', () => {
+    it('getQuote returns valid quote for USDC/OP volatile pool', async () => {
+      const chainManager = createForkChainManager(opFork.rpcUrl, optimism)
+      const provider = createProvider(
+        optimism.id as SupportedChainId,
+        chainManager,
+        {
+          marketAllowlist: [
+            {
+              assets: [OP_USDC, OP_OP],
+              stable: false,
+              chainId: optimism.id as SupportedChainId,
+            },
+          ],
+        },
+      )
+
+      const quote = await provider.getQuote({
+        assetIn: OP_USDC,
+        assetOut: OP_OP,
+        amountIn: 10,
+        chainId: optimism.id as SupportedChainId,
+      })
+
+      expect(quote.amountIn).toBe(10)
+      expect(quote.amountInRaw).toBe(10_000_000n) // 10 USDC = 10e6
+      expect(quote.amountOut).toBeGreaterThan(0)
+      expect(quote.amountOutRaw).toBeGreaterThan(0n)
+      expect(quote.price).toBeGreaterThan(0)
+      expect(quote.execution.swapCalldata).toMatch(/^0x/)
+      expect(quote.provider).toBe('velodrome')
+      expect(quote.route.pools).toHaveLength(1)
+    })
+
+    it('getQuote returns valid quote for USDC/WETH volatile pool', async () => {
+      const chainManager = createForkChainManager(opFork.rpcUrl, optimism)
+      const provider = createProvider(
+        optimism.id as SupportedChainId,
+        chainManager,
+        {
+          marketAllowlist: [
+            {
+              assets: [OP_USDC, OP_WETH],
+              stable: false,
+              chainId: optimism.id as SupportedChainId,
+            },
+          ],
+        },
+      )
+
+      const quote = await provider.getQuote({
+        assetIn: OP_USDC,
+        assetOut: OP_WETH,
+        amountIn: 100,
+        chainId: optimism.id as SupportedChainId,
+      })
+
+      expect(quote.amountOut).toBeGreaterThan(0)
+      expect(quote.price).toBeGreaterThan(0)
+      expect(quote.amountOutMin).toBeLessThan(quote.amountOut)
+    })
+  })
+
+  describe('Base — v2 router (Aerodrome)', () => {
+    it('getQuote returns valid quote for USDC/WETH volatile pool', async () => {
+      const chainManager = createForkChainManager(baseFork.rpcUrl, base)
+      const provider = createProvider(
+        base.id as SupportedChainId,
+        chainManager,
+        {
+          marketAllowlist: [
+            {
+              assets: [BASE_USDC, BASE_WETH],
+              stable: false,
+              chainId: base.id as SupportedChainId,
+            },
+          ],
+        },
+      )
+
+      const quote = await provider.getQuote({
+        assetIn: BASE_USDC,
+        assetOut: BASE_WETH,
+        amountIn: 100,
+        chainId: base.id as SupportedChainId,
+      })
+
+      expect(quote.amountOut).toBeGreaterThan(0)
+      expect(quote.price).toBeGreaterThan(0)
+      expect(quote.execution.swapCalldata).toMatch(/^0x/)
+    })
+  })
+
+  describe('Optimism — CL/Slipstream pool', () => {
+    it('getQuote returns valid quote for WETH/USDC CL pool', async () => {
+      const chainManager = createForkChainManager(opFork.rpcUrl, optimism)
+      const provider = createProvider(
+        optimism.id as SupportedChainId,
+        chainManager,
+        {
+          marketAllowlist: [
+            {
+              assets: [OP_USDC, OP_WETH],
+              tickSpacing: 100,
+              chainId: optimism.id as SupportedChainId,
+            },
+          ],
+        },
+      )
+
+      const quote = await provider.getQuote({
+        assetIn: OP_USDC,
+        assetOut: OP_WETH,
+        amountIn: 100,
+        chainId: optimism.id as SupportedChainId,
+      })
+
+      expect(quote.amountOut).toBeGreaterThan(0)
+      expect(quote.amountOutRaw).toBeGreaterThan(0n)
+      expect(quote.price).toBeGreaterThan(0)
+      expect(quote.execution.swapCalldata).toMatch(/^0x/)
+      expect(quote.provider).toBe('velodrome')
+    })
+  })
+
+  describe('Base — CL/Slipstream pool (Aerodrome)', () => {
+    it('getQuote returns valid quote for USDC/WETH CL pool', async () => {
+      const chainManager = createForkChainManager(baseFork.rpcUrl, base)
+      const provider = createProvider(
+        base.id as SupportedChainId,
+        chainManager,
+        {
+          marketAllowlist: [
+            {
+              assets: [BASE_USDC, BASE_WETH],
+              tickSpacing: 100,
+              chainId: base.id as SupportedChainId,
+            },
+          ],
+        },
+      )
+
+      const quote = await provider.getQuote({
+        assetIn: BASE_USDC,
+        assetOut: BASE_WETH,
+        amountIn: 100,
+        chainId: base.id as SupportedChainId,
+      })
+
+      expect(quote.amountOut).toBeGreaterThan(0)
+      expect(quote.amountOutRaw).toBeGreaterThan(0n)
+      expect(quote.price).toBeGreaterThan(0)
+      expect(quote.execution.swapCalldata).toMatch(/^0x/)
+    })
+
+    it('execute(quote) produces valid transaction data', async () => {
+      const chainManager = createForkChainManager(baseFork.rpcUrl, base)
+      const provider = createProvider(
+        base.id as SupportedChainId,
+        chainManager,
+        {
+          marketAllowlist: [
+            {
+              assets: [BASE_USDC, BASE_WETH],
+              tickSpacing: 100,
+              chainId: base.id as SupportedChainId,
+            },
+          ],
+        },
+      )
+
+      const quote = await provider.getQuote({
+        assetIn: BASE_USDC,
+        assetOut: BASE_WETH,
+        amountIn: 100,
+        chainId: base.id as SupportedChainId,
+        recipient: '0x000000000000000000000000000000000000dEaD' as Address,
+      })
+
+      const tx = await provider.execute(quote)
+
+      expect(tx.transactionData.swap.data).toBe(quote.execution.swapCalldata)
+      expect(tx.amountIn).toBe(quote.amountIn)
+      expect(tx.price).toBe(quote.price)
+    })
+  })
+})

package/src/swap/providers/velodrome/__tests__/VelodromeSwapProvider.routing.test.ts

@@ -0,0 +1,202 @@
+import type { PublicClient } from 'viem'
+import { base, baseSepolia, mode, optimism } from 'viem/chains'
+import { describe, expect, it, vi } from 'vitest'
+
+import {
+  MOCK_POOL,
+  MOCK_WALLET,
+  MockETHAsset as ETH,
+  MockUSDCAsset as USDC,
+  MockWETHAsset as WETH,
+} from '@/__mocks__/MockAssets.js'
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+import type { ChainManager } from '@/services/ChainManager.js'
+import type { VelodromeSwapProviderConfig } from '@/swap/providers/velodrome/types.js'
+import { VelodromeSwapProvider } from '@/swap/providers/velodrome/VelodromeSwapProvider.js'
+
+const OP_CHAIN_ID = optimism.id as SupportedChainId
+const BASE_CHAIN_ID = base.id as SupportedChainId
+const BASE_SEPOLIA_CHAIN_ID = baseSepolia.id as SupportedChainId
+
+function createMockChainManager(chainId: SupportedChainId): ChainManager {
+  const mockPublicClient = {
+    readContract: vi
+      .fn()
+      .mockImplementation(({ functionName }: { functionName: string }) => {
+        if (functionName === 'getAmountsOut')
+          return Promise.resolve([1000000n, 500000000000000000n])
+        if (functionName === 'allowance') return Promise.resolve(0n)
+        // Factory.getPool returns a pool address
+        if (functionName === 'getPool') return Promise.resolve(MOCK_POOL)
+        // Pool.getAmountOut for v2/universal quoting
+        if (functionName === 'getAmountOut')
+          return Promise.resolve(500000000000000000n)
+        // QuoterV2.quoteExactInputSingle for CL pools
+        if (functionName === 'quoteExactInputSingle')
+          return Promise.resolve([500000000000000000n, 0n, 0, 0n])
+        return Promise.resolve(0n)
+      }),
+  } as unknown as PublicClient
+
+  return {
+    getPublicClient: vi.fn().mockReturnValue(mockPublicClient),
+    getSupportedChains: vi.fn().mockReturnValue([chainId]),
+  } as unknown as ChainManager
+}
+
+function createProvider(
+  chainId: SupportedChainId,
+  configOverrides?: Partial<VelodromeSwapProviderConfig>,
+): VelodromeSwapProvider {
+  const config: VelodromeSwapProviderConfig = {
+    defaultSlippage: 0.005,
+    marketAllowlist: [{ assets: [USDC, WETH], stable: false, chainId }],
+    ...configOverrides,
+  }
+  return new VelodromeSwapProvider(config, createMockChainManager(chainId))
+}
+
+describe('VelodromeSwapProvider router type routing', () => {
+  describe('v2 router (Optimism)', () => {
+    it('executes swap via legacy router on Optimism', async () => {
+      const provider = createProvider(OP_CHAIN_ID)
+      const result = await provider.execute({
+        amountIn: 100,
+        assetIn: USDC,
+        assetOut: WETH,
+        chainId: OP_CHAIN_ID,
+        walletAddress: MOCK_WALLET,
+      })
+
+      expect(result.transactionData.swap).toBeDefined()
+      // Legacy router: approval via ERC20.approve (not transfer)
+      expect(result.transactionData.tokenApproval).toBeDefined()
+    })
+  })
+
+  describe('v2 router (Base / Aerodrome)', () => {
+    it('executes swap via legacy router on Base', async () => {
+      const provider = createProvider(BASE_CHAIN_ID)
+      const result = await provider.execute({
+        amountIn: 100,
+        assetIn: USDC,
+        assetOut: WETH,
+        chainId: BASE_CHAIN_ID,
+        walletAddress: MOCK_WALLET,
+      })
+
+      expect(result.transactionData.swap).toBeDefined()
+      expect(result.transactionData.tokenApproval).toBeDefined()
+    })
+  })
+
+  describe('universal router (Base Sepolia)', () => {
+    it('executes swap via Universal Router', async () => {
+      const provider = createProvider(BASE_SEPOLIA_CHAIN_ID)
+      const result = await provider.execute({
+        amountIn: 100,
+        assetIn: USDC,
+        assetOut: WETH,
+        chainId: BASE_SEPOLIA_CHAIN_ID,
+        walletAddress: MOCK_WALLET,
+      })
+
+      expect(result.transactionData.swap).toBeDefined()
+      // Universal Router: uses ERC20.transfer (not approve)
+      expect(result.transactionData.tokenApproval).toBeDefined()
+      // tokenApproval should be a transfer() call, not approve()
+      const approvalData = result.transactionData.tokenApproval!.data
+      // transfer() selector = 0xa9059cbb
+      expect(approvalData.startsWith('0xa9059cbb')).toBe(true)
+    })
+
+    it('quotes via pool.getAmountOut for Universal Router', async () => {
+      const provider = createProvider(BASE_SEPOLIA_CHAIN_ID)
+      const quote = await provider.getQuote({
+        assetIn: USDC,
+        assetOut: WETH,
+        amountIn: 100,
+        chainId: BASE_SEPOLIA_CHAIN_ID,
+      })
+
+      expect(quote.price).toBeTypeOf('number')
+      expect(quote.amountOut).toBeGreaterThan(0)
+    })
+  })
+
+  describe('leaf router (relay chains)', () => {
+    it('executes swap on Mode (leaf chain)', async () => {
+      const MODE_CHAIN_ID = mode.id as SupportedChainId
+
+      const provider = new VelodromeSwapProvider(
+        {
+          defaultSlippage: 0.005,
+          marketAllowlist: [
+            {
+              assets: [USDC, WETH],
+              stable: false,
+              chainId: MODE_CHAIN_ID,
+            },
+          ],
+        },
+        createMockChainManager(MODE_CHAIN_ID),
+      )
+
+      const result = await provider.execute({
+        amountIn: 100,
+        assetIn: USDC,
+        assetOut: WETH,
+        chainId: MODE_CHAIN_ID,
+        walletAddress: MOCK_WALLET,
+      })
+
+      expect(result.transactionData.swap).toBeDefined()
+      // Leaf router uses legacy approve pattern
+      expect(result.transactionData.tokenApproval).toBeDefined()
+    })
+  })
+
+  describe('native ETH swaps', () => {
+    it('skips approval for native ETH input', async () => {
+      const provider = createProvider(OP_CHAIN_ID, {
+        marketAllowlist: [
+          { assets: [ETH, USDC], stable: false, chainId: OP_CHAIN_ID },
+        ],
+      })
+
+      const result = await provider.execute({
+        amountIn: 1,
+        assetIn: ETH,
+        assetOut: USDC,
+        chainId: OP_CHAIN_ID,
+        walletAddress: MOCK_WALLET,
+      })
+
+      // No approval needed for native ETH
+      expect(result.transactionData.tokenApproval).toBeUndefined()
+      // Swap tx should carry ETH value
+      expect(result.transactionData.swap.value).toBeGreaterThan(0n)
+    })
+
+    it('includes zero value for token-to-native swaps', async () => {
+      const provider = createProvider(OP_CHAIN_ID, {
+        marketAllowlist: [
+          { assets: [USDC, ETH], stable: false, chainId: OP_CHAIN_ID },
+        ],
+      })
+
+      const result = await provider.execute({
+        amountIn: 100,
+        assetIn: USDC,
+        assetOut: ETH,
+        chainId: OP_CHAIN_ID,
+        walletAddress: MOCK_WALLET,
+      })
+
+      // Approval needed for USDC
+      expect(result.transactionData.tokenApproval).toBeDefined()
+      // Swap tx should have zero value (not sending ETH)
+      expect(result.transactionData.swap.value).toBe(0n)
+    })
+  })
+})