@eco-incorp/sauce 0.99.6 → 0.99.8

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

@@ -18,6 +18,12 @@
  * A binding method's output is declared, and so decoded, only when an action reads it — see
  * `abis.ts`.
  *
+ * ONE SWAP IMPLEMENTATION. A swap action at one of `@sauce/router`'s nine venues is a call into
+ * that library — `uniswapV2Swap` is `uniswapV2(...)`, `curveSwap` is `curve(...)` — with the
+ * action's fields as its arguments, so an action program and a hand-written Sauce program trade a
+ * venue through the same code. The program imports what it calls from `@sauce/router`, which the
+ * SDK serves from memory (`compile.ts`). Only the venues the library does not cover lower here.
+ *
  * 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
@@ -38,27 +44,35 @@ export interface ActionResult {
     readonly output: Expr;
     /** The ABI bindings `stmts` call through. */
     readonly bindings: readonly BindingName[];
+    /** The `@sauce/router` functions `stmts` call. */
+    readonly router: readonly RouterFunction[];
 }
+/** A function of `@sauce/router`, the one implementation of a swap at its venue. */
+export type RouterFunction = "uniswapV2" | "uniswapV3" | "uniswapV4" | "curve" | "balancerV2" | "dodoV2" | "traderJoeLB" | "woofi" | "maverickV2";
 /** 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;
+    /** The `@sauce/router` functions the body calls, which the program imports. */
+    readonly router: readonly RouterFunction[];
     /** Runtime arguments (`argument` actions), in the order `main` declares them. */
     readonly parameters: readonly string[];
 }
 /** Lowers a validated action list into `main`'s body. */
 export declare function lowerActions(actions: readonly Action[]): Lowered;
+/** The line importing what the program calls from `@sauce/router`, or nothing. */
+export declare function routerImport(router: readonly RouterFunction[]): string;
 /** `main` for a standalone compile: typed parameters and the `void` return the compiler requires. */
 export declare function renderProgram(lowered: Lowered): string;
 /**
- * `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.
+ * `main` for an SDK route body: no return annotation, because the route compiler's adapter adds the
+ * `void` itself. 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 lowerAction(emit: Emitter, action: Action, amount: Expr, needsOutput: boolean): ActionResult;
+export declare function lowerAction(emit: Emitter, action: Action, amount: Expr, needsOutput: boolean, where?: string): 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;;;;;;;;;;;;;;;;;;;;;;;;;;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"}
+{"version":3,"file":"to-sauce.d.ts","sourceRoot":"","sources":["../src/to-sauce.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;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;AAMnB,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;IAC1C,kDAAkD;IAClD,QAAQ,CAAC,MAAM,EAAE,SAAS,cAAc,EAAE,CAAC;CAC5C;AAED,oFAAoF;AACpF,MAAM,MAAM,cAAc,GACtB,WAAW,GACX,WAAW,GACX,WAAW,GACX,OAAO,GACP,YAAY,GACZ,QAAQ,GACR,aAAa,GACb,OAAO,GACP,YAAY,CAAC;AAoLjB,yFAAyF;AACzF,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,IAAI,EAAE,SAAS,IAAI,EAAE,CAAC;IAC/B,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAC;IACpC,+EAA+E;IAC/E,QAAQ,CAAC,MAAM,EAAE,SAAS,cAAc,EAAE,CAAC;IAC3C,iFAAiF;IACjF,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;CACxC;AAOD,yDAAyD;AACzD,wBAAgB,YAAY,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAsChE;AAED,kFAAkF;AAClF,wBAAgB,YAAY,CAAC,MAAM,EAAE,SAAS,cAAc,EAAE,GAAG,MAAM,CAEtE;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,EACpB,KAAK,SAAW,GACf,YAAY,CA4Fd"}

package/actions/dist/to-sauce.js

@@ -18,6 +18,12 @@
  * A binding method's output is declared, and so decoded, only when an action reads it — see
  * `abis.ts`.
  *
+ * ONE SWAP IMPLEMENTATION. A swap action at one of `@sauce/router`'s nine venues is a call into
+ * that library — `uniswapV2Swap` is `uniswapV2(...)`, `curveSwap` is `curve(...)` — with the
+ * action's fields as its arguments, so an action program and a hand-written Sauce program trade a
+ * venue through the same code. The program imports what it calls from `@sauce/router`, which the
+ * SDK serves from memory (`compile.ts`). Only the venues the library does not cover lower here.
+ *
  * 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
@@ -27,16 +33,10 @@
  */
 import { bindBytes, bindConst, encodeArgs, fn, hexToBytes, indent, newEmitter, slotVar, } from "./emit.js";
 import { contractsFor, methodSelector, } from "./abis.js";
+import { CONTRACT_NAME_RE, isName, NATIVE } from "./names.js";
 import { safeApproveStatements, safeTransferStatements } from "./registry.js";
 import { consumesPrevious } from "./semantics.js";
 import { ACTION_SPECS } from "./spec.js";
-/** V4 ActionConstants.CONTRACT_BALANCE — signals the router to use its own token balance. */
-const V4_CONTRACT_BALANCE = 1n << 255n;
-/**
- * V4 ActionConstants.OPEN_DELTA — a TAKE of this amount takes everything owed. It is ZERO: the
- * all-ones word this used to be overflows the router's `uint128` cast and reverts every swap.
- */
-const V4_OPEN_DELTA = 0n;
 /** type(int256).max — Balancer's "no limit" for an asset the Vault may take. */
 const MAX_INT256 = (1n << 255n) - 1n;
 /** Aave V3's variable interest-rate mode, the only one it offers. */
@@ -49,8 +49,18 @@ const SELF = "ctx.self()";
 function word(value) {
     return `${BigInt(value).toString()}n`;
 }
-/** An address as a hex literal, so the emitted source reads like the addresses it was built from. */
+/**
+ * A token or contract field as the program reads it: a name is the program global of that name
+ * (`USDC`, `UniswapV3.Factory`), which the compile resolves on its chain; `"native"` is the zero
+ * address the venue keys the native currency as; an address is a hex literal, so the emitted source
+ * reads like the addresses it was built from. A name is emitted as written: `program.ts` admits
+ * only an identifier or `Identifier.Identifier`.
+ */
 function addr(value) {
+    if (typeof value === "string" && isName(value))
+        return value;
+    if (value === NATIVE)
+        return "0n";
     return `0x${BigInt(value).toString(16).padStart(40, "0")}n`;
 }
 /** A recipient field: an address, or the Pot for `"self"`. */
@@ -80,10 +90,14 @@ function list(elements) {
 /** Collects one action's statements and the bindings they name. */
 class Lowering {
     emit;
+    where;
     stmts = [];
     used = new Set();
-    constructor(emit) {
+    library = new Set();
+    /** `where` names the action in a revert message: `actions[2]`. */
+    constructor(emit, where) {
         this.emit = emit;
+        this.where = where;
     }
     /** `IBinding.at(target).method(args)` — the expression, not yet a statement. */
     call(binding, target, method, args) {
@@ -143,14 +157,45 @@ class Lowering {
     selfBalance(token) {
         return this.bind("bal", this.call("IErc20", token, "balanceOf", [SELF]));
     }
+    /**
+     * The Pot's balance of an asset a venue may pay in the native currency — `"native"` or the zero
+     * address, which Ambient and the Balancer V2 Vault key it as: its native balance, not an ERC-20
+     * read of the zero address, which has no code to answer.
+     */
+    assetBalance(asset) {
+        const native = asset === NATIVE || (/^0x/i.test(asset) && BigInt(asset) === 0n);
+        return native ? this.nativeBalance() : this.selfBalance(addr(asset));
+    }
     /** The Pot's native balance, as a bound local. */
     nativeBalance() {
         return this.bind("nat", "ctx.selfBalance()");
     }
+    /** `fn(args)`, a call into `@sauce/router` — the expression, not yet a statement. */
+    router(fn, args) {
+        this.library.add(fn);
+        return `${fn}(${args.join(", ")})`;
+    }
     result(output) {
-        return { stmts: this.stmts, output, bindings: [...this.used] };
+        return { stmts: this.stmts, output, bindings: [...this.used], router: [...this.library] };
     }
 }
+/**
+ * A pool given by its key, read from its factory while the program runs: by namespace when the
+ * factory is named (`UniswapV3.Factory.getPool(...)`, the registry's own ABI for it), through
+ * `binding` when it is an address. `field` picks the pool out of a struct the lookup returns. No
+ * pool under that key on this chain reads as the zero address, which reverts the program before
+ * anything moves.
+ */
+function keyedPool(l, factory, binding, method, args, field) {
+    const lookup = CONTRACT_NAME_RE.test(factory)
+        ? `${factory}.${method}(${args.join(", ")})`
+        : l.call(binding, addr(factory), method, args);
+    let pool = l.bind("pool", lookup);
+    if (field !== undefined)
+        pool = l.bind("pool", `${pool}.${field}`);
+    l.stmts.push(`require(${pool} != 0n, "${l.where}: no pool under that key");`);
+    return pool;
+}
 /** A call whose declared output is the action's output when `needsOutput`. */
 function captured(l, needsOutput, call, passThrough) {
     if (!needsOutput) {
@@ -184,6 +229,7 @@ export function lowerActions(actions) {
     const emit = newEmitter();
     const body = [];
     const bindings = new Set();
+    const router = new Set();
     const parameters = [];
     const declared = new Set();
     let previous;
@@ -192,10 +238,12 @@ export function lowerActions(actions) {
             parameters.push(action.name);
         const next = actions[i + 1];
         const needsOutput = action.saveOutputAs !== undefined || (next !== undefined && consumesPrevious(next));
-        const result = lowerAction(emit, action, amountOf(action, previous), needsOutput);
+        const result = lowerAction(emit, action, amountOf(action, previous), needsOutput, `actions[${i}]`);
         body.push(...result.stmts);
         for (const b of result.bindings)
             bindings.add(b);
+        for (const f of result.router)
+            router.add(f);
         if (needsOutput) {
             const slot = action.saveOutputAs === undefined ? `t_out${i}` : slotVar(action.saveOutputAs);
             body.push(declared.has(slot) ? `${slot} = ${result.output};` : `let ${slot} = ${result.output};`);
@@ -203,7 +251,11 @@ export function lowerActions(actions) {
             previous = slot;
         }
     });
-    return { body, contracts: contractsFor(bindings), parameters };
+    return { body, contracts: contractsFor(bindings), router: [...router].sort(), parameters };
+}
+/** The line importing what the program calls from `@sauce/router`, or nothing. */
+export function routerImport(router) {
+    return router.length === 0 ? "" : `import { ${router.join(", ")} } from "@sauce/router";\n\n`;
 }
 /** The amount an action spends: its `amount`, the output it references, or the previous output. */
 function amountOf(action, previous) {
@@ -221,12 +273,12 @@ function amountOf(action, previous) {
 /** `main` for a standalone compile: typed parameters and the `void` return the compiler requires. */
 export function renderProgram(lowered) {
     const params = lowered.parameters.map((name) => `${argumentVar(name)}: Uint256`);
-    return `${fn("main", params, "void", lowered.body)}\n`;
+    return `${routerImport(lowered.router)}${fn("main", params, "void", lowered.body)}\n`;
 }
 /**
- * `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.
+ * `main` for an SDK route body: no return annotation, because the route compiler's adapter adds the
+ * `void` itself. A route body is compiled with no arguments, so a program with `argument` actions
+ * cannot be one.
  */
 export function renderRouteBody(lowered) {
     if (lowered.parameters.length > 0) {
@@ -234,43 +286,43 @@ export function renderRouteBody(lowered) {
             `${lowered.parameters.map((p) => `'${p}'`).join(", ")}. Read the amount on-chain instead ` +
             `(a \`balanceOf\` action), or compile it standalone with \`compileProgram\`.`);
     }
-    return `function main() {\n${indent(lowered.body)}\n}\n`;
+    return `${routerImport(lowered.router)}function main() {\n${indent(lowered.body)}\n}\n`;
 }
 /**
  * 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 function lowerAction(emit, action, amount, needsOutput) {
-    const l = new Lowering(emit);
+export function lowerAction(emit, action, amount, needsOutput, where = "action") {
+    const l = new Lowering(emit, where);
     switch (action.type) {
-        case "uniswapV3ExactInput":
-            return uniswapV3ExactInput(l, action, amount, needsOutput);
-        case "uniswapV3ExactInputMultiHop":
-            return uniswapV3ExactInputMultiHop(l, action, amount, needsOutput);
-        case "uniswapV4ExactInput":
-            return uniswapV4ExactInput(l, action, amount, needsOutput);
-        case "uniswapV4ExactInputMultiHop":
-            return uniswapV4ExactInputMultiHop(l, action, amount, needsOutput);
+        case "uniswapV2Swap":
+            return uniswapV2Swap(l, action, amount, needsOutput);
+        case "uniswapV3Swap":
+            return uniswapV3Swap(l, action, amount, needsOutput);
+        case "uniswapV4Swap":
+            return uniswapV4Swap(l, action, amount, needsOutput);
         case "curveSwap":
             return curveSwap(l, action, amount, needsOutput);
-        case "curveRouterNGSwap":
-            return curveRouterNGSwap(l, action, amount, needsOutput);
         case "balancerV2Swap":
             return balancerV2Swap(l, action, amount, needsOutput);
+        case "dodoV2Swap":
+            return dodoV2Swap(l, action, amount, needsOutput);
+        case "traderJoeLBSwap":
+            return traderJoeLBSwap(l, action, amount, needsOutput);
+        case "woofiSwap":
+            return woofiSwap(l, action, amount, needsOutput);
+        case "maverickV2Swap":
+            return maverickV2Swap(l, action, amount, needsOutput);
+        case "curveRouterNGSwap":
+            return curveRouterNGSwap(l, action, amount, needsOutput);
         case "balancerV2BatchSwap":
             return balancerV2BatchSwap(l, action, amount, needsOutput);
         case "balancerV3Swap":
             return balancerV3Swap(l, action, amount, needsOutput);
-        case "uniswapV2Swap":
-            return uniswapV2Swap(l, action, amount, needsOutput);
         case "ambientSwap":
             return ambientSwap(l, action, amount, needsOutput);
-        case "dodoSwap":
-            return dodoSwap(l, action, amount, needsOutput);
-        case "maverickSwap":
-            return maverickSwap(l, action, amount, needsOutput);
-        case "maverickMultiHopSwap":
-            return maverickMultiHopSwap(l, action, amount, needsOutput);
+        case "dodoV1Swap":
+            return dodoV1Swap(l, action, amount, needsOutput);
         case "carbonSwap":
             return carbonSwap(l, action, amount, needsOutput);
         case "fraxswapSwap":
@@ -334,150 +386,159 @@ export function lowerAction(emit, action, amount, needsOutput) {
     }
 }
 // ---------------------------------------------------------------------------
-// Swap actions
+// Swap actions — through `@sauce/router`
 // ---------------------------------------------------------------------------
-function uniswapV3ExactInput(l, action, amountIn, needsOutput) {
-    const params = record({
-        tokenIn: addr(action.tokenIn),
-        tokenOut: addr(action.tokenOut),
-        fee: word(action.fee),
-        recipient: needsOutput ? SELF : recipient(action.recipient),
+/**
+ * Where a swap action's output goes: the Pot when a later action spends it, else its recipient.
+ * Every `@sauce/router` function returns what the recipient received, which is the action's output.
+ */
+function swapRecipient(action, needsOutput) {
+    return needsOutput ? SELF : recipient(action.recipient);
+}
+function uniswapV2Swap(l, action, amountIn, needsOutput) {
+    const pair = action.pool !== undefined
+        ? addr(action.pool)
+        : keyedPool(l, action.factory, "IUniswapV2Factory", "getPair", [
+            addr(action.tokenIn),
+            addr(action.tokenOut),
+        ]);
+    const call = l.router("uniswapV2", [
+        pair,
+        addr(action.tokenIn),
+        addr(action.tokenOut),
         amountIn,
-        amountOutMinimum: word(action.amountOutMin),
-        sqrtPriceLimitX96: word(action.sqrtPriceLimitX96 ?? "0"),
-    });
-    const call = l.call("ISwapRouter02", addr(action.router), "exactInputSingle", [params]);
+        word(action.feePpm ?? 0),
+        word(action.amountOutMin),
+        swapRecipient(action, needsOutput),
+    ]);
     return captured(l, needsOutput, call, amountIn);
 }
-function uniswapV3ExactInputMultiHop(l, action, amountIn, needsOutput) {
-    const path = l.bytes("path", hexToBytes(action.path));
-    const params = record({
-        path,
-        recipient: needsOutput ? SELF : recipient(action.recipient),
+function uniswapV3Swap(l, action, amountIn, needsOutput) {
+    const tokens = [addr(action.tokenIn), addr(action.tokenOut)];
+    const pool = action.pool !== undefined
+        ? addr(action.pool)
+        : action.fee !== undefined
+            ? keyedPool(l, action.factory, "IUniswapV3Factory", "getPool", [
+                ...tokens,
+                word(action.fee),
+            ])
+            : keyedPool(l, action.factory, "ISlipstreamFactory", "getPool", [
+                ...tokens,
+                word(action.tickSpacing),
+            ]);
+    const call = l.router("uniswapV3", [
+        pool,
+        addr(action.tokenIn),
+        addr(action.tokenOut),
         amountIn,
-        amountOutMinimum: word(action.amountOutMin),
-    });
-    const call = l.call("ISwapRouter02", addr(action.router), "exactInput", [params]);
+        word(action.sqrtPriceLimitX96 ?? "0"),
+        word(action.amountOutMin),
+        swapRecipient(action, needsOutput),
+    ]);
     return captured(l, needsOutput, call, amountIn);
 }
-/**
- * Uniswap V4 through the Universal Router's `V4_SWAP` command (0x10): the input token is
- * transferred to the router, which swaps (`SWAP_EXACT_IN_SINGLE` 0x06 / `SWAP_EXACT_IN` 0x07),
- * settles from its own balance (`SETTLE` 0x0b, `payerIsUser = false`, `CONTRACT_BALANCE`) and takes
- * everything owed to the recipient (`TAKE` 0x0e, `OPEN_DELTA`).
- *
- * The router input is encoded in the program — `abi.encode(actions, params[])` inside the
- * `bytes[]` of `execute` — so the amount is a runtime value, and the TAKE recipient can be
- * `ctx.self()` when the output is chained, like every other swap. The swap parameters are ONE
- * ABI-encoded struct, head offset included, which is what the V4 router's calldata decoder reads;
- * the multi-hop struct has no `maxHopSlippage` field. Both were checked against the deployed
- * mainnet Universal Router (`v4.mainnet.test.ts`), where the flattened encoding this replaced reverts.
- */
-function v4Execute(l, router, currencyIn, currencyOut, amountIn, swapAction, swapParams, to) {
-    l.erc20Write("transfer", addr(currencyIn), addr(router), amountIn);
-    const settle = l.bind("settle", encodeArgs([addr(currencyIn), word(V4_CONTRACT_BALANCE), flag(false)]));
-    const take = l.bind("take", encodeArgs([addr(currencyOut), to, word(V4_OPEN_DELTA)]));
-    const actions = l.bytes("v4actions", Uint8Array.of(swapAction, 0x0b, 0x0e));
-    const input = l.bind("v4input", encodeArgs([actions, list([swapParams, settle, take])]));
-    const commands = l.bytes("v4cmd", Uint8Array.of(0x10));
-    l.exec("IUniversalRouter", addr(router), "execute", [commands, list([input])]);
-}
-function uniswapV4ExactInput(l, action, amountIn, needsOutput) {
-    const { poolKey } = action;
-    const currencyIn = action.zeroForOne ? poolKey.currency0 : poolKey.currency1;
-    const currencyOut = action.zeroForOne ? poolKey.currency1 : poolKey.currency0;
-    const to = needsOutput ? SELF : recipient(action.recipient);
-    return balanceDelta(l, needsOutput, () => l.selfBalance(addr(currencyOut)), () => {
-        const hookData = l.bytes("hook", new Uint8Array());
-        // ExactInputSingleParams { PoolKey poolKey; bool zeroForOne; uint128 amountIn;
-        //                          uint128 amountOutMinimum; bytes hookData; }
-        const params = l.bind("v4swap", encodeArgs([
-            record({
-                poolKey: record({
-                    currency0: addr(poolKey.currency0),
-                    currency1: addr(poolKey.currency1),
-                    fee: word(poolKey.fee),
-                    tickSpacing: word(poolKey.tickSpacing),
-                    hooks: addr(poolKey.hooks),
-                }),
-                zeroForOne: flag(action.zeroForOne),
-                amountIn,
-                amountOutMinimum: word(action.amountOutMin),
-                hookData,
-            }),
-        ]));
-        v4Execute(l, action.router, currencyIn, currencyOut, amountIn, 0x06, params, to);
-    }, amountIn);
-}
-function uniswapV4ExactInputMultiHop(l, action, amountIn, needsOutput) {
-    const currencyOut = action.path[action.path.length - 1].intermediateCurrency;
-    const to = needsOutput ? SELF : recipient(action.recipient);
-    return balanceDelta(l, needsOutput, () => l.selfBalance(addr(currencyOut)), () => {
-        const hookData = l.bytes("hook", new Uint8Array());
-        // ExactInputParams { Currency currencyIn; PathKey[] path; uint128 amountIn;
-        //                    uint128 amountOutMinimum; }
-        const path = list(action.path.map((hop) => record({
-            intermediateCurrency: addr(hop.intermediateCurrency),
-            fee: word(hop.fee),
-            tickSpacing: word(hop.tickSpacing),
-            hooks: addr(hop.hooks),
-            hookData,
-        })));
-        const params = l.bind("v4swap", encodeArgs([
-            record({
-                currencyIn: addr(action.currencyIn),
-                path,
-                amountIn,
-                amountOutMinimum: word(action.amountOutMin),
-            }),
-        ]));
-        v4Execute(l, action.router, action.currencyIn, currencyOut, amountIn, 0x07, params, to);
-    }, amountIn);
+function uniswapV4Swap(l, action, amountIn, needsOutput) {
+    const call = l.router("uniswapV4", [
+        addr(action.poolManager),
+        addr(action.tokenIn),
+        addr(action.tokenOut),
+        amountIn,
+        word(action.fee),
+        word(action.tickSpacing),
+        action.hooks === undefined ? ZERO : addr(action.hooks),
+        word(action.sqrtPriceLimitX96 ?? "0"),
+        word(action.amountOutMin),
+        swapRecipient(action, needsOutput),
+    ]);
+    return captured(l, needsOutput, call, amountIn);
 }
 function curveSwap(l, action, amountIn, needsOutput) {
-    // 3pool-era pools (e.g. 0xbEbc44…) expose only the 4-argument `exchange`, which returns nothing
-    // and pays msg.sender — the executing account. The output is the `tokenOut` balance delta around
-    // the call, which excludes whatever an earlier action left behind.
-    const tokenOut = addr(action.tokenOut);
-    const pre = l.selfBalance(tokenOut);
-    l.exec("ICurvePool", addr(action.pool), "exchange", [
+    const call = l.router("curve", [
+        addr(action.pool),
+        addr(action.tokenIn),
+        addr(action.tokenOut),
+        amountIn,
         word(action.i),
         word(action.j),
-        amountIn,
+        flag(action.indexType === "uint256"),
         word(action.amountOutMin),
+        swapRecipient(action, needsOutput),
     ]);
-    const post = l.selfBalance(tokenOut);
-    const delta = l.bind("delta", `${post} - ${pre}`);
-    // Not chained, and not asked to keep it: forward the delta to the recipient.
-    if (!needsOutput && action.recipient !== "self") {
-        l.erc20Write("transfer", tokenOut, recipient(action.recipient), delta);
-    }
-    return l.result(delta);
+    return captured(l, needsOutput, call, amountIn);
 }
 function balancerV2Swap(l, action, amountIn, needsOutput) {
-    const userData = l.bytes("ud", new Uint8Array());
-    const singleSwap = record({
-        poolId: b32(action.poolId),
-        kind: ZERO, // GIVEN_IN
-        assetIn: addr(action.tokenIn),
-        assetOut: addr(action.tokenOut),
-        amount: amountIn,
-        userData,
-    });
-    const funds = record({
-        sender: SELF, // must be msg.sender for the Vault to pull from it
-        fromInternalBalance: flag(false),
-        recipient: needsOutput ? SELF : recipient(action.recipient),
-        toInternalBalance: flag(false),
-    });
-    const call = l.call("IBalancerV2Vault", addr(action.vault), "swap", [
-        singleSwap,
-        funds,
+    const call = l.router("balancerV2", [
+        addr(action.vault),
+        addr(action.tokenIn),
+        addr(action.tokenOut),
+        amountIn,
+        b32(action.poolId),
         word(action.amountOutMin),
-        word(action.deadline),
+        swapRecipient(action, needsOutput),
+    ]);
+    return captured(l, needsOutput, call, amountIn);
+}
+function dodoV2Swap(l, action, amountIn, needsOutput) {
+    const call = l.router("dodoV2", [
+        addr(action.pool),
+        addr(action.tokenIn),
+        addr(action.tokenOut),
+        amountIn,
+        addr(action.baseToken),
+        addr(action.quoteToken),
+        word(action.amountOutMin),
+        swapRecipient(action, needsOutput),
+    ]);
+    return captured(l, needsOutput, call, amountIn);
+}
+function traderJoeLBSwap(l, action, amountIn, needsOutput) {
+    const pair = action.pool !== undefined
+        ? addr(action.pool)
+        : keyedPool(l, action.factory, "ILBFactory", "getLBPairInformation", [addr(action.tokenIn), addr(action.tokenOut), word(action.binStep)], "LBPair");
+    // The pair's own tokens, read from it when the action leaves them out.
+    const [tokenX, tokenY] = action.tokenX !== undefined
+        ? [addr(action.tokenX), addr(action.tokenY)]
+        : [
+            l.bind("tokenX", l.call("ILBPair", pair, "getTokenX", [])),
+            l.bind("tokenY", l.call("ILBPair", pair, "getTokenY", [])),
+        ];
+    const call = l.router("traderJoeLB", [
+        pair,
+        addr(action.tokenIn),
+        addr(action.tokenOut),
+        amountIn,
+        tokenX,
+        tokenY,
+        word(action.amountOutMin),
+        swapRecipient(action, needsOutput),
+    ]);
+    return captured(l, needsOutput, call, amountIn);
+}
+function woofiSwap(l, action, amountIn, needsOutput) {
+    const call = l.router("woofi", [
+        addr(action.pool),
+        addr(action.tokenIn),
+        addr(action.tokenOut),
+        amountIn,
+        word(action.amountOutMin),
+        swapRecipient(action, needsOutput),
     ]);
     return captured(l, needsOutput, call, amountIn);
 }
+function maverickV2Swap(l, action, amountIn, needsOutput) {
+    const call = l.router("maverickV2", [
+        addr(action.pool),
+        addr(action.tokenIn),
+        addr(action.tokenOut),
+        amountIn,
+        word(action.amountOutMin),
+        swapRecipient(action, needsOutput),
+    ]);
+    return captured(l, needsOutput, call, amountIn);
+}
+// ---------------------------------------------------------------------------
+// Swap actions — venues `@sauce/router` does not cover
+// ---------------------------------------------------------------------------
 function balancerV2BatchSwap(l, action, amountIn, needsOutput) {
     const userData = l.bytes("ud", new Uint8Array());
     const steps = list(action.steps.map((step) => record({
@@ -500,7 +561,7 @@ function balancerV2BatchSwap(l, action, amountIn, needsOutput) {
     // realized output is the executing account's delta on the last step's output asset instead.
     const lastStep = action.steps[action.steps.length - 1];
     const assetOut = action.assets[Number(lastStep.assetOutIndex)];
-    return balanceDelta(l, needsOutput, () => l.selfBalance(addr(assetOut)), () => l.exec("IBalancerV2Vault", addr(action.vault), "batchSwap", [
+    return balanceDelta(l, needsOutput, () => l.assetBalance(assetOut), () => l.exec("IBalancerV2Vault", addr(action.vault), "batchSwap", [
         ZERO, // GIVEN_IN
         steps,
         list(action.assets.map(addr)),
@@ -509,17 +570,6 @@ function balancerV2BatchSwap(l, action, amountIn, needsOutput) {
         word(action.deadline),
     ]), amountIn);
 }
-function uniswapV2Swap(l, action, amountIn, needsOutput) {
-    // `swapExactTokensForTokens` returns `uint256[] amounts`; the output is the balance delta on the
-    // last path token instead, which is what actually arrived.
-    return balanceDelta(l, needsOutput, () => l.selfBalance(addr(action.path[action.path.length - 1])), () => l.exec("IUniswapV2Router", addr(action.router), "swapExactTokensForTokens", [
-        amountIn,
-        word(action.amountOutMin),
-        list(action.path.map(addr)),
-        needsOutput ? SELF : recipient(action.recipient),
-        word(action.deadline),
-    ]), amountIn);
-}
 function curveRouterNGSwap(l, action, amountIn, needsOutput) {
     const zero = "0x0000000000000000000000000000000000000000";
     const route = [...action.route];
@@ -561,8 +611,8 @@ function ambientSwap(l, action, amountIn, needsOutput) {
     // inBaseQty, qty, tip, limitPrice, minOut, reserveFlags). It returns `bytes`, and settles to
     // msg.sender, so the output is the delta on the received side: the quote token when buying
     // (paying base), the base token otherwise.
-    const tokenOut = addr(action.isBuy ? action.quote : action.base);
-    return balanceDelta(l, needsOutput, () => l.selfBalance(tokenOut), () => {
+    const received = action.isBuy ? action.quote : action.base;
+    return balanceDelta(l, needsOutput, () => l.assetBalance(received), () => {
         const cmd = l.bind("cmd", encodeArgs([
             addr(action.base),
             addr(action.quote),
@@ -578,41 +628,18 @@ function ambientSwap(l, action, amountIn, needsOutput) {
         l.exec("ICrocSwapDex", addr(action.dex), "userCmd", ["1n", cmd]);
     }, amountIn);
 }
-function dodoSwap(l, action, amountIn, needsOutput) {
-    // The proxy pays msg.sender and returns the amount it paid. `version: "v1"` routes legacy
-    // Classical pairs through `dodoSwapV1`; allowances go to DODOApprove, not to the proxy.
-    const args = [
-        addr(action.fromToken),
-        addr(action.toToken),
+function dodoV1Swap(l, action, amountIn, needsOutput) {
+    // The proxy pays msg.sender and returns the amount it paid. Allowances go to DODOApprove, not to
+    // the proxy.
+    const call = l.call("IDodoProxy", addr(action.proxy), "dodoSwapV1", [
+        addr(action.tokenIn),
+        addr(action.tokenOut),
         amountIn,
         word(action.amountOutMin),
         list(action.pairs.map(addr)),
         word(action.directions),
         flag(false), // isIncentive
         word(action.deadline),
-    ];
-    const call = action.version === "v1"
-        ? l.call("IDodoProxy", addr(action.proxy), "dodoSwapV1", args)
-        : l.call("IDodoProxy", addr(action.proxy), "dodoSwapV2TokenToToken", args);
-    return captured(l, needsOutput, call, amountIn);
-}
-function maverickSwap(l, action, amountIn, needsOutput) {
-    const call = l.call("IMaverickV2Router", addr(action.router), "exactInputSingle", [
-        needsOutput ? SELF : recipient(action.recipient),
-        addr(action.pool),
-        flag(action.tokenAIn),
-        amountIn,
-        word(action.amountOutMin),
-    ]);
-    return captured(l, needsOutput, call, amountIn);
-}
-function maverickMultiHopSwap(l, action, amountIn, needsOutput) {
-    const path = l.bytes("path", hexToBytes(action.path));
-    const call = l.call("IMaverickV2Router", addr(action.router), "exactInputMultiHop", [
-        needsOutput ? SELF : recipient(action.recipient),
-        path,
-        amountIn,
-        word(action.amountOutMin),
     ]);
     return captured(l, needsOutput, call, amountIn);
 }