@eco-incorp/sauce 0.99.3 → 0.99.5

package/actions/dist/emit.d.ts

@@ -1,20 +1,3 @@
-/**
- * SauceScript source emission — the vocabulary `to-sauce.ts`, `to-quote.ts` and `megas-swap.ts`
- * share now that programs are generated as SOURCE and handed to the published Rust/wasm compiler.
- * The same idiom `sdk/src/deposit/templates.ts` and `sdk/src/token/svm.ts` already use: build
- * statement strings, hand them to one compile seam.
- *
- * Two compiler rules shape everything here, and both are why this module exists rather than each
- * generator formatting its own strings:
- *
- *   1. **A method call's receiver must be a plain identifier or another call.** `hex`…`.concat(x)`,
- *      `(a >> b).toBytesBe(4)` and `t.field.slice(0, 4)` are all rejected with "calling anything
- *      other than a plain function name is not supported in the M1 subset". So every byte literal
- *      is BOUND to a `const` before anything is called on it — that is what [`Fragment`] carries.
- *   2. **A module-scope binding holds one scalar.** A `bytes`/array/tuple initializer at module
- *      scope is rejected outright, so a selector const lives inside the function that uses it, and
- *      two actions of the same kind in one program need two distinct names — hence [`Emitter`].
- */
 /** A SauceScript expression. */
 export type Expr = string;
 /** A SauceScript statement, including its trailing `;`. */
@@ -40,7 +23,6 @@ export declare function formatBigint(value: bigint): Expr;
 export declare function bytesLiteral(bytes: Uint8Array): Expr;
 /** A tuple literal. Fields are positional; the names are a mnemonic the ABI encoder ignores. */
 export declare function tupleLiteral(fields: readonly Expr[]): Expr;
-export declare function arrayLiteral(elements: readonly Expr[]): Expr;
 /**
  * `abi.encode` of an argument list, always wrapped in one tuple.
  *
@@ -52,28 +34,11 @@ export declare function arrayLiteral(elements: readonly Expr[]): Expr;
  * all seven distinct calldata shapes these generators emit.
  */
 export declare function encodeArgs(args: readonly Expr[]): Expr;
-/** The 4-byte selector of a Solidity function signature. */
-export declare function selector(sig: string): Uint8Array;
 export declare function hexToBytes(hex: string): Uint8Array;
 /** Bind `bytes` to a fresh `const` and yield its name. */
 export declare function bindBytes(emit: Emitter, prefix: string, bytes: Uint8Array): Fragment;
 /** Bind `expr` to a fresh `const` and yield its name. */
 export declare function bindConst(emit: Emitter, prefix: string, expr: Expr): Fragment;
-/**
- * Calldata for `sig`: a bound selector const, concatenated with the ABI-encoded arguments. Calldata
- * assembled from pre-encoded blobs instead (UniV4's two-level router input, `balancerV2BatchSwap`'s
- * placeholder splice) uses [`concatCalldata`] over the bound selector directly.
- */
-export declare function calldata(emit: Emitter, sig: string, args: readonly Expr[]): Fragment;
-/** `sel.concat(part, part, …)` — for calldata assembled from pre-encoded blobs. */
-export declare function concatCalldata(sel: Expr, parts: readonly Expr[]): Expr;
-/**
- * A single `uint256` read out of a call's return data.
- *
- * The return data is bound first. That is not tidiness: a projection re-evaluates the object it
- * embeds, so `abi.decode(evm.call(…), ["Uint256"])[0]` would issue the call twice.
- */
-export declare function decodeUint256(emit: Emitter, callExpr: Expr): Fragment;
 /**
  * Indent a statement list into a function body. Every LINE of a multi-line entry is indented, not
  * just its first — an entry may itself be a nested block (a dispatcher branch), and indenting only

package/actions/dist/emit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"emit.d.ts","sourceRoot":"","sources":["../src/emit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH,gCAAgC;AAChC,MAAM,MAAM,IAAI,GAAG,MAAM,CAAC;AAE1B,2DAA2D;AAC3D,MAAM,MAAM,IAAI,GAAG,MAAM,CAAC;AAE1B,gFAAgF;AAChF,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,CAAC;IAChC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;CACrB;AAED,0EAA0E;AAC1E,MAAM,WAAW,OAAO;IACtB,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;CAC9B;AAED,wBAAgB,UAAU,IAAI,OAAO,CAIpC;AAKD;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAQ3C;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAEhD;AAED,yFAAyF;AACzF,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,CAEpD;AAED,gGAAgG;AAChG,wBAAgB,YAAY,CAAC,MAAM,EAAE,SAAS,IAAI,EAAE,GAAG,IAAI,CAE1D;AAED,wBAAgB,YAAY,CAAC,QAAQ,EAAE,SAAS,IAAI,EAAE,GAAG,IAAI,CAE5D;AAED;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,SAAS,IAAI,EAAE,GAAG,IAAI,CAEtD;AAED,4DAA4D;AAC5D,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAEhD;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAQlD;AAED,0DAA0D;AAC1D,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,QAAQ,CAIpF;AAED,yDAAyD;AACzD,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,QAAQ,CAI7E;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,IAAI,EAAE,GAAG,QAAQ,CAKpF;AAED,mFAAmF;AACnF,wBAAgB,cAAc,CAAC,GAAG,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,IAAI,EAAE,GAAG,IAAI,CAEtE;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,IAAI,GAAG,QAAQ,CAIrE;AAED;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,EAAE,KAAK,SAAI,GAAG,MAAM,CAWhE;AAED,qEAAqE;AACrE,wBAAgB,EAAE,CAChB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,SAAS,IAAI,EAAE,GACpB,MAAM,CAER"}
+{"version":3,"file":"emit.d.ts","sourceRoot":"","sources":["../src/emit.ts"],"names":[],"mappings":"AAoBA,gCAAgC;AAChC,MAAM,MAAM,IAAI,GAAG,MAAM,CAAC;AAE1B,2DAA2D;AAC3D,MAAM,MAAM,IAAI,GAAG,MAAM,CAAC;AAE1B,gFAAgF;AAChF,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,CAAC;IAChC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;CACrB;AAED,0EAA0E;AAC1E,MAAM,WAAW,OAAO;IACtB,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;CAC9B;AAED,wBAAgB,UAAU,IAAI,OAAO,CAIpC;AAKD;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAQ3C;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAEhD;AAED,yFAAyF;AACzF,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,CAEpD;AAED,gGAAgG;AAChG,wBAAgB,YAAY,CAAC,MAAM,EAAE,SAAS,IAAI,EAAE,GAAG,IAAI,CAE1D;AAED;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,SAAS,IAAI,EAAE,GAAG,IAAI,CAEtD;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAQlD;AAED,0DAA0D;AAC1D,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,QAAQ,CAIpF;AAED,yDAAyD;AACzD,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,QAAQ,CAI7E;AAED;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,EAAE,KAAK,SAAI,GAAG,MAAM,CAWhE;AAED,qEAAqE;AACrE,wBAAgB,EAAE,CAChB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,SAAS,IAAI,EAAE,GACpB,MAAM,CAER"}

package/actions/dist/emit.js

@@ -1,21 +1,22 @@
 /**
- * SauceScript source emission — the vocabulary `to-sauce.ts`, `to-quote.ts` and `megas-swap.ts`
- * share now that programs are generated as SOURCE and handed to the published Rust/wasm compiler.
- * The same idiom `sdk/src/deposit/templates.ts` and `sdk/src/token/svm.ts` already use: build
- * statement strings, hand them to one compile seam.
+ * SauceScript source emission — the vocabulary `to-sauce.ts`, `to-quote.ts` and `split-swap.ts`
+ * share: build statement strings, hand them to one compile seam.
  *
- * Two compiler rules shape everything here, and both are why this module exists rather than each
- * generator formatting its own strings:
+ * Two compiler rules shape what is here (probed against the pinned compiler, 2.3.0):
  *
- *   1. **A method call's receiver must be a plain identifier or another call.** `hex`…`.concat(x)`,
- *      `(a >> b).toBytesBe(4)` and `t.field.slice(0, 4)` are all rejected with "calling anything
- *      other than a plain function name is not supported in the M1 subset". So every byte literal
- *      is BOUND to a `const` before anything is called on it — that is what [`Fragment`] carries.
+ *   1. **A method call's receiver must be a plain identifier or another call.** `hex`…`.concat(x)`
+ *      and `(a >> b).toBytesBe(4)` are rejected with "calling anything other than a plain function
+ *      name is not supported in the M1 subset". So every byte literal is BOUND to a `const` before
+ *      anything is called on it — that is what [`Fragment`] carries. A binding call,
+ *      `IErc20.at(x).approve(…)`, is fine: its receiver is a call.
  *   2. **A module-scope binding holds one scalar.** A `bytes`/array/tuple initializer at module
- *      scope is rejected outright, so a selector const lives inside the function that uses it, and
- *      two actions of the same kind in one program need two distinct names — hence [`Emitter`].
+ *      scope is rejected outright, so every generated local lives inside the function that uses
+ *      it, and two actions of the same kind in one program need two distinct names — hence
+ *      [`Emitter`].
+ *
+ * `++`/`--` and nested functions are also rejected, so generated loops write `i = i + 1n`.
  */
-import { keccak256, toBytes } from "viem";
+import { bytesToHex } from "viem";
 export function newEmitter() {
     let counter = 0;
     return { name: (prefix) => `${prefix}${counter++}` };
@@ -38,15 +39,12 @@ export function formatBigint(value) {
 }
 /** A `hex` literal. Bind it before calling anything on it — see this module's header. */
 export function bytesLiteral(bytes) {
-    return `hex\`${Buffer.from(bytes).toString("hex")}\``;
+    return `hex\`${bytesToHex(bytes).slice(2)}\``;
 }
 /** A tuple literal. Fields are positional; the names are a mnemonic the ABI encoder ignores. */
 export function tupleLiteral(fields) {
     return `{ ${fields.map((field, i) => `f${i}: ${field}`).join(", ")} }`;
 }
-export function arrayLiteral(elements) {
-    return `[${elements.join(", ")}]`;
-}
 /**
  * `abi.encode` of an argument list, always wrapped in one tuple.
  *
@@ -60,10 +58,6 @@ export function arrayLiteral(elements) {
 export function encodeArgs(args) {
     return `abi.encode(${tupleLiteral(args)})`;
 }
-/** The 4-byte selector of a Solidity function signature. */
-export function selector(sig) {
-    return hexToBytes(keccak256(toBytes(sig)).slice(0, 10));
-}
 export function hexToBytes(hex) {
     const body = hex.startsWith("0x") ? hex.slice(2) : hex;
     const bytes = new Uint8Array(body.length / 2);
@@ -82,31 +76,6 @@ export function bindConst(emit, prefix, expr) {
     const name = emit.name(prefix);
     return { stmts: [`const ${name} = ${expr};`], expr: name };
 }
-/**
- * Calldata for `sig`: a bound selector const, concatenated with the ABI-encoded arguments. Calldata
- * assembled from pre-encoded blobs instead (UniV4's two-level router input, `balancerV2BatchSwap`'s
- * placeholder splice) uses [`concatCalldata`] over the bound selector directly.
- */
-export function calldata(emit, sig, args) {
-    const sel = bindBytes(emit, "sel", selector(sig));
-    if (args.length === 0)
-        return sel;
-    return { stmts: sel.stmts, expr: `${sel.expr}.concat(${encodeArgs(args)})` };
-}
-/** `sel.concat(part, part, …)` — for calldata assembled from pre-encoded blobs. */
-export function concatCalldata(sel, parts) {
-    return parts.length === 0 ? sel : `${sel}.concat(${parts.join(", ")})`;
-}
-/**
- * A single `uint256` read out of a call's return data.
- *
- * The return data is bound first. That is not tidiness: a projection re-evaluates the object it
- * embeds, so `abi.decode(evm.call(…), ["Uint256"])[0]` would issue the call twice.
- */
-export function decodeUint256(emit, callExpr) {
-    const ret = bindConst(emit, "ret", callExpr);
-    return { stmts: ret.stmts, expr: `abi.decode(${ret.expr}, ["Uint256"])[0]` };
-}
 /**
  * Indent a statement list into a function body. Every LINE of a multi-line entry is indented, not
  * just its first — an entry may itself be a nested block (a dispatcher branch), and indenting only

package/actions/dist/index.d.ts

@@ -1,10 +1,13 @@
-export { actionsToSauce, actionsToSauceSource, actionToSauce, buildAction } from "./to-sauce.js";
-export type { ActionResult } from "./to-sauce.js";
-export { actionToQuote } from "./to-quote.js";
-export type { QuoteCall, QuoteOpts } from "./to-quote.js";
-export { megasSwapToSauce, megasSwapToSauceSource, megasUsdcUsdtSwapToSauce, } from "./megas-swap.js";
-export type { MegasSwapOpts } from "./megas-swap.js";
-export { newEmitter } from "./emit.js";
-export type { Emitter, Expr, Fragment, Stmt } from "./emit.js";
+export { parseProgram, serializeProgram } from "./program.js";
+export { ProgramError } from "./semantics.js";
+export type { ProgramIssue } from "./semantics.js";
+export { programSchema } from "./schema.js";
+export type { JsonSchema } from "./schema.js";
+export { compileProgram, programIntent } from "./compose.js";
+export type { ArgumentEncoding, ArgumentValues, CompiledProgram, CompileOptions, } from "./compose.js";
+export { quoteAction } from "./to-quote.js";
+export type { Quote, QuoteOptions } from "./to-quote.js";
+export { compileSplitSwap } from "./split-swap.js";
+export type { SplitSwap } from "./split-swap.js";
 export type * from "./types.js";
 //# sourceMappingURL=index.d.ts.map

package/actions/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACjG,YAAY,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,YAAY,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1D,OAAO,EACL,gBAAgB,EAChB,sBAAsB,EACtB,wBAAwB,GACzB,MAAM,iBAAiB,CAAC;AACzB,YAAY,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACvC,YAAY,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAC/D,mBAAmB,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,YAAY,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,YAAY,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7D,YAAY,EACV,gBAAgB,EAChB,cAAc,EACd,eAAe,EACf,cAAc,GACf,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,YAAY,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAEzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACnD,YAAY,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD,mBAAmB,YAAY,CAAC"}

package/actions/dist/index.js

@@ -1,4 +1,6 @@
-export { actionsToSauce, actionsToSauceSource, actionToSauce, buildAction } from "./to-sauce.js";
-export { actionToQuote } from "./to-quote.js";
-export { megasSwapToSauce, megasSwapToSauceSource, megasUsdcUsdtSwapToSauce, } from "./megas-swap.js";
-export { newEmitter } from "./emit.js";
+export { parseProgram, serializeProgram } from "./program.js";
+export { ProgramError } from "./semantics.js";
+export { programSchema } from "./schema.js";
+export { compileProgram, programIntent } from "./compose.js";
+export { quoteAction } from "./to-quote.js";
+export { compileSplitSwap } from "./split-swap.js";

package/actions/dist/program.d.ts

@@ -0,0 +1,23 @@
+import { type ActionSpec } from "./spec.js";
+import type { Action, ActionProgram } from "./types.js";
+/** The action-program format version this package reads and writes. */
+export declare const PROGRAM_VERSION = 1;
+/** The keys an action of `spec` may carry, in canonical (serialization) order. */
+export declare function actionKeys(spec: ActionSpec): string[];
+/**
+ * Checks each of `values` as an action on its own — shape only, no chaining rules — and returns
+ * them as canonical copies. Throws a `ProgramError` whose paths start at `path`.
+ */
+export declare function parseActions(values: readonly unknown[], path: string): Action[];
+/**
+ * Parses and validates an action program — JSON text, or an already-parsed value. Returns a fresh
+ * copy with its keys in canonical order. Throws a `ProgramError` whose `issues` lists every
+ * problem, each with its path.
+ */
+export declare function parseProgram(input: unknown): ActionProgram;
+/**
+ * The canonical JSON text of `program`: validated first, keys in schema order, so two equal
+ * programs serialize to the same text. `space` indents as `JSON.stringify` does.
+ */
+export declare function serializeProgram(program: ActionProgram, space?: number | string): string;
+//# sourceMappingURL=program.d.ts.map

package/actions/dist/program.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"program.d.ts","sourceRoot":"","sources":["../src/program.ts"],"names":[],"mappings":"AAcA,OAAO,EAGL,KAAK,UAAU,EAIhB,MAAM,WAAW,CAAC;AAEnB,OAAO,KAAK,EAAE,MAAM,EAAE,aAAa,EAAc,MAAM,YAAY,CAAC;AAEpE,uEAAuE;AACvE,eAAO,MAAM,eAAe,IAAI,CAAC;AA0NjC,kFAAkF;AAClF,wBAAgB,UAAU,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,EAAE,CAQrD;AA4FD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAM/E;AAqED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,aAAa,CAK1D;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,aAAa,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAExF"}

package/actions/dist/program.js

@@ -0,0 +1,358 @@
+/**
+ * Action programs as JSON: strict parsing with located errors, and canonical serialization.
+ *
+ * A program is plain data — `{ version, chainId, actions }` — so it can be written by hand, stored,
+ * signed, sent to another service, or produced in any language against the published JSON Schema
+ * (`action-program.schema.json`). `parseProgram` accepts exactly what that schema accepts and then
+ * applies the rules a schema cannot express (`semantics.ts`); every problem is reported with its
+ * path, not just the first.
+ *
+ * Round trip: for any program `p` this module accepts, `parseProgram(serializeProgram(p))`
+ * deep-equals `p`. Parsing only reorders keys; it fills in no defaults.
+ */
+import { getAddress } from "viem";
+import { ACTION_SPECS, ACTION_TYPES, } from "./spec.js";
+import { IDENTIFIER_RE, ProgramError, programIssues } from "./semantics.js";
+/** The action-program format version this package reads and writes. */
+export const PROGRAM_VERSION = 1;
+const UINT_RE = /^(0|[1-9][0-9]*)$/;
+const ADDRESS_RE = /^0x[0-9a-fA-F]{40}$/;
+const BYTES_RE = /^0x(?:[0-9a-fA-F]{2})*$/;
+const BYTES32_RE = /^0x[0-9a-fA-F]{64}$/;
+const PROGRAM_KEYS = ["$schema", "version", "chainId", "actions"];
+function describe(value) {
+    if (value === null)
+        return "null";
+    if (Array.isArray(value))
+        return "an array";
+    if (typeof value === "string")
+        return JSON.stringify(value.length > 48 ? `${value.slice(0, 45)}...` : value);
+    if (typeof value === "object")
+        return "an object";
+    return `${typeof value} ${String(value)}`;
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** A key that is present. An `undefined` value — which JSON cannot carry — counts as absent. */
+function has(value, key) {
+    return key in value && value[key] !== undefined;
+}
+/** The closest of `candidates` to `word`, when it is close enough to be a likely typo. */
+function suggest(word, candidates) {
+    const distance = (a, b) => {
+        const row = Array.from({ length: b.length + 1 }, (_, j) => j);
+        for (let i = 1; i <= a.length; i++) {
+            let prev = row[0];
+            row[0] = i;
+            for (let j = 1; j <= b.length; j++) {
+                const next = row[j];
+                row[j] = Math.min(row[j] + 1, row[j - 1] + 1, prev + (a[i - 1] === b[j - 1] ? 0 : 1));
+                prev = next;
+            }
+        }
+        return row[b.length];
+    };
+    let best;
+    let bestDistance = Infinity;
+    for (const candidate of candidates) {
+        const d = distance(word.toLowerCase(), candidate.toLowerCase());
+        if (d < bestDistance) {
+            bestDistance = d;
+            best = candidate;
+        }
+    }
+    return bestDistance <= Math.max(2, Math.floor(word.length / 4)) ? best : undefined;
+}
+class Checker {
+    issues = [];
+    fail(path, message) {
+        this.issues.push({ path, message });
+    }
+    /** Checks `value` against `kind`; returns false (having recorded why) when it does not match. */
+    value(path, value, kind) {
+        const start = this.issues.length;
+        switch (kind.k) {
+            case "address":
+                this.address(path, value);
+                break;
+            case "recipient":
+                if (value !== "self")
+                    this.address(path, value, ' or "self"');
+                break;
+            case "remoteRecipient":
+                if (typeof value === "string" && BYTES32_RE.test(value))
+                    break;
+                this.address(path, value, " or a 32-byte account (0x + 64 hex digits)");
+                break;
+            case "uint":
+                if (typeof value === "bigint") {
+                    this.fail(path, `expected a base-10 string, got the bigint ${value} — JSON has no bigint: write "${value}"`);
+                }
+                else if (typeof value === "number") {
+                    this.fail(path, `expected a base-10 string, got the JSON number ${value} — JSON numbers lose precision ` +
+                        `above 2^53, so amounts are strings: write ${JSON.stringify(Number.isInteger(value) && value >= 0 ? BigInt(value).toString() : "123")}`);
+                }
+                else if (typeof value !== "string" || !UINT_RE.test(value)) {
+                    this.fail(path, `expected a base-10 unsigned integer string (digits only, no sign, exponent or leading zeros), got ${describe(value)}`);
+                }
+                else if (BigInt(value) >= 1n << BigInt(kind.bits)) {
+                    this.fail(path, `${value} does not fit in ${kind.bits} bits`);
+                }
+                break;
+            case "bytes":
+                if (typeof value !== "string" || !BYTES_RE.test(value))
+                    this.fail(path, `expected 0x-prefixed hex bytes (an even number of hex digits), got ${describe(value)}`);
+                break;
+            case "bytes32":
+                if (typeof value !== "string" || !BYTES32_RE.test(value))
+                    this.fail(path, `expected 32 bytes: 0x + 64 hex digits, got ${describe(value)}`);
+                break;
+            case "int":
+                if (typeof value !== "number" || !Number.isInteger(value)) {
+                    this.fail(path, `expected a JSON integer, got ${describe(value)}`);
+                }
+                else if (value < kind.min || value > kind.max) {
+                    this.fail(path, `${value} is outside ${kind.min}..${kind.max}`);
+                }
+                break;
+            case "enum":
+                if (!kind.values.includes(value))
+                    this.fail(path, `expected one of ${kind.values.map((v) => JSON.stringify(v)).join(", ")}, got ${describe(value)}`);
+                break;
+            case "bool":
+                if (typeof value !== "boolean")
+                    this.fail(path, `expected true or false, got ${describe(value)}`);
+                break;
+            case "identifier":
+                if (typeof value !== "string" || !IDENTIFIER_RE.test(value))
+                    this.fail(path, `expected an identifier ([A-Za-z_$][A-Za-z0-9_$]*), got ${describe(value)}`);
+                break;
+            case "array":
+                if (!Array.isArray(value)) {
+                    this.fail(path, `expected an array, got ${describe(value)}`);
+                    break;
+                }
+                if (kind.min !== undefined && value.length < kind.min)
+                    this.fail(path, `expected at least ${kind.min} ${kind.min === 1 ? "entry" : "entries"}, got ${value.length}`);
+                if (kind.max !== undefined && value.length > kind.max)
+                    this.fail(path, `expected at most ${kind.max} entries, got ${value.length}`);
+                value.forEach((item, i) => this.value(`${path}[${i}]`, item, kind.of));
+                break;
+            case "tuple":
+                if (!Array.isArray(value) || value.length !== kind.of.length) {
+                    this.fail(path, `expected an array of exactly ${kind.of.length} entries, got ${describe(value)}${Array.isArray(value) ? ` of ${value.length}` : ""}`);
+                    break;
+                }
+                value.forEach((item, i) => this.value(`${path}[${i}]`, item, kind.of[i]));
+                break;
+            case "object":
+                this.object(path, value, kind.fields, []);
+                break;
+        }
+        return this.issues.length === start;
+    }
+    address(path, value, alternative = "") {
+        if (typeof value !== "string" || !ADDRESS_RE.test(value)) {
+            this.fail(path, `expected an address (0x + 40 hex digits)${alternative}, got ${describe(value)}`);
+            return;
+        }
+        const hex = value.slice(2);
+        const mixedCase = hex !== hex.toLowerCase() && hex !== hex.toUpperCase();
+        if (mixedCase && getAddress(value) !== value) {
+            this.fail(path, `${value} has an invalid EIP-55 checksum (expected ${getAddress(value)}); write it all-lowercase to skip the check`);
+        }
+    }
+    /** Checks an object's fields; `extra` names keys handled by the caller. */
+    object(path, value, fields, extra) {
+        if (!isPlainObject(value)) {
+            this.fail(path, `expected an object, got ${describe(value)}`);
+            return false;
+        }
+        const known = [...Object.keys(fields), ...extra];
+        for (const key of Object.keys(value)) {
+            if (!known.includes(key) && has(value, key)) {
+                const hint = suggest(key, known);
+                this.fail(`${path}.${key}`, `unknown field${hint ? ` — did you mean \`${hint}\`?` : ""} (allowed: ${known.join(", ")})`);
+            }
+        }
+        for (const [key, def] of Object.entries(fields)) {
+            if (!has(value, key)) {
+                if (!def.optional)
+                    this.fail(`${path}.${key}`, `missing (${def.doc})`);
+                continue;
+            }
+            this.value(`${path}.${key}`, value[key], def.kind);
+        }
+        return true;
+    }
+}
+/** The keys an action of `spec` may carry, in canonical (serialization) order. */
+export function actionKeys(spec) {
+    return [
+        "type",
+        ...(spec.spends ? ["amount"] : []),
+        ...Object.keys(spec.fields),
+        ...(spec.spends ? ["amountRef"] : []),
+        "saveOutputAs",
+    ];
+}
+function checkAction(c, path, value) {
+    if (!isPlainObject(value)) {
+        c.fail(path, `expected an action object, got ${describe(value)}`);
+        return undefined;
+    }
+    const type = value.type;
+    if (typeof type !== "string" || !(type in ACTION_SPECS)) {
+        const hint = typeof type === "string" ? suggest(type, ACTION_TYPES) : undefined;
+        c.fail(`${path}.type`, type === undefined
+            ? "missing — every action names its `type`"
+            : `unknown action type ${describe(type)}${hint ? ` — did you mean "${hint}"?` : ""}`);
+        return undefined;
+    }
+    const spec = ACTION_SPECS[type];
+    const extra = ["type", "saveOutputAs"];
+    if (spec.spends) {
+        extra.push("amount", "amountRef");
+    }
+    else {
+        // Reported here, once, with the reason — not also as an unknown field.
+        for (const key of ["amount", "amountRef"]) {
+            if (!has(value, key))
+                continue;
+            c.fail(`${path}.${key}`, spec.group === "source"
+                ? `${type} spends nothing, so it takes no \`${key}\``
+                : `${type} takes its amounts from its own fields, so it takes no \`${key}\``);
+            extra.push(key);
+        }
+    }
+    const before = c.issues.length;
+    if (!c.object(path, value, spec.fields, extra))
+        return undefined;
+    if (spec.spends && has(value, "amount"))
+        c.value(`${path}.amount`, value.amount, { k: "uint", bits: 256 });
+    for (const key of ["saveOutputAs", "amountRef"]) {
+        if (has(value, key) && (key === "saveOutputAs" || spec.spends))
+            c.value(`${path}.${key}`, value[key], { k: "identifier" });
+    }
+    if (type === "balancerV2BatchSwap" && Array.isArray(value.steps) && Array.isArray(value.assets)) {
+        const assets = value.assets.length;
+        value.steps.forEach((step, i) => {
+            if (!isPlainObject(step))
+                return;
+            for (const key of ["assetInIndex", "assetOutIndex"]) {
+                const index = step[key];
+                if (typeof index === "number" && index >= assets) {
+                    c.fail(`${path}.steps[${i}].${key}`, `${index} is not an index into \`assets\` (${assets} entries)`);
+                }
+            }
+        });
+    }
+    if (c.issues.length > before)
+        return undefined;
+    // A deep copy, in canonical key order.
+    const copy = JSON.parse(JSON.stringify(value));
+    return ordered(copy, actionKeys(spec), spec.fields);
+}
+/** `value` rebuilt with its keys in `keys` order (nested objects follow their field order too). */
+function ordered(value, keys, fields) {
+    const out = {};
+    for (const key of keys) {
+        if (!(key in value))
+            continue;
+        const def = fields[key];
+        out[key] = def ? orderedValue(value[key], def.kind) : value[key];
+    }
+    return out;
+}
+function orderedValue(value, kind) {
+    if (kind.k === "object" && isPlainObject(value))
+        return ordered(value, Object.keys(kind.fields), kind.fields);
+    if (kind.k === "array" && Array.isArray(value))
+        return value.map((item) => orderedValue(item, kind.of));
+    return value;
+}
+/**
+ * Checks each of `values` as an action on its own — shape only, no chaining rules — and returns
+ * them as canonical copies. Throws a `ProgramError` whose paths start at `path`.
+ */
+export function parseActions(values, path) {
+    const c = new Checker();
+    const actions = values.flatMap((value, i) => checkAction(c, `${path}[${i}]`, value) ?? []);
+    if (c.issues.length > 0)
+        throw new ProgramError(c.issues);
+    return actions;
+}
+function check(input) {
+    const c = new Checker();
+    let value = input;
+    if (typeof input === "string") {
+        try {
+            value = JSON.parse(input);
+        }
+        catch (error) {
+            return { issues: [{ path: "$", message: `not valid JSON: ${error.message}` }] };
+        }
+    }
+    if (!isPlainObject(value)) {
+        c.fail("$", `expected an action program object ({ version, chainId, actions }), got ${describe(value)}`);
+        return { issues: c.issues };
+    }
+    for (const key of Object.keys(value)) {
+        if (!PROGRAM_KEYS.includes(key) && has(value, key)) {
+            const hint = suggest(key, PROGRAM_KEYS);
+            c.fail(key, `unknown field${hint ? ` — did you mean \`${hint}\`?` : ""} (allowed: ${PROGRAM_KEYS.join(", ")})`);
+        }
+    }
+    if (has(value, "$schema") && typeof value.$schema !== "string")
+        c.fail("$schema", `expected a string, got ${describe(value.$schema)}`);
+    if (value.version !== PROGRAM_VERSION) {
+        c.fail("version", value.version === undefined
+            ? `missing — set it to ${PROGRAM_VERSION}`
+            : `unsupported version ${describe(value.version)}; this package reads version ${PROGRAM_VERSION}`);
+    }
+    if (has(value, "chainId"))
+        c.value("chainId", value.chainId, { k: "int", min: 1, max: Number.MAX_SAFE_INTEGER });
+    else
+        c.fail("chainId", "missing — the chain every action executes on");
+    const actions = [];
+    if (!Array.isArray(value.actions)) {
+        c.fail("actions", value.actions === undefined
+            ? "missing"
+            : `expected an array of actions, got ${describe(value.actions)}`);
+    }
+    else if (value.actions.length === 0) {
+        c.fail("actions", "is empty — a program needs at least one action");
+    }
+    else {
+        value.actions.forEach((raw, i) => {
+            const action = checkAction(c, `actions[${i}]`, raw);
+            if (action)
+                actions.push(action);
+        });
+    }
+    // The chaining rules read every action, so they run only once every action is well formed.
+    if (c.issues.length === 0)
+        c.issues.push(...programIssues(actions, value.chainId));
+    if (c.issues.length > 0)
+        return { issues: c.issues };
+    return { program: { version: PROGRAM_VERSION, chainId: value.chainId, actions } };
+}
+/**
+ * Parses and validates an action program — JSON text, or an already-parsed value. Returns a fresh
+ * copy with its keys in canonical order. Throws a `ProgramError` whose `issues` lists every
+ * problem, each with its path.
+ */
+export function parseProgram(input) {
+    const result = check(input);
+    if ("issues" in result)
+        throw new ProgramError(result.issues);
+    return result.program;
+}
+/**
+ * The canonical JSON text of `program`: validated first, keys in schema order, so two equal
+ * programs serialize to the same text. `space` indents as `JSON.stringify` does.
+ */
+export function serializeProgram(program, space) {
+    return JSON.stringify(parseProgram(program), null, space);
+}

package/actions/dist/registry.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The SDK modules the actions build on: protocol-registry ABIs for the bindings and the quotes, and
+ * the SDK's `SafeERC20` ERC-20 write lowering.
+ *
+ * Imported by RELATIVE path into the SDK's build output, not by package name, and that is the one
+ * spelling that resolves in both layouts this code runs in: in the repository `actions/src/` and
+ * `sdk/dist/` are siblings under the root, and in the published `@eco-incorp/sauce` tarball
+ * `actions/dist/` and `sdk/dist/` are siblings under the package root. A package name would need the
+ * private workspace package (`@eco-incorp/sauce-source`), which is not published. The cost is build
+ * order: the SDK must be built before this package is typechecked, built or tested — `pnpm build`
+ * orders the two, and CI builds the SDK first.
+ *
+ * Each registry module is a protocol's public entry (`@eco-incorp/sauce/protocols/<slug>`), not a
+ * file inside it. `token/safe` is the SDK's own lowering of `approve`/`transfer` with OpenZeppelin
+ * `SafeERC20` semantics (a USDT `approve` returns no `bool`, and a stale allowance is reset first);
+ * every SDK token write uses the same one, so the SDK has one ERC-20 write path.
+ */
+export { ERC20ABI } from "../../sdk/dist/protocols/erc20/index.js";
+export { PoolABI as AaveV3PoolABI } from "../../sdk/dist/protocols/aave-v3/index.js";
+export { CometABI } from "../../sdk/dist/protocols/compound-v3/index.js";
+export { AcrossSpokePoolABI } from "../../sdk/dist/protocols/across/index.js";
+export { CrocSwapDexABI } from "../../sdk/dist/protocols/ambient/index.js";
+export { BalancerV2VaultABI } from "../../sdk/dist/protocols/balancer-v2/index.js";
+export { CurveRouterNGABI, CurveThreePoolABI } from "../../sdk/dist/protocols/curve/index.js";
+export { DODOV2ProxyABI } from "../../sdk/dist/protocols/dodo/index.js";
+export { LidoABI, WstETHABI } from "../../sdk/dist/protocols/lido/index.js";
+export { LiquidityPoolABI } from "../../sdk/dist/protocols/etherfi/index.js";
+export { MaverickV2RouterABI } from "../../sdk/dist/protocols/maverick/index.js";
+export { Permit2ABI } from "../../sdk/dist/protocols/permit2/index.js";
+export { RETHABI, RocketDepositPoolABI } from "../../sdk/dist/protocols/rocket-pool/index.js";
+export { StargatePoolABI } from "../../sdk/dist/protocols/stargate/index.js";
+export { TokenMessengerABI } from "../../sdk/dist/protocols/cctp/index.js";
+export { UniswapV2RouterABI } from "../../sdk/dist/protocols/uniswap-v2/index.js";
+export { UniswapV3QuoterV2ABI, UniswapV3SwapRouter02ABI, } from "../../sdk/dist/protocols/uniswap-v3/index.js";
+export { UniswapV4UniversalRouterABI } from "../../sdk/dist/protocols/uniswap-v4/index.js";
+export { safeApproveStatements, safeTransferStatements, type WordArg, } from "../../sdk/dist/token/safe.js";
+//# sourceMappingURL=registry.d.ts.map

package/actions/dist/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,yCAAyC,CAAC;AACnE,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,2CAA2C,CAAC;AACrF,OAAO,EAAE,QAAQ,EAAE,MAAM,+CAA+C,CAAC;AACzE,OAAO,EAAE,kBAAkB,EAAE,MAAM,0CAA0C,CAAC;AAC9E,OAAO,EAAE,cAAc,EAAE,MAAM,2CAA2C,CAAC;AAC3E,OAAO,EAAE,kBAAkB,EAAE,MAAM,+CAA+C,CAAC;AACnF,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,yCAAyC,CAAC;AAC9F,OAAO,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAC;AACxE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,wCAAwC,CAAC;AAC5E,OAAO,EAAE,gBAAgB,EAAE,MAAM,2CAA2C,CAAC;AAC7E,OAAO,EAAE,mBAAmB,EAAE,MAAM,4CAA4C,CAAC;AACjF,OAAO,EAAE,UAAU,EAAE,MAAM,2CAA2C,CAAC;AACvE,OAAO,EAAE,OAAO,EAAE,oBAAoB,EAAE,MAAM,+CAA+C,CAAC;AAC9F,OAAO,EAAE,eAAe,EAAE,MAAM,4CAA4C,CAAC;AAC7E,OAAO,EAAE,iBAAiB,EAAE,MAAM,wCAAwC,CAAC;AAC3E,OAAO,EAAE,kBAAkB,EAAE,MAAM,8CAA8C,CAAC;AAClF,OAAO,EACL,oBAAoB,EACpB,wBAAwB,GACzB,MAAM,8CAA8C,CAAC;AACtD,OAAO,EAAE,2BAA2B,EAAE,MAAM,8CAA8C,CAAC;AAC3F,OAAO,EACL,qBAAqB,EACrB,sBAAsB,EACtB,KAAK,OAAO,GACb,MAAM,8BAA8B,CAAC"}