@eco-incorp/sauce 0.99.0

package/sdk/dist/verify/intent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intent.d.ts","sourceRoot":"","sources":["../../src/verify/intent.ts"],"names":[],"mappings":"AA2BA,OAAO,EAAgC,KAAK,GAAG,EAAE,MAAM,MAAM,CAAC;AAC9D,OAAO,EAGL,KAAK,oBAAoB,EACzB,KAAK,UAAU,EAChB,MAAM,aAAa,CAAC;AAerB,MAAM,WAAW,iBAAkB,SAAQ,oBAAoB;IAC7D;;kFAE8E;IAC9E,eAAe,EAAE,MAAM,CAAC;IACxB;;;;;4DAKwD;IACxD,eAAe,EAAE,MAAM,CAAC;IACxB;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,EAAE,KAAK,MAAM,EAAE,CAAC;CACxB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,GAAG,EACb,QAAQ,CAAC,EAAE,SAAS,CAAC,GAAG,GAAG,UAAU,CAAC,EAAE,GACvC,iBAAiB,GAAG,IAAI,CAkD1B;AAED;gGACgG;AAChG,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,GAAG,CAAC;IACV,MAAM,CAAC,EAAE,KAAK,MAAM,EAAE,CAAC;CACxB;AAED,MAAM,WAAW,kBAAmB,SAAQ,iBAAiB;IAC3D,uEAAuE;IACvE,SAAS,EAAE,MAAM,CAAC;IAClB,kFAAkF;IAClF,MAAM,CAAC,EAAE,KAAK,MAAM,EAAE,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,SAAS,cAAc,EAAE,EAChC,QAAQ,CAAC,EAAE,SAAS,CAAC,GAAG,GAAG,UAAU,CAAC,EAAE,GACvC,kBAAkB,GAAG,IAAI,CAM3B;AAED;kDACkD;AAClD,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE;QAAE,KAAK,EAAE,SAAS,cAAc,EAAE,CAAA;KAAE,CAAC;CAC7C;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,UAAU,EAClB,QAAQ,CAAC,EAAE,SAAS,CAAC,GAAG,GAAG,UAAU,CAAC,EAAE,GACvC,kBAAkB,GAAG,IAAI,CAE3B"}

package/sdk/dist/verify/intent.js

@@ -0,0 +1,163 @@
+// @eco-incorp/sauce/verify — extract settle params from the CALLS an intent carries.
+//
+// `decodeSettleProgram` / `validateSettleProgram` (decode.ts) turn a raw settle PAYLOAD's bytes back
+// into `(tokens, minOut, recipient)`. But a producer (eco-solver, the recipes API) never hands you the
+// bare payload — on EVM it hands you an intent whose `route.calls[]` batch ends with a `cook` call
+// carrying the settle payload as its program. These helpers close that last gap: unwrap the cook
+// calldata and hand that program to the decoder, so a caller goes from an intent object to
+// `(tokens, minOut, recipient)` in one step. Two cook shapes are decoded — see `COOK_V12_ABI`.
+//
+// Same dependency contract as decode.ts: `viem` ONLY (no compiler, no node, no artifact resolution), so
+// this stays safe to import in a browser or edge runtime.
+//
+// IDENTIFICATION IS BY PROGRAM HASH. An ingredient is taken as the settle when its leading 362 bytes
+// hash to `SETTLE_WIRE.PROGRAM_HASH` and its tail is canonical — `validateSettleProgram`, not the
+// structural `decodeSettleProgram`. Under the v1 grammar the prologue's shape was itself the
+// signature; a length pin alone is a far weaker one, since ANY 362-byte prefix followed by a
+// well-formed tail would decode. The hash is both stronger and simpler, and it is available at all
+// only because the arguments left the program — so what these helpers return is now "the audited
+// settle, with these params", not "something settle-shaped, params unverified".
+//
+// The SVM analogue is `extractSvmSettleFromIntent` in `@eco-incorp/sauce/svm/verify`: an SVM intent
+// wraps its settle CPI one layer deeper (the Eco Portal `CalldataWithAccounts` Borsh envelope), so that
+// module decodes the envelope itself before handing the halves to `decodeSvmSettleExecution` /
+// `verifySvmSettleExecution` — same "one call from intent to params" story, on the SVM side. It reaches
+// its verdict by RECOMPILING, because an SVM settle's params are folded into its bytecode and no amount
+// of reading the calldata recovers them; this EVM path needs no compiler for the same verdict, which is
+// what keeps `/verify` viem-only.
+import { decodeFunctionData, parseAbi } from "viem";
+import { SettleDecodeError, validateSettleProgram, } from "./decode.js";
+/**
+ * TWO fragments, because the two cooks no longer share a signature.
+ *
+ * They used to: one `cook(bytes[])` fragment decoded a `V12Pot` and a v1 `SauceRouter` alike. v12
+ * #432 changed the Pot to `cook(address engine, bytes program)` — the engine is named per call —
+ * while a v1 `SauceRouter` still takes `bytes[]`. A single fragment now silently fails on one of
+ * them, so both are tried, v12 first.
+ */
+const COOK_V12_ABI = parseAbi([
+    "function cook(address engine, bytes program) payable returns (bytes)",
+]);
+const COOK_V1_ABI = parseAbi(["function cook(bytes[] ingredients) payable returns (bytes)"]);
+/**
+ * Decodes one `Pot.cook(address,bytes)` / `SauceRouter.cook(bytes[])` call and returns the settle payload it
+ * carries — or `null` if the calldata is not a `cook` call, or ingredient 0 is not the settle payload.
+ * Never throws for a non-cook / non-settle input: a mismatched selector, malformed ABI, or a non-settle
+ * ingredient 0 all return `null`.
+ *
+ * The index-0 rule is a `V12Pot` property, and on a v1 `SauceRouter` it cuts BOTH ways, because a
+ * SauceRouter executes EVERY ingredient. A settle at index ≥1 reads as `null` here (a missed settle —
+ * harmless); but `cook([settlePayload, drainPayload])` on a SauceRouter validates index 0, returns the
+ * settle, and the drain runs too — a settle reported for a call that does more than settle. The
+ * returned `ingredientCount` is how a caller detects that: require it to be 1 on a SauceRouter. So a
+ * non-null result is a statement about a v12 cook ONLY. On a SauceRouter it is not sufficient, for the
+ * same reason `extractEvmSettleFromCalls` is not sufficient across `route.calls[]`. The detection IS `validateSettleProgram` (the pinned
+ * program hash, plus a canonical tail), so an accepted ingredient is the audited settle program AND the
+ * unique byte encoding of the `(tokens, minOut, recipient)` reported.
+ */
+export function decodeSettleCall(callData, accepted) {
+    let ingredients;
+    let engine;
+    try {
+        // v12 first: one program, and the engine it names.
+        const decoded = decodeFunctionData({ abi: COOK_V12_ABI, data: callData });
+        if (decoded.functionName !== "cook")
+            return null;
+        const [namedEngine, program] = decoded.args;
+        // Lowercased: viem returns EIP-55 casing, every other address this module reports comes out of
+        // a raw-bytes decode in lower case, and a consumer comparing `engine === config.engine` with
+        // `===` would fail on the mismatch alone.
+        engine = namedEngine.toLowerCase();
+        ingredients = [program];
+    }
+    catch {
+        try {
+            // v1 `SauceRouter.cook(bytes[])` — a DIFFERENT selector, so this is not a fallback that could
+            // reinterpret a v12 call; it only matches calldata the v12 fragment cannot decode at all.
+            const decoded = decodeFunctionData({ abi: COOK_V1_ABI, data: callData });
+            if (decoded.functionName !== "cook")
+                return null;
+            ingredients = decoded.args[0];
+        }
+        catch {
+            return null; // not a cook call (wrong selector / malformed calldata)
+        }
+    }
+    // ONLY ingredient 0. A v12 cook has exactly one program, so this is the whole call; a v1
+    // `SauceRouter` executes EVERY ingredient, and scanning further there would report a payload the
+    // caller did not ask about: given `cook([drainProgram, honestSettle])` a scan would skip the drain,
+    // validate the settle at index 1, and hand back the honest program's parameters for an intent that
+    // drains. `ingredientCount` is what makes the rest visible.
+    if (ingredients.length === 0)
+        return null;
+    try {
+        // An EMPTY list is forwarded, NOT swapped for the default. `validateSettleProgram([])` refuses,
+        // so this returns `null` -- fail-closed, matching that layer. Falling back to the built-in pin
+        // would be fail-OPEN: a caller whose configured accept-list resolved to empty would be told
+        // "this is the audited settle" against a trust anchor they never listed.
+        return {
+            ...validateSettleProgram(ingredients[0], ...(accepted ? [accepted] : [])),
+            ingredientIndex: 0,
+            ingredientCount: ingredients.length,
+            ...(engine === undefined ? {} : { engine }),
+        };
+    }
+    catch (error) {
+        // Only a DECODE failure means "this cook does not settle". A malformed pin -- a `{ hash: null }`
+        // from config -- would otherwise be swallowed as that, and every intent would report no settle
+        // while a monitor built on this went silently blind. Let a programmer error escape.
+        if (!(error instanceof SettleDecodeError))
+            throw error;
+        return null; // ingredient 0 is not a settle payload — this cook does not settle
+    }
+}
+/**
+ * Scans an intent's `route.calls[]` and returns the settle params from the first `cook` call carrying
+ * the settle payload — the EVM settle in a batch is a `Pot.cook(settleBytecodes)` alongside a
+ * `Pot.cook(swapBytecodes)`, so this finds it by CONTENT (which cook validates as settle), not by
+ * position. `null` if no call carries one.
+ *
+ * LOCATES THE SETTLE; DOES NOT CLEAR THE INTENT. Unlike a cook's sibling ingredients — where only
+ * ingredient 0 runs, so reading further would describe dead bytes — EVERY entry in `route.calls[]`
+ * executes. This returns the first entry that validates and leaves the others UNEXAMINED, so a
+ * non-null result answers "this intent contains the audited settle, with these parameters" and NOT
+ * "this intent does only that": in `[cook([drain]), cook([settle])]` the drain is real, executes
+ * first, and is not reported. A caller deciding whether an intent is safe must check `callIndex`
+ * against its own expectation and account for the remaining calls itself.
+ *
+ * AND IT MUST VALIDATE `target` AND `engine`. Matching is on a cook selector and the program bytes
+ * ONLY — nothing here looks at the callee or the interpreter.
+ *
+ * `target`: the one-program rule that makes a non-null result meaningful is a property of
+ * `V12Pot.cook`, so it says nothing about an arbitrary contract that merely exposes that selector.
+ * For `[{ target: attackerContract, data: cook(engine, canonicalSettlePayload) }]` this returns the
+ * correct `(tokens, minOut, recipient)` while the attacker's `cook` ignores the payload entirely.
+ * Compare it against a V12Pot address you trust; unvalidated, the parameters describe bytes that
+ * were handed to an unknown contract.
+ *
+ * `engine`: validating the program proves which BYTES run, not what runs them. The audited settle
+ * program on an attacker-chosen interpreter is an attacker-chosen computation, and the interpreter
+ * is a plain `cook` argument the producer picks. Compare it against your own allow-list,
+ * CASE-INSENSITIVELY — it is reported lower-cased here, and a checksummed constant will not match
+ * with `===`. It is `undefined` only for a v1 `SauceRouter.cook(bytes[])`, which names no engine.
+ *
+ * Both are carried on the result for exactly these checks. Neither is validated here, because only
+ * the caller knows which Pots and which interpreters it trusts.
+ */
+export function extractEvmSettleFromCalls(calls, accepted) {
+    for (let i = 0; i < calls.length; i++) {
+        const decoded = decodeSettleCall(calls[i].data, accepted);
+        if (decoded)
+            return { ...decoded, callIndex: i, target: calls[i].target };
+    }
+    return null;
+}
+/**
+ * Extracts the EVM settle params `(tokens, minOut, recipient)` from an intent object — the thin
+ * intent-level wrapper over `extractEvmSettleFromCalls`. Duck-typed on `{ route: { calls } }`, so it takes
+ * an eco-solver `Intent` (runtime or persisted) as-is. `null` if the intent carries no settle cook.
+ */
+export function extractEvmSettleFromIntent(intent, accepted) {
+    return extractEvmSettleFromCalls(intent.route.calls, accepted);
+}
+//# sourceMappingURL=intent.js.map

package/sdk/dist/verify/intent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"intent.js","sourceRoot":"","sources":["../../src/verify/intent.ts"],"names":[],"mappings":"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"}

package/sdk/dist/verify/vectors.d.ts

@@ -0,0 +1,86 @@
+import type { Hex } from "viem";
+import type { SettleFailureCode } from "./decode.js";
+/**
+ * The compiled `recipes/settle.sauce.ts` program — 362 bytes, measured by compiling it with the
+ * published Rust compiler (`@eco-incorp/sauce-compiler`) against the package's own
+ * `artifacts/IERC20.json`.
+ *
+ * ONE constant covers the whole corpus because the program is INVARIANT: `main` takes
+ * `(tokens, minOut, recipient)` as runtime entry arguments, so no caller value reaches the
+ * compiler. That is the property the appended-args model rests on, and `verify.compile.test.ts` recompiles
+ * this and compares — a LIVE pin, unlike the v1 corpus it replaces, whose compiler no longer exists.
+ */
+export declare const SETTLE_PROGRAM: Hex;
+export interface ConformanceVector {
+    name: string;
+    tokens: Hex[];
+    minOut: bigint;
+    recipient: Hex;
+    /** The canonical argument tail these values encode to. `settlePayload(args)` prepends the program. */
+    args: Hex;
+}
+/** The full on-the-wire payload for a vector's tail: `program || args`.
+ *
+ *  Exported from `./verify`, so it takes a caller's hex rather than only this file's literals: an
+ *  unprefixed tail would otherwise lose its first byte to the slice and resurface as a puzzling
+ *  `ARGS_TRUNCATED`, and a `0X` prefix — which the decoder itself tolerates — would produce garbage.
+ *  Requires the canonical `0x`, consistent with `encodeSettleProgram`'s inputs. */
+export declare function settlePayload(args: Hex): Hex;
+/**
+ * Golden wire-format vectors — the Go/Solidity/Python conformance corpus, and the definition of the
+ * layout for anyone reimplementing the decoder.
+ *
+ * Each `args` tail is proven by EXECUTION, not by construction: `verify-execution.e2e.test.ts` runs
+ * `settlePayload(v.args)` on a real v12 runtime against real ERC20s and asserts the engine sweeps
+ * exactly `v.tokens` to `v.recipient` under `v.minOut`. The bytes below are what the engine reads,
+ * not what this package's encoder happens to emit.
+ *
+ * `v3` carries `Z = 0x0000000000000000000000000000000000ff00aa` — the address the retired v1 corpus
+ * used as its trap, because a minimal-length PUSH squeezed it into 3 bytes and a fixed 20-byte read
+ * misframed everything after it. On THIS wire it is an ordinary 32-byte word: the layout is
+ * fixed-width, so leading zero bytes cost nothing and mean nothing. The hazard moved, and
+ * `SETTLE_REJECTIONS` is where it went.
+ */
+export declare const SETTLE_VECTORS: readonly ConformanceVector[];
+export interface RejectionVector {
+    name: string;
+    /** The non-canonical tail. `settlePayload(args)` makes the payload a decoder must refuse. */
+    args: Hex;
+    code: SettleFailureCode;
+    /** Whether a real v12 runtime ACCEPTS this payload — measured. Where it does, the rejection is
+     *  this decoder being stricter than the engine on purpose (decode.ts §4), and the vector is
+     *  load-bearing: a lax implementation would pass every other test in this corpus.
+     *
+     *  NOT SELF-VERIFYING for every row. The e2e filters on `sweepsIdentically`, so only those rows
+     *  re-measure themselves on chain each run. Any row that is `engineAccepts` WITHOUT
+     *  `sweepsIdentically` is asserted nowhere but here and would keep claiming it if the engine changed
+     *  — `SETTLE_REJECTIONS.filter(r => r.engineAccepts && !r.sweepsIdentically)` is that ledger, and the
+     *  suite pins it rather than this comment naming rows that then drift. Each is refused by the CALLEE
+     *  rather than the engine, so proving one needs a token fixture that skips the check in question;
+     *  without that, the engine's acceptance is invisible behind the revert. */
+    engineAccepts: boolean;
+    /** Whether the whole call then SUCCEEDS and moves the same tokens as the canonical payload, against
+     *  a standard solc ERC20. Distinct from `engineAccepts`, and the e2e's on-chain equivalence loop
+     *  filters on THIS: the engine can run a payload that the *callee* refuses, in which case the
+     *  identical-behavior claim holds only for tokens that do not perform the callee's check. */
+    sweepsIdentically: boolean;
+}
+/**
+ * Payloads a conformant decoder MUST refuse — the successor to the v1 corpus's `v3` trap.
+ *
+ * The `engineAccepts` rows are the trap proper, and they are the reason this corpus exists at all: the
+ * engine RUNS them and produces exactly the behavior of the canonical payload beside them, so they
+ * are distinct byte strings with identical meaning. A decoder that accepts any of them is not
+ * injective, and `encodeSettleProgram` re-encode-and-compare stops agreeing with decode-and-compare.
+ * `upperBytes` is the sharpest: the engine masks a call target to 160 bits, so twelve arbitrary
+ * bytes ride along in a token word and sweep the very same token.
+ *
+ * Each vector's `code` is reachable under ANY check order, so a Go or Solidity reimplementation is not
+ * required to match this decoder's sequence to pass. `tokensPointer` is the one that has to be built
+ * for that: its padding word is `0x02` so that the count read at the canonical offset agrees with the
+ * tail length, leaving the non-canonical pointer as the only complaint. A length-first decoder and a
+ * pointer-first decoder both report `TOKENS_OFFSET`. (The engine reads its array from offset 128, so
+ * that word is not in its read path -- `engineAccepts` is unaffected by its value.)
+ */
+export declare const SETTLE_REJECTIONS: readonly RejectionVector[];
+//# sourceMappingURL=vectors.d.ts.map

package/sdk/dist/verify/vectors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vectors.d.ts","sourceRoot":"","sources":["../../src/verify/vectors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAEhC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,EAAE,GACosB,CAAC;AAEluB,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,GAAG,EAAE,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,GAAG,CAAC;IACf,sGAAsG;IACtG,IAAI,EAAE,GAAG,CAAC;CACX;AAED;;;;;mFAKmF;AACnF,wBAAgB,aAAa,CAAC,IAAI,EAAE,GAAG,GAAG,GAAG,CAQ5C;AAQD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,cAAc,EAAE,SAAS,iBAAiB,EAsBtD,CAAC;AAEF,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,6FAA6F;IAC7F,IAAI,EAAE,GAAG,CAAC;IACV,IAAI,EAAE,iBAAiB,CAAC;IACxB;;;;;;;;;;gFAU4E;IAC5E,aAAa,EAAE,OAAO,CAAC;IACvB;;;iGAG6F;IAC7F,iBAAiB,EAAE,OAAO,CAAC;CAC5B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,iBAAiB,EAAE,SAAS,eAAe,EA4DvD,CAAC"}

package/sdk/dist/verify/vectors.js

@@ -0,0 +1,145 @@
+/**
+ * The compiled `recipes/settle.sauce.ts` program — 362 bytes, measured by compiling it with the
+ * published Rust compiler (`@eco-incorp/sauce-compiler`) against the package's own
+ * `artifacts/IERC20.json`.
+ *
+ * ONE constant covers the whole corpus because the program is INVARIANT: `main` takes
+ * `(tokens, minOut, recipient)` as runtime entry arguments, so no caller value reaches the
+ * compiler. That is the property the appended-args model rests on, and `verify.compile.test.ts` recompiles
+ * this and compares — a LIVE pin, unlike the v1 corpus it replaces, whose compiler no longer exists.
+ */
+export const SETTLE_PROGRAM = "0xa50201cad1514702000eb19000b6d002016a0120955402016a21d1d1d00120d4212295540240000120d22348020033b19000b60120d123012021d221d35147020046b19000b6d0012023d08a04ffffffff30e10120340a9220000000000000000031310100d2d146020070b10200adb00120d4210120d223e1210120d5210120d3230120e1e1e22121d3d3d151d14642020167b1d8e1e2e3e4d0e1e2e3e4e52295549b0101d121e1e0020065b0d402018a01209554e1e2e3e4e50201aa012095540100d4970100e1649401a0900470a082319602a3a10120970100d348020107b1d2d147020107b1901c736574746c653a2062616c616e63652062656c6f77206d696e4f7574b60100d551d146020115b1020158b0d0d6970100d1649401a0900470a082319602a3a10120970100d14802014cb10100d20100d3d89402a09004a9059cbb9602a2a1012097e00101d321e3e0e0e0020109b0e101208ae1d18905200000000031009000b6";
+/** The full on-the-wire payload for a vector's tail: `program || args`.
+ *
+ *  Exported from `./verify`, so it takes a caller's hex rather than only this file's literals: an
+ *  unprefixed tail would otherwise lose its first byte to the slice and resurface as a puzzling
+ *  `ARGS_TRUNCATED`, and a `0X` prefix — which the decoder itself tolerates — would produce garbage.
+ *  Requires the canonical `0x`, consistent with `encodeSettleProgram`'s inputs. */
+export function settlePayload(args) {
+    if (typeof args !== "string" || !/^0x([0-9a-fA-F]{2})*$/.test(args)) {
+        throw new RangeError(`settlePayload: args must be 0x-prefixed hex of whole bytes, got ${String(args)}`);
+    }
+    return (SETTLE_PROGRAM + args.slice(2));
+}
+const U = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"; // Base USDC
+const W = "0x4200000000000000000000000000000000000006"; // Base WETH
+const Z = "0x0000000000000000000000000000000000ff00aa"; // an address with leading zero bytes
+const D = "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb"; // Base DAI
+const B = "0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf"; // Base cbBTC
+/**
+ * Golden wire-format vectors — the Go/Solidity/Python conformance corpus, and the definition of the
+ * layout for anyone reimplementing the decoder.
+ *
+ * Each `args` tail is proven by EXECUTION, not by construction: `verify-execution.e2e.test.ts` runs
+ * `settlePayload(v.args)` on a real v12 runtime against real ERC20s and asserts the engine sweeps
+ * exactly `v.tokens` to `v.recipient` under `v.minOut`. The bytes below are what the engine reads,
+ * not what this package's encoder happens to emit.
+ *
+ * `v3` carries `Z = 0x0000000000000000000000000000000000ff00aa` — the address the retired v1 corpus
+ * used as its trap, because a minimal-length PUSH squeezed it into 3 bytes and a fixed 20-byte read
+ * misframed everything after it. On THIS wire it is an ordinary 32-byte word: the layout is
+ * fixed-width, so leading zero bytes cost nothing and mean nothing. The hazard moved, and
+ * `SETTLE_REJECTIONS` is where it went.
+ */
+export const SETTLE_VECTORS = [
+    {
+        name: "v1 — single token, minOut disabled",
+        tokens: [U],
+        minOut: 0n,
+        recipient: W,
+        args: "0x0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000042000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000001000000000000000000000000833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+    },
+    {
+        name: "v2 — two tokens, large minOut",
+        tokens: [U, W],
+        minOut: 1234567890123456789012n,
+        recipient: W,
+        args: "0x0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000042ed123b0bd8203a1400000000000000000000000042000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000002000000000000000000000000833589fcd6edb6e08f4c7c32d4f71b54bda029130000000000000000000000004200000000000000000000000000000000000006",
+    },
+    {
+        name: "v3 — five tokens, leading-zero-byte addresses in both a token slot and the recipient",
+        tokens: [Z, U, W, D, B],
+        minOut: 1n,
+        recipient: Z,
+        args: "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000ff00aa00000000000000000000000000000000000000000000000000000000000000050000000000000000000000000000000000000000000000000000000000ff00aa000000000000000000000000833589fcd6edb6e08f4c7c32d4f71b54bda02913000000000000000000000000420000000000000000000000000000000000000600000000000000000000000050c5725949a6f0c72e6c4a641f24049a917db0cb000000000000000000000000cbb7c0000ab88b473b1f5afd9ef808440eed33bf",
+    },
+];
+/**
+ * Payloads a conformant decoder MUST refuse — the successor to the v1 corpus's `v3` trap.
+ *
+ * The `engineAccepts` rows are the trap proper, and they are the reason this corpus exists at all: the
+ * engine RUNS them and produces exactly the behavior of the canonical payload beside them, so they
+ * are distinct byte strings with identical meaning. A decoder that accepts any of them is not
+ * injective, and `encodeSettleProgram` re-encode-and-compare stops agreeing with decode-and-compare.
+ * `upperBytes` is the sharpest: the engine masks a call target to 160 bits, so twelve arbitrary
+ * bytes ride along in a token word and sweep the very same token.
+ *
+ * Each vector's `code` is reachable under ANY check order, so a Go or Solidity reimplementation is not
+ * required to match this decoder's sequence to pass. `tokensPointer` is the one that has to be built
+ * for that: its padding word is `0x02` so that the count read at the canonical offset agrees with the
+ * tail length, leaving the non-canonical pointer as the only complaint. A length-first decoder and a
+ * pointer-first decoder both report `TOKENS_OFFSET`. (The engine reads its array from offset 128, so
+ * that word is not in its read path -- `engineAccepts` is unaffected by its value.)
+ */
+export const SETTLE_REJECTIONS = [
+    {
+        name: "tokensPointer — 0x80 with a padding word, instead of the canonical 0x60",
+        args: "0x00000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000420000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000001000000000000000000000000833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+        code: "TOKENS_OFFSET",
+        engineAccepts: true,
+        sweepsIdentically: true,
+    },
+    {
+        name: "trailingSlack — a canonical tail with 32 zero bytes appended",
+        args: "0x0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000042000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000001000000000000000000000000833589fcd6edb6e08f4c7c32d4f71b54bda029130000000000000000000000000000000000000000000000000000000000000000",
+        code: "ARGS_OVERLONG",
+        engineAccepts: true,
+        sweepsIdentically: true,
+    },
+    {
+        name: "upperBytes — tokens[0] carries 0xff in all 12 bytes above its address",
+        args: "0x0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000042000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000001ffffffffffffffffffffffff833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+        code: "DIRTY_ADDRESS_WORD",
+        engineAccepts: true,
+        sweepsIdentically: true,
+    },
+    {
+        name: "dirtyRecipient — the recipient word carries 0xff above its address",
+        args: "0x00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff42000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000001000000000000000000000000833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+        code: "DIRTY_ADDRESS_WORD",
+        // The engine passes the RECIPIENT word through unmasked -- unlike a token word, which it masks as
+        // a CALL target -- so it executes this payload and emits `a9059cbb <dirty recipient> ...`. The
+        // revert against a solc ERC20 is that callee's own dirty-`address` ABI check, not the engine's.
+        // A token that does not perform it (Vyper, older solc, a raw-forwarding proxy) delivers to the
+        // same recipient as the canonical payload, which is the non-injectivity §4 exists to refuse.
+        engineAccepts: true,
+        sweepsIdentically: false,
+    },
+    {
+        name: "shortArray — count says 2, one element word present",
+        args: "0x0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000042000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000002000000000000000000000000833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+        code: "ARGS_TRUNCATED",
+        engineAccepts: false,
+        sweepsIdentically: false,
+    },
+    {
+        name: "zeroRecipient — the recipient word is 0",
+        args: "0x0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+        code: "ZERO_RECIPIENT",
+        // Same fact as `dirtyRecipient`, not a separate measurement: the engine passes the recipient word
+        // through unmasked and performs no check on it, so zero is simply another value of that word --
+        // there is no mechanism by which the engine would single it out. A standard solc ERC20's own
+        // zero-address check in `_transfer` is what refuses this; a callee that permits it sends the
+        // tokens to address(0).
+        engineAccepts: true,
+        sweepsIdentically: false,
+    },
+    {
+        name: "emptyArray — count is 0, so there is no floor token",
+        args: "0x0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000042000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000",
+        code: "TOKENS_EMPTY",
+        engineAccepts: false,
+        sweepsIdentically: false,
+    },
+];
+//# sourceMappingURL=vectors.js.map

package/sdk/dist/verify/vectors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vectors.js","sourceRoot":"","sources":["../../src/verify/vectors.ts"],"names":[],"mappings":"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"}

package/sdk/dist/verify/wire.d.ts

@@ -0,0 +1,44 @@
+/** Wire-format constants for the settle payload on engine target v12. */
+export declare const SETTLE_WIRE: {
+    /** Byte length of the compiled `settle.sauce.ts` program. It is INVARIANT: the program takes its
+     *  `(tokens, minOut, recipient)` as runtime entry arguments, so nothing about the caller's values
+     *  reaches the compiler. This length is what locates the argument tail. */
+    readonly PROGRAM_BYTES: 362;
+    /** Which compiler produced the bytes `PROGRAM_HASH` pins. The dependency is a caret range, and on
+     *  `^2.0.0` that is the whole `2.x` line — a far wider window than the `0.7.x` a `^0.7.0` caret
+     *  admitted, since a caret on `0.x` pins the minor. Any `2.x` that changes codegen makes a
+     *  consumer's own compile fail that pin; the fix then is to re-pin all three of these, not to
+     *  loosen the check. `verify.compile.test.ts` asserts this
+     *  exact version against the resolved package, so it cannot silently describe a producer that never
+     *  ran — and it must be asserted against the version EVERY workspace resolves, since a bump in one
+     *  package.json leaves this string describing a compiler no consumer runs.
+     *
+     *  0.5.0 → 0.7.0 moved these bytes: 391 → 370, with a different hash. A consumer on the newer
+     *  compiler and the older pin has every settle it produces rejected on `PROGRAM_HASH`, which is why
+     *  the bump and the re-pin are one change. Intents published against the old hash still verify —
+     *  pass it via `validateSettleProgram`'s accepted-hash set.
+     *
+     *  0.7.0 → 1.0.0 did NOT move them, despite carrying ABI type widths through both codec
+     *  directions, and neither did 1.0.0 → 2.0.0 — whose major is an artifact of the release config
+     *  rather than a compiler change. 2.0.0 → 2.1.0 DID: 370 → 363, on the element/field write
+     *  boxing change. 2.1.0 → 2.2.0 DID too: 363 → 362, on the UNPACK opcode and the entry-argument
+     *  lowering it came with. So a compiler bump is not evidence either way: this string changes
+     *  every time, the hash only when the output does, and the tests above tell them apart. */
+    readonly PROGRAM_COMPILER: "@eco-incorp/sauce-compiler@2.2.0";
+    /** `keccak256` of those `PROGRAM_BYTES` bytes — the authenticity pin `validateSettleProgram`
+     *  enforces, and the reason a matching payload runs the audited program and nothing else.
+     *  Whole-program, not a body slice: program and arguments are disjoint byte regions on this wire.
+     *  `verify.compile.test.ts` recomputes it from source every run and fails before any consumer does. */
+    readonly PROGRAM_HASH: "0x2da5c63da0ed3e934f4bb09985a38723de1f2a8e9a9a97ef3993e526cb649d11";
+    /** Every argument word is 32 bytes, big-endian. */
+    readonly WORD_BYTES: 32;
+    /** An address occupies the LOW 20 bytes of its word; the upper 12 MUST be zero (§4). */
+    readonly ADDRESS_BYTES: 20;
+    /** The three head slots — `tokens` pointer, `minOut`, `recipient` — ahead of the token array. */
+    readonly HEAD_SLOTS: 3;
+    /** `HEAD_SLOTS * WORD_BYTES`. Also the ONLY legal value of the `tokens` pointer: the array data
+     *  follows the head immediately, so the pointer is a constant on a canonical payload even though
+     *  the engine would follow any offset. */
+    readonly HEAD_BYTES: 96;
+};
+//# sourceMappingURL=wire.d.ts.map

package/sdk/dist/verify/wire.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wire.d.ts","sourceRoot":"","sources":["../../src/verify/wire.ts"],"names":[],"mappings":"AAkBA,yEAAyE;AACzE,eAAO,MAAM,WAAW;IACtB;;+EAE2E;;IAE3E;;;;;;;;;;;;;;;;;;;+FAmB2F;;IAE3F;;;2GAGuG;;IAEvG,mDAAmD;;IAEnD,wFAAwF;;IAExF,iGAAiG;;IAEjG;;8CAE0C;;CAElC,CAAC"}

package/sdk/dist/verify/wire.js

@@ -0,0 +1,61 @@
+// SAUCE SETTLE PAYLOAD WIRE FORMAT — the byte-level constants a partner needs to implement the
+// check in ANY language (Go/Solidity/Python), independent of this package. See decode.ts's module
+// docstring for the full layout; this file carries only the numbers.
+//
+// Every value here was MEASURED against the published Rust compiler's actual emission for
+// `recipes/settle.sauce.ts` and against a real v12 runtime executing it — none is a choice.
+//
+// GONE WITH THE v1 GRAMMAR: `scanMinimalPush` / `encodeMinimalPush` / `PushScanResult`. Those
+// decoded the retired TypeScript compiler's `L || data[L]` argument pushes. The arguments no longer
+// live in the program at all — they ride a fixed-width 32-byte-word tail — so there is no push to
+// scan and no minimality to enforce. The uniqueness those checks bought is now bought by the fixed
+// layout itself, plus `HEAD_BYTES` and the zero-upper-bytes rule (decode.ts, §4).
+//
+// ALSO GONE FROM `SETTLE_WIRE` in that change: `TUPLE_OP`, `PUSH_MIN`, `PUSH_MAX`, `MAX_ARITY`. All
+// four described that same prologue — there are no pushes to bound and no arity to cap when every
+// value is a fixed 32-byte word. A build breaking on one of them wants `PROGRAM_BYTES`, `WORD_BYTES`
+// or `HEAD_BYTES` instead. This is a breaking change to the published `./verify` subpath.
+/** Wire-format constants for the settle payload on engine target v12. */
+export const SETTLE_WIRE = {
+    /** Byte length of the compiled `settle.sauce.ts` program. It is INVARIANT: the program takes its
+     *  `(tokens, minOut, recipient)` as runtime entry arguments, so nothing about the caller's values
+     *  reaches the compiler. This length is what locates the argument tail. */
+    PROGRAM_BYTES: 362,
+    /** Which compiler produced the bytes `PROGRAM_HASH` pins. The dependency is a caret range, and on
+     *  `^2.0.0` that is the whole `2.x` line — a far wider window than the `0.7.x` a `^0.7.0` caret
+     *  admitted, since a caret on `0.x` pins the minor. Any `2.x` that changes codegen makes a
+     *  consumer's own compile fail that pin; the fix then is to re-pin all three of these, not to
+     *  loosen the check. `verify.compile.test.ts` asserts this
+     *  exact version against the resolved package, so it cannot silently describe a producer that never
+     *  ran — and it must be asserted against the version EVERY workspace resolves, since a bump in one
+     *  package.json leaves this string describing a compiler no consumer runs.
+     *
+     *  0.5.0 → 0.7.0 moved these bytes: 391 → 370, with a different hash. A consumer on the newer
+     *  compiler and the older pin has every settle it produces rejected on `PROGRAM_HASH`, which is why
+     *  the bump and the re-pin are one change. Intents published against the old hash still verify —
+     *  pass it via `validateSettleProgram`'s accepted-hash set.
+     *
+     *  0.7.0 → 1.0.0 did NOT move them, despite carrying ABI type widths through both codec
+     *  directions, and neither did 1.0.0 → 2.0.0 — whose major is an artifact of the release config
+     *  rather than a compiler change. 2.0.0 → 2.1.0 DID: 370 → 363, on the element/field write
+     *  boxing change. 2.1.0 → 2.2.0 DID too: 363 → 362, on the UNPACK opcode and the entry-argument
+     *  lowering it came with. So a compiler bump is not evidence either way: this string changes
+     *  every time, the hash only when the output does, and the tests above tell them apart. */
+    PROGRAM_COMPILER: "@eco-incorp/sauce-compiler@2.2.0",
+    /** `keccak256` of those `PROGRAM_BYTES` bytes — the authenticity pin `validateSettleProgram`
+     *  enforces, and the reason a matching payload runs the audited program and nothing else.
+     *  Whole-program, not a body slice: program and arguments are disjoint byte regions on this wire.
+     *  `verify.compile.test.ts` recomputes it from source every run and fails before any consumer does. */
+    PROGRAM_HASH: "0x2da5c63da0ed3e934f4bb09985a38723de1f2a8e9a9a97ef3993e526cb649d11",
+    /** Every argument word is 32 bytes, big-endian. */
+    WORD_BYTES: 32,
+    /** An address occupies the LOW 20 bytes of its word; the upper 12 MUST be zero (§4). */
+    ADDRESS_BYTES: 20,
+    /** The three head slots — `tokens` pointer, `minOut`, `recipient` — ahead of the token array. */
+    HEAD_SLOTS: 3,
+    /** `HEAD_SLOTS * WORD_BYTES`. Also the ONLY legal value of the `tokens` pointer: the array data
+     *  follows the head immediately, so the pointer is a constant on a canonical payload even though
+     *  the engine would follow any offset. */
+    HEAD_BYTES: 96,
+};
+//# sourceMappingURL=wire.js.map

package/sdk/dist/verify/wire.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wire.js","sourceRoot":"","sources":["../../src/verify/wire.ts"],"names":[],"mappings":"AAAA,+FAA+F;AAC/F,kGAAkG;AAClG,qEAAqE;AACrE,EAAE;AACF,0FAA0F;AAC1F,4FAA4F;AAC5F,EAAE;AACF,8FAA8F;AAC9F,oGAAoG;AACpG,kGAAkG;AAClG,mGAAmG;AACnG,kFAAkF;AAClF,EAAE;AACF,oGAAoG;AACpG,kGAAkG;AAClG,qGAAqG;AACrG,0FAA0F;AAE1F,yEAAyE;AACzE,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB;;+EAE2E;IAC3E,aAAa,EAAE,GAAG;IAClB;;;;;;;;;;;;;;;;;;;+FAmB2F;IAC3F,gBAAgB,EAAE,kCAAkC;IACpD;;;2GAGuG;IACvG,YAAY,EAAE,oEAAoE;IAClF,mDAAmD;IACnD,UAAU,EAAE,EAAE;IACd,wFAAwF;IACxF,aAAa,EAAE,EAAE;IACjB,iGAAiG;IACjG,UAAU,EAAE,CAAC;IACb;;8CAE0C;IAC1C,UAAU,EAAE,EAAE;CACN,CAAC"}