@eth-optimism/actions-sdk 0.2.0 → 0.4.0

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

@@ -0,0 +1,217 @@
+import { formatUnits } from 'viem'
+
+import { UNISWAP } 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 {
+  getSupportedChainIds,
+  getUniswapAddresses,
+} from '@/swap/providers/uniswap/addresses.js'
+import {
+  encodeUniversalRouterSwap,
+  getQuote,
+} from '@/swap/providers/uniswap/encoding.js'
+import {
+  configToMarkets,
+  getValidMarketConfigs,
+} from '@/swap/providers/uniswap/markets.js'
+import type {
+  UniswapMarketConfig,
+  UniswapSwapProviderConfig,
+} from '@/swap/providers/uniswap/types.js'
+import type { Asset } from '@/types/asset.js'
+import type {
+  GetSwapMarketParams,
+  GetSwapMarketsParams,
+  ResolvedSwapParams,
+  SwapMarket,
+  SwapQuote,
+  SwapQuoteParams,
+  SwapTransaction,
+} from '@/types/swap/index.js'
+import { isNativeAsset, parseAssetAmount } from '@/utils/assets.js'
+
+/**
+ * Uniswap V4 swap provider using Universal Router and Permit2 approvals.
+ */
+export class UniswapSwapProvider extends SwapProvider<UniswapSwapProviderConfig> {
+  protocolSupportedChainIds(): SupportedChainId[] {
+    return getSupportedChainIds()
+  }
+
+  protected async _execute(
+    params: ResolvedSwapParams,
+  ): Promise<SwapTransaction> {
+    const swapQuote = await this._getQuote({
+      assetIn: params.assetIn,
+      assetOut: params.assetOut,
+      amountIn: params.amountInRaw
+        ? parseFloat(
+            formatUnits(params.amountInRaw, params.assetIn.metadata.decimals),
+          )
+        : undefined,
+      amountOut: params.amountOutRaw
+        ? parseFloat(
+            formatUnits(params.amountOutRaw, params.assetOut.metadata.decimals),
+          )
+        : undefined,
+      chainId: params.chainId,
+      slippage: params.slippage,
+      deadline: params.deadline,
+      recipient: params.recipient,
+    })
+    return this.buildSwapTransactions(swapQuote)
+  }
+
+  protected async _buildApprovals(quote: SwapQuote) {
+    const addresses = getUniswapAddresses(quote.chainId)
+
+    return this.buildPermit2Approvals(
+      {
+        assetIn: quote.assetIn,
+        assetOut: quote.assetOut,
+        slippage: quote.slippage,
+        deadline: quote.deadline,
+        recipient: quote.recipient!,
+        walletAddress: quote.recipient!,
+        chainId: quote.chainId,
+        amountInRaw: quote.amountInRaw,
+      },
+      quote.amountInRaw,
+      addresses.permit2,
+      addresses.universalRouter,
+    )
+  }
+
+  protected async _getQuote(params: SwapQuoteParams): Promise<SwapQuote> {
+    const { chainId, assetIn, assetOut } = params
+    const addresses = getUniswapAddresses(chainId)
+    const publicClient = this.chainManager.getPublicClient(chainId)
+    const marketConfig = this.resolveUniswapConfig(assetIn, assetOut, chainId)
+
+    const { slippage, now, deadline, recipient, amountInRaw } =
+      this.resolveQuoteDefaults(params)
+    const amountOutRaw = parseAssetAmount(assetOut, params.amountOut)
+
+    const quote = await getQuote({
+      assetIn,
+      assetOut,
+      amountInRaw: amountOutRaw ? undefined : amountInRaw,
+      amountOutRaw,
+      chainId,
+      publicClient,
+      quoterAddress: addresses.quoter,
+      poolManagerAddress: addresses.poolManager,
+      fee: marketConfig.fee,
+      tickSpacing: marketConfig.tickSpacing,
+    })
+
+    const swapCalldata = encodeUniversalRouterSwap({
+      amountInRaw: amountOutRaw ? undefined : amountInRaw,
+      amountOutRaw,
+      assetIn,
+      assetOut,
+      slippage,
+      deadline,
+      recipient,
+      chainId,
+      quote,
+      universalRouterAddress: addresses.universalRouter,
+      fee: marketConfig.fee,
+      tickSpacing: marketConfig.tickSpacing,
+    })
+
+    const finalAmountInRaw = amountOutRaw ? quote.amountInRaw : amountInRaw
+
+    const { amountOutMinRaw, amountOutMin } = this.computeSlippageBounds(
+      quote.amountOutRaw,
+      slippage,
+      assetOut,
+    )
+
+    return {
+      assetIn,
+      assetOut,
+      chainId,
+      amountIn: quote.amountIn,
+      amountInRaw: finalAmountInRaw,
+      amountOut: quote.amountOut,
+      amountOutRaw: quote.amountOutRaw,
+      amountOutMin,
+      amountOutMinRaw,
+      price: quote.amountOut / quote.amountIn,
+      priceInverse: quote.amountIn / quote.amountOut,
+      priceImpact: quote.priceImpact,
+      route: quote.route,
+      execution: {
+        swapCalldata,
+        routerAddress: addresses.universalRouter,
+        value: isNativeAsset(assetIn) ? (amountInRaw ?? 0n) : 0n,
+        providerContext: {
+          fee: marketConfig.fee,
+          tickSpacing: marketConfig.tickSpacing,
+          permit2Address: addresses.permit2,
+        },
+      },
+      provider: UNISWAP,
+      slippage,
+      deadline,
+      quotedAt: now,
+      expiresAt: deadline,
+      gasEstimate: quote.gasEstimate,
+      quotedRecipient: recipient,
+    }
+  }
+
+  /**
+   * 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,
+    })
+  }
+
+  /**
+   * Resolve and validate Uniswap market config for a pair.
+   * @throws If pair not in allowlist or missing fee/tickSpacing
+   */
+  private resolveUniswapConfig(
+    assetIn: Asset,
+    assetOut: Asset,
+    chainId: SupportedChainId,
+  ): UniswapMarketConfig & { fee: number; tickSpacing: number } {
+    const config = this.resolveMarketConfig(assetIn, assetOut, chainId) as
+      | UniswapMarketConfig
+      | undefined
+    if (config?.fee === undefined || config?.tickSpacing === undefined) {
+      throw new Error(
+        `fee and tickSpacing must be configured for pair ${assetIn.metadata.symbol}/${assetOut.metadata.symbol}`,
+      )
+    }
+    return config as UniswapMarketConfig & { fee: number; tickSpacing: number }
+  }
+}

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 { UniswapSwapProviderConfig } from '@/swap/providers/uniswap/types.js'
+import { UniswapSwapProvider } from '@/swap/providers/uniswap/UniswapSwapProvider.js'
+import type { Asset } from '@/types/asset.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('getQuote', () => {
+    it('returns swap quote', 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.route.path).toEqual([USDC, OP])
+      expect(quote.execution).toBeDefined()
+    })
+
+    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)
+    })
+  })
+
+  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)
+      }
+    })
+  })
+})