@eco-incorp/sauce 0.99.5 → 0.99.7

package/sdk/dist/routes/intent-sugar.js

@@ -12,9 +12,9 @@
  * ```
  *
  * WHAT THIS IS. A source rewrite, run before the compiler ever sees the program — the same class of
- * thing as `token-rewrite.ts`'s `Token(x)` -> `IERC20.at(x)`, and for the same reason: the compiler
- * has no notion of a closure, a chain, or an intent, and does not need one. By the time it runs, the
- * expression above has become ordinary statements it already supports.
+ * thing as `token-rewrite.ts`'s `Token(x).transfer(...)` -> `transfer(x, ...)`, and for the same
+ * reason: the compiler has no notion of a closure, a chain, or an intent, and does not need one.
+ * By the time it runs, the expression above has become ordinary statements it already supports.
  *
  * WHAT `amount` IS. It is a local of the ENCLOSING program, whose value exists only while that
  * program runs. So the child intent cannot be encoded with it — it is encoded with a sentinel in its
@@ -22,26 +22,44 @@
  * variable is one slot. This is the identical mechanism `nest-dynamic.ts` uses for a measured
  * balance; a capture is just a value that arrives by a different route.
  *
- * WHAT IS LOWERED, AND WHAT IS REFUSED. Each statement of the closure becomes one entry in the
- * child's `route.calls` — which is what an eco-routes route IS, a list of calls, so the mapping is
- * the natural one rather than a convention. A statement that is not one call (a loop, a balance
- * read, arithmetic) has no entry to become and is REFUSED, by name, pointing at the explicit
- * compiled-program form. An identifier that is neither a compile-time value nor an enclosing local
- * is refused the same way. Nothing here guesses: the failure mode this exists to avoid is a
- * plausible-looking intent carrying a number nobody chose.
+ * WHAT IS LOWERED, AND HOW. A body whose every statement is a token `transfer`/`approve` becomes
+ * plain `route.calls` — which is what an eco-routes route IS, a list of calls — one per transfer and
+ * two per approve (a reset to zero first, for USDT). The Portal's Executor runs those, not a Sauce
+ * program, so they get the Executor's checks rather than SafeERC20's; see the lowering loop. Any
+ * other body (a loop, a balance read, arithmetic, `transferFrom`, an intent of its own) is compiled
+ * as a program for the destination and cooked on its Pot. An identifier that is neither a
+ * compile-time value nor an enclosing local is refused. Nothing here guesses: the failure mode this
+ * exists to avoid is a plausible-looking intent carrying a number nobody chose.
+ *
+ * HOW THE REWARD IS FUNDED. By default the program pays it into the intent's vault itself and then
+ * publishes: it asks the source Portal for `intentVaultAddress` over the very bytes it is about to
+ * publish, transfers each reward token there with `SafeERC20` semantics, sends the native amount,
+ * and calls `publish` — all in the one cook, so the vault cannot be wrong and no allowance is left
+ * on the Pot every intent on the chain shares. `intents.fundVia: "publishAndFund"` emits the
+ * approvals and `publishAndFund` instead. See `vaultFundingStatements` and `portal.ts`'s module doc.
+ *
+ * WHICH CHAIN A NAME MEANS. Two chains are in play, and each part of the expression belongs to one.
+ * The body and the delivery argument run on the destination, so `USDC` there is the destination's.
+ * The reward is escrowed by the enclosing program, on the chain it runs on, in a vault of that
+ * chain's Portal, so `USDC` in `.reward(...)` is that chain's. An intent opened inside a body is
+ * funded on the body's chain: its reward resolves there and its own body on its own destination —
+ * the same rule one level down, because the child compile re-enters this pass with `source` set to
+ * the chain it compiles for.
  *
  * WHERE THE ADDRESSES COME FROM. The Portal on each side, and the prover for the pair, are looked up
  * in the SDK's eco-routes deployment registry (`protocols/eco-routes`). A caller supplies what has
  * no correct default — deadlines, and a creator when the refund must not go to the executing Pot.
  */
-import { parse } from "acorn";
 import { encodeFunctionData } from "viem";
 import { ERC20ABI } from "../protocols/erc20/abis.js";
-import { safeApproveStatements } from "../token/safe.js";
-import { collectDeclaredNames, walk } from "./ast-walk.js";
+import { safeApproveStatements, safeTransferStatements } from "../token/safe.js";
+import { walk } from "./ast-walk.js";
+import { childProgram, enclosingLocals, literalValue, moduleScope, unreachedFunctions, } from "./intent-body.js";
 import { denormalizeToEvm } from "./encode.js";
+import { rewardAssetsConflict } from "./intent.js";
 import { normalizeReward, normalizeRoute, toUniversalAddress } from "./normalize.js";
-import { publishAndFundTx } from "./portal.js";
+import { INTENT_FUND_VIA, intentVaultAddressCall, publishAndFundTx, publishTx, } from "./portal.js";
+import { parseSauce } from "./parse.js";
 import { emitTemplate, splitByPlaceholders } from "./template.js";
 /**
  * One sentinel per captured variable.
@@ -68,22 +86,16 @@ const fail = (message) => {
     throw new SugarError(`intent sugar: ${message}`);
 };
 function literalOf(node) {
-    if (node.type === "Literal") {
-        const value = node.value;
-        if (typeof value === "bigint")
-            return value;
-        if (typeof value === "number" && Number.isSafeInteger(value))
-            return BigInt(value);
-        if (typeof value === "boolean")
-            return value ? 1n : 0n;
-    }
+    const value = literalValue(node);
+    if (value !== undefined)
+        return value;
     if (node.type === "UnaryExpression" && node.operator === "-") {
         fail("a negative literal is not a valid address or amount");
     }
     return undefined;
 }
 function makeResolver(defines, outerLocals) {
-    return (node, what) => {
+    return (node, what, unknown) => {
         const direct = literalOf(node);
         if (direct !== undefined)
             return { literal: direct };
@@ -94,6 +106,8 @@ function makeResolver(defines, outerLocals) {
                 return { literal: define };
             if (outerLocals.has(name))
                 return { capture: name };
+            if (unknown !== undefined)
+                return fail(unknown(name));
             return fail(`${what} refers to '${name}', which is neither a compile-time value nor a variable of the ` +
                 `enclosing program. Declare it with \`const ${name} = ...\` before the intent, or supply ` +
                 `it as a compile-time define.`);
@@ -104,12 +118,18 @@ function makeResolver(defines, outerLocals) {
 }
 /** Whether every statement is a plain token write, which lowers to direct `route.calls` entries and
  *  needs no program, no Pot and no Kitchen fee. Anything else — a swap, control flow, a nested
- *  intent — takes the general path. */
+ *  intent, an argument that has to be computed (`half(amount)`, `amount - fee`) — takes the
+ *  general path. */
 function isDirectCallBody(body, defines) {
+    // The SHAPE of each argument, not its value: a literal or a name is resolved by the lowering
+    // itself, which reports a name it cannot resolve by name. Anything computed needs a program.
+    const shapeOnly = (node, what) => literalOf(node) !== undefined || node.type === "Identifier"
+        ? { literal: 0n }
+        : fail(`${what} is computed`);
     return (body.length > 0 &&
         body.every((statement) => {
             try {
-                lowerStatement(statement, () => ({ literal: 0n }), defines);
+                lowerStatement(statement, shapeOnly, defines);
                 return true;
             }
             catch {
@@ -117,7 +137,7 @@ function isDirectCallBody(body, defines) {
             }
         }));
 }
-/** `USDC.transfer(to, amount)` or `Token(addr).transfer(to, amount)` -> one call. */
+/** `USDC.transfer(to, amount)` or `Token(addr).transfer(to, amount)` -> the token write it names. */
 function lowerStatement(statement, resolve, defines) {
     if (statement.type !== "ExpressionStatement") {
         return fail(`a \`${statement.type}\` cannot become a route call. An intent's body is a list of calls, so ` +
@@ -151,7 +171,7 @@ function lowerStatement(statement, resolve, defines) {
         const address = defines.get(name);
         if (address === undefined) {
             return fail(`'${name}' is not a token this chain registers. Use a registered symbol, or ` +
-                `\`Token(address)\` with a literal or define.`);
+                "`Token(address)` with a literal, a define or a top-level `const` of a literal.");
         }
         target = address;
     }
@@ -176,59 +196,31 @@ function lowerStatement(statement, resolve, defines) {
     }
     return { target, method, args };
 }
-/**
- * The enclosing program's variables a closure body reads.
- *
- * Whole-program `outerLocals` minus everything the closure declares itself, minus names the
- * destination resolves (tokens, protocols, `ctx`, `abi`…). Conservative in the safe direction: a
- * name wrongly treated as a capture becomes an unused program parameter, while one wrongly left out
- * becomes an undeclared variable the compiler rejects by name.
- */
-function collectCaptures(body, outerLocals, defines) {
-    const declared = new Set();
-    const read = [];
-    for (const statement of body) {
-        walk(statement, (node) => {
-            if (node.type === "VariableDeclarator") {
-                const id = node.id;
-                if (id?.type === "Identifier")
-                    declared.add(id.name);
-            }
-        });
-    }
-    for (const statement of body) {
-        walk(statement, (node) => {
-            if (node.type !== "Identifier")
-                return;
-            const name = node.name;
-            if (declared.has(name) || defines.has(name))
-                return;
-            if (!outerLocals.has(name))
-                return;
-            if (!read.includes(name))
-                read.push(name);
-        });
+/** How a message names a field of `list`. */
+const fieldOf = (list, path) => list.part === "reward" ? `\`reward.${path}\`` : `the delivery's \`${path}\``;
+/** A token address of `list`. It is encoded into the intent, so it must be known when the intent is
+ *  built: a symbol, a literal, a define or a top-level `const` of a literal, never a value the
+ *  program has only while it runs. */
+function tokenOf(node, resolve, list) {
+    const chain = list.chain.slug;
+    const subject = `the ${list.part} token`;
+    const where = list.part === "delivery"
+        ? `The delivery — the intent's second argument, \`{ tokens: [...] }\` — is what the solver ` +
+            `brings to ${chain}, so its symbols are ${chain}'s: fix it there, not in \`.reward(...)\`.`
+        : `The reward — \`.reward({ tokens: [...] })\` — is escrowed on ${chain}, where the program ` +
+            `opening the intent runs, so its symbols are ${chain}'s.`;
+    const fix = `Use a symbol ${chain} registers, or the token's ${chain} address as a literal, a define or a ` +
+        "top-level `const` of a literal.";
+    if (node.type !== "Identifier" && literalOf(node) === undefined) {
+        return fail(`${subject} is a ${node.type}, which is not known when the intent is built. ${where} ${fix}`);
     }
-    return read;
+    const value = resolve(node, subject, (name) => `${subject} '${name}' is not a token ${chain} registers, nor a define. ${where} ${fix}`);
+    if ("literal" in value)
+        return value.literal;
+    return fail(`${subject} '${value.capture}' is a variable of the program, known only while it runs, and an ` +
+        `intent names its tokens when it is built. ${where} ${fix}`);
 }
-/** Is this identifier a PROPERTY (`a.b`) rather than a value read? Those are never captures. */
-function stripMemberProperties(body) {
-    const properties = new Set();
-    for (const statement of body) {
-        walk(statement, (node) => {
-            if (node.type !== "MemberExpression")
-                return;
-            if (node.computed === true)
-                return;
-            const property = node.property;
-            if (property?.type === "Identifier") {
-                properties.add(property.name);
-            }
-        });
-    }
-    return properties;
-}
-function lowerReward(node, resolve) {
+function lowerReward(node, resolve, list) {
     if (node.type !== "ObjectExpression") {
         return fail("`.reward(...)` takes an object, e.g. `{ tokens: [{ token: USDC, amount }] }`");
     }
@@ -239,11 +231,12 @@ function lowerReward(node, resolve) {
         const name = key?.type === "Identifier" ? key.name : "";
         const value = property.value;
         if (name === "tokens") {
-            if (value.type !== "ArrayExpression")
-                return fail("`reward.tokens` must be an array");
+            if (value.type !== "ArrayExpression") {
+                return fail(`${fieldOf(list, "tokens")} must be an array`);
+            }
             tokens = (value.elements ?? []).map((element) => {
                 if (element === null || element.type !== "ObjectExpression") {
-                    return fail("each `reward.tokens` entry must be `{ token, amount }`");
+                    return fail(`each entry of ${fieldOf(list, "tokens")} must be \`{ token, amount }\``);
                 }
                 let token;
                 let amount;
@@ -253,27 +246,26 @@ function lowerReward(node, resolve) {
                     // `{ token: USDC, amount }` -- shorthand's value IS the identifier.
                     const fieldValue = field.value;
                     if (fieldName === "token") {
-                        const resolved = resolve(fieldValue, "`reward.tokens[].token`");
-                        if (!("literal" in resolved)) {
-                            return fail("a reward token address must be known when the intent is built");
-                        }
-                        token = resolved.literal;
+                        token = tokenOf(fieldValue, resolve, list);
                     }
                     else if (fieldName === "amount") {
-                        amount = resolve(fieldValue, "`reward.tokens[].amount`");
+                        amount = resolve(fieldValue, fieldOf(list, "tokens[].amount"));
                     }
                     else {
-                        return fail(`\`reward.tokens[].${fieldName}\` is not a field of a token amount`);
+                        return fail(`${fieldOf(list, `tokens[].${fieldName}`)} is not a field of a token amount`);
                     }
                 }
                 if (token === undefined || amount === undefined) {
-                    return fail("each `reward.tokens` entry needs both `token` and `amount`");
+                    return fail(`each entry of ${fieldOf(list, "tokens")} needs both \`token\` and \`amount\``);
                 }
                 return { token, amount };
             });
         }
         else if (name === "nativeAmount") {
-            nativeAmount = resolve(value, "`reward.nativeAmount`");
+            nativeAmount = resolve(value, fieldOf(list, "nativeAmount"));
+        }
+        else if (list.part === "delivery") {
+            return fail(`\`${name}\` is not a field of the delivery, which takes only \`tokens\``);
         }
         else {
             return fail(`\`reward.${name}\` is not settable here. Deadlines, creator and prover come from the ` +
@@ -281,17 +273,20 @@ function lowerReward(node, resolve) {
         }
     }
     if (tokens.length === 0 && nativeAmount === undefined) {
-        return fail("`.reward(...)` must offer something — `tokens`, `nativeAmount`, or both");
+        return fail(list.part === "reward"
+            ? "`.reward(...)` must offer something — `tokens`, `nativeAmount`, or both"
+            : "the delivery names no token: list what the solver brings in `tokens`, or leave the " +
+                "intent's second argument out");
     }
     return { tokens, nativeAmount };
 }
 /** `{ tokens: [{ token, amount }] }` — what the solver delivers to run the intent. Same shape as a
  *  reward leg, and deliberately the same parser, since the fields mean the same things. */
-function lowerDelivery(node, resolve) {
+function lowerDelivery(node, resolve, list) {
     if (node.type !== "ObjectExpression") {
         return fail("an intent's second argument is `{ tokens: [{ token, amount }] }`");
     }
-    const spec = lowerReward(node, resolve);
+    const spec = lowerReward(node, resolve, list);
     if (spec.nativeAmount !== undefined) {
         return fail("`nativeAmount` belongs to the reward, not to what the solver delivers");
     }
@@ -361,7 +356,7 @@ function collectSites(program, context) {
 // ---------------------------------------------------------------------------
 const addressHex = (value) => `0x${value.toString(16).padStart(40, "0")}`;
 /** Lowers every `Chain(() => { ... }).reward({ ... })` in `source`. Purely textual surgery driven by
- *  acorn ranges, so everything else survives byte for byte. */
+ *  parser ranges, so everything else survives byte for byte. */
 export function rewriteIntentSugar(source, context) {
     // Every route compile comes through here, and most programs have no sugar, so skip the parse
     // when a site is impossible. A site is a call whose callee's property is the identifier
@@ -372,17 +367,16 @@ export function rewriteIntentSugar(source, context) {
     if (!source.includes("reward") && !source.includes("\\u")) {
         return { source, rewrote: false, intents: [] };
     }
-    const program = parse(source, {
-        ecmaVersion: "latest",
-        sourceType: "module",
-    });
+    const program = parseSauce(source);
     const sites = collectSites(program, context);
     if (sites.length === 0)
         return { source, rewrote: false, intents: [] };
-    // Every name the program binds anywhere. A capture must be one of them, and the enclosing
-    // program's locals are what this set is -- deliberately whole-program rather than scope-accurate,
-    // matching `token-rewrite.ts`'s posture, because SauceScript shares scope across blocks anyway.
-    const outerLocals = collectDeclaredNames(program);
+    // The file's top level: the declarations a child program may carry, and the entry. See
+    // `intent-body.ts` for what each name an intent body reads means.
+    const scope = moduleScope(program);
+    // The file's functions some child program carries; those the enclosing program no longer reaches
+    // once its bodies are lowered move out of it below.
+    const carriedFunctions = new Set();
     const intents = [];
     const replacements = [];
     sites.forEach((site, index) => {
@@ -412,10 +406,31 @@ export function rewriteIntentSugar(source, context) {
             }
             return captureSentinel(at);
         };
-        // Resolved against the DESTINATION's registry: `USDC` in this closure is the destination's
-        // USDC, because that is the chain the calls run on.
-        const defines = context.definesFor(site.chain);
-        const resolve = makeResolver(defines, outerLocals);
+        // TWO chains, so two resolvers. The body and the delivery argument run on the DESTINATION:
+        // `USDC` in the closure is the destination's USDC. The reward is escrowed by THIS program, on
+        // the chain it runs on, and approved to that chain's Portal a few statements below, so its
+        // `USDC` is the enclosing chain's. Crossing them names an address with no code where the call
+        // runs: a reward token from the destination fails SafeERC20's code check on the approval and
+        // reverts the whole fulfilment, and a body token from here is not a token over there.
+        //
+        // A top-level `const` of a literal is known when the file is compiled, so it is a value here
+        // exactly as a define is, and the same on both chains: what the file wrote. A define of the same
+        // name takes precedence, as the compiler gives a define over a module `const`, and a local of
+        // the opening function shadows it.
+        const opening = enclosingLocals(program, scope, site.start);
+        const fixed = [...scope.declarations].flatMap(([name, d]) => d.literal === undefined || opening.has(name) ? [] : [[name, d.literal]]);
+        const compileTime = (chain) => new Map([...fixed, ...context.definesFor(chain)]);
+        const defines = compileTime(site.chain);
+        // What the enclosing program can read where the intent opens: its locals there, and the
+        // file's module-level values. A reward, a delivery or a token-write argument naming one is
+        // spliced in at run time.
+        const readable = new Set([
+            ...opening,
+            ...scope.imports.keys(),
+            ...[...scope.declarations].filter(([, d]) => d.kind === "variable").map(([name]) => name),
+        ]);
+        const resolve = makeResolver(defines, readable);
+        const resolveFunding = makeResolver(compileTime(context.source), readable);
         /**
          * What the solver delivers to the destination Executor so this intent can run.
          *
@@ -424,15 +439,19 @@ export function rewriteIntentSugar(source, context) {
          * because there it is not a judgement call — a `transfer` of N moves N, so N is what has to
          * arrive. A program's needs cannot be read off its source, so the general path asks.
          */
-        const explicitDelivery = site.delivery === undefined ? undefined : lowerDelivery(site.delivery, resolve);
+        const explicitDelivery = site.delivery === undefined
+            ? undefined
+            : lowerDelivery(site.delivery, resolve, { part: "delivery", chain: site.chain });
         // TWO SHAPES, chosen by what the closure actually contains.
         //
         // A body of nothing but token writes needs no program: each statement is already one route
         // call, which is cheaper than a cook and needs neither a Pot nor a Kitchen fee. Anything else --
         // a swap, a condition, a loop, an intent of its own -- is a program, compiled for the
         // destination and run through its Pot. The second shape is strictly more general; the first is
-        // kept because it is free.
-        const simple = isDirectCallBody(site.body, defines);
+        // kept because it is free. It is ERC-20 calldata, so only for an EVM destination: on Solana a
+        // symbol is a mint's key, and a token write there goes the program way, where the SVM compile
+        // refuses the token syntax by name.
+        const simple = site.chain.kind === "evm" && isDirectCallBody(site.body, defines);
         // The Portal the child's route records. Resolved once, here, because it is also what the Pot's
         // owner is derived from: a route recording one Portal is run by that Portal's Executor.
         const destinationPortal = context.defaults.destinationPortal ?? context.portalOf(site.chain);
@@ -440,17 +459,20 @@ export function rewriteIntentSugar(source, context) {
         const calls = [];
         const captureWords = [];
         if (!simple) {
-            const properties = stripMemberProperties(site.body);
-            const captured = collectCaptures(site.body, outerLocals, defines).filter((name) => !properties.has(name));
+            // The body as a program of its own: the file's declarations it reaches, carried as written,
+            // and `main` taking what it captures (`intent-body.ts`).
+            //
             // Captured values reach the program as ENTRY ARGUMENTS. They cannot be folded in: their
             // values do not exist when it is compiled. Declared as `main`'s parameters, encoded
             // compact-v1 at a declared width so the payload's length does not move with them, and spliced
-            // by the parent at a fixed offset -- which is the property `scalarWidth` exists for.
-            // UNTYPED parameters on purpose: the rewrite passes downstream are acorn-based and cannot
-            // parse an annotation. `rs-compile.ts#ensureTypedMainParams` adds them at the compile seam,
-            // after every rewrite has run -- the same staging `ensureVoidMain` already uses.
-            const childSource = `function main(${captured.join(", ")}) {\n${source.slice(site.bodyStart + 1, site.bodyEnd - 1)}\n}`;
-            const child = context.compileChild(site.chain, childSource, captured, destinationPortal);
+            // by the parent at a fixed offset -- which is the property `scalarWidth` exists for. Left
+            // unannotated: the compiler reads an unannotated parameter as a number, which a spliced
+            // 32-byte word is.
+            const childModule = childProgram(source, program, scope, site, site.body, source.slice(site.bodyStart + 1, site.bodyEnd - 1), new Set(defines.keys()));
+            const captured = childModule.captures;
+            for (const name of childModule.carriedFunctions)
+                carriedFunctions.add(name);
+            const child = context.compileChild(site.chain, childModule.source, captured, destinationPortal);
             captured.forEach((name, i) => {
                 captureWords.push({ name, sentinel: child.captureSentinels[i] });
             });
@@ -468,24 +490,40 @@ export function rewriteIntentSugar(source, context) {
             }
             calls.push(child.call);
         }
+        // Each call is encoded by viem against the ERC-20 ABI, so the selector and the word layout are
+        // the encoder's rather than this file's. A captured argument goes in as its sentinel, which is
+        // address-shaped and therefore legal in either position.
+        const tokenCall = (target, method, args) => ({
+            target: addressHex(target),
+            data: encodeFunctionData({
+                abi: ERC20ABI,
+                functionName: method,
+                args: [addressHex(sentinelFor(args[0])), sentinelFor(args[1])],
+            }),
+            value: 0n,
+        });
+        // These calls are not a Sauce program: the Portal's Executor runs each one raw and checks only
+        // that it did not revert and that the target has code. So they are NOT SafeERC20. What that
+        // costs, and what the lowering does about it:
+        //  - A token that returns nothing (USDT) works as it is: nothing decodes the return.
+        //  - USDT refuses to move a non-zero allowance to another non-zero value, and ONE Executor runs
+        //    every intent on a chain, so an allowance an earlier intent left behind is a realistic
+        //    state. Every approve is therefore preceded by `approve(spender, 0)` — `forceApprove`'s end
+        //    state, unconditionally, because the Executor's allowance cannot be read when the intent is
+        //    built. A literal zero amount needs no reset.
+        //  - A token that returns `false` instead of reverting is NOT detected. A body that needs that
+        //    check must take the program path, whose writes are `@sauce/token`'s SafeERC20 ones.
         for (const statement of simple ? site.body : []) {
             const lowered = lowerStatement(statement, resolve, defines);
             // A `transfer` moves tokens the Executor must have been given; an `approve` moves nothing.
             if (lowered.method === "transfer" && explicitDelivery === undefined) {
                 derivedDelivery.push({ token: lowered.target, amount: lowered.args[1] });
             }
-            calls.push({
-                target: addressHex(lowered.target),
-                // Encoded by viem against the ERC-20 ABI, so the selector and the word layout are the
-                // encoder's rather than this file's. A captured argument goes in as its sentinel, which is
-                // address-shaped and therefore legal in either position.
-                data: encodeFunctionData({
-                    abi: ERC20ABI,
-                    functionName: lowered.method,
-                    args: [addressHex(sentinelFor(lowered.args[0])), sentinelFor(lowered.args[1])],
-                }),
-                value: 0n,
-            });
+            const amount = lowered.args[1];
+            if (lowered.method === "approve" && !("literal" in amount && amount.literal === 0n)) {
+                calls.push(tokenCall(lowered.target, "approve", [lowered.args[0], { literal: 0n }]));
+            }
+            calls.push(tokenCall(lowered.target, lowered.method, lowered.args));
         }
         // A capture the PROGRAM reads is a slot too: its sentinel sits in the argument tail of the cook
         // calldata above, which the parent splices exactly as it splices a reward amount.
@@ -499,7 +537,18 @@ export function rewriteIntentSugar(source, context) {
             if (!captures.includes(name))
                 captures.push(name);
         }
-        const reward = lowerReward(site.reward, resolve);
+        // On the enclosing chain: see `resolveFunding` above.
+        const reward = lowerReward(site.reward, resolveFunding, {
+            part: "reward",
+            chain: context.source,
+        });
+        // A native amount known to be zero offers nothing; any other (a literal or a run-time value)
+        // is a native leg the source Portal would count against a leg of its native ERC-20.
+        const offersNative = reward.nativeAmount !== undefined &&
+            !("literal" in reward.nativeAmount && reward.nativeAmount.literal === 0n);
+        const conflict = rewardAssetsConflict(context.source.id, offersNative, reward.tokens.map((t) => addressHex(t.token)));
+        if (conflict !== undefined)
+            fail(conflict);
         const { defaults } = context;
         const rewardDeadline = defaults.rewardDeadline ?? requireDeadline(defaults);
         const child = {
@@ -533,14 +582,21 @@ export function rewriteIntentSugar(source, context) {
             }),
         };
         const sourcePortal = defaults.sourcePortal ?? context.portalOf(context.source);
-        const tx = publishAndFundTx(child, defaults.allowPartial ?? false, { portal: sourcePortal });
-        const template = splitByPlaceholders(tx.data, placeholders);
+        const fundVia = requireFundVia(defaults);
+        // `publish` when the program pays the vault itself, `publishAndFund` when the Portal pulls the
+        // reward under an approval. Either way the intent is these bytes, cut at the same slots.
+        const tx = fundVia === "transfer"
+            ? publishTx(child, { portal: sourcePortal })
+            : publishAndFundTx(child, defaults.allowPartial ?? false, { portal: sourcePortal });
+        // An intent every value of which is known now — defines and literals, no local of the program —
+        // has no slot to fill: its calldata is simply these bytes.
+        const template = placeholders.length === 0 ? undefined : splitByPlaceholders(tx.data, placeholders);
         // Every sentinel must have become a slot. `splitByPlaceholders` guarantees that for the ones it
         // was TOLD about; this catches the other direction — a sentinel written into the payload whose
         // placeholder was never declared, which leaves it in the literal segments and ships an intent
         // carrying `0x5acecab7…` where an amount belongs. That happened once, silently, which is why it
         // is checked rather than reasoned about.
-        for (const segment of template.segments) {
+        for (const segment of template?.segments ?? [tx.data]) {
             for (const tag of [CAPTURE_TAG, CHILD_CAPTURE_TAG]) {
                 if (segment.includes(tag)) {
                     throw new SugarError(`intent sugar: a capture sentinel (0x${tag}) survived into the encoded intent — some ` +
@@ -550,28 +606,50 @@ export function rewriteIntentSugar(source, context) {
             }
         }
         const locals = Object.fromEntries(captures.map((name) => [name, name]));
-        const emitted = emitTemplate(template, { prefix, locals });
+        const emitted = template === undefined
+            ? {
+                statements: [`const ${prefix}data = hex\`${tx.data.slice(2)}\`;`],
+                dataVar: `${prefix}data`,
+            }
+            : emitTemplate(template, { prefix, locals });
         const statements = [...emitted.statements];
-        // One approve per distinct reward token, so the Portal can pull the escrow from this Pot.
-        // Through `token/safe.ts`: the ERC-20 ABI's `bool` return is decoded even when discarded and a
-        // token like USDT returns nothing, so the call goes out raw and the SafeERC20 check judges the
-        // result. That helper also resets a standing allowance first -- which matters here more than
-        // anywhere, because one Pot publishes every intent on this chain and the previous one's
-        // leftover allowance is exactly what USDT refuses to overwrite.
         const portalWord = {
             literal: BigInt(denormalizeToEvm(toUniversalAddress(sourcePortal))),
         };
-        const approved = new Set();
-        reward.tokens.forEach((t, i) => {
-            const token = addressHex(t.token);
-            if (approved.has(token))
-                return;
-            approved.add(token);
-            const amount = "literal" in t.amount ? { literal: t.amount.literal } : { local: t.amount.capture };
-            statements.push(...safeApproveStatements(`${prefix}${i}`, `${BigInt(t.token)}n`, portalWord, amount));
+        const portalLiteral = `${portalWord.literal}n`;
+        if (fundVia === "transfer") {
+            statements.push(...vaultFundingStatements({
+                prefix,
+                child,
+                publishData: tx.data,
+                dataVar: emitted.dataVar,
+                sourcePortal,
+                reward,
+            }), `evm.call(${portalLiteral}, 0n, ${emitted.dataVar});`);
+        }
+        else {
+            // One approve per distinct reward token, so the Portal can pull the escrow from this Pot.
+            // Through `token/safe.ts`: the ERC-20 ABI's `bool` return is decoded even when discarded and a
+            // token like USDT returns nothing, so the call goes out raw and the SafeERC20 check judges the
+            // result. That helper also resets a standing allowance first -- which matters here more than
+            // anywhere, because one Pot publishes every intent on this chain and the previous one's
+            // leftover allowance is exactly what USDT refuses to overwrite. A token listed twice is
+            // approved once, for the larger amount: `_fundToken` pulls each entry up to the vault's
+            // whole balance of that token, so the largest entry is the allowance it needs.
+            largestPerToken(`${prefix}a`, reward, statements).forEach(({ token, amount }, i) => {
+                statements.push(...safeApproveStatements(`${prefix}${i}`, `${token}n`, portalWord, amount));
+            });
+            // The native reward travels as the call's value: `_fundNative` pays the vault from
+            // `msg.value`, and `Refund.excessNative` returns what it did not need.
+            statements.push(`evm.call(${portalLiteral}, ${valueExpression(reward.nativeAmount)}, ${emitted.dataVar});`);
+        }
+        intents.push({
+            intent: child,
+            captures,
+            sentinels: placeholders.map(({ value, source }) => ({ sentinel: value, capture: source })),
+            destination: site.chain,
+            fundVia,
         });
-        statements.push(`evm.call(${BigInt(denormalizeToEvm(toUniversalAddress(sourcePortal)))}n, 0n, ${emitted.dataVar});`);
-        intents.push({ intent: child, captures, destination: site.chain });
         replacements.push({
             start: site.start,
             end: site.end,
@@ -584,7 +662,135 @@ export function rewriteIntentSugar(source, context) {
     for (const replacement of [...replacements].sort((a, b) => b.start - a.start)) {
         out = out.slice(0, replacement.start) + replacement.text + out.slice(replacement.end);
     }
-    return { source: out, rewrote: true, intents };
+    return { source: withoutMovedFunctions(out, carriedFunctions), rewrote: true, intents };
+}
+/**
+ * `source` without the functions only an intent body used. Each moved into that body's program,
+ * which compiles it for the chain it runs on; left here it would be compiled for this chain too,
+ * where the program never calls it, and could fail a rewrite there for a token or protocol that
+ * chain does not have.
+ */
+function withoutMovedFunctions(source, carried) {
+    if (carried.size === 0)
+        return source;
+    const program = parseSauce(source);
+    const moved = unreachedFunctions(moduleScope(program), carried);
+    if (moved.size === 0)
+        return source;
+    let out = source;
+    const statements = [...(program.body ?? [])].reverse();
+    for (const statement of statements) {
+        const node = statement.type === "ExportNamedDeclaration"
+            ? (statement.declaration ?? statement)
+            : statement;
+        const id = node.type === "FunctionDeclaration" ? node.id : undefined;
+        if (id === undefined || !moved.has(id.name))
+            continue;
+        const end = out[statement.end] === "\n" ? statement.end + 1 : statement.end;
+        out = out.slice(0, statement.start) + out.slice(end);
+    }
+    return out;
+}
+/** A native amount as the expression a call's value takes: its literal, or the enclosing local. */
+function valueExpression(value) {
+    if (value === undefined)
+        return "0n";
+    return "literal" in value ? `${value.literal}n` : value.capture;
+}
+/** `defaults.fundVia`, defaulted and checked, refusing an option that belongs to the other mode. */
+function requireFundVia(defaults) {
+    const fundVia = defaults.fundVia ?? "transfer";
+    if (!INTENT_FUND_VIA.includes(fundVia)) {
+        return fail(`\`intents.fundVia\` is '${String(fundVia)}', which is not ` +
+            `${INTENT_FUND_VIA.map((via) => `"${via}"`).join(" or ")}`);
+    }
+    if (fundVia === "transfer" && defaults.allowPartial === true) {
+        return fail('`intents.allowPartial` goes with `fundVia: "publishAndFund"`: funding by transfer pays the ' +
+            "whole reward into the vault, and `publish` takes no such flag");
+    }
+    return fundVia;
+}
+/**
+ * Each distinct reward token, in first-seen order, with the largest amount it is listed for: the
+ * balance `isIntentFunded` checks every entry of that token against, and so what a transfer into
+ * the vault — or an approval the Portal pulls under — must cover. A literal when every amount is
+ * known now; otherwise a local, computed by the statements this appends (named `<tag><i>m<k>`), the
+ * largest of the captured values and of the largest literal beside them.
+ */
+function largestPerToken(tag, reward, statements) {
+    const byToken = new Map();
+    for (const t of reward.tokens)
+        byToken.set(t.token, [...(byToken.get(t.token) ?? []), t.amount]);
+    return [...byToken].map(([token, amounts], i) => {
+        const largestLiteral = amounts.reduce((max, a) => ("literal" in a && (max === undefined || a.literal > max) ? a.literal : max), undefined);
+        const captured = [...new Set(amounts.flatMap((a) => ("capture" in a ? [a.capture] : [])))];
+        if (captured.length === 0)
+            return { token, amount: { literal: largestLiteral } };
+        const operands = [...captured, ...(largestLiteral === undefined ? [] : [`${largestLiteral}n`])];
+        let local = operands[0];
+        operands.slice(1).forEach((operand, k) => {
+            const next = `${tag}${i}m${k}`;
+            statements.push(`const ${next} = ${local} > ${operand} ? ${local} : ${operand};`);
+            local = next;
+        });
+        return { token, amount: { local } };
+    });
+}
+/**
+ * The statements that pay an intent's reward into its vault from the executing contract, before
+ * the `publish` that follows them:
+ *
+ *  1. the vault, read from the Portal in this same cook — `intentVaultAddress` over the very bytes
+ *     about to be published, so the address cannot disagree with the intent the Portal records.
+ *     Its arguments are `publish`'s exactly (`(uint64, bytes, Reward)` both), so the call is the
+ *     rendered payload with the other selector in front, not a second copy of the intent;
+ *  2. one `transfer(vault, amount)` per distinct reward token, for the largest of its amounts (the
+ *     balance `isIntentFunded` checks each entry against), with `SafeERC20` semantics
+ *     (`token/safe.ts`): a token returning nothing works, `false` or no code reverts the cook. A
+ *     captured amount of zero transfers nothing;
+ *  3. the native amount, sent to the vault.
+ */
+function vaultFundingStatements(funding) {
+    const { prefix, child, publishData, dataVar, sourcePortal, reward } = funding;
+    const query = intentVaultAddressCall(child, { portal: sourcePortal }).data;
+    // Held, not assumed: the selector swap below is only sound while both functions take the same
+    // arguments in the same encoding.
+    if (query.slice(10) !== publishData.slice(10)) {
+        throw new SugarError("intent sugar: intentVaultAddress and publish no longer encode the same arguments — " +
+            "the vault read would ask about a different intent than the one published. This is a bug " +
+            "in the lowering, not in the program.");
+    }
+    const portal = `${BigInt(denormalizeToEvm(toUniversalAddress(sourcePortal)))}n`;
+    const vault = `${prefix}vault`;
+    const statements = [
+        `const ${prefix}vsel = hex\`${query.slice(2, 10)}\`;`,
+        `const ${prefix}vq = ${prefix}vsel.concat(${dataVar}.slice(4n, ${dataVar}.length));`,
+        `const [${vault}] = abi.decode(evm.static(${portal}, ${prefix}vq), ["Address"]);`,
+    ];
+    largestPerToken(`${prefix}f`, reward, statements).forEach(({ token, amount }, i) => {
+        // A token listed only for nothing needs nothing in the vault.
+        if ("literal" in amount && amount.literal === 0n)
+            return;
+        const transfer = safeTransferStatements(`${prefix}f${i}_`, `${token}n`, { local: vault }, amount);
+        if ("literal" in amount) {
+            statements.push(...transfer);
+            return;
+        }
+        // The calldata consts are hoisted out of the zero guard; the call AND its SafeERC20 check go
+        // inside it, since checking a call that never happened would read a stale result.
+        const firstCall = transfer.findIndex((line) => line.includes("evm.call("));
+        statements.push(...transfer.slice(0, firstCall));
+        statements.push(`if (${amount.local} > 0n) { ${transfer.slice(firstCall).join(" ")} }`);
+    });
+    const native = reward.nativeAmount;
+    if (native !== undefined && !("literal" in native && native.literal === 0n)) {
+        // Bound, not inline: a method call on a `hex` literal is outside the compiler's subset, and
+        // `evm.call` is the one way to send value.
+        statements.push(`const ${prefix}fnd = hex\`\`;`);
+        const send = `evm.call(${vault}, ${valueExpression(native)}, ${prefix}fnd);`;
+        statements.push("literal" in native ? send : `if (${native.capture} > 0n) { ${send} }`);
+    }
+    return statements;
 }
 /**
  * The reward's creator — who may reclaim it once `rewardDeadline` passes.