@eth-optimism/actions-sdk 0.3.0 → 0.4.0

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

@@ -1,6 +1,8 @@
 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,
@@ -19,27 +21,30 @@ describe('BaseSwapNamespace', () => {
     metadata: { name: 'Ether', symbol: 'ETH', decimals: 18 },
   }
 
-  describe('price', () => {
-    it('delegates to provider getPrice', async () => {
+  describe('getQuote', () => {
+    it('delegates to provider getQuote', async () => {
       const provider = createMockSwapProvider()
       const namespace = new ActionsSwapNamespace({ uniswap: provider })
 
-      const result = await namespace.price({
+      const result = await namespace.getQuote({
         assetIn: USDC,
         assetOut: ETH,
         amountIn: 100,
         chainId: 84532 as SupportedChainId,
       })
 
-      expect(provider.mockGetPrice).toHaveBeenCalledTimes(1)
-      expect(result.price).toBe('1.5')
+      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.price({
+        namespace.getQuote({
           assetIn: USDC,
           assetOut: ETH,
           amountIn: 100,
@@ -49,6 +54,190 @@ describe('BaseSwapNamespace', () => {
     })
   })
 
+  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()
@@ -62,6 +251,42 @@ describe('BaseSwapNamespace', () => {
       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', () => {
@@ -73,11 +298,9 @@ describe('BaseSwapNamespace', () => {
 
       const namespace = new ActionsSwapNamespace({
         uniswap: provider1,
+        velodrome: provider2,
       })
 
-      // Add second provider manually for testing aggregation
-      ;(namespace as any).providers.oneInch = provider2
-
       const result = await namespace.getMarkets({})
 
       expect(result.length).toBeGreaterThanOrEqual(1)
@@ -99,14 +322,18 @@ describe('BaseSwapNamespace', () => {
       const provider1 = createMockSwapProvider(undefined, {
         supportedChains: [84532 as SupportedChainId],
       })
-      const provider2 = new MockSwapProvider(undefined, {
-        supportedChains: [1 as SupportedChainId, 10 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,
       })
-      ;(namespace as any).providers.oneInch = provider2
 
       const result = namespace.supportedChainIds()
 
@@ -126,8 +353,8 @@ describe('BaseSwapNamespace', () => {
 
       const namespace = new ActionsSwapNamespace({
         uniswap: provider1,
+        velodrome: provider2,
       })
-      ;(namespace as any).providers.oneInch = provider2
 
       const result = namespace.supportedChainIds()
 

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

@@ -45,7 +45,7 @@ describe('WalletSwapNamespace', () => {
       expect(provider.mockExecute).toHaveBeenCalledTimes(1)
       expect(wallet.send).toHaveBeenCalledTimes(1)
       expect(wallet.sendBatch).not.toHaveBeenCalled()
-      expect(result.price).toBe('1.5')
+      expect(result.price).toBe(1.5)
       expect(result.assetIn).toBe(USDC)
       expect(result.assetOut).toBe(ETH)
     })
@@ -59,11 +59,11 @@ describe('WalletSwapNamespace', () => {
       provider.mockExecute.mockResolvedValueOnce({
         amountIn: 100,
         amountOut: 1.5,
-        amountInWei: 100000000n,
-        amountOutWei: 1500000000000000000n,
+        amountInRaw: 100000000n,
+        amountOutRaw: 1500000000000000000n,
         assetIn: USDC,
         assetOut: ETH,
-        price: '1.5',
+        price: 1.5,
         priceImpact: 0.001,
         transactionData: {
           tokenApproval: {
@@ -131,24 +131,119 @@ describe('WalletSwapNamespace', () => {
         }),
       ).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('inherits read-only methods', () => {
-    it('has price method from BaseSwapNamespace', async () => {
+  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)
 
-      const result = await namespace.price({
+      // 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
       })
 
-      expect(result.price).toBe('1.5')
+      // 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()