fix: harden amount sanity checks for CoW order and swap flows

apps/agentic-server/src/routes/chat.ts

@@ -46,6 +46,7 @@ import type {
   SafeChainDeployment,
   WalletContext,
 } from '../utils/walletContextSimple'
+import { wrapTools } from '../utils/wrapTools'
 
 const allEvmChainIds = [
   ethChainId,
@@ -60,31 +61,6 @@ const allEvmChainIds = [
 
 const allSupportedChainIds = [...allEvmChainIds, solanaChainId]
 
-function wrapTool<TSchema, TExecute extends (args: never, walletContext?: WalletContext) => unknown>(
-  name: string,
-  tool: { description: string; inputSchema: TSchema; execute: TExecute },
-  walletContext?: WalletContext
-) {
-  return {
-    description: tool.description,
-    inputSchema: tool.inputSchema,
-    execute: (args: Parameters<TExecute>[0]) => {
-      console.log(`[Tool] ${name}:`, JSON.stringify(args, null, 2))
-      return tool.execute(args, walletContext)
-    },
-  }
-}
-
-function wrapTools(
-  tools: Record<
-    string,
-    { description: string; inputSchema: unknown; execute: (args: never, walletContext?: WalletContext) => unknown }
-  >,
-  walletContext?: WalletContext
-) {
-  return Object.fromEntries(Object.entries(tools).map(([name, tool]) => [name, wrapTool(name, tool, walletContext)]))
-}
-
 function buildWalletContext(
   evmAddress?: string,
   solanaAddress?: string,
@@ -380,17 +356,17 @@ If unsure whether a number is USD or tokens, ask the user.
 
 <percentage-limit-price>
 When a user requests a limit order based on a percentage change (e.g., "sell when price goes up X%", "buy if it drops X%"):
-1. Call getAssetPrices to get the current USD price per token
-2. Call mathCalculator: limitPrice = currentPricePerToken × (1 + percentage / 100) for increases, or × (1 - percentage / 100) for decreases
+1. Call getAssetPrices for both the sell and buy assets.
+2. Call mathCalculator: currentPairPrice = sellAssetUsdPrice / buyAssetUsdPrice. Then limitPrice = currentPairPrice × (1 + percentage / 100) for increases, or × (1 - percentage / 100) for decreases.
 3. Pass the computed limitPrice to createLimitOrder
 
 <example>
-"Sell FOX when it goes up 2%" — FOX current price = $0.0065
-limitPrice = 0.0065 × 1.02 = 0.00663
-Do NOT use the total portfolio value or USD amount — limitPrice is always per-token.
+"Sell FOX for USDC when it goes up 2%" — FOX = $0.0065, USDC = $1
+limitPrice = (0.0065 / 1) × 1.02 = 0.00663 USDC per FOX
+For a crypto-to-crypto pair, divide by the buy token USD price too. Do NOT use the total portfolio value — limitPrice is always buy tokens per sell token.
 </example>
 
-Sanity check: if your computed limitPrice differs from the current market price by more than 100×, stop and confirm with the user before submitting.
+If the tool flags an inverted, USD-like, or distant target, ask the user to confirm the exact price in buy tokens per sell token. Do not automatically change the price or retry with priceConfirmed=true. Use priceConfirmed=true only after the user explicitly confirms the flagged target.
 </percentage-limit-price>
 
 <swap-rules>
@@ -554,16 +530,18 @@ export async function handleChatRequest(c: Context) {
       knownTransactions
     )
 
-    // Convert UIMessages to ModelMessages
-    const modelMessages = convertToModelMessages(messages as Parameters<typeof convertToModelMessages>[0])
+    const tools = buildTools(walletContext)
+
+    // Apply the same output filtering to previous turns as to live tool results.
+    const modelMessages = convertToModelMessages(messages as Parameters<typeof convertToModelMessages>[0], { tools })
 
     const result = streamText({
       model: getModel(),
       messages: modelMessages,
       system: buildSystemPrompt(evmAddress, solanaAddress, approvedChainIds, safeDeploymentState),
       temperature: 0.3,
       stopWhen: stepCountIs(5),
-      tools: buildTools(walletContext),
+      tools,
       // Venice-specific parameters to disable reasoning for faster responses
       ...(getProviderName() === 'venice' && {
         providerOptions: {

apps/agentic-server/src/tools/initiateSwap.ts

@@ -1,6 +1,7 @@
 import { fromAssetId } from '@shapeshiftoss/caip'
 import type { Asset, GetRateOutput } from '@shapeshiftoss/types'
 import { toBigInt, toBaseUnit } from '@shapeshiftoss/utils'
+import BigNumber from 'bignumber.js'
 import { encodeFunctionData, erc20Abi, getAddress } from 'viem'
 import { z } from 'zod'
 
@@ -14,6 +15,7 @@ import { isEvmChain } from '../utils/chains/helpers'
 import { getBebopRate } from '../utils/getBebopRate'
 import { getRelayRate } from '../utils/getRelayRate'
 import { networkToFeeSymbol } from '../utils/networkHelpers'
+import { tokenAmountSchema, tokenAmountToBaseUnit } from '../utils/tokenAmount'
 import { createTransaction } from '../utils/transactionHelpers'
 import { getAddressForChain } from '../utils/walletContextSimple'
 import type { WalletContext } from '../utils/walletContextSimple'
@@ -207,31 +209,51 @@ async function executeSwapInternal({
   sellAmountCrypto: string
   walletContext?: WalletContext
 }): Promise<z.infer<typeof swapPreparationSchema>> {
-  if (!Number.isFinite(parseFloat(sellAmountCrypto)) || parseFloat(sellAmountCrypto) <= 0) {
-    throw new Error('Sell amount must be a positive number')
-  }
+  sellAmountCrypto = tokenAmountSchema.parse(sellAmountCrypto)
 
   const { sellAsset, buyAsset } = await resolveSwapAssets(sellAssetInput, buyAssetInput, walletContext)
 
+  const sellAmountBaseUnit = tokenAmountToBaseUnit(sellAmountCrypto, sellAsset)
+
+  // Guard likely USD-vs-token amount mismatches for expensive assets.
+  // Example mistake: entering "100" for ETH when intent was "$100 worth of ETH".
+  const sellAssetPrice = parseFloat(sellAsset.price || '0')
+  const sellAmountNum = parseFloat(sellAmountCrypto)
+  const sellValueUsd = sellAssetPrice > 0 ? sellAmountNum * sellAssetPrice : 0
+  const hasCurrencyLikePrecision = /^\d+(\.\d{1,2})?$/.test(sellAmountCrypto.trim())
+  const looksLikeUsdAsTokenAmount =
+    hasCurrencyLikePrecision && sellAssetPrice >= 10 && sellValueUsd >= 50_000 && sellAmountNum <= 100_000
+
   const sellAddress = getAddressForChain(walletContext, sellAsset.chainId)
   const buyAddress = getAddressForChain(walletContext, buyAsset.chainId)
 
   validateAddress(sellAddress, sellAsset.chainId)
   validateAddress(buyAddress, buyAsset.chainId)
 
+  try {
+    await validateSufficientBalance(sellAddress, sellAsset, sellAmountCrypto)
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    if (looksLikeUsdAsTokenAmount && message.includes('Insufficient')) {
+      throw new Error(
+        `${message} This request may be using a USD amount as token units. ` +
+          `If you meant a dollar value, use the USD swap flow (e.g. "$${sellAmountCrypto} worth").`
+      )
+    }
+    throw error
+  }
+
   const bestRate = await fetchBestSwapRate(sellAddress, buyAddress, sellAsset, buyAsset, sellAmountCrypto)
 
   const allowanceData = await getAllowance({
-    amount: toBaseUnit(sellAmountCrypto, sellAsset.precision),
+    amount: sellAmountBaseUnit,
     asset: sellAsset,
     from: sellAddress,
     spender: bestRate.approvalTarget,
   })
 
   const needsApproval = allowanceData.isApprovalRequired
 
-  await validateSufficientBalance(sellAddress, sellAsset, sellAmountCrypto)
-
   const approvalTx = buildApprovalTransaction(
     needsApproval,
     sellAsset,
@@ -274,7 +296,9 @@ async function executeSwapInternal({
 export const initiateSwapSchema = z.object({
   sellAsset: assetInputSchema.describe('Asset to sell'),
   buyAsset: assetInputSchema.describe('Asset to buy'),
-  sellAmount: z.string().describe('Amount to sell in crypto tokens, e.g. 1 for 1 ETH, 0.5 for 0.5 SOL'),
+  sellAmount: tokenAmountSchema.describe(
+    'Amount to sell in TOKEN units (not USD), e.g. "1" for 1 ETH, "0.5" for 0.5 SOL. Never pass base units (like wei), and do not pass dollar amounts here.'
+  ),
 })
 
 export type InitiateSwapInput = z.infer<typeof initiateSwapSchema>
@@ -326,7 +350,9 @@ export async function executeInitiateSwapUsd(
     throw new Error(`Unable to fetch price for ${sellAsset.symbol}. Price data may be unavailable.`)
   }
 
-  const sellAmountCrypto = (parseFloat(sellAmountUsd) / sellAssetPrice).toString()
+  const sellAmountCrypto = new BigNumber(tokenAmountSchema.parse(sellAmountUsd))
+    .div(sellAssetPrice)
+    .toFixed(sellAsset.precision, BigNumber.ROUND_DOWN)
 
   return executeSwapInternal({
     sellAssetInput,

apps/agentic-server/src/tools/limitOrder/__tests__/validateLimitPrice.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, test } from 'bun:test'
+
+import { validateLimitPrice } from '../validateLimitPrice'
+
+const arb = { symbol: 'ARB', price: '0.5' }
+const usdc = { symbol: 'USDC', price: '1' }
+
+describe('limit price sanity checks', () => {
+  test('asks for clarification on the advertised sub-dollar inversion', () => {
+    expect(() => validateLimitPrice('2', arb, usdc)).toThrow('inverted pair price')
+    expect(() => validateLimitPrice('2', arb, usdc)).toThrow('confirm the exact target in USDC per 1 ARB')
+    expect(() => validateLimitPrice('2', arb, usdc, true)).not.toThrow()
+  })
+
+  test('accepts the market rate and ordinary percentage targets', () => {
+    for (const price of ['0.5', '0.525', '0.45']) expect(() => validateLimitPrice(price, arb, usdc)).not.toThrow()
+    // ARB $0.12 / EUL $1.39, with a 5% increase in the pair rate.
+    expect(() =>
+      validateLimitPrice('0.09064748201438849', { symbol: 'ARB', price: '0.12' }, { symbol: 'EUL', price: '1.39' })
+    ).not.toThrow()
+  })
+
+  test('flags USD prices used as crypto-to-crypto pair prices', () => {
+    const sell = { symbol: 'ARB', price: '0.12' }
+    const buy = { symbol: 'EUL', price: '1.39' }
+    expect(() => validateLimitPrice('1.39', sell, buy)).toThrow('USD token price')
+    expect(() => validateLimitPrice('1.39', sell, buy, true)).not.toThrow()
+  })
+
+  test('allows explicitly confirmed distant future targets', () => {
+    expect(() => validateLimitPrice('600', arb, usdc)).toThrow('more than 10×')
+    expect(() => validateLimitPrice('600', arb, usdc, true)).not.toThrow()
+    expect(() => validateLimitPrice('0.0001', arb, usdc)).toThrow('more than 10×')
+    expect(() => validateLimitPrice('0.0001', arb, usdc, true)).not.toThrow()
+  })
+
+  test('does not round tiny pair rates to zero in guidance', () => {
+    const sell = { symbol: 'SMALL', price: '0.000001' }
+    const buy = { symbol: 'WETH', price: '3000' }
+    expect(() => validateLimitPrice('0.000001', sell, buy)).toThrow('3.3333333e-10')
+    expect(() => validateLimitPrice('0.000000000333333333', sell, buy)).not.toThrow()
+  })
+
+  test('rejects invalid prices regardless of market data or confirmation', () => {
+    for (const value of ['0', '-1', 'NaN', 'Infinity', '1 USDC', '']) {
+      expect(() => validateLimitPrice(value, arb, usdc, true)).toThrow('positive number')
+      expect(() => validateLimitPrice(value, { symbol: 'ARB', price: '0' }, usdc)).toThrow('positive number')
+    }
+  })
+
+  test('does not infer an inversion from unavailable prices', () => {
+    for (const price of ['0', 'NaN', 'Infinity', '-1']) {
+      expect(() => validateLimitPrice('0.5', { symbol: 'ARB', price }, usdc)).not.toThrow()
+      expect(() => validateLimitPrice('0.5', arb, { symbol: 'USDC', price })).not.toThrow()
+    }
+  })
+})

apps/agentic-server/src/tools/limitOrder/createLimitOrder.ts

@@ -12,22 +12,30 @@ import type { TransactionData } from '../../lib/schemas/swapSchemas'
 import { getAllowance } from '../../utils'
 import { buildApprovalTransaction } from '../../utils/approvalHelpers'
 import { isNativeToken, resolveAsset } from '../../utils/assetHelpers'
+import { validateSufficientBalance } from '../../utils/balanceHelpers'
+import { tokenAmountSchema, tokenAmountToBaseUnit } from '../../utils/tokenAmount'
 import { getAddressForChain } from '../../utils/walletContextSimple'
 import type { WalletContext } from '../../utils/walletContextSimple'
 
+import { validateLimitPrice } from './validateLimitPrice'
+
 export const createLimitOrderSchema = z.object({
   sellAsset: z.string().describe('Token symbol or name to sell (e.g., "USDC", "WETH")'),
   buyAsset: z.string().describe('Token symbol or name to buy (e.g., "USDC", "WETH")'),
   network: cowSupportedNetworkSchema.describe('Network for the limit order'),
-  sellAmount: z
+  sellAmount: tokenAmountSchema.describe(
+    'Amount to sell in TOKEN units, not USD (e.g., "100" for 100 USDC, "230" for 230 ARB). Never pass base units even if precision is 18 (e.g., not "230000000000000000000"). If the user specified a USD dollar amount, convert to token units first using getAssetPricesTool and mathCalculatorTool.'
+  ),
+  limitPrice: z
     .string()
     .describe(
-      'Amount to sell in TOKEN units, not USD (e.g., "100" for 100 USDC, "0.5" for 0.5 WETH). If the user specified a USD dollar amount, convert to token units first using getAssetPricesTool and mathCalculatorTool.'
+      'How much buyAsset you receive per 1 sellAsset. Do not invert the pair rate. For ARB at $0.50 USD selling for USDC at $1, the current pair rate is 0.50 USDC/ARB; 2 is a different future target. "sell A when worth X B" → limitPrice=X. Example: "worth 2 USDT" → "2". For percentage-based requests ("sell when up 5%"), compute: (sellAssetUsdPrice / buyAssetUsdPrice) × (1 + pct/100). Use getAssetPrices if uncertain.'
     ),
-  limitPrice: z
-    .string()
+  priceConfirmed: z
+    .boolean()
+    .optional()
     .describe(
-      'How much buyAsset you receive per 1 sellAsset. "sell A when worth X B" → limitPrice=X. Example: "worth 2 USDT" → "2". For percentage-based requests ("sell when up 5%"), compute: currentPricePerToken × (1 + pct/100).'
+      'Set true only after asking the user to confirm a flagged price and receiving explicit confirmation of the exact buyAsset-per-sellAsset target. Never set this automatically to bypass a validation error.'
     ),
   expirationHours: z
     .number()
@@ -95,6 +103,10 @@ export async function executeCreateLimitOrder(
     resolveAsset({ symbolOrName: input.buyAsset, network: input.network }, walletContext),
   ])
 
+  const sellAmountBaseUnit = tokenAmountToBaseUnit(input.sellAmount, sellAsset)
+
+  validateLimitPrice(input.limitPrice, sellAsset, buyAsset, input.priceConfirmed)
+
   // Get numeric chain ID directly from network (Zod schema guarantees valid network)
   const evmChainId = NETWORK_TO_CHAIN_ID[input.network]!
 
@@ -120,12 +132,13 @@ export async function executeCreateLimitOrder(
   const buyToken = resolveCowTokenAddress(buyAsset, isNativeBuyToken)
 
   // Calculate amounts in base units
-  const sellAmountBaseUnit = toBaseUnit(input.sellAmount, sellAsset.precision)
   const buyAmountBaseUnit = calculateBuyAmount(buyAsset, input.sellAmount, input.limitPrice)
 
   // Get approval target (CoW VaultRelayer contract - same address across all chains)
   const approvalTarget = COW_VAULT_RELAYER_ADDRESS
 
+  await validateSufficientBalance(userAddress, sellAsset, input.sellAmount)
+
   // Check allowance for sell token
   const { isApprovalRequired: needsApproval } = await getAllowance({
     amount: sellAmountBaseUnit,
@@ -199,7 +212,16 @@ IMPORTANT:
 - Currently supports: Ethereum, Gnosis, Arbitrum
 - Order executes automatically when market price reaches limit
 - If user specifies total amounts (e.g., "10 USDC for 20 USDT"), use the maths tool to calculate limitPrice (20÷10=2)
-- For percentage-based requests ("sell when up X%"), compute limitPrice = currentPricePerToken × (1 + X/100) using getAssetPrices and the maths tool`,
+- For percentage-based requests ("sell when up X%"), compute limitPrice = (sellAssetUsdPrice / buyAssetUsdPrice) × (1 + X/100) using getAssetPrices and the maths tool
+- If a price is flagged, ask the user to confirm the exact buyAsset-per-sellAsset target. Set priceConfirmed only after their explicit confirmation; do not silently substitute the market rate.`,
   inputSchema: createLimitOrderSchema,
   execute: executeCreateLimitOrder,
+  toModelOutput: (result: CreateLimitOrderOutput) => ({
+    type: 'text' as const,
+    value: JSON.stringify({
+      summary: result.summary,
+      needsApproval: result.needsApproval,
+      trackingUrl: result.trackingUrl,
+    }),
+  }),
 }

apps/agentic-server/src/tools/limitOrder/validateLimitPrice.ts

@@ -0,0 +1,50 @@
+import type { Asset } from '@shapeshiftoss/types'
+import BigNumber from 'bignumber.js'
+
+type PricedAsset = Pick<Asset, 'symbol' | 'price'>
+
+export function validateLimitPrice(
+  value: string,
+  sellAsset: PricedAsset,
+  buyAsset: PricedAsset,
+  priceConfirmed = false
+): void {
+  const price = new BigNumber(value)
+  if (!price.isFinite() || !price.gt(0)) {
+    throw new Error(`Invalid limitPrice "${value}". It must be a positive number.`)
+  }
+
+  const sellUsd = new BigNumber(sellAsset.price ?? '0')
+  const buyUsd = new BigNumber(buyAsset.price ?? '0')
+  // Missing prices cannot establish an inversion. Basic validation still applies.
+  if (!sellUsd.isFinite() || !buyUsd.isFinite() || !sellUsd.gt(0) || !buyUsd.gt(0)) return
+
+  // Cross-multiply comparisons to avoid rounding very small pair prices to zero.
+  const targetSellUsd = price.times(buyUsd)
+  const materiallyDifferent = targetSellUsd.gte(sellUsd.times(2)) || targetSellUsd.lte(sellUsd.times('0.5'))
+  const nearInverse = price.times(sellUsd).minus(buyUsd).abs().lte(buyUsd.times('0.1'))
+  const farFromMarket = targetSellUsd.gt(sellUsd.times(10)) || targetSellUsd.lt(sellUsd.times('0.1'))
+  const nearUsdPrice = [sellUsd, buyUsd].some(usd => price.minus(usd).abs().lte(usd.times('0.25')))
+
+  let reason: string
+  if (materiallyDifferent && nearInverse) {
+    reason = 'looks like an inverted pair price'
+  } else if (farFromMarket && nearUsdPrice) {
+    reason = 'looks like a USD token price rather than a pair price'
+  } else if (farFromMarket) {
+    reason = 'differs from the current pair price by more than 10×'
+  } else {
+    return
+  }
+
+  if (priceConfirmed) return
+
+  const Price = BigNumber.clone({ DECIMAL_PLACES: 80 })
+  const marketPrice = new Price(sellUsd).div(buyUsd).toPrecision(8)
+  throw new Error(
+    `limitPrice ${value} ${buyAsset.symbol}/${sellAsset.symbol} ${reason}. ` +
+      `The current market rate is approximately ${marketPrice} ${buyAsset.symbol} per 1 ${sellAsset.symbol}. ` +
+      `Ask the user to confirm the exact target in ${buyAsset.symbol} per 1 ${sellAsset.symbol}; do not silently change it. ` +
+      `Only after explicit confirmation, retry with that target and priceConfirmed=true.`
+  )
+}