@eth-optimism/actions-sdk 0.2.0 → 0.4.0

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

@@ -0,0 +1,365 @@
+import { describe, expect, it } from 'vitest'
+
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+import { MockChainManager } from '@/services/__mocks__/MockChainManager.js'
+import type { ChainManager } from '@/services/ChainManager.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('getQuote', () => {
+    it('delegates to provider getQuote', async () => {
+      const provider = createMockSwapProvider()
+      const namespace = new ActionsSwapNamespace({ uniswap: provider })
+
+      const result = await namespace.getQuote({
+        assetIn: USDC,
+        assetOut: ETH,
+        amountIn: 100,
+        chainId: 84532 as SupportedChainId,
+      })
+
+      expect(provider.mockGetQuote).toHaveBeenCalledTimes(1)
+      expect(result.price).toBe(1.5)
+      expect(result.execution).toBeDefined()
+      expect(result.execution.swapCalldata).toMatch(/^0x/)
+      expect(result.provider).toBe('uniswap')
+    })
+
+    it('throws if no provider configured', async () => {
+      const namespace = new ActionsSwapNamespace({})
+
+      await expect(
+        namespace.getQuote({
+          assetIn: USDC,
+          assetOut: ETH,
+          amountIn: 100,
+          chainId: 84532 as SupportedChainId,
+        }),
+      ).rejects.toThrow('No swap provider configured')
+    })
+  })
+
+  describe('getQuote with price routing', () => {
+    it('returns the best price across providers when routing is price', async () => {
+      const cheapProvider = new MockSwapProvider(
+        { marketAllowlist: [{ assets: [USDC, ETH] }] },
+        { defaultPrice: 1.2, provider: 'uniswap' },
+      )
+      const expensiveProvider = new MockSwapProvider(
+        { marketAllowlist: [{ assets: [USDC, ETH] }] },
+        { defaultPrice: 1.8, provider: 'velodrome' },
+      )
+
+      const namespace = new ActionsSwapNamespace(
+        { uniswap: cheapProvider, velodrome: expensiveProvider },
+        { routing: 'price' },
+      )
+
+      const result = await namespace.getQuote({
+        assetIn: USDC,
+        assetOut: ETH,
+        amountIn: 100,
+        chainId: 84532 as SupportedChainId,
+      })
+
+      // Should pick velodrome because 1.8 > 1.2 (higher amountOut)
+      expect(result.provider).toBe('velodrome')
+    })
+
+    it('skips providers that fail to quote', async () => {
+      const workingProvider = createMockSwapProvider(
+        { marketAllowlist: [{ assets: [USDC, ETH] }] },
+        { provider: 'velodrome' },
+      )
+      const failingProvider = createMockSwapProvider(
+        { marketAllowlist: [{ assets: [USDC, ETH] }] },
+        { provider: 'uniswap' },
+      )
+      failingProvider.mockGetQuote.mockRejectedValue(new Error('RPC failure'))
+
+      const namespace = new ActionsSwapNamespace(
+        { uniswap: failingProvider, velodrome: workingProvider },
+        { routing: 'price' },
+      )
+
+      const result = await namespace.getQuote({
+        assetIn: USDC,
+        assetOut: ETH,
+        amountIn: 100,
+        chainId: 84532 as SupportedChainId,
+      })
+
+      expect(result.provider).toBe('velodrome')
+    })
+
+    it('throws when all providers fail to quote', async () => {
+      const failingProvider = createMockSwapProvider({
+        marketAllowlist: [{ assets: [USDC, ETH] }],
+      })
+      failingProvider.mockGetQuote.mockRejectedValue(new Error('fail'))
+
+      const namespace = new ActionsSwapNamespace(
+        { uniswap: failingProvider },
+        { routing: 'price' },
+      )
+
+      await expect(
+        namespace.getQuote({
+          assetIn: USDC,
+          assetOut: ETH,
+          amountIn: 100,
+          chainId: 84532 as SupportedChainId,
+        }),
+      ).rejects.toThrow('All providers failed')
+    })
+
+    it('uses explicit provider when specified, ignoring routing', async () => {
+      const cheapProvider = new MockSwapProvider(
+        { marketAllowlist: [{ assets: [USDC, ETH] }] },
+        { defaultPrice: 1.2, provider: 'uniswap' },
+      )
+      const expensiveProvider = new MockSwapProvider(
+        { marketAllowlist: [{ assets: [USDC, ETH] }] },
+        { defaultPrice: 1.8, provider: 'velodrome' },
+      )
+
+      const namespace = new ActionsSwapNamespace(
+        { uniswap: cheapProvider, velodrome: expensiveProvider },
+        { routing: 'price' },
+      )
+
+      const result = await namespace.getQuote({
+        assetIn: USDC,
+        assetOut: ETH,
+        amountIn: 100,
+        chainId: 84532 as SupportedChainId,
+        provider: 'uniswap',
+      })
+
+      // Should use uniswap despite worse price because it was explicitly requested
+      expect(result.provider).toBe('uniswap')
+    })
+  })
+
+  describe('getQuotes', () => {
+    it('returns quotes from all eligible providers sorted by best price', async () => {
+      const cheapProvider = new MockSwapProvider(
+        { marketAllowlist: [{ assets: [USDC, ETH] }] },
+        { defaultPrice: 1.2, provider: 'uniswap' },
+      )
+      const expensiveProvider = new MockSwapProvider(
+        { marketAllowlist: [{ assets: [USDC, ETH] }] },
+        { defaultPrice: 1.8, provider: 'velodrome' },
+      )
+
+      const namespace = new ActionsSwapNamespace({
+        uniswap: cheapProvider,
+        velodrome: expensiveProvider,
+      })
+
+      const quotes = await namespace.getQuotes({
+        assetIn: USDC,
+        assetOut: ETH,
+        amountIn: 100,
+        chainId: 84532 as SupportedChainId,
+      })
+
+      expect(quotes).toHaveLength(2)
+      expect(quotes[0].provider).toBe('velodrome')
+      expect(quotes[1].provider).toBe('uniswap')
+    })
+
+    it('skips failed providers and returns successful ones', async () => {
+      const workingProvider = createMockSwapProvider(
+        { marketAllowlist: [{ assets: [USDC, ETH] }] },
+        { provider: 'velodrome' },
+      )
+      const failingProvider = createMockSwapProvider(
+        { marketAllowlist: [{ assets: [USDC, ETH] }] },
+        { provider: 'uniswap' },
+      )
+      failingProvider.mockGetQuote.mockRejectedValue(new Error('fail'))
+
+      const namespace = new ActionsSwapNamespace({
+        uniswap: failingProvider,
+        velodrome: workingProvider,
+      })
+
+      const quotes = await namespace.getQuotes({
+        assetIn: USDC,
+        assetOut: ETH,
+        amountIn: 100,
+        chainId: 84532 as SupportedChainId,
+      })
+
+      expect(quotes).toHaveLength(1)
+      expect(quotes[0].provider).toBe('velodrome')
+    })
+
+    it('returns single-element array when explicit provider specified', async () => {
+      const provider1 = createMockSwapProvider(undefined, {
+        provider: 'uniswap',
+      })
+      const provider2 = new MockSwapProvider(undefined, {
+        supportedChains: [84532 as SupportedChainId],
+        provider: 'velodrome',
+      })
+
+      const namespace = new ActionsSwapNamespace({
+        uniswap: provider1,
+        velodrome: provider2,
+      })
+
+      const quotes = await namespace.getQuotes({
+        assetIn: USDC,
+        assetOut: ETH,
+        amountIn: 100,
+        chainId: 84532 as SupportedChainId,
+        provider: 'uniswap',
+      })
+
+      expect(quotes).toHaveLength(1)
+      expect(quotes[0].provider).toBe('uniswap')
+    })
+  })
+
+  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')
+    })
+
+    it('queries specific provider when specified', async () => {
+      const provider1 = createMockSwapProvider(undefined, {
+        provider: 'uniswap',
+      })
+      const provider2 = new MockSwapProvider(undefined, {
+        supportedChains: [84532 as SupportedChainId],
+        provider: 'velodrome',
+      })
+
+      const namespace = new ActionsSwapNamespace({
+        uniswap: provider1,
+        velodrome: provider2,
+      })
+
+      await namespace.getMarket(
+        { poolId: '0xpool123', chainId: 84532 as SupportedChainId },
+        'velodrome',
+      )
+
+      expect(provider2.mockGetMarket).toHaveBeenCalledTimes(1)
+      expect(provider1.mockGetMarket).not.toHaveBeenCalled()
+    })
+
+    it('throws for unknown provider name', async () => {
+      const namespace = new ActionsSwapNamespace({
+        uniswap: createMockSwapProvider(),
+      })
+
+      await expect(
+        namespace.getMarket(
+          { poolId: '0x1', chainId: 84532 as SupportedChainId },
+          'velodrome',
+        ),
+      ).rejects.toThrow('not configured')
+    })
+  })
+
+  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,
+        velodrome: 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] },
+        new MockChainManager({
+          supportedChains: [1 as SupportedChainId, 10 as SupportedChainId],
+        }) as unknown as ChainManager,
+      )
+
+      const namespace = new ActionsSwapNamespace({
+        uniswap: provider1,
+        velodrome: 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,
+        velodrome: 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,257 @@
+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,
+        amountInRaw: 100000000n,
+        amountOutRaw: 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')
+    })
+
+    it('executes swap from a SwapQuote (skips re-quoting)', async () => {
+      const provider = createMockSwapProvider()
+      const wallet = createMockWallet()
+      const namespace = new WalletSwapNamespace({ uniswap: provider }, wallet)
+
+      // Get a quote first
+      const quote = await namespace.getQuote({
+        assetIn: USDC,
+        assetOut: ETH,
+        amountIn: 100,
+        chainId: 84532 as SupportedChainId,
+      })
+
+      // Execute with the quote
+      const result = await namespace.execute(quote)
+
+      // Should use quote path: _buildApprovals called, not _execute
+      expect(provider.mockBuildApprovals).toHaveBeenCalledTimes(1)
+      expect(provider.mockExecute).not.toHaveBeenCalled()
+      expect(result.price).toBe(1.5)
+      expect(wallet.send).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe('getQuote recipient injection', () => {
+    it('injects wallet address as recipient', async () => {
+      const provider = createMockSwapProvider()
+      const wallet = createMockWallet()
+      const namespace = new WalletSwapNamespace({ uniswap: provider }, wallet)
+
+      const quote = await namespace.getQuote({
+        assetIn: USDC,
+        assetOut: ETH,
+        amountIn: 100,
+        chainId: 84532 as SupportedChainId,
+      })
+
+      // Quote should have wallet address as the encoded recipient
+      expect(quote.quotedRecipient).toBe(mockWalletAddress)
+    })
+
+    it('preserves explicit recipient over wallet address', async () => {
+      const provider = createMockSwapProvider()
+      const wallet = createMockWallet()
+      const namespace = new WalletSwapNamespace({ uniswap: provider }, wallet)
+      const customRecipient =
+        '0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' as Address
+
+      const quote = await namespace.getQuote({
+        assetIn: USDC,
+        assetOut: ETH,
+        amountIn: 100,
+        chainId: 84532 as SupportedChainId,
+        recipient: customRecipient,
+      })
+
+      expect(quote.quotedRecipient).toBe(customRecipient)
+    })
+  })
+
+  describe('execute with recipient mismatch', () => {
+    it('re-encodes when quote recipient differs from wallet', async () => {
+      const provider = createMockSwapProvider()
+      const wallet = createMockWallet()
+      const namespace = new WalletSwapNamespace({ uniswap: provider }, wallet)
+
+      // Get quote without wallet (simulates ActionsSwapNamespace quote)
+      const quote = await provider.getQuote({
+        assetIn: USDC,
+        assetOut: ETH,
+        amountIn: 100,
+        chainId: 84532 as SupportedChainId,
+        // No recipient — uses placeholder
+      })
+
+      // quotedRecipient should be the placeholder, not the wallet
+      expect(quote.quotedRecipient).not.toBe(mockWalletAddress)
+
+      // Execute through wallet namespace — should re-quote with correct recipient
+      const result = await namespace.execute(quote)
+      expect(result.price).toBeDefined()
+
+      // Provider's getQuote should have been called twice:
+      // 1) original quote, 2) re-quote with wallet address
+      expect(provider.mockGetQuote).toHaveBeenCalledTimes(2)
+    })
+
+    it('skips re-encode when quote already has correct recipient', async () => {
+      const provider = createMockSwapProvider()
+      const wallet = createMockWallet()
+      const namespace = new WalletSwapNamespace({ uniswap: provider }, wallet)
+
+      // Get quote through wallet namespace (has correct recipient)
+      const quote = await namespace.getQuote({
+        assetIn: USDC,
+        assetOut: ETH,
+        amountIn: 100,
+        chainId: 84532 as SupportedChainId,
+      })
+
+      expect(quote.quotedRecipient).toBe(mockWalletAddress)
+
+      // Execute — should NOT re-quote
+      const result = await namespace.execute(quote)
+      expect(result.price).toBeDefined()
+
+      // getQuote called only once (the original)
+      expect(provider.mockGetQuote).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe('inherits read-only methods', () => {
+    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)
+    })
+  })
+})