@eth-optimism/actions-sdk 0.2.0 → 0.3.0

package/src/swap/namespaces/__tests__/BaseSwapNamespace.spec.ts

@@ -0,0 +1,138 @@
+import { describe, expect, it } from 'vitest'
+
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+import {
+  createMockSwapProvider,
+  MockSwapProvider,
+} from '@/swap/__mocks__/MockSwapProvider.js'
+import { ActionsSwapNamespace } from '@/swap/namespaces/ActionsSwapNamespace.js'
+
+describe('BaseSwapNamespace', () => {
+  const USDC = {
+    type: 'erc20' as const,
+    address: { 84532: '0x036CbD53842c5426634e7929541eC2318f3dCF7e' as const },
+    metadata: { name: 'USD Coin', symbol: 'USDC', decimals: 6 },
+  }
+  const ETH = {
+    type: 'native' as const,
+    address: { 84532: '0x0000000000000000000000000000000000000000' as const },
+    metadata: { name: 'Ether', symbol: 'ETH', decimals: 18 },
+  }
+
+  describe('price', () => {
+    it('delegates to provider getPrice', async () => {
+      const provider = createMockSwapProvider()
+      const namespace = new ActionsSwapNamespace({ uniswap: provider })
+
+      const result = await namespace.price({
+        assetIn: USDC,
+        assetOut: ETH,
+        amountIn: 100,
+        chainId: 84532 as SupportedChainId,
+      })
+
+      expect(provider.mockGetPrice).toHaveBeenCalledTimes(1)
+      expect(result.price).toBe('1.5')
+    })
+
+    it('throws if no provider configured', async () => {
+      const namespace = new ActionsSwapNamespace({})
+
+      await expect(
+        namespace.price({
+          assetIn: USDC,
+          assetOut: ETH,
+          amountIn: 100,
+          chainId: 84532 as SupportedChainId,
+        }),
+      ).rejects.toThrow('No swap provider configured')
+    })
+  })
+
+  describe('getMarket', () => {
+    it('delegates to provider getMarket', async () => {
+      const provider = createMockSwapProvider()
+      const namespace = new ActionsSwapNamespace({ uniswap: provider })
+
+      const result = await namespace.getMarket({
+        poolId: '0xpool123',
+        chainId: 84532 as SupportedChainId,
+      })
+
+      expect(provider.mockGetMarket).toHaveBeenCalledTimes(1)
+      expect(result.marketId.poolId).toBe('0xpool123')
+    })
+  })
+
+  describe('getMarkets', () => {
+    it('aggregates markets from all providers', async () => {
+      const provider1 = createMockSwapProvider()
+      const provider2 = new MockSwapProvider(undefined, {
+        supportedChains: [84532 as SupportedChainId],
+      })
+
+      const namespace = new ActionsSwapNamespace({
+        uniswap: provider1,
+      })
+
+      // Add second provider manually for testing aggregation
+      ;(namespace as any).providers.oneInch = provider2
+
+      const result = await namespace.getMarkets({})
+
+      expect(result.length).toBeGreaterThanOrEqual(1)
+      expect(provider1.mockGetMarkets).toHaveBeenCalledTimes(1)
+      expect(provider2.mockGetMarkets).toHaveBeenCalledTimes(1)
+    })
+
+    it('returns empty array when no providers', async () => {
+      const namespace = new ActionsSwapNamespace({})
+
+      const result = await namespace.getMarkets({})
+
+      expect(result).toEqual([])
+    })
+  })
+
+  describe('supportedChainIds', () => {
+    it('returns union of chains from all providers', () => {
+      const provider1 = createMockSwapProvider(undefined, {
+        supportedChains: [84532 as SupportedChainId],
+      })
+      const provider2 = new MockSwapProvider(undefined, {
+        supportedChains: [1 as SupportedChainId, 10 as SupportedChainId],
+      })
+
+      const namespace = new ActionsSwapNamespace({
+        uniswap: provider1,
+      })
+      ;(namespace as any).providers.oneInch = provider2
+
+      const result = namespace.supportedChainIds()
+
+      expect(result).toContain(84532)
+      expect(result).toContain(1)
+      expect(result).toContain(10)
+      expect(result.length).toBe(3)
+    })
+
+    it('deduplicates chain IDs', () => {
+      const provider1 = createMockSwapProvider(undefined, {
+        supportedChains: [84532 as SupportedChainId, 1 as SupportedChainId],
+      })
+      const provider2 = new MockSwapProvider(undefined, {
+        supportedChains: [1 as SupportedChainId],
+      })
+
+      const namespace = new ActionsSwapNamespace({
+        uniswap: provider1,
+      })
+      ;(namespace as any).providers.oneInch = provider2
+
+      const result = namespace.supportedChainIds()
+
+      // Should have unique values only
+      expect(new Set(result).size).toBe(result.length)
+    })
+  })
+})

package/src/swap/namespaces/__tests__/WalletSwapNamespace.spec.ts

@@ -0,0 +1,162 @@
+import type { Address } from 'viem'
+import { describe, expect, it, vi } from 'vitest'
+
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+import { createMockSwapProvider } from '@/swap/__mocks__/MockSwapProvider.js'
+import { WalletSwapNamespace } from '@/swap/namespaces/WalletSwapNamespace.js'
+import type { Wallet } from '@/wallet/core/wallets/abstract/Wallet.js'
+
+describe('WalletSwapNamespace', () => {
+  const USDC = {
+    type: 'erc20' as const,
+    address: { 84532: '0x036CbD53842c5426634e7929541eC2318f3dCF7e' as const },
+    metadata: { name: 'USD Coin', symbol: 'USDC', decimals: 6 },
+  }
+  const ETH = {
+    type: 'native' as const,
+    address: { 84532: '0x0000000000000000000000000000000000000000' as const },
+    metadata: { name: 'Ether', symbol: 'ETH', decimals: 18 },
+  }
+
+  const mockWalletAddress =
+    '0x1234567890123456789012345678901234567890' as Address
+
+  function createMockWallet(): Wallet {
+    return {
+      address: mockWalletAddress,
+      send: vi.fn().mockResolvedValue({ transactionHash: '0xtx1' }),
+      sendBatch: vi.fn().mockResolvedValue({ transactionHash: '0xtx2' }),
+    } as unknown as Wallet
+  }
+
+  describe('execute', () => {
+    it('executes swap with single transaction', async () => {
+      const provider = createMockSwapProvider()
+      const wallet = createMockWallet()
+      const namespace = new WalletSwapNamespace({ uniswap: provider }, wallet)
+
+      const result = await namespace.execute({
+        amountIn: 100,
+        assetIn: USDC,
+        assetOut: ETH,
+        chainId: 84532 as SupportedChainId,
+      })
+
+      expect(provider.mockExecute).toHaveBeenCalledTimes(1)
+      expect(wallet.send).toHaveBeenCalledTimes(1)
+      expect(wallet.sendBatch).not.toHaveBeenCalled()
+      expect(result.price).toBe('1.5')
+      expect(result.assetIn).toBe(USDC)
+      expect(result.assetOut).toBe(ETH)
+    })
+
+    it('batches transactions when approvals needed', async () => {
+      const provider = createMockSwapProvider()
+      const wallet = createMockWallet()
+      const namespace = new WalletSwapNamespace({ uniswap: provider }, wallet)
+
+      // Override mock to return transaction with approvals
+      provider.mockExecute.mockResolvedValueOnce({
+        amountIn: 100,
+        amountOut: 1.5,
+        amountInWei: 100000000n,
+        amountOutWei: 1500000000000000000n,
+        assetIn: USDC,
+        assetOut: ETH,
+        price: '1.5',
+        priceImpact: 0.001,
+        transactionData: {
+          tokenApproval: {
+            to: '0xpermit2' as Address,
+            data: '0xapprove' as `0x${string}`,
+            value: 0n,
+          },
+          permit2Approval: {
+            to: '0xpermit2' as Address,
+            data: '0xpermit' as `0x${string}`,
+            value: 0n,
+          },
+          swap: {
+            to: '0xrouter' as Address,
+            data: '0xswap' as `0x${string}`,
+            value: 0n,
+          },
+        },
+      })
+
+      await namespace.execute({
+        amountIn: 100,
+        assetIn: USDC,
+        assetOut: ETH,
+        chainId: 84532 as SupportedChainId,
+      })
+
+      expect(wallet.sendBatch).toHaveBeenCalledTimes(1)
+      expect(wallet.send).not.toHaveBeenCalled()
+
+      // Verify all 3 transactions were batched
+      const batchCall = vi.mocked(wallet.sendBatch).mock.calls[0]
+      expect(batchCall[0]).toHaveLength(3)
+    })
+
+    it('passes wallet address to provider', async () => {
+      const provider = createMockSwapProvider()
+      const wallet = createMockWallet()
+      const namespace = new WalletSwapNamespace({ uniswap: provider }, wallet)
+
+      await namespace.execute({
+        amountIn: 100,
+        assetIn: USDC,
+        assetOut: ETH,
+        chainId: 84532 as SupportedChainId,
+      })
+
+      expect(provider.mockExecute).toHaveBeenCalledWith(
+        expect.objectContaining({
+          walletAddress: mockWalletAddress,
+        }),
+      )
+    })
+
+    it('throws when no provider configured', async () => {
+      const wallet = createMockWallet()
+      const namespace = new WalletSwapNamespace({}, wallet)
+
+      await expect(
+        namespace.execute({
+          amountIn: 100,
+          assetIn: USDC,
+          assetOut: ETH,
+          chainId: 84532 as SupportedChainId,
+        }),
+      ).rejects.toThrow('No swap provider configured')
+    })
+  })
+
+  describe('inherits read-only methods', () => {
+    it('has price method from BaseSwapNamespace', async () => {
+      const provider = createMockSwapProvider()
+      const wallet = createMockWallet()
+      const namespace = new WalletSwapNamespace({ uniswap: provider }, wallet)
+
+      const result = await namespace.price({
+        assetIn: USDC,
+        assetOut: ETH,
+        amountIn: 100,
+        chainId: 84532 as SupportedChainId,
+      })
+
+      expect(result.price).toBe('1.5')
+    })
+
+    it('has getMarkets method from BaseSwapNamespace', async () => {
+      const provider = createMockSwapProvider()
+      const wallet = createMockWallet()
+      const namespace = new WalletSwapNamespace({ uniswap: provider }, wallet)
+
+      const result = await namespace.getMarkets({})
+
+      expect(result.length).toBeGreaterThanOrEqual(1)
+    })
+  })
+})

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

@@ -0,0 +1,304 @@
+import { type Address, encodeAbiParameters, formatUnits, keccak256 } from 'viem'
+
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+import { SwapProvider } from '@/swap/core/SwapProvider.js'
+import { POOL_KEY_ABI_TYPE } from '@/swap/providers/uniswap/abis.js'
+import {
+  getSupportedChainIds,
+  getUniswapAddresses,
+} from '@/swap/providers/uniswap/addresses.js'
+import {
+  encodeUniversalRouterSwap,
+  getQuote,
+} from '@/swap/providers/uniswap/encoding.js'
+import type {
+  UniswapMarketConfig,
+  UniswapSwapProviderConfig,
+} from '@/swap/providers/uniswap/types.js'
+import type { Asset } from '@/types/asset.js'
+import type {
+  GetSwapMarketParams,
+  GetSwapMarketsParams,
+  ResolvedSwapParams,
+  SwapMarket,
+  SwapPrice,
+  SwapPriceParams,
+  SwapTransaction,
+} from '@/types/swap/index.js'
+import type { TransactionData } from '@/types/transaction.js'
+import { isNativeAsset, parseAssetAmount } from '@/utils/assets.js'
+
+/**
+ * Uniswap V4 swap provider using Universal Router and Permit2 approvals.
+ */
+export class UniswapSwapProvider extends SwapProvider<UniswapSwapProviderConfig> {
+  /** @returns Chain IDs where Uniswap V4 contracts are deployed */
+  supportedChainIds(): SupportedChainId[] {
+    return getSupportedChainIds()
+  }
+
+  /**
+   * Build a swap transaction with quote, calldata, and any required approvals.
+   * @param params - Resolved swap parameters (amounts in wei, defaults applied)
+   * @returns Transaction data ready for wallet execution
+   */
+  protected async _execute(
+    params: ResolvedSwapParams,
+  ): Promise<SwapTransaction> {
+    const { chainId, assetIn, assetOut } = params
+    const addresses = getUniswapAddresses(chainId)
+    const publicClient = this.chainManager.getPublicClient(chainId)
+    const marketConfig = this.resolveUniswapConfig(assetIn, assetOut, chainId)
+
+    const quote = await getQuote({
+      assetIn,
+      assetOut,
+      amountInWei: params.amountInWei,
+      amountOutWei: params.amountOutWei,
+      chainId,
+      publicClient,
+      quoterAddress: addresses.quoter,
+      poolManagerAddress: addresses.poolManager,
+      fee: marketConfig.fee,
+      tickSpacing: marketConfig.tickSpacing,
+    })
+
+    const swapCalldata = encodeUniversalRouterSwap({
+      amountInWei: params.amountInWei,
+      amountOutWei: params.amountOutWei,
+      assetIn,
+      assetOut,
+      slippage: params.slippage,
+      deadline: params.deadline,
+      recipient: params.recipient,
+      chainId,
+      quote,
+      universalRouterAddress: addresses.universalRouter,
+      fee: marketConfig.fee,
+      tickSpacing: marketConfig.tickSpacing,
+    })
+
+    const amountInWei = params.amountInWei ?? quote.amountInWei
+    const { tokenApproval, permit2Approval } = await this.buildPermit2Approvals(
+      params,
+      amountInWei,
+      addresses.permit2,
+      addresses.universalRouter,
+      this._config.permit2ExpirySeconds,
+    )
+
+    const swapTx: TransactionData = {
+      to: addresses.universalRouter,
+      data: swapCalldata,
+      value: isNativeAsset(assetIn) ? (params.amountInWei ?? 0n) : 0n,
+    }
+
+    return {
+      amountIn: parseFloat(formatUnits(amountInWei, assetIn.metadata.decimals)),
+      amountOut: parseFloat(
+        formatUnits(quote.amountOutWei, assetOut.metadata.decimals),
+      ),
+      amountInWei,
+      amountOutWei: quote.amountOutWei,
+      assetIn,
+      assetOut,
+      price: quote.price,
+      priceImpact: quote.priceImpact,
+      transactionData: { tokenApproval, permit2Approval, swap: swapTx },
+    }
+  }
+
+  /**
+   * Get a price quote for a swap pair.
+   * @param params - Price query with assets, optional amounts, and chain
+   * @returns Quote with price, amounts, price impact, and route
+   */
+  protected async _getPrice(params: SwapPriceParams): Promise<SwapPrice> {
+    const { chainId, assetIn, assetOut } = params
+    const addresses = getUniswapAddresses(chainId)
+    const publicClient = this.chainManager.getPublicClient(chainId)
+
+    if (!assetOut) {
+      throw new Error('assetOut is required')
+    }
+
+    const marketConfig = this.resolveUniswapConfig(assetIn, assetOut, chainId)
+
+    // Default to 1 unit for price quotes when no amount specified
+    const amountInWei = parseAssetAmount(assetIn, params.amountIn ?? 1)
+    const amountOutWei = parseAssetAmount(assetOut, params.amountOut)
+
+    return getQuote({
+      assetIn,
+      assetOut,
+      amountInWei: amountOutWei ? undefined : amountInWei,
+      amountOutWei,
+      chainId,
+      publicClient,
+      quoterAddress: addresses.quoter,
+      poolManagerAddress: addresses.poolManager,
+      fee: marketConfig.fee,
+      tickSpacing: marketConfig.tickSpacing,
+    })
+  }
+
+  /**
+   * 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> {
+    const { poolId, chainId } = params
+
+    for (const config of this.validConfigs()) {
+      if (config.chainId !== undefined && config.chainId !== chainId) continue
+      const match = this.marketsFromConfig(config, chainId).find(
+        (m) => m.marketId.poolId === poolId,
+      )
+      if (match) return match
+    }
+
+    throw new Error(
+      `Market with poolId ${poolId} not found on chain ${chainId}`,
+    )
+  }
+
+  /**
+   * Expand the market allowlist into concrete SwapMarket objects.
+   * Derives poolId from each asset pair's pool key — no RPC calls needed.
+   * @param params - Optional chain and asset filters
+   * @returns All configured markets matching the filters
+   */
+  protected async _getMarkets(
+    params: GetSwapMarketsParams,
+  ): Promise<SwapMarket[]> {
+    return this.validConfigs().flatMap((config) => {
+      const chainIds = params.chainId
+        ? [params.chainId]
+        : config.chainId
+          ? [config.chainId]
+          : this.supportedChainIds()
+
+      return chainIds.flatMap((chainId) =>
+        this.marketsFromConfig(config, chainId, params.asset),
+      )
+    })
+  }
+
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Private helpers
+  // ─────────────────────────────────────────────────────────────────────────────
+
+  /**
+   * Look up the Uniswap-specific market config for a pair, validating fee/tickSpacing.
+   * @param assetIn - Input asset
+   * @param assetOut - Output asset
+   * @param chainId - Target chain
+   * @returns Market config with guaranteed fee and tickSpacing
+   * @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 }
+  }
+
+  /** @returns Allowlist entries that have the required fee and tickSpacing set */
+  private validConfigs(): Array<
+    UniswapMarketConfig & { fee: number; tickSpacing: number }
+  > {
+    return (this._config.marketAllowlist ?? []).filter(
+      (f): f is UniswapMarketConfig & { fee: number; tickSpacing: number } =>
+        f.fee !== undefined && f.tickSpacing !== undefined,
+    )
+  }
+
+  /**
+   * Generate all SwapMarket objects from a single config entry on a given chain.
+   * @param config - Market config with fee/tickSpacing
+   * @param chainId - Target chain
+   * @param asset - If provided, only return markets containing this asset
+   */
+  private marketsFromConfig(
+    config: UniswapMarketConfig & { fee: number; tickSpacing: number },
+    chainId: SupportedChainId,
+    asset?: Asset,
+  ): SwapMarket[] {
+    return this.assetPairs(config.assets, asset)
+      .map(([a, b]) =>
+        this.configToMarket(a, b, chainId, config.fee, config.tickSpacing),
+      )
+      .filter((m): m is SwapMarket => m !== null)
+  }
+
+  /**
+   * Generate unique asset pairs, optionally scoped to pairs containing a required asset.
+   * @param assets - Full list of assets from a market config
+   * @param requiredAsset - If set, only pairs including this asset are returned
+   */
+  private assetPairs(
+    assets: Asset[],
+    requiredAsset?: Asset,
+  ): Array<[Asset, Asset]> {
+    return assets
+      .flatMap((a, i) => assets.slice(i + 1).map((b): [Asset, Asset] => [a, b]))
+      .filter(
+        ([a, b]) =>
+          !requiredAsset || a === requiredAsset || b === requiredAsset,
+      )
+  }
+
+  /**
+   * Build a SwapMarket from two assets and V4 pool parameters.
+   * Computes a deterministic poolId from the sorted pool key.
+   * @returns SwapMarket, or null if either asset lacks an address on this chain
+   */
+  private configToMarket(
+    assetA: Asset,
+    assetB: Asset,
+    chainId: SupportedChainId,
+    fee: number,
+    tickSpacing: number,
+  ): SwapMarket | null {
+    const addrA = assetA.address[chainId]
+    const addrB = assetB.address[chainId]
+    if (!addrA || addrA === 'native' || !addrB || addrB === 'native')
+      return null
+
+    // V4 requires currency0 < currency1 for deterministic pool keys
+    const [currency0, currency1] =
+      addrA.toLowerCase() < addrB.toLowerCase()
+        ? [addrA, addrB]
+        : [addrB, addrA]
+
+    // PoolId = keccak256(abi.encode(PoolKey)) per V4's PoolIdLibrary
+    // @see https://github.com/Uniswap/v4-core/blob/main/src/types/PoolId.sol
+    const poolId = keccak256(
+      encodeAbiParameters(POOL_KEY_ABI_TYPE, [
+        currency0 as Address,
+        currency1 as Address,
+        fee,
+        tickSpacing,
+        '0x0000000000000000000000000000000000000000' as Address,
+      ]),
+    )
+
+    return {
+      marketId: { poolId, chainId },
+      assets: [assetA, assetB],
+      fee,
+      provider: 'uniswap',
+    }
+  }
+}