viem 2.57.5 → 2.57.6

package/tempo/actions/dex.ts

@@ -24,8 +24,16 @@ import type { ExtractAbiItem, GetEventArgs } from '../../types/contract.js'
 import type { Log as viem_Log } from '../../types/log.js'
 import type { Compute, UnionOmit } from '../../types/utils.js'
 import { parseEventLogs } from '../../utils/abi/parseEventLogs.js'
+import { isAddressEqual } from '../../utils/address/isAddressEqual.js'
 import * as Abis from '../Abis.js'
 import * as Addresses from '../Addresses.js'
+import type * as Errors from '../errors.js'
+import { TempoExecutionError } from '../errors.js'
+import {
+  type Context,
+  type Resolvers,
+  withExecutionError,
+} from '../internal/errors.js'
 import type {
   GetAccountParameter,
   ReadParameters,
@@ -97,7 +105,7 @@ export namespace buy {
   export type ReturnValue = WriteContractReturnType
 
   // TODO: exhaustive error type
-  export type ErrorType = BaseErrorType
+  export type ErrorType = Errors.ExecutionErrorType | BaseErrorType
 
   /** @internal */
   export async function inner<
@@ -111,7 +119,7 @@ export namespace buy {
   ): Promise<ReturnType<action>> {
     const { tokenIn, tokenOut, amountOut, maxAmountIn, ...rest } = parameters
     const call = buy.call({ tokenIn, tokenOut, amountOut, maxAmountIn })
-    return (await action(client, {
+    return (await withExecutionError(action)(client, {
       ...rest,
       ...call,
     } as never)) as never
@@ -219,7 +227,7 @@ export namespace buySync {
   }>
 
   // TODO: exhaustive error type
-  export type ErrorType = BaseErrorType
+  export type ErrorType = Errors.ExecutionErrorType | BaseErrorType
 }
 
 /**
@@ -271,7 +279,7 @@ export namespace cancel {
   export type ReturnValue = WriteContractReturnType
 
   // TODO: exhaustive error type
-  export type ErrorType = BaseErrorType
+  export type ErrorType = Errors.ExecutionErrorType | BaseErrorType
 
   /** @internal */
   export async function inner<
@@ -285,7 +293,7 @@ export namespace cancel {
   ): Promise<ReturnType<action>> {
     const { orderId, ...rest } = parameters
     const call = cancel.call({ orderId })
-    return (await action(client, {
+    return (await withExecutionError(action)(client, {
       ...rest,
       ...call,
     } as never)) as never
@@ -416,7 +424,7 @@ export namespace cancelSync {
   >
 
   // TODO: exhaustive error type
-  export type ErrorType = BaseErrorType
+  export type ErrorType = Errors.ExecutionErrorType | BaseErrorType
 }
 
 /**
@@ -471,7 +479,7 @@ export namespace cancelStale {
   export type ReturnValue = WriteContractReturnType
 
   // TODO: exhaustive error type
-  export type ErrorType = BaseErrorType
+  export type ErrorType = Errors.ExecutionErrorType | BaseErrorType
 
   /** @internal */
   export async function inner<
@@ -485,7 +493,7 @@ export namespace cancelStale {
   ): Promise<ReturnType<action>> {
     const { orderId, ...rest } = parameters
     const call = cancelStale.call({ orderId })
-    return (await action(client, {
+    return (await withExecutionError(action)(client, {
       ...rest,
       ...call,
     } as never)) as never
@@ -619,7 +627,7 @@ export namespace cancelStaleSync {
   >
 
   // TODO: exhaustive error type
-  export type ErrorType = BaseErrorType
+  export type ErrorType = Errors.ExecutionErrorType | BaseErrorType
 }
 
 /**
@@ -671,7 +679,7 @@ export namespace createPair {
   export type ReturnValue = WriteContractReturnType
 
   // TODO: exhaustive error type
-  export type ErrorType = BaseErrorType
+  export type ErrorType = Errors.ExecutionErrorType | BaseErrorType
 
   /** @internal */
   export async function inner<
@@ -685,7 +693,7 @@ export namespace createPair {
   ): Promise<ReturnType<action>> {
     const { base, ...rest } = parameters
     const call = createPair.call({ base })
-    return (await action(client, {
+    return (await withExecutionError(action)(client, {
       ...rest,
       ...call,
     } as never)) as never
@@ -816,7 +824,7 @@ export namespace createPairSync {
   >
 
   // TODO: exhaustive error type
-  export type ErrorType = BaseErrorType
+  export type ErrorType = Errors.ExecutionErrorType | BaseErrorType
 }
 
 /**
@@ -853,7 +861,7 @@ export async function getBalance<
   const { account: acc = client.account, token, ...rest } = parameters
   const address = acc ? parseAccount(acc).address : undefined
   if (!address) throw new Error('account is required.')
-  return readContract(client, {
+  return withExecutionError(readContract)(client, {
     ...rest,
     ...getBalance.call({ account: address, token }),
   })
@@ -892,6 +900,8 @@ export namespace getBalance {
       functionName: 'balanceOf',
     })
   }
+
+  export type ErrorType = Errors.ExecutionErrorType | BaseErrorType
 }
 
 /**
@@ -924,7 +934,7 @@ export async function getBuyQuote<chain extends Chain | undefined>(
   parameters: getBuyQuote.Parameters,
 ): Promise<getBuyQuote.ReturnValue> {
   const { tokenIn, tokenOut, amountOut, ...rest } = parameters
-  return readContract(client, {
+  return withExecutionError(readContract)(client, {
     ...rest,
     ...getBuyQuote.call({ tokenIn, tokenOut, amountOut }),
   })
@@ -963,6 +973,8 @@ export namespace getBuyQuote {
       functionName: 'quoteSwapExactAmountOut',
     })
   }
+
+  export type ErrorType = Errors.ExecutionErrorType | BaseErrorType
 }
 
 /**
@@ -993,7 +1005,7 @@ export async function getOrder<chain extends Chain | undefined>(
   parameters: getOrder.Parameters,
 ): Promise<getOrder.ReturnValue> {
   const { orderId, ...rest } = parameters
-  return readContract(client, {
+  return withExecutionError(readContract)(client, {
     ...rest,
     ...getOrder.call({ orderId }),
   })
@@ -1028,6 +1040,8 @@ export namespace getOrder {
       functionName: 'getOrder',
     })
   }
+
+  export type ErrorType = Errors.ExecutionErrorType | BaseErrorType
 }
 
 /**
@@ -1059,7 +1073,7 @@ export async function getOrderbook<chain extends Chain | undefined>(
   parameters: getOrderbook.Parameters,
 ): Promise<getOrderbook.ReturnValue> {
   const { base, quote, ...rest } = parameters
-  return readContract(client, {
+  return withExecutionError(readContract)(client, {
     ...rest,
     ...getOrderbook.call({ base, quote }),
   })
@@ -1097,6 +1111,8 @@ export namespace getOrderbook {
       functionName: 'books',
     })
   }
+
+  export type ErrorType = Errors.ExecutionErrorType | BaseErrorType
 }
 
 /**
@@ -1129,10 +1145,13 @@ export async function getTickLevel<chain extends Chain | undefined>(
   parameters: getTickLevel.Parameters,
 ): Promise<getTickLevel.ReturnValue> {
   const { base, tick, isBid, ...rest } = parameters
-  const [head, tail, totalLiquidity] = await readContract(client, {
-    ...rest,
-    ...getTickLevel.call({ base, tick, isBid }),
-  })
+  const [head, tail, totalLiquidity] = await withExecutionError(readContract)(
+    client,
+    {
+      ...rest,
+      ...getTickLevel.call({ base, tick, isBid }),
+    },
+  )
   return { head, tail, totalLiquidity }
 }
 
@@ -1172,6 +1191,8 @@ export namespace getTickLevel {
       functionName: 'getTickLevel',
     })
   }
+
+  export type ErrorType = Errors.ExecutionErrorType | BaseErrorType
 }
 
 /**
@@ -1204,7 +1225,7 @@ export async function getSellQuote<chain extends Chain | undefined>(
   parameters: getSellQuote.Parameters,
 ): Promise<getSellQuote.ReturnValue> {
   const { tokenIn, tokenOut, amountIn, ...rest } = parameters
-  return readContract(client, {
+  return withExecutionError(readContract)(client, {
     ...rest,
     ...getSellQuote.call({ tokenIn, tokenOut, amountIn }),
   })
@@ -1243,6 +1264,8 @@ export namespace getSellQuote {
       functionName: 'quoteSwapExactAmountIn',
     })
   }
+
+  export type ErrorType = Errors.ExecutionErrorType | BaseErrorType
 }
 
 /**
@@ -1303,7 +1326,7 @@ export namespace place {
   export type ReturnValue = WriteContractReturnType
 
   // TODO: exhaustive error type
-  export type ErrorType = BaseErrorType
+  export type ErrorType = Errors.ExecutionErrorType | BaseErrorType
 
   /** @internal */
   export async function inner<
@@ -1317,7 +1340,7 @@ export namespace place {
   ): Promise<ReturnType<action>> {
     const { amount, token, type, tick, ...rest } = parameters
     const call = place.call({ amount, token, type, tick })
-    return (await action(client, {
+    return (await withExecutionError(action)(client, {
       ...rest,
       ...call,
     } as never)) as never
@@ -1447,7 +1470,7 @@ export namespace placeFlip {
   export type ReturnValue = WriteContractReturnType
 
   // TODO: exhaustive error type
-  export type ErrorType = BaseErrorType
+  export type ErrorType = Errors.ExecutionErrorType | BaseErrorType
 
   /** @internal */
   export async function inner<
@@ -1461,7 +1484,7 @@ export namespace placeFlip {
   ): Promise<ReturnType<action>> {
     const { amount, flipTick, tick, token, type, ...rest } = parameters
     const call = placeFlip.call({ amount, flipTick, tick, token, type })
-    return (await action(client, {
+    return (await withExecutionError(action)(client, {
       ...rest,
       ...call,
     } as never)) as never
@@ -1602,7 +1625,7 @@ export namespace placeFlipSync {
   >
 
   // TODO: exhaustive error type
-  export type ErrorType = BaseErrorType
+  export type ErrorType = Errors.ExecutionErrorType | BaseErrorType
 }
 
 /**
@@ -1674,7 +1697,7 @@ export namespace placeSync {
   >
 
   // TODO: exhaustive error type
-  export type ErrorType = BaseErrorType
+  export type ErrorType = Errors.ExecutionErrorType | BaseErrorType
 }
 
 /**
@@ -1735,7 +1758,7 @@ export namespace sell {
   export type ReturnValue = WriteContractReturnType
 
   // TODO: exhaustive error type
-  export type ErrorType = BaseErrorType
+  export type ErrorType = Errors.ExecutionErrorType | BaseErrorType
 
   /** @internal */
   export async function inner<
@@ -1749,7 +1772,7 @@ export namespace sell {
   ): Promise<ReturnType<action>> {
     const { tokenIn, tokenOut, amountIn, minAmountOut, ...rest } = parameters
     const call = sell.call({ tokenIn, tokenOut, amountIn, minAmountOut })
-    return (await action(client, {
+    return (await withExecutionError(action)(client, {
       ...rest,
       ...call,
     } as never)) as never
@@ -1857,7 +1880,7 @@ export namespace sellSync {
   }>
 
   // TODO: exhaustive error type
-  export type ErrorType = BaseErrorType
+  export type ErrorType = Errors.ExecutionErrorType | BaseErrorType
 }
 
 /**
@@ -2236,7 +2259,7 @@ export namespace withdraw {
   export type ReturnValue = WriteContractReturnType
 
   // TODO: exhaustive error type
-  export type ErrorType = BaseErrorType
+  export type ErrorType = Errors.ExecutionErrorType | BaseErrorType
 
   /** @internal */
   export async function inner<
@@ -2250,7 +2273,7 @@ export namespace withdraw {
   ): Promise<ReturnType<action>> {
     const { token, amount, ...rest } = parameters
     const call = withdraw.call({ token, amount })
-    return (await action(client, {
+    return (await withExecutionError(action)(client, {
       ...rest,
       ...call,
     } as never)) as never
@@ -2354,9 +2377,552 @@ export namespace withdrawSync {
   }>
 
   // TODO: exhaustive error type
-  export type ErrorType = BaseErrorType
+  export type ErrorType = Errors.ExecutionErrorType | BaseErrorType
 }
 
 function getPairKey(base: Address, quote: Address) {
   return Hash.keccak256(Hex.concat(base, quote))
 }
+
+// Errors
+
+/** Errors this module throws for decoded Tempo errors. Narrow with `error.name`. */
+export type ExecutionErrorType =
+  | DexBelowMinimumOrderSizeErrorType
+  | DexInsufficientBalanceErrorType
+  | DexInsufficientLiquidityErrorType
+  | DexInsufficientOutputErrorType
+  | DexInvalidFlipTickErrorType
+  | DexMaxInputExceededErrorType
+  | DexOrderNotFoundErrorType
+  | DexOrderNotStaleErrorType
+  | DexPairNotFoundErrorType
+  | DexTickOutOfBoundsErrorType
+
+/** `DexInsufficientOutputError` with a literal `name`, for narrowing. */
+export type DexInsufficientOutputErrorType = DexInsufficientOutputError & {
+  name: 'DexInsufficientOutputError'
+}
+
+/** Thrown when a sell would return less than `minAmountOut`. */
+export class DexInsufficientOutputError extends TempoExecutionError<
+  Errors.TempoExecutionError.Decoded<'InsufficientOutput'>
+> {
+  /** Amount of `tokenIn` to sell. */
+  amountIn: bigint | undefined
+  /** Minimum amount of `tokenOut` to receive. */
+  minAmountOut: bigint | undefined
+  /** Current quote for `amountIn`, when available. */
+  quote: bigint | undefined
+  /** Token to sell. */
+  tokenIn: Address | undefined
+  /** Token to buy. */
+  tokenOut: Address | undefined
+
+  constructor(parameters: DexInsufficientOutputError.Parameters) {
+    const { amountIn, minAmountOut, quote, tokenIn, tokenOut } = parameters
+    super(parameters, {
+      details: {
+        'token in': tokenIn,
+        'token out': tokenOut,
+        'amount in': amountIn,
+        'min amount out': minAmountOut,
+        quote,
+      },
+      name: 'DexInsufficientOutputError',
+    })
+    this.amountIn = amountIn
+    this.minAmountOut = minAmountOut
+    this.quote = quote
+    this.tokenIn = tokenIn
+    this.tokenOut = tokenOut
+  }
+}
+
+export declare namespace DexInsufficientOutputError {
+  /** Constructor parameters. */
+  type Parameters = Errors.TempoExecutionError.Parameters & {
+    /** Amount of `tokenIn` to sell. */
+    amountIn?: bigint | undefined
+    /** Minimum amount of `tokenOut` to receive. */
+    minAmountOut?: bigint | undefined
+    /** Current quote for `amountIn`, when available. */
+    quote?: bigint | undefined
+    /** Token to sell. */
+    tokenIn?: Address | undefined
+    /** Token to buy. */
+    tokenOut?: Address | undefined
+  }
+}
+
+/** `DexMaxInputExceededError` with a literal `name`, for narrowing. */
+export type DexMaxInputExceededErrorType = DexMaxInputExceededError & {
+  name: 'DexMaxInputExceededError'
+}
+
+/** Thrown when a buy would cost more than `maxAmountIn`. */
+export class DexMaxInputExceededError extends TempoExecutionError<
+  Errors.TempoExecutionError.Decoded<'MaxInputExceeded'>
+> {
+  /** Amount of `tokenOut` to buy. */
+  amountOut: bigint | undefined
+  /** Maximum amount of `tokenIn` to spend. */
+  maxAmountIn: bigint | undefined
+  /** Current cost of `amountOut`, when available. */
+  quote: bigint | undefined
+  /** Token to spend. */
+  tokenIn: Address | undefined
+  /** Token to buy. */
+  tokenOut: Address | undefined
+
+  constructor(parameters: DexMaxInputExceededError.Parameters) {
+    const { amountOut, maxAmountIn, quote, tokenIn, tokenOut } = parameters
+    super(parameters, {
+      details: {
+        'token in': tokenIn,
+        'token out': tokenOut,
+        'amount out': amountOut,
+        'max amount in': maxAmountIn,
+        quote,
+      },
+      name: 'DexMaxInputExceededError',
+    })
+    this.amountOut = amountOut
+    this.maxAmountIn = maxAmountIn
+    this.quote = quote
+    this.tokenIn = tokenIn
+    this.tokenOut = tokenOut
+  }
+}
+
+export declare namespace DexMaxInputExceededError {
+  /** Constructor parameters. */
+  type Parameters = Errors.TempoExecutionError.Parameters & {
+    /** Amount of `tokenOut` to buy. */
+    amountOut?: bigint | undefined
+    /** Maximum amount of `tokenIn` to spend. */
+    maxAmountIn?: bigint | undefined
+    /** Current cost of `amountOut`, when available. */
+    quote?: bigint | undefined
+    /** Token to spend. */
+    tokenIn?: Address | undefined
+    /** Token to buy. */
+    tokenOut?: Address | undefined
+  }
+}
+
+/** `DexInsufficientLiquidityError` with a literal `name`, for narrowing. */
+export type DexInsufficientLiquidityErrorType =
+  DexInsufficientLiquidityError & { name: 'DexInsufficientLiquidityError' }
+
+/** Thrown when the order book cannot fill a swap. */
+export class DexInsufficientLiquidityError extends TempoExecutionError<
+  Errors.TempoExecutionError.Decoded<'InsufficientLiquidity'>
+> {
+  /** Amount of `tokenIn` to sell, for sells. */
+  amountIn: bigint | undefined
+  /** Amount of `tokenOut` to buy, for buys. */
+  amountOut: bigint | undefined
+  /** Token to spend. */
+  tokenIn: Address | undefined
+  /** Token to buy. */
+  tokenOut: Address | undefined
+
+  constructor(
+    parameters: Errors.TempoExecutionError.Parameters & {
+      amountIn?: bigint | undefined
+      amountOut?: bigint | undefined
+      tokenIn?: Address | undefined
+      tokenOut?: Address | undefined
+    },
+  ) {
+    const { amountIn, amountOut, tokenIn, tokenOut } = parameters
+    super(parameters, {
+      details: {
+        'token in': tokenIn,
+        'token out': tokenOut,
+        'amount in': amountIn,
+        'amount out': amountOut,
+      },
+      name: 'DexInsufficientLiquidityError',
+    })
+    this.amountIn = amountIn
+    this.amountOut = amountOut
+    this.tokenIn = tokenIn
+    this.tokenOut = tokenOut
+  }
+}
+
+/** `DexBelowMinimumOrderSizeError` with a literal `name`, for narrowing. */
+export type DexBelowMinimumOrderSizeErrorType =
+  DexBelowMinimumOrderSizeError & { name: 'DexBelowMinimumOrderSizeError' }
+
+/** Thrown when an order is smaller than the minimum order size. */
+export class DexBelowMinimumOrderSizeError extends TempoExecutionError<
+  Errors.TempoExecutionError.Decoded<'BelowMinimumOrderSize'>
+> {
+  /** Order amount. */
+  amount: bigint
+  /** Minimum order amount, when known. */
+  minimum: bigint | undefined
+
+  constructor(
+    parameters: Errors.TempoExecutionError.Parameters & {
+      minimum?: bigint | undefined
+    },
+  ) {
+    const [amount] = parameters.error.args as readonly [bigint]
+    const { minimum } = parameters
+    super(parameters, {
+      details: { amount, minimum },
+      name: 'DexBelowMinimumOrderSizeError',
+      shortMessage: `Order amount ${amount} is below the minimum${minimum === undefined ? '' : ` of ${minimum}`}.`,
+    })
+    this.amount = amount
+    this.minimum = minimum
+  }
+}
+
+/** `DexTickOutOfBoundsError` with a literal `name`, for narrowing. */
+export type DexTickOutOfBoundsErrorType = DexTickOutOfBoundsError & {
+  name: 'DexTickOutOfBoundsError'
+}
+
+/** Thrown when an order's tick or flip tick is outside the allowed range. */
+export class DexTickOutOfBoundsError extends TempoExecutionError<
+  Errors.TempoExecutionError.Decoded<'TickOutOfBounds'>
+> {
+  /** Highest allowed tick, when known. */
+  maxTick: number | undefined
+  /** Lowest allowed tick, when known. */
+  minTick: number | undefined
+  /** Tick that is out of range. */
+  tick: number
+
+  constructor(
+    parameters: Errors.TempoExecutionError.Parameters & {
+      maxTick?: number | undefined
+      minTick?: number | undefined
+    },
+  ) {
+    const [tick] = parameters.error.args as readonly [number]
+    const { maxTick, minTick } = parameters
+    super(parameters, {
+      details: {
+        tick,
+        range:
+          minTick === undefined || maxTick === undefined
+            ? undefined
+            : `${minTick} to ${maxTick}`,
+      },
+      name: 'DexTickOutOfBoundsError',
+    })
+    this.maxTick = maxTick
+    this.minTick = minTick
+    this.tick = tick
+  }
+}
+
+/** `DexInvalidFlipTickError` with a literal `name`, for narrowing. */
+export type DexInvalidFlipTickErrorType = DexInvalidFlipTickError & {
+  name: 'DexInvalidFlipTickError'
+}
+
+/** Thrown when a flip order's flip tick is on the wrong side of its tick or off the tick spacing. */
+export class DexInvalidFlipTickError extends TempoExecutionError<
+  Errors.TempoExecutionError.Decoded<'InvalidFlipTick'>
+> {
+  /** Flip tick. */
+  flipTick: number | undefined
+  /** Order side. */
+  side: 'buy' | 'sell' | undefined
+  /** Order tick. */
+  tick: number | undefined
+  /** Tick spacing, when known. */
+  tickSpacing: number | undefined
+
+  constructor(
+    parameters: Errors.TempoExecutionError.Parameters & {
+      flipTick?: number | undefined
+      side?: 'buy' | 'sell' | undefined
+      tick?: number | undefined
+      tickSpacing?: number | undefined
+    },
+  ) {
+    const { flipTick, side, tick, tickSpacing } = parameters
+    super(parameters, {
+      details: {
+        side,
+        tick,
+        'flip tick': flipTick,
+        'tick spacing': tickSpacing,
+      },
+      name: 'DexInvalidFlipTickError',
+      shortMessage:
+        side === 'buy'
+          ? 'The flip tick of a buy order must be at or above its tick, and a multiple of the tick spacing.'
+          : side === 'sell'
+            ? 'The flip tick of a sell order must be at or below its tick, and a multiple of the tick spacing.'
+            : undefined,
+    })
+    this.flipTick = flipTick
+    this.side = side
+    this.tick = tick
+    this.tickSpacing = tickSpacing
+  }
+}
+
+/** `DexOrderNotFoundError` with a literal `name`, for narrowing. */
+export type DexOrderNotFoundErrorType = DexOrderNotFoundError & {
+  name: 'DexOrderNotFoundError'
+}
+
+/** Thrown when an order does not exist or is already filled. */
+export class DexOrderNotFoundError extends TempoExecutionError<
+  Errors.TempoExecutionError.Decoded<'OrderDoesNotExist'>
+> {
+  /** Order ID. */
+  orderId: bigint
+
+  constructor(
+    parameters: Errors.TempoExecutionError.Parameters & { orderId: bigint },
+  ) {
+    super(parameters, {
+      details: { order: parameters.orderId },
+      name: 'DexOrderNotFoundError',
+      shortMessage: `Order ${parameters.orderId} does not exist or is already filled.`,
+    })
+    this.orderId = parameters.orderId
+  }
+}
+
+/** `DexOrderNotStaleError` with a literal `name`, for narrowing. */
+export type DexOrderNotStaleErrorType = DexOrderNotStaleError & {
+  name: 'DexOrderNotStaleError'
+}
+
+/** Thrown when cancelling a stale order whose maker is still authorized by the token's policy. */
+export class DexOrderNotStaleError extends TempoExecutionError<
+  Errors.TempoExecutionError.Decoded<'OrderNotStale'>
+> {
+  /** Order ID. */
+  orderId: bigint
+
+  constructor(
+    parameters: Errors.TempoExecutionError.Parameters & { orderId: bigint },
+  ) {
+    super(parameters, {
+      details: { order: parameters.orderId },
+      name: 'DexOrderNotStaleError',
+      shortMessage: `Order ${parameters.orderId} is not stale: its maker is still authorized.`,
+    })
+    this.orderId = parameters.orderId
+  }
+}
+
+/** `DexPairNotFoundError` with a literal `name`, for narrowing. */
+export type DexPairNotFoundErrorType = DexPairNotFoundError & {
+  name: 'DexPairNotFoundError'
+}
+
+/** Thrown when no trading pair exists for a token. */
+export class DexPairNotFoundError extends TempoExecutionError<
+  Errors.TempoExecutionError.Decoded<'PairDoesNotExist'>
+> {
+  /** Tokens of the call. */
+  tokens: readonly Address[]
+
+  constructor(
+    parameters: Errors.TempoExecutionError.Parameters & {
+      tokens: readonly Address[]
+    },
+  ) {
+    super(parameters, {
+      details: { tokens: parameters.tokens.join(', ') || undefined },
+      name: 'DexPairNotFoundError',
+    })
+    this.tokens = parameters.tokens
+  }
+}
+
+/** `DexInsufficientBalanceError` with a literal `name`, for narrowing. */
+export type DexInsufficientBalanceErrorType = DexInsufficientBalanceError & {
+  name: 'DexInsufficientBalanceError'
+}
+
+/** Thrown when withdrawing more than the account's exchange balance. */
+export class DexInsufficientBalanceError extends TempoExecutionError<
+  Errors.TempoExecutionError.Decoded<'InsufficientBalance'>
+> {
+  /** Amount to withdraw. */
+  amount: bigint | undefined
+  /** Exchange balance, when known. */
+  balance: bigint | undefined
+  /** Token address. */
+  token: Address
+
+  constructor(
+    parameters: Errors.TempoExecutionError.Parameters & {
+      amount?: bigint | undefined
+      balance?: bigint | undefined
+      token: Address
+    },
+  ) {
+    const { amount, balance, token } = parameters
+    super(parameters, {
+      details: { token, amount, balance },
+      name: 'DexInsufficientBalanceError',
+      shortMessage: `Insufficient exchange balance of token "${token}".`,
+    })
+    this.amount = amount
+    this.balance = balance
+    this.token = token
+  }
+}
+
+const exchange = {
+  address: Addresses.stablecoinDex,
+  abi: Abis.stablecoinDex,
+} as const
+
+/** The failed call, when it targets the exchange. */
+function getExchangeCall(context: Context) {
+  const { call } = context
+  return call && isAddressEqual(call.address, Addresses.stablecoinDex)
+    ? call
+    : undefined
+}
+
+/** @internal */
+export const errorResolvers: Resolvers = {
+  'BelowMinimumOrderSize(uint128)': async (context) => {
+    if (!getExchangeCall(context) || !context.base.error.args) return undefined
+    const [minimum] = await context.read([
+      { ...exchange, functionName: 'MIN_ORDER_AMOUNT' },
+    ])
+    return new DexBelowMinimumOrderSizeError({
+      ...context.base,
+      minimum: minimum?.result,
+    })
+  },
+  'InsufficientBalance()': async (context) => {
+    const call = getExchangeCall(context)
+    const token = call?.arg<Address>('token')
+    if (call?.functionName !== 'withdraw' || !token || !context.signer)
+      return undefined
+    const [balance] = await context.read([
+      {
+        ...exchange,
+        functionName: 'balanceOf',
+        args: [context.signer.address, token],
+      },
+    ])
+    return new DexInsufficientBalanceError({
+      ...context.base,
+      amount: call.arg<bigint>('amount'),
+      balance: balance?.result,
+      token,
+    })
+  },
+  'InsufficientLiquidity()': (context) => {
+    const call = getExchangeCall(context)
+    if (!call) return undefined
+    return new DexInsufficientLiquidityError({
+      ...context.base,
+      amountIn: call.arg<bigint>('amountIn'),
+      amountOut: call.arg<bigint>('amountOut'),
+      tokenIn: call.arg<Address>('tokenIn'),
+      tokenOut: call.arg<Address>('tokenOut'),
+    })
+  },
+  'InsufficientOutput()': async (context) => {
+    const call = getExchangeCall(context)
+    if (!call) return undefined
+    const tokenIn = call.arg<Address>('tokenIn')!
+    const tokenOut = call.arg<Address>('tokenOut')!
+    const amountIn = call.arg<bigint>('amountIn')!
+    const [quote] = await context.read([
+      {
+        ...exchange,
+        functionName: 'quoteSwapExactAmountIn',
+        args: [tokenIn, tokenOut, amountIn],
+      },
+    ])
+    return new DexInsufficientOutputError({
+      ...context.base,
+      amountIn,
+      minAmountOut: call.arg<bigint>('minAmountOut'),
+      quote: quote?.result,
+      tokenIn,
+      tokenOut,
+    })
+  },
+  'InvalidFlipTick()': async (context) => {
+    const call = getExchangeCall(context)
+    if (!call) return undefined
+    const [tickSpacing] = await context.read([
+      { ...exchange, functionName: 'TICK_SPACING' },
+    ])
+    const isBid = call.arg<boolean>('isBid')
+    return new DexInvalidFlipTickError({
+      ...context.base,
+      flipTick: call.arg<number>('flipTick'),
+      side: isBid === undefined ? undefined : isBid ? 'buy' : 'sell',
+      tick: call.arg<number>('tick'),
+      tickSpacing: tickSpacing?.result,
+    })
+  },
+  'MaxInputExceeded()': async (context) => {
+    const call = getExchangeCall(context)
+    if (!call) return undefined
+    const tokenIn = call.arg<Address>('tokenIn')!
+    const tokenOut = call.arg<Address>('tokenOut')!
+    const amountOut = call.arg<bigint>('amountOut')!
+    const [quote] = await context.read([
+      {
+        ...exchange,
+        functionName: 'quoteSwapExactAmountOut',
+        args: [tokenIn, tokenOut, amountOut],
+      },
+    ])
+    return new DexMaxInputExceededError({
+      ...context.base,
+      amountOut,
+      maxAmountIn: call.arg<bigint>('maxAmountIn'),
+      quote: quote?.result,
+      tokenIn,
+      tokenOut,
+    })
+  },
+  'OrderDoesNotExist()': (context) => {
+    const orderId = getExchangeCall(context)?.arg<bigint>('orderId')
+    if (orderId === undefined) return undefined
+    return new DexOrderNotFoundError({ ...context.base, orderId })
+  },
+  'OrderNotStale()': (context) => {
+    const orderId = getExchangeCall(context)?.arg<bigint>('orderId')
+    if (orderId === undefined) return undefined
+    return new DexOrderNotStaleError({ ...context.base, orderId })
+  },
+  'PairDoesNotExist()': (context) => {
+    const call = getExchangeCall(context)
+    if (!call) return undefined
+    const tokens = ['token', 'tokenIn', 'tokenOut', 'base'].flatMap((name) => {
+      const token = call.arg<Address>(name)
+      return token ? [token] : []
+    })
+    return new DexPairNotFoundError({ ...context.base, tokens })
+  },
+  'TickOutOfBounds(int16)': async (context) => {
+    if (!getExchangeCall(context) || !context.base.error.args) return undefined
+    const [minTick, maxTick] = await context.read([
+      { ...exchange, functionName: 'MIN_TICK' },
+      { ...exchange, functionName: 'MAX_TICK' },
+    ])
+    return new DexTickOutOfBoundsError({
+      ...context.base,
+      maxTick: maxTick?.result,
+      minTick: minTick?.result,
+    })
+  },
+}