@eth-optimism/actions-sdk 0.3.0 → 0.5.0

package/src/swap/namespaces/WalletSwapNamespace.ts

@@ -1,48 +1,95 @@
 import type { SupportedChainId } from '@/constants/supportedChains.js'
+import type { SwapExecuteParamsResolved } from '@/ens/types.js'
+import { QUOTE_DISCRIMINATOR } from '@/swap/core/SwapProvider.js'
 import { BaseSwapNamespace } from '@/swap/namespaces/BaseSwapNamespace.js'
+import type { SwapSettings } from '@/types/actions.js'
 import type {
   SwapProviders,
+  SwapQuote,
+  SwapQuoteParams,
   SwapReceipt,
   SwapTransaction,
   WalletSwapParams,
 } from '@/types/swap/index.js'
+import type { RecipientResolver } from '@/utils/ens.js'
 import type { Wallet } from '@/wallet/core/wallets/abstract/Wallet.js'
 
 /**
- * Wallet swap namespace (full operations with signing)
- * @description Provides execute() for swapping tokens
+ * Wallet swap namespace with full operations including signing.
+ * Provides getQuote() for pricing and execute() for swapping tokens.
  */
 export class WalletSwapNamespace extends BaseSwapNamespace {
   constructor(
     providers: SwapProviders,
     private readonly wallet: Wallet,
+    resolveRecipient?: RecipientResolver,
+    settings?: SwapSettings,
   ) {
-    super(providers)
+    super(providers, resolveRecipient, settings)
   }
 
   /**
-   * Execute a token swap
-   * @param params - Swap parameters including chainId
-   * @returns Swap receipt with transaction details
+   * Get a swap quote with the wallet address as recipient.
+   * Ensures calldata is encoded for the real wallet, not a placeholder.
    */
-  async execute(params: WalletSwapParams): Promise<SwapReceipt> {
-    const provider = this.getProvider()
+  override async getQuote(params: SwapQuoteParams): Promise<SwapQuote> {
+    return super.getQuote({
+      ...params,
+      recipient: params.recipient ?? this.wallet.address,
+    })
+  }
 
-    // Build swap transaction
-    const swapTx = await provider.execute({
+  /**
+   * Get quotes from all providers with the wallet address as recipient.
+   */
+  override async getQuotes(params: SwapQuoteParams): Promise<SwapQuote[]> {
+    return super.getQuotes({
       ...params,
-      walletAddress: this.wallet.address,
+      recipient: params.recipient ?? this.wallet.address,
     })
+  }
 
-    // Execute transaction(s)
+  /**
+   * Execute a token swap.
+   * Accepts either raw params (re-quotes internally) or a pre-built SwapQuote (skips re-quoting).
+   * @param params - Swap parameters or a pre-built SwapQuote from getQuote()
+   * @returns Swap receipt with transaction details
+   */
+  async execute(params: WalletSwapParams | SwapQuote): Promise<SwapReceipt> {
+    // Inject walletAddress — raw params need it for validation,
+    // quotes need it for on-chain allowance checks during approval building.
+    // Resolve ENS recipient here so providers only ever receive an Address.
+    const executeParams: SwapExecuteParamsResolved | SwapQuote =
+      QUOTE_DISCRIMINATOR in params
+        ? { ...params, recipient: this.wallet.address }
+        : {
+            ...params,
+            walletAddress: this.wallet.address,
+            recipient: await this.resolveRecipient(params.recipient),
+          }
+
+    const provider = this.resolveProvider(
+      params.provider,
+      params.assetIn,
+      params.assetOut,
+      params.chainId,
+    )
+
+    const swapTx = await provider.execute(executeParams)
     const receipt = await this.executeTransaction(swapTx, params.chainId)
+    return this.buildReceipt(swapTx, receipt)
+  }
 
+  private buildReceipt(
+    swapTx: SwapTransaction,
+    receipt: SwapReceipt['receipt'],
+  ): SwapReceipt {
     return {
       receipt,
       amountIn: swapTx.amountIn,
       amountOut: swapTx.amountOut,
-      amountInWei: swapTx.amountInWei,
-      amountOutWei: swapTx.amountOutWei,
+      amountInRaw: swapTx.amountInRaw,
+      amountOutRaw: swapTx.amountOutRaw,
       assetIn: swapTx.assetIn,
       assetOut: swapTx.assetOut,
       price: swapTx.price,

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,194 @@ 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 },
+        undefined,
+        { 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 },
+        undefined,
+        { 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 },
+        undefined,
+        { 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 },
+        undefined,
+        { 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 +255,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 +302,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 +326,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 +357,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()