@eth-optimism/actions-sdk 0.2.0 → 0.4.0

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

@@ -0,0 +1,369 @@
+import { type Address, type PublicClient, zeroAddress } from 'viem'
+import { describe, expect, it, vi } from 'vitest'
+
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+import {
+  calculatePriceImpact,
+  encodeUniversalRouterSwap,
+  getQuote,
+} from '@/swap/providers/uniswap/encoding.js'
+import type { Asset } from '@/types/asset.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,
+      amountInRaw: 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.amountInRaw).toBe(100000000n)
+    expect(quote.amountOutRaw).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,
+      amountOutRaw: 500000000000000000n, // 0.5 WETH
+      chainId: CHAIN_ID,
+      publicClient,
+      quoterAddress: QUOTER,
+      poolManagerAddress: POOL_MANAGER,
+      fee: FEE,
+      tickSpacing: TICK_SPACING,
+    })
+
+    expect(quote.amountInRaw).toBe(100000000n)
+    expect(quote.amountOutRaw).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
+      amountInRaw: 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,
+      amountInRaw: 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,
+      amountInRaw: 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,
+    amountInRaw: 100000000n,
+    amountOutRaw: 500000000000000000n,
+    priceImpact: 0.001,
+    route: { path: [USDC, WETH], pools: [] },
+    gasEstimate: 150000n,
+  }
+
+  it('encodes exact-in swap calldata', () => {
+    const calldata = encodeUniversalRouterSwap({
+      amountInRaw: 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({
+      amountOutRaw: 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({
+      amountInRaw: 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({
+      amountOutRaw: 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({
+      amountInRaw: 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({
+      amountInRaw: 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)
+  })
+})

package/src/swap/providers/uniswap/abis.ts

@@ -0,0 +1,144 @@
+/**
+ * PoolKey tuple components (shared across V4 ABI definitions)
+ */
+const POOL_KEY_COMPONENTS = [
+  { name: 'currency0', type: 'address' },
+  { name: 'currency1', type: 'address' },
+  { name: 'fee', type: 'uint24' },
+  { name: 'tickSpacing', type: 'int24' },
+  { name: 'hooks', type: 'address' },
+] as const
+
+/**
+ * V4 Quoter ABI (subset for quoting)
+ * @see https://docs.uniswap.org/contracts/v4/reference/periphery/interfaces/IQuoter
+ */
+export const QUOTER_ABI = [
+  {
+    name: 'quoteExactInputSingle',
+    type: 'function',
+    stateMutability: 'nonpayable',
+    inputs: [
+      {
+        name: 'params',
+        type: 'tuple',
+        components: [
+          { name: 'poolKey', type: 'tuple', components: POOL_KEY_COMPONENTS },
+          { name: 'zeroForOne', type: 'bool' },
+          { name: 'exactAmount', type: 'uint128' },
+          { name: 'hookData', type: 'bytes' },
+        ],
+      },
+    ],
+    outputs: [
+      { name: 'amountOut', type: 'uint256' },
+      { name: 'gasEstimate', type: 'uint256' },
+    ],
+  },
+  {
+    name: 'quoteExactOutputSingle',
+    type: 'function',
+    stateMutability: 'nonpayable',
+    inputs: [
+      {
+        name: 'params',
+        type: 'tuple',
+        components: [
+          { name: 'poolKey', type: 'tuple', components: POOL_KEY_COMPONENTS },
+          { name: 'zeroForOne', type: 'bool' },
+          { name: 'exactAmount', type: 'uint128' },
+          { name: 'hookData', type: 'bytes' },
+        ],
+      },
+    ],
+    outputs: [
+      { name: 'amountIn', type: 'uint256' },
+      { name: 'gasEstimate', type: 'uint256' },
+    ],
+  },
+] as const
+
+/**
+ * Universal Router ABI (subset for swaps)
+ * @see https://docs.uniswap.org/contracts/v4/reference/periphery/UniversalRouter
+ */
+export const UNIVERSAL_ROUTER_ABI = [
+  {
+    name: 'execute',
+    type: 'function',
+    stateMutability: 'payable',
+    inputs: [
+      { name: 'commands', type: 'bytes' },
+      { name: 'inputs', type: 'bytes[]' },
+      { name: 'deadline', type: 'uint256' },
+    ],
+    outputs: [],
+  },
+] as const
+
+/** ABI type for ExactInputSingleParams */
+export const EXACT_INPUT_SINGLE_PARAMS = [
+  {
+    type: 'tuple',
+    components: [
+      {
+        name: 'poolKey',
+        type: 'tuple',
+        components: [...POOL_KEY_COMPONENTS],
+      },
+      { name: 'zeroForOne', type: 'bool' },
+      { name: 'amountIn', type: 'uint128' },
+      { name: 'amountOutMinimum', type: 'uint128' },
+      { name: 'hookData', type: 'bytes' },
+    ],
+  },
+] as const
+
+/** ABI type for ExactOutputSingleParams */
+export const EXACT_OUTPUT_SINGLE_PARAMS = [
+  {
+    type: 'tuple',
+    components: [
+      {
+        name: 'poolKey',
+        type: 'tuple',
+        components: [...POOL_KEY_COMPONENTS],
+      },
+      { name: 'zeroForOne', type: 'bool' },
+      { name: 'amountOut', type: 'uint128' },
+      { name: 'amountInMaximum', type: 'uint128' },
+      { name: 'hookData', type: 'bytes' },
+    ],
+  },
+] as const
+
+/** ABI type for SETTLE_ALL / TAKE_ALL params */
+export const CURRENCY_AMOUNT_PARAMS = [
+  { type: 'address' },
+  { type: 'uint256' },
+] as const
+
+/**
+ * PoolManager extsload ABI — reads arbitrary storage slots via SLOAD
+ * @see https://docs.uniswap.org/contracts/v4/guides/read-pool-state
+ */
+export const EXTSLOAD_ABI = [
+  {
+    name: 'extsload',
+    type: 'function',
+    stateMutability: 'view',
+    inputs: [{ name: 'slot', type: 'bytes32' }],
+    outputs: [{ type: 'bytes32' }],
+  },
+] as const
+
+/**
+ * PoolKey ABI encoding type for computing PoolId
+ */
+export const POOL_KEY_ABI_TYPE = [
+  { name: 'currency0', type: 'address' },
+  { name: 'currency1', type: 'address' },
+  { name: 'fee', type: 'uint24' },
+  { name: 'tickSpacing', type: 'int24' },
+  { name: 'hooks', type: 'address' },
+] as const

package/src/swap/providers/uniswap/addresses.ts

@@ -0,0 +1,110 @@
+import type { Address } from 'viem'
+import {
+  base,
+  baseSepolia,
+  mainnet,
+  optimism,
+  sepolia,
+  unichain,
+  unichainSepolia,
+  worldchain,
+} from 'viem/chains'
+
+import { PERMIT2_ADDRESS } from '@/constants/contracts.js'
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+
+/**
+ * Uniswap contract addresses
+ */
+export interface UniswapAddresses {
+  poolManager: Address
+  positionManager: Address
+  universalRouter: Address
+  quoter: Address
+  permit2: Address
+}
+
+/**
+ * Uniswap V4 contract addresses per chain
+ * @see https://docs.uniswap.org/contracts/v4/deployments
+ */
+export const UNISWAP_ADDRESSES: Partial<
+  Record<SupportedChainId, UniswapAddresses>
+> = {
+  [mainnet.id]: {
+    poolManager: '0x000000000004444c5dc75cB358380D2e3dE08A90',
+    positionManager: '0xbd216513d74c8cf14cf4747e6aaa6420ff64ee9e',
+    universalRouter: '0x66a9893cc07d91d95644aedd05d03f95e1dba8af',
+    quoter: '0x52f0e24d1c21c8a0cb1e5a5dd6198556bd9e1203',
+    permit2: PERMIT2_ADDRESS,
+  },
+  [optimism.id]: {
+    poolManager: '0x9a13f98cb987694c9f086b1f5eb990eea8264ec3',
+    positionManager: '0x3c3ea4b57a46241e54610e5f022e5c45859a1017',
+    universalRouter: '0x851116d9223fabed8e56c0e6b8ad0c31d98b3507',
+    quoter: '0x1f3131a13296fb91c90870043742c3cdbff1a8d7',
+    permit2: PERMIT2_ADDRESS,
+  },
+  [base.id]: {
+    poolManager: '0x498581ff718922c3f8e6a244956af099b2652b2b',
+    positionManager: '0x7c5f5a4bbd8fd63184577525326123b519429bdc',
+    universalRouter: '0x6ff5693b99212da76ad316178a184ab56d299b43',
+    quoter: '0x0d5e0f971ed27fbff6c2837bf31316121532048d',
+    permit2: PERMIT2_ADDRESS,
+  },
+  [unichain.id]: {
+    poolManager: '0x1f98400000000000000000000000000000000004',
+    positionManager: '0x4529a01c7a0410167c5740c487a8de60232617bf',
+    universalRouter: '0xef740bf23acae26f6492b10de645d6b98dc8eaf3',
+    quoter: '0x333e3c607b141b18ff6de9f258db6e77fe7491e0',
+    permit2: PERMIT2_ADDRESS,
+  },
+  [worldchain.id]: {
+    poolManager: '0xb1860d529182ac3bc1f51fa2abd56662b7d13f33',
+    positionManager: '0xc585e0f504613b5fbf874f21af14c65260fb41fa',
+    universalRouter: '0x8ac7bee993bb44dab564ea4bc9ea67bf9eb5e743',
+    quoter: '0x55d235b3ff2daf7c3ede0defc9521f1d6fe6c5c0',
+    permit2: PERMIT2_ADDRESS,
+  },
+  [sepolia.id]: {
+    poolManager: '0xE03A1074c86CFeDd5C142C4F04F1a1536e203543',
+    positionManager: '0x429ba70129df741B2Ca2a85BC3A2a3328e5c09b4',
+    universalRouter: '0x3A9D48AB9751398BbFa63ad67599Bb04e4BdF98b',
+    quoter: '0x61b3f2011a92d183c7dbadbda940a7555ccf9227',
+    permit2: PERMIT2_ADDRESS,
+  },
+  [baseSepolia.id]: {
+    poolManager: '0x05E73354cFDd6745C338b50BcFDfA3Aa6fA03408',
+    positionManager: '0x4b2c77d209d3405f41a037ec6c77f7f5b8e2ca80',
+    universalRouter: '0x492e6456d9528771018deb9e87ef7750ef184104',
+    quoter: '0x4a6513c898fe1b2d0e78d3b0e0a4a151589b1cba',
+    permit2: PERMIT2_ADDRESS,
+  },
+  [unichainSepolia.id]: {
+    poolManager: '0x00b036b58a818b1bc34d502d3fe730db729e62ac',
+    positionManager: '0xf969aee60879c54baaed9f3ed26147db216fd664',
+    universalRouter: '0xf70536b3bcc1bd1a972dc186a2cf84cc6da6be5d',
+    quoter: '0x56dcd40a3f2d466f48e7f48bdbe5cc9b92ae4472',
+    permit2: PERMIT2_ADDRESS,
+  },
+}
+
+/**
+ * Get Uniswap contract addresses for a chain
+ */
+export function getUniswapAddresses(
+  chainId: SupportedChainId,
+): UniswapAddresses {
+  const addresses = UNISWAP_ADDRESSES[chainId]
+  if (!addresses) {
+    throw new Error(`Uniswap not supported on chain ${chainId}`)
+  }
+  return addresses
+}
+
+/**
+ * Get supported chain IDs for Uniswap
+ */
+export function getSupportedChainIds(): SupportedChainId[] {
+  return Object.keys(UNISWAP_ADDRESSES).map(Number) as SupportedChainId[]
+}