@eco-incorp/sauce 0.99.3 → 0.99.5

package/actions/dist/to-sauce.js

@@ -1,197 +1,332 @@
 /**
- * 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 { arrayLiteral, bindBytes, bindConst, calldata, concatCalldata, decodeUint256, encodeArgs, formatBigint, fn, hexToBytes, newEmitter, selector, slotVar, tupleLiteral as tuple, } from "./emit.js";
-import { compileEvm } from "./compile.js";
-import { encodeAbiParameters } from "viem";
+import { bindBytes, bindConst, encodeArgs, fn, hexToBytes, indent, newEmitter, slotVar, } from "./emit.js";
+import { contractsFor, methodSelector, } from "./abis.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 = BigInt("0x8000000000000000000000000000000000000000000000000000000000000000");
-/** V4 ActionConstants.OPEN_DELTA — signals "take all owed" in a TAKE action. */
-const V4_OPEN_DELTA = BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+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. */
+const AAVE_VARIABLE_RATE = 2n;
+/** CCTP V2's `minFinalityThreshold` for a standard (finalized) transfer. */
+const CCTP_FINALIZED = 2000;
 const ZERO = "0n";
 const SELF = "ctx.self()";
-const MSG_SENDER = "ctx.msgSender()";
-/** An address, pool id or any other 256-bit field, as the literal the emitted source carries. */
+/** An integer field, as the decimal literal the emitted source carries. */
 function word(value) {
-    return formatBigint(BigInt(value));
+    return `${BigInt(value).toString()}n`;
+}
+/** An address as a hex literal, so the emitted source reads like the addresses it was built from. */
+function addr(value) {
+    return `0x${BigInt(value).toString(16).padStart(40, "0")}n`;
+}
+/** A recipient field: an address, or the Pot for `"self"`. */
+function recipient(value) {
+    return value === "self" ? SELF : addr(value);
+}
+/** A bytes32 field (a pool id). */
+function b32(value) {
+    return `0x${BigInt(value).toString(16).padStart(64, "0")}n`;
+}
+/** A recipient on another chain, as the 32-byte word bridges take: an address is left-padded. */
+function remote(value) {
+    return b32(value);
 }
 function flag(value) {
-    return value ? "1n" : "0n";
+    return value ? "true" : "false";
+}
+/** An object literal. A binding orders its fields by the ABI; `abi.encode` takes them as written. */
+function record(fields) {
+    return `{ ${Object.entries(fields)
+        .map(([k, v]) => `${k}: ${v}`)
+        .join(", ")} }`;
+}
+function list(elements) {
+    return `[${elements.join(", ")}]`;
+}
+/** Collects one action's statements and the bindings they name. */
+class Lowering {
+    emit;
+    stmts = [];
+    used = new Set();
+    constructor(emit) {
+        this.emit = emit;
+    }
+    /** `IBinding.at(target).method(args)` — the expression, not yet a statement. */
+    call(binding, target, method, args) {
+        this.used.add(binding);
+        return `${binding}.at(${target}).${method}(${args.join(", ")})`;
+    }
+    /** A call whose value nothing reads. */
+    exec(binding, target, method, args) {
+        this.stmts.push(`${this.call(binding, target, method, args)};`);
+    }
+    /**
+     * An ERC-20 `approve(spender, amount)` or `transfer(to, amount)` through the SDK's `token/safe`,
+     * with OpenZeppelin `SafeERC20` semantics: the call is raw, so nothing is decoded on the way out,
+     * and then its returndata must be empty (from a contract) or decode as an ABI word equal to 1.
+     * `approve` first resets a non-zero allowance, which USDT requires. A token that refuses the
+     * write reverts the program.
+     */
+    erc20Write(fn, token, first, amount) {
+        const prefix = this.emit.name("e");
+        const statements = fn === "approve"
+            ? safeApproveStatements(prefix, token, this.wordArg(first), this.wordArg(amount))
+            : safeTransferStatements(prefix, token, this.wordArg(first), this.wordArg(amount));
+        this.stmts.push(...statements);
+    }
+    /** A word `token/safe` can splice: a literal, or a local (an expression is bound to one). */
+    wordArg(expr) {
+        const literal = /^(0x[0-9a-f]+|[0-9]+)n$/.exec(expr);
+        if (literal)
+            return { literal: BigInt(literal[1]) };
+        if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(expr))
+            return { local: expr };
+        return { local: this.bind("w", expr) };
+    }
+    /**
+     * A payable call carrying native `value`. Raw, because a binding call cannot attach value — the
+     * selector is still the binding's own fragment's, and the arguments are `abi.encode`d in one
+     * tuple (see `emit.ts#encodeArgs` for why the wrap is load-bearing).
+     */
+    valueCall(binding, target, value, method, args) {
+        const sel = this.bytes("sel", hexToBytes(methodSelector(binding, method)));
+        const data = args.length === 0 ? sel : `${sel}.concat(${encodeArgs(args)})`;
+        this.stmts.push(`evm.call(${target}, ${value}, ${data});`);
+    }
+    /** Bind `expr` to a fresh `const` and yield its name. */
+    bind(prefix, expr) {
+        const bound = bindConst(this.emit, prefix, expr);
+        this.stmts.push(...bound.stmts);
+        return bound.expr;
+    }
+    /** Bind a byte literal. A method call's receiver must be an identifier, so bytes are bound. */
+    bytes(prefix, value) {
+        const bound = bindBytes(this.emit, prefix, value);
+        this.stmts.push(...bound.stmts);
+        return bound.expr;
+    }
+    /** The Pot's balance of `token`, as a bound local. */
+    selfBalance(token) {
+        return this.bind("bal", this.call("IErc20", token, "balanceOf", [SELF]));
+    }
+    /** The Pot's native balance, as a bound local. */
+    nativeBalance() {
+        return this.bind("nat", "ctx.selfBalance()");
+    }
+    result(output) {
+        return { stmts: this.stmts, output, bindings: [...this.used] };
+    }
 }
-function evmCall(target, value, data) {
-    return `evm.call(${target}, ${value}, ${data})`;
+/** A call whose declared output is the action's output when `needsOutput`. */
+function captured(l, needsOutput, call, passThrough) {
+    if (!needsOutput) {
+        l.stmts.push(`${call};`);
+        return l.result(passThrough);
+    }
+    return l.result(l.bind("amt", call));
 }
-// ---------------------------------------------------------------------------
-// Amount resolution
-// ---------------------------------------------------------------------------
 /**
- * Resolve the amount for an action:
- * 1. Explicit amount string (highest priority)
- * 2. amountRef — the local a previous action saved its output to
- * 3. lastOutputSlot — implicit chain from the previous action
+ * Runs `run` between two readings of `measure` — the Pot's balance of the token it receives — and
+ * returns the DELTA as the output, for a venue whose return is not the amount received (an array,
+ * a signed pair, `bytes`, shares, or nothing). The call must deliver to the Pot for the delta to
+ * mean anything, which every caller arranges whenever `needsOutput` is set.
  */
-function resolveAmountIn(explicitAmount, amountRef, lastOutputSlot) {
-    if (explicitAmount !== undefined)
-        return word(explicitAmount);
-    if (amountRef !== undefined)
-        return slotVar(amountRef);
-    if (lastOutputSlot !== undefined)
-        return lastOutputSlot;
-    throw new Error("No amount specified: provide an explicit amount, amountRef, or chain from a previous action");
+function balanceDelta(l, needsOutput, measure, run, passThrough) {
+    if (!needsOutput) {
+        run();
+        return l.result(passThrough);
+    }
+    const pre = measure();
+    run();
+    const post = measure();
+    return l.result(l.bind("delta", `${post} - ${pre}`));
 }
-/** Extract the explicit amount field from any action type. */
-function getExplicitAmount(action) {
-    const a = action;
-    return a.amountIn ?? a.amount ?? a.stETHAmount ?? a.wstETHAmount ?? a.steps?.[0]?.amount;
+/** The local a runtime argument arrives in. Prefixed like `slotVar`, for the same reasons. */
+function argumentVar(name) {
+    return `a_${name}`;
 }
-// ---------------------------------------------------------------------------
-// Dispatcher
-// ---------------------------------------------------------------------------
-/** The SauceScript source for `actions`. Empty for an empty list. */
-export function actionsToSauceSource(actions) {
-    if (actions.length === 0)
-        return "";
+/** Lowers a validated action list into `main`'s body. */
+export function lowerActions(actions) {
     const emit = newEmitter();
     const body = [];
+    const bindings = new Set();
+    const parameters = [];
     const declared = new Set();
-    let lastOutputSlot;
-    for (let i = 0; i < actions.length; i++) {
-        const action = actions[i];
-        const amountIn = resolveAmountIn(getExplicitAmount(action), action.amountRef, lastOutputSlot);
-        const nextAction = actions[i + 1];
-        const needsStore = action.saveOutputAs !== undefined ||
-            (nextAction !== undefined &&
-                getExplicitAmount(nextAction) === undefined &&
-                nextAction.amountRef === undefined);
-        const result = buildAction(emit, action, amountIn, needsStore);
+    let previous;
+    actions.forEach((action, i) => {
+        if (action.type === "argument")
+            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);
         body.push(...result.stmts);
-        if (needsStore) {
+        for (const b of result.bindings)
+            bindings.add(b);
+        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};`);
             declared.add(slot);
-            lastOutputSlot = slot;
+            previous = slot;
         }
-    }
-    return `${fn("main", [], "void", body)}\n`;
+    });
+    return { body, contracts: contractsFor(bindings), parameters };
+}
+/** The amount an action spends: its `amount`, the output it references, or the previous output. */
+function amountOf(action, previous) {
+    if (!ACTION_SPECS[action.type].spends)
+        return ZERO;
+    const { amount, amountRef } = action;
+    if (amount !== undefined)
+        return word(amount);
+    if (amountRef !== undefined)
+        return slotVar(amountRef);
+    if (previous !== undefined)
+        return previous;
+    throw new Error(`${action.type} has no amount — the program was not validated`);
 }
-export function actionsToSauce(actions) {
-    const source = actionsToSauceSource(actions);
-    return source === "" ? new Uint8Array() : compileEvm(source);
+/** `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`;
 }
-export function actionToSauce(action) {
-    return actionsToSauce([action]);
+/**
+ * `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 function renderRouteBody(lowered) {
+    if (lowered.parameters.length > 0) {
+        throw new Error(`an intent route takes no runtime arguments, but this program declares ` +
+            `${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`;
 }
 /**
- * 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.
+ * 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 buildAction(emit, action, amountIn, needsOutput) {
+export function lowerAction(emit, action, amount, needsOutput) {
+    const l = new Lowering(emit);
     switch (action.type) {
         case "uniswapV3ExactInput":
-            return uniswapV3ExactInput(emit, action, amountIn, needsOutput);
+            return uniswapV3ExactInput(l, action, amount, needsOutput);
         case "uniswapV3ExactInputMultiHop":
-            return uniswapV3ExactInputMultiHop(emit, action, amountIn, needsOutput);
+            return uniswapV3ExactInputMultiHop(l, action, amount, needsOutput);
         case "uniswapV4ExactInput":
-            return uniswapV4ExactInput(emit, action, amountIn, needsOutput);
+            return uniswapV4ExactInput(l, action, amount, needsOutput);
         case "uniswapV4ExactInputMultiHop":
-            return uniswapV4ExactInputMultiHop(emit, action, amountIn, needsOutput);
+            return uniswapV4ExactInputMultiHop(l, action, amount, needsOutput);
         case "curveSwap":
-            return curveSwap(emit, action, amountIn, needsOutput);
+            return curveSwap(l, action, amount, needsOutput);
+        case "curveRouterNGSwap":
+            return curveRouterNGSwap(l, action, amount, needsOutput);
         case "balancerV2Swap":
-            return balancerV2Swap(emit, action, amountIn, needsOutput);
+            return balancerV2Swap(l, action, amount, needsOutput);
         case "balancerV2BatchSwap":
-            return balancerV2BatchSwap(emit, action, amountIn, needsOutput);
+            return balancerV2BatchSwap(l, action, amount, needsOutput);
         case "balancerV3Swap":
-            return balancerV3Swap(emit, action, amountIn, needsOutput);
+            return balancerV3Swap(l, action, amount, needsOutput);
         case "uniswapV2Swap":
-            return uniswapV2Swap(emit, action, amountIn, needsOutput);
-        case "curveRouterNGSwap":
-            return curveRouterNGSwap(emit, action, amountIn, needsOutput);
+            return uniswapV2Swap(l, action, amount, needsOutput);
         case "ambientSwap":
-            return ambientSwap(emit, action, amountIn, needsOutput);
+            return ambientSwap(l, action, amount, needsOutput);
         case "dodoSwap":
-            return dodoSwap(emit, action, amountIn, needsOutput);
+            return dodoSwap(l, action, amount, needsOutput);
         case "maverickSwap":
-            return maverickSwap(emit, action, amountIn, needsOutput);
+            return maverickSwap(l, action, amount, needsOutput);
         case "maverickMultiHopSwap":
-            return maverickMultiHopSwap(emit, action, amountIn, needsOutput);
+            return maverickMultiHopSwap(l, action, amount, needsOutput);
         case "carbonSwap":
-            return carbonSwap(emit, action, amountIn, needsOutput);
+            return carbonSwap(l, action, amount, needsOutput);
         case "fraxswapSwap":
-            return fraxswapSwap(emit, action, amountIn, needsOutput);
-        case "clipperSwap":
-            return clipperSwap(emit, action, amountIn, needsOutput);
-        case "integralSwap":
-            return integralSwap(emit, action, amountIn, needsOutput);
+            return fraxswapSwap(l, action, amount, needsOutput);
         case "fluidDexT1Swap":
-            return fluidDexT1Swap(emit, action, amountIn, needsOutput);
-        case "fluidDexLiteSwap":
-            return fluidDexLiteSwap(emit, action, amountIn, needsOutput);
-        case "transfer":
-            return transfer(emit, action, amountIn);
-        case "approve":
-            return approve(emit, action, amountIn);
+            return fluidDexT1Swap(l, action, amount, needsOutput);
+        case "acrossBridge":
+            return acrossBridge(l, action, amount);
+        case "stargateBridge":
+            return stargateBridge(l, action, amount);
+        case "cctpBridge":
+            return cctpBridge(l, action, amount);
+        case "hyperlaneBridge":
+            return hyperlaneBridge(l, action, amount);
         case "wrapETH":
-            return wrapETH(emit, action, amountIn);
+            return wrapETH(l, action, amount);
         case "unwrapETH":
-            return unwrapETH(emit, action, amountIn);
+            return unwrapETH(l, action, amount);
         case "wrapStETH":
-            return wrapStETH(emit, action, amountIn);
+            return wrapStETH(l, action, amount, needsOutput);
         case "unwrapStETH":
-            return unwrapStETH(emit, action, amountIn);
+            return unwrapStETH(l, action, amount, needsOutput);
         case "lidoStake":
-            return lidoStake(emit, action, amountIn);
+            return lidoStake(l, action, amount, needsOutput);
         case "lidoUnstake":
-            return lidoUnstake(emit, action, amountIn);
+            return lidoUnstake(l, action, amount);
         case "rocketPoolStake":
-            return rocketPoolStake(emit, action, amountIn);
+            return rocketPoolStake(l, action, amount, needsOutput);
         case "rocketPoolUnstake":
-            return rocketPoolUnstake(emit, action, amountIn);
-        case "coinbaseStake":
-            return coinbaseStake(emit, action, amountIn);
+            return rocketPoolUnstake(l, action, amount, needsOutput);
         case "etherFiStake":
-            return etherFiStake(emit, action, amountIn);
+            return etherFiStake(l, action, amount, needsOutput);
         case "aaveV3Supply":
-            return aaveV3Supply(emit, action, amountIn);
+            return aaveV3Supply(l, action, amount);
         case "aaveV3Withdraw":
-            return aaveV3Withdraw(emit, action, amountIn, needsOutput);
+            return aaveV3Withdraw(l, action, amount, needsOutput);
         case "aaveV3Borrow":
-            return aaveV3Borrow(emit, action, amountIn);
+            return aaveV3Borrow(l, action, amount);
         case "aaveV3Repay":
-            return aaveV3Repay(emit, action, amountIn);
+            return aaveV3Repay(l, action, amount);
         case "compoundV3Supply":
-            return compoundV3Supply(emit, action, amountIn);
+            return compoundV3Supply(l, action, amount);
         case "compoundV3Withdraw":
-            return compoundV3Withdraw(emit, action, amountIn);
-        case "acrossBridge":
-            return acrossBridge(emit, action, amountIn);
-        case "stargateBridge":
-            return stargateBridge(emit, action, amountIn);
-        case "cctpBridge":
-            return cctpBridge(emit, action, amountIn);
-        case "hyperlaneBridge":
-            return hyperlaneBridge(emit, action, amountIn);
+            return compoundV3Withdraw(l, action, amount);
+        case "transfer":
+            return transfer(l, action, amount);
+        case "approve":
+            return approve(l, action, amount);
+        case "permit2Approve":
+            return permit2Approve(l, action, amount);
+        case "balanceOf":
+            return balanceOf(l, action);
+        case "nativeBalance":
+            return l.result(l.nativeBalance());
+        case "argument":
+            return argument(l, action);
         default: {
             const _ = action;
             throw new Error(`Unknown action type: ${_.type}`);
@@ -199,713 +334,516 @@ export function buildAction(emit, action, amountIn, needsOutput) {
     }
 }
 // ---------------------------------------------------------------------------
-// Call shapes
+// Swap actions
 // ---------------------------------------------------------------------------
-/** A call whose `uint256` return value is the action's output when `needsOutput`. */
-function capturedCall(emit, needsOutput, target, value, cd, passThrough) {
-    const call = evmCall(target, value, cd.expr);
-    if (!needsOutput)
-        return { stmts: [...cd.stmts, `${call};`], output: passThrough };
-    const decoded = decodeUint256(emit, call);
-    const bound = bindConst(emit, "amt", decoded.expr);
-    return { stmts: [...cd.stmts, ...decoded.stmts, ...bound.stmts], output: bound.expr };
-}
-/** A call with no usable return value — the input amount passes through. */
-function voidCall(target, value, cd, passThrough) {
-    return { stmts: [...cd.stmts, `${evmCall(target, value, cd.expr)};`], output: passThrough };
+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),
+        amountIn,
+        amountOutMinimum: word(action.amountOutMin),
+        sqrtPriceLimitX96: word(action.sqrtPriceLimitX96 ?? "0"),
+    });
+    const call = l.call("ISwapRouter02", addr(action.router), "exactInputSingle", [params]);
+    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),
+        amountIn,
+        amountOutMinimum: word(action.amountOutMin),
+    });
+    const call = l.call("ISwapRouter02", addr(action.router), "exactInput", [params]);
+    return captured(l, needsOutput, call, amountIn);
 }
 /**
- * Runs `stmts` between a pre/post `balanceOf(ctx.self())` snapshot of `token` and returns the
- * DELTA as the output.
+ * 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 shape for any venue whose call has no usable `uint256` return — an array, a struct, an order
- * id, or `bytes`. `capturedCall` decodes the first 32 bytes of the return, which for those is an
- * ABI offset or an unrelated value, not an amount. Seven builders got that wrong; this is the one
- * correct pattern, written once.
- *
- * The caller must have routed the output to `ctx.self()` for the delta to mean anything.
+ * 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 balanceDeltaResult(emit, needsOutput, token, stmts, passThrough) {
-    if (!needsOutput)
-        return { stmts: [...stmts], output: passThrough };
-    const pre = selfBalance(emit, token);
-    const post = selfBalance(emit, token);
-    const delta = bindConst(emit, "delta", `${post.expr} - ${pre.expr}`);
-    return {
-        stmts: [...pre.stmts, ...stmts, ...post.stmts, ...delta.stmts],
-        output: delta.expr,
-    };
-}
-/** `balanceOf(ctx.self())` on `token`, as a bound `uint256` local. */
-function selfBalance(emit, token) {
-    const cd = calldata(emit, "balanceOf(address)", [SELF]);
-    const decoded = decodeUint256(emit, evmCall(token, ZERO, cd.expr));
-    const bound = bindConst(emit, "bal", decoded.expr);
-    return { stmts: [...cd.stmts, ...decoded.stmts, ...bound.stmts], expr: bound.expr };
-}
-// ---------------------------------------------------------------------------
-// Swap actions — capture uint256 output
-// ---------------------------------------------------------------------------
-function uniswapV3ExactInput(emit, action, amountIn, needsOutput) {
-    const recipient = needsOutput ? SELF : word(action.recipient);
-    const params = [
-        word(action.tokenIn),
-        word(action.tokenOut),
-        word(action.fee),
-        recipient,
-        amountIn,
-        word(action.amountOutMin ?? "0"),
-        word(action.sqrtPriceLimitX96 ?? "0"),
-    ];
-    const cd = calldata(emit, "exactInputSingle((address,address,uint24,address,uint256,uint256,uint160))", [tuple(params)]);
-    return capturedCall(emit, needsOutput, word(action.router), ZERO, cd, amountIn);
-}
-function uniswapV3ExactInputMultiHop(emit, action, amountIn, needsOutput) {
-    const recipient = needsOutput ? SELF : word(action.recipient);
-    const path = bindBytes(emit, "path", hexToBytes(action.path));
-    const cd = calldata(emit, "exactInput((bytes,address,uint256,uint256))", [
-        tuple([path.expr, recipient, amountIn, word(action.amountOutMin)]),
-    ]);
-    return capturedCall(emit, needsOutput, word(action.router), ZERO, { stmts: [...path.stmts, ...cd.stmts], expr: cd.expr }, amountIn);
-}
-function uniswapV4ExactInput(emit, action, amountIn, needsOutput) {
-    const currencyIn = action.zeroForOne ? action.poolKey.currency0 : action.poolKey.currency1;
-    const currencyOut = action.zeroForOne ? action.poolKey.currency1 : action.poolKey.currency0;
-    // Transfer input token to the router so it can settle without Permit2
-    const transferCd = calldata(emit, "transfer(address,uint256)", [word(action.router), amountIn]);
-    // ExactInputSingleParams: { PoolKey poolKey, bool zeroForOne, uint128 amountIn, uint128 amountOutMinimum, bytes hookData }
-    const poolKeyAbi = {
-        type: "tuple",
-        components: [
-            { type: "address", name: "currency0" },
-            { type: "address", name: "currency1" },
-            { type: "uint24", name: "fee" },
-            { type: "int24", name: "tickSpacing" },
-            { type: "address", name: "hooks" },
-        ],
-    };
-    const swapParams = encodeAbiParameters([poolKeyAbi, { type: "bool" }, { type: "uint128" }, { type: "uint128" }, { type: "bytes" }], [
-        {
-            currency0: action.poolKey.currency0,
-            currency1: action.poolKey.currency1,
-            fee: action.poolKey.fee,
-            tickSpacing: action.poolKey.tickSpacing,
-            hooks: action.poolKey.hooks,
-        },
-        action.zeroForOne,
-        BigInt(action.amountIn ?? "0"),
-        BigInt(action.amountOutMin),
-        "0x",
-    ]);
-    // SETTLE (0x0b) with payerIsUser=false + CONTRACT_BALANCE (0) — router uses its own balance
-    const settleParams = encodeAbiParameters([{ type: "address" }, { type: "uint256" }, { type: "bool" }], [currencyIn, V4_CONTRACT_BALANCE, false]);
-    // TAKE (0x0e) — sends output to specified recipient, OPEN_DELTA = take all owed
-    const takeParams = encodeAbiParameters([{ type: "address" }, { type: "address" }, { type: "uint256" }], [currencyOut, action.recipient, V4_OPEN_DELTA]);
-    const executeCalldata = v4ExecuteCalldata("0x060b0e", [swapParams, settleParams, takeParams]);
-    const sel = bindBytes(emit, "sel", selector("execute(bytes,bytes[])"));
-    const blob = bindBytes(emit, "v4", hexToBytes(executeCalldata));
-    const swap = [
-        ...transferCd.stmts,
-        `${evmCall(word(currencyIn), ZERO, transferCd.expr)};`,
-        ...sel.stmts,
-        ...blob.stmts,
-        `${evmCall(word(action.router), ZERO, concatCalldata(sel.expr, [blob.expr]))};`,
-    ];
-    // V4's take recipient is baked into a STATICALLY encoded blob, so unlike every other builder this
-    // one cannot redirect the output to ctx.self() when capturing. The delta is therefore measured on
-    // the recipient the caller named — which is the true realized output either way, and is only
-    // chainable when that recipient is the executing contract.
-    return balanceDeltaResult(emit, needsOutput, word(currencyOut), swap, amountIn);
-}
-function uniswapV4ExactInputMultiHop(emit, action, amountIn, needsOutput) {
+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 transferCd = calldata(emit, "transfer(address,uint256)", [word(action.router), amountIn]);
-    // ExactInputParams: { Currency currencyIn, PathKey[] path, uint256[] maxHopSlippage, uint128 amountIn, uint128 amountOutMinimum }
-    const pathKeyAbi = {
-        type: "tuple[]",
-        components: [
-            { type: "address", name: "intermediateCurrency" },
-            { type: "uint24", name: "fee" },
-            { type: "int24", name: "tickSpacing" },
-            { type: "address", name: "hooks" },
-            { type: "bytes", name: "hookData" },
-        ],
-    };
-    const swapParams = encodeAbiParameters([
-        { type: "address" },
-        pathKeyAbi,
-        { type: "uint256[]" },
-        { type: "uint128" },
-        { type: "uint128" },
-    ], [
-        action.currencyIn,
-        action.path.map((step) => ({
-            intermediateCurrency: step.intermediateCurrency,
-            fee: step.fee,
-            tickSpacing: step.tickSpacing,
-            hooks: step.hooks,
-            hookData: "0x",
-        })),
-        [], // maxHopSlippage — empty array means no per-hop slippage limits
-        BigInt(action.amountIn ?? "0"),
-        BigInt(action.amountOutMin),
-    ]);
-    const settleParams = encodeAbiParameters([{ type: "address" }, { type: "uint256" }, { type: "bool" }], [action.currencyIn, V4_CONTRACT_BALANCE, false]);
-    const takeParams = encodeAbiParameters([{ type: "address" }, { type: "address" }, { type: "uint256" }], [currencyOut, action.recipient, V4_OPEN_DELTA]);
-    const executeCalldata = v4ExecuteCalldata("0x070b0e", [swapParams, settleParams, takeParams]);
-    const sel = bindBytes(emit, "sel", selector("execute(bytes,bytes[])"));
-    const blob = bindBytes(emit, "v4", hexToBytes(executeCalldata));
-    const swap = [
-        ...transferCd.stmts,
-        `${evmCall(word(action.currencyIn), ZERO, transferCd.expr)};`,
-        ...sel.stmts,
-        ...blob.stmts,
-        `${evmCall(word(action.router), ZERO, concatCalldata(sel.expr, [blob.expr]))};`,
-    ];
-    // V4's take recipient is baked into a STATICALLY encoded blob, so unlike every other builder this
-    // one cannot redirect the output to ctx.self() when capturing. The delta is therefore measured on
-    // the recipient the caller named — which is the true realized output either way, and is only
-    // chainable when that recipient is the executing contract.
-    return balanceDeltaResult(emit, needsOutput, word(currencyOut), swap, amountIn);
-}
-/** `abi.encode(bytes("0x10"), [abi.encode(actions, params)])` — the V4 router's two-level input. */
-function v4ExecuteCalldata(actions, params) {
-    const v4Input = encodeAbiParameters([{ type: "bytes" }, { type: "bytes[]" }], [actions, params]);
-    return encodeAbiParameters([{ type: "bytes" }, { type: "bytes[]" }], ["0x10", [v4Input]]);
-}
-function curveSwap(emit, action, amountIn, needsOutput) {
-    // Older Curve pools (e.g. 3pool at 0xbEbc44...) expose only the 4-arg `exchange` which returns
-    // VOID and sends the output to msg.sender. We snapshot the pre-swap `tokenOut` balance, call the
-    // 4-arg exchange (Sauce is msg.sender — output lands here), then compute `post - pre` to recover
-    // this swap's output without sweeping any pre-existing dust from earlier actions.
-    const tokenOut = word(action.tokenOut);
-    const pre = selfBalance(emit, tokenOut);
-    const exchangeCd = calldata(emit, "exchange(int128,int128,uint256,uint256)", [
+    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 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", [
         word(action.i),
         word(action.j),
         amountIn,
         word(action.amountOutMin),
     ]);
-    const post = selfBalance(emit, tokenOut);
-    const delta = bindConst(emit, "delta", `${post.expr} - ${pre.expr}`);
-    const captureAndSwap = [
-        ...pre.stmts,
-        ...exchangeCd.stmts,
-        `${evmCall(word(action.pool), ZERO, exchangeCd.expr)};`,
-        ...post.stmts,
-        ...delta.stmts,
-    ];
-    if (needsOutput)
-        return { stmts: captureAndSwap, output: delta.expr };
-    // Non-chained: forward the delta to the recipient.
-    const transferCd = calldata(emit, "transfer(address,uint256)", [
-        word(action.recipient),
-        delta.expr,
-    ]);
-    return {
-        stmts: [...captureAndSwap, ...transferCd.stmts, `${evmCall(tokenOut, ZERO, transferCd.expr)};`],
-        output: delta.expr,
-    };
-}
-function balancerV2Swap(emit, action, amountIn, needsOutput) {
-    const recipient = needsOutput ? SELF : word(action.recipient);
-    const userData = bindBytes(emit, "ud", new Uint8Array(0));
-    const singleSwap = tuple([
-        word(action.poolId), // bytes32 — must be static, not dynamic bytes
-        ZERO, // kind = GIVEN_IN
-        word(action.tokenIn),
-        word(action.tokenOut),
-        amountIn,
-        userData.expr,
-    ]);
-    const funds = tuple([
-        SELF, // sender — must equal msg.sender (Sauce) for vault auth
-        ZERO,
-        recipient, // recipient — Sauce when chaining, caller otherwise
-        ZERO,
-    ]);
-    const cd = calldata(emit, "swap((bytes32,uint8,address,address,uint256,bytes),(address,bool,address,bool),uint256,uint256)", [singleSwap, funds, word(action.amountOutMin), word(action.deadline)]);
-    return capturedCall(emit, needsOutput, word(action.vault), ZERO, { stmts: [...userData.stmts, ...cd.stmts], expr: cd.expr }, amountIn);
-}
-function balancerV2BatchSwap(emit, action, amountIn, needsOutput) {
-    // `getExplicitAmount` reads `steps[0].amount`, which a batch swap always has, so `amountRef`
-    // could never win the `resolveAmountIn` precedence — it was accepted and silently ignored. The
-    // step amounts are baked into the pre-encoded blob below, so a runtime amount genuinely cannot
-    // reach this venue: say so rather than encode a different trade than the caller asked for.
-    if (action.amountRef !== undefined) {
-        throw new Error("balancerV2BatchSwap: `amountRef` cannot be applied — the per-step amounts are ABI-encoded " +
-            "into the batchSwap calldata at build time, so a chained runtime amount has nowhere to go. " +
-            "Set `steps[].amount` explicitly.");
+    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);
     }
-    const recipientExpr = needsOutput ? SELF : word(action.recipient);
-    // Pre-encode the complex calldata with viem, then splice in the runtime values for funds.sender
-    // (ctx.self()) and funds.recipient.
-    const MAX_INT256 = BigInt("57896044618658097711785492504343953926634992332820282019728792003956564819967");
-    const stepsData = action.steps.map((step) => ({
-        poolId: step.poolId,
-        assetInIndex: BigInt(step.assetInIndex),
-        assetOutIndex: BigInt(step.assetOutIndex),
-        amount: BigInt(step.amount),
-        userData: "0x",
-    }));
-    const assetsData = action.assets.map((a) => a);
-    const limitsData = action.assets.map((_, i) => i === action.assets.length - 1 ? -BigInt(action.amountOutMin) : MAX_INT256);
-    // Placeholder addresses stand in for the two runtime values.
-    const SENDER_PLACEHOLDER = "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
-    const RECIPIENT_PLACEHOLDER = "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
-    const encoded = encodeAbiParameters([
-        { type: "uint8" },
-        {
-            type: "tuple[]",
-            components: [
-                { type: "bytes32", name: "poolId" },
-                { type: "uint256", name: "assetInIndex" },
-                { type: "uint256", name: "assetOutIndex" },
-                { type: "uint256", name: "amount" },
-                { type: "bytes", name: "userData" },
-            ],
-        },
-        { type: "address[]" },
-        {
-            type: "tuple",
-            components: [
-                { type: "address", name: "sender" },
-                { type: "bool", name: "fromInternalBalance" },
-                { type: "address", name: "recipient" },
-                { type: "bool", name: "toInternalBalance" },
-            ],
-        },
-        { type: "int256[]" },
-        { type: "uint256" },
-    ], [
-        0,
-        stepsData,
-        assetsData,
-        {
-            sender: SENDER_PLACEHOLDER,
-            fromInternalBalance: false,
-            recipient: RECIPIENT_PLACEHOLDER,
-            toInternalBalance: false,
-        },
-        limitsData,
-        BigInt(action.deadline),
+    return l.result(delta);
+}
+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,
+        word(action.amountOutMin),
+        word(action.deadline),
     ]);
-    const encodedBytes = hexToBytes(encoded);
-    const senderPad = hexToBytes("0x000000000000000000000000aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
-    const recipientPad = hexToBytes("0x000000000000000000000000bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
-    let senderOffset = -1;
-    let recipientOffset = -1;
-    for (let i = 0; i <= encodedBytes.length - 32; i++) {
-        if (senderOffset === -1 && encodedBytes.slice(i, i + 32).every((b, j) => b === senderPad[j])) {
-            senderOffset = i;
-        }
-        if (recipientOffset === -1 &&
-            encodedBytes.slice(i, i + 32).every((b, j) => b === recipientPad[j])) {
-            recipientOffset = i;
-        }
-    }
-    const sel = bindBytes(emit, "sel", selector("batchSwap(uint8,(bytes32,uint256,uint256,uint256,bytes)[],address[],(address,bool,address,bool),int256[],uint256)"));
-    // Build: selector + pre_sender + ctx.self() + between + recipient + post_recipient. Each pre-
-    // encoded run is a bound `hex` const, because a method call's receiver must be an identifier.
-    const stmts = [...sel.stmts];
-    const parts = [];
-    const chunk = (from, to) => {
-        const bound = bindBytes(emit, "bs", encodedBytes.slice(from, to));
-        stmts.push(...bound.stmts);
-        parts.push(bound.expr);
-    };
-    if (senderOffset < recipientOffset) {
-        chunk(0, senderOffset);
-        parts.push(encodeArgs([SELF]));
-        chunk(senderOffset + 32, recipientOffset);
-        parts.push(encodeArgs([recipientExpr]));
-        chunk(recipientOffset + 32, encodedBytes.length);
-    }
-    else {
-        chunk(0, recipientOffset);
-        parts.push(encodeArgs([recipientExpr]));
-        chunk(recipientOffset + 32, senderOffset);
-        parts.push(encodeArgs([SELF]));
-        chunk(senderOffset + 32, encodedBytes.length);
-    }
-    stmts.push(`${evmCall(word(action.vault), ZERO, concatCalldata(sel.expr, parts))};`);
-    // `batchSwap` returns `int256[] assetDeltas` — an array, so there is no uint256 to decode, and
-    // the entry that matters is signed and negative for the asset received. `recipientExpr` is
-    // already ctx.self() whenever we are capturing, so the self delta on the last step's output asset
-    // is the realized amount without any sign handling.
+    return captured(l, needsOutput, call, amountIn);
+}
+function balancerV2BatchSwap(l, action, amountIn, needsOutput) {
+    const userData = l.bytes("ud", new Uint8Array());
+    const steps = list(action.steps.map((step) => record({
+        poolId: b32(step.poolId),
+        assetInIndex: word(step.assetInIndex),
+        assetOutIndex: word(step.assetOutIndex),
+        amount: word(step.amount),
+        userData,
+    })));
+    // The Vault may take any amount of every asset but the last, and must pay at least
+    // `amountOutMin` of the last (a negative limit is an amount the Vault pays out).
+    const limits = list(action.assets.map((_, i) => i === action.assets.length - 1 ? `-${word(action.amountOutMin)}` : word(MAX_INT256)));
+    const funds = record({
+        sender: SELF,
+        fromInternalBalance: flag(false),
+        recipient: needsOutput ? SELF : recipient(action.recipient),
+        toInternalBalance: flag(false),
+    });
+    // `batchSwap` returns `int256[] assetDeltas`, signed and negative for what was received; the
+    // 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 balanceDeltaResult(emit, needsOutput, word(assetOut), stmts, amountIn);
+    return balanceDelta(l, needsOutput, () => l.selfBalance(addr(assetOut)), () => l.exec("IBalancerV2Vault", addr(action.vault), "batchSwap", [
+        ZERO, // GIVEN_IN
+        steps,
+        list(action.assets.map(addr)),
+        funds,
+        limits,
+        word(action.deadline),
+    ]), amountIn);
 }
-// ---------------------------------------------------------------------------
-// New AMM swap actions
-// ---------------------------------------------------------------------------
-function uniswapV2Swap(emit, action, amountIn, needsOutput) {
-    const recipient = needsOutput ? SELF : word(action.recipient);
-    const cd = calldata(emit, "swapExactTokensForTokens(uint256,uint256,address[],address,uint256)", [
+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),
-        arrayLiteral(action.path.map(word)),
-        recipient,
+        list(action.path.map(addr)),
+        needsOutput ? SELF : recipient(action.recipient),
         word(action.deadline),
-    ]);
-    const swap = [...cd.stmts, `${evmCall(word(action.router), ZERO, cd.expr)};`];
-    if (!needsOutput)
-        return { stmts: swap, output: amountIn };
-    // swapExactTokensForTokens returns `uint256[] memory amounts` — decoding the first 32 bytes as a
-    // uint256 yields the ABI offset (0x20), not the output amount. Snapshot the tokenOut balance
-    // pre/post instead.
-    const tokenOut = word(action.path[action.path.length - 1]);
-    const pre = selfBalance(emit, tokenOut);
-    const post = selfBalance(emit, tokenOut);
-    const delta = bindConst(emit, "delta", `${post.expr} - ${pre.expr}`);
-    return {
-        stmts: [...pre.stmts, ...swap, ...post.stmts, ...delta.stmts],
-        output: delta.expr,
-    };
-}
-function curveRouterNGSwap(emit, action, amountIn, needsOutput) {
-    const recipient = needsOutput ? SELF : word(action.recipient);
-    // Pad route to 11 entries
+    ]), amountIn);
+}
+function curveRouterNGSwap(l, action, amountIn, needsOutput) {
+    const zero = "0x0000000000000000000000000000000000000000";
     const route = [...action.route];
     while (route.length < 11)
-        route.push("0x0000000000000000000000000000000000000000");
-    // Pad swapParams to 5x5
-    const swapParams = [...action.swapParams];
+        route.push(zero);
+    const swapParams = action.swapParams.map((row) => [...row]);
     while (swapParams.length < 5)
         swapParams.push([0, 0, 0, 0, 0]);
-    // Pad pools to 5
     const pools = [...action.pools];
     while (pools.length < 5)
-        pools.push("0x0000000000000000000000000000000000000000");
-    const cd = calldata(emit, "exchange(address[11],uint256[5][5],uint256,uint256,address[5],address)", [
-        tuple(route.map(word)),
-        tuple(swapParams.map((row) => tuple(row.map(word)))),
+        pools.push(zero);
+    const call = l.call("ICurveRouterNG", addr(action.router), "exchange", [
+        list(route.map(addr)),
+        list(swapParams.map((row) => list(row.map(word)))),
         amountIn,
         word(action.amountOutMin),
-        tuple(pools.map(word)),
-        recipient,
+        list(pools.map(addr)),
+        needsOutput ? SELF : recipient(action.recipient),
     ]);
-    return capturedCall(emit, needsOutput, word(action.router), ZERO, cd, amountIn);
-}
-function balancerV3Swap(emit, action, amountIn, needsOutput) {
-    // BalancerV3 Router sends output to msg.sender; no recipient parameter in the function
-    const userData = bindBytes(emit, "ud", new Uint8Array(0));
-    const cd = calldata(emit, "swapSingleTokenExactIn(address,address,address,uint256,uint256,uint256,bool,bytes)", [
-        word(action.pool),
-        word(action.tokenIn),
-        word(action.tokenOut),
+    return captured(l, needsOutput, call, amountIn);
+}
+function balancerV3Swap(l, action, amountIn, needsOutput) {
+    // The V3 Router pays msg.sender — the executing account — and takes no recipient.
+    const userData = l.bytes("ud", new Uint8Array());
+    const call = l.call("IBalancerV3Router", addr(action.router), "swapSingleTokenExactIn", [
+        addr(action.pool),
+        addr(action.tokenIn),
+        addr(action.tokenOut),
         amountIn,
         word(action.amountOutMin),
         word(action.deadline),
         flag(action.wethIsEth),
-        userData.expr,
+        userData,
     ]);
-    return capturedCall(emit, needsOutput, word(action.router), ZERO, { stmts: [...userData.stmts, ...cd.stmts], expr: cd.expr }, amountIn);
-}
-function ambientSwap(emit, action, amountIn, needsOutput) {
-    // abi.encode(base, quote, poolIdx, isBuy, inBaseQty, qty, tip, limitPrice, minOut, settleFlags)
-    const cmd = bindConst(emit, "cmd", encodeArgs([
-        word(action.base),
-        word(action.quote),
-        word(action.poolIdx),
-        flag(action.isBuy),
-        flag(action.inBaseQty),
-        amountIn,
-        word(action.tip),
-        word(action.limitPrice),
-        word(action.minOut),
-        word(action.reserveFlags),
-    ]));
-    const cd = calldata(emit, "userCmd(uint16,bytes)", ["1n", cmd.expr]);
-    // `userCmd` returns `bytes`, so there is no uint256 to decode. Ambient settles to msg.sender —
-    // ctx.self() here — so the self delta on the received side IS the output. `isBuy` is "paying
-    // base, receiving quote" (AMM_SWAP_INTERFACES.md), so the received token is the quote when
-    // buying and the base otherwise.
-    const swap = [...cmd.stmts, ...cd.stmts, `${evmCall(word(action.dex), ZERO, cd.expr)};`];
-    const tokenOut = word(action.isBuy ? action.quote : action.base);
-    return balanceDeltaResult(emit, needsOutput, tokenOut, swap, amountIn);
-}
-function dodoSwap(emit, action, amountIn, needsOutput) {
-    // The DODO proxy sends output to msg.sender; we return the proxy's own return value.
-    const sig = action.version === "v1"
-        ? "dodoSwapV1(address,address,uint256,uint256,address[],uint256,bool,uint256)"
-        : "dodoSwapV2TokenToToken(address,address,uint256,uint256,address[],uint256,bool,uint256)";
-    const cd = calldata(emit, sig, [
-        word(action.fromToken),
-        word(action.toToken),
+    return captured(l, needsOutput, call, amountIn);
+}
+function ambientSwap(l, action, amountIn, needsOutput) {
+    // `userCmd(1, cmd)` is the swap callpath: cmd = abi.encode(base, quote, poolIdx, isBuy,
+    // 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 cmd = l.bind("cmd", encodeArgs([
+            addr(action.base),
+            addr(action.quote),
+            word(action.poolIdx),
+            flag(action.isBuy),
+            flag(action.inBaseQty),
+            amountIn,
+            word(action.tip),
+            word(action.limitPrice),
+            word(action.amountOutMin),
+            word(action.reserveFlags),
+        ]));
+        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),
         amountIn,
         word(action.amountOutMin),
-        arrayLiteral(action.dodoPairs.map(word)),
+        list(action.pairs.map(addr)),
         word(action.directions),
-        ZERO, // isIncentive = false
+        flag(false), // isIncentive
         word(action.deadline),
-    ]);
-    return capturedCall(emit, needsOutput, word(action.proxy), ZERO, cd, amountIn);
-}
-function maverickSwap(emit, action, amountIn, needsOutput) {
-    const recipient = needsOutput ? SELF : word(action.recipient);
-    const cd = calldata(emit, "exactInputSingle(address,address,bool,uint256,uint256)", [
-        recipient,
-        word(action.pool),
+    ];
+    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 capturedCall(emit, needsOutput, word(action.router), ZERO, cd, amountIn);
-}
-function maverickMultiHopSwap(emit, action, amountIn, needsOutput) {
-    const recipient = needsOutput ? SELF : word(action.recipient);
-    const path = bindBytes(emit, "path", hexToBytes(action.path));
-    const cd = calldata(emit, "exactInputMultiHop(address,bytes,uint256,uint256)", [
-        recipient,
-        path.expr,
+    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 capturedCall(emit, needsOutput, word(action.router), ZERO, { stmts: [...path.stmts, ...cd.stmts], expr: cd.expr }, amountIn);
-}
-function carbonSwap(emit, action, amountIn, needsOutput) {
-    // Carbon doesn't support a recipient override.
-    const tradeActions = action.tradeActions.map((ta) => tuple([word(ta.strategyId), word(ta.amount)]));
-    const cd = calldata(emit, "tradeBySourceAmount(address,address,(uint256,uint128)[],uint256,uint128)", [
-        word(action.sourceToken),
-        word(action.targetToken),
-        arrayLiteral(tradeActions),
+    return captured(l, needsOutput, call, amountIn);
+}
+function carbonSwap(l, action, amountIn, needsOutput) {
+    // Carbon pays msg.sender, and its per-strategy amounts are the trade: the action's own amount is
+    // not an argument here.
+    const tradeActions = list(action.tradeActions.map((ta) => record({ strategyId: word(ta.strategyId), amount: word(ta.amount) })));
+    const call = l.call("ICarbonController", addr(action.controller), "tradeBySourceAmount", [
+        addr(action.sourceToken),
+        addr(action.targetToken),
+        tradeActions,
         word(action.deadline),
         word(action.amountOutMin),
     ]);
-    return capturedCall(emit, needsOutput, word(action.controller), ZERO, cd, amountIn);
+    return captured(l, needsOutput, call, amountIn);
 }
-function fraxswapSwap(emit, action, amountIn, needsOutput) {
-    const recipient = needsOutput ? SELF : word(action.recipient);
-    const cd = calldata(emit, "swapExactTokensForTokens(uint256,uint256,address[],address,uint256)", [
+function fraxswapSwap(l, action, amountIn, needsOutput) {
+    // Fraxswap's router is UniswapV2-compatible for this function: same selector, same `uint256[]`
+    // return, so the output is a balance delta for the same reason.
+    return balanceDelta(l, needsOutput, () => l.selfBalance(addr(action.path[action.path.length - 1])), () => l.exec("IUniswapV2Router", addr(action.router), "swapExactTokensForTokens", [
         amountIn,
         word(action.amountOutMin),
-        arrayLiteral(action.path.map(word)),
-        recipient,
+        list(action.path.map(addr)),
+        needsOutput ? SELF : recipient(action.recipient),
         word(action.deadline),
-    ]);
-    // `swapExactTokensForTokens` returns `uint256[] memory amounts` — the SAME selector uniswapV2Swap
-    // uses, where decoding the first 32 bytes yields the ABI offset (0x20), not the output amount.
-    // This builder captured it anyway, so a chained fraxswap output was the constant 32.
-    const swap = [...cd.stmts, `${evmCall(word(action.router), ZERO, cd.expr)};`];
-    const tokenOut = word(action.path[action.path.length - 1]);
-    return balanceDeltaResult(emit, needsOutput, tokenOut, swap, amountIn);
-}
-function clipperSwap(emit, action, amountIn, needsOutput) {
-    // Clipper uses pre-transferred tokens, so the amount is implicit.
-    const recipient = needsOutput ? SELF : word(action.recipient);
-    const aux = bindBytes(emit, "aux", hexToBytes(action.auxiliaryData));
-    const cd = calldata(emit, "sellTokenForToken(address,address,address,uint256,bytes)", [
-        word(action.inputToken),
-        word(action.outputToken),
-        recipient,
-        word(action.amountOutMin),
-        aux.expr,
-    ]);
-    return capturedCall(emit, needsOutput, word(action.exchange), ZERO, { stmts: [...aux.stmts, ...cd.stmts], expr: cd.expr }, amountIn);
-}
-function integralSwap(emit, action, amountIn, needsOutput) {
-    // `sell` returns `uint256 orderId`, and Integral executes orders LATER — there is no output in
-    // this transaction to capture, so any number returned here would be a lie. Previously the order
-    // id was captured and chained as an amount.
-    if (needsOutput) {
-        throw new Error("integralSwap: Integral is a delayed-order venue — `sell` returns an orderId and the swap " +
-            "executes in a later transaction, so this action has no output amount to chain from. " +
-            "Give the next action an explicit amount or an amountRef to a different action.");
-    }
-    const recipient = word(action.recipient);
-    const params = tuple([
-        word(action.tokenIn),
-        word(action.tokenOut),
-        amountIn,
-        word(action.amountOutMin),
-        flag(action.wrapUnwrap),
-        recipient,
-        word(action.gasLimit),
-        word(action.submitDeadline),
-    ]);
-    const cd = calldata(emit, "sell((address,address,uint256,uint256,bool,address,uint256,uint32))", [
-        params,
-    ]);
-    return voidCall(word(action.delay), ZERO, cd, amountIn);
+    ]), amountIn);
 }
-function fluidDexT1Swap(emit, action, amountIn, needsOutput) {
-    const recipient = needsOutput ? SELF : word(action.recipient);
-    const cd = calldata(emit, "swapIn(bool,uint256,uint256,address)", [
+function fluidDexT1Swap(l, action, amountIn, needsOutput) {
+    const call = l.call("IFluidDexT1", addr(action.pool), "swapIn", [
         flag(action.swap0to1),
         amountIn,
         word(action.amountOutMin),
-        recipient,
-    ]);
-    return capturedCall(emit, needsOutput, word(action.pool), ZERO, cd, amountIn);
-}
-function fluidDexLiteSwap(emit, action, amountIn, needsOutput) {
-    // DexKey is a tuple: (token0, token1, salt)
-    const dexKey = tuple([word(action.token0), word(action.token1), word(action.salt)]);
-    const cd = calldata(emit, "swapSingle((address,address,bytes32),bool,int256,uint256,address)", [
-        dexKey,
-        flag(action.swap0To1),
-        amountIn, // positive = exact input
-        word(action.amountOutMin),
-        needsOutput ? SELF : word(action.recipient),
+        needsOutput ? SELF : recipient(action.recipient),
     ]);
-    // `swapSingle` returns `(int256 amount0, int256 amount1)` — a signed pair, so the first word is
-    // neither reliably the output nor reliably positive. The self delta on the received token needs
-    // no sign handling.
-    const swap = [...cd.stmts, `${evmCall(word(action.dex), ZERO, cd.expr)};`];
-    const tokenOut = word(action.swap0To1 ? action.token1 : action.token0);
-    return balanceDeltaResult(emit, needsOutput, tokenOut, swap, amountIn);
+    return captured(l, needsOutput, call, amountIn);
 }
 // ---------------------------------------------------------------------------
-// Transfer & approve — void output (pass-through amount)
+// Bridges — the amount passes through
 // ---------------------------------------------------------------------------
-function transfer(emit, action, amountIn) {
-    const cd = calldata(emit, "transfer(address,uint256)", [word(action.to), amountIn]);
-    return voidCall(word(action.token), ZERO, cd, amountIn);
+function acrossBridge(l, action, amount) {
+    // The Pot deposits, so an expired deposit is refunded to it. The relayer keeps the difference
+    // between the input and output amounts; a fee above the amount reverts the subtraction.
+    const message = l.bytes("msg", hexToBytes(action.message));
+    const fee = BigInt(action.relayerFee);
+    const outputAmount = fee === 0n ? amount : l.bind("out", `${amount} - ${word(fee)}`);
+    l.exec("IAcrossSpokePool", addr(action.spokePool), "depositV3", [
+        SELF, // depositor
+        addr(action.recipient),
+        addr(action.token), // inputToken
+        addr(action.token), // outputToken: the same token on the destination
+        amount,
+        outputAmount,
+        word(action.destChainId),
+        ZERO, // exclusiveRelayer: none
+        word(action.quoteTimestamp),
+        word(action.fillDeadline),
+        word(action.exclusivityDeadline),
+        message,
+    ]);
+    return l.result(amount);
+}
+function stargateBridge(l, action, amount) {
+    // Taxi mode (an empty `oftCmd`): the pool quotes the LayerZero fee for exactly this send, and the
+    // send pays it from the Pot, which also receives any refund.
+    const empty = l.bytes("empty", new Uint8Array());
+    const sendParam = record({
+        dstEid: word(action.dstEid),
+        to: remote(action.recipient),
+        amountLD: amount,
+        minAmountLD: word(action.amountOutMin),
+        extraOptions: empty,
+        composeMsg: empty,
+        oftCmd: empty,
+    });
+    const pool = addr(action.pool);
+    const quoted = l.bind("lz", l.call("IStargatePool", pool, "quoteSend", [sendParam, "false"]));
+    const nativeFee = l.bind("lzfee", `${quoted}.nativeFee`);
+    l.valueCall("IStargatePool", pool, nativeFee, "send", [
+        sendParam,
+        record({ nativeFee, lzTokenFee: ZERO }),
+        SELF,
+    ]);
+    return l.result(amount);
 }
-function approve(emit, action, amountIn) {
-    const cd = calldata(emit, "approve(address,uint256)", [word(action.spender), amountIn]);
-    return voidCall(word(action.token), ZERO, cd, amountIn);
+function cctpBridge(l, action, amount) {
+    l.exec("ICctpTokenMessenger", addr(action.tokenMessenger), "depositForBurn", [
+        amount,
+        word(action.destinationDomain),
+        remote(action.recipient),
+        addr(action.token),
+        ZERO, // destinationCaller: anyone may relay the mint
+        word(action.maxFee ?? "0"),
+        word(action.minFinalityThreshold ?? CCTP_FINALIZED),
+    ]);
+    return l.result(amount);
+}
+function hyperlaneBridge(l, action, amount) {
+    const router = addr(action.router);
+    const domain = word(action.destinationDomain);
+    const gas = l.bind("igp", l.call("IWarpRoute", router, "quoteGasPayment", [domain]));
+    l.valueCall("IWarpRoute", router, gas, "transferRemote", [
+        domain,
+        remote(action.recipient),
+        amount,
+    ]);
+    return l.result(amount);
 }
 // ---------------------------------------------------------------------------
-// Wrap / Unwrap — void output (pass-through amount)
+// Wrapping
 // ---------------------------------------------------------------------------
-function wrapETH(emit, action, amountIn) {
-    return voidCall(word(action.weth), amountIn, calldata(emit, "deposit()", []), amountIn);
+function wrapETH(l, action, amount) {
+    l.valueCall("IWeth9", addr(action.weth), amount, "deposit", []);
+    return l.result(amount);
 }
-function unwrapETH(emit, action, amountIn) {
-    return voidCall(word(action.weth), ZERO, calldata(emit, "withdraw(uint256)", [amountIn]), amountIn);
+function unwrapETH(l, action, amount) {
+    l.exec("IWeth9", addr(action.weth), "withdraw", [amount]);
+    return l.result(amount);
 }
-function wrapStETH(emit, action, amountIn) {
-    return voidCall(word(action.wstETH), ZERO, calldata(emit, "wrap(uint256)", [amountIn]), amountIn);
+function wrapStETH(l, action, amount, needsOutput) {
+    // `wrap` returns the wstETH it minted.
+    const call = l.call("IWstEth", addr(action.wstETH), "wrap", [amount]);
+    return captured(l, needsOutput, call, amount);
 }
-function unwrapStETH(emit, action, amountIn) {
-    return voidCall(word(action.wstETH), ZERO, calldata(emit, "unwrap(uint256)", [amountIn]), amountIn);
+function unwrapStETH(l, action, amount, needsOutput) {
+    // `unwrap` returns the stETH it released — never more than the Pot's balance grew by, so a later
+    // action can always spend it.
+    const call = l.call("IWstEth", addr(action.wstETH), "unwrap", [amount]);
+    return captured(l, needsOutput, call, amount);
 }
 // ---------------------------------------------------------------------------
-// Liquid staking — void output (pass-through amount)
+// Staking
 // ---------------------------------------------------------------------------
-function lidoStake(emit, action, amountIn) {
-    const cd = calldata(emit, "submit(address)", [word(action.referral)]);
-    return voidCall(word(action.stETH), amountIn, cd, amountIn);
-}
-function lidoUnstake(emit, action, amountIn) {
-    const cd = calldata(emit, "requestWithdrawals(uint256[],address)", [
-        arrayLiteral([amountIn]),
-        MSG_SENDER,
+function lidoStake(l, action, amount, needsOutput) {
+    // `submit` returns shares, not stETH, and a stETH balance can round a wei below the ETH staked;
+    // the output is the stETH balance delta.
+    const stETH = addr(action.stETH);
+    return balanceDelta(l, needsOutput, () => l.selfBalance(stETH), () => l.valueCall("ILido", stETH, amount, "submit", [
+        addr(action.referral ?? "0x0000000000000000000000000000000000000000"),
+    ]), amount);
+}
+function lidoUnstake(l, action, amount) {
+    l.exec("ILidoWithdrawalQueue", addr(action.withdrawalQueue), "requestWithdrawals", [
+        list([amount]),
+        recipient(action.owner),
     ]);
-    return voidCall(word(action.withdrawalQueue), ZERO, cd, amountIn);
-}
-function rocketPoolStake(emit, action, amountIn) {
-    return voidCall(word(action.depositPool), amountIn, calldata(emit, "deposit()", []), amountIn);
+    return l.result(amount);
 }
-function rocketPoolUnstake(emit, action, amountIn) {
-    return voidCall(word(action.rETH), ZERO, calldata(emit, "burn(uint256)", [amountIn]), amountIn);
+function rocketPoolStake(l, action, amount, needsOutput) {
+    return balanceDelta(l, needsOutput, () => l.selfBalance(addr(action.rETH)), () => l.valueCall("IRocketDepositPool", addr(action.depositPool), amount, "deposit", []), amount);
 }
-function coinbaseStake(emit, action, amountIn) {
-    return voidCall(word(action.cbETH), amountIn, calldata(emit, "deposit()", []), amountIn);
+function rocketPoolUnstake(l, action, amount, needsOutput) {
+    return balanceDelta(l, needsOutput, () => l.nativeBalance(), () => l.exec("IRocketTokenReth", addr(action.rETH), "burn", [amount]), amount);
 }
-function etherFiStake(emit, action, amountIn) {
-    return voidCall(word(action.liquidityPool), amountIn, calldata(emit, "deposit()", []), amountIn);
+function etherFiStake(l, action, amount, needsOutput) {
+    // `deposit` returns eETH shares; the output is the eETH balance delta.
+    return balanceDelta(l, needsOutput, () => l.selfBalance(addr(action.eETH)), () => l.valueCall("IEtherFiLiquidityPool", addr(action.liquidityPool), amount, "deposit", []), amount);
 }
 // ---------------------------------------------------------------------------
-// Lending / Borrowing — void output (pass-through amount)
+// Lending
 // ---------------------------------------------------------------------------
-function aaveV3Supply(emit, action, amountIn) {
-    const cd = calldata(emit, "supply(address,uint256,address,uint16)", [
-        word(action.token),
-        amountIn,
-        word(action.onBehalfOf),
-        word(action.referralCode),
+function aaveV3Supply(l, action, amount) {
+    l.exec("IAaveV3Pool", addr(action.pool), "supply", [
+        addr(action.token),
+        amount,
+        recipient(action.onBehalfOf),
+        word(action.referralCode ?? 0),
     ]);
-    return voidCall(word(action.pool), ZERO, cd, amountIn);
-}
-function aaveV3Withdraw(emit, action, amountIn, needsOutput) {
-    const cd = calldata(emit, "withdraw(address,uint256,address)", [
-        word(action.token),
-        amountIn,
-        word(action.to),
+    return l.result(amount);
+}
+function aaveV3Withdraw(l, action, amount, needsOutput) {
+    // `withdraw` returns the amount withdrawn, which is less than a `type(uint256).max` request.
+    const call = l.call("IAaveV3Pool", addr(action.pool), "withdraw", [
+        addr(action.token),
+        amount,
+        recipient(action.recipient),
     ]);
-    return capturedCall(emit, needsOutput, word(action.pool), ZERO, cd, amountIn);
-}
-function aaveV3Borrow(emit, action, amountIn) {
-    const cd = calldata(emit, "borrow(address,uint256,uint256,uint16,address)", [
-        word(action.token),
-        amountIn,
-        word(action.interestRateMode),
-        word(action.referralCode),
-        word(action.onBehalfOf),
+    return captured(l, needsOutput, call, amount);
+}
+function aaveV3Borrow(l, action, amount) {
+    l.exec("IAaveV3Pool", addr(action.pool), "borrow", [
+        addr(action.token),
+        amount,
+        word(AAVE_VARIABLE_RATE),
+        word(action.referralCode ?? 0),
+        recipient(action.onBehalfOf),
     ]);
-    return voidCall(word(action.pool), ZERO, cd, amountIn);
-}
-function aaveV3Repay(emit, action, amountIn) {
-    const cd = calldata(emit, "repay(address,uint256,uint256,address)", [
-        word(action.token),
-        amountIn,
-        word(action.interestRateMode),
-        word(action.onBehalfOf),
+    return l.result(amount);
+}
+function aaveV3Repay(l, action, amount) {
+    l.exec("IAaveV3Pool", addr(action.pool), "repay", [
+        addr(action.token),
+        amount,
+        word(AAVE_VARIABLE_RATE),
+        recipient(action.onBehalfOf),
     ]);
-    return voidCall(word(action.pool), ZERO, cd, amountIn);
+    return l.result(amount);
 }
-function compoundV3Supply(emit, action, amountIn) {
-    const cd = calldata(emit, "supply(address,uint256)", [word(action.token), amountIn]);
-    return voidCall(word(action.comet), ZERO, cd, amountIn);
+function compoundV3Supply(l, action, amount) {
+    l.exec("ICometMarket", addr(action.comet), "supply", [addr(action.token), amount]);
+    return l.result(amount);
 }
-function compoundV3Withdraw(emit, action, amountIn) {
-    const cd = calldata(emit, "withdraw(address,uint256)", [word(action.token), amountIn]);
-    return voidCall(word(action.comet), ZERO, cd, amountIn);
+function compoundV3Withdraw(l, action, amount) {
+    l.exec("ICometMarket", addr(action.comet), "withdraw", [addr(action.token), amount]);
+    return l.result(amount);
 }
 // ---------------------------------------------------------------------------
-// Bridge actions — void output (pass-through amount)
+// Tokens — the amount passes through, and nothing is decoded (`Lowering.erc20Write`)
 // ---------------------------------------------------------------------------
-function acrossBridge(emit, action, amountIn) {
-    const message = bindBytes(emit, "msg", hexToBytes(action.message));
-    const cd = calldata(emit, "depositV3(address,address,address,address,uint256,uint256,uint256,address,uint32,uint32,uint32,bytes)", [
-        MSG_SENDER, // depositor
-        MSG_SENDER, // recipient
-        word(action.token), // inputToken
-        word(action.token), // outputToken (same for simple bridge)
-        amountIn, // inputAmount
-        amountIn, // outputAmount
-        word(action.destChainId), // destinationChainId
-        ZERO, // exclusiveRelayer (none)
-        word(action.quoteTimestamp),
-        word(action.fillDeadline),
-        word(action.exclusivityDeadline),
-        message.expr,
+function transfer(l, action, amount) {
+    l.erc20Write("transfer", addr(action.token), recipient(action.recipient), amount);
+    return l.result(amount);
+}
+function approve(l, action, amount) {
+    l.erc20Write("approve", addr(action.token), addr(action.spender), amount);
+    return l.result(amount);
+}
+function permit2Approve(l, action, amount) {
+    l.exec("IPermit2", addr(action.permit2), "approve", [
+        addr(action.token),
+        addr(action.spender),
+        amount,
+        word(action.expiration),
     ]);
-    return voidCall(word(action.spokePool), ZERO, { stmts: [...message.stmts, ...cd.stmts], expr: cd.expr }, amountIn);
+    return l.result(amount);
 }
-function stargateBridge(emit, action, amountIn) {
-    const payload = bindBytes(emit, "pl", new Uint8Array(0));
-    const cd = calldata(emit, "swap(uint16,uint256,uint256,address,uint256,uint256,(address,address,bytes))", [
-        word(action.destChainId),
-        word(action.srcPoolId),
-        word(action.dstPoolId),
-        MSG_SENDER,
-        amountIn,
-        word(action.amountOutMin),
-        tuple([MSG_SENDER, MSG_SENDER, payload.expr]),
-    ]);
-    return voidCall(word(action.router), word(action.lzFee), { stmts: [...payload.stmts, ...cd.stmts], expr: cd.expr }, amountIn);
-}
-function cctpBridge(emit, action, amountIn) {
-    const cd = calldata(emit, "depositForBurn(uint256,uint32,bytes32,address)", [
-        amountIn,
-        word(action.destDomain),
-        word(action.mintRecipient),
-        word(action.token),
-    ]);
-    return voidCall(word(action.tokenMessenger), ZERO, cd, amountIn);
+// ---------------------------------------------------------------------------
+// Sources — produce a value
+// ---------------------------------------------------------------------------
+function balanceOf(l, action) {
+    return l.result(l.selfBalance(addr(action.token)));
 }
-function hyperlaneBridge(emit, action, amountIn) {
-    const body = bindBytes(emit, "body", new Uint8Array(0));
-    const cd = calldata(emit, "dispatch(uint32,bytes32,bytes)", [
-        word(action.destinationDomain),
-        word(action.token),
-        body.expr,
-    ]);
-    return voidCall(word(action.router), word(action.gasPayment), { stmts: [...body.stmts, ...cd.stmts], expr: cd.expr }, amountIn);
+function argument(l, action) {
+    return l.result(argumentVar(action.name));
 }