@eco-incorp/sauce 0.99.0

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

@@ -0,0 +1,67 @@
+/**
+ * Chain-global surface machinery: every canonical chain global is BOTH
+ * callable (`Base(sauce, opts)`) and a namespace carrying `.chain` and
+ * `.route` (the same callable, `Base.route === Base`'s own behavior).
+ *
+ * `ChainRoute`/`ChainGlobal` are ONE interface hierarchy — `ChainGlobal
+ * extends ChainRoute`, so the call signature and `.route` can never drift
+ * apart (see `sdk/test/routes-globals-ambient-types.test.ts`'s type-level pin).
+ *
+ * `ChainRef`/`CanonicalChain` now come straight from `../chains/canonical.js`
+ * (which additionally accepts `bigint`) rather than a narrower copy kept
+ * here — re-exported below so the public name survives at this import path.
+ */
+import type { CanonicalChain, ChainRef, ChainSlug } from "../chains/canonical.js";
+import type { IntentOptions, PendingSauceRoute, SauceBody } from "./intent-dsl.js";
+export type { ChainRef };
+/**
+ * `PascalOf<"bnb-chain">` = `"BnbChain"`. Matches the runtime `pascal()`
+ * derivation in `accessors.ts` by construction (both reduce to
+ * `Capitalize<S>` composed across `-`-separated segments) -- re-exported from
+ * `accessors.ts` so callers only need one import site.
+ */
+export type PascalOf<S extends string> = S extends `${infer H}-${infer T}` ? `${Capitalize<H>}${PascalOf<T>}` : Capitalize<S>;
+/** The call signature: `Chain(sauce, options)` -> a pending route awaiting `.reward(...)`. */
+export interface ChainRoute {
+    (sauce: SauceBody, options?: IntentOptions): PendingSauceRoute;
+}
+/** A chain global: callable (the SAME behavior as `.route`), plus `.chain`/`.route`. */
+export interface ChainGlobal extends ChainRoute {
+    /** The registry record this global was generated from (or resolved via `chain(ref)`). */
+    readonly chain: CanonicalChain;
+    /** The SAME interface as the call signature -- `Base.route === Base` in behavior, by construction. */
+    readonly route: ChainRoute;
+}
+/** One generated `ChainGlobal` per canonical chain slug, PascalCase-keyed. */
+export type ChainGlobals = {
+    readonly [S in ChainSlug as PascalOf<S>]: ChainGlobal;
+};
+/** Function intrinsics a namespace/contract-accessor key must never collide with -- see
+ *  `globals.ts#composeChainGlobal`'s own, wider denylist for the composed (installed) global. */
+declare const FUNCTION_INTRINSICS: ReadonlySet<string>;
+/**
+ * Builds the callable `ChainGlobal` for `chain` -- what a generated global
+ * (`Base`) or `chain(ref)` returns. An ARROW function (no own `prototype` to
+ * collide with) forwarding to `openRoute`, with `chain`/`route` defined onto
+ * it as enumerable so `Object.keys(chainAccessors.Base)` stays exactly
+ * `["chain","route"]`.
+ */
+export declare function makeChainGlobal(chain: CanonicalChain): ChainGlobal;
+/**
+ * Generates the top-level chain globals from `../chains/canonical.js` --
+ * adding a chain to `CANONICAL_CHAINS` adds a global here with zero code
+ * changes; a duplicate PascalCase key (two slugs colliding after casing)
+ * throws at module-eval time rather than silently overwriting one with
+ * another.
+ */
+export declare function createChainGlobals(): ChainGlobals;
+/**
+ * `PascalOf`'s runtime mirror: split on `-`, upper-case each segment's first
+ * character, join. Agrees with the type-level `PascalOf` by construction
+ * (both reduce to `Capitalize<S>` per `-`-separated segment) as long as a
+ * slug matches `^[a-z0-9]+(-[a-z0-9]+)*$` -- pinned by
+ * `chains-canonical.test.ts`.
+ */
+export declare function pascalOfSlug(slug: string): string;
+export { FUNCTION_INTRINSICS };
+//# sourceMappingURL=builder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../src/routes/builder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAElF,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAGnF,YAAY,EAAE,QAAQ,EAAE,CAAC;AAEzB;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,SAAS,MAAM,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,IAAI,MAAM,CAAC,EAAE,GACtE,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,EAAE,GAChC,UAAU,CAAC,CAAC,CAAC,CAAC;AAElB,8FAA8F;AAC9F,MAAM,WAAW,UAAU;IACzB,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,iBAAiB,CAAC;CAChE;AAED,wFAAwF;AACxF,MAAM,WAAW,WAAY,SAAQ,UAAU;IAC7C,yFAAyF;IACzF,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;IAC/B,sGAAsG;IACtG,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;CAC5B;AAED,8EAA8E;AAC9E,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,EAAE,CAAC,IAAI,SAAS,IAAI,QAAQ,CAAC,CAAC,CAAC,GAAG,WAAW;CACtD,CAAC;AAEF;iGACiG;AACjG,QAAA,MAAM,mBAAmB,EAAE,WAAW,CAAC,MAAM,CAa3C,CAAC;AAEH;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,cAAc,GAAG,WAAW,CAalE;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,IAAI,YAAY,CAUjD;AAID;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAKjD;AAID,OAAO,EAAE,mBAAmB,EAAE,CAAC"}

package/sdk/dist/routes/builder.js

@@ -0,0 +1,70 @@
+import { canonicalChains } from "../chains/canonical.js";
+import { openRoute } from "./intent-dsl.js";
+/** Function intrinsics a namespace/contract-accessor key must never collide with -- see
+ *  `globals.ts#composeChainGlobal`'s own, wider denylist for the composed (installed) global. */
+const FUNCTION_INTRINSICS = new Set([
+    "length",
+    "name",
+    "prototype",
+    "arguments",
+    "caller",
+    "bind",
+    "call",
+    "apply",
+    "toString",
+    "constructor",
+    "chain",
+    "route",
+]);
+/**
+ * Builds the callable `ChainGlobal` for `chain` -- what a generated global
+ * (`Base`) or `chain(ref)` returns. An ARROW function (no own `prototype` to
+ * collide with) forwarding to `openRoute`, with `chain`/`route` defined onto
+ * it as enumerable so `Object.keys(chainAccessors.Base)` stays exactly
+ * `["chain","route"]`.
+ */
+export function makeChainGlobal(chain) {
+    const route = (sauce, options) => openRoute(chain, sauce, options);
+    const fn = ((sauce, options) => route(sauce, options));
+    Object.defineProperties(fn, {
+        chain: { value: chain, enumerable: true, configurable: false, writable: false },
+        route: { value: route, enumerable: true, configurable: false, writable: false },
+    });
+    return fn;
+}
+/**
+ * Generates the top-level chain globals from `../chains/canonical.js` --
+ * adding a chain to `CANONICAL_CHAINS` adds a global here with zero code
+ * changes; a duplicate PascalCase key (two slugs colliding after casing)
+ * throws at module-eval time rather than silently overwriting one with
+ * another.
+ */
+export function createChainGlobals() {
+    const out = {};
+    for (const c of canonicalChains) {
+        const key = pascalOfSlug(c.slug);
+        if (key in out) {
+            throw new Error(`duplicate chain global '${key}' (from slug '${c.slug}')`);
+        }
+        out[key] = makeChainGlobal(c);
+    }
+    return out;
+}
+// --- shared slug/pascal helpers (also used by accessors.ts, descriptors/accessors.ts, svm/accessors.ts) ---
+/**
+ * `PascalOf`'s runtime mirror: split on `-`, upper-case each segment's first
+ * character, join. Agrees with the type-level `PascalOf` by construction
+ * (both reduce to `Capitalize<S>` per `-`-separated segment) as long as a
+ * slug matches `^[a-z0-9]+(-[a-z0-9]+)*$` -- pinned by
+ * `chains-canonical.test.ts`.
+ */
+export function pascalOfSlug(slug) {
+    return slug
+        .split("-")
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join("");
+}
+// Re-exported so a caller checking for a hard denylist elsewhere (globals.ts)
+// can extend, rather than re-derive, this list.
+export { FUNCTION_INTRINSICS };
+//# sourceMappingURL=builder.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"builder.js","sourceRoot":"","sources":["../../src/routes/builder.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAEzD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAgC5C;iGACiG;AACjG,MAAM,mBAAmB,GAAwB,IAAI,GAAG,CAAC;IACvD,QAAQ;IACR,MAAM;IACN,WAAW;IACX,WAAW;IACX,QAAQ;IACR,MAAM;IACN,MAAM;IACN,OAAO;IACP,UAAU;IACV,aAAa;IACb,OAAO;IACP,OAAO;CACR,CAAC,CAAC;AAEH;;;;;;GAMG;AACH,MAAM,UAAU,eAAe,CAAC,KAAqB;IACnD,MAAM,KAAK,GAAe,CAAC,KAAgB,EAAE,OAAuB,EAAqB,EAAE,CACzF,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;IAEnC,MAAM,EAAE,GAAG,CAAC,CAAC,KAAgB,EAAE,OAAuB,EAAqB,EAAE,CAC3E,KAAK,CAAC,KAAK,EAAE,OAAO,CAAC,CAA2B,CAAC;IAEnD,MAAM,CAAC,gBAAgB,CAAC,EAAE,EAAE;QAC1B,KAAK,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE;QAC/E,KAAK,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE;KAChF,CAAC,CAAC;IAEH,OAAO,EAAE,CAAC;AACZ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB;IAChC,MAAM,GAAG,GAAgC,EAAE,CAAC;IAC5C,KAAK,MAAM,CAAC,IAAI,eAAe,EAAE,CAAC;QAChC,MAAM,GAAG,GAAG,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QACjC,IAAI,GAAG,IAAI,GAAG,EAAE,CAAC;YACf,MAAM,IAAI,KAAK,CAAC,2BAA2B,GAAG,iBAAiB,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC;QAC7E,CAAC;QACD,GAAG,CAAC,GAAG,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC;IAChC,CAAC;IACD,OAAO,GAAmB,CAAC;AAC7B,CAAC;AAED,6GAA6G;AAE7G;;;;;;GAMG;AACH,MAAM,UAAU,YAAY,CAAC,IAAY;IACvC,OAAO,IAAI;SACR,KAAK,CAAC,GAAG,CAAC;SACV,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;SAC3D,IAAI,CAAC,EAAE,CAAC,CAAC;AACd,CAAC;AAED,8EAA8E;AAC9E,gDAAgD;AAChD,OAAO,EAAE,mBAAmB,EAAE,CAAC"}

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

@@ -0,0 +1,9 @@
+export type SauceBody = string | (() => unknown);
+/**
+ * Extracts a complete `function main(){...}` program from a closure's own declared source text.
+ * Fails closed (never silently falls back) on anything this first cut doesn't support.
+ */
+export declare function sauceBodyToSource(body: () => unknown): string;
+/** True for anything `sauceBodyToSource` (rather than the plain string path) should handle. */
+export declare function isSauceClosure(body: SauceBody): body is () => unknown;
+//# sourceMappingURL=closure.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"closure.d.ts","sourceRoot":"","sources":["../../src/routes/closure.ts"],"names":[],"mappings":"AAuBA,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,CAAC,MAAM,OAAO,CAAC,CAAC;AAQjD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,OAAO,GAAG,MAAM,CA2D7D;AAED,+FAA+F;AAC/F,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI,IAAI,MAAM,OAAO,CAErE"}

package/sdk/dist/routes/closure.js

@@ -0,0 +1,78 @@
+/**
+ * Closure route bodies — `() => {...}` accepted as a `SauceBody` alongside a string.
+ *
+ * Mechanism: `Function.prototype.toString.call(fn)` returns the verbatim declared text
+ * (ES2018-spec-guaranteed). We parse `(${text})` with acorn (parsing the parenthesized form is
+ * what makes both a `function (){}` expression and an arrow valid inputs to one parse), take the
+ * single `ExpressionStatement`'s function node, and either:
+ *  - a BLOCK body: slice the ORIGINAL text between the block's own braces using the node's
+ *    `start`/`end` ranges (minus the one-character paren offset) and emit `function main() {\n<slice>\n}`
+ *    — the slice is verbatim source, so comments/formatting/nested arrows/string literals survive
+ *    untouched;
+ *  - a CONCISE body (`() => expr`): slice the expression's range and synthesize
+ *    `function main() {\n  return <slice>;\n}`.
+ *
+ * Never hand-slice on `=>` or brace-counting: a `=>` inside a string literal, a template literal,
+ * a comment, or a default parameter breaks naive slicing, which is exactly why acorn is used.
+ *
+ * CAPTURE: there is none, by construction, and that is CORRECT — a free identifier that is neither
+ * a chain-scoped ambient name nor a caller-supplied `defines` entry is a hard "`X` is not a declared variable"
+ * compile error, which can never silently bake a stale JS value into bytecode.
+ */
+import * as acorn from "acorn";
+class SauceClosureError extends Error {
+}
+function fail(message) {
+    throw new SauceClosureError(`sauceBodyToSource: ${message}`);
+}
+/**
+ * Extracts a complete `function main(){...}` program from a closure's own declared source text.
+ * Fails closed (never silently falls back) on anything this first cut doesn't support.
+ */
+export function sauceBodyToSource(body) {
+    if (typeof body !== "function") {
+        fail(`expected a function, got ${typeof body}`);
+    }
+    const text = Function.prototype.toString.call(body);
+    if (text.includes("[native code]")) {
+        fail("the closure's own toString() returned '[native code]' -- this can happen for a bound/proxied " +
+            "function, or under a hostile minifier that strips function bodies; pass a string instead.");
+    }
+    let parsed;
+    const PAREN_OFFSET = 1; // the leading "(" we prepend below
+    try {
+        parsed = acorn.parseExpressionAt(`(${text})`, 0, { ecmaVersion: "latest" });
+    }
+    catch (err) {
+        fail(`could not parse the closure's own declared source with acorn (${err.message}) -- ` +
+            "this can happen under a bundler/minifier that rewrites function text; pass a string instead.");
+    }
+    const fnNode = parsed;
+    if (fnNode.type !== "ArrowFunctionExpression" && fnNode.type !== "FunctionExpression") {
+        fail(`expected a function/arrow expression, parsed a '${fnNode.type}' instead`);
+    }
+    if (fnNode.async) {
+        fail("an async closure is not supported -- a route body must be synchronous SauceScript");
+    }
+    if (fnNode.generator) {
+        fail("a generator closure is not supported");
+    }
+    if (fnNode.params !== undefined && fnNode.params.length > 0) {
+        fail("a closure with parameters is not supported yet -- main(args) support is a deliberate later " +
+            "unit; write a zero-parameter closure or pass a string instead");
+    }
+    const start = fnNode.body.start - PAREN_OFFSET;
+    const end = fnNode.body.end - PAREN_OFFSET;
+    if (fnNode.body.type === "BlockStatement") {
+        // start/end include the surrounding braces themselves; slice the interior.
+        const interior = text.slice(start + 1, end - 1);
+        return `function main() {\n${interior}\n}`;
+    }
+    const exprText = text.slice(start, end);
+    return `function main() {\n  return ${exprText};\n}`;
+}
+/** True for anything `sauceBodyToSource` (rather than the plain string path) should handle. */
+export function isSauceClosure(body) {
+    return typeof body === "function";
+}
+//# sourceMappingURL=closure.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"closure.js","sourceRoot":"","sources":["../../src/routes/closure.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAI/B,MAAM,iBAAkB,SAAQ,KAAK;CAAG;AAExC,SAAS,IAAI,CAAC,OAAe;IAC3B,MAAM,IAAI,iBAAiB,CAAC,sBAAsB,OAAO,EAAE,CAAC,CAAC;AAC/D,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAmB;IACnD,IAAI,OAAO,IAAI,KAAK,UAAU,EAAE,CAAC;QAC/B,IAAI,CAAC,4BAA4B,OAAO,IAAI,EAAE,CAAC,CAAC;IAClD,CAAC;IAED,MAAM,IAAI,GAAG,QAAQ,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAW,CAAC;IAC9D,IAAI,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC,EAAE,CAAC;QACnC,IAAI,CACF,+FAA+F;YAC7F,2FAA2F,CAC9F,CAAC;IACJ,CAAC;IAED,IAAI,MAAkB,CAAC;IACvB,MAAM,YAAY,GAAG,CAAC,CAAC,CAAC,mCAAmC;IAC3D,IAAI,CAAC;QACH,MAAM,GAAG,KAAK,CAAC,iBAAiB,CAAC,IAAI,IAAI,GAAG,EAAE,CAAC,EAAE,EAAE,WAAW,EAAE,QAAQ,EAAE,CAAC,CAAC;IAC9E,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,IAAI,CACF,iEAAkE,GAAa,CAAC,OAAO,OAAO;YAC5F,8FAA8F,CACjG,CAAC;IACJ,CAAC;IAED,MAAM,MAAM,GAAG,MAMd,CAAC;IAEF,IAAI,MAAM,CAAC,IAAI,KAAK,yBAAyB,IAAI,MAAM,CAAC,IAAI,KAAK,oBAAoB,EAAE,CAAC;QACtF,IAAI,CAAC,mDAAmD,MAAM,CAAC,IAAI,WAAW,CAAC,CAAC;IAClF,CAAC;IACD,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;QACjB,IAAI,CAAC,mFAAmF,CAAC,CAAC;IAC5F,CAAC;IACD,IAAI,MAAM,CAAC,SAAS,EAAE,CAAC;QACrB,IAAI,CAAC,sCAAsC,CAAC,CAAC;IAC/C,CAAC;IACD,IAAI,MAAM,CAAC,MAAM,KAAK,SAAS,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC5D,IAAI,CACF,6FAA6F;YAC3F,+DAA+D,CAClE,CAAC;IACJ,CAAC;IAED,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,GAAG,YAAY,CAAC;IAC/C,MAAM,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,GAAG,YAAY,CAAC;IAE3C,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,gBAAgB,EAAE,CAAC;QAC1C,2EAA2E;QAC3E,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC;QAChD,OAAO,sBAAsB,QAAQ,KAAK,CAAC;IAC7C,CAAC;IAED,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;IACxC,OAAO,+BAA+B,QAAQ,MAAM,CAAC;AACvD,CAAC;AAED,+FAA+F;AAC/F,MAAM,UAAU,cAAc,CAAC,IAAe;IAC5C,OAAO,OAAO,IAAI,KAAK,UAAU,CAAC;AACpC,CAAC"}

package/sdk/dist/routes/compile-types.d.ts

@@ -0,0 +1,63 @@
+/**
+ * The compiler seam's data contract, owned by the SDK.
+ *
+ * `compileSauceRoute` reaches the compiler through one seam (`rs-compile.ts`), and the shapes below
+ * are what that seam produces and consumes. Owning them here is what lets `sdk/src` name a route's
+ * compile inputs and outputs without importing the compiler's own type surface — which is a wasm
+ * package loaded at runtime, not something the SDK's public types should be pinned to.
+ */
+export interface AbiParameter {
+    name?: string;
+    type: string;
+    components?: AbiParameter[];
+    indexed?: boolean;
+}
+export interface AbiFunction {
+    type: "function";
+    name: string;
+    inputs: AbiParameter[];
+    outputs?: AbiParameter[];
+    stateMutability?: "pure" | "view" | "nonpayable" | "payable";
+}
+export type AbiItem = AbiFunction | {
+    type: "event";
+    name: string;
+    inputs: AbiParameter[];
+} | {
+    type: "error";
+    name: string;
+    inputs: AbiParameter[];
+} | {
+    type: "constructor";
+    inputs: AbiParameter[];
+} | {
+    type: "fallback";
+} | {
+    type: "receive";
+};
+export type Abi = readonly AbiItem[];
+export interface ContractConfig {
+    abi: Abi;
+}
+/**
+ * Contract bindings by local name, holding a PARSED ABI in memory — never a filesystem path.
+ * `protocol-rewrite.ts` synthesizes these, and `rs-compile.ts` maps them onto the RS compiler's
+ * `inlineContracts` (its path-based `contracts` option expects a `resolve()`-able path, which this
+ * seam never has).
+ */
+export type ContractsConfig = Record<string, ContractConfig>;
+/**
+ * Bytecode target: `'v1'` (prefix, Solidity interpreter), `'v12'` (postfix, Huff runtime) or
+ * `'svm'` (postfix v12 dialect for the Solana engine). The RS compiler collapses `'v1'`/`'v12'`
+ * onto its single `'evm'` backend (see `rs-compile.ts#mapTarget`).
+ */
+export type CompileTarget = "v1" | "v12" | "svm";
+/**
+ * What a route compile yields. `bytecode` is a list of SEGMENTS — `compileSauceRoute` slots
+ * `bytecode[0]` as the one `Call` a cook executes (see `sauce-route.ts`'s "ONE COOK = ONE PROGRAM").
+ */
+export interface CompileResult {
+    bytecode: Uint8Array[];
+    warnings: string[];
+}
+//# sourceMappingURL=compile-types.d.ts.map

package/sdk/dist/routes/compile-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile-types.d.ts","sourceRoot":"","sources":["../../src/routes/compile-types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,YAAY,EAAE,CAAC;IAC5B,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,YAAY,EAAE,CAAC;IACvB,OAAO,CAAC,EAAE,YAAY,EAAE,CAAC;IACzB,eAAe,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,YAAY,GAAG,SAAS,CAAC;CAC9D;AAED,MAAM,MAAM,OAAO,GACf,WAAW,GACX;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,YAAY,EAAE,CAAA;CAAE,GACvD;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,YAAY,EAAE,CAAA;CAAE,GACvD;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,MAAM,EAAE,YAAY,EAAE,CAAA;CAAE,GAC/C;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,GACpB;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,CAAC;AAExB,MAAM,MAAM,GAAG,GAAG,SAAS,OAAO,EAAE,CAAC;AAErC,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,GAAG,CAAC;CACV;AAED;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;AAE7D;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG,IAAI,GAAG,KAAK,GAAG,KAAK,CAAC;AAEjD;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,UAAU,EAAE,CAAC;IACvB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB"}

package/sdk/dist/routes/compile-types.js

@@ -0,0 +1,10 @@
+/**
+ * The compiler seam's data contract, owned by the SDK.
+ *
+ * `compileSauceRoute` reaches the compiler through one seam (`rs-compile.ts`), and the shapes below
+ * are what that seam produces and consumes. Owning them here is what lets `sdk/src` name a route's
+ * compile inputs and outputs without importing the compiler's own type surface — which is a wasm
+ * package loaded at runtime, not something the SDK's public types should be pinned to.
+ */
+export {};
+//# sourceMappingURL=compile-types.js.map

package/sdk/dist/routes/compile-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile-types.js","sourceRoot":"","sources":["../../src/routes/compile-types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG"}

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

@@ -0,0 +1,279 @@
+/**
+ * eco-routes on-chain encoding — E3.2.
+ *
+ * Encodes the runtime `Route`/`Reward`/`Intent` shapes (`types.ts`) into the
+ * exact on-chain bytes each chain KIND expects, and computes the intent hash
+ * the Portal contracts commit to. Forks by `ChainKind` (`../chains/canonical.js`):
+ *
+ *  - `evm` (and, for now, `tvm` — see the module doc risk note below) uses
+ *    viem `encodeAbiParameters` against the deployed Portal ABI's `Route`/
+ *    `Reward` tuple shapes.
+ *  - `svm` uses a Borsh schema built from `@solana/kit` codecs, replicating
+ *    the Portal IDL's `Route`/`Reward`/`TokenAmount`/`Call`/`Bytes32` types.
+ *    SVM `Call` has no `value` field.
+ *
+ * SVM PARITY CAVEAT (read before trusting this for a real on-chain intent):
+ * the SVM codec below is a standard Borsh schema built with `@solana/kit`,
+ * replicating the Portal IDL's declared `Route`/`Reward`/`TokenAmount`/`Call`/
+ * `Bytes32` layout (field order, u64 widths, u32-length-prefixed vecs). The
+ * golden vector in `routes-encode.test.ts` was computed from THIS schema and
+ * is independently checkable as correct standard Borsh — it was NOT produced
+ * by running a real `@coral-xyz/anchor` `BorshCoder`. So it pins the schema
+ * against regressions, but does NOT prove parity with the deployed Portal
+ * program's serializer on any cluster, and is NOT an on-chain integration
+ * test. Closing that gap needs one real vector (a mainnet `publish`/
+ * `publishAndFund` whose emitted `intentHash` this module reproduces) —
+ * recommended as a follow-up, not bundled here.
+ *
+ * `ChainKind` is currently `"evm" | "svm"` only — there is no `"tvm"`. A Tron
+ * (or other TVM) chain reaching this module today must already be registered
+ * with `kind: "evm"` (encoding-correct: TVM ABI-encodes identically to EVM;
+ * identity-misleading) or this fork has nothing to dispatch on.
+ */
+import { type Hex } from "viem";
+import { type CanonicalChain, type ChainKind } from "../chains/canonical.js";
+import type { Intent, Reward, Route, UniversalAddress } from "./types.js";
+/** Anything that can select which encoding fork to use: an explicit kind, or anything `resolveChain` accepts
+ *  — including a native `bigint` chain id (eco-routes `Intent.destination`/`sourceChainId` are bigint), so a
+ *  caller can pass those straight through without a silent evm mis-classification. */
+export type ChainKindRef = ChainKind | number | bigint | string | CanonicalChain;
+/**
+ * Resolves a `ChainKindRef` to a `ChainKind`. An explicit `"evm"`/`"svm"`
+ * literal is returned as-is (the escape hatch for a chain id not yet in the
+ * canonical registry). Anything else is looked up via `requireChain`, which
+ * THROWS for an unregistered id — this never silently defaults to `"evm"`.
+ */
+export declare function kindOf(ref: ChainKindRef): ChainKind;
+/** The deployed Portal `Route` tuple shape (`fulfillAndProve.inputs[1]`). */
+export declare const EVM_ROUTE_PARAM: {
+    readonly name: "route";
+    readonly type: "tuple";
+    readonly components: readonly [{
+        readonly name: "salt";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint64";
+    }, {
+        readonly name: "portal";
+        readonly type: "address";
+    }, {
+        readonly name: "nativeAmount";
+        readonly type: "uint256";
+    }, {
+        readonly name: "tokens";
+        readonly type: "tuple[]";
+        readonly components: readonly [{
+            readonly name: "token";
+            readonly type: "address";
+        }, {
+            readonly name: "amount";
+            readonly type: "uint256";
+        }];
+    }, {
+        readonly name: "calls";
+        readonly type: "tuple[]";
+        readonly components: readonly [{
+            readonly name: "target";
+            readonly type: "address";
+        }, {
+            readonly name: "data";
+            readonly type: "bytes";
+        }, {
+            readonly name: "value";
+            readonly type: "uint256";
+        }];
+    }];
+};
+/** The deployed Portal `Reward` tuple shape (`publish.inputs[2]`). */
+export declare const EVM_REWARD_PARAM: {
+    readonly name: "reward";
+    readonly type: "tuple";
+    readonly components: readonly [{
+        readonly name: "deadline";
+        readonly type: "uint64";
+    }, {
+        readonly name: "creator";
+        readonly type: "address";
+    }, {
+        readonly name: "prover";
+        readonly type: "address";
+    }, {
+        readonly name: "nativeAmount";
+        readonly type: "uint256";
+    }, {
+        readonly name: "tokens";
+        readonly type: "tuple[]";
+        readonly components: readonly [{
+            readonly name: "token";
+            readonly type: "address";
+        }, {
+            readonly name: "amount";
+            readonly type: "uint256";
+        }];
+    }];
+};
+/**
+ * Narrows a 32-byte `UniversalAddress` to a 20-byte EVM address. Throws
+ * (rather than silently truncating) if the leading 12 bytes aren't zero —
+ * that shape means the address is not EVM-representable (e.g. a real SVM
+ * pubkey), and truncating it would produce a plausible-looking but wrong hash.
+ */
+export declare function denormalizeToEvm(u: UniversalAddress): Hex;
+/** Encodes a `Route` for an EVM (or TVM) destination via the deployed Portal ABI shape. */
+export declare function encodeRouteEvm(route: Route): Hex;
+/** Encodes a `Reward` for an EVM (or TVM) source via the deployed Portal ABI shape. */
+export declare function encodeRewardEvm(reward: Reward): Hex;
+/** Decodes a `Route` previously produced by `encodeRouteEvm`, re-normalizing addresses back to 32-byte form. */
+export declare function decodeRouteEvm(encoded: Hex): Route;
+/** Decodes a `Reward` previously produced by `encodeRewardEvm`, re-normalizing addresses back to 32-byte form. */
+export declare function decodeRewardEvm(encoded: Hex): Reward;
+/**
+ * Codecs are declared without an explicit `Codec<T>` annotation: `@solana/kit`
+ * decodes a fixed-size byte field as its own `ReadonlyUint8Array` variant,
+ * which isn't structurally assignable to a plain `Uint8Array`-typed field —
+ * pinning the annotation would fight that instead of just letting it infer.
+ * `encode()`/`decode()` call sites below convert at the boundary instead
+ * (`toBytes`, and a plain-`Uint8Array` input object, which IS assignable the
+ * other direction).
+ */
+/** Portal IDL `TokenAmount { token: Bytes32, amount: u64 }`. */
+export declare const svmTokenAmountCodec: import("@solana/kit").FixedSizeCodec<{
+    token: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
+    amount: number | bigint;
+}, {
+    token: import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
+    amount: bigint;
+} & {
+    token: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
+    amount: number | bigint;
+}>;
+/** Portal IDL `Call { target: Bytes32, data: bytes }` — NO `value` field. */
+export declare const svmCallCodec: import("@solana/kit").VariableSizeCodec<{
+    target: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
+    data: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
+}, {
+    target: import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
+    data: import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
+} & {
+    target: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
+    data: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
+}>;
+/** Portal IDL `Route { salt, deadline, portal, native_amount, tokens, calls }`, field order per the IDL. */
+export declare const svmRouteCodec: import("@solana/kit").VariableSizeCodec<{
+    salt: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
+    deadline: number | bigint;
+    portal: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
+    nativeAmount: number | bigint;
+    tokens: {
+        token: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
+        amount: number | bigint;
+    }[];
+    calls: {
+        target: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
+        data: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
+    }[];
+}, {
+    salt: import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
+    deadline: bigint;
+    portal: import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
+    nativeAmount: bigint;
+    tokens: ({
+        token: import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
+        amount: bigint;
+    } & {
+        token: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
+        amount: number | bigint;
+    })[];
+    calls: ({
+        target: import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
+        data: import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
+    } & {
+        target: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
+        data: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
+    })[];
+} & {
+    salt: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
+    deadline: number | bigint;
+    portal: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
+    nativeAmount: number | bigint;
+    tokens: {
+        token: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
+        amount: number | bigint;
+    }[];
+    calls: {
+        target: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
+        data: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
+    }[];
+}>;
+/** Portal IDL `Reward { deadline, creator, prover, native_amount, tokens }`, field order per the IDL. */
+export declare const svmRewardCodec: import("@solana/kit").VariableSizeCodec<{
+    deadline: number | bigint;
+    creator: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
+    prover: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
+    nativeAmount: number | bigint;
+    tokens: {
+        token: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
+        amount: number | bigint;
+    }[];
+}, {
+    deadline: bigint;
+    creator: import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
+    prover: import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
+    nativeAmount: bigint;
+    tokens: ({
+        token: import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
+        amount: bigint;
+    } & {
+        token: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
+        amount: number | bigint;
+    })[];
+} & {
+    deadline: number | bigint;
+    creator: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
+    prover: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
+    nativeAmount: number | bigint;
+    tokens: {
+        token: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
+        amount: number | bigint;
+    }[];
+}>;
+/** Encodes a `Route` for an SVM destination via the Portal IDL's Borsh layout. */
+export declare function encodeRouteSvm(route: Route): Hex;
+/** Encodes a `Reward` for an SVM source via the Portal IDL's Borsh layout. */
+export declare function encodeRewardSvm(reward: Reward): Hex;
+/** Decodes a `Route` previously produced by `encodeRouteSvm`. `calls[].value` is reconstituted as `0n`. */
+export declare function decodeRouteSvm(encoded: Hex): Route;
+/** Decodes a `Reward` previously produced by `encodeRewardSvm`. */
+export declare function decodeRewardSvm(encoded: Hex): Reward;
+/** Encodes a `Route` for the given chain, forking by `ChainKind`. */
+export declare function encodeRoute(route: Route, chain: ChainKindRef): Hex;
+/** Encodes a `Reward` for the given chain, forking by `ChainKind`. */
+export declare function encodeReward(reward: Reward, chain: ChainKindRef): Hex;
+/** Decodes a `Route` for the given chain, forking by `ChainKind`. */
+export declare function decodeRoute(encoded: Hex, chain: ChainKindRef): Route;
+/** Decodes a `Reward` for the given chain, forking by `ChainKind`. */
+export declare function decodeReward(encoded: Hex, chain: ChainKindRef): Reward;
+/** Encodes an `Intent`'s route (for `intent.destination`) and reward (for `intent.sourceChainId`). */
+export declare function encodeIntent(intent: Intent): {
+    route: Hex;
+    reward: Hex;
+};
+/** `keccak256(encodeRoute(route, destination))`. */
+export declare function routeHash(route: Route, destination: ChainKindRef): Hex;
+/** `keccak256(encodeReward(reward, source))`. */
+export declare function rewardHash(reward: Reward, source: ChainKindRef): Hex;
+export interface IntentHashes {
+    readonly intentHash: Hex;
+    readonly routeHash: Hex;
+    readonly rewardHash: Hex;
+}
+/**
+ * Computes the eco-routes intent hash: `keccak256(abi.encodePacked(uint64
+ * destination, bytes32 routeHash, bytes32 rewardHash))`, with the route
+ * encoded for `intent.destination`'s kind and the reward encoded for
+ * `intent.sourceChainId`'s kind — the asymmetry that makes a cross-VM
+ * (e.g. EVM source -> SVM destination) leg hash correctly.
+ */
+export declare function hashIntent(intent: Intent): IntentHashes;
+//# sourceMappingURL=encode.d.ts.map

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

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