@eth-optimism/actions-sdk 0.4.0 → 0.6.0

package/src/{swap → actions/swap}/namespaces/__tests__/WalletSwapNamespace.spec.ts

@@ -1,9 +1,9 @@
 import type { Address } from 'viem'
 import { describe, expect, it, vi } from 'vitest'
 
+import { createMockSwapProvider } from '@/actions/swap/__mocks__/MockSwapProvider.js'
+import { WalletSwapNamespace } from '@/actions/swap/namespaces/WalletSwapNamespace.js'
 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', () => {
@@ -118,6 +118,47 @@ describe('WalletSwapNamespace', () => {
       )
     })
 
+    it('defaults recipient to wallet address when omitted', 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({
+          recipient: 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
+
+      await namespace.execute({
+        amountIn: 100,
+        assetIn: USDC,
+        assetOut: ETH,
+        chainId: 84532 as SupportedChainId,
+        recipient: customRecipient,
+      })
+
+      expect(provider.mockExecute).toHaveBeenCalledWith(
+        expect.objectContaining({
+          recipient: customRecipient,
+        }),
+      )
+    })
+
     it('throws when no provider configured', async () => {
       const wallet = createMockWallet()
       const namespace = new WalletSwapNamespace({}, wallet)
@@ -129,7 +170,7 @@ describe('WalletSwapNamespace', () => {
           assetOut: ETH,
           chainId: 84532 as SupportedChainId,
         }),
-      ).rejects.toThrow('No swap provider configured')
+      ).rejects.toThrow("A 'swap' provider is not configured")
     })
 
     it('executes swap from a SwapQuote (skips re-quoting)', async () => {
@@ -170,7 +211,7 @@ describe('WalletSwapNamespace', () => {
       })
 
       // Quote should have wallet address as the encoded recipient
-      expect(quote.quotedRecipient).toBe(mockWalletAddress)
+      expect(quote.recipient).toBe(mockWalletAddress)
     })
 
     it('preserves explicit recipient over wallet address', async () => {
@@ -188,43 +229,61 @@ describe('WalletSwapNamespace', () => {
         recipient: customRecipient,
       })
 
-      expect(quote.quotedRecipient).toBe(customRecipient)
+      expect(quote.recipient).toBe(customRecipient)
     })
   })
 
   describe('execute with recipient mismatch', () => {
-    it('re-encodes when quote recipient differs from wallet', async () => {
+    it('throws when quote.recipient does not match wallet.address', async () => {
       const provider = createMockSwapProvider()
       const wallet = createMockWallet()
       const namespace = new WalletSwapNamespace({ uniswap: provider }, wallet)
 
-      // Get quote without wallet (simulates ActionsSwapNamespace quote)
+      // Get quote without wallet (simulates ActionsSwapNamespace quote — recipient
+      // defaults to UNIVERSAL_ROUTER_MSG_SENDER, not the executing wallet)
       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)
+      expect(quote.recipient).not.toBe(mockWalletAddress)
 
-      // Execute through wallet namespace — should re-quote with correct recipient
-      const result = await namespace.execute(quote)
-      expect(result.price).toBeDefined()
+      await expect(namespace.execute(quote)).rejects.toThrow(
+        /generated for a different recipient/i,
+      )
+      // Provider's getQuote was called once (the original); execute did not re-quote.
+      expect(provider.mockGetQuote).toHaveBeenCalledTimes(1)
+    })
+
+    it('throws on a quote built for a different wallet address', async () => {
+      const provider = createMockSwapProvider()
+      const wallet = createMockWallet()
+      const namespace = new WalletSwapNamespace({ uniswap: provider }, wallet)
+      const otherWallet =
+        '0x9999999999999999999999999999999999999999' as Address
+
+      const quote = await provider.getQuote({
+        assetIn: USDC,
+        assetOut: ETH,
+        amountIn: 100,
+        chainId: 84532 as SupportedChainId,
+        recipient: otherWallet,
+      })
+
+      expect(quote.recipient).toBe(otherWallet)
 
-      // Provider's getQuote should have been called twice:
-      // 1) original quote, 2) re-quote with wallet address
-      expect(provider.mockGetQuote).toHaveBeenCalledTimes(2)
+      await expect(namespace.execute(quote)).rejects.toThrow(
+        /generated for a different recipient/i,
+      )
     })
 
-    it('skips re-encode when quote already has correct recipient', async () => {
+    it('executes when quote.recipient equals wallet.address', 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,
@@ -232,15 +291,44 @@ describe('WalletSwapNamespace', () => {
         chainId: 84532 as SupportedChainId,
       })
 
-      expect(quote.quotedRecipient).toBe(mockWalletAddress)
+      expect(quote.recipient).toBe(mockWalletAddress)
 
-      // Execute — should NOT re-quote
       const result = await namespace.execute(quote)
       expect(result.price).toBeDefined()
-
-      // getQuote called only once (the original)
+      // Single getQuote call — no re-quote, no re-encode.
       expect(provider.mockGetQuote).toHaveBeenCalledTimes(1)
     })
+
+    it('executes when quote.recipient differs only in case from wallet.address', async () => {
+      // Address with hex letters so case actually changes the string. The
+      // wallet uses checksummed casing; the quote uses lowercase. Without
+      // `isAddressEqual` the strict `!==` would falsely reject.
+      const checksummedAddress =
+        '0xAbCdEf1234567890aBcDeF1234567890ABcDeF12' as Address
+      const lowercaseAddress = checksummedAddress.toLowerCase() as Address
+
+      const provider = createMockSwapProvider()
+      const wallet = {
+        address: checksummedAddress,
+        send: vi.fn().mockResolvedValue({ transactionHash: '0xtx1' }),
+        sendBatch: vi.fn().mockResolvedValue({ transactionHash: '0xtx2' }),
+      } as unknown as Wallet
+      const namespace = new WalletSwapNamespace({ uniswap: provider }, wallet)
+
+      const quote = await provider.getQuote({
+        assetIn: USDC,
+        assetOut: ETH,
+        amountIn: 100,
+        chainId: 84532 as SupportedChainId,
+        recipient: lowercaseAddress,
+      })
+
+      expect(quote.recipient).toBe(lowercaseAddress)
+      expect(quote.recipient).not.toBe(checksummedAddress)
+
+      const result = await namespace.execute(quote)
+      expect(result.price).toBeDefined()
+    })
   })
 
   describe('inherits read-only methods', () => {

package/src/{swap → actions/swap}/providers/uniswap/UniswapSwapProvider.ts

@@ -1,25 +1,29 @@
 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 { expandMarkets, findMarket } from '@/actions/swap/core/markets.js'
+import { SwapProvider } from '@/actions/swap/core/SwapProvider.js'
 import {
   getSupportedChainIds,
   getUniswapAddresses,
-} from '@/swap/providers/uniswap/addresses.js'
+} from '@/actions/swap/providers/uniswap/addresses.js'
 import {
   encodeUniversalRouterSwap,
   getQuote,
-} from '@/swap/providers/uniswap/encoding.js'
+} from '@/actions/swap/providers/uniswap/encoding.js'
 import {
   configToMarkets,
   getValidMarketConfigs,
-} from '@/swap/providers/uniswap/markets.js'
+} from '@/actions/swap/providers/uniswap/markets.js'
 import type {
   UniswapMarketConfig,
   UniswapSwapProviderConfig,
-} from '@/swap/providers/uniswap/types.js'
+} from '@/actions/swap/providers/uniswap/types.js'
+import { UNISWAP } from '@/constants/providers.js'
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+import { AssetMetadataRequiredError } from '@/core/error/errors.js'
+import type { ChainManager } from '@/services/ChainManager.js'
+import type { SwapQuoteParamsResolved } from '@/services/nameservices/ens/types.js'
+import type { SwapSettings } from '@/types/actions.js'
 import type { Asset } from '@/types/asset.js'
 import type {
   GetSwapMarketParams,
@@ -27,15 +31,23 @@ import type {
   ResolvedSwapParams,
   SwapMarket,
   SwapQuote,
-  SwapQuoteParams,
   SwapTransaction,
 } from '@/types/swap/index.js'
+import { resolveApprovalMode } from '@/utils/approve.js'
 import { isNativeAsset, parseAssetAmount } from '@/utils/assets.js'
 
 /**
  * Uniswap V4 swap provider using Universal Router and Permit2 approvals.
  */
 export class UniswapSwapProvider extends SwapProvider<UniswapSwapProviderConfig> {
+  constructor(
+    config: UniswapSwapProviderConfig,
+    chainManager: ChainManager,
+    settings?: SwapSettings,
+  ) {
+    super(config, chainManager, settings)
+  }
+
   protocolSupportedChainIds(): SupportedChainId[] {
     return getSupportedChainIds()
   }
@@ -61,7 +73,10 @@ export class UniswapSwapProvider extends SwapProvider<UniswapSwapProviderConfig>
       deadline: params.deadline,
       recipient: params.recipient,
     })
-    return this.buildSwapTransactions(swapQuote)
+    return this.buildSwapTransactions({
+      ...swapQuote,
+      approvalMode: params.approvalMode,
+    })
   }
 
   protected async _buildApprovals(quote: SwapQuote) {
@@ -73,10 +88,15 @@ export class UniswapSwapProvider extends SwapProvider<UniswapSwapProviderConfig>
         assetOut: quote.assetOut,
         slippage: quote.slippage,
         deadline: quote.deadline,
-        recipient: quote.recipient!,
-        walletAddress: quote.recipient!,
+        recipient: quote.recipient,
+        walletAddress: quote.recipient,
         chainId: quote.chainId,
         amountInRaw: quote.amountInRaw,
+        approvalMode: resolveApprovalMode(
+          quote.approvalMode,
+          this._config.approvalMode,
+          this._settings.approvalMode,
+        ),
       },
       quote.amountInRaw,
       addresses.permit2,
@@ -84,7 +104,9 @@ export class UniswapSwapProvider extends SwapProvider<UniswapSwapProviderConfig>
     )
   }
 
-  protected async _getQuote(params: SwapQuoteParams): Promise<SwapQuote> {
+  protected async _getQuote(
+    params: SwapQuoteParamsResolved,
+  ): Promise<SwapQuote> {
     const { chainId, assetIn, assetOut } = params
     const addresses = getUniswapAddresses(chainId)
     const publicClient = this.chainManager.getPublicClient(chainId)
@@ -160,7 +182,7 @@ export class UniswapSwapProvider extends SwapProvider<UniswapSwapProviderConfig>
       quotedAt: now,
       expiresAt: deadline,
       gasEstimate: quote.gasEstimate,
-      quotedRecipient: recipient,
+      recipient,
     }
   }
 
@@ -208,7 +230,7 @@ export class UniswapSwapProvider extends SwapProvider<UniswapSwapProviderConfig>
       | UniswapMarketConfig
       | undefined
     if (config?.fee === undefined || config?.tickSpacing === undefined) {
-      throw new Error(
+      throw new AssetMetadataRequiredError(
         `fee and tickSpacing must be configured for pair ${assetIn.metadata.symbol}/${assetOut.metadata.symbol}`,
       )
     }

package/src/{swap → actions/swap}/providers/uniswap/__tests__/UniswapSwapProvider.test.ts

@@ -3,10 +3,10 @@ import { baseSepolia } from 'viem/chains'
 import { describe, expect, it, vi } from 'vitest'
 
 import { MockWETHAsset } from '@/__mocks__/MockAssets.js'
+import type { UniswapSwapProviderConfig } from '@/actions/swap/providers/uniswap/types.js'
+import { UniswapSwapProvider } from '@/actions/swap/providers/uniswap/UniswapSwapProvider.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

package/src/{swap → actions/swap}/providers/uniswap/__tests__/sdk.test.ts

@@ -1,12 +1,19 @@
-import { type Address, type PublicClient, zeroAddress } from 'viem'
+import {
+  type Address,
+  decodeAbiParameters,
+  decodeFunctionData,
+  type PublicClient,
+  zeroAddress,
+} from 'viem'
 import { describe, expect, it, vi } from 'vitest'
 
-import type { SupportedChainId } from '@/constants/supportedChains.js'
+import { UNIVERSAL_ROUTER_ABI } from '@/actions/swap/providers/uniswap/abis.js'
 import {
   calculatePriceImpact,
   encodeUniversalRouterSwap,
   getQuote,
-} from '@/swap/providers/uniswap/encoding.js'
+} from '@/actions/swap/providers/uniswap/encoding.js'
+import type { SupportedChainId } from '@/constants/supportedChains.js'
 import type { Asset } from '@/types/asset.js'
 
 const USDC: Asset = {
@@ -302,6 +309,61 @@ describe('encodeUniversalRouterSwap', () => {
     expect(calldata.length).toBeGreaterThan(10)
   })
 
+  it('tags V4 action bytes per Uniswap v4-periphery Actions.sol', () => {
+    // Regression: SWAP_EXACT_OUT_SINGLE was previously encoded as 0x07, which
+    // V4Router treats as multi-hop SWAP_EXACT_IN. The router decoded our
+    // single-hop EXACT_OUTPUT_SINGLE_PARAMS struct as a PathKey[] path and
+    // bare-reverted on pool lookup. Correct codes:
+    //   0x06 SWAP_EXACT_IN_SINGLE
+    //   0x08 SWAP_EXACT_OUT_SINGLE
+    const decodeActions = (calldata: `0x${string}`): `0x${string}` => {
+      const { args } = decodeFunctionData({
+        abi: UNIVERSAL_ROUTER_ABI,
+        data: calldata,
+      })
+      const [, inputs] = args as readonly [
+        `0x${string}`,
+        ReadonlyArray<`0x${string}`>,
+        bigint,
+      ]
+      const [actions] = decodeAbiParameters(
+        [{ type: 'bytes' }, { type: 'bytes[]' }],
+        inputs[0]!,
+      )
+      return actions as `0x${string}`
+    }
+
+    const exactIn = encodeUniversalRouterSwap({
+      amountInRaw: 100000000n,
+      assetIn: USDC,
+      assetOut: WETH,
+      slippage: 0.005,
+      deadline: 1700000000,
+      recipient: '0xrecipient' as Address,
+      chainId: CHAIN_ID,
+      quote: baseQuote,
+      universalRouterAddress: '0xrouter' as Address,
+      fee: FEE,
+      tickSpacing: TICK_SPACING,
+    })
+    expect(decodeActions(exactIn)).toBe('0x060c0f')
+
+    const exactOut = encodeUniversalRouterSwap({
+      amountOutRaw: 500000000000000000n,
+      assetIn: USDC,
+      assetOut: WETH,
+      slippage: 0.005,
+      deadline: 1700000000,
+      recipient: '0xrecipient' as Address,
+      chainId: CHAIN_ID,
+      quote: baseQuote,
+      universalRouterAddress: '0xrouter' as Address,
+      fee: FEE,
+      tickSpacing: TICK_SPACING,
+    })
+    expect(decodeActions(exactOut)).toBe('0x080c0f')
+  })
+
   it('produces different calldata for exact-in vs exact-out', () => {
     const exactIn = encodeUniversalRouterSwap({
       amountInRaw: 100000000n,

package/src/{swap → actions/swap}/providers/uniswap/addresses.ts

@@ -12,6 +12,7 @@ import {
 
 import { PERMIT2_ADDRESS } from '@/constants/contracts.js'
 import type { SupportedChainId } from '@/constants/supportedChains.js'
+import { ChainNotSupportedError } from '@/core/error/errors.js'
 
 /**
  * Uniswap contract addresses
@@ -97,7 +98,10 @@ export function getUniswapAddresses(
 ): UniswapAddresses {
   const addresses = UNISWAP_ADDRESSES[chainId]
   if (!addresses) {
-    throw new Error(`Uniswap not supported on chain ${chainId}`)
+    throw new ChainNotSupportedError({
+      chainId,
+      supportedChainIds: Object.keys(UNISWAP_ADDRESSES).map(Number),
+    })
   }
   return addresses
 }

package/src/{swap → actions/swap}/providers/uniswap/encoding.ts

@@ -7,7 +7,6 @@ import {
   zeroAddress,
 } from 'viem'
 
-import type { SupportedChainId } from '@/constants/supportedChains.js'
 import {
   CURRENCY_AMOUNT_PARAMS,
   EXACT_INPUT_SINGLE_PARAMS,
@@ -16,7 +15,8 @@ import {
   POOL_KEY_ABI_TYPE,
   QUOTER_ABI,
   UNIVERSAL_ROUTER_ABI,
-} from '@/swap/providers/uniswap/abis.js'
+} from '@/actions/swap/providers/uniswap/abis.js'
+import type { SupportedChainId } from '@/constants/supportedChains.js'
 import type { Asset } from '@/types/asset.js'
 import type { SwapPrice, SwapRoute } from '@/types/swap/index.js'
 import { getAssetAddress, isNativeAsset } from '@/utils/assets.js'
@@ -213,7 +213,7 @@ const V4_SWAP = 0x10
 
 // V4 action types
 const SWAP_EXACT_IN_SINGLE = 0x06
-const SWAP_EXACT_OUT_SINGLE = 0x07
+const SWAP_EXACT_OUT_SINGLE = 0x08
 const SETTLE_ALL = 0x0c
 const TAKE_ALL = 0x0f
 

package/src/{swap → actions/swap}/providers/uniswap/markets.ts

@@ -1,9 +1,9 @@
 import { type Address, encodeAbiParameters, keccak256 } from 'viem'
 
+import { assetPairs } from '@/actions/swap/core/markets.js'
+import { POOL_KEY_ABI_TYPE } from '@/actions/swap/providers/uniswap/abis.js'
 import { UNISWAP } from '@/constants/providers.js'
 import type { SupportedChainId } from '@/constants/supportedChains.js'
-import { assetPairs } from '@/swap/core/markets.js'
-import { POOL_KEY_ABI_TYPE } from '@/swap/providers/uniswap/abis.js'
 import type { Asset } from '@/types/asset.js'
 import type { SwapMarket } from '@/types/swap/index.js'
 

package/src/{swap → actions/swap}/providers/velodrome/VelodromeSwapProvider.ts

@@ -1,27 +1,33 @@
 import { formatUnits } from 'viem'
 
-import { VELODROME } 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 { expandMarkets, findMarket } from '@/actions/swap/core/markets.js'
+import { SwapProvider } from '@/actions/swap/core/SwapProvider.js'
 import {
   getChainConfig,
   getSupportedChainIds,
   getValidMarketConfigs,
-} from '@/swap/providers/velodrome/config.js'
+} from '@/actions/swap/providers/velodrome/config.js'
 import {
-  buildTokenApproval,
   encodePoolSwap,
   fetchPoolQuote,
-} from '@/swap/providers/velodrome/encoding/index.js'
+} from '@/actions/swap/providers/velodrome/encoding/index.js'
 import {
   configToMarkets,
   resolvePoolConfig,
-} from '@/swap/providers/velodrome/markets.js'
+} from '@/actions/swap/providers/velodrome/markets.js'
 import type {
   VelodromeMarketConfig,
   VelodromeSwapProviderConfig,
-} from '@/swap/providers/velodrome/types.js'
+} from '@/actions/swap/providers/velodrome/types.js'
+import { VELODROME } from '@/constants/providers.js'
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+import {
+  ExactOutputNotSupportedError,
+  MarketNotAllowedError,
+} from '@/core/error/errors.js'
+import type { ChainManager } from '@/services/ChainManager.js'
+import type { SwapQuoteParamsResolved } from '@/services/nameservices/ens/types.js'
+import type { SwapSettings } from '@/types/actions.js'
 import type { Asset } from '@/types/asset.js'
 import type {
   GetSwapMarketParams,
@@ -29,9 +35,14 @@ import type {
   ResolvedSwapParams,
   SwapMarket,
   SwapQuote,
-  SwapQuoteParams,
   SwapTransaction,
 } from '@/types/swap/index.js'
+import {
+  buildErc20ApprovalTx,
+  checkTokenAllowance,
+  resolveApprovalMode,
+  resolveErc20ApprovalAmount,
+} from '@/utils/approve.js'
 import { getAssetAddress, isNativeAsset } from '@/utils/assets.js'
 
 /**
@@ -40,6 +51,14 @@ import { getAssetAddress, isNativeAsset } from '@/utils/assets.js'
  * v2 routers (Optimism, Base), leaf routers (Relay chains), and Universal Router (Base Sepolia).
  */
 export class VelodromeSwapProvider extends SwapProvider<VelodromeSwapProviderConfig> {
+  constructor(
+    config: VelodromeSwapProviderConfig,
+    chainManager: ChainManager,
+    settings?: SwapSettings,
+  ) {
+    super(config, chainManager, settings)
+  }
+
   /** @returns Chain IDs where Velodrome/Aerodrome contracts are deployed */
   protocolSupportedChainIds(): SupportedChainId[] {
     return getSupportedChainIds()
@@ -55,9 +74,7 @@ export class VelodromeSwapProvider extends SwapProvider<VelodromeSwapProviderCon
     params: ResolvedSwapParams,
   ): Promise<SwapTransaction> {
     if (params.amountOutRaw !== undefined) {
-      throw new Error(
-        'Velodrome/Aerodrome does not support exact-output swaps. Provide amountIn instead of amountOut.',
-      )
+      throw new ExactOutputNotSupportedError('Velodrome/Aerodrome')
     }
 
     const swapQuote = await this._getQuote({
@@ -73,7 +90,10 @@ export class VelodromeSwapProvider extends SwapProvider<VelodromeSwapProviderCon
       deadline: params.deadline,
       recipient: params.recipient,
     })
-    return this.buildSwapTransactions(swapQuote)
+    return this.buildSwapTransactions({
+      ...swapQuote,
+      approvalMode: params.approvalMode,
+    })
   }
 
   /**
@@ -113,13 +133,13 @@ export class VelodromeSwapProvider extends SwapProvider<VelodromeSwapProviderCon
    * @returns SwapQuote with amounts, price, route, and encoded calldata
    * @throws If amountOut is provided (Velodrome only supports exact-input)
    */
-  protected async _getQuote(params: SwapQuoteParams): Promise<SwapQuote> {
+  protected async _getQuote(
+    params: SwapQuoteParamsResolved,
+  ): Promise<SwapQuote> {
     const { chainId, assetIn, assetOut } = params
 
     if (params.amountOut !== undefined) {
-      throw new Error(
-        'Velodrome/Aerodrome does not support exact-output swaps. Provide amountIn instead of amountOut.',
-      )
+      throw new ExactOutputNotSupportedError('Velodrome/Aerodrome')
     }
 
     const chain = getChainConfig(chainId)
@@ -180,25 +200,44 @@ export class VelodromeSwapProvider extends SwapProvider<VelodromeSwapProviderCon
       quotedAt: now,
       expiresAt: deadline,
       gasEstimate: internalQuote.gasEstimate,
-      quotedRecipient: recipient,
+      recipient,
     }
   }
 
   protected async _buildApprovals(quote: SwapQuote) {
+    if (isNativeAsset(quote.assetIn)) {
+      return { tokenApproval: undefined }
+    }
+
     const chain = getChainConfig(quote.chainId)
     const publicClient = this.chainManager.getPublicClient(quote.chainId)
+    const token = getAssetAddress(quote.assetIn, quote.chainId)
+    const spender = chain.contracts.router
+    const required = quote.amountInRaw
 
-    const tokenApproval = isNativeAsset(quote.assetIn)
-      ? undefined
-      : await buildTokenApproval(
-          getAssetAddress(quote.assetIn, quote.chainId),
-          chain.contracts.router,
-          chain.metadata.routerType,
-          quote.amountInRaw,
-          quote.recipient!,
-          publicClient,
-        )
+    const allowance = await checkTokenAllowance({
+      publicClient,
+      token,
+      owner: quote.recipient,
+      spender,
+    })
+
+    if (allowance >= required) {
+      return { tokenApproval: undefined }
+    }
 
+    const tokenApproval = buildErc20ApprovalTx(
+      token,
+      spender,
+      resolveErc20ApprovalAmount(
+        resolveApprovalMode(
+          quote.approvalMode,
+          this._config.approvalMode,
+          this._settings.approvalMode,
+        ),
+        required,
+      ),
+    )
     return { tokenApproval }
   }
 
@@ -215,9 +254,12 @@ export class VelodromeSwapProvider extends SwapProvider<VelodromeSwapProviderCon
       | VelodromeMarketConfig
       | undefined
     if (!config) {
-      throw new Error(
-        `No market config for pair ${assetIn.metadata.symbol}/${assetOut.metadata.symbol}`,
-      )
+      throw new MarketNotAllowedError({
+        assetInSymbol: assetIn.metadata.symbol,
+        assetOutSymbol: assetOut.metadata.symbol,
+        chainId,
+        reason: 'No market config for this pair',
+      })
     }
     return resolvePoolConfig(config)
   }

package/src/{swap → actions/swap}/providers/velodrome/__tests__/VelodromeSwapProvider.network.test.ts

@@ -14,10 +14,10 @@ import { createPublicClient, http } from 'viem'
 import { base, optimism } from 'viem/chains'
 import { afterAll, beforeAll, describe, expect, it } from 'vitest'
 
+import type { VelodromeSwapProviderConfig } from '@/actions/swap/providers/velodrome/types.js'
+import { VelodromeSwapProvider } from '@/actions/swap/providers/velodrome/VelodromeSwapProvider.js'
 import type { SupportedChainId } from '@/constants/supportedChains.js'
 import type { ChainManager } from '@/services/ChainManager.js'
-import type { VelodromeSwapProviderConfig } from '@/swap/providers/velodrome/types.js'
-import { VelodromeSwapProvider } from '@/swap/providers/velodrome/VelodromeSwapProvider.js'
 import type { Asset } from '@/types/asset.js'
 
 // ── Real mainnet assets ──