@pafi-dev/trading 0.4.3 → 0.5.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { Address, PublicClient, Hex, WalletClient, TransactionReceipt } from 'viem';
-import { PartialUserOperation, PoolKey, QuoteResult, PathKey, BestQuote, ExactOutputBestQuote, ExactOutputQuoteResult, BROKER_HASHES } from '@pafi-dev/core';
+import { PartialUserOperation, PoolKey, V3Path, BestQuote, ExactOutputBestQuote, QuoteResult, ExactOutputQuoteResult, BROKER_HASHES } from '@pafi-dev/core';
 export { PAFI_SUBGRAPH_URL, fetchPafiPools } from '@pafi-dev/core';
 
 interface ApiQuoteRequest {
@@ -23,7 +23,7 @@ interface ApiQuoteResponse {
     /** Echoes `request.amount` for FE bookkeeping. */
     inputAmount: bigint;
     /**
-     * Gross output from the V4 quoter — before operator fee deduction.
+     * Gross output from the V3 QuoterV2 — before operator fee deduction.
      * Use for "you swap X for ~Y" UI; do not promise this number to user.
      * 0n when `quoteError` set.
      */
@@ -42,7 +42,7 @@ interface ApiQuoteResponse {
      * raw units. 0n on the fallback path or when handler couldn't quote.
      */
     feeAmountOutput: bigint;
-    /** V4 Quoter's gas estimate for the route. */
+    /** V3 QuoterV2's gas estimate for the route. */
     gasEstimate: bigint;
     quoteError?: ApiQuoteError;
 }
@@ -117,7 +117,7 @@ interface ApiQuoteExactOutResponse {
     /** Echoes `request.amount` — the exact output amount. */
     outputAmount: bigint;
     /**
-     * Gross input required from the V4 quoter — before operator fee. Use
+     * Gross input required from the V3 QuoterV2 — before operator fee. Use
      * for "you'll pay ~X PT for exactly Y USDT" UI; do not promise this
      * number without slippage bounding. 0n when `quoteError` set.
      */
@@ -132,7 +132,7 @@ interface ApiQuoteExactOutResponse {
      * fallback path or when handler couldn't quote.
      */
     feeAmountInput: bigint;
-    /** V4 Quoter's gas estimate for the route. */
+    /** V3 QuoterV2's gas estimate for the route. */
     gasEstimate: bigint;
     quoteError?: ApiQuoteError;
 }
@@ -176,7 +176,7 @@ interface ApiSwapExactOutResponse {
     userOpFallback?: PartialUserOperation;
     /** Echoes `request.amount` — the exact output. */
     outputAmount: bigint;
-    /** Raw input amount from the V4 quoter, before slippage. For display. */
+    /** Raw input amount from the V3 QuoterV2, before slippage. For display. */
     estimatedInputAmount: bigint;
     /** Maximum input accepted — encoded in the UserOp calldata. */
     maxAmountIn: bigint;
@@ -322,7 +322,7 @@ declare class TradingHandlers {
     private readonly chainId;
     constructor(config: TradingHandlersConfig);
     /**
-     * Quote exact-input PT → USDT via Uniswap V4 on-chain Quoter.
+     * Quote exact-input PT → USDT via Uniswap V3 QuoterV2.
      *
      * Uses multicall to batch all candidate routes into a single RPC call.
      * Returns `quoteError: "QUOTE_UNAVAILABLE"` when no pool/path exists
@@ -349,7 +349,7 @@ declare class TradingHandlers {
     handleSwap(authenticatedAddress: Address, request: ApiSwapRequest): Promise<ApiSwapResponse>;
     /**
      * Quote the input required to receive `request.amount` of the output
-     * token via Uniswap V4. Input-side operator fee is auto-quoted, so
+     * token via Uniswap V3 QuoterV2. Input-side operator fee is auto-quoted, so
      * `inputGross = estimatedInputAmount + feeAmountInput` is the total
      * the user must hold.
      *
@@ -358,7 +358,7 @@ declare class TradingHandlers {
      */
     handleQuoteExactOut(request: ApiQuoteExactOutRequest): Promise<ApiQuoteExactOutResponse>;
     /**
-     * Build a V4 exact-output swap UserOp.
+     * Build a V3 exact-output swap UserOp.
      *
      * Quotes the best exact-output route, applies slippage as a CEILING on
      * `maxAmountIn` (so the cap is never silently tightened by floor
@@ -367,7 +367,7 @@ declare class TradingHandlers {
      *   inputToken.transfer(feeRecipient, gasFeeAmountInput)  [if > 0]
      *     → input.approve(Permit2, maxAmountIn)
      *     → Permit2.approve(router, maxAmountIn)
-     *     → UniversalRouter.execute (V4 SWAP_EXACT_OUT)
+     *     → UniversalRouter.execute (V3_SWAP_EXACT_OUT)
      *
      * Operator fee is INPUT-token-side (charged before swap) so the user
      * receives exactly `request.amount` of output.
@@ -408,60 +408,40 @@ declare function buildErc20ApprovalCalldata(spender: Address, amount: bigint): H
  */
 declare function buildPermit2ApprovalCalldata(token: Address, spender: Address, amount: bigint, expiration: number): Hex;
 
-declare const SWAP_EXACT_OUT_SINGLE: 8;
-declare const SWAP_EXACT_OUT: 9;
+/** UniversalRouter command byte for V3 exact-input swap. */
+declare const V3_SWAP_EXACT_IN: 0;
+/** UniversalRouter command byte for V3 exact-output swap. */
+declare const V3_SWAP_EXACT_OUT: 1;
 /**
- * Build the calldata inputs[0] (the V4_SWAP command payload) for
- * UniversalRouter.execute.
- *
- * Actions encoded: SWAP_EXACT_IN → SETTLE_ALL → TAKE_ALL
- *
- * Encoding matches the Uniswap V4 SDK's V4Planner — each action's params
- * are individually ABI-encoded, then wrapped together with the action bytes.
+ * Build the calldata `inputs[0]` payload for the `V3_SWAP_EXACT_IN`
+ * command. Path bytes are packed input→output; the router walks the
+ * same direction.
  */
-declare function buildV4SwapInput(currencyIn: Address, path: PathKey[], amountIn: bigint, minAmountOut: bigint, outputCurrency: Address): Hex;
+declare function buildV3SwapInputExactIn(recipient: Address, path: V3Path, amountIn: bigint, minAmountOut: bigint): Hex;
 /**
- * Build the full commands + inputs args for UniversalRouter.execute.
- */
-declare function buildUniversalRouterExecuteArgs(currencyIn: Address, path: PathKey[], amountIn: bigint, minAmountOut: bigint, outputCurrency: Address): {
-    commands: Hex;
-    inputs: Hex[];
-};
-/**
- * Build the calldata inputs[0] (the V4_SWAP command payload) for
- * UniversalRouter.execute, using the V4 exact-output flow.
- *
- * Actions encoded: SWAP_EXACT_OUT → SETTLE_ALL → TAKE_ALL
- *
- * Settle/take semantics flip vs. the exact-input builder:
- *   - SETTLE_ALL caps the input pulled at `maxAmountIn` (router pulls
- *     only the actual amount the swap consumed; reverts if it exceeds
- *     the cap).
- *   - TAKE_ALL requires the user to receive *exactly* `amountOut` of
- *     `outputCurrency`.
- *
- * The `path` argument here is in V4 exact-output orientation — i.e.
- * traversed output→input — which is what `findBestQuoteExactOut`
- * (and `buildAllPaths(pools, tokenOut, tokenIn, ...)`) returns.
- *
- * @throws if `amountOut` or `maxAmountIn` exceeds 2^128 - 1.
+ * Build the calldata `inputs[0]` payload for the `V3_SWAP_EXACT_OUT`
+ * command. Path bytes are packed output→input — the router walks the
+ * desired output back to the input, taking only as much input as needed
+ * (capped by `maxAmountIn`).
+ *
+ * The `path` argument is in canonical input→output orientation; the
+ * encoder reverses internally so callers don't have to reason about
+ * direction.
  */
-declare function buildV4SwapInputExactOut(currencyOut: Address, path: PathKey[], amountOut: bigint, maxAmountIn: bigint, inputCurrency: Address): Hex;
+declare function buildV3SwapInputExactOut(recipient: Address, path: V3Path, amountOut: bigint, maxAmountIn: bigint): Hex;
 /**
- * Build the full commands + inputs args for UniversalRouter.execute,
- * using the V4 exact-output flow.
+ * Build the full `commands` + `inputs` args for `UniversalRouter.execute`
+ * for an exact-input V3 swap.
  */
-declare function buildUniversalRouterExecuteArgsExactOut(currencyOut: Address, path: PathKey[], amountOut: bigint, maxAmountIn: bigint, inputCurrency: Address): {
+declare function buildUniversalRouterExecuteArgs(recipient: Address, path: V3Path, amountIn: bigint, minAmountOut: bigint): {
     commands: Hex;
     inputs: Hex[];
 };
-declare function buildSwapFromQuote(params: {
-    quote: QuoteResult;
-    currencyIn: Address;
-    currencyOut: Address;
-    amountIn: bigint;
-    minAmountOut: bigint;
-}): {
+/**
+ * Build the full `commands` + `inputs` args for `UniversalRouter.execute`
+ * for an exact-output V3 swap.
+ */
+declare function buildUniversalRouterExecuteArgsExactOut(recipient: Address, path: V3Path, amountOut: bigint, maxAmountIn: bigint): {
     commands: Hex;
     inputs: Hex[];
 };
@@ -487,8 +467,8 @@ interface SwapSimulationResult {
 declare function simulateSwap(client: PublicClient, routerAddress: Address, commands: Hex, inputs: Hex[], deadline: bigint, from: Address): Promise<SwapSimulationResult>;
 
 /**
- * v0.3 — Generalized swap UserOp builder. Direction-agnostic: works
- * for **any** ERC-20 → ERC-20 pair routable through PAFI's V4 pools:
+ * v0.5 — Generalized swap UserOp builder. Direction-agnostic: works
+ * for **any** ERC-20 → ERC-20 pair routable through PAFI's V3 pools:
  *
  *   - PT → USDT      (cashout)
  *   - USDT → PT      (buy PT with USDT)
@@ -499,7 +479,7 @@ declare function simulateSwap(client: PublicClient, routerAddress: Address, comm
  *   1. `inputToken.approve(Permit2, amountIn)` — exactly the swap amount.
  *   2. `Permit2.approve(inputToken, router, amountIn, deadline)` — Permit2
  *      authorization to UniversalRouter.
- *   3. `UniversalRouter.execute(commands, inputs, deadline)` — V4 swap
+ *   3. `UniversalRouter.execute(commands, inputs, deadline)` — V3 swap
  *      `inputToken → outputToken`; user receives ≥ `minAmountOut`.
  *   4. `outputToken.transfer(feeRecipient, gasFeeAmountOutput)` —
  *      operator gas reimbursement, paid in OUTPUT token (omitted when 0).
@@ -518,16 +498,14 @@ declare function simulateSwap(client: PublicClient, routerAddress: Address, comm
  * Caller MUST ensure `minAmountOut >= gasFeeAmountOutput` (fee transfer
  * reverts otherwise → whole batch reverts).
  *
- * ## PAFI Hook fee
- *
- * The V4 PAFIHook charges 10% on PT → USDT direction (one-way). The
- * 10% is taken at pool level inside `UniversalRouter.execute`, so this
- * builder doesn't model it explicitly — it shows up as a smaller
- * `amountOut` from `findBestQuote`.
+ * ## Pool-level fees
  *
- *   - PT → USDT:   pool charges 10%  (output reduced)
- *   - USDT → PT:   no hook fee
- *   - PT0 → PT1:   10% on PT0 → USDT leg, 0% on USDT → PT1 leg
+ * PAFI's PT pools are standard Uniswap V3 — no swap-time hooks. The
+ * protocol's gas-recoupment fee lives in `MintFeeWrapper` on the mint
+ * path; the only pool-level economics here are Uniswap's regular LP
+ * fee tier (per the PoolKey's `fee` field), already baked into the
+ * quote returned by `findBestQuote`. This builder doesn't apply or
+ * model any additional swap-time fee on top.
  */
 interface BuildSwapUserOpParams {
     /** User's EOA (with EIP-7702 delegation to BatchExecutor). */
@@ -549,10 +527,11 @@ interface BuildSwapUserOpParams {
      */
     minAmountOut: bigint;
     /**
-     * V4 pool path for the swap. Single-hop = 1 PathKey, multi-hop = N.
-     * Get this from `findBestQuote().bestRoute.path`.
+     * V3 swap path. `tokens.length === fees.length + 1`. Get this from
+     * `findBestQuote().bestRoute.path`. Single-hop has 2 tokens + 1 fee;
+     * multi-hop has N+1 tokens + N fees.
      */
-    swapPath: PathKey[];
+    swapPath: V3Path;
     /** Unix seconds. After this, the router rejects the swap. */
     deadline: bigint;
     /**
@@ -611,10 +590,11 @@ interface BuildSwapUserOpExactOutParams {
      */
     maxAmountIn: bigint;
     /**
-     * V4 pool path in **output→input** orientation. Single-hop = 1 PathKey,
-     * multi-hop = N. Get this from `findBestQuoteExactOut().bestRoute.path`.
+     * V3 swap path in canonical **input→output** orientation. The encoder
+     * reverses internally for the on-chain exact-output Router call.
+     * Get this from `findBestQuoteExactOut().bestRoute.path`.
      */
-    swapPath: PathKey[];
+    swapPath: V3Path;
     /** Unix seconds. After this, the router rejects the swap. */
     deadline: bigint;
     /**
@@ -640,7 +620,7 @@ interface BuildSwapUserOpExactOutParams {
     };
 }
 /**
- * Build an unsigned UserOp for the V4 exact-output swap flow.
+ * Build an unsigned UserOp for the V3 exact-output swap flow.
  *
  * UserOp shape (atomic batch via EIP-7702 BatchExecutor):
  *
@@ -649,12 +629,12 @@ interface BuildSwapUserOpExactOutParams {
  *   2. `inputToken.approve(Permit2, maxAmountIn)` — cap, not exact.
  *   3. `Permit2.approve(inputToken, router, maxAmountIn, deadline)` —
  *      Permit2 authorization to UniversalRouter for up to `maxAmountIn`.
- *   4. `UniversalRouter.execute(commands, inputs, deadline)` — V4
+ *   4. `UniversalRouter.execute(commands, inputs, deadline)` — V3
  *      exact-output swap; user receives exactly `amountOut`.
  *
  * @throws when `amountOut`/`maxAmountIn` are non-positive,
- *   `gasFeeAmountInput` is negative, `swapPath` is empty, or `deadline`
- *   is out of Permit2's uint48 range.
+ *   `gasFeeAmountInput` is negative, `swapPath` is malformed, or
+ *   `deadline` is out of Permit2's uint48 range.
  */
 declare function buildSwapUserOpExactOut(params: BuildSwapUserOpExactOutParams): PartialUserOperation;
 
@@ -664,8 +644,9 @@ declare function buildSwapUserOpExactOut(params: BuildSwapUserOpExactOutParams):
  */
 declare function combineRoutes(chainId: number, pointTokenAddress: Address): PoolKey[];
 /**
- * Build all possible swap paths from `tokenIn` to `tokenOut` using the given
- * pools. Returns an array of PathKey[] routes (each up to `maxHops` hops).
+ * Build all possible V3 swap paths from `tokenIn` to `tokenOut` using
+ * the given pools. Returns an array of `V3Path` routes (each up to
+ * `maxHops` hops, in canonical input→output orientation).
  *
  * Supports both direct single-hop routes and multi-hop routes through
  * intermediate tokens. Each pool is used at most once per path.
@@ -675,96 +656,89 @@ declare function combineRoutes(chainId: number, pointTokenAddress: Address): Poo
  * @param tokenOut - Desired output token address
  * @param maxHops  - Maximum number of hops (default 3)
  */
-declare function buildAllPaths(pools: PoolKey[], tokenIn: Address, tokenOut: Address, maxHops?: number): PathKey[][];
+declare function buildAllPaths(pools: PoolKey[], tokenIn: Address, tokenOut: Address, maxHops?: number): V3Path[];
 
 /**
- * Quote exact-input for a multi-hop path.
+ * Quote exact-input for a multi-hop V3 path.
+ *
+ * `path` is in canonical input→output orientation; the encoder produces
+ * `tokens[0] ‖ fees[0] ‖ tokens[1] ‖ ... ‖ tokens[N]` packed bytes.
  */
-declare function quoteExactInput(client: PublicClient, quoterAddress: Address, exactCurrency: Address, path: PathKey[], exactAmount: bigint): Promise<QuoteResult>;
+declare function quoteExactInput(client: PublicClient, quoterAddress: Address, path: V3Path, exactAmount: bigint): Promise<QuoteResult>;
 /**
- * Quote exact-input for a single-hop swap, given an explicit PoolKey and direction.
+ * Quote exact-input for a single-hop V3 swap, given an explicit pool
+ * and direction. `sqrtPriceLimitX96 = 0n` disables the price-limit
+ * guard (the on-chain "no limit" sentinel).
  */
-declare function quoteExactInputSingle(client: PublicClient, quoterAddress: Address, poolKey: PoolKey, zeroForOne: boolean, exactAmount: bigint, hookData: `0x${string}`): Promise<{
+declare function quoteExactInputSingle(client: PublicClient, quoterAddress: Address, tokenIn: Address, tokenOut: Address, fee: number, exactAmount: bigint, sqrtPriceLimitX96?: bigint): Promise<{
     amountOut: bigint;
     gasEstimate: bigint;
 }>;
 /**
- * Try multiple PathKey[] routes and return the best quote plus all results.
- * Routes that fail (e.g. pool does not exist) are silently skipped.
+ * Try multiple V3Path routes and return the best quote plus all results.
+ * Routes that fail (e.g. pool does not exist, insufficient liquidity)
+ * are silently skipped. The first failure reason is included in the
+ * error message when EVERY route fails.
  *
- * Uses viem multicall to batch all quotes into a single RPC call for speed.
+ * Uses viem multicall to batch all quotes into a single RPC call.
  */
-declare function quoteBestRoute(client: PublicClient, quoterAddress: Address, exactCurrency: Address, routes: PathKey[][], exactAmount: bigint): Promise<BestQuote>;
+declare function quoteBestRoute(client: PublicClient, quoterAddress: Address, routes: V3Path[], exactAmount: bigint): Promise<BestQuote>;
 /**
- * Find and quote the best swap route from `tokenIn` to `tokenOut`.
+ * Find and quote the best V3 swap route from `tokenIn` to `tokenOut`.
  *
  * Combines the caller's `pools` with `COMMON_POOLS[chainId]`, builds all
  * possible paths (up to `maxHops`), then quotes them all via a single
  * multicall and returns the best result.
  *
  * @param client         - viem PublicClient
- * @param chainId        - Chain ID (used to look up COMMON_POOLS and V4_QUOTER_ADDRESSES)
+ * @param chainId        - Chain ID (used to look up COMMON_POOLS and QUOTER_V2_ADDRESSES)
  * @param tokenIn        - Input token address
  * @param tokenOut       - Desired output token address
  * @param exactAmount    - Exact input amount
  * @param pools          - Additional pools to consider (e.g. point-token-specific)
- * @param quoterAddress  - Override the default V4 Quoter address for this chain
+ * @param quoterAddress  - Override the default V3 QuoterV2 address for this chain
  * @param maxHops        - Maximum number of hops per path (default 3)
  */
 declare function findBestQuote(client: PublicClient, chainId: number, tokenIn: Address, tokenOut: Address, exactAmount: bigint, pools?: PoolKey[], quoterAddress?: Address, maxHops?: number): Promise<BestQuote>;
 /**
- * Quote V4 exact-output for a multi-hop path.
+ * Quote V3 exact-output for a multi-hop path.
  *
- * @param exactCurrency  - The OUTPUT token (the one the user wants to
- *                         receive a precise amount of).
- * @param path           - PathKey[] in output→input orientation. Use
- *                         `buildAllPaths(pools, tokenOut, tokenIn, ...)`
- *                         (arguments swapped vs. exact-in) to produce
- *                         the right shape.
- * @param exactAmount    - Exact OUTPUT amount the user wants.
- * @returns `{ amountIn, gasEstimate, path }` — the input amount required
- *          to receive `exactAmount` of `exactCurrency`.
+ * @param path          - V3Path in canonical input→output orientation.
+ *                        The encoder reverses for the on-chain call.
+ * @param exactAmount   - Exact OUTPUT amount the user wants to receive.
+ * @returns `{ amountIn, gasEstimate, path }` — the input amount required.
  */
-declare function quoteExactOutput(client: PublicClient, quoterAddress: Address, exactCurrency: Address, path: PathKey[], exactAmount: bigint): Promise<ExactOutputQuoteResult>;
+declare function quoteExactOutput(client: PublicClient, quoterAddress: Address, path: V3Path, exactAmount: bigint): Promise<ExactOutputQuoteResult>;
 /**
- * Quote V4 exact-output for a single-hop swap, given an explicit PoolKey
- * and direction.
- *
- * `zeroForOne` semantics are identical to the exact-input variant —
- * "trade direction" is invariant to the exactness parameter. Only
- * `exactAmount` flips meaning (here: amount of *output* currency the
- * user wants to receive).
+ * Quote V3 exact-output for a single-hop swap, given an explicit
+ * `tokenIn`/`tokenOut`/`fee` triple.
  */
-declare function quoteExactOutputSingle(client: PublicClient, quoterAddress: Address, poolKey: PoolKey, zeroForOne: boolean, exactAmount: bigint, hookData: `0x${string}`): Promise<{
+declare function quoteExactOutputSingle(client: PublicClient, quoterAddress: Address, tokenIn: Address, tokenOut: Address, fee: number, exactAmount: bigint, sqrtPriceLimitX96?: bigint): Promise<{
     amountIn: bigint;
     gasEstimate: bigint;
 }>;
 /**
- * Try multiple PathKey[] routes for an exact-output swap and return the
+ * Try multiple V3Path routes for an exact-output swap and return the
  * route requiring the **smallest** input amount, plus all results.
- * Routes that fail (e.g. pool does not exist) are silently skipped.
- *
- * Uses viem multicall to batch all quotes into a single RPC call.
+ * Routes that fail are silently skipped.
  */
-declare function quoteBestRouteExactOut(client: PublicClient, quoterAddress: Address, exactCurrency: Address, routes: PathKey[][], exactAmount: bigint): Promise<ExactOutputBestQuote>;
+declare function quoteBestRouteExactOut(client: PublicClient, quoterAddress: Address, routes: V3Path[], exactAmount: bigint): Promise<ExactOutputBestQuote>;
 /**
- * Find and quote the best V4 exact-output route from `tokenIn` to
+ * Find and quote the best V3 exact-output route from `tokenIn` to
  * `tokenOut` for a desired output amount.
  *
- * Symmetric to `findBestQuote` but with two key differences:
- *
- *   - `exactAmount` is denominated in `tokenOut` (the OUTPUT token).
- *   - Internally calls `buildAllPaths(allPools, tokenOut, tokenIn, ...)`
- *     (arguments swapped) to enumerate paths in output→input
- *     orientation, which is what `quoteExactOutput` expects.
+ * Symmetric to `findBestQuote` but `exactAmount` is denominated in
+ * `tokenOut` (the OUTPUT token). Paths are enumerated input→output (the
+ * canonical SDK orientation) — the QuoterV2 wrapper reverses for the
+ * on-chain call.
  *
  * @param client        - viem PublicClient.
- * @param chainId       - Chain ID (looks up COMMON_POOLS + V4_QUOTER_ADDRESSES).
+ * @param chainId       - Chain ID (looks up COMMON_POOLS + QUOTER_V2_ADDRESSES).
  * @param tokenIn       - Input token address (what user pays).
  * @param tokenOut      - Output token address (what user wants exactly).
  * @param exactAmount   - Exact OUTPUT amount.
  * @param pools         - Additional pools (e.g. point-token-specific).
- * @param quoterAddress - Override the default V4 Quoter address.
+ * @param quoterAddress - Override the default V3 QuoterV2 address.
  * @param maxHops       - Maximum number of hops per path (default 3).
  */
 declare function findBestQuoteExactOut(client: PublicClient, chainId: number, tokenIn: Address, tokenOut: Address, exactAmount: bigint, pools?: PoolKey[], quoterAddress?: Address, maxHops?: number): Promise<ExactOutputBestQuote>;
@@ -820,8 +794,11 @@ interface SwapDirectResult {
  *
  * Flow:
  *   1. Verify the EOA has EIP-7702 delegation to a PAFI-supported impl
- *      (Simple7702Account or Coinbase SW v2 BatchExecutor). Throw with
- *      a clear hint pointing at `delegateDirect()` if not delegated.
+ *      (canonically Pimlico's `Simple7702Account`; the legacy Coinbase
+ *      Smart Wallet v2 BatchExecutor is still accepted by
+ *      `detectDelegateImpl` for EOAs delegated earlier). Throw with a
+ *      clear hint pointing at `delegateDirect()` if not delegated at
+ *      all.
  *   2. `findBestQuote` → best route + gross output.
  *   3. `buildSwapUserOp` → encoded `executeBatch(calls)` calldata.
  *   4. `walletClient.sendTransaction({ to: userAddress, data: callData })`
@@ -900,7 +877,7 @@ interface SwapDirectExactOutResult {
     receipt?: TransactionReceipt;
     /** Echoes `params.amount` — the exact output. */
     outputAmount: bigint;
-    /** Raw input amount from the V4 quoter, before slippage. */
+    /** Raw input amount from the V3 quoter, before slippage. */
     estimatedInputAmount: bigint;
     /** Slippage-bumped cap on input — encoded in the swap calldata. */
     maxAmountIn: bigint;
@@ -1030,4 +1007,4 @@ interface PerpDepositDirectResult {
  */
 declare function perpDepositDirect(params: PerpDepositDirectParams): Promise<PerpDepositDirectResult>;
 
-export { type ApiPerpDepositRequest, type ApiPerpDepositResponse, type ApiQuoteError, type ApiQuoteExactOutRequest, type ApiQuoteExactOutResponse, type ApiQuoteRequest, type ApiQuoteResponse, type ApiSwapExactOutRequest, type ApiSwapExactOutResponse, type ApiSwapRequest, type ApiSwapResponse, type BuildSwapUserOpExactOutParams, type BuildSwapUserOpParams, type PerpDepositDirectParams, type PerpDepositDirectResult, SWAP_EXACT_OUT, SWAP_EXACT_OUT_SINGLE, type SwapDirectExactOutParams, type SwapDirectExactOutResult, type SwapDirectParams, type SwapDirectResult, type SwapSimulationResult, TradingHandlers, type TradingHandlersConfig, buildAllPaths, buildErc20ApprovalCalldata, buildPermit2ApprovalCalldata, buildSwapFromQuote, buildSwapUserOp, buildSwapUserOpExactOut, buildUniversalRouterExecuteArgs, buildUniversalRouterExecuteArgsExactOut, buildV4SwapInput, buildV4SwapInputExactOut, checkAllowance, combineRoutes, findBestQuote, findBestQuoteExactOut, perpDepositDirect, quoteBestRoute, quoteBestRouteExactOut, quoteExactInput, quoteExactInputSingle, quoteExactOutput, quoteExactOutputSingle, simulateSwap, swapDirect, swapDirectExactOut };
+export { type ApiPerpDepositRequest, type ApiPerpDepositResponse, type ApiQuoteError, type ApiQuoteExactOutRequest, type ApiQuoteExactOutResponse, type ApiQuoteRequest, type ApiQuoteResponse, type ApiSwapExactOutRequest, type ApiSwapExactOutResponse, type ApiSwapRequest, type ApiSwapResponse, type BuildSwapUserOpExactOutParams, type BuildSwapUserOpParams, type PerpDepositDirectParams, type PerpDepositDirectResult, type SwapDirectExactOutParams, type SwapDirectExactOutResult, type SwapDirectParams, type SwapDirectResult, type SwapSimulationResult, TradingHandlers, type TradingHandlersConfig, V3_SWAP_EXACT_IN, V3_SWAP_EXACT_OUT, buildAllPaths, buildErc20ApprovalCalldata, buildPermit2ApprovalCalldata, buildSwapUserOp, buildSwapUserOpExactOut, buildUniversalRouterExecuteArgs, buildUniversalRouterExecuteArgsExactOut, buildV3SwapInputExactIn, buildV3SwapInputExactOut, checkAllowance, combineRoutes, findBestQuote, findBestQuoteExactOut, perpDepositDirect, quoteBestRoute, quoteBestRouteExactOut, quoteExactInput, quoteExactInputSingle, quoteExactOutput, quoteExactOutputSingle, simulateSwap, swapDirect, swapDirectExactOut };