@eco-incorp/sauce 0.99.4 → 0.99.6

package/actions/dist/registry.js

@@ -0,0 +1,36 @@
+/**
+ * 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, } from "../../sdk/dist/token/safe.js";

package/actions/dist/schema.d.ts

@@ -0,0 +1,6 @@
+export type JsonSchema = {
+    readonly [key: string]: unknown;
+};
+/** The JSON Schema every action program satisfies. */
+export declare function programSchema(): JsonSchema;
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAuBA,MAAM,MAAM,UAAU,GAAG;IAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,CAAC;AAmI7D,sDAAsD;AACtD,wBAAgB,aAAa,IAAI,UAAU,CAoC1C"}

package/actions/dist/schema.js

@@ -0,0 +1,166 @@
+/**
+ * The action-program JSON Schema (draft 2020-12), generated from the same table the parser reads
+ * (`spec.ts`), for clients that are not written in TypeScript.
+ *
+ * The schema is exact about shape and deliberately silent about three things it cannot express,
+ * which `parseProgram` enforces and the schema's `description` states: an address's EIP-55
+ * checksum, an amount's numeric range beyond its digit count, and the chaining rules across actions
+ * (`semantics.ts`). A document the schema rejects is always rejected by the parser; the reverse
+ * holds only for those three.
+ *
+ * `actions/action-program.schema.json` is this function's output, committed so it can be read and
+ * fetched without running anything; a unit test fails when the two drift.
+ */
+import { ACTION_SPECS, ACTION_TYPES, } from "./spec.js";
+import { actionKeys, PROGRAM_VERSION } from "./program.js";
+/** Decimal digits of the largest `bits`-bit unsigned integer. */
+function maxDigits(bits) {
+    return ((1n << BigInt(bits)) - 1n).toString().length;
+}
+const DEFS = {
+    address: {
+        type: "string",
+        pattern: "^0x[0-9a-fA-F]{40}$",
+        description: "An address: 0x + 40 hex digits. A mixed-case address must carry a valid EIP-55 checksum.",
+    },
+    recipient: {
+        description: 'An address, or "self" for the executing Pot.',
+        oneOf: [{ $ref: "#/$defs/address" }, { const: "self" }],
+    },
+    remoteRecipient: {
+        description: "An address, or a 32-byte account on a non-EVM destination (0x + 64 hex digits).",
+        oneOf: [{ $ref: "#/$defs/address" }, { $ref: "#/$defs/bytes32" }],
+    },
+    bytes: {
+        type: "string",
+        pattern: "^0x(?:[0-9a-fA-F]{2})*$",
+        description: "0x-prefixed hex bytes, an even number of digits.",
+    },
+    bytes32: {
+        type: "string",
+        pattern: "^0x[0-9a-fA-F]{64}$",
+        description: "32 bytes: 0x + 64 hex digits.",
+    },
+    identifier: {
+        type: "string",
+        pattern: "^[A-Za-z_$][A-Za-z0-9_$]*$",
+        description: "A name that becomes a local variable in the emitted SauceScript.",
+    },
+    chainId: { type: "integer", minimum: 1, maximum: Number.MAX_SAFE_INTEGER },
+};
+function kindSchema(kind) {
+    switch (kind.k) {
+        case "address":
+        case "recipient":
+        case "remoteRecipient":
+        case "bytes":
+        case "bytes32":
+        case "identifier":
+            return { $ref: `#/$defs/${kind.k}` };
+        case "uint":
+            return {
+                type: "string",
+                pattern: "^(0|[1-9][0-9]*)$",
+                maxLength: maxDigits(kind.bits),
+                description: `A base-10 unsigned integer of at most ${kind.bits} bits.`,
+            };
+        case "int":
+            return { type: "integer", minimum: kind.min, maximum: kind.max };
+        case "enum":
+            return { enum: [...kind.values] };
+        case "bool":
+            return { type: "boolean" };
+        case "array":
+            return {
+                type: "array",
+                items: kindSchema(kind.of),
+                ...(kind.min !== undefined ? { minItems: kind.min } : {}),
+                ...(kind.max !== undefined ? { maxItems: kind.max } : {}),
+            };
+        case "tuple":
+            return {
+                type: "array",
+                prefixItems: kind.of.map(kindSchema),
+                items: false,
+                minItems: kind.of.length,
+            };
+        case "object":
+            return objectSchema(kind.fields, {});
+    }
+}
+function field(def) {
+    return { ...kindSchema(def.kind), description: def.doc };
+}
+function objectSchema(fields, extra) {
+    const properties = { ...extra };
+    for (const [key, def] of Object.entries(fields))
+        properties[key] = field(def);
+    const required = Object.entries(fields)
+        .filter(([, def]) => !def.optional)
+        .map(([key]) => key);
+    return { type: "object", additionalProperties: false, required, properties };
+}
+function actionSchema(spec) {
+    const extra = { type: { const: spec.type } };
+    if (spec.spends) {
+        extra.amount = {
+            ...kindSchema({ k: "uint", bits: 256 }),
+            description: "The amount this action spends. Omit it (and amountRef) to spend the previous action's output.",
+        };
+        extra.amountRef = {
+            $ref: "#/$defs/identifier",
+            description: "Spend the output an earlier action saved under this name.",
+        };
+    }
+    extra.saveOutputAs = {
+        $ref: "#/$defs/identifier",
+        description: "Save this action's output under a name later actions can reference.",
+    };
+    const schema = objectSchema(spec.fields, extra);
+    const properties = schema.properties;
+    // Properties in canonical order, which is the order `serializeProgram` writes.
+    const orderedProperties = Object.fromEntries(actionKeys(spec)
+        .filter((key) => key in properties)
+        .map((key) => [key, properties[key]]));
+    return {
+        title: spec.type,
+        description: `${spec.summary} Calls ${spec.calls}.`,
+        ...schema,
+        required: ["type", ...schema.required],
+        properties: orderedProperties,
+    };
+}
+/** The JSON Schema every action program satisfies. */
+export function programSchema() {
+    const actionDefs = Object.fromEntries(ACTION_TYPES.map((type) => [`action_${type}`, actionSchema(ACTION_SPECS[type])]));
+    return {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        $id: `urn:eco-incorp:sauce:action-program:${PROGRAM_VERSION}`,
+        title: "Sauce action program",
+        description: "A sequence of protocol actions that compiles to one Sauce program executing on one chain. " +
+            "Amounts are base-10 strings. Beyond this schema, a program must satisfy: every address with " +
+            "mixed-case hex carries a valid EIP-55 checksum; every amount fits its declared width; a " +
+            "first action that takes an amount sets `amount`; an amountRef names a " +
+            "saveOutputAs set by an earlier action, and is not combined with `amount`; argument names " +
+            "are unique; and the value of every balanceOf/nativeBalance/argument action is read.",
+        type: "object",
+        additionalProperties: false,
+        required: ["version", "chainId", "actions"],
+        properties: {
+            $schema: { type: "string", description: "The schema this document declares; ignored." },
+            version: { const: PROGRAM_VERSION },
+            chainId: { $ref: "#/$defs/chainId", description: "The chain every action executes on." },
+            actions: {
+                type: "array",
+                minItems: 1,
+                items: { $ref: "#/$defs/action" },
+                description: "The actions, in execution order.",
+            },
+        },
+        $defs: {
+            ...DEFS,
+            action: { oneOf: ACTION_TYPES.map((type) => ({ $ref: `#/$defs/action_${type}` })) },
+            ...actionDefs,
+        },
+    };
+}

package/actions/dist/semantics.d.ts

@@ -0,0 +1,18 @@
+import type { Action } from "./types.js";
+/** One problem with a program, located by a path into the document (`actions[2].amountRef`). */
+export interface ProgramIssue {
+    readonly path: string;
+    readonly message: string;
+}
+/** Thrown for a program that breaks any rule. `issues` lists every problem found, in order. */
+export declare class ProgramError extends Error {
+    readonly issues: readonly ProgramIssue[];
+    constructor(issues: readonly ProgramIssue[]);
+}
+/** A chaining name becomes a SauceScript local, so it has to be spellable as one. */
+export declare const IDENTIFIER_RE: RegExp;
+/** True when `action` spends the previous action's output: it could take an amount, and has none. */
+export declare function consumesPrevious(action: Action): boolean;
+/** Every rule `actions` breaks on `chainId`. */
+export declare function programIssues(actions: readonly Action[], chainId?: number): ProgramIssue[];
+//# sourceMappingURL=semantics.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"semantics.d.ts","sourceRoot":"","sources":["../src/semantics.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,MAAM,EAAc,MAAM,YAAY,CAAC;AAErD,gGAAgG;AAChG,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,+FAA+F;AAC/F,qBAAa,YAAa,SAAQ,KAAK;IACrC,QAAQ,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,CAAC;gBAE7B,MAAM,EAAE,SAAS,YAAY,EAAE;CAQ5C;AAED,qFAAqF;AACrF,eAAO,MAAM,aAAa,QAA+B,CAAC;AAM1D,qGAAqG;AACrG,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAMxD;AA+ED,gDAAgD;AAChD,wBAAgB,aAAa,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,YAAY,EAAE,CA+D1F"}

package/actions/dist/semantics.js

@@ -0,0 +1,164 @@
+/**
+ * The rules an action list must satisfy beyond each action's own shape: where every amount comes
+ * from, and that every value a source action produces is read. `program.ts` runs the structural
+ * checks first, so by the time these run every field has its declared type.
+ */
+import { getChain, nativeErc20 } from "../../sdk/dist/chains/index.js";
+import { ACTION_SPECS } from "./spec.js";
+/** Thrown for a program that breaks any rule. `issues` lists every problem found, in order. */
+export class ProgramError extends Error {
+    issues;
+    constructor(issues) {
+        super(`invalid action program (${issues.length} ${issues.length === 1 ? "issue" : "issues"}):\n` +
+            issues.map((i) => `  ${i.path}: ${i.message}`).join("\n"));
+        this.name = "ProgramError";
+        this.issues = issues;
+    }
+}
+/** A chaining name becomes a SauceScript local, so it has to be spellable as one. */
+export const IDENTIFIER_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function field(action, key) {
+    return action[key];
+}
+/** True when `action` spends the previous action's output: it could take an amount, and has none. */
+export function consumesPrevious(action) {
+    return (ACTION_SPECS[action.type].spends &&
+        field(action, "amount") === undefined &&
+        field(action, "amountRef") === undefined);
+}
+/**
+ * Actions that exist only because the native coin is ETH with a canonical WETH9: they wrap or
+ * unwrap it, or stake it as ETH. Where the native coin is itself an ERC-20 (Arc's USDC) none of
+ * them has a meaning — there is nothing to wrap, and native value is not ETH.
+ */
+const NATIVE_ETH_ACTIONS = new Set([
+    "wrapETH",
+    "unwrapETH",
+    "lidoStake",
+    "rocketPoolStake",
+    "etherFiStake",
+]);
+/** The actions that read `actions[i]`'s output: the next one implicitly, or later ones by name. */
+function readersOf(actions, i) {
+    const readers = [];
+    const next = actions[i + 1];
+    if (next !== undefined && consumesPrevious(next))
+        readers.push(i + 1);
+    const name = actions[i].saveOutputAs;
+    if (name === undefined)
+        return readers;
+    for (let k = i + 1; k < actions.length; k++) {
+        if (field(actions[k], "amountRef") === name && !readers.includes(k))
+            readers.push(k);
+        // A later action saving the same name reassigns it; readers after that read the new value.
+        if (actions[k].saveOutputAs === name)
+            break;
+    }
+    return readers;
+}
+/**
+ * The rules a chain whose native coin is an ERC-20 adds (Arc: USDC, 18 decimals natively and 6
+ * through the ERC-20 at `0x3600…0000`, one balance). Empty on every other chain.
+ */
+function nativeErc20Issues(actions, chainId) {
+    const erc20 = nativeErc20(chainId);
+    const chain = getChain(chainId);
+    if (erc20 === undefined || chain === undefined)
+        return [];
+    const native = chain.nativeCurrency;
+    const where = `${chain.name} (chain ${chainId})`;
+    const issues = [];
+    actions.forEach((action, i) => {
+        if (NATIVE_ETH_ACTIONS.has(action.type)) {
+            issues.push({
+                path: `actions[${i}]`,
+                message: `${action.type} needs native ETH and a canonical WETH9, and ${where} has neither: ` +
+                    `its native coin is ${native.symbol}, which is already the ERC-20 at ${erc20.address}. ` +
+                    "Spend that token directly — there is nothing to wrap",
+            });
+        }
+        if (action.type === "balancerV3Swap" && action.wethIsEth) {
+            issues.push({
+                path: `actions[${i}].wethIsEth`,
+                message: `${where} has no canonical wrapped native for the router to pay or receive as ` +
+                    "native; set it to false",
+            });
+        }
+        if (action.type === "nativeBalance") {
+            for (const k of readersOf(actions, i)) {
+                const reader = actions[k];
+                if (ACTION_SPECS[reader.type].value === "amount")
+                    continue; // spent as native value
+                issues.push({
+                    path: `actions[${i}]`,
+                    message: `on ${where} the native balance is ${native.symbol} at ${native.decimals} decimals, and ` +
+                        `actions[${k}] (${reader.type}) spends it as a token amount — ${erc20.decimals}-decimal ` +
+                        `units through ${erc20.address}, so 10^${native.decimals - erc20.decimals} times too ` +
+                        `much. Read it with \`balanceOf\` on ${erc20.address} instead: the same balance, in ` +
+                        "token units",
+                });
+            }
+        }
+    });
+    return issues;
+}
+/** Every rule `actions` breaks on `chainId`. */
+export function programIssues(actions, chainId) {
+    const issues = [];
+    const at = (i, key) => key === undefined ? `actions[${i}]` : `actions[${i}].${key}`;
+    const saved = new Set();
+    const argumentNames = new Map();
+    actions.forEach((action, i) => {
+        const ref = field(action, "amountRef");
+        if (ref !== undefined && field(action, "amount") !== undefined) {
+            issues.push({
+                path: at(i, "amountRef"),
+                message: "both `amount` and `amountRef` are set — an action spends one amount; remove one",
+            });
+        }
+        else if (ref !== undefined && !saved.has(ref)) {
+            issues.push({
+                path: at(i, "amountRef"),
+                message: `'${ref}' is not saved by an earlier action (set \`saveOutputAs: "${ref}"\` on one before this)`,
+            });
+        }
+        if (consumesPrevious(action) && i === 0) {
+            issues.push({
+                path: at(i),
+                message: "has no amount: set `amount` or `amountRef`, or put an action before it whose output it spends",
+            });
+        }
+        if (action.type === "argument") {
+            const first = argumentNames.get(action.name);
+            if (first !== undefined) {
+                issues.push({
+                    path: at(i, "name"),
+                    message: `argument '${action.name}' is already declared by actions[${first}]`,
+                });
+            }
+            argumentNames.set(action.name, first ?? i);
+        }
+        if (action.saveOutputAs !== undefined)
+            saved.add(action.saveOutputAs);
+    });
+    // A source action exists only to feed a later one. Unread, it is almost certainly a mistake.
+    actions.forEach((action, i) => {
+        if (ACTION_SPECS[action.type].group !== "source")
+            return;
+        const next = actions[i + 1];
+        const name = action.saveOutputAs;
+        const read = (next !== undefined && consumesPrevious(next)) ||
+            (name !== undefined &&
+                actions.slice(i + 1).some((later) => field(later, "amountRef") === name));
+        if (!read) {
+            issues.push({
+                path: at(i),
+                message: `the value this ${action.type} produces is never read — the next action must omit its ` +
+                    "amount to spend it, or a later action must reference it by `amountRef`",
+            });
+        }
+    });
+    if (chainId !== undefined)
+        issues.push(...nativeErc20Issues(actions, chainId));
+    return issues;
+}

package/actions/dist/spec.d.ts

@@ -0,0 +1,97 @@
+/**
+ * The JSON shape of every action — one table that the strict parser (`program.ts`), the published
+ * JSON Schema (`schema.ts`) and the guide's reference are all generated from, so none can disagree.
+ *
+ * ENCODING. JSON has no integer wider than 2^53, so every amount, price and any other value that can
+ * exceed it is a base-10 string (`"1000000000000000000"`): digits only, no sign, no exponent, no
+ * leading zeros. Addresses are `0x` + 40 hex digits (a mixed-case address must carry a valid
+ * EIP-55 checksum), byte strings are `0x` + an even number of hex digits, and small enumerations —
+ * fee tiers, indices, domain ids, deadlines in seconds — are JSON integers.
+ */
+import type { ActionType } from "./types.js";
+export type FieldKind = {
+    readonly k: "address";
+}
+/** An address, or `"self"` for the executing Pot. */
+ | {
+    readonly k: "recipient";
+}
+/** An address, or a 32-byte account on a non-EVM destination. */
+ | {
+    readonly k: "remoteRecipient";
+}
+/** A base-10 string holding an unsigned integer of at most `bits` bits. */
+ | {
+    readonly k: "uint";
+    readonly bits: number;
+} | {
+    readonly k: "bytes";
+} | {
+    readonly k: "bytes32";
+}
+/** A JSON integer in `[min, max]`. */
+ | {
+    readonly k: "int";
+    readonly min: number;
+    readonly max: number;
+} | {
+    readonly k: "enum";
+    readonly values: readonly (string | number)[];
+} | {
+    readonly k: "bool";
+} | {
+    readonly k: "identifier";
+} | {
+    readonly k: "array";
+    readonly of: FieldKind;
+    readonly min?: number;
+    readonly max?: number;
+}
+/** A fixed-length JSON array whose positions have their own kinds. */
+ | {
+    readonly k: "tuple";
+    readonly of: readonly FieldKind[];
+} | {
+    readonly k: "object";
+    readonly fields: Fields;
+};
+export interface FieldDef {
+    readonly kind: FieldKind;
+    readonly optional?: boolean;
+    readonly doc: string;
+}
+export type Fields = Readonly<Record<string, FieldDef>>;
+/**
+ * What an action's output is — the value an implicitly chained next action, or an `amountRef`,
+ * spends.
+ *
+ * - `realized`: what the action delivered to the Pot (a swap's received amount, a staking token,
+ *   an Aave withdrawal).
+ * - `passThrough`: the action's own amount, unchanged.
+ * - `value`: a source action's value (a balance, a runtime argument).
+ */
+export type OutputKind = "realized" | "passThrough" | "value";
+export type ActionGroup = "swap" | "bridge" | "wrap" | "stake" | "lending" | "token" | "source";
+export interface ActionSpec {
+    readonly type: ActionType;
+    readonly group: ActionGroup;
+    /** One sentence for the reference: what the action does. */
+    readonly summary: string;
+    /** The contract function it calls, as documentation. */
+    readonly calls: string;
+    /**
+     * Whether the action takes `amount`/`amountRef`, and so spends the previous action's output when
+     * both are absent. False for a source, and for an action whose amounts are its own fields.
+     */
+    readonly spends: boolean;
+    readonly output: OutputKind;
+    /** Native value the call attaches, for the reference. */
+    readonly value?: string;
+    /** Everything but `type`, `amount`, `amountRef` and `saveOutputAs`. */
+    readonly fields: Fields;
+}
+/** Every action's specification, by `type`. */
+export declare const ACTION_SPECS: Readonly<Record<ActionType, ActionSpec>>;
+/** Every action `type`, in reference order. */
+export declare const ACTION_TYPES: readonly ActionType[];
+//# sourceMappingURL=spec.d.ts.map

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

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