@eco-incorp/sauce 0.99.6 → 0.99.8

package/actions/dist/to-quote.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"to-quote.d.ts","sourceRoot":"","sources":["../src/to-quote.ts"],"names":[],"mappings":"AA6BA,OAAO,EAML,KAAK,OAAO,EACZ,KAAK,IAAI,EACT,KAAK,QAAQ,EAEd,MAAM,WAAW,CAAC;AAGnB,OAAO,KAAK,EACV,UAAU,EAgBX,MAAM,YAAY,CAAC;AAEpB,KAAK,OAAO,GAAG,KAAK,MAAM,EAAE,CAAC;AAC7B,KAAK,GAAG,GAAG,KAAK,MAAM,EAAE,CAAC;AAMzB,qGAAqG;AACrG,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC;IACnB,MAAM,CAAC,MAAM,EAAE,GAAG,GAAG,MAAM,CAAC;CAC7B;AAED,iGAAiG;AACjG,MAAM,WAAW,SAAU,SAAQ,KAAK;IACtC,0FAA0F;IAC1F,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,QAAQ,CAAC;IAC/C;;;OAGG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,IAAI,KAAK,QAAQ,CAAC;CACzE;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,uFAAuF;IACvF,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAC;IACnC,uFAAuF;IACvF,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAC;IACnC,2EAA2E;IAC3E,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC;IAClC,+CAA+C;IAC/C,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;IACjC,yDAAyD;IACzD,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;CACrC;AAiPD;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,GAAE,YAAiB,GAAG,KAAK,CAUjF;AAED,yFAAyF;AACzF,wBAAgB,SAAS,CACvB,MAAM,EAAE,UAAU,EAClB,QAAQ,EAAE,MAAM,EAChB,IAAI,GAAE,YAAiB,GACtB,SAAS,CA6CX"}
+{"version":3,"file":"to-quote.d.ts","sourceRoot":"","sources":["../src/to-quote.ts"],"names":[],"mappings":"AAyBA,OAAO,EAML,KAAK,OAAO,EACZ,KAAK,IAAI,EACT,KAAK,QAAQ,EAEd,MAAM,WAAW,CAAC;AAEnB,OAAO,EAAgB,KAAK,QAAQ,EAAE,MAAM,oCAAoC,CAAC;AAIjF,OAAO,KAAK,EACV,UAAU,EAiBX,MAAM,YAAY,CAAC;AAEpB,KAAK,OAAO,GAAG,KAAK,MAAM,EAAE,CAAC;AAC7B,KAAK,GAAG,GAAG,KAAK,MAAM,EAAE,CAAC;AAMzB,qGAAqG;AACrG,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC;IACnB,MAAM,CAAC,MAAM,EAAE,GAAG,GAAG,MAAM,CAAC;CAC7B;AAED,iGAAiG;AACjG,MAAM,WAAW,SAAU,SAAQ,KAAK;IACtC,0FAA0F;IAC1F,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,QAAQ,CAAC;IAC/C;;;OAGG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,IAAI,KAAK,QAAQ,CAAC;CACzE;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC;IAC1B;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,kDAAkD;IAClD,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC;IAClC,+CAA+C;IAC/C,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;IACjC,yDAAyD;IACzD,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;CACrC;AAwPD;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,GAAE,YAAiB,GAAG,KAAK,CA2BjF;AAED,yFAAyF;AACzF,wBAAgB,SAAS,CACvB,MAAM,EAAE,UAAU,EAClB,QAAQ,EAAE,MAAM,EAChB,IAAI,GAAE,YAAiB,GACtB,SAAS,CA+CX"}

package/actions/dist/to-quote.js

@@ -10,11 +10,14 @@
  * (`registryFunction`, checked the way `abis.ts` checks a binding). The rest of the quoters are
  * not in the registry, and their signatures are written here.
  */
-import { keccak256, toBytes, encodeAbiParameters, encodeFunctionData, decodeAbiParameters, getAddress, } from "viem";
+import { keccak256, toBytes, encodeAbiParameters, encodeFunctionData, decodeAbiParameters, getAddress, parseAbiItem, } from "viem";
 import { registryFunction } from "./abis.js";
-import { CurveRouterNGABI, CurveThreePoolABI, UniswapV2RouterABI, UniswapV3QuoterV2ABI, } from "./registry.js";
+import { CurveRouterNGABI, CurveThreePoolABI } from "./registry.js";
 import { bindBytes, bindConst, encodeArgs, formatBigint, hexToBytes, } from "./emit.js";
+import { resolveChain } from "../../sdk/dist/chains/canonical.js";
+import { resolveNames, usesNames } from "./names.js";
 import { parseActions } from "./program.js";
+import { ProgramError } from "./semantics.js";
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -34,6 +37,11 @@ function concatHex(a, b) {
 }
 const decodeUint256 = (data) => decodeAbiParameters([{ type: "uint256" }], data)[0];
 const ZERO_ADDR = "0x0000000000000000000000000000000000000000";
+/**
+ * A token or contract field of an action `quoteCall` was given: an address, because `quoteAction`
+ * and the split swap resolve every name on their chain first, and a quote is calldata built here.
+ */
+const at = (value) => (value === "native" ? ZERO_ADDR : value);
 /** Return data is a single uint256. */
 const OUT_UINT256 = ["Uint256"];
 /** Return data is a single dynamic uint256[] (or int256[] read as its two's-complement words). */
@@ -168,7 +176,21 @@ function required(options, name) {
  * separate quoter take its address from `options`.
  */
 export function quoteAction(action, options = {}) {
-    const [checked] = parseActions([action], "action");
+    let [checked] = parseActions([action], "action");
+    if (checked.factory !== undefined) {
+        throw new Error("quoteAction prices a pool at its address, and a pool named by its key (`factory`) is found " +
+            "only on chain: read it there first (the factory's getPool/getPair), then give `pool`");
+    }
+    if (usesNames([checked])) {
+        const chain = options.chain === undefined ? undefined : resolveChain(options.chain);
+        if (chain === undefined) {
+            throw new Error("quoteAction: the action names a token or a contract — pass `chain` to resolve it on");
+        }
+        const { resolved, issues } = resolveNames([checked], chain, "action");
+        if (issues.length > 0)
+            throw new ProgramError(issues, chain);
+        checked = resolved[0];
+    }
     const amount = checked.amount;
     const explicit = checked.type === "carbonSwap" || checked.type === "balancerV2BatchSwap";
     if (amount === undefined && !explicit) {
@@ -181,37 +203,38 @@ export function quoteAction(action, options = {}) {
 export function quoteCall(action, amountIn, opts = {}) {
     switch (action.type) {
         // --- On the same contract as the action ---
+        case "uniswapV2Swap":
+            return quoteUniswapV2(action, amountIn);
         case "curveSwap":
             return quoteCurve(action, amountIn);
+        case "balancerV2Swap":
+            return quoteBalV2Single(action, amountIn);
+        case "dodoV2Swap":
+            return quoteDodoV2(action, amountIn);
+        case "traderJoeLBSwap":
+            return quoteTraderJoeLB(action, amountIn);
+        case "woofiSwap":
+            return quoteWoofi(action, amountIn);
         case "curveRouterNGSwap":
             return quoteCurveRouterNG(action, amountIn);
-        case "uniswapV2Swap":
-            return quoteV2Router(action.router, action.path, amountIn);
         case "fraxswapSwap":
-            return quoteFraxswap(action.router, action.path, amountIn);
-        case "balancerV2Swap":
-            return quoteBalV2Single(action, amountIn);
+            return quoteFraxswap(at(action.router), action.path.map(at), amountIn);
         case "balancerV2BatchSwap":
             return quoteBalV2Batch(action);
         case "balancerV3Swap":
             return quoteBalV3(action, amountIn);
         case "carbonSwap":
             return quoteCarbon(action);
-        case "dodoSwap":
-            return quoteDODO(action, amountIn);
+        case "dodoV1Swap":
+            return quoteDodoV1(action, amountIn);
+        // --- The Sauce Router, which swaps them ---
+        case "uniswapV3Swap":
+            return quoteThroughRouter(action, amountIn, required(opts, "router"));
+        case "uniswapV4Swap":
+            return quoteThroughRouter(action, amountIn, required(opts, "router"));
         // --- Separate quoter / resolver contract ---
-        case "uniswapV3ExactInput":
-            return quoteUniV3Single(action, amountIn, required(opts, "uniswapV3Quoter"));
-        case "uniswapV3ExactInputMultiHop":
-            return quoteUniV3Multi(action, amountIn, required(opts, "uniswapV3Quoter"));
-        case "uniswapV4ExactInput":
-            return quoteUniV4Single(action, amountIn, required(opts, "uniswapV4Quoter"));
-        case "uniswapV4ExactInputMultiHop":
-            return quoteUniV4Multi(action, amountIn, required(opts, "uniswapV4Quoter"));
-        case "maverickSwap":
-            return quoteMaverick(action, amountIn, required(opts, "maverickQuoter"));
-        case "maverickMultiHopSwap":
-            return quoteMaverickMulti(action, amountIn, required(opts, "maverickQuoter"));
+        case "maverickV2Swap":
+            return quoteMaverickV2(action, amountIn, required(opts, "maverickQuoter"));
         case "ambientSwap":
             return quoteAmbient(action, amountIn, required(opts, "ambientImpact"));
         case "fluidDexT1Swap":
@@ -226,19 +249,22 @@ export function quoteCall(action, amountIn, opts = {}) {
 // View functions — on the same contract referenced by the action
 // ---------------------------------------------------------------------------
 /**
- * Curve StableSwap / CryptoSwap pool — `get_dy(int128,int128,uint256)`, from the same 3pool ABI
- * the `curveSwap` binding uses; every 4-argument pool declares it the same way.
+ * Curve pool — `get_dy(i, j, dx)` in the pool's own index type: `int128` from the registry's 3pool
+ * ABI for a StableSwap or NG pool, `uint256` for a CryptoSwap pool (its selector differs, and the
+ * registry has no CryptoSwap ABI). Either way the arguments are three words.
  */
 function quoteCurve(action, amountIn) {
-    const fn = registryFunction("curve", "CurveThreePoolABI", CurveThreePoolABI, "get_dy(int128,int128,uint256)");
-    const to = action.pool;
+    const fn = action.indexType === "uint256"
+        ? parseAbiItem("function get_dy(uint256 i, uint256 j, uint256 dx) view returns (uint256)")
+        : registryFunction("curve", "CurveThreePoolABI", CurveThreePoolABI, "get_dy(int128,int128,uint256)");
+    const to = at(action.pool);
     const data = callData(fn, [BigInt(action.i), BigInt(action.j), amountIn]);
     return {
         to,
         data,
         decode: (result) => returned(fn, result)[0],
         toSauce: asUint256("static", to, data),
-        // selector(4) + int128 i(32) + int128 j(32) = 68
+        // selector(4) + i(32) + j(32) = 68
         toSauceDynamic: makeDynamic("static", to, data, 68, OUT_UINT256, firstWord),
     };
 }
@@ -254,7 +280,7 @@ function quoteCurveRouterNG(action, amountIn) {
     while (pools.length < 5)
         pools.push(ZERO_ADDR);
     const fn = registryFunction("curve", "CurveRouterNGABI", CurveRouterNGABI, "get_dy(address[11],uint256[5][5],uint256,address[5])");
-    const to = action.router;
+    const to = at(action.router);
     const data = callData(fn, [
         route,
         swapParams.map((r) => r.map((v) => BigInt(v))),
@@ -270,21 +296,40 @@ function quoteCurveRouterNG(action, amountIn) {
         toSauceDynamic: makeDynamic("static", to, data, 1156, OUT_UINT256, firstWord),
     };
 }
-/** UniswapV2 / SushiSwap / Fraxswap router — `getAmountsOut(uint256,address[])`. */
-function quoteV2Router(router, path, amountIn) {
-    const fn = registryFunction("uniswap-v2", "UniswapV2RouterABI", UniswapV2RouterABI, "getAmountsOut(uint256,address[])");
-    const to = router;
-    const data = callData(fn, [amountIn, path]);
+/**
+ * Uniswap V2 pair — `getReserves()` (view), priced exactly as `@sauce/router`'s `uniswapV2` prices
+ * it: the Router's constant-product math, the fee in ppm (absent or 0 is 3000), the direction from
+ * the sort order. The amount is not in the calldata, so the on-chain form applies it after the read.
+ */
+function quoteUniswapV2(action, amountIn) {
+    const fee = BigInt(action.feePpm === undefined || action.feePpm === 0 ? 3000 : action.feePpm);
+    const zeroForOne = BigInt(action.tokenIn) < BigInt(action.tokenOut);
+    const [inIndex, outIndex] = zeroForOne ? [0, 1] : [1, 0];
+    const to = at(action.pool);
+    const data = sel("getReserves()");
+    const price = (reserveIn, reserveOut) => {
+        const inWithFee = amountIn * (1000000n - fee);
+        return (inWithFee * reserveOut) / (reserveIn * 1000000n + inWithFee);
+    };
+    const onChain = (emit, amountExpr) => {
+        const cd = bindBytes(emit, "qcd", hexToBytes(data));
+        const decoded = decodeCall(emit, "static", to, cd, words(3));
+        const inWithFee = bindConst(emit, "qw", `${amountExpr} * ${formatBigint(1000000n - fee)}`);
+        return {
+            stmts: [...decoded.stmts, ...inWithFee.stmts],
+            expr: `Math.mulDiv(${inWithFee.expr}, ${decoded.expr}[${outIndex}], ` +
+                `${decoded.expr}[${inIndex}] * 1000000n + ${inWithFee.expr})`,
+        };
+    };
     return {
         to,
         data,
         decode: (result) => {
-            const [amounts] = returned(fn, result);
-            return amounts[amounts.length - 1];
+            const reserves = decodeAbiParameters([{ type: "uint112" }, { type: "uint112" }, { type: "uint32" }], result);
+            return price(reserves[inIndex], reserves[outIndex]);
         },
-        toSauce: asUint256ArrayLast("static", to, data),
-        // selector(4), then amountIn is the first head slot.
-        toSauceDynamic: makeDynamic("static", to, data, 4, OUT_UINT256_ARRAY, arrayLast),
+        toSauce: (emit) => onChain(emit, formatBigint(amountIn)),
+        toSauceDynamic: onChain,
     };
 }
 /**
@@ -357,7 +402,7 @@ function buildQueryBatchSwap(vault, steps, assets, outAssetIndex) {
 }
 /** BalancerV2 single swap — converted to `queryBatchSwap`. */
 function quoteBalV2Single(action, amountIn) {
-    const base = buildQueryBatchSwap(action.vault, [{ poolId: action.poolId, assetInIndex: 0n, assetOutIndex: 1n, amount: amountIn }], [action.tokenIn, action.tokenOut], 1);
+    const base = buildQueryBatchSwap(at(action.vault), [{ poolId: action.poolId, assetInIndex: 0n, assetOutIndex: 1n, amount: amountIn }], [at(action.tokenIn), at(action.tokenOut)], 1);
     // Neither `toSauce` nor `toSauceDynamic`, here or on the batch variant: the Vault implements
     // `queryBatchSwap` by performing the swap and reverting with the encoded deltas, so it mutates
     // state and cannot run inside the STATICCALL an on-chain quote issues. Any emitted form of it is
@@ -368,12 +413,12 @@ function quoteBalV2Single(action, amountIn) {
 /** BalancerV2 batch swap — `queryBatchSwap`. */
 function quoteBalV2Batch(action) {
     const lastStep = action.steps[action.steps.length - 1];
-    return buildQueryBatchSwap(action.vault, action.steps.map((s) => ({
+    return buildQueryBatchSwap(at(action.vault), action.steps.map((s) => ({
         poolId: s.poolId,
         assetInIndex: BigInt(s.assetInIndex),
         assetOutIndex: BigInt(s.assetOutIndex),
         amount: BigInt(s.amount),
-    })), action.assets, lastStep.assetOutIndex);
+    })), action.assets.map(at), lastStep.assetOutIndex);
 }
 /**
  * BalancerV3 — `querySwapSingleTokenExactIn`. The Vault answers a query only outside a
@@ -381,7 +426,7 @@ function quoteBalV2Batch(action) {
  * on-chain form.
  */
 function quoteBalV3(action, amountIn) {
-    const to = action.router;
+    const to = at(action.router);
     const data = concatHex(sel("querySwapSingleTokenExactIn(address,address,address,uint256,address,bytes)"), encodeAbiParameters([
         { type: "address" },
         { type: "address" },
@@ -389,7 +434,7 @@ function quoteBalV3(action, amountIn) {
         { type: "uint256" },
         { type: "address" },
         { type: "bytes" },
-    ], [action.pool, action.tokenIn, action.tokenOut, amountIn, ZERO_ADDR, "0x"]));
+    ], [at(action.pool), at(action.tokenIn), at(action.tokenOut), amountIn, ZERO_ADDR, "0x"]));
     return { to, data, decode: decodeUint256 };
 }
 /**
@@ -397,7 +442,7 @@ function quoteBalV3(action, amountIn) {
  * Uses the action's tradeActions as-is (caller must provide valid strategy IDs + amounts).
  */
 function quoteCarbon(action) {
-    const to = action.controller;
+    const to = at(action.controller);
     const data = concatHex(sel("calculateTradeTargetAmount(address,address,(uint256,uint128)[])"), encodeAbiParameters([
         { type: "address" },
         { type: "address" },
@@ -409,8 +454,8 @@ function quoteCarbon(action) {
             ],
         },
     ], [
-        action.sourceToken,
-        action.targetToken,
+        at(action.sourceToken),
+        at(action.targetToken),
         action.tradeActions.map((ta) => ({
             strategyId: BigInt(ta.strategyId),
             amount: BigInt(ta.amount),
@@ -419,35 +464,78 @@ function quoteCarbon(action) {
     return { to, data, decode: decodeUint256, toSauce: asUint256("static", to, data) };
 }
 /**
- * DODO V2 — `querySellBase` / `querySellQuote` (view) on the pool.
- *
- * The `directions` bitmask in the action encodes the swap direction:
- * bit 0 = 0 → selling base (querySellBase), bit 0 = 1 → selling quote (querySellQuote).
- * Only single-hop is supported via view; multi-hop falls back to first pool.
+ * DODO V2 — `querySellBase` / `querySellQuote` (view) on the pool, the side `@sauce/router`'s `dodoV2`
+ * takes: selling base when `tokenIn` is the base token. Every DODO V2 pool returns the amount first.
  */
-function quoteDODO(action, amountIn) {
-    const pool = getAddress(action.pairs[0]);
-    const sellingBase = (action.directions & 1) === 0;
-    if (action.version === "v1")
-        return quoteDODOV1(pool, sellingBase, amountIn);
-    const fnSel = sellingBase
-        ? sel("querySellBase(address,uint256)")
-        : sel("querySellQuote(address,uint256)");
-    const to = pool;
-    const data = concatHex(fnSel, encodeAbiParameters([{ type: "address" }, { type: "uint256" }], [ZERO_ADDR, amountIn]));
+function quoteDodoV2(action, amountIn) {
+    const sellingBase = BigInt(action.tokenIn) === BigInt(action.baseToken);
+    const to = at(action.pool);
+    const data = concatHex(sel(sellingBase ? "querySellBase(address,uint256)" : "querySellQuote(address,uint256)"), encodeAbiParameters([{ type: "address" }, { type: "uint256" }], [ZERO_ADDR, amountIn]));
     return {
         to,
         data,
         decode: (result) => {
-            // Returns (uint256 receiveAmount, uint256 mtFee)
+            // DVM returns (receiveAmount, mtFee); DPP and DSP append more words.
             const [receiveAmount] = decodeAbiParameters([{ type: "uint256" }, { type: "uint256" }], result);
             return receiveAmount;
         },
         toSauce: asUint256("static", to, data),
-        // selector(4) + sender/zero(32) = 36
+        // selector(4) + trader(32) = 36
         toSauceDynamic: makeDynamic("static", to, data, 36, OUT_UINT256, firstWord),
     };
 }
+/** DODO V1 — the first pair of the route, quoted by `quoteDODOV1`. */
+function quoteDodoV1(action, amountIn) {
+    return quoteDODOV1(getAddress(action.pairs[0]), (action.directions & 1) === 0, amountIn);
+}
+/**
+ * Trader Joe LB — `getSwapOut(amountIn, swapForY)` (view) on the pair. A pair that would leave part
+ * of the input unspent quotes zero: `@sauce/router`'s `traderJoeLB` swap reverts there
+ * (`LBPair__OutOfLiquidity`) rather than fill it partly.
+ */
+function quoteTraderJoeLB(action, amountIn) {
+    // The quote's direction is whether the input is the pair's X: the program reads X from the pair
+    // when the action leaves it out, and an eth_call built here cannot.
+    if (action.tokenX === undefined) {
+        throw new Error("quoting a traderJoeLBSwap needs its tokenX and tokenY — the pair's getTokenX() and " +
+            "getTokenY() — to know which way it trades; the swap reads them itself, the quote cannot");
+    }
+    const swapForY = BigInt(at(action.tokenIn)) === BigInt(at(action.tokenX));
+    const to = at(action.pool);
+    const data = concatHex(sel("getSwapOut(uint128,bool)"), encodeAbiParameters([{ type: "uint128" }, { type: "bool" }], [amountIn, swapForY]));
+    // (uint128 amountInLeft, uint128 amountOut, uint128 fee): the output, or 0 when input is left.
+    const filled = (emit, decoded) => {
+        const left = bindConst(emit, "qleft", `${decoded.expr}[0]`);
+        return {
+            stmts: [...decoded.stmts, ...left.stmts],
+            expr: `${left.expr} == 0n ? ${decoded.expr}[1] : 0n`,
+        };
+    };
+    return {
+        to,
+        data,
+        decode: (result) => {
+            const [left, out] = decodeAbiParameters([{ type: "uint128" }, { type: "uint128" }, { type: "uint128" }], result);
+            return left === 0n ? out : 0n;
+        },
+        toSauce: staticQuote("static", to, data, words(3), filled),
+        // selector(4), then the amount is the first head slot.
+        toSauceDynamic: makeDynamic("static", to, data, 4, words(3), filled),
+    };
+}
+/** WOOFi — the WooPPV2's own `query(fromToken, toToken, fromAmount)` (view). */
+function quoteWoofi(action, amountIn) {
+    const to = at(action.pool);
+    const data = concatHex(sel("query(address,address,uint256)"), encodeAbiParameters([{ type: "address" }, { type: "address" }, { type: "uint256" }], [at(action.tokenIn), at(action.tokenOut), amountIn]));
+    return {
+        to,
+        data,
+        decode: decodeUint256,
+        toSauce: asUint256("static", to, data),
+        // selector(4) + fromToken(32) + toToken(32) = 68
+        toSauceDynamic: makeDynamic("static", to, data, 68, OUT_UINT256, firstWord),
+    };
+}
 /**
  * DODO V1 Classical pair — `querySellBaseToken(uint256)` (view). V1 pairs have no `querySellBase`,
  * which is V2's, so a V1 action quoted through it reverted. A V1 pair prices only a BASE sale this
@@ -472,176 +560,73 @@ function quoteDODOV1(pool, sellingBase, amountIn) {
 // ---------------------------------------------------------------------------
 // Separate quoter / resolver contracts
 // ---------------------------------------------------------------------------
-/** UniswapV3 single-pool — QuoterV2 `quoteExactInputSingle` (revert-sim). */
-function quoteUniV3Single(action, amountIn, quoter) {
-    const fn = registryFunction("uniswap-v3", "UniswapV3QuoterV2ABI", UniswapV3QuoterV2ABI, "quoteExactInputSingle((address,address,uint256,uint24,uint160))");
-    const to = quoter;
-    const data = callData(fn, [
-        {
-            tokenIn: action.tokenIn,
-            tokenOut: action.tokenOut,
-            amountIn,
-            fee: action.fee,
-            sqrtPriceLimitX96: BigInt(action.sqrtPriceLimitX96 ?? 0),
-        },
-    ]);
-    return {
-        to,
-        data,
-        // (uint256 amountOut, uint160 sqrtPriceX96After, uint32 initializedTicksCrossed, uint256 gasEstimate)
-        decode: (result) => returned(fn, result)[0],
-        toSauce: asUint256("call", to, data),
-        // Struct args: selector(4) + tokenIn(32) + tokenOut(32) = 68
-        toSauceDynamic: makeDynamic("call", to, data, 68, OUT_UINT256, firstWord),
-    };
-}
-/** UniswapV3 multi-hop — QuoterV2 `quoteExactInput` (revert-sim). */
-function quoteUniV3Multi(action, amountIn, quoter) {
-    const to = quoter;
-    const data = concatHex(sel("quoteExactInput(bytes,uint256)"), encodeAbiParameters([{ type: "bytes" }, { type: "uint256" }], [action.path, amountIn]));
-    return {
-        to,
-        data,
-        decode: (result) => {
-            // (uint256 amountOut, uint160[] sqrtPriceX96AfterList, uint32[] initializedTicksCrossedList, uint256 gasEstimate)
-            const [amountOut] = decodeAbiParameters([{ type: "uint256" }, { type: "uint160[]" }, { type: "uint32[]" }, { type: "uint256" }], result);
-            return amountOut;
-        },
-        toSauce: asUint256("call", to, data),
-        // selector(4) + path_offset_pointer(32) = 36 (amount is the 2nd head slot; path tail follows)
-        toSauceDynamic: makeDynamic("call", to, data, 36, OUT_UINT256, firstWord),
-    };
-}
-/**
- * UniswapV4 single-pool — V4Quoter `quoteExactInputSingle` (revert-sim).
- *
- * QuoteExactSingleParams: { PoolKey poolKey, bool zeroForOne, uint128 exactAmount, bytes hookData }
- * PoolKey: { Currency currency0, Currency currency1, uint24 fee, int24 tickSpacing, address hooks }
- */
-function quoteUniV4Single(action, amountIn, quoter) {
-    const to = quoter;
-    const data = concatHex(
-    // One struct parameter: `quoteExactInputSingle(((address,address,uint24,int24,address),bool,
-    // uint128,bytes))`. An extra pair of parentheses here hashed a different signature, and every
-    // V4 quote reverted.
-    sel("quoteExactInputSingle(((address,address,uint24,int24,address),bool,uint128,bytes))"), encodeAbiParameters([
-        {
-            type: "tuple",
-            components: [
-                {
-                    type: "tuple",
-                    name: "poolKey",
-                    components: [
-                        { type: "address", name: "currency0" },
-                        { type: "address", name: "currency1" },
-                        { type: "uint24", name: "fee" },
-                        { type: "int24", name: "tickSpacing" },
-                        { type: "address", name: "hooks" },
-                    ],
-                },
-                {
-                    type: "bool",
-                    name: "zeroForOne",
-                },
-                {
-                    type: "uint128",
-                    name: "exactAmount",
-                },
-                {
-                    type: "bytes",
-                    name: "hookData",
-                },
-            ],
-        },
-    ], [
-        {
-            poolKey: {
-                currency0: action.poolKey.currency0,
-                currency1: action.poolKey.currency1,
-                fee: action.poolKey.fee,
-                tickSpacing: action.poolKey.tickSpacing,
-                hooks: action.poolKey.hooks,
-            },
-            zeroForOne: action.zeroForOne,
-            exactAmount: amountIn,
-            hookData: "0x",
-        },
-    ]));
-    return {
-        to,
-        data,
-        decode: (result) => {
-            // (uint256 amountOut, uint256 gasEstimate)
-            const [amountOut] = decodeAbiParameters([{ type: "uint256" }, { type: "uint256" }], result);
-            return amountOut;
-        },
-        toSauce: asUint256("call", to, data),
-    };
-}
+/** The Sauce Router's `quote(QuoteParams)`: a swap it simulates and reverts, needing no tokens. */
+const ROUTER_QUOTE = parseAbiItem("function quote((uint8 poolType, address pool, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) poolKey, address stateView, address tokenIn, address tokenOut, int256 amountSpecified, uint160 sqrtPriceLimitX96) params) returns ((uint256 amountIn, uint256 amountOut, uint160 sqrtPriceAfter, uint256 gasEstimate) result)");
+/** A sentinel amount, planted to find where the amount word sits in the encoded quote. */
+const AMOUNT_SENTINEL = (1n << 254n) + 0x5a0cen;
 /**
- * UniswapV4 multi-hop — V4Quoter `quoteExactInput` (revert-sim).
- *
- * QuoteExactParams: { Currency exactCurrency, PathKey[] path, uint128 exactAmount }
- * PathKey: { address intermediateCurrency, uint24 fee, int24 tickSpacing, address hooks, bytes hookData }
+ * Uniswap V3 and V4 — the Router's own `quote`, which runs the swap the action's `@sauce/router`
+ * call runs (`swapV3`, `swapV4`) and reverts it, without tokens. V3 takes the exact input positive
+ * and V4 negative, the signs the swap passes; the V4 pool key is the action's tokens in sort order.
  */
-function quoteUniV4Multi(action, amountIn, quoter) {
-    const to = quoter;
-    const data = concatHex(sel("quoteExactInput((address,(address,uint24,int24,address,bytes)[],uint128))"), encodeAbiParameters([
+function quoteThroughRouter(action, amountIn, router) {
+    const v4 = action.type === "uniswapV4Swap";
+    const [c0, c1] = BigInt(at(action.tokenIn)) < BigInt(at(action.tokenOut))
+        ? [at(action.tokenIn), at(action.tokenOut)]
+        : [at(action.tokenOut), at(action.tokenIn)];
+    const encode = (amountSpecified) => callData(ROUTER_QUOTE, [
         {
-            type: "tuple",
-            components: [
-                {
-                    type: "address",
-                    name: "exactCurrency",
-                },
-                {
-                    type: "tuple[]",
-                    name: "path",
-                    components: [
-                        { type: "address", name: "intermediateCurrency" },
-                        { type: "uint24", name: "fee" },
-                        { type: "int24", name: "tickSpacing" },
-                        { type: "address", name: "hooks" },
-                        { type: "bytes", name: "hookData" },
-                    ],
-                },
-                {
-                    type: "uint128",
-                    name: "exactAmount",
+            poolType: v4 ? 2 : 1,
+            pool: at(v4 ? action.poolManager : action.pool),
+            poolKey: v4
+                ? {
+                    currency0: c0,
+                    currency1: c1,
+                    fee: action.fee,
+                    tickSpacing: action.tickSpacing,
+                    hooks: action.hooks ?? ZERO_ADDR,
+                }
+                : {
+                    currency0: ZERO_ADDR,
+                    currency1: ZERO_ADDR,
+                    fee: 0,
+                    tickSpacing: 0,
+                    hooks: ZERO_ADDR,
                 },
-            ],
-        },
-    ], [
-        {
-            exactCurrency: action.currencyIn,
-            path: action.path.map((step) => ({
-                intermediateCurrency: step.intermediateCurrency,
-                fee: step.fee,
-                tickSpacing: step.tickSpacing,
-                hooks: step.hooks,
-                hookData: "0x",
-            })),
-            exactAmount: amountIn,
+            stateView: ZERO_ADDR,
+            tokenIn: at(action.tokenIn),
+            tokenOut: at(action.tokenOut),
+            amountSpecified,
+            sqrtPriceLimitX96: BigInt(action.sqrtPriceLimitX96 ?? 0),
         },
-    ]));
+    ]);
+    const data = encode(v4 ? -amountIn : amountIn);
+    // The amount's word, found rather than counted: a static struct, so it has a fixed offset.
+    const probe = encode(AMOUNT_SENTINEL).slice(2);
+    const word = probe.indexOf(AMOUNT_SENTINEL.toString(16).padStart(64, "0"));
+    if (word < 0 || word % 2 !== 0)
+        throw new Error("quote: the Router quote's amount word moved");
+    const offset = word / 2;
+    const dynamic = makeDynamic("call", router, data, offset, words(4), nthWord(1));
     return {
-        to,
+        to: router,
         data,
-        decode: (result) => {
-            // (uint256 amountOut, uint256 gasEstimate)
-            const [amountOut] = decodeAbiParameters([{ type: "uint256" }, { type: "uint256" }], result);
-            return amountOut;
-        },
-        toSauce: asUint256("call", to, data),
+        // SwapQuoteResult (amountIn, amountOut, sqrtPriceAfter, gasEstimate): the output is the second.
+        decode: (result) => returned(ROUTER_QUOTE, result)[0].amountOut,
+        toSauce: asTupleFieldUint256("call", router, data, 4, 1),
+        toSauceDynamic: v4 ? (emit, amountExpr) => dynamic(emit, `-(${amountExpr})`) : dynamic,
     };
 }
 /**
- * Maverick V2 single swap — MaverickV2Quoter `calculateSwap` (revert-sim).
+ * Maverick V2 — MaverickV2Quoter `calculateSwap` (revert-sim), over the full tick range the
+ * Router's swap uses. A Maverick V2 pool's token A is its lower-addressed token, so selling A is
+ * `tokenIn < tokenOut`.
  *
  * calculateSwap(IMaverickV2Pool pool, uint128 amount, bool tokenAIn, bool exactOutput, int32 tickLimit)
  *   → (uint256 amountIn, uint256 amountOut, uint256 gasEstimate)
  */
-function quoteMaverick(action, amountIn, quoter) {
+function quoteMaverickV2(action, amountIn, quoter) {
+    const tokenAIn = BigInt(action.tokenIn) < BigInt(action.tokenOut);
     const to = quoter;
     const data = concatHex(sel("calculateSwap(address,uint128,bool,bool,int32)"), encodeAbiParameters([
         { type: "address" },
@@ -650,15 +635,13 @@ function quoteMaverick(action, amountIn, quoter) {
         { type: "bool" },
         { type: "int32" },
     ], 
-    // No tick limit, as the router's own swap applies none: the extreme tick in the swap's
-    // direction (up when selling token A). A limit of 0 cut a quote short on any pool whose
-    // active tick was not straddling 0, and reverted it on the far side.
-    [action.pool, amountIn, action.tokenAIn, false, action.tokenAIn ? 2 ** 31 - 1 : -(2 ** 31)]));
+    // No tick limit, as the Router's swap applies none: the extreme tick in the swap's direction
+    // (up when selling token A).
+    [at(action.pool), amountIn, tokenAIn, false, tokenAIn ? 2 ** 31 - 1 : -(2 ** 31)]));
     return {
         to,
         data,
         decode: (result) => {
-            // (uint256 amountIn, uint256 amountOut, uint256 gasEstimate)
             const [, amountOut] = decodeAbiParameters([{ type: "uint256" }, { type: "uint256" }, { type: "uint256" }], result);
             return amountOut;
         },
@@ -667,23 +650,6 @@ function quoteMaverick(action, amountIn, quoter) {
         toSauceDynamic: makeDynamic("call", to, data, 36, words(3), nthWord(1)),
     };
 }
-/** Maverick V2 multi-hop — MaverickV2Quoter `calculateMultiHopSwap` (revert-sim). */
-function quoteMaverickMulti(action, amountIn, quoter) {
-    const to = quoter;
-    const data = concatHex(sel("calculateMultiHopSwap(bytes,uint256,bool)"), encodeAbiParameters([{ type: "bytes" }, { type: "uint256" }, { type: "bool" }], [action.path, amountIn, false]));
-    return {
-        to,
-        data,
-        decode: (result) => {
-            // (uint256 returnAmount, uint256 gasEstimate)
-            const [returnAmount] = decodeAbiParameters([{ type: "uint256" }, { type: "uint256" }], result);
-            return returnAmount;
-        },
-        toSauce: asUint256("call", to, data),
-        // selector(4) + path_offset_pointer(32) = 36 (2nd head slot is amount)
-        toSauceDynamic: makeDynamic("call", to, data, 36, OUT_UINT256, firstWord),
-    };
-}
 /**
  * Ambient — CrocImpact `calcImpact` (view).
  *
@@ -702,8 +668,8 @@ function quoteAmbient(action, amountIn, impact) {
         { type: "uint16" },
         { type: "uint128" },
     ], [
-        action.base,
-        action.quote,
+        at(action.base),
+        at(action.quote),
         BigInt(action.poolIdx),
         action.isBuy,
         action.inBaseQty,
@@ -738,7 +704,7 @@ function quoteAmbient(action, amountIn, impact) {
  */
 function quoteFluidT1(action, amountIn, resolver) {
     const to = resolver;
-    const data = concatHex(sel("estimateSwapIn(address,bool,uint256,uint256)"), encodeAbiParameters([{ type: "address" }, { type: "bool" }, { type: "uint256" }, { type: "uint256" }], [action.pool, action.swap0to1, amountIn, 0n]));
+    const data = concatHex(sel("estimateSwapIn(address,bool,uint256,uint256)"), encodeAbiParameters([{ type: "address" }, { type: "bool" }, { type: "uint256" }, { type: "uint256" }], [at(action.pool), action.swap0to1, amountIn, 0n]));
     return {
         to,
         data,