@eco-incorp/sauce 0.99.0

package/sdk/dist/recipes/plain-transfer.sauce.ts

@@ -0,0 +1,14 @@
+/**
+ * plain-transfer — the no-bridge baseline: move `XFER_AMOUNT` USDC to `XFER_RECIPIENT` in one call.
+ * Same standalone-asset shape as `cctp-split.sauce.ts`: the two consts below carry placeholder
+ * defaults and the builder overrides them per intent via `defines`, which are constant-folded into
+ * fixed bytecode. `USDC` resolves from the token registry. Declarations unannotated for the same
+ * acorn-based-rewrite reason documented there.
+ */
+const XFER_RECIPIENT = 0n;
+const XFER_AMOUNT = 0n;
+
+function main() {
+  USDC.transfer(XFER_RECIPIENT, XFER_AMOUNT);
+  return 0n;
+}

package/sdk/dist/recipes/settle.sauce.ts

@@ -0,0 +1,101 @@
+import { IERC20 } from "./artifacts/IERC20.json";
+
+// settle.sauce.ts — a STANDALONE, reusable Sauce program: sweep the Pot's balance of a list of
+// tokens to one recipient, with a minimum-output floor enforced on the first token.
+//
+// It is deliberately NOT tied to any recipe, protocol or product. Nothing in the program below
+// knows what produced the balances it moves — a swap, a bridge, an airdrop, a manual transfer, or
+// nothing at all. Its contract is exactly "these tokens, this floor, this recipient", so any caller
+// that needs a Pot emptied to a destination can compile and run it. Keep it that way: no
+// caller-specific names, in the code OR in the revert string (the string is inside the compiled
+// program, so changing it rotates SETTLE_WIRE.PROGRAM_HASH — see sdk/src/verify/wire.ts).
+//
+// COMPOSING IT AFTER ANOTHER PROGRAM (the common case, and the reason the floor exists): a
+// V12Pot.cook runs exactly ONE program, so ONE cook cannot run
+// "do the thing, then sweep". That composition is TWO TOP-LEVEL cook() calls joined by an
+// owner-authorised multicall in ONE transaction:
+//   multicall → [ Pot.cook(engine, producerProgram) , Pot.cook(engine, sweepProgram) ]
+// The multicall contract MUST be this Pot's `owner` (V12Pot.cook is
+// `msg.sender == owner || msg.sender == address(this)`-gated — there is no third path) and MUST
+// propagate a reverting call's revert data rather than swallow it (a non-reverting/tryAggregate
+// dispatch turns a sweep failure into "the first cook landed, the recipient got nothing").
+// SECURITY: the multicall must NEVER be a permissionless batcher. Multicall3's `aggregate3` CALLs
+// from its own address, so if it owned a Pot, any address could call
+// `aggregate3([{target: pot, callData: cook([drainProgram])}])` and drain it — owning the batcher
+// IS owning the Pot. The operator's batcher must be owner-controlled (see OwnerMulticall.sol,
+// this repo's test-only reference fixture for the shape a real deployment needs).
+//
+// COMPILED BY THE ORDINARY COMPILER — see `sdk/src/recipes/index.ts` for the exact snippet and
+// options. This file is the ONE source of truth for the program text; consumers compile it rather
+// than keeping a second copy. `sdk/src/verify/` itself is the DECODING / authenticity surface (turn
+// a payload's bytes back into `(tokens, minOut, recipient)` and prove the program half is this
+// audited template); the program source lives here, outside it, because a reusable program is not a
+// verification concern.
+//
+// THE COMPILED PROGRAM IS A FUNCTION OF THIS FILE AND THE COMPILER PIN ONLY — never of the
+// arguments. `main`'s three parameters below are RUNTIME ENTRY ARGUMENTS: the caller appends them
+// to the compiled program as 32-byte words and the program reads them back through CALLDATA, so no
+// value a caller picks is visible to the compiler at all. One 362-byte blob therefore serves every
+// token list, floor and recipient, which is what lets `sdk/src/verify/` pin a single
+// `keccak256(program)` and still report per-payload params.
+//
+// KEEP THEM PARAMETERS. Moving any of the three to a compile-time `define` would fold it into the
+// program and make the bytes vary per caller — the pinned-hash design would collapse, and the whole
+// `/verify` surface with it.
+//
+// THE SHAPE: `main(tokens, minOut, recipient)` sweeps the Pot's CURRENT balance of EVERY token in
+// `tokens` to `recipient` — a full-balance sweep is the EXPLICIT INTENT (not a hazard to guard
+// against): after this cook lands, the Pot holds none of the listed tokens. `tokens[0]` is the
+// FLOOR TOKEN by POSITION (not a separately-named arg) — chosen over a named field because the
+// decoded shape this way is exactly `(tokens[], minOut, recipient)`, the same three values the
+// caller compiled it with, with no fourth field that could itself drift out of sync with which
+// array slot it names. `minOut` is enforced against tokens[0]'s balance BEFORE any transfer runs,
+// so an unmeetable floor reverts the WHOLE sweep cook (and, when composed with another cook in one
+// transaction, that whole transaction) before anything moves.
+//
+// USEFUL ORDERING PROPERTY: tokens[0] is swept FIRST, and no external call runs between the floor
+// check and that transfer — so for the floor token the amount CHECKED is the amount TRANSFERRED. A
+// hostile token later in the list cannot retroactively affect it, and a duplicate entry is a no-op
+// on its second pass (its balance is already 0).
+//
+// KNOWN PROPERTY, DOCUMENTED AND ACCEPTED — NOT DEFENDED AGAINST: the floor and the sweep both
+// read the Pot's CURRENT balance, not a delta against some baseline. A pre-existing or donated
+// balance of tokens[0] in the Pot therefore counts toward minOut and rides to the recipient along
+// with whatever the caller actually produced. This is a consequence of the sweep model the
+// maintainer chose (the Pot ending clean is the point), not an oversight — do not add baseline/
+// delta machinery to defend against it.
+//
+// A given execution's `tokens`/`minOut`/`recipient` arrive as RUNTIME ENTRY ARGUMENTS, appended after
+// the program as 32-byte words (see `verify/decode.ts` for the layout) — there is no
+// cross-cook or cross-program handoff of any kind (an earlier design used a tagged EIP-1153
+// transient-storage handoff between two cooks; the sweep model made it unnecessary — this program
+// simply carries its own destination and floor, and reads only the Pot's live balances). Running it
+// on its own, against a Pot holding nothing, sweeps whatever is there (0, ordinarily) — there is
+// nothing to "orphan" against, since its target and floor are self-contained.
+//
+// THE DECODER (sdk/src/verify/decode.ts's decodeSettleProgram/validateSettleProgram): a payload is
+// `program || args`, and the two regions are disjoint. decodeSettleProgram pins the program's
+// LENGTH and reads the argument tail — three 32-byte head words (a pointer to the token array,
+// `minOut`, `recipient`) followed by the array's count and its elements — so it names the values a
+// payload will run with. validateSettleProgram adds `keccak256` over the WHOLE program against the
+// pinned hash, which is a COMPLETE authenticity answer here: a program carrying different or extra
+// behaviour (say, sweeping to a hardcoded address instead of the supplied `recipient`) is different
+// bytes, so it fails the hash. There is no body/prologue split to reason about any more, and no
+// argument-independent suffix to hash separately — the whole program is argument-independent.
+function main(tokens: Address[], minOut: Uint256, recipient: Address): Uint256 {
+  const floorToken = IERC20.at(tokens[0]);
+  const floorBal: Uint256 = floorToken.balanceOf(ctx.self());
+  if (minOut > 0) {
+    if (floorBal < minOut) {
+      throw "settle: balance below minOut";
+    }
+  }
+  for (let i = 0; i < tokens.length; i = i + 1) {
+    const t = IERC20.at(tokens[i]);
+    const bal: Uint256 = t.balanceOf(ctx.self());
+    if (bal > 0) {
+      t.transfer(recipient, bal);
+    }
+  }
+  return floorBal;
+}

package/sdk/dist/routes/accessor-index.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Registry-derived name index for the protocol-accessor rewrite (`protocol-rewrite.ts`): which
+ * identifiers are "namespace keys" (a protocol's PascalCase key or a family alias) vs "chain keys"
+ * (`PascalOf(chain.slug)`), and what each namespace key resolves to.
+ *
+ * Built once at module eval from `descriptors/registry.ts#DESCRIPTORS` + `chains/canonical.js`'s
+ * `canonicalChains` — holds no data of its own. This mirrors the SAME `protocolGroups`/
+ * `familyMembers` construction `descriptors/accessors.ts` already does internally for its own lazy
+ * accessor tree (not exported there, so this is a second, independently-built index rather than a
+ * re-export) — kept in lockstep by construction, since both derive from the identical rule:
+ * `PascalOf(protocol slug)` for the canonical key, `PascalOf(-v<N>-stripped stem)` for a family
+ * alias.
+ *
+ * Fails closed at module-eval time (not merely documented) if a namespace key and a chain key ever
+ * collide -- shape A/B (namespace-rooted) and shape C/D (chain-rooted) are only unambiguous while
+ * that intersection stays empty.
+ */
+import { type ChainSlug } from "../chains/canonical.js";
+import type { ContractDescriptor } from "../descriptors/types.js";
+export interface ProtocolNamespace {
+    readonly kind: "protocol";
+    readonly protocol: string;
+    readonly contracts: ReadonlyMap<string, ContractDescriptor>;
+    /** Set iff exactly one contract is linked under this protocol -- shape B's ("<Protocol>.<method>")
+     *  only source of a default contract. */
+    readonly defaultContract?: string;
+}
+export interface FamilyNamespace {
+    readonly kind: "family";
+    readonly familyKey: string;
+    readonly members: readonly string[];
+    /** contract name -> owning protocol slug(s); length > 1 means ambiguous under this family. */
+    readonly contractOwners: ReadonlyMap<string, readonly string[]>;
+}
+export type Namespace = ProtocolNamespace | FamilyNamespace;
+export declare function resolveNamespace(key: string): Namespace | undefined;
+export declare function isChainKey(key: string): boolean;
+export declare function chainSlugForKey(key: string): ChainSlug | undefined;
+/** Exposed for tests pinning the registry-derived coverage invariants (M14-style). */
+export declare const NAMESPACE_KEYS: ReadonlySet<string>;
+export declare const CHAIN_KEY_SET: ReadonlySet<string>;
+//# sourceMappingURL=accessor-index.d.ts.map

package/sdk/dist/routes/accessor-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accessor-index.d.ts","sourceRoot":"","sources":["../../src/routes/accessor-index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EAAmB,KAAK,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAEzE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAGlE,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;IAC5D;6CACyC;IACzC,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;CACnC;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,8FAA8F;IAC9F,QAAQ,CAAC,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC;CACjE;AAED,MAAM,MAAM,SAAS,GAAG,iBAAiB,GAAG,eAAe,CAAC;AAiF5D,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAEnE;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAE/C;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAElE;AAED,sFAAsF;AACtF,eAAO,MAAM,cAAc,EAAE,WAAW,CAAC,MAAM,CAA8B,CAAC;AAC9E,eAAO,MAAM,aAAa,EAAE,WAAW,CAAC,MAAM,CAA8B,CAAC"}

package/sdk/dist/routes/accessor-index.js

@@ -0,0 +1,108 @@
+/**
+ * Registry-derived name index for the protocol-accessor rewrite (`protocol-rewrite.ts`): which
+ * identifiers are "namespace keys" (a protocol's PascalCase key or a family alias) vs "chain keys"
+ * (`PascalOf(chain.slug)`), and what each namespace key resolves to.
+ *
+ * Built once at module eval from `descriptors/registry.ts#DESCRIPTORS` + `chains/canonical.js`'s
+ * `canonicalChains` — holds no data of its own. This mirrors the SAME `protocolGroups`/
+ * `familyMembers` construction `descriptors/accessors.ts` already does internally for its own lazy
+ * accessor tree (not exported there, so this is a second, independently-built index rather than a
+ * re-export) — kept in lockstep by construction, since both derive from the identical rule:
+ * `PascalOf(protocol slug)` for the canonical key, `PascalOf(-v<N>-stripped stem)` for a family
+ * alias.
+ *
+ * Fails closed at module-eval time (not merely documented) if a namespace key and a chain key ever
+ * collide -- shape A/B (namespace-rooted) and shape C/D (chain-rooted) are only unambiguous while
+ * that intersection stays empty.
+ */
+import { canonicalChains } from "../chains/canonical.js";
+import { DESCRIPTORS } from "../descriptors/registry.js";
+import { pascalOfSlug } from "./builder.js";
+/** `"uniswap-v4"` -> `"uniswap"`; a slug with no trailing `-v<N>` yields `undefined`. */
+function familyStem(slug) {
+    const m = /^(.+)-v\d+$/.exec(slug);
+    return m ? m[1] : undefined;
+}
+const protocolGroups = new Map();
+for (const d of DESCRIPTORS) {
+    const list = protocolGroups.get(d.protocol);
+    if (list)
+        list.push(d);
+    else
+        protocolGroups.set(d.protocol, [d]);
+}
+const NAMESPACES = new Map();
+for (const [slug, descriptors] of protocolGroups) {
+    const key = pascalOfSlug(slug);
+    if (NAMESPACES.has(key)) {
+        throw new Error(`accessor-index: duplicate protocol namespace '${key}' (from slug '${slug}')`);
+    }
+    const contracts = new Map();
+    for (const d of descriptors)
+        contracts.set(d.contract, d);
+    // Shape B's default excludes kind:"address-only" contracts -- they have no ABI/methods at all, so
+    // they could never be the target of a bare `<Protocol>.<method>(...)` call anyway.
+    const callable = descriptors.filter((d) => d.kind !== "address-only");
+    NAMESPACES.set(key, {
+        kind: "protocol",
+        protocol: slug,
+        contracts,
+        defaultContract: callable.length === 1 ? callable[0].contract : undefined,
+    });
+}
+const familyMembersBySlug = new Map();
+for (const slug of protocolGroups.keys()) {
+    const stem = familyStem(slug);
+    if (stem === undefined)
+        continue;
+    const key = pascalOfSlug(stem);
+    const list = familyMembersBySlug.get(key);
+    if (list)
+        list.push(slug);
+    else
+        familyMembersBySlug.set(key, [slug]);
+}
+for (const [familyKey, members] of familyMembersBySlug) {
+    if (NAMESPACES.has(familyKey)) {
+        throw new Error(`accessor-index: family alias '${familyKey}' collides with a canonical protocol namespace`);
+    }
+    const contractOwners = new Map();
+    for (const slug of members) {
+        for (const d of protocolGroups.get(slug) ?? []) {
+            const owners = contractOwners.get(d.contract);
+            if (owners)
+                owners.push(slug);
+            else
+                contractOwners.set(d.contract, [slug]);
+        }
+    }
+    NAMESPACES.set(familyKey, { kind: "family", familyKey, members, contractOwners });
+}
+/** PascalCase chain key -> chain slug. */
+const CHAIN_KEYS = (() => {
+    const map = new Map();
+    for (const c of canonicalChains) {
+        map.set(pascalOfSlug(c.slug), c.slug);
+    }
+    return map;
+})();
+// Fail closed: measured/asserted disjointness, not assumed (see the module doc).
+for (const key of NAMESPACES.keys()) {
+    if (CHAIN_KEYS.has(key)) {
+        throw new Error(`accessor-index: namespace key '${key}' collides with a chain key -- the protocol-accessor ` +
+            "rewrite requires these two key sets to be disjoint");
+    }
+}
+export function resolveNamespace(key) {
+    return NAMESPACES.get(key);
+}
+export function isChainKey(key) {
+    return CHAIN_KEYS.has(key);
+}
+export function chainSlugForKey(key) {
+    return CHAIN_KEYS.get(key);
+}
+/** Exposed for tests pinning the registry-derived coverage invariants (M14-style). */
+export const NAMESPACE_KEYS = new Set(NAMESPACES.keys());
+export const CHAIN_KEY_SET = new Set(CHAIN_KEYS.keys());
+//# sourceMappingURL=accessor-index.js.map

package/sdk/dist/routes/accessor-index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"accessor-index.js","sourceRoot":"","sources":["../../src/routes/accessor-index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EAAE,eAAe,EAAkB,MAAM,wBAAwB,CAAC;AACzE,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAEzD,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAqB5C,yFAAyF;AACzF,SAAS,UAAU,CAAC,IAAY;IAC9B,MAAM,CAAC,GAAG,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACnC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AAC9B,CAAC;AAED,MAAM,cAAc,GAAG,IAAI,GAAG,EAAgC,CAAC;AAC/D,KAAK,MAAM,CAAC,IAAI,WAAW,EAAE,CAAC;IAC5B,MAAM,IAAI,GAAG,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;IAC5C,IAAI,IAAI;QAAE,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;;QAClB,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;AAC3C,CAAC;AAED,MAAM,UAAU,GAAG,IAAI,GAAG,EAAqB,CAAC;AAEhD,KAAK,MAAM,CAAC,IAAI,EAAE,WAAW,CAAC,IAAI,cAAc,EAAE,CAAC;IACjD,MAAM,GAAG,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC;IAC/B,IAAI,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;QACxB,MAAM,IAAI,KAAK,CAAC,iDAAiD,GAAG,iBAAiB,IAAI,IAAI,CAAC,CAAC;IACjG,CAAC;IACD,MAAM,SAAS,GAAG,IAAI,GAAG,EAA8B,CAAC;IACxD,KAAK,MAAM,CAAC,IAAI,WAAW;QAAE,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;IAC1D,kGAAkG;IAClG,mFAAmF;IACnF,MAAM,QAAQ,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,cAAc,CAAC,CAAC;IACtE,UAAU,CAAC,GAAG,CAAC,GAAG,EAAE;QAClB,IAAI,EAAE,UAAU;QAChB,QAAQ,EAAE,IAAI;QACd,SAAS;QACT,eAAe,EAAE,QAAQ,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS;KAC3E,CAAC,CAAC;AACL,CAAC;AAED,MAAM,mBAAmB,GAAG,IAAI,GAAG,EAAoB,CAAC;AACxD,KAAK,MAAM,IAAI,IAAI,cAAc,CAAC,IAAI,EAAE,EAAE,CAAC;IACzC,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC;IAC9B,IAAI,IAAI,KAAK,SAAS;QAAE,SAAS;IACjC,MAAM,GAAG,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC;IAC/B,MAAM,IAAI,GAAG,mBAAmB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAC1C,IAAI,IAAI;QAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;;QACrB,mBAAmB,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC;AAC5C,CAAC;AAED,KAAK,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,IAAI,mBAAmB,EAAE,CAAC;IACvD,IAAI,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC;QAC9B,MAAM,IAAI,KAAK,CACb,iCAAiC,SAAS,gDAAgD,CAC3F,CAAC;IACJ,CAAC;IACD,MAAM,cAAc,GAAG,IAAI,GAAG,EAAoB,CAAC;IACnD,KAAK,MAAM,IAAI,IAAI,OAAO,EAAE,CAAC;QAC3B,KAAK,MAAM,CAAC,IAAI,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,CAAC;YAC/C,MAAM,MAAM,GAAG,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;YAC9C,IAAI,MAAM;gBAAE,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;;gBACzB,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC;QAC9C,CAAC;IACH,CAAC;IACD,UAAU,CAAC,GAAG,CAAC,SAAS,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,cAAc,EAAE,CAAC,CAAC;AACpF,CAAC;AAED,0CAA0C;AAC1C,MAAM,UAAU,GAAmC,CAAC,GAAG,EAAE;IACvD,MAAM,GAAG,GAAG,IAAI,GAAG,EAAqB,CAAC;IACzC,KAAK,MAAM,CAAC,IAAI,eAAe,EAAE,CAAC;QAChC,GAAG,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAiB,CAAC,CAAC;IACrD,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC,CAAC,EAAE,CAAC;AAEL,iFAAiF;AACjF,KAAK,MAAM,GAAG,IAAI,UAAU,CAAC,IAAI,EAAE,EAAE,CAAC;IACpC,IAAI,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;QACxB,MAAM,IAAI,KAAK,CACb,kCAAkC,GAAG,uDAAuD;YAC1F,oDAAoD,CACvD,CAAC;IACJ,CAAC;AACH,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,GAAW;IAC1C,OAAO,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAC7B,CAAC;AAED,MAAM,UAAU,UAAU,CAAC,GAAW;IACpC,OAAO,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAC7B,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,GAAW;IACzC,OAAO,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAC7B,CAAC;AAED,sFAAsF;AACtF,MAAM,CAAC,MAAM,cAAc,GAAwB,IAAI,GAAG,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC,CAAC;AAC9E,MAAM,CAAC,MAAM,aAAa,GAAwB,IAAI,GAAG,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC,CAAC"}

package/sdk/dist/routes/accessors.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Default-schema instantiation of the chain-global builder, generated from
+ * `../chains/canonical.js` at module-eval time. Adding a chain to
+ * `CANONICAL_CHAINS` adds a global here with zero code changes — see
+ * `sdk/test/routes.test.ts`'s "accessor generation is registry-derived"
+ * case for the proof.
+ *
+ * `PascalOf`/`pascalOfSlug` live in `builder.ts` (needed there for the
+ * `ChainGlobals` mapped type) and are re-exported here so a caller only
+ * needs one import site for the whole `routes/` surface, matching the
+ * module layout in the design doc.
+ */
+import type { CanonicalChain, ChainRef } from "../chains/canonical.js";
+import { pascalOfSlug, type ChainGlobal, type ChainGlobals, type PascalOf } from "./builder.js";
+export type { PascalOf, ChainRef };
+export { pascalOfSlug };
+/** The generated record: `const { Base, Solana, Ethereum } = chainAccessors;` -- each entry is
+ *  BOTH callable (`Base(sauce, opts)`) and a namespace (`Base.chain`/`Base.route`). */
+export declare const chainAccessors: ChainGlobals;
+/**
+ * Dynamic front door for a runtime-resolved chain (`chain('eth')`,
+ * `chain(8453)`, `chain('BNB Chain')`) — delegates to `requireChain`, so it
+ * inherits the registry's alias resolution and unknown-chain throw.
+ */
+export declare function chain(ref: number | string | bigint | CanonicalChain): ChainGlobal;
+//# sourceMappingURL=accessors.d.ts.map

package/sdk/dist/routes/accessors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accessors.d.ts","sourceRoot":"","sources":["../../src/routes/accessors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAEvE,OAAO,EAGL,YAAY,EACZ,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,QAAQ,EACd,MAAM,cAAc,CAAC;AAEtB,YAAY,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC;AACnC,OAAO,EAAE,YAAY,EAAE,CAAC;AAExB;uFACuF;AACvF,eAAO,MAAM,cAAc,EAAE,YAAmC,CAAC;AAEjE;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,cAAc,GAAG,WAAW,CAGjF"}

package/sdk/dist/routes/accessors.js

@@ -0,0 +1,16 @@
+import { requireChain } from "../chains/canonical.js";
+import { createChainGlobals, makeChainGlobal, pascalOfSlug, } from "./builder.js";
+export { pascalOfSlug };
+/** The generated record: `const { Base, Solana, Ethereum } = chainAccessors;` -- each entry is
+ *  BOTH callable (`Base(sauce, opts)`) and a namespace (`Base.chain`/`Base.route`). */
+export const chainAccessors = createChainGlobals();
+/**
+ * Dynamic front door for a runtime-resolved chain (`chain('eth')`,
+ * `chain(8453)`, `chain('BNB Chain')`) — delegates to `requireChain`, so it
+ * inherits the registry's alias resolution and unknown-chain throw.
+ */
+export function chain(ref) {
+    const resolved = requireChain(ref);
+    return makeChainGlobal(resolved);
+}
+//# sourceMappingURL=accessors.js.map

package/sdk/dist/routes/accessors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"accessors.js","sourceRoot":"","sources":["../../src/routes/accessors.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,EACL,kBAAkB,EAClB,eAAe,EACf,YAAY,GAIb,MAAM,cAAc,CAAC;AAGtB,OAAO,EAAE,YAAY,EAAE,CAAC;AAExB;uFACuF;AACvF,MAAM,CAAC,MAAM,cAAc,GAAiB,kBAAkB,EAAE,CAAC;AAEjE;;;;GAIG;AACH,MAAM,UAAU,KAAK,CAAC,GAA8C;IAClE,MAAM,QAAQ,GAAG,YAAY,CAAC,GAAe,CAAC,CAAC;IAC/C,OAAO,eAAe,CAAC,QAAQ,CAAC,CAAC;AACnC,CAAC"}

package/sdk/dist/routes/ambient.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Chain-scoped scalar ambient defines — `chainId`/protocol-contract addresses/caller token symbols,
+ * threaded into `compile()`'s `defines` underneath a caller's own `IntentOptions.compile.defines`
+ * (caller wins on a key collision; a user's own `let X = ...` inside the body wins over both, via
+ * the compiler's own `getConstant`-only-when-`getVar`-is-undefined precedence).
+ *
+ * TOKEN SYMBOLS: `USDC`/`WETH`/etc. now resolve by DEFAULT from `token-registry.ts`'s curated,
+ * probe-verified per-chain registry (see that file for exactly which chains/symbols are covered) --
+ * this SDK has no OTHER per-chain token-address source (`protocols/erc20/addresses.ts` is
+ * deliberately empty — "ERC20 is a standard interface, not a specific deployment"; see
+ * `token-registry.ts`'s own module doc for the full discovery sweep). `opts.tokens` is the OVERRIDE
+ * layer on top of the registry, resolved through `resolveTokenMap` (per-key precedence — overriding
+ * one symbol never drops an unrelated registry symbol for the same chain).
+ *
+ * Deliberately NOT here: `self` (a runtime intrinsic, not a `bigint|boolean|number` constant — the
+ * working spelling stays the compiler's own `ctx.self()`); SVM venue programIds; family-alias
+ * spellings (`Uniswap_UniversalRouter` alongside `UniswapV4_UniversalRouter`); qualified cross-scope
+ * `Base.USDC` (needs nesting).
+ */
+import type { CanonicalChain } from "../chains/canonical.js";
+import type { AddressInput } from "./types.js";
+export interface AmbientDefinesOptions {
+    /** Caller-supplied token symbol -> address map, e.g. `{ USDC: "0x..." }`. */
+    readonly tokens?: Readonly<Record<string, AddressInput>>;
+}
+/**
+ * The chain-scoped ambient defines map for `chain`: `chainId`/`CHAIN_ID`, every EVM protocol
+ * contract address that has a real entry on `chain.id`, and any caller-supplied token symbols.
+ *
+ * P8: `protocolAddresses`/`tokens` are read through `loadPluginData()` (`plugin/index.ts`) rather
+ * than importing `descriptors/registry.ts`/`token-registry.ts` directly — the SAME underlying
+ * array/function, re-exposed through the plugin accessor as the single point the SDK reads
+ * Layer-B data through. Byte-identical output: `loadPluginData().protocolAddresses` IS
+ * `DESCRIPTORS` and `.tokens` IS `resolveTokenMap`, not a copy.
+ */
+export declare function chainDefines(chain: CanonicalChain, opts?: AmbientDefinesOptions): Record<string, bigint | boolean | number>;
+/**
+ * The ambient-MODULE half of a chain bundle (`chainDefines` above is the scalar-DEFINES half — two
+ * distinct mechanisms, see `plugin/index.ts`'s note). Returns the ambient module specifier list
+ * active for `chain`: whole SauceScript library modules whose exported functions/consts are
+ * broadcast into a chain's compiled program with no `import` line (see
+ * `sauce-route.ts#SauceCompileOptions.ambient`/`rs-compile.ts`).
+ *
+ * Currently a SINGLE source of truth, not yet chain-specific: every chain gets the same list, the
+ * plugin manifest's own `ambient` array (`plugin/index.ts#loadPlugin`) — `["@sauce/token"]` by
+ * default, resolved to the SDK's own vendored copy on the route path. Extensible to a genuinely
+ * per-chain bundle later (e.g. an SVM destination activating an SVM-only ambient module an EVM one
+ * shouldn't see) without changing this function's signature — a caller already threads `chain`
+ * through.
+ */
+export declare function chainAmbient(_chain: CanonicalChain): string[];
+//# sourceMappingURL=ambient.d.ts.map

package/sdk/dist/routes/ambient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ambient.d.ts","sourceRoot":"","sources":["../../src/routes/ambient.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAG7D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C,MAAM,WAAW,qBAAqB;IACpC,6EAA6E;IAC7E,QAAQ,CAAC,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC;CAC1D;AAMD;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,cAAc,EACrB,IAAI,GAAE,qBAA0B,GAC/B,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC,CAuB3C;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,cAAc,GAAG,MAAM,EAAE,CAE7D"}

package/sdk/dist/routes/ambient.js

@@ -0,0 +1,54 @@
+import { loadPlugin, loadPluginData } from "../plugin/index.js";
+import { pascalOfSlug } from "./builder.js";
+function toBigIntAddress(input) {
+    return BigInt(input);
+}
+/**
+ * The chain-scoped ambient defines map for `chain`: `chainId`/`CHAIN_ID`, every EVM protocol
+ * contract address that has a real entry on `chain.id`, and any caller-supplied token symbols.
+ *
+ * P8: `protocolAddresses`/`tokens` are read through `loadPluginData()` (`plugin/index.ts`) rather
+ * than importing `descriptors/registry.ts`/`token-registry.ts` directly — the SAME underlying
+ * array/function, re-exposed through the plugin accessor as the single point the SDK reads
+ * Layer-B data through. Byte-identical output: `loadPluginData().protocolAddresses` IS
+ * `DESCRIPTORS` and `.tokens` IS `resolveTokenMap`, not a copy.
+ */
+export function chainDefines(chain, opts = {}) {
+    const defines = {
+        chainId: BigInt(chain.id),
+        CHAIN_ID: BigInt(chain.id),
+    };
+    const plugin = loadPluginData();
+    if (chain.kind === "evm") {
+        for (const d of plugin.protocolAddresses) {
+            const address = d.perChainAddress[chain.id];
+            if (address === undefined)
+                continue;
+            const key = `${pascalOfSlug(d.protocol)}_${d.contract}`;
+            defines[key] = toBigIntAddress(address);
+        }
+    }
+    const tokenMap = plugin.tokens(chain, opts.tokens);
+    for (const [symbol, address] of tokenMap) {
+        defines[symbol] = address;
+    }
+    return defines;
+}
+/**
+ * The ambient-MODULE half of a chain bundle (`chainDefines` above is the scalar-DEFINES half — two
+ * distinct mechanisms, see `plugin/index.ts`'s note). Returns the ambient module specifier list
+ * active for `chain`: whole SauceScript library modules whose exported functions/consts are
+ * broadcast into a chain's compiled program with no `import` line (see
+ * `sauce-route.ts#SauceCompileOptions.ambient`/`rs-compile.ts`).
+ *
+ * Currently a SINGLE source of truth, not yet chain-specific: every chain gets the same list, the
+ * plugin manifest's own `ambient` array (`plugin/index.ts#loadPlugin`) — `["@sauce/token"]` by
+ * default, resolved to the SDK's own vendored copy on the route path. Extensible to a genuinely
+ * per-chain bundle later (e.g. an SVM destination activating an SVM-only ambient module an EVM one
+ * shouldn't see) without changing this function's signature — a caller already threads `chain`
+ * through.
+ */
+export function chainAmbient(_chain) {
+    return loadPlugin().ambient;
+}
+//# sourceMappingURL=ambient.js.map

package/sdk/dist/routes/ambient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ambient.js","sourceRoot":"","sources":["../../src/routes/ambient.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAChE,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAQ5C,SAAS,eAAe,CAAC,KAAmB;IAC1C,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;AACvB,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,YAAY,CAC1B,KAAqB,EACrB,OAA8B,EAAE;IAEhC,MAAM,OAAO,GAA8C;QACzD,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;QACzB,QAAQ,EAAE,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;KAC3B,CAAC;IAEF,MAAM,MAAM,GAAG,cAAc,EAAE,CAAC;IAEhC,IAAI,KAAK,CAAC,IAAI,KAAK,KAAK,EAAE,CAAC;QACzB,KAAK,MAAM,CAAC,IAAI,MAAM,CAAC,iBAAiB,EAAE,CAAC;YACzC,MAAM,OAAO,GAAG,CAAC,CAAC,eAAe,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;YAC5C,IAAI,OAAO,KAAK,SAAS;gBAAE,SAAS;YACpC,MAAM,GAAG,GAAG,GAAG,YAAY,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,CAAC;YACxD,OAAO,CAAC,GAAG,CAAC,GAAG,eAAe,CAAC,OAAO,CAAC,CAAC;QAC1C,CAAC;IACH,CAAC;IAED,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IACnD,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,QAAQ,EAAE,CAAC;QACzC,OAAO,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC;IAC5B,CAAC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,YAAY,CAAC,MAAsB;IACjD,OAAO,UAAU,EAAE,CAAC,OAAO,CAAC;AAC9B,CAAC"}

package/sdk/dist/routes/ast-walk.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Shared acorn-AST plumbing for the routes/ source-rewrite passes (`token-rewrite.ts`,
+ * `protocol-rewrite.ts`). Extracted verbatim from `token-rewrite.ts` (U4) so the two passes' whole-
+ * program shadow semantics can never drift apart — see `token-rewrite.ts`'s own module doc for the
+ * shadowing rationale (SauceScript shares scope across `if`/`while`/bare-block bodies, so this is
+ * deliberately a coarser, whole-program-conservative check, not real lexical scoping).
+ */
+export interface AstNode {
+    type: string;
+    start: number;
+    end: number;
+    [key: string]: unknown;
+}
+/** Generic recursive descent over every object/array-shaped property -- deliberately not a
+ *  hand-maintained per-node-type visitor table, since SauceScript's supported grammar surface is
+ *  itself the only thing that can appear here, and a generic walk needs no per-type maintenance as
+ *  that surface grows. */
+export declare function walk(node: unknown, visit: (n: AstNode) => void): void;
+/** Every name the program introduces that could shadow a rewritten global, anywhere in the tree --
+ *  deliberately whole-program, not scope-sensitive (see the module doc's shadowing note).
+ *
+ *  Covers every form that BINDS a name, not just the common ones: `let`/`const`/`var` declarators
+ *  (including destructuring), function and arrow parameters, a function's or class's own name, a
+ *  `catch` parameter, and every `import` clause. The import and class cases are not hypothetical --
+ *  an `import { Token } from "./mine.js"` is a user's own `Token` by any reading, and missing it
+ *  meant their call was silently redirected to an ERC20 they never named. Fail closed on all of
+ *  them: over-collecting only ever declines a rewrite, which is the safe direction. */
+export declare function collectDeclaredNames(program: AstNode): ReadonlySet<string>;
+//# sourceMappingURL=ast-walk.d.ts.map

package/sdk/dist/routes/ast-walk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast-walk.d.ts","sourceRoot":"","sources":["../../src/routes/ast-walk.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED;;;0BAG0B;AAC1B,wBAAgB,IAAI,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,IAAI,GAAG,IAAI,CAerE;AAsCD;;;;;;;;uFAQuF;AACvF,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,GAAG,WAAW,CAAC,MAAM,CAAC,CAkC1E"}

package/sdk/dist/routes/ast-walk.js

@@ -0,0 +1,100 @@
+/** Generic recursive descent over every object/array-shaped property -- deliberately not a
+ *  hand-maintained per-node-type visitor table, since SauceScript's supported grammar surface is
+ *  itself the only thing that can appear here, and a generic walk needs no per-type maintenance as
+ *  that surface grows. */
+export function walk(node, visit) {
+    if (node === null || typeof node !== "object")
+        return;
+    if (Array.isArray(node)) {
+        for (const item of node)
+            walk(item, visit);
+        return;
+    }
+    const rec = node;
+    if (typeof rec.type === "string") {
+        visit(rec);
+    }
+    for (const key of Object.keys(rec)) {
+        if (key === "type" || key === "start" || key === "end" || key === "loc" || key === "range")
+            continue;
+        walk(rec[key], visit);
+    }
+}
+/** Every name a binding PATTERN introduces -- an identifier, or any nesting of object/array
+ *  destructuring, defaults and rest. Collecting only the `Identifier` case would miss
+ *  `const { Token } = x` and `function f({ Token })`, which bind the name just as plainly. */
+function collectPatternNames(pattern, names) {
+    if (pattern === null || typeof pattern !== "object")
+        return;
+    const node = pattern;
+    switch (node.type) {
+        case "Identifier":
+            names.add(node.name);
+            return;
+        case "ObjectPattern":
+            for (const property of node.properties ?? []) {
+                // A `Property`'s VALUE is the binding (`{ a: Token }` binds `Token`, not `a`); a
+                // `RestElement`'s argument is.
+                collectPatternNames(property.value ?? property.argument, names);
+            }
+            return;
+        case "ArrayPattern":
+            for (const element of node.elements ?? []) {
+                collectPatternNames(element, names);
+            }
+            return;
+        case "AssignmentPattern":
+            collectPatternNames(node.left, names);
+            return;
+        case "RestElement":
+            collectPatternNames(node.argument, names);
+            return;
+        default:
+            return;
+    }
+}
+/** Every name the program introduces that could shadow a rewritten global, anywhere in the tree --
+ *  deliberately whole-program, not scope-sensitive (see the module doc's shadowing note).
+ *
+ *  Covers every form that BINDS a name, not just the common ones: `let`/`const`/`var` declarators
+ *  (including destructuring), function and arrow parameters, a function's or class's own name, a
+ *  `catch` parameter, and every `import` clause. The import and class cases are not hypothetical --
+ *  an `import { Token } from "./mine.js"` is a user's own `Token` by any reading, and missing it
+ *  meant their call was silently redirected to an ERC20 they never named. Fail closed on all of
+ *  them: over-collecting only ever declines a rewrite, which is the safe direction. */
+export function collectDeclaredNames(program) {
+    const names = new Set();
+    walk(program, (n) => {
+        switch (n.type) {
+            case "VariableDeclarator":
+                collectPatternNames(n.id, names);
+                return;
+            case "FunctionDeclaration":
+            case "FunctionExpression":
+            case "ArrowFunctionExpression":
+                // The function's own name binds too (`function Token(...)`), and an arrow has none.
+                collectPatternNames(n.id, names);
+                for (const param of n.params ?? []) {
+                    collectPatternNames(param, names);
+                }
+                return;
+            case "ClassDeclaration":
+            case "ClassExpression":
+                collectPatternNames(n.id, names);
+                return;
+            case "CatchClause":
+                collectPatternNames(n.param, names);
+                return;
+            case "ImportSpecifier":
+            case "ImportDefaultSpecifier":
+            case "ImportNamespaceSpecifier":
+                // `local` is the name brought into scope — `import { a as Token }` binds `Token`.
+                collectPatternNames(n.local, names);
+                return;
+            default:
+                return;
+        }
+    });
+    return names;
+}
+//# sourceMappingURL=ast-walk.js.map

package/sdk/dist/routes/ast-walk.js.map

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