@eth-optimism/actions-sdk 0.4.0 → 0.6.0

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

@@ -9,10 +9,10 @@ import {
   MockUSDCAsset as USDC,
   MockWETHAsset as WETH,
 } from '@/__mocks__/MockAssets.js'
+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'
 
 const OP_CHAIN_ID = optimism.id as SupportedChainId
 const BASE_CHAIN_ID = base.id as SupportedChainId
@@ -91,7 +91,7 @@ describe('VelodromeSwapProvider router type routing', () => {
   })
 
   describe('universal router (Base Sepolia)', () => {
-    it('executes swap via Universal Router', async () => {
+    it('executes swap via Universal Router with standard approve', async () => {
       const provider = createProvider(BASE_SEPOLIA_CHAIN_ID)
       const result = await provider.execute({
         amountIn: 100,
@@ -102,12 +102,13 @@ describe('VelodromeSwapProvider router type routing', () => {
       })
 
       expect(result.transactionData.swap).toBeDefined()
-      // Universal Router: uses ERC20.transfer (not approve)
+      // Universal Router pulls tokens via transferFrom (payerIsUser=true), so the
+      // approval is a standard ERC20 approve(router, amount) — NOT a transfer.
+      // See encoding.v2.test.ts and the regression test in VelodromeSwapProvider.test.ts.
       expect(result.transactionData.tokenApproval).toBeDefined()
-      // tokenApproval should be a transfer() call, not approve()
       const approvalData = result.transactionData.tokenApproval!.data
-      // transfer() selector = 0xa9059cbb
-      expect(approvalData.startsWith('0xa9059cbb')).toBe(true)
+      // approve(spender, amount) selector = 0x095ea7b3
+      expect(approvalData.startsWith('0x095ea7b3')).toBe(true)
     })
 
     it('quotes via pool.getAmountOut for Universal Router', async () => {

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

@@ -1,4 +1,5 @@
 import type { Address, PublicClient } from 'viem'
+import { decodeFunctionData, erc20Abi, maxUint256 } from 'viem'
 import { mode, optimism } from 'viem/chains'
 import { describe, expect, it, vi } from 'vitest'
 
@@ -8,15 +9,17 @@ import {
   MockUSDCAsset as USDC,
   MockWETHAsset as WETH,
 } from '@/__mocks__/MockAssets.js'
+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'
 
 const CHAIN_ID = optimism.id as SupportedChainId
 
-function createMockChainManager(): ChainManager {
+function createMockChainManager(
+  supportedChains: SupportedChainId[] = [CHAIN_ID],
+): ChainManager {
   const mockPublicClient = {
     readContract: vi
       .fn()
@@ -34,7 +37,8 @@ function createMockChainManager(): ChainManager {
 
   return {
     getPublicClient: vi.fn().mockReturnValue(mockPublicClient),
-    getSupportedChains: vi.fn().mockReturnValue([CHAIN_ID]),
+    tryGetPublicClient: vi.fn().mockReturnValue(undefined),
+    getSupportedChains: vi.fn().mockReturnValue(supportedChains),
   } as unknown as ChainManager
 }
 
@@ -94,6 +98,44 @@ describe('VelodromeSwapProvider', () => {
       expect(result.transactionData.permit2Approval).toBeUndefined()
     })
 
+    it('approves the exact swap amount in default exact mode', async () => {
+      const provider = createProvider()
+      const result = await provider.execute({
+        amountIn: 100,
+        assetIn: USDC,
+        assetOut: OP,
+        chainId: CHAIN_ID,
+        walletAddress: MOCK_WALLET,
+      })
+
+      const decoded = decodeFunctionData({
+        abi: erc20Abi,
+        data: result.transactionData.tokenApproval!.data,
+      })
+      expect(decoded.functionName).toBe('approve')
+      // 100 USDC at 6 decimals
+      expect(decoded.args[1]).toBe(100_000_000n)
+    })
+
+    it('approves maxUint256 when approvalMode is "max"', async () => {
+      const provider = createProvider()
+      const result = await provider.execute({
+        amountIn: 100,
+        assetIn: USDC,
+        assetOut: OP,
+        chainId: CHAIN_ID,
+        walletAddress: MOCK_WALLET,
+        approvalMode: 'max',
+      })
+
+      const decoded = decodeFunctionData({
+        abi: erc20Abi,
+        data: result.transactionData.tokenApproval!.data,
+      })
+      expect(decoded.functionName).toBe('approve')
+      expect(decoded.args[1]).toBe(maxUint256)
+    })
+
     it('throws for exact-output swaps', async () => {
       const provider = createProvider()
 
@@ -476,7 +518,7 @@ describe('VelodromeSwapProvider', () => {
           amountIn: 100,
           chainId: MODE_CHAIN_ID,
         }),
-      ).rejects.toThrow('CL pools not supported on chain')
+      ).rejects.toThrow('is not supported')
     })
   })
 

package/src/{swap → actions/swap}/providers/velodrome/__tests__/encoding.cl.test.ts

@@ -1,11 +1,14 @@
+import type { Hex } from 'viem'
+import { decodeAbiParameters } from 'viem'
 import { describe, expect, it } from 'vitest'
 
 import { MockUSDCAsset, MockWETHAsset } from '@/__mocks__/MockAssets.js'
-import { UNIVERSAL_ROUTER_ABI } from '@/swap/providers/velodrome/abis.js'
+import { UNIVERSAL_ROUTER_ABI } from '@/actions/swap/providers/velodrome/abis.js'
 import {
   encodeCLSwap,
   encodeSwap,
-} from '@/swap/providers/velodrome/encoding/index.js'
+} from '@/actions/swap/providers/velodrome/encoding/index.js'
+import { V3_SWAP_EXACT_IN_INPUT_PARAMS } from '@/actions/swap/providers/velodrome/encoding/routers/cl.js'
 
 import {
   BASE_CHAIN_ID,
@@ -39,6 +42,32 @@ describe('encodeCLSwap', () => {
     expect(deadline).toBe(BigInt(DEADLINE))
   })
 
+  // Regression for #438: payerIsUser must be true so the router pulls tokens via
+  // transferFrom against an ERC20 allowance. See encoding.v2.test.ts for context.
+  it('encodes V3_SWAP_EXACT_IN with payerIsUser = true', () => {
+    const data = encodeCLSwap({
+      assetIn: MockUSDCAsset,
+      assetOut: MockWETHAsset,
+      amountInRaw: 1000000n,
+      amountOutMin: 400000000000000000n,
+      tickSpacing: 100,
+      recipient: RECIPIENT,
+      deadline: DEADLINE,
+      chainId: BASE_CHAIN_ID,
+    })
+
+    const { args } = decode<[Hex, Hex[], bigint]>(UNIVERSAL_ROUTER_ABI, data)
+    const [, inputs] = args
+    const decoded = decodeAbiParameters(
+      V3_SWAP_EXACT_IN_INPUT_PARAMS,
+      inputs[0],
+    )
+    const payerIsUserIdx = V3_SWAP_EXACT_IN_INPUT_PARAMS.findIndex(
+      (p) => p.name === 'payerIsUser',
+    )
+    expect(decoded[payerIsUserIdx]).toBe(true)
+  })
+
   it('produces different calldata than V2 universal router swap', () => {
     const clData = encodeCLSwap({
       assetIn: MockUSDCAsset,

package/src/{swap → actions/swap}/providers/velodrome/__tests__/encoding.v2.test.ts

@@ -1,4 +1,5 @@
-import type { Address } from 'viem'
+import type { Address, Hex } from 'viem'
+import { decodeAbiParameters } from 'viem'
 import { describe, expect, it } from 'vitest'
 
 import {
@@ -10,8 +11,9 @@ import {
   LEAF_ROUTER_ABI,
   UNIVERSAL_ROUTER_ABI,
   V2_ROUTER_ABI,
-} from '@/swap/providers/velodrome/abis.js'
-import { encodeSwap } from '@/swap/providers/velodrome/encoding/index.js'
+} from '@/actions/swap/providers/velodrome/abis.js'
+import { encodeSwap } from '@/actions/swap/providers/velodrome/encoding/index.js'
+import { V2_SWAP_EXACT_IN_INPUT_PARAMS } from '@/actions/swap/providers/velodrome/encoding/routers/v2.js'
 
 import {
   BASE_CHAIN_ID,
@@ -197,6 +199,35 @@ describe('encodeSwap', () => {
       expect(inputs).toHaveLength(1)
       expect(deadline).toBe(BigInt(DEADLINE))
     })
+
+    // Regression for #438: payerIsUser must be true so the router pulls tokens via
+    // transferFrom against an ERC20 allowance. payerIsUser=false requires tokens to
+    // be pre-deposited to the router, which only works when caller batches atomically.
+    it('encodes V2_SWAP_EXACT_IN with payerIsUser = true', () => {
+      const data = encodeSwap({
+        assetIn: MockUSDCAsset,
+        assetOut: MockWETHAsset,
+        amountInRaw: 1000000n,
+        amountOutMin: 400000000000000000n,
+        routerType: 'universal',
+        stable: false,
+        factoryAddress: FACTORY,
+        recipient: RECIPIENT,
+        deadline: DEADLINE,
+        chainId: BASE_CHAIN_ID,
+      })
+
+      const { args } = decode<[Hex, Hex[], bigint]>(UNIVERSAL_ROUTER_ABI, data)
+      const [, inputs] = args
+      const decoded = decodeAbiParameters(
+        V2_SWAP_EXACT_IN_INPUT_PARAMS,
+        inputs[0],
+      )
+      const payerIsUserIdx = V2_SWAP_EXACT_IN_INPUT_PARAMS.findIndex(
+        (p) => p.name === 'payerIsUser',
+      )
+      expect(decoded[payerIsUserIdx]).toBe(true)
+    })
   })
 
   describe('router type comparison', () => {

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

@@ -1,4 +1,5 @@
 import type { SupportedChainId } from '@/constants/supportedChains.js'
+import { ChainNotSupportedError } from '@/core/error/errors.js'
 
 import { VELODROME_CHAINS, type VelodromeChainConfig } from './addresses.js'
 import type { VelodromeMarketConfig } from './types.js'
@@ -20,7 +21,10 @@ export function getChainConfig(
 ): VelodromeChainConfig {
   const config = VELODROME_CHAINS[chainId]
   if (!config) {
-    throw new Error(`Velodrome/Aerodrome not supported on chain ${chainId}`)
+    throw new ChainNotSupportedError({
+      chainId,
+      supportedChainIds: getSupportedChainIds(),
+    })
   }
   return config
 }

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

@@ -1,9 +1,10 @@
 import type { Address } from 'viem'
 import { formatUnits } from 'viem'
 
+import { UNIVERSAL_ROUTER_MSG_SENDER } from '@/actions/swap/core/markets.js'
 import { WETH } from '@/constants/assets.js'
 import type { SupportedChainId } from '@/constants/supportedChains.js'
-import { UNIVERSAL_ROUTER_MSG_SENDER } from '@/swap/core/markets.js'
+import { ChainNotSupportedError } from '@/core/error/errors.js'
 import type { Asset } from '@/types/asset.js'
 import type { SwapPrice, SwapRoute } from '@/types/swap/index.js'
 import { getAssetAddress, isNativeAsset } from '@/utils/assets.js'
@@ -42,7 +43,7 @@ export function resolveTokens(
 export function getWrappedNativeAddress(chainId: SupportedChainId): Address {
   const addr = WETH.address[chainId]
   if (!addr || addr === 'native') {
-    throw new Error(`No WETH address configured for chain ${chainId}`)
+    throw new ChainNotSupportedError({ chainId })
   }
   return addr
 }

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

@@ -1,6 +1,5 @@
 export type { PoolQuoteResult } from './poolRouter.js'
 export { encodePoolSwap, fetchPoolQuote } from './poolRouter.js'
-export { buildTokenApproval } from './routers/approval.js'
 export type { EncodeCLSwapParams, GetCLQuoteParams } from './routers/cl.js'
 export { encodeCLSwap, getCLQuote } from './routers/cl.js'
 export type { EncodeSwapParams, GetQuoteParams } from './routers/v2.js'

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

@@ -1,8 +1,9 @@
 import type { Address, Hex, PublicClient } from 'viem'
 
+import type { VelodromeChainConfig } from '@/actions/swap/providers/velodrome/config.js'
+import type { ResolvedPoolConfig } from '@/actions/swap/providers/velodrome/types.js'
 import type { SupportedChainId } from '@/constants/supportedChains.js'
-import type { VelodromeChainConfig } from '@/swap/providers/velodrome/config.js'
-import type { ResolvedPoolConfig } from '@/swap/providers/velodrome/types.js'
+import { ChainNotSupportedError } from '@/core/error/errors.js'
 import type { Asset } from '@/types/asset.js'
 import type { SwapPrice } from '@/types/swap/index.js'
 
@@ -36,7 +37,7 @@ export async function fetchPoolQuote(
 
   if (poolConfig.type === 'cl') {
     if (!chain.contracts.clPoolFactory || !chain.contracts.clQuoterV2) {
-      throw new Error(`CL pools not supported on chain ${chainId}`)
+      throw new ChainNotSupportedError({ chainId })
     }
     const internalQuote = await getCLQuote({
       assetIn,

package/src/{swap → actions/swap}/providers/velodrome/encoding/routers/cl.ts

@@ -1,17 +1,18 @@
 import type { Address, Hex, PublicClient } from 'viem'
 import { encodeAbiParameters, encodeFunctionData, encodePacked } from 'viem'
 
-import type { SupportedChainId } from '@/constants/supportedChains.js'
 import {
   CL_POOL_FACTORY_ABI,
   CL_QUOTER_ABI,
   UNIVERSAL_ROUTER_ABI,
-} from '@/swap/providers/velodrome/abis.js'
+} from '@/actions/swap/providers/velodrome/abis.js'
 import {
   buildSwapPrice,
   resolveTokens,
   UNIVERSAL_ROUTER_MSG_SENDER,
-} from '@/swap/providers/velodrome/encoding/helpers.js'
+} from '@/actions/swap/providers/velodrome/encoding/helpers.js'
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+import { MarketNotAllowedError } from '@/core/error/errors.js'
 import type { Asset } from '@/types/asset.js'
 import type { SwapPrice, SwapRoute } from '@/types/swap/index.js'
 
@@ -62,9 +63,12 @@ export async function getCLQuote(params: GetCLQuoteParams): Promise<SwapPrice> {
     !poolAddress ||
     poolAddress === '0x0000000000000000000000000000000000000000'
   ) {
-    throw new Error(
-      `No CL pool found for ${assetIn.metadata.symbol}/${assetOut.metadata.symbol} (tickSpacing=${tickSpacing})`,
-    )
+    throw new MarketNotAllowedError({
+      assetInSymbol: assetIn.metadata.symbol,
+      assetOutSymbol: assetOut.metadata.symbol,
+      chainId,
+      reason: `No CL pool found for ${assetIn.metadata.symbol}/${assetOut.metadata.symbol} (tickSpacing=${tickSpacing})`,
+    })
   }
 
   // Quote via QuoterV2.quoteExactInputSingle
@@ -109,9 +113,22 @@ export interface EncodeCLSwapParams {
 /** Universal Router V3_SWAP_EXACT_IN command byte */
 const V3_SWAP_EXACT_IN = 0x00
 
+/** ABI param shape for the V3_SWAP_EXACT_IN input payload. Shared with tests. */
+export const V3_SWAP_EXACT_IN_INPUT_PARAMS = [
+  { name: 'recipient', type: 'address' },
+  { name: 'amountIn', type: 'uint256' },
+  { name: 'amountOutMin', type: 'uint256' },
+  { name: 'path', type: 'bytes' },
+  { name: 'payerIsUser', type: 'bool' },
+] as const
+
 /**
  * Encode a V3_SWAP_EXACT_IN command for a CL/Slipstream pool on the Universal Router.
  * Path: encodePacked([tokenIn (20), tickSpacing as int24 (3), tokenOut (20)]) — 43 bytes.
+ *
+ * payerIsUser = true: the router pulls tokens from msg.sender via standard
+ * transferFrom against an existing ERC20 allowance. Works for both EOAs (sequential
+ * approve + execute) and smart wallets (atomic approve + execute in one UserOp).
  * @param params - CL swap encoding parameters
  * @returns Encoded calldata as hex string
  */
@@ -123,7 +140,7 @@ export function encodeCLSwap(params: EncodeCLSwapParams): Hex {
     chainId,
   )
 
-  const commands = `0x${V3_SWAP_EXACT_IN.toString(16).padStart(2, '0')}` as Hex
+  const commands = encodePacked(['uint8'], [V3_SWAP_EXACT_IN])
 
   // CL path: [tokenIn (20)] [tickSpacing as int24 (3)] [tokenOut (20)] — 43 bytes
   const path = encodePacked(
@@ -131,22 +148,13 @@ export function encodeCLSwap(params: EncodeCLSwapParams): Hex {
     [tokenIn, tickSpacing, tokenOut],
   )
 
-  const input = encodeAbiParameters(
-    [
-      { type: 'address' },
-      { type: 'uint256' },
-      { type: 'uint256' },
-      { type: 'bytes' },
-      { type: 'bool' },
-    ],
-    [
-      UNIVERSAL_ROUTER_MSG_SENDER, // recipient = msg.sender (Universal Router sentinel)
-      amountInRaw,
-      amountOutMin,
-      path,
-      false, // payerIsUser — tokens pre-transferred to router
-    ],
-  )
+  const input = encodeAbiParameters(V3_SWAP_EXACT_IN_INPUT_PARAMS, [
+    UNIVERSAL_ROUTER_MSG_SENDER, // recipient = msg.sender (Universal Router sentinel)
+    amountInRaw,
+    amountOutMin,
+    path,
+    true, // payerIsUser — router pulls from msg.sender via transferFrom
+  ])
 
   return encodeFunctionData({
     abi: UNIVERSAL_ROUTER_ABI,

package/src/{swap → actions/swap}/providers/velodrome/encoding/routers/v2.ts

@@ -1,20 +1,21 @@
 import type { Address, Hex, PublicClient } from 'viem'
 import { encodeAbiParameters, encodeFunctionData, encodePacked } from 'viem'
 
-import type { SupportedChainId } from '@/constants/supportedChains.js'
 import {
   LEAF_ROUTER_ABI,
   POOL_ABI,
   POOL_FACTORY_ABI,
   UNIVERSAL_ROUTER_ABI,
   V2_ROUTER_ABI,
-} from '@/swap/providers/velodrome/abis.js'
-import type { VelodromeRouterType } from '@/swap/providers/velodrome/config.js'
+} from '@/actions/swap/providers/velodrome/abis.js'
+import type { VelodromeRouterType } from '@/actions/swap/providers/velodrome/config.js'
 import {
   buildSwapPrice,
   resolveTokens,
   UNIVERSAL_ROUTER_MSG_SENDER,
-} from '@/swap/providers/velodrome/encoding/helpers.js'
+} from '@/actions/swap/providers/velodrome/encoding/helpers.js'
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+import { MarketNotAllowedError } from '@/core/error/errors.js'
 import type { Asset } from '@/types/asset.js'
 import type { SwapPrice, SwapRoute } from '@/types/swap/index.js'
 import { isNativeAsset } from '@/utils/assets.js'
@@ -22,6 +23,16 @@ import { isNativeAsset } from '@/utils/assets.js'
 /** Universal Router V2_SWAP_EXACT_IN command byte */
 const V2_SWAP_EXACT_IN = 0x08
 
+/** ABI param shape for the V2_SWAP_EXACT_IN input payload. Shared with tests. */
+export const V2_SWAP_EXACT_IN_INPUT_PARAMS = [
+  { name: 'recipient', type: 'address' },
+  { name: 'amountIn', type: 'uint256' },
+  { name: 'amountOutMin', type: 'uint256' },
+  { name: 'route', type: 'bytes' },
+  { name: 'payerIsUser', type: 'bool' },
+  { name: 'isUni', type: 'bool' },
+] as const
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Quoting
 // ─────────────────────────────────────────────────────────────────────────────
@@ -109,9 +120,12 @@ async function fetchAmountOutViaPool(
     !poolAddress ||
     poolAddress === '0x0000000000000000000000000000000000000000'
   ) {
-    throw new Error(
-      `No Velodrome pool found for ${assetIn.metadata.symbol}/${assetOut.metadata.symbol} (stable=${stable})`,
-    )
+    throw new MarketNotAllowedError({
+      assetInSymbol: assetIn.metadata.symbol,
+      assetOutSymbol: assetOut.metadata.symbol,
+      chainId: params.chainId,
+      reason: `No Velodrome pool found for ${assetIn.metadata.symbol}/${assetOut.metadata.symbol} (stable=${stable})`,
+    })
   }
 
   return (await publicClient.readContract({
@@ -192,36 +206,29 @@ export function encodeSwap(params: EncodeSwapParams): Hex {
 /**
  * Encode a V2_SWAP_EXACT_IN command for the Universal Router.
  * Route: encodePacked(tokenIn, stable, tokenOut) — 41 bytes per hop.
- * payerIsUser = false: tokens are pre-transferred to the Router by the smart wallet.
+ *
+ * payerIsUser = true: the router pulls tokens from msg.sender via standard
+ * transferFrom against an existing ERC20 allowance. Works for both EOAs (sequential
+ * approve + execute) and smart wallets (atomic approve + execute in one UserOp).
  */
 function encodeUniversalV2Swap(
   tokenIn: Address,
   tokenOut: Address,
   params: EncodeSwapParams,
 ): Hex {
-  const commands = `0x${V2_SWAP_EXACT_IN.toString(16).padStart(2, '0')}` as Hex
+  const commands = encodePacked(['uint8'], [V2_SWAP_EXACT_IN])
   const routes = encodePacked(
     ['address', 'bool', 'address'],
     [tokenIn, params.stable, tokenOut],
   )
-  const input = encodeAbiParameters(
-    [
-      { type: 'address' },
-      { type: 'uint256' },
-      { type: 'uint256' },
-      { type: 'bytes' },
-      { type: 'bool' },
-      { type: 'bool' },
-    ],
-    [
-      UNIVERSAL_ROUTER_MSG_SENDER, // recipient = msg.sender (Universal Router sentinel)
-      params.amountInRaw,
-      params.amountOutMin,
-      routes,
-      false, // payerIsUser
-      false, // isUni — false for Velodrome/Aerodrome
-    ],
-  )
+  const input = encodeAbiParameters(V2_SWAP_EXACT_IN_INPUT_PARAMS, [
+    UNIVERSAL_ROUTER_MSG_SENDER, // recipient = msg.sender (Universal Router sentinel)
+    params.amountInRaw,
+    params.amountOutMin,
+    routes,
+    true, // payerIsUser — router pulls from msg.sender via transferFrom
+    false, // isUni — false for Velodrome/Aerodrome
+  ])
   return encodeFunctionData({
     abi: UNIVERSAL_ROUTER_ABI,
     functionName: 'execute',

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

@@ -1,9 +1,10 @@
 import type { Address } from 'viem'
 import { concat, keccak256 } from 'viem'
 
+import { assetPairs } from '@/actions/swap/core/markets.js'
 import { VELODROME } from '@/constants/providers.js'
 import type { SupportedChainId } from '@/constants/supportedChains.js'
-import { assetPairs } from '@/swap/core/markets.js'
+import { AssetMetadataRequiredError } from '@/core/error/errors.js'
 import type { Asset } from '@/types/asset.js'
 import type { SwapMarket } from '@/types/swap/index.js'
 
@@ -22,12 +23,12 @@ export function resolvePoolConfig(
   const hasStable = config.stable !== undefined
   const hasTick = config.tickSpacing !== undefined
   if (hasStable && hasTick) {
-    throw new Error(
+    throw new AssetMetadataRequiredError(
       'stable and tickSpacing are mutually exclusive — set one, not both',
     )
   }
   if (!hasStable && !hasTick) {
-    throw new Error(
+    throw new AssetMetadataRequiredError(
       'Either stable (v2 AMM) or tickSpacing (CL) must be configured',
     )
   }