@eth-optimism/actions-sdk 0.2.0 → 0.4.0

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)
+    })
+  })
+})

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

@@ -0,0 +1,506 @@
+import type { Address, PublicClient } from 'viem'
+import { mode, optimism } from 'viem/chains'
+import { describe, expect, it, vi } from 'vitest'
+
+import {
+  MOCK_WALLET,
+  MockOPAsset as OP,
+  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'
+import type { Asset } from '@/types/asset.js'
+
+const CHAIN_ID = optimism.id as SupportedChainId
+
+function createMockChainManager(): ChainManager {
+  const mockPublicClient = {
+    readContract: vi
+      .fn()
+      .mockImplementation(({ functionName }: { functionName: string }) => {
+        if (functionName === 'getAmountsOut')
+          return Promise.resolve([100000000n, 500000000000000000n])
+        if (functionName === 'allowance') return Promise.resolve(0n)
+        if (functionName === 'getPool')
+          return Promise.resolve('0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA')
+        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([CHAIN_ID]),
+  } as unknown as ChainManager
+}
+
+function createProvider(
+  configOverrides?: Partial<VelodromeSwapProviderConfig>,
+): VelodromeSwapProvider {
+  const config: VelodromeSwapProviderConfig = {
+    defaultSlippage: 0.005,
+    marketAllowlist: [{ assets: [USDC, OP], stable: false, chainId: CHAIN_ID }],
+    ...configOverrides,
+  }
+  return new VelodromeSwapProvider(config, createMockChainManager())
+}
+
+describe('VelodromeSwapProvider', () => {
+  describe('supportedChainIds', () => {
+    it('returns Optimism and Base', () => {
+      const provider = createProvider()
+      const chainIds = provider.protocolSupportedChainIds()
+      expect(chainIds).toContain(10) // Optimism
+      expect(chainIds).toContain(8453) // Base
+    })
+  })
+
+  describe('execute', () => {
+    it('returns swap transaction with approval data', async () => {
+      const provider = createProvider()
+      const result = await provider.execute({
+        amountIn: 100,
+        assetIn: USDC,
+        assetOut: OP,
+        chainId: CHAIN_ID,
+        walletAddress: MOCK_WALLET,
+      })
+
+      expect(result.transactionData.swap).toBeDefined()
+      expect(result.transactionData.swap.to).toBeDefined()
+      expect(result.transactionData.swap.data).toMatch(/^0x/)
+      expect(result.amountIn).toBeDefined()
+      expect(result.amountOut).toBeDefined()
+      expect(result.price).toBeDefined()
+    })
+
+    it('includes token approval to router when allowance insufficient', async () => {
+      const provider = createProvider()
+      const result = await provider.execute({
+        amountIn: 100,
+        assetIn: USDC,
+        assetOut: OP,
+        chainId: CHAIN_ID,
+        walletAddress: MOCK_WALLET,
+      })
+
+      // Mock returns 0n allowance, so approval to Router should be needed
+      expect(result.transactionData.tokenApproval).toBeDefined()
+      // No Permit2 for Velodrome
+      expect(result.transactionData.permit2Approval).toBeUndefined()
+    })
+
+    it('throws for exact-output swaps', async () => {
+      const provider = createProvider()
+
+      await expect(
+        provider.execute({
+          amountOut: 1,
+          assetIn: USDC,
+          assetOut: OP,
+          chainId: CHAIN_ID,
+          walletAddress: MOCK_WALLET,
+        }),
+      ).rejects.toThrow('does not support exact-output swaps')
+    })
+
+    it('throws without stable flag in market config', async () => {
+      const provider = createProvider({
+        // Intentionally omit stable to test runtime validation
+        marketAllowlist: [{ assets: [USDC, OP], chainId: CHAIN_ID }],
+      })
+
+      await expect(
+        provider.execute({
+          amountIn: 100,
+          assetIn: USDC,
+          assetOut: OP,
+          chainId: CHAIN_ID,
+          walletAddress: MOCK_WALLET,
+        }),
+      ).rejects.toThrow(
+        'Either stable (v2 AMM) or tickSpacing (CL) must be configured',
+      )
+    })
+  })
+
+  describe('getQuote', () => {
+    it('returns SwapQuote with execution data', async () => {
+      const provider = createProvider()
+      const quote = await provider.getQuote({
+        assetIn: USDC,
+        assetOut: OP,
+        amountIn: 100,
+        chainId: CHAIN_ID,
+      })
+
+      expect(quote.price).toBeTypeOf('number')
+      expect(quote.amountIn).toBeDefined()
+      expect(quote.amountOut).toBeDefined()
+      expect(quote.amountInRaw).toBeGreaterThan(0n)
+      expect(quote.route.path).toEqual([USDC, OP])
+      expect(quote.execution).toBeDefined()
+      expect(quote.execution.swapCalldata).toMatch(/^0x/)
+      expect(quote.execution.routerAddress).toBeDefined()
+      expect(quote.provider).toBe('velodrome')
+      expect(quote.quotedAt).toBeGreaterThan(0)
+      expect(quote.expiresAt).toBeGreaterThan(quote.quotedAt)
+    })
+
+    it('defaults to 1 unit when no amount specified', async () => {
+      const provider = createProvider()
+      const quote = await provider.getQuote({
+        assetIn: USDC,
+        assetOut: OP,
+        chainId: CHAIN_ID,
+      })
+
+      // 1 USDC = 1000000 (6 decimals)
+      expect(quote.amountInRaw).toBe(1000000n)
+    })
+
+    it('throws for exact-output quotes', async () => {
+      const provider = createProvider()
+
+      await expect(
+        provider.getQuote({
+          assetIn: USDC,
+          assetOut: OP,
+          amountOut: 1,
+          chainId: CHAIN_ID,
+        }),
+      ).rejects.toThrow('does not support exact-output swaps')
+    })
+
+    it('execute with quote skips re-quoting', async () => {
+      const provider = createProvider()
+      const quote = await provider.getQuote({
+        assetIn: USDC,
+        assetOut: OP,
+        amountIn: 100,
+        chainId: CHAIN_ID,
+        recipient: MOCK_WALLET,
+      })
+
+      const result = await provider.execute({
+        ...quote,
+        recipient: MOCK_WALLET,
+      })
+
+      expect(result.transactionData.swap).toBeDefined()
+      expect(result.transactionData.swap.data).toBe(
+        quote.execution.swapCalldata,
+      )
+      expect(result.price).toBe(quote.price)
+    })
+  })
+
+  describe('getMarkets', () => {
+    it('returns markets from allowlist config', async () => {
+      const provider = createProvider()
+      const markets = await provider.getMarkets({})
+      expect(markets).toHaveLength(1)
+      expect(markets[0].assets).toEqual([USDC, OP])
+      expect(markets[0].fee).toBe(0)
+      expect(markets[0].provider).toBe('velodrome')
+      expect(markets[0].marketId.poolId).toMatch(/^0x/)
+      expect(markets[0].marketId.chainId).toBe(CHAIN_ID)
+    })
+
+    it('returns empty when no allowlist configured', async () => {
+      const provider = createProvider({ marketAllowlist: [] })
+      const markets = await provider.getMarkets({})
+      expect(markets).toEqual([])
+    })
+
+    it('expands multi-asset filter into all pairs', async () => {
+      const provider = createProvider({
+        marketAllowlist: [
+          {
+            assets: [USDC, OP, WETH],
+            stable: false,
+            chainId: CHAIN_ID,
+          },
+        ],
+      })
+      const markets = await provider.getMarkets({})
+      // 3 assets → 3 pairs: USDC/OP, USDC/WETH, OP/WETH
+      expect(markets).toHaveLength(3)
+    })
+
+    it('filters by asset', async () => {
+      const provider = createProvider({
+        marketAllowlist: [
+          {
+            assets: [USDC, OP, WETH],
+            stable: false,
+            chainId: CHAIN_ID,
+          },
+        ],
+      })
+      const markets = await provider.getMarkets({ asset: USDC })
+      expect(markets).toHaveLength(2)
+      for (const market of markets) {
+        expect(market.assets).toContain(USDC)
+      }
+    })
+
+    it('skips configs without stable or tickSpacing defined', async () => {
+      const provider = createProvider({
+        marketAllowlist: [
+          // Intentionally omit both to test filtering
+          { assets: [USDC, OP], chainId: CHAIN_ID },
+          {
+            assets: [USDC, WETH],
+            stable: true,
+            chainId: CHAIN_ID,
+          },
+        ],
+      })
+      const markets = await provider.getMarkets({})
+      expect(markets).toHaveLength(1)
+      expect(markets[0].assets).toEqual([USDC, WETH])
+    })
+
+    it('includes CL configs with tickSpacing', async () => {
+      const provider = createProvider({
+        marketAllowlist: [
+          {
+            assets: [USDC, WETH],
+            tickSpacing: 100,
+            chainId: CHAIN_ID,
+          },
+        ],
+      })
+      const markets = await provider.getMarkets({})
+      expect(markets).toHaveLength(1)
+      expect(markets[0].marketId.poolId).toMatch(/^0x/)
+    })
+
+    it('CL pool has different poolId than v2 pool for same pair', async () => {
+      const v2Provider = createProvider({
+        marketAllowlist: [
+          { assets: [USDC, WETH], stable: false, chainId: CHAIN_ID },
+        ],
+      })
+      const clProvider = createProvider({
+        marketAllowlist: [
+          { assets: [USDC, WETH], tickSpacing: 100, chainId: CHAIN_ID },
+        ],
+      })
+      const v2Markets = await v2Provider.getMarkets({})
+      const clMarkets = await clProvider.getMarkets({})
+      expect(v2Markets[0].marketId.poolId).not.toBe(
+        clMarkets[0].marketId.poolId,
+      )
+    })
+
+    it('throws when both stable and tickSpacing are set', async () => {
+      const provider = createProvider({
+        marketAllowlist: [
+          {
+            assets: [USDC, OP],
+            stable: false,
+            tickSpacing: 100,
+            chainId: CHAIN_ID,
+          },
+        ],
+      })
+      await expect(provider.getMarkets({})).rejects.toThrow(
+        'mutually exclusive',
+      )
+    })
+
+    it('skips assets without address on target chain', async () => {
+      const noChainAsset: Asset = {
+        type: 'erc20',
+        address: { 1: '0x5555555555555555555555555555555555555555' as Address },
+        metadata: { name: 'No Chain', symbol: 'NC', decimals: 18 },
+      }
+      const provider = createProvider({
+        marketAllowlist: [
+          { assets: [USDC, noChainAsset], stable: false, chainId: CHAIN_ID },
+        ],
+      })
+      const markets = await provider.getMarkets({})
+      expect(markets).toEqual([])
+    })
+
+    it('produces deterministic poolIds', async () => {
+      const provider = createProvider()
+      const first = await provider.getMarkets({})
+      const second = await provider.getMarkets({})
+      expect(first[0].marketId.poolId).toBe(second[0].marketId.poolId)
+    })
+  })
+
+  describe('getMarket', () => {
+    it('finds market by poolId', async () => {
+      const provider = createProvider()
+      const markets = await provider.getMarkets({})
+      const market = await provider.getMarket({
+        poolId: markets[0].marketId.poolId,
+        chainId: CHAIN_ID,
+      })
+      expect(market.fee).toBe(0)
+      expect(market.assets).toEqual([USDC, OP])
+    })
+
+    it('throws for unknown poolId', async () => {
+      const provider = createProvider()
+      await expect(
+        provider.getMarket({ poolId: '0xunknown', chainId: CHAIN_ID }),
+      ).rejects.toThrow('not found')
+    })
+
+    it('finds correct market in multi-asset filter', async () => {
+      const provider = createProvider({
+        marketAllowlist: [
+          {
+            assets: [USDC, OP, WETH],
+            stable: false,
+            chainId: CHAIN_ID,
+          },
+        ],
+      })
+      const markets = await provider.getMarkets({})
+      for (const expected of markets) {
+        const found = await provider.getMarket({
+          poolId: expected.marketId.poolId,
+          chainId: CHAIN_ID,
+        })
+        expect(found.marketId.poolId).toBe(expected.marketId.poolId)
+      }
+    })
+  })
+
+  describe('CL/Slipstream pools', () => {
+    it('getQuote returns quote with CL-specific providerContext', async () => {
+      const provider = createProvider({
+        marketAllowlist: [
+          { assets: [USDC, WETH], tickSpacing: 100, chainId: CHAIN_ID },
+        ],
+      })
+
+      const quote = await provider.getQuote({
+        assetIn: USDC,
+        assetOut: WETH,
+        amountIn: 100,
+        chainId: CHAIN_ID,
+      })
+
+      expect(quote.provider).toBe('velodrome')
+      expect(quote.amountOut).toBeGreaterThan(0)
+      expect(quote.execution.swapCalldata).toMatch(/^0x/)
+      expect(
+        (quote.execution.providerContext as Record<string, unknown>)
+          .tickSpacing,
+      ).toBe(100)
+    })
+
+    it('execute with CL quote uses pre-built calldata', async () => {
+      const provider = createProvider({
+        marketAllowlist: [
+          { assets: [USDC, WETH], tickSpacing: 100, chainId: CHAIN_ID },
+        ],
+      })
+
+      const quote = await provider.getQuote({
+        assetIn: USDC,
+        assetOut: WETH,
+        amountIn: 100,
+        chainId: CHAIN_ID,
+        recipient: MOCK_WALLET,
+      })
+
+      const result = await provider.execute({
+        ...quote,
+        recipient: MOCK_WALLET,
+      })
+      expect(result.transactionData.swap.data).toBe(
+        quote.execution.swapCalldata,
+      )
+    })
+
+    it('execute works for CL pool via raw params', async () => {
+      const provider = createProvider({
+        marketAllowlist: [
+          { assets: [USDC, WETH], tickSpacing: 100, chainId: CHAIN_ID },
+        ],
+      })
+
+      const result = await provider.execute({
+        amountIn: 100,
+        assetIn: USDC,
+        assetOut: WETH,
+        chainId: CHAIN_ID,
+        walletAddress: MOCK_WALLET,
+      })
+
+      expect(result.transactionData.swap).toBeDefined()
+      expect(result.amountOut).toBeGreaterThan(0)
+    })
+
+    it('throws for CL on unsupported chain (no clPoolFactory)', async () => {
+      const MODE_CHAIN_ID = mode.id as SupportedChainId
+
+      const mockChainManager = {
+        getPublicClient: vi.fn().mockReturnValue({
+          readContract: vi.fn(),
+        }),
+        getSupportedChains: vi.fn().mockReturnValue([MODE_CHAIN_ID]),
+      } as unknown as ChainManager
+
+      const provider = new VelodromeSwapProvider(
+        {
+          defaultSlippage: 0.005,
+          marketAllowlist: [
+            {
+              assets: [USDC, WETH],
+              tickSpacing: 100,
+              chainId: MODE_CHAIN_ID,
+            },
+          ],
+        },
+        mockChainManager,
+      )
+
+      await expect(
+        provider.getQuote({
+          assetIn: USDC,
+          assetOut: WETH,
+          amountIn: 100,
+          chainId: MODE_CHAIN_ID,
+        }),
+      ).rejects.toThrow('CL pools not supported on chain')
+    })
+  })
+
+  describe('protocolSupportedChainIds', () => {
+    it('includes all configured chains', () => {
+      const provider = createProvider()
+      const chainIds = provider.protocolSupportedChainIds()
+
+      expect(chainIds).toContain(10) // Optimism
+      expect(chainIds).toContain(8453) // Base
+      expect(chainIds).toContain(84532) // Base Sepolia
+      expect(chainIds).toContain(60808) // Bob
+      expect(chainIds).toContain(42220) // Celo
+      expect(chainIds).toContain(252) // Fraxtal
+      expect(chainIds).toContain(57073) // Ink
+      expect(chainIds).toContain(1135) // Lisk
+      expect(chainIds).toContain(1750) // Metal
+      expect(chainIds).toContain(34443) // Mode
+      expect(chainIds).toContain(1868) // Soneium
+      expect(chainIds).toContain(5330) // Superseed
+      expect(chainIds).toContain(1923) // Swell
+      expect(chainIds).toContain(130) // Unichain
+
+      expect(chainIds).toHaveLength(14)
+    })
+  })
+})