@eth-optimism/actions-sdk 0.2.0 → 0.4.0

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

@@ -0,0 +1,224 @@
+import { formatUnits } from 'viem'
+
+import { VELODROME } from '@/constants/providers.js'
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+import { expandMarkets, findMarket } from '@/swap/core/markets.js'
+import { SwapProvider } from '@/swap/core/SwapProvider.js'
+import {
+  getChainConfig,
+  getSupportedChainIds,
+  getValidMarketConfigs,
+} from '@/swap/providers/velodrome/config.js'
+import {
+  buildTokenApproval,
+  encodePoolSwap,
+  fetchPoolQuote,
+} from '@/swap/providers/velodrome/encoding/index.js'
+import {
+  configToMarkets,
+  resolvePoolConfig,
+} from '@/swap/providers/velodrome/markets.js'
+import type {
+  VelodromeMarketConfig,
+  VelodromeSwapProviderConfig,
+} from '@/swap/providers/velodrome/types.js'
+import type { Asset } from '@/types/asset.js'
+import type {
+  GetSwapMarketParams,
+  GetSwapMarketsParams,
+  ResolvedSwapParams,
+  SwapMarket,
+  SwapQuote,
+  SwapQuoteParams,
+  SwapTransaction,
+} from '@/types/swap/index.js'
+import { getAssetAddress, isNativeAsset } from '@/utils/assets.js'
+
+/**
+ * Velodrome/Aerodrome swap provider for OP Stack chains.
+ * Supports v2 AMM pools, CL/Slipstream concentrated liquidity pools,
+ * v2 routers (Optimism, Base), leaf routers (Relay chains), and Universal Router (Base Sepolia).
+ */
+export class VelodromeSwapProvider extends SwapProvider<VelodromeSwapProviderConfig> {
+  /** @returns Chain IDs where Velodrome/Aerodrome contracts are deployed */
+  protocolSupportedChainIds(): SupportedChainId[] {
+    return getSupportedChainIds()
+  }
+
+  /**
+   * Build a swap transaction from raw parameters.
+   * @param params - Resolved swap parameters (amounts as raw bigint, defaults applied)
+   * @returns Transaction data ready for wallet execution
+   * @throws If amountOut is provided (Velodrome only supports exact-input swaps)
+   */
+  protected async _execute(
+    params: ResolvedSwapParams,
+  ): Promise<SwapTransaction> {
+    if (params.amountOutRaw !== undefined) {
+      throw new Error(
+        'Velodrome/Aerodrome does not support exact-output swaps. Provide amountIn instead of amountOut.',
+      )
+    }
+
+    const swapQuote = await this._getQuote({
+      assetIn: params.assetIn,
+      assetOut: params.assetOut,
+      amountIn: params.amountInRaw
+        ? parseFloat(
+            formatUnits(params.amountInRaw, params.assetIn.metadata.decimals),
+          )
+        : undefined,
+      chainId: params.chainId,
+      slippage: params.slippage,
+      deadline: params.deadline,
+      recipient: params.recipient,
+    })
+    return this.buildSwapTransactions(swapQuote)
+  }
+
+  /**
+   * Find a specific market by poolId from the allowlist.
+   * @param params - Pool ID and chain to look up
+   * @returns Matching market
+   * @throws If no matching market found in config
+   */
+  protected async _getMarket(params: GetSwapMarketParams): Promise<SwapMarket> {
+    return findMarket(
+      getValidMarketConfigs(this._config.marketAllowlist),
+      params.chainId,
+      params.poolId,
+      configToMarkets,
+    )
+  }
+
+  /**
+   * Expand the market allowlist into concrete SwapMarket objects.
+   * @param params - Optional filters (chainId, asset)
+   * @returns All configured markets matching the filters
+   */
+  protected async _getMarkets(
+    params: GetSwapMarketsParams,
+  ): Promise<SwapMarket[]> {
+    return expandMarkets({
+      configs: getValidMarketConfigs(this._config.marketAllowlist),
+      filters: params,
+      supportedChainIds: this.supportedChainIds(),
+      toMarkets: configToMarkets,
+    })
+  }
+
+  /**
+   * Get a full swap quote with pricing, slippage bounds, and pre-built execution data.
+   * @param params - Quote parameters (assets, amounts, chain, slippage, deadline)
+   * @returns SwapQuote with amounts, price, route, and encoded calldata
+   * @throws If amountOut is provided (Velodrome only supports exact-input)
+   */
+  protected async _getQuote(params: SwapQuoteParams): Promise<SwapQuote> {
+    const { chainId, assetIn, assetOut } = params
+
+    if (params.amountOut !== undefined) {
+      throw new Error(
+        'Velodrome/Aerodrome does not support exact-output swaps. Provide amountIn instead of amountOut.',
+      )
+    }
+
+    const chain = getChainConfig(chainId)
+    const publicClient = this.chainManager.getPublicClient(chainId)
+    const poolConfig = this.resolveVelodromeMarketConfig(
+      assetIn,
+      assetOut,
+      chainId,
+    )
+    const { slippage, now, deadline, recipient, amountInRaw } =
+      this.resolveQuoteDefaults(params)
+
+    const { internalQuote, providerContext } = await fetchPoolQuote(
+      poolConfig,
+      { assetIn, assetOut, amountInRaw, chainId, publicClient, chain },
+    )
+
+    const { amountOutMinRaw, amountOutMin } = this.computeSlippageBounds(
+      internalQuote.amountOutRaw,
+      slippage,
+      assetOut,
+    )
+
+    const swapCalldata = encodePoolSwap(poolConfig, {
+      assetIn,
+      assetOut,
+      amountInRaw,
+      amountOutMinRaw,
+      recipient,
+      deadline,
+      chainId,
+      chain,
+    })
+
+    return {
+      assetIn,
+      assetOut,
+      chainId,
+      amountIn: internalQuote.amountIn,
+      amountInRaw,
+      amountOut: internalQuote.amountOut,
+      amountOutRaw: internalQuote.amountOutRaw,
+      amountOutMin,
+      amountOutMinRaw,
+      price: internalQuote.amountOut / internalQuote.amountIn,
+      priceInverse: internalQuote.amountIn / internalQuote.amountOut,
+      priceImpact: internalQuote.priceImpact,
+      route: internalQuote.route,
+      execution: {
+        swapCalldata,
+        routerAddress: chain.contracts.router,
+        value: isNativeAsset(assetIn) ? amountInRaw : 0n,
+        providerContext,
+      },
+      provider: VELODROME,
+      slippage,
+      deadline,
+      quotedAt: now,
+      expiresAt: deadline,
+      gasEstimate: internalQuote.gasEstimate,
+      quotedRecipient: recipient,
+    }
+  }
+
+  protected async _buildApprovals(quote: SwapQuote) {
+    const chain = getChainConfig(quote.chainId)
+    const publicClient = this.chainManager.getPublicClient(quote.chainId)
+
+    const tokenApproval = isNativeAsset(quote.assetIn)
+      ? undefined
+      : await buildTokenApproval(
+          getAssetAddress(quote.assetIn, quote.chainId),
+          chain.contracts.router,
+          chain.metadata.routerType,
+          quote.amountInRaw,
+          quote.recipient!,
+          publicClient,
+        )
+
+    return { tokenApproval }
+  }
+
+  /**
+   * Resolve market config to a discriminated pool config.
+   * @throws If pair not in allowlist, or has both/neither stable and tickSpacing
+   */
+  private resolveVelodromeMarketConfig(
+    assetIn: Asset,
+    assetOut: Asset,
+    chainId: SupportedChainId,
+  ) {
+    const config = this.resolveMarketConfig(assetIn, assetOut, chainId) as
+      | VelodromeMarketConfig
+      | undefined
+    if (!config) {
+      throw new Error(
+        `No market config for pair ${assetIn.metadata.symbol}/${assetOut.metadata.symbol}`,
+      )
+    }
+    return resolvePoolConfig(config)
+  }
+}

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