@eth-optimism/actions-sdk 0.1.0 → 0.3.0

package/src/swap/providers/uniswap/__tests__/UniswapSwapProvider.test.ts

@@ -0,0 +1,299 @@
+import type { Address, PublicClient } from 'viem'
+import { baseSepolia } from 'viem/chains'
+import { describe, expect, it, vi } from 'vitest'
+
+import { MockWETHAsset } from '@/__mocks__/MockAssets.js'
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+import type { ChainManager } from '@/services/ChainManager.js'
+import type { Asset } from '@/types/asset.js'
+
+import type { UniswapSwapProviderConfig } from '../types.js'
+import { UniswapSwapProvider } from '../UniswapSwapProvider.js'
+
+const CHAIN_ID = baseSepolia.id as SupportedChainId
+
+const USDC: Asset = {
+  type: 'erc20',
+  address: {
+    [CHAIN_ID]: '0x1111111111111111111111111111111111111111' as Address,
+  },
+  metadata: { name: 'USD Coin', symbol: 'USDC', decimals: 6 },
+}
+
+const OP: Asset = {
+  type: 'erc20',
+  address: {
+    [CHAIN_ID]: '0x3333333333333333333333333333333333333333' as Address,
+  },
+  metadata: { name: 'Optimism', symbol: 'OP', decimals: 18 },
+}
+
+function createMockChainManager(): ChainManager {
+  const mockPublicClient = {
+    simulateContract: vi.fn().mockResolvedValue({
+      result: [500000000000000000n, 150000n],
+    }),
+    readContract: vi
+      .fn()
+      .mockImplementation(
+        ({ functionName, args }: { functionName: string; args: unknown[] }) => {
+          if (functionName === 'extsload')
+            return Promise.resolve(
+              '0x0000000000000000000000000000000000000000000000000000000000000000',
+            )
+          // Permit2 allowance: 3 args (owner, token, spender)
+          if (args?.length === 3) return Promise.resolve([0n, 0, 0])
+          // ERC20 allowance: 2 args (owner, spender)
+          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<UniswapSwapProviderConfig>,
+): UniswapSwapProvider {
+  const config: UniswapSwapProviderConfig = {
+    defaultSlippage: 0.005,
+    marketAllowlist: [
+      { assets: [USDC, OP], fee: 100, tickSpacing: 2, chainId: CHAIN_ID },
+    ],
+    ...configOverrides,
+  }
+  return new UniswapSwapProvider(config, createMockChainManager())
+}
+
+describe('UniswapSwapProvider', () => {
+  describe('supportedChainIds', () => {
+    it('returns Base Sepolia', () => {
+      const provider = createProvider()
+      expect(provider.supportedChainIds()).toContain(CHAIN_ID)
+    })
+  })
+
+  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: '0xwallet' as Address,
+      })
+
+      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 when allowance is insufficient', async () => {
+      const provider = createProvider()
+      const result = await provider.execute({
+        amountIn: 100,
+        assetIn: USDC,
+        assetOut: OP,
+        chainId: CHAIN_ID,
+        walletAddress: '0xwallet' as Address,
+      })
+
+      // Mock readContract returns 0n (no allowance), so approvals should be needed
+      expect(result.transactionData.tokenApproval).toBeDefined()
+      expect(result.transactionData.permit2Approval).toBeDefined()
+    })
+
+    it('throws without fee/tickSpacing in market filter', async () => {
+      const provider = createProvider({
+        marketAllowlist: [{ assets: [USDC, OP], chainId: CHAIN_ID }],
+      })
+
+      await expect(
+        provider.execute({
+          amountIn: 100,
+          assetIn: USDC,
+          assetOut: OP,
+          chainId: CHAIN_ID,
+          walletAddress: '0xwallet' as Address,
+        }),
+      ).rejects.toThrow('fee and tickSpacing must be configured')
+    })
+  })
+
+  describe('getPrice', () => {
+    it('returns price quote', async () => {
+      const provider = createProvider()
+      const price = await provider.getPrice({
+        assetIn: USDC,
+        assetOut: OP,
+        amountIn: 100,
+        chainId: CHAIN_ID,
+      })
+
+      expect(price.price).toBeDefined()
+      expect(price.amountIn).toBeDefined()
+      expect(price.amountOut).toBeDefined()
+      expect(price.route.path).toEqual([USDC, OP])
+    })
+
+    it('defaults to 1 unit when no amount specified', async () => {
+      const provider = createProvider()
+      const price = await provider.getPrice({
+        assetIn: USDC,
+        assetOut: OP,
+        chainId: CHAIN_ID,
+      })
+
+      // 1 USDC = 1000000 (6 decimals)
+      expect(price.amountInWei).toBe(1000000n)
+    })
+  })
+
+  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(100)
+      expect(markets[0].provider).toBe('uniswap')
+      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, MockWETHAsset],
+            fee: 100,
+            tickSpacing: 2,
+            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, MockWETHAsset],
+            fee: 100,
+            tickSpacing: 2,
+            chainId: CHAIN_ID,
+          },
+        ],
+      })
+      const markets = await provider.getMarkets({ asset: USDC })
+      // Only pairs containing USDC: USDC/OP, USDC/WETH
+      expect(markets).toHaveLength(2)
+      for (const market of markets) {
+        expect(market.assets).toContain(USDC)
+      }
+    })
+
+    it('skips filters without fee/tickSpacing', async () => {
+      const provider = createProvider({
+        marketAllowlist: [
+          { assets: [USDC, OP], chainId: CHAIN_ID },
+          {
+            assets: [USDC, MockWETHAsset],
+            fee: 500,
+            tickSpacing: 10,
+            chainId: CHAIN_ID,
+          },
+        ],
+      })
+      const markets = await provider.getMarkets({})
+      // Only the second filter has fee+tickSpacing
+      expect(markets).toHaveLength(1)
+      expect(markets[0].assets).toEqual([USDC, MockWETHAsset])
+    })
+
+    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],
+            fee: 100,
+            tickSpacing: 2,
+            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(100)
+      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, MockWETHAsset],
+            fee: 100,
+            tickSpacing: 2,
+            chainId: CHAIN_ID,
+          },
+        ],
+      })
+      const markets = await provider.getMarkets({})
+      // Look up each market by its poolId
+      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)
+      }
+    })
+  })
+})

package/src/swap/providers/uniswap/__tests__/sdk.test.ts

@@ -0,0 +1,370 @@
+import { type Address, type PublicClient, zeroAddress } from 'viem'
+import { describe, expect, it, vi } from 'vitest'
+
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+import type { Asset } from '@/types/asset.js'
+
+import {
+  calculatePriceImpact,
+  encodeUniversalRouterSwap,
+  getQuote,
+} from '../encoding.js'
+
+const USDC: Asset = {
+  type: 'erc20',
+  address: { 84532: '0x1111111111111111111111111111111111111111' as Address },
+  metadata: { name: 'USD Coin', symbol: 'USDC', decimals: 6 },
+}
+
+const WETH: Asset = {
+  type: 'erc20',
+  address: { 84532: '0x2222222222222222222222222222222222222222' as Address },
+  metadata: { name: 'Wrapped Ether', symbol: 'WETH', decimals: 18 },
+}
+
+const ETH: Asset = {
+  type: 'native',
+  address: { 84532: 'native' },
+  metadata: { name: 'Ethereum', symbol: 'ETH', decimals: 18 },
+}
+
+const QUOTER = '0x4a6513c898fe1b2d0e78d3b0e0a4a151589b1cba' as Address
+const POOL_MANAGER = '0x05E73354cFDd6745C338b50BcFDfA3Aa6fA03408' as Address
+const CHAIN_ID = 84532 as SupportedChainId
+const FEE = 100
+const TICK_SPACING = 2
+
+// Mock sqrtPriceX96 for a ~2000 USDC/WETH pool
+// sqrtPriceX96 = sqrt(price) * 2^96, where price = WETH/USDC adjusted for decimals
+// For 1 WETH = 2000 USDC: price(token0→token1) depends on sort order
+const MOCK_SQRT_PRICE =
+  '0x0000000000000000000000000000000000000000000000010000000000000000' as `0x${string}`
+
+function createMockPublicClient(
+  amountResult: bigint,
+  gasEstimate = 150000n,
+): PublicClient {
+  return {
+    simulateContract: vi.fn().mockResolvedValue({
+      result: [amountResult, gasEstimate],
+    }),
+    readContract: vi.fn().mockResolvedValue(MOCK_SQRT_PRICE),
+  } as unknown as PublicClient
+}
+
+describe('getQuote', () => {
+  it('returns quote for exact-in swap', async () => {
+    const publicClient = createMockPublicClient(500000000000000000n) // 0.5 WETH
+    const quote = await getQuote({
+      assetIn: USDC,
+      assetOut: WETH,
+      amountInWei: 100000000n, // 100 USDC
+      chainId: CHAIN_ID,
+      publicClient,
+      quoterAddress: QUOTER,
+      poolManagerAddress: POOL_MANAGER,
+      fee: FEE,
+      tickSpacing: TICK_SPACING,
+    })
+
+    expect(quote.amountIn).toBe(100)
+    expect(quote.amountOut).toBe(0.5)
+    expect(quote.amountInWei).toBe(100000000n)
+    expect(quote.amountOutWei).toBe(500000000000000000n)
+    expect(quote.price).toBeDefined()
+    expect(quote.priceInverse).toBeDefined()
+    expect(typeof quote.priceImpact).toBe('number')
+    expect(quote.priceImpact).toBeGreaterThanOrEqual(0)
+    expect(quote.route.path).toEqual([USDC, WETH])
+    expect(quote.route.pools).toHaveLength(1)
+    expect(quote.gasEstimate).toBe(150000n)
+
+    expect(publicClient.simulateContract).toHaveBeenCalledWith(
+      expect.objectContaining({
+        functionName: 'quoteExactInputSingle',
+      }),
+    )
+    // Should also read sqrtPriceX96 via extsload
+    expect(publicClient.readContract).toHaveBeenCalledWith(
+      expect.objectContaining({
+        address: POOL_MANAGER,
+        functionName: 'extsload',
+      }),
+    )
+  })
+
+  it('returns quote for exact-out swap', async () => {
+    const publicClient = createMockPublicClient(100000000n) // 100 USDC needed
+    const quote = await getQuote({
+      assetIn: USDC,
+      assetOut: WETH,
+      amountOutWei: 500000000000000000n, // 0.5 WETH
+      chainId: CHAIN_ID,
+      publicClient,
+      quoterAddress: QUOTER,
+      poolManagerAddress: POOL_MANAGER,
+      fee: FEE,
+      tickSpacing: TICK_SPACING,
+    })
+
+    expect(quote.amountInWei).toBe(100000000n)
+    expect(quote.amountOutWei).toBe(500000000000000000n)
+
+    expect(publicClient.simulateContract).toHaveBeenCalledWith(
+      expect.objectContaining({
+        functionName: 'quoteExactOutputSingle',
+      }),
+    )
+  })
+
+  it('sorts currency0/currency1 correctly', async () => {
+    const publicClient = createMockPublicClient(100000000n)
+    await getQuote({
+      assetIn: WETH, // higher address
+      assetOut: USDC, // lower address
+      amountInWei: 1000000000000000000n,
+      chainId: CHAIN_ID,
+      publicClient,
+      quoterAddress: QUOTER,
+      poolManagerAddress: POOL_MANAGER,
+      fee: FEE,
+      tickSpacing: TICK_SPACING,
+    })
+
+    const call = vi.mocked(publicClient.simulateContract).mock.calls[0][0]
+    const args = (call as any).args[0]
+    // currency0 should be the lower address
+    expect(
+      args.poolKey.currency0.toLowerCase() <
+        args.poolKey.currency1.toLowerCase(),
+    ).toBe(true)
+  })
+
+  it('uses address(0) for native ETH in pool key', async () => {
+    const publicClient = createMockPublicClient(100000000n)
+    await getQuote({
+      assetIn: ETH,
+      assetOut: USDC,
+      amountInWei: 1000000000000000000n,
+      chainId: CHAIN_ID,
+      publicClient,
+      quoterAddress: QUOTER,
+      poolManagerAddress: POOL_MANAGER,
+      fee: FEE,
+      tickSpacing: TICK_SPACING,
+    })
+
+    const call = vi.mocked(publicClient.simulateContract).mock.calls[0][0]
+    const args = (call as any).args[0]
+    // Native ETH should be address(0), sorted as currency0 (lowest possible address)
+    expect(args.poolKey.currency0).toBe(zeroAddress)
+  })
+
+  it('uses address(0) for native ETH as output', async () => {
+    const publicClient = createMockPublicClient(1000000000000000000n)
+    await getQuote({
+      assetIn: USDC,
+      assetOut: ETH,
+      amountInWei: 100000000n,
+      chainId: CHAIN_ID,
+      publicClient,
+      quoterAddress: QUOTER,
+      poolManagerAddress: POOL_MANAGER,
+      fee: FEE,
+      tickSpacing: TICK_SPACING,
+    })
+
+    const call = vi.mocked(publicClient.simulateContract).mock.calls[0][0]
+    const args = (call as any).args[0]
+    // Native ETH should be address(0) regardless of swap direction
+    expect(args.poolKey.currency0).toBe(zeroAddress)
+  })
+})
+
+describe('calculatePriceImpact', () => {
+  // sqrtPriceX96 for a pool where 1 USDC-wei buys 5e9 WETH-wei
+  // (100 USDC → 0.5 WETH at mid-price)
+  // Computed as: sqrt(5e9) * 2^96 ≈ 70711 * 2^96
+  const MID_SQRT_PRICE = 5602302599546145575577086272208896n
+
+  it('returns 0 when sqrtPriceX96 is 0', () => {
+    const impact = calculatePriceImpact({
+      sqrtPriceX96: 0n,
+      amountIn: 100000000n,
+      amountOut: 500000000000000000n,
+      zeroForOne: true,
+    })
+    expect(impact).toBe(0)
+  })
+
+  it('returns ~0 for a trade at mid-price', () => {
+    // 100 USDC → ~0.5 WETH, which matches the mid-price
+    const impact = calculatePriceImpact({
+      sqrtPriceX96: MID_SQRT_PRICE,
+      amountIn: 100000000n,
+      amountOut: 500000000000000000n,
+      zeroForOne: true,
+    })
+
+    // Very small due to integer sqrt rounding, but near 0
+    expect(impact).toBeLessThan(0.001)
+  })
+
+  it('returns positive impact when execution is worse than mid-price', () => {
+    // Mid-price says we should get ~0.5 WETH, but we only get 0.4 WETH
+    const impact = calculatePriceImpact({
+      sqrtPriceX96: MID_SQRT_PRICE,
+      amountIn: 100000000n,
+      amountOut: 400000000000000000n, // 0.4 WETH instead of ~0.5
+      zeroForOne: true,
+    })
+
+    // ~20% price impact
+    expect(impact).toBeGreaterThan(0.15)
+    expect(impact).toBeLessThan(0.25)
+  })
+
+  it('clamps negative impact to 0', () => {
+    // Execution was better than mid-price (got more than expected)
+    const impact = calculatePriceImpact({
+      sqrtPriceX96: MID_SQRT_PRICE,
+      amountIn: 100000000n,
+      amountOut: 600000000000000000n, // 0.6 WETH — better than ~0.5 mid
+      zeroForOne: true,
+    })
+
+    expect(impact).toBe(0)
+  })
+
+  it('works for oneForZero direction', () => {
+    // Selling WETH for USDC (oneForZero)
+    // At mid-price: 0.5 WETH should get ~100 USDC-wei worth
+    // But we only get 90 USDC → some impact
+    const impact = calculatePriceImpact({
+      sqrtPriceX96: MID_SQRT_PRICE,
+      amountIn: 500000000000000000n, // 0.5 WETH
+      amountOut: 90000000n, // 90 USDC (less than ~100)
+      zeroForOne: false,
+    })
+
+    expect(impact).toBeGreaterThan(0.05)
+    expect(impact).toBeLessThan(0.15)
+  })
+})
+
+describe('encodeUniversalRouterSwap', () => {
+  const baseQuote = {
+    price: '0.005',
+    priceInverse: '200',
+    amountIn: 100,
+    amountOut: 0.5,
+    amountInWei: 100000000n,
+    amountOutWei: 500000000000000000n,
+    priceImpact: 0.001,
+    route: { path: [USDC, WETH], pools: [] },
+    gasEstimate: 150000n,
+  }
+
+  it('encodes exact-in swap calldata', () => {
+    const calldata = encodeUniversalRouterSwap({
+      amountInWei: 100000000n,
+      assetIn: USDC,
+      assetOut: WETH,
+      slippage: 0.005,
+      deadline: 1700000000,
+      recipient: '0xrecipient' as Address,
+      chainId: CHAIN_ID,
+      quote: baseQuote,
+      universalRouterAddress: '0xrouter' as Address,
+      fee: FEE,
+      tickSpacing: TICK_SPACING,
+    })
+
+    expect(calldata).toMatch(/^0x/)
+    expect(calldata.length).toBeGreaterThan(10)
+  })
+
+  it('encodes exact-out swap calldata', () => {
+    const calldata = encodeUniversalRouterSwap({
+      amountOutWei: 500000000000000000n,
+      assetIn: USDC,
+      assetOut: WETH,
+      slippage: 0.005,
+      deadline: 1700000000,
+      recipient: '0xrecipient' as Address,
+      chainId: CHAIN_ID,
+      quote: baseQuote,
+      universalRouterAddress: '0xrouter' as Address,
+      fee: FEE,
+      tickSpacing: TICK_SPACING,
+    })
+
+    expect(calldata).toMatch(/^0x/)
+    expect(calldata.length).toBeGreaterThan(10)
+  })
+
+  it('produces different calldata for exact-in vs exact-out', () => {
+    const exactIn = encodeUniversalRouterSwap({
+      amountInWei: 100000000n,
+      assetIn: USDC,
+      assetOut: WETH,
+      slippage: 0.005,
+      deadline: 1700000000,
+      recipient: '0xrecipient' as Address,
+      chainId: CHAIN_ID,
+      quote: baseQuote,
+      universalRouterAddress: '0xrouter' as Address,
+      fee: FEE,
+      tickSpacing: TICK_SPACING,
+    })
+
+    const exactOut = encodeUniversalRouterSwap({
+      amountOutWei: 500000000000000000n,
+      assetIn: USDC,
+      assetOut: WETH,
+      slippage: 0.005,
+      deadline: 1700000000,
+      recipient: '0xrecipient' as Address,
+      chainId: CHAIN_ID,
+      quote: baseQuote,
+      universalRouterAddress: '0xrouter' as Address,
+      fee: FEE,
+      tickSpacing: TICK_SPACING,
+    })
+
+    expect(exactIn).not.toBe(exactOut)
+  })
+
+  it('applies slippage to minimum output for exact-in', () => {
+    const noSlippage = encodeUniversalRouterSwap({
+      amountInWei: 100000000n,
+      assetIn: USDC,
+      assetOut: WETH,
+      slippage: 0,
+      deadline: 1700000000,
+      recipient: '0xrecipient' as Address,
+      chainId: CHAIN_ID,
+      quote: baseQuote,
+      universalRouterAddress: '0xrouter' as Address,
+      fee: FEE,
+      tickSpacing: TICK_SPACING,
+    })
+
+    const withSlippage = encodeUniversalRouterSwap({
+      amountInWei: 100000000n,
+      assetIn: USDC,
+      assetOut: WETH,
+      slippage: 0.05, // 5%
+      deadline: 1700000000,
+      recipient: '0xrecipient' as Address,
+      chainId: CHAIN_ID,
+      quote: baseQuote,
+      universalRouterAddress: '0xrouter' as Address,
+      fee: FEE,
+      tickSpacing: TICK_SPACING,
+    })
+
+    // Different slippage should produce different calldata
+    expect(noSlippage).not.toBe(withSlippage)
+  })
+})