@eco-incorp/sauce 0.99.4 → 0.99.6

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":"AAcA,OAAO,EAML,KAAK,OAAO,EACZ,KAAK,IAAI,EACT,KAAK,QAAQ,EAEd,MAAM,WAAW,CAAC;AAEnB,OAAO,KAAK,EACV,UAAU,EAmBX,MAAM,YAAY,CAAC;AAEpB,KAAK,OAAO,GAAG,KAAK,MAAM,EAAE,CAAC;AAC7B,KAAK,GAAG,GAAG,KAAK,MAAM,EAAE,CAAC;AAMzB,2DAA2D;AAC3D,MAAM,WAAW,SAAS;IACxB,oCAAoC;IACpC,EAAE,EAAE,OAAO,CAAC;IACZ,2BAA2B;IAC3B,IAAI,EAAE,GAAG,CAAC;IACV,4DAA4D;IAC5D,MAAM,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,MAAM,CAAC;IAChC;;;;;;;;;OASG;IACH,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,QAAQ,CAAC;IACtC;;;;;;;;;;;;OAYG;IACH,cAAc,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,IAAI,KAAK,QAAQ,CAAC;CAChE;AAED;;;GAGG;AACH,MAAM,WAAW,SAAS;IACxB,kEAAkE;IAClE,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,kEAAkE;IAClE,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,2EAA2E;IAC3E,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,gEAAgE;IAChE,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,mEAAmE;IACnE,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,0EAA0E;IAC1E,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,wEAAwE;IACxE,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAyOD;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,UAAU,EAClB,QAAQ,EAAE,MAAM,EAChB,IAAI,GAAE,SAAc,GACnB,SAAS,CA2DX"}
+{"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"}

package/actions/dist/to-quote.js

@@ -1,23 +1,34 @@
 /**
- * Swap actions -> quote calls, both off-chain (`eth_call`) and on-chain.
+ * Swap actions -> quote calls: an `eth_call` a client sends to price a swap (`quoteAction`), and
+ * the same call emitted as SauceScript, which the split swap runs on-chain (`quoteCall`).
  *
- * The off-chain half (`to`, `data`, `decode`) never touched a compiler and is unchanged. The
- * on-chain half emitted `Saucer` builder nodes against the retired TypeScript compiler; it now
- * emits SauceScript statements plus the `uint256` expression they leave available (a
- * [`Fragment`]), because the Rust compiler's only surface is `compile()` over source text.
+ * The on-chain form is statements plus the `uint256` expression they leave available (a
+ * [`Fragment`]); a quote's return shape maps onto an `abi.decode` shape string — see [`Shape`].
  *
- * The four return SHAPES the retired `OutputSpec` described map onto `abi.decode` shape strings —
- * see [`Shape`]. Everything else about a quote (target, selector, arguments, amount offsets) is
- * byte-for-byte what it was.
+ * Where the SDK's protocol registry declares the quote function exactly — the same selector,
+ * input types and outputs — its calldata and decoding come from that registry fragment
+ * (`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, decodeAbiParameters, getAddress } from "viem";
+import { keccak256, toBytes, encodeAbiParameters, encodeFunctionData, decodeAbiParameters, getAddress, } from "viem";
+import { registryFunction } from "./abis.js";
+import { CurveRouterNGABI, CurveThreePoolABI, UniswapV2RouterABI, UniswapV3QuoterV2ABI, } from "./registry.js";
 import { bindBytes, bindConst, encodeArgs, formatBigint, hexToBytes, } from "./emit.js";
+import { parseActions } from "./program.js";
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 function sel(sig) {
     return keccak256(toBytes(sig)).slice(0, 10);
 }
+/** A registry function's calldata: its selector, then `args` encoded by its own input types. */
+function callData(fn, args) {
+    return encodeFunctionData({ abi: [fn], functionName: fn.name, args });
+}
+/** `result` decoded by a registry function's own output types. */
+function returned(fn, result) {
+    return decodeAbiParameters(fn.outputs, result);
+}
 function concatHex(a, b) {
     return (a + b.slice(2));
 }
@@ -142,24 +153,32 @@ function makeDynamic(mode, to, data, amountOffset, shape, extract) {
         return extract(emit, decodeCall(emit, mode, to, cd, shape));
     };
 }
-function requireOpt(value, name) {
+function required(options, name) {
+    const value = options[name];
     if (!value)
-        throw new Error(`opts.${name} is required for this action type`);
+        throw new Error(`quoting this action needs \`${name}\` in the quote options`);
     return value;
 }
 // ---------------------------------------------------------------------------
 // Dispatcher
 // ---------------------------------------------------------------------------
 /**
- * Compile a swap action into calldata for quoting the output amount via `eth_call`.
- *
- * Every supported action resolves to a view or revert-simulation call that
- * does **not** require token balance or approvals.
- *
- * Some protocols use a separate quoter/resolver contract. Pass the relevant
- * address in {@link QuoteOpts} when quoting those protocols.
+ * The `eth_call` that prices `action` at its own `amount` (a Carbon trade or a Balancer batch at
+ * the amounts it carries). None needs a balance or an allowance. Venues that price through a
+ * separate quoter take its address from `options`.
  */
-export function actionToQuote(action, amountIn, opts = {}) {
+export function quoteAction(action, options = {}) {
+    const [checked] = parseActions([action], "action");
+    const amount = checked.amount;
+    const explicit = checked.type === "carbonSwap" || checked.type === "balancerV2BatchSwap";
+    if (amount === undefined && !explicit) {
+        throw new Error(`quoteAction: set the ${checked.type}'s \`amount\` to quote it`);
+    }
+    const { to, data, decode } = quoteCall(checked, BigInt(amount ?? 0), options);
+    return { to, data, decode };
+}
+/** The quote for `action` at `amountIn`, with its on-chain forms where there are any. */
+export function quoteCall(action, amountIn, opts = {}) {
     switch (action.type) {
         // --- On the same contract as the action ---
         case "curveSwap":
@@ -169,7 +188,7 @@ export function actionToQuote(action, amountIn, opts = {}) {
         case "uniswapV2Swap":
             return quoteV2Router(action.router, action.path, amountIn);
         case "fraxswapSwap":
-            return quoteV2Router(action.router, action.path, amountIn);
+            return quoteFraxswap(action.router, action.path, amountIn);
         case "balancerV2Swap":
             return quoteBalV2Single(action, amountIn);
         case "balancerV2BatchSwap":
@@ -178,31 +197,25 @@ export function actionToQuote(action, amountIn, opts = {}) {
             return quoteBalV3(action, amountIn);
         case "carbonSwap":
             return quoteCarbon(action);
-        case "clipperSwap":
-            return quoteClipper(action, amountIn);
         case "dodoSwap":
             return quoteDODO(action, amountIn);
         // --- Separate quoter / resolver contract ---
         case "uniswapV3ExactInput":
-            return quoteUniV3Single(action, amountIn, requireOpt(opts.quoterV3, "quoterV3"));
+            return quoteUniV3Single(action, amountIn, required(opts, "uniswapV3Quoter"));
         case "uniswapV3ExactInputMultiHop":
-            return quoteUniV3Multi(action, amountIn, requireOpt(opts.quoterV3, "quoterV3"));
+            return quoteUniV3Multi(action, amountIn, required(opts, "uniswapV3Quoter"));
         case "uniswapV4ExactInput":
-            return quoteUniV4Single(action, amountIn, requireOpt(opts.quoterV4, "quoterV4"));
+            return quoteUniV4Single(action, amountIn, required(opts, "uniswapV4Quoter"));
         case "uniswapV4ExactInputMultiHop":
-            return quoteUniV4Multi(action, amountIn, requireOpt(opts.quoterV4, "quoterV4"));
+            return quoteUniV4Multi(action, amountIn, required(opts, "uniswapV4Quoter"));
         case "maverickSwap":
-            return quoteMaverick(action, amountIn, requireOpt(opts.quoterMaverick, "quoterMaverick"));
+            return quoteMaverick(action, amountIn, required(opts, "maverickQuoter"));
         case "maverickMultiHopSwap":
-            return quoteMaverickMulti(action, amountIn, requireOpt(opts.quoterMaverick, "quoterMaverick"));
+            return quoteMaverickMulti(action, amountIn, required(opts, "maverickQuoter"));
         case "ambientSwap":
-            return quoteAmbient(action, amountIn, requireOpt(opts.impact, "impact"));
-        case "integralSwap":
-            return quoteIntegral(action, amountIn, requireOpt(opts.relayer, "relayer"));
+            return quoteAmbient(action, amountIn, required(opts, "ambientImpact"));
         case "fluidDexT1Swap":
-            return quoteFluidT1(action, amountIn, requireOpt(opts.fluidResolver, "fluidResolver"));
-        case "fluidDexLiteSwap":
-            return quoteFluidLite(action, amountIn, requireOpt(opts.fluidLiteResolver, "fluidLiteResolver"));
+            return quoteFluidT1(action, amountIn, required(opts, "fluidDexResolver"));
         default: {
             const _ = action;
             throw new Error(`Unknown action type: ${_.type}`);
@@ -212,14 +225,18 @@ export function actionToQuote(action, amountIn, opts = {}) {
 // ---------------------------------------------------------------------------
 // View functions — on the same contract referenced by the action
 // ---------------------------------------------------------------------------
-/** Curve StableSwap / CryptoSwap pool — `get_dy(int128,int128,uint256)`. */
+/**
+ * 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.
+ */
 function quoteCurve(action, amountIn) {
+    const fn = registryFunction("curve", "CurveThreePoolABI", CurveThreePoolABI, "get_dy(int128,int128,uint256)");
     const to = action.pool;
-    const data = concatHex(sel("get_dy(int128,int128,uint256)"), encodeAbiParameters([{ type: "int128" }, { type: "int128" }, { type: "uint256" }], [BigInt(action.i), BigInt(action.j), amountIn]));
+    const data = callData(fn, [BigInt(action.i), BigInt(action.j), amountIn]);
     return {
         to,
         data,
-        decode: decodeUint256,
+        decode: (result) => returned(fn, result)[0],
         toSauce: asUint256("static", to, data),
         // selector(4) + int128 i(32) + int128 j(32) = 68
         toSauceDynamic: makeDynamic("static", to, data, 68, OUT_UINT256, firstWord),
@@ -236,17 +253,18 @@ function quoteCurveRouterNG(action, amountIn) {
     const pools = [...action.pools];
     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 data = concatHex(sel("get_dy(address[11],uint256[5][5],uint256,address[5])"), encodeAbiParameters([
-        { type: "address[11]" },
-        { type: "uint256[5][5]" },
-        { type: "uint256" },
-        { type: "address[5]" },
-    ], [route, swapParams.map((r) => r.map((v) => BigInt(v))), amountIn, pools]));
+    const data = callData(fn, [
+        route,
+        swapParams.map((r) => r.map((v) => BigInt(v))),
+        amountIn,
+        pools,
+    ]);
     return {
         to,
         data,
-        decode: decodeUint256,
+        decode: (result) => returned(fn, result)[0],
         toSauce: asUint256("static", to, data),
         // selector(4) + address[11] (11*32) + uint256[5][5] (25*32) = 1156
         toSauceDynamic: makeDynamic("static", to, data, 1156, OUT_UINT256, firstWord),
@@ -254,13 +272,14 @@ function quoteCurveRouterNG(action, amountIn) {
 }
 /** 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 = concatHex(sel("getAmountsOut(uint256,address[])"), encodeAbiParameters([{ type: "uint256" }, { type: "address[]" }], [amountIn, path]));
+    const data = callData(fn, [amountIn, path]);
     return {
         to,
         data,
         decode: (result) => {
-            const [amounts] = decodeAbiParameters([{ type: "uint256[]" }], result);
+            const [amounts] = returned(fn, result);
             return amounts[amounts.length - 1];
         },
         toSauce: asUint256ArrayLast("static", to, data),
@@ -268,6 +287,25 @@ function quoteV2Router(router, path, amountIn) {
         toSauceDynamic: makeDynamic("static", to, data, 4, OUT_UINT256_ARRAY, arrayLast),
     };
 }
+/**
+ * Fraxswap — router `getAmountsOutWithTwamm` (state-changing, so CALL). The view `getAmountsOut`
+ * reverts with "twamm out of date" whenever a pair's TWAMM has pending virtual orders; this variant
+ * executes them first, which is what the router's own swap does.
+ */
+function quoteFraxswap(router, path, amountIn) {
+    const to = router;
+    const data = concatHex(sel("getAmountsOutWithTwamm(uint256,address[])"), encodeAbiParameters([{ type: "uint256" }, { type: "address[]" }], [amountIn, path]));
+    return {
+        to,
+        data,
+        decode: (result) => {
+            const [amounts] = decodeAbiParameters([{ type: "uint256[]" }], result);
+            return amounts[amounts.length - 1];
+        },
+        toSauce: asUint256ArrayLast("call", to, data),
+        toSauceDynamic: makeDynamic("call", to, data, 4, OUT_UINT256_ARRAY, arrayLast),
+    };
+}
 // --- BalancerV2 via queryBatchSwap ---
 const BATCH_SWAP_STEP_ABI = {
     type: "tuple[]",
@@ -337,24 +375,22 @@ function quoteBalV2Batch(action) {
         amount: BigInt(s.amount),
     })), action.assets, lastStep.assetOutIndex);
 }
-/** BalancerV3 — `querySwapSingleTokenExactIn`. */
+/**
+ * BalancerV3 — `querySwapSingleTokenExactIn`. The Vault answers a query only outside a
+ * transaction (`tx.origin` zero, as in an `eth_call` from the zero address), so this quote has no
+ * on-chain form.
+ */
 function quoteBalV3(action, amountIn) {
     const to = action.router;
-    const data = concatHex(sel("querySwapSingleTokenExactIn(address,address,address,uint256,bytes)"), encodeAbiParameters([
+    const data = concatHex(sel("querySwapSingleTokenExactIn(address,address,address,uint256,address,bytes)"), encodeAbiParameters([
         { type: "address" },
         { type: "address" },
         { type: "address" },
         { type: "uint256" },
+        { type: "address" },
         { type: "bytes" },
-    ], [action.pool, action.tokenIn, action.tokenOut, amountIn, "0x"]));
-    return {
-        to,
-        data,
-        decode: decodeUint256,
-        toSauce: asUint256("static", to, data),
-        // selector(4) + pool(32) + tokenIn(32) + tokenOut(32) = 100
-        toSauceDynamic: makeDynamic("static", to, data, 100, OUT_UINT256, firstWord),
-    };
+    ], [action.pool, action.tokenIn, action.tokenOut, amountIn, ZERO_ADDR, "0x"]));
+    return { to, data, decode: decodeUint256 };
 }
 /**
  * Carbon — `calculateTradeTargetAmount` (view).
@@ -382,19 +418,6 @@ function quoteCarbon(action) {
     ]));
     return { to, data, decode: decodeUint256, toSauce: asUint256("static", to, data) };
 }
-/** Clipper — `getSellQuote` (view). On-chain FMM estimate; actual execution uses signed off-chain quotes. */
-function quoteClipper(action, amountIn) {
-    const to = action.exchange;
-    const data = concatHex(sel("getSellQuote(address,address,uint256)"), encodeAbiParameters([{ type: "address" }, { type: "address" }, { type: "uint256" }], [action.inputToken, action.outputToken, amountIn]));
-    return {
-        to,
-        data,
-        decode: decodeUint256,
-        toSauce: asUint256("static", to, data),
-        // selector(4) + tokenIn(32) + tokenOut(32) = 68
-        toSauceDynamic: makeDynamic("static", to, data, 68, OUT_UINT256, firstWord),
-    };
-}
 /**
  * DODO V2 — `querySellBase` / `querySellQuote` (view) on the pool.
  *
@@ -403,8 +426,10 @@ function quoteClipper(action, amountIn) {
  * Only single-hop is supported via view; multi-hop falls back to first pool.
  */
 function quoteDODO(action, amountIn) {
-    const pool = getAddress(action.dodoPairs[0]);
+    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)");
@@ -423,40 +448,48 @@ function quoteDODO(action, amountIn) {
         toSauceDynamic: makeDynamic("static", to, data, 36, 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
+ * way; selling the quote token is a `buyBaseToken` the pair cannot quote by input amount.
+ */
+function quoteDODOV1(pool, sellingBase, amountIn) {
+    if (!sellingBase) {
+        throw new Error("a DODO V1 pair quotes only a base-token sale by input amount " +
+            "(querySellBaseToken); this action sells the quote token");
+    }
+    const to = pool;
+    const data = concatHex(sel("querySellBaseToken(uint256)"), encodeAbiParameters([{ type: "uint256" }], [amountIn]));
+    return {
+        to,
+        data,
+        decode: decodeUint256,
+        toSauce: asUint256("static", to, data),
+        // selector(4), then the amount is the first head slot.
+        toSauceDynamic: makeDynamic("static", to, data, 4, OUT_UINT256, firstWord),
+    };
+}
 // ---------------------------------------------------------------------------
 // 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 = concatHex(sel("quoteExactInputSingle((address,address,uint256,uint24,uint160))"), encodeAbiParameters([
-        {
-            type: "tuple",
-            components: [
-                { type: "address", name: "tokenIn" },
-                { type: "address", name: "tokenOut" },
-                { type: "uint256", name: "amountIn" },
-                { type: "uint24", name: "fee" },
-                { type: "uint160", name: "sqrtPriceLimitX96" },
-            ],
-        },
-    ], [
+    const data = callData(fn, [
         {
             tokenIn: action.tokenIn,
             tokenOut: action.tokenOut,
             amountIn,
             fee: action.fee,
-            sqrtPriceLimitX96: 0n,
+            sqrtPriceLimitX96: BigInt(action.sqrtPriceLimitX96 ?? 0),
         },
-    ]));
+    ]);
     return {
         to,
         data,
-        decode: (result) => {
-            // (uint256 amountOut, uint160 sqrtPriceX96After, uint32 initializedTicksCrossed, uint256 gasEstimate)
-            const [amountOut] = decodeAbiParameters([{ type: "uint256" }, { type: "uint160" }, { type: "uint32" }, { type: "uint256" }], result);
-            return amountOut;
-        },
+        // (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),
@@ -487,7 +520,11 @@ function quoteUniV3Multi(action, amountIn, quoter) {
  */
 function quoteUniV4Single(action, amountIn, quoter) {
     const to = quoter;
-    const data = concatHex(sel("quoteExactInputSingle((((address,address,uint24,int24,address),bool,uint128,bytes)))"), encodeAbiParameters([
+    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: [
@@ -549,7 +586,7 @@ function quoteUniV4Single(action, amountIn, quoter) {
  */
 function quoteUniV4Multi(action, amountIn, quoter) {
     const to = quoter;
-    const data = concatHex(sel("quoteExactInput(((address,(address,uint24,int24,address,bytes)[],uint128)))"), encodeAbiParameters([
+    const data = concatHex(sel("quoteExactInput((address,(address,uint24,int24,address,bytes)[],uint128))"), encodeAbiParameters([
         {
             type: "tuple",
             components: [
@@ -612,7 +649,11 @@ function quoteMaverick(action, amountIn, quoter) {
         { type: "bool" },
         { type: "bool" },
         { type: "int32" },
-    ], [action.pool, amountIn, action.tokenAIn, false, 0]));
+    ], 
+    // 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)]));
     return {
         to,
         data,
@@ -689,19 +730,6 @@ function quoteAmbient(action, amountIn, impact) {
         toSauceDynamic: makeDynamic("static", to, data, 164, AMBIENT_OUTPUT, ambientFlow),
     };
 }
-/** Integral SIZE — TwapRelayer `quoteSell` (view). */
-function quoteIntegral(action, amountIn, relayer) {
-    const to = relayer;
-    const data = concatHex(sel("quoteSell(address,address,uint256)"), encodeAbiParameters([{ type: "address" }, { type: "address" }, { type: "uint256" }], [action.tokenIn, action.tokenOut, amountIn]));
-    return {
-        to,
-        data,
-        decode: decodeUint256,
-        toSauce: asUint256("static", to, data),
-        // selector(4) + tokenIn(32) + tokenOut(32) = 68
-        toSauceDynamic: makeDynamic("static", to, data, 68, OUT_UINT256, firstWord),
-    };
-}
 /**
  * Fluid DEX T1 — DexReservesResolver `estimateSwapIn` (revert-sim).
  *
@@ -720,38 +748,3 @@ function quoteFluidT1(action, amountIn, resolver) {
         toSauceDynamic: makeDynamic("call", to, data, 68, OUT_UINT256, firstWord),
     };
 }
-/**
- * Fluid DEX Lite — FluidDexLiteResolver `estimateSwapSingle` (revert-sim).
- *
- * estimateSwapSingle(DexKey dexKey_, bool swap0To1_, int256 amountSpecified_)
- *   → uint256 amountUnspecified_
- * DexKey = (address token0, address token1, bytes32 salt)
- * Positive amountSpecified = exact input.
- */
-function quoteFluidLite(action, amountIn, resolver) {
-    const to = resolver;
-    const data = concatHex(sel("estimateSwapSingle((address,address,bytes32),bool,int256)"), encodeAbiParameters([
-        {
-            type: "tuple",
-            components: [
-                { type: "address", name: "token0" },
-                { type: "address", name: "token1" },
-                { type: "bytes32", name: "salt" },
-            ],
-        },
-        { type: "bool" },
-        { type: "int256" },
-    ], [
-        { token0: action.token0, token1: action.token1, salt: action.salt },
-        action.swap0To1,
-        amountIn, // positive = exact input
-    ]));
-    return {
-        to,
-        data,
-        decode: decodeUint256,
-        toSauce: asUint256("call", to, data),
-        // selector(4) + DexKey(3*32) + bool(32) = 132
-        toSauceDynamic: makeDynamic("call", to, data, 132, OUT_UINT256, firstWord),
-    };
-}

package/actions/dist/to-sauce.d.ts

@@ -1,48 +1,64 @@
 /**
- * Routing actions -> a SauceScript program, compiled by the published Rust/wasm compiler.
+ * Action programs -> SauceScript, compiled by the published Rust/wasm compiler.
  *
- * This used to compose builder nodes (`s.int`, `s.externalCall`, `chain.join`) against the in-repo
- * TypeScript compiler's `Saucer`. That compiler is retired and the Rust one's only surface is
- * `compile()` over source text, so every action now emits SauceScript STATEMENTS instead — the
- * idiom `sdk/src/deposit/templates.ts` and `sdk/src/token/svm.ts` already use.
+ * Every protocol call is an ABI binding, `IBinding.at(target).method(args)`, the same shape an SDK
+ * route body lowers to: the compiler derives the selector and the argument encoding from the ABI,
+ * so this module computes neither. The ABIs come from the SDK's protocol registry wherever it has
+ * the exact function, and `abis.ts` records, per method, why not where it does not. Struct
+ * arguments are object literals keyed by the ABI's component names, which the compiler orders.
  *
- * WHAT DID NOT CHANGE: the calldata. Every action still targets the same address with the same
- * selector and the same ABI-encoded arguments; `emit.ts`'s `encodeArgs` reproduces the retired
- * builder's `abiEncode(tuple(args))` for every arity. What changed is the shape of the intermediate
- * representation, and two things that were latent bugs in it:
+ * Two kinds of call stay raw `evm.call`, each for a stated reason:
  *
- *   - the per-build scratch-slot counters (`curveScratchCounter`, `v2ScratchCounter`) were
- *     module-level and leaked across builds; they are the [`Emitter`]'s now, so a program's names
- *     depend only on that program;
- *   - a call whose `uint256` return value is consumed binds it to a local. The builder returned an
- *     expression that re-issued the call on each use, which is one on-chain call per use.
+ *   - an ERC-20 `approve`/`transfer` (`erc20Write`), through the SDK's `token/safe` lowering:
+ *     a binding would decode the ABI's `bool` output, and a token that returns nothing (USDT)
+ *     would then revert a write that succeeded — the raw call is checked the way OpenZeppelin's
+ *     `SafeERC20` checks it instead;
+ *   - a call carrying native value (`valueCall`), because a binding cannot attach value.
+ *
+ * A binding method's output is declared, and so decoded, only when an action reads it — see
+ * `abis.ts`.
+ *
+ * AMOUNTS AND OUTPUTS. An action's amount is its `amount`, the local an earlier action saved under
+ * its `amountRef`, or the previous action's output. Its output is what it delivered to the Pot
+ * (`ctx.self()`) for a swap, a wrap or a stake and for an Aave withdrawal — the venue's return value
+ * where that is the amount, a balance delta around the call where it is not — the value read for a
+ * source action, and otherwise its own amount, passed through. An action whose output a later
+ * action spends delivers to the Pot whatever its `recipient` says.
  */
 import { type Emitter, type Expr, type Stmt } from "./emit.js";
-import type { RoutingAction } from "./types.js";
+import { type ActionContracts, type BindingName } from "./abis.js";
+import type { Action } from "./types.js";
 export interface ActionResult {
     /** Statements that execute the action, in order. */
     readonly stmts: readonly Stmt[];
     /**
-     * The action's output amount, as an expression valid once `stmts` have run.
-     *
-     * Meaningful only when `buildAction` was asked for the output (`needsOutput`). An action whose
-     * return value was not requested leaves the pass-through input amount here — the same looseness
-     * the retired builder had, and for the same reason: nothing reads it in that case.
+     * The action's output, as an expression valid once `stmts` have run. Meaningful only when the
+     * lowering was asked for it (`needsOutput`); otherwise it is the pass-through amount, unread.
      */
     readonly output: Expr;
+    /** The ABI bindings `stmts` call through. */
+    readonly bindings: readonly BindingName[];
+}
+/** A program's parts, before it is rendered for a standalone compile or a route body. */
+export interface Lowered {
+    readonly body: readonly Stmt[];
+    readonly contracts: ActionContracts;
+    /** Runtime arguments (`argument` actions), in the order `main` declares them. */
+    readonly parameters: readonly string[];
 }
-/** The SauceScript source for `actions`. Empty for an empty list. */
-export declare function actionsToSauceSource(actions: readonly RoutingAction[]): string;
-export declare function actionsToSauce(actions: readonly RoutingAction[]): Uint8Array;
-export declare function actionToSauce(action: RoutingAction): Uint8Array;
+/** Lowers a validated action list into `main`'s body. */
+export declare function lowerActions(actions: readonly Action[]): Lowered;
+/** `main` for a standalone compile: typed parameters and the `void` return the compiler requires. */
+export declare function renderProgram(lowered: Lowered): string;
 /**
- * Emit the statements for one action.
- *
- * BREAKING: this took a `Saucer` and a `Saucer` amount and returned builder nodes. It now takes an
- * [`Emitter`] (from `newEmitter()`) and a SauceScript amount EXPRESSION, and returns source
- * fragments. `needsOutput` is the old `outputChained` under its real name: it both selects the
- * recipient (`ctx.self()` when the output is consumed here, the action's own `recipient` otherwise)
- * and decides whether a call's `uint256` return value is captured.
+ * `main` for an SDK route body: no annotations, because the route compiler's rewrite passes parse
+ * plain JavaScript and add the `void` themselves. A route body is compiled with no arguments, so a
+ * program with `argument` actions cannot be one.
+ */
+export declare function renderRouteBody(lowered: Lowered): string;
+/**
+ * The statements for one action, spending the SauceScript expression `amount`. `needsOutput` both
+ * routes the output to the Pot (instead of the action's own `recipient`) and captures it.
  */
-export declare function buildAction(emit: Emitter, action: RoutingAction, amountIn: Expr, needsOutput: boolean): ActionResult;
+export declare function lowerAction(emit: Emitter, action: Action, amount: Expr, needsOutput: boolean): ActionResult;
 //# sourceMappingURL=to-sauce.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"to-sauce.d.ts","sourceRoot":"","sources":["../src/to-sauce.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EAeL,KAAK,OAAO,EACZ,KAAK,IAAI,EAET,KAAK,IAAI,EACV,MAAM,WAAW,CAAC;AAInB,OAAO,KAAK,EACV,aAAa,EA2Cd,MAAM,YAAY,CAAC;AAkEpB,MAAM,WAAW,YAAY;IAC3B,oDAAoD;IACpD,QAAQ,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,CAAC;IAChC;;;;;;OAMG;IACH,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;CACvB;AAMD,qEAAqE;AACrE,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,SAAS,aAAa,EAAE,GAAG,MAAM,CAiC9E;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,SAAS,aAAa,EAAE,GAAG,UAAU,CAI5E;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,aAAa,GAAG,UAAU,CAE/D;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,OAAO,EACb,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,IAAI,EACd,WAAW,EAAE,OAAO,GACnB,YAAY,CA2Fd"}
+{"version":3,"file":"to-sauce.d.ts","sourceRoot":"","sources":["../src/to-sauce.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,EASL,KAAK,OAAO,EACZ,KAAK,IAAI,EACT,KAAK,IAAI,EACV,MAAM,WAAW,CAAC;AACnB,OAAO,EAGL,KAAK,eAAe,EACpB,KAAK,WAAW,EAEjB,MAAM,WAAW,CAAC;AAKnB,OAAO,KAAK,EACV,MAAM,EA4CP,MAAM,YAAY,CAAC;AAmEpB,MAAM,WAAW,YAAY;IAC3B,oDAAoD;IACpD,QAAQ,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,CAAC;IAChC;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;IACtB,6CAA6C;IAC7C,QAAQ,CAAC,QAAQ,EAAE,SAAS,WAAW,EAAE,CAAC;CAC3C;AAoID,yFAAyF;AACzF,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,IAAI,EAAE,SAAS,IAAI,EAAE,CAAC;IAC/B,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAC;IACpC,iFAAiF;IACjF,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;CACxC;AAOD,yDAAyD;AACzD,wBAAgB,YAAY,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CA8BhE;AAYD,qGAAqG;AACrG,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAItD;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CASxD;AAED;;;GAGG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,OAAO,EACb,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,IAAI,EACZ,WAAW,EAAE,OAAO,GACnB,YAAY,CA4Fd"}