@eco-incorp/sauce-compiler API

function main(amount: Uint256): Uint256 {
  return amount + 1;
}

import { readFileSync } from "node:fs";
import { resolve } from "node:path";
import { compile } from "@eco-incorp/sauce/compiler";

const root = resolve("src");
const result = compile({
  target: "evm",
  entry: "main.sauce.ts",
  resolve: (path) => {
    try {
      return readFileSync(resolve(root, path));
    } catch (error) {
      // Nothing at this path: the compiler may try another candidate.
      if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
      throw error;
    }
  },
});
console.log(result.bytecode.length, result.isaRevision, result.entryEncoding);
console.log(JSON.stringify(result.entryParams));
console.log(JSON.stringify(result.entrySignature));

import { encodeAbiParameters, toBytes } from "viem";
import { compile } from "@eco-incorp/sauce/compiler";

const source = new TextEncoder().encode(
  "function main(amount: Uint256, recipient: Address): Uint256 {\n  return amount + 1;\n}\n",
);
const result = compile({ target: "evm", resolve: (path) => (path === "main.js" ? source : undefined) });

const args = encodeAbiParameters(result.entryParams, [42n, "0x1111111111111111111111111111111111111111"]);
const program = new Uint8Array([...result.bytecode, ...toBytes(args)]);
console.log(result.entryParams.map((p) => `${p.type} ${p.name}`).join(", "), program.length - result.bytecode.length);

import { compile } from "@eco-incorp/sauce/compiler";

const closure = new TextEncoder().encode("(amount: Uint256, double: bool): Uint256 => double ? amount * 2 : amount");
const options = { target: "evm" as const, entryKind: "closure" as const, resolve: () => closure };

const open = compile(options);
const bound = compile({ ...options, args: [21n, true] });

console.log(open.entryParams.length, open.bytecode.length);
console.log(bound.entryParams.length, bound.bytecode.length);
console.log(JSON.stringify(bound.entrySignature));

import { compile } from "@eco-incorp/sauce/compiler";

const source = new TextEncoder().encode(
  [
    "function main(fee: Uint256): Uint256 {",
    "  const parcel = program((amount: Uint256): Uint256 => amount - fee, 1000);",
    "  return parcel.args.length;",
    "}",
    "",
  ].join("\n"),
);
const result = compile({ target: "evm", resolve: (path) => (path === "main.js" ? source : undefined) });
for (const p of result.programs) console.log(p.id, JSON.stringify(p.path), p.target, p.bytecode.length, JSON.stringify(p.captures));

import { compile } from "@eco-incorp/sauce/compiler";

// The shape of what compile throws (CompileError), declared locally: the subpath does not export it.
type CompileError = Error & {
  diagnostics: { path: string; message: string; code?: string; start: { line: number; column: number; offset: number } }[];
};

const source = "function main(): Uint256 {\n  return missing + 1;\n}\n";
try {
  compile({
    target: "evm",
    resolve: (path) => (path === "main.js" ? new TextEncoder().encode(source) : undefined),
  });
} catch (error) {
  const { message, diagnostics } = error as CompileError;
  console.log(message);
  for (const d of diagnostics) console.log(d.code, d.path, d.start.line, d.start.column, d.message);
}

import { compile, type CompileOptions } from "@eco-incorp/sauce/compiler";

type ChainProfile = NonNullable<CompileOptions["chainProfiles"]>[string];

const source = "function main(): Uint256 {\n  return ctx.prevrandao();\n}\n";
const chainProfiles: Record<string, ChainProfile> = {
  "1": { name: "Ethereum" },
  "42161": { name: "Arbitrum", builtins: { "ctx.prevrandao": "unsupported" } },
};
const options: CompileOptions = {
  target: "evm",
  resolve: (path) => (path === "main.js" ? new TextEncoder().encode(source) : undefined),
  chainProfiles,
};

const onEthereum = compile({ ...options, chain: "1" });
console.log(onEthereum.chain, onEthereum.bytecode.length);
try {
  compile({ ...options, chain: "42161" });
} catch (error) {
  console.log((error as Error).message);
}

import { compile } from "@eco-incorp/sauce/compiler";
import { clearFunctionCache, functionCacheStats } from "sauce-compiler";

const source = new TextEncoder().encode("function main(): Uint256 {\n  return 1;\n}\n");
const options = { target: "evm" as const, resolve: (path: string) => (path === "main.js" ? source : undefined) };

clearFunctionCache();
compile(options);
compile(options);
console.log(functionCacheStats());

import { compile, ready } from "@eco-incorp/sauce/compiler";

await ready();
const source = new TextEncoder().encode("function main(): Uint256 {\n  return 1;\n}\n");
const { bytecode } = compile({ target: "evm", resolve: (path) => (path === "main.js" ? source : undefined) });
console.log(bytecode.length);