@eco-incorp/sauce 0.99.6 → 0.99.7

package/sdk/dist/cli/commands.js

@@ -0,0 +1,637 @@
+/**
+ * What `sauce compile`, `tx`, `simulate`, `run` and `pot` compute. Each returns its result as the
+ * lines a person reads and as the JSON a program reads; `run.ts` picks which to print.
+ *
+ * Every piece is the SDK's own: `compileSauceProgram` compiles the file as a standalone program with
+ * the chain's ambient names, `encodeEntryArguments` encodes `main`'s arguments, `buildSauceEvmCall`
+ * (`v12Pot.encodeCook`) is the cook, `v12PredictPot`, `potSalt` and `sauceEvmDeployPotCall` are the
+ * Pot, and `destinationExecutionFee` is the Kitchen's fee. Nothing is reimplemented here; `chain.ts`
+ * reads and sends, and `signer.ts` holds the key.
+ */
+import { createRequire } from "node:module";
+import { dirname, resolve as resolvePath } from "node:path";
+import { bytesToHex, getAddress, hexToBytes, } from "viem";
+import { v12DeployedAddresses, v12EngineAddress, v12KitchenAddress, v12SvmEngineProgramId, } from "../deployments/index.js";
+import { v12PredictPot } from "../deployments/pot.js";
+/** The released Kitchen, which deploys every Pot (`V12Deployments.json`). */
+export const kitchenAddress = () => getAddress(v12KitchenAddress());
+import { encodeEntryArguments } from "../routes/entry.js";
+import { MAX_SQRT_PRICE_X96, MIN_SQRT_PRICE_X96 } from "../price.js";
+import { buildSauceEvmCall, sauceEvmDeployPotCall } from "../routes/sauce-calls.js";
+import { compileSauceProgram, } from "../routes/sauce-route.js";
+import { CliError, UsageError } from "./args.js";
+import { awaitPot, connect, kitchenFee, potState, releasedContracts, sendAndWait, } from "./chain.js";
+import { describeCompileError } from "./diagnostics.js";
+import { checkIntentPots, intentCooks, missingPotNote, potCheckJson, } from "./intents.js";
+import { costJson, costLine, costOf, receiptEffects, receiptReport } from "./receipt.js";
+import { appliedDefines, contractCollector } from "./report.js";
+import { mainReturnType } from "../routes/entry.js";
+import { svmCookSize } from "./solana.js";
+import { intentDestinations, previewRefusal, requireSupported, } from "./support.js";
+/** Why `--intent-deadline` has passed, or `undefined` while it is still ahead. */
+export function pastDeadline(program, now = Date.now()) {
+    const deadline = program.intents.deadline;
+    if (deadline === undefined || deadline > BigInt(Math.floor(now / 1000)))
+        return undefined;
+    return (`--intent-deadline ${deadline} (${new Date(Number(deadline) * 1000).toISOString()}) has ` +
+        "passed: an intent can be filled only until its deadline");
+}
+/**
+ * Refuses a program whose intents' deadline has passed: the commands that build an intent to
+ * publish — `compileCommand`, `cookOf` (simulate, tx, run), the Solana cook, `publishCommand` —
+ * would build one no solver could ever fill. Here, in the commands both front ends call, so the
+ * CLI and the MCP tools refuse it alike. `fill` rehearses one anyway, with a note, and `inspect`
+ * reads what was.
+ */
+export function refusePastDeadline(program, now = Date.now()) {
+    const past = pastDeadline(program, now);
+    if (past === undefined)
+        return;
+    const later = BigInt(Math.floor(now / 1000)) + 86400n;
+    throw new UsageError(`${past}, so this one never could be. Give a later Unix time in seconds, such as ${later} ` +
+        "(a day from now).");
+}
+/** An input file's text — the program, a defines file — or a precise reason it has none. */
+export function readInput(files, file) {
+    try {
+        return files.readText(file);
+    }
+    catch (error) {
+        const code = error.code;
+        throw new CliError(code === "ENOENT" ? `${file}: no such file` : `${file}: ${error.message}`);
+    }
+}
+/** A `cast send` of exactly `to`/`data`/`value`, with the endpoint and key left to the reader —
+ *  never filled in from `--rpc-url`, whose URL often carries a provider key. */
+export function castSend(to, data, value) {
+    return [
+        "cast send",
+        to,
+        data,
+        ...(value === undefined ? [] : ["--value", value.toString()]),
+        "--rpc-url",
+        "<RPC_URL>",
+        "--private-key",
+        "<PRIVATE_KEY>",
+    ].join(" ");
+}
+/**
+ * The options every compile here runs with, on top of the chain's ambient names that
+ * `compileSauceProgram` adds itself: the defines, the intent settings, the argument encoding, and a
+ * resolver that serves the program's own relative imports from beside the file.
+ */
+function compileOptions(input, files, onContract) {
+    const dir = sourceDirOf(input);
+    const { deadline, rewardDeadline, creator, prover, executionFee, fundVia } = input.intents;
+    const intents = {
+        ...(deadline === undefined ? {} : { deadline }),
+        ...(rewardDeadline === undefined ? {} : { rewardDeadline }),
+        ...(creator === undefined ? {} : { creator }),
+        ...(prover === undefined ? {} : { prover }),
+        ...(executionFee === undefined ? {} : { executionFee }),
+        ...(fundVia === undefined ? {} : { fundVia }),
+    };
+    return {
+        defines: input.defines,
+        ...(Object.keys(intents).length === 0 ? {} : { intents }),
+        ...(input.compactArgs ? { compactArgs: true } : {}),
+        // The intents the program opens compile with these options too, so this hears their contracts.
+        ...(onContract === undefined ? {} : { accessors: { onContract } }),
+        ...(input.contracts === undefined ? {} : { contracts: input.contracts }),
+        resolve: (path) => files.readModule(resolvePath(dir, path)),
+    };
+}
+/** The directory a program's relative imports resolve against. */
+export const sourceDirOf = (input) => resolvePath(input.sourceDir ?? (input.stdin === true ? "." : dirname(resolvePath(input.file))));
+/**
+ * Compiles the file as a standalone program, turning a failure into one message about the file.
+ * `onContract` is told each protocol contract the compile resolves.
+ */
+export function compileProgram(input, files, onContract) {
+    try {
+        return compileSauceProgram(input.chain, input.text, compileOptions(input, files, onContract));
+    }
+    catch (error) {
+        const described = describeCompileError(error, input.file, input.text, input.chain);
+        // A relative import that did not resolve, from a program with no directory of its own.
+        const imports = input.stdin === true && /import|resolv|\.\//i.test(String(error));
+        throw new CliError(`${input.file} does not compile for ${input.chain.slug}\n${described}` +
+            (imports
+                ? `\nhint: the program came from stdin, so its relative imports resolve against ` +
+                    `${sourceDirOf(input)}: pass --source-dir <dir> to resolve them elsewhere`
+                : ""));
+    }
+}
+/**
+ * The chains a cook of `input` is refused by: its own, and the destination of each intent it opens
+ * — what {@link requireSupported} is asked about before anything that publishes them. A fee the
+ * intents' cooks are not given yet is zero here: the chains do not depend on it.
+ */
+export function programChains(input, files) {
+    const probe = compileProgram({ ...input, intents: { ...input.intents, executionFee: input.intents.executionFee ?? 0n } }, files);
+    return [input.chain, ...intentDestinations(probe.intents)];
+}
+/** The installed compiler's package name and version, read from its own manifest. */
+function compilerPackage() {
+    const require = createRequire(import.meta.url);
+    // The entry (`node/sauce_wasm.js`) sits one level under the package root, and the package's
+    // `exports` does not list `package.json` itself.
+    const manifest = resolvePath(dirname(require.resolve("sauce-compiler")), "..", "package.json");
+    const { name, version } = require(manifest);
+    return { name, version };
+}
+/** The released engine a program for `chain` runs on, from the release record the SDK ships. */
+function pairedEngine(chain) {
+    const releases = v12DeployedAddresses().releases;
+    if (chain.kind === "svm") {
+        const { version, commit } = releases["v12-svm"];
+        return { release: "v12-svm", version, commit, programId: v12SvmEngineProgramId() };
+    }
+    const { version, commit } = releases["v12-evm"];
+    return { release: "v12-evm", version, commit, address: getAddress(v12EngineAddress()) };
+}
+/** `main(name: Type, …)`, as the program declares its runtime parameters. */
+const signatureOf = (params) => `main(${params.map((param) => `${param.name}: ${param.type}`).join(", ")})`;
+/**
+ * `sauce compile`: the program's bytecode, and with `--json` what it pairs with and takes, what it
+ * was compiled with — the defines it reads and the protocol contracts it calls, each with where it
+ * came from — and how large it is: the program, the payload with `main`'s arguments, and on Solana
+ * the cook's transaction against the one-transaction limit.
+ */
+export async function compileCommand(input, files) {
+    refusePastDeadline(input);
+    const collected = contractCollector();
+    const program = compileProgram(input, files, collected.onContract);
+    const bytecode = bytesToHex(program.bytecode);
+    const { defines, unread } = appliedDefines(input.text, input.chain, input.defines, new Set(input.addressDefines ?? []));
+    // The payload is the program with its arguments appended: known once the arguments are.
+    const payload = input.args === undefined && program.entryParams.length > 0
+        ? undefined
+        : hexToBytes(payloadOf(program, input.args));
+    const cook = input.chain.kind === "svm" && payload !== undefined
+        ? await svmCookSize(payload, program.manifest ?? { accounts: [] }, input.accounts ?? {}, input.via)
+        : undefined;
+    const cooks = intentCooks(program.intents);
+    const pots = input.endpoints === undefined ? cooks : await checkIntentPots(cooks, input.endpoints);
+    const notes = [
+        ...priceLimitNotes(input, program.entryParams, input.args),
+        ...pots.filter((check) => check.deployed === false).map(missingPotNote),
+        ...unread.map(({ name, readOn }) => readOn.length === 0
+            ? `--define ${name}: ${input.file} never reads ${name}, so the define changes nothing`
+            : `--define ${name}: ${input.file} reads ${name} only in intents on ${readOn.join(", ")}, ` +
+                `where it is that chain's own: a define of a name each chain sets holds on ` +
+                `${input.chain.slug} alone, so this one changes nothing`),
+        ...(cook === undefined || cook.fits
+            ? []
+            : [
+                `the cook is a ${cook.size}-byte transaction, past Solana's ${cook.limit}: \`sauce run\` ` +
+                    "stages the program in a code buffer first; `sauce simulate` and `sauce tx` cannot",
+            ]),
+    ];
+    return {
+        text: bytecode,
+        json: {
+            chain: input.chain.slug,
+            chainId: input.chain.id,
+            target: input.chain.kind,
+            bytecode,
+            size: program.bytecode.length,
+            payload: payload === undefined
+                ? null
+                : { size: payload.length, argumentsSize: payload.length - program.bytecode.length },
+            ...(cook === undefined ? {} : { cook }),
+            entryEncoding: program.entryEncoding,
+            entryParams: program.entryParams,
+            entrySchema: program.entrySchema === undefined ? null : bytesToHex(program.entrySchema),
+            // What main returns, as it declares it: `simulate` reads the cook's return data as this.
+            returnType: mainReturnType(input.text) ?? null,
+            defines,
+            contracts: collected.contracts(),
+            ...(pots.length === 0 ? {} : { intentPots: pots.map(potCheckJson) }),
+            compiler: compilerPackage(),
+            engine: pairedEngine(input.chain),
+            ...(program.manifest === undefined ? {} : { manifest: program.manifest }),
+        },
+        ...(notes.length === 0 ? {} : { notes }),
+    };
+}
+/**
+ * The values to encode for `params`. A `--args` string is the value itself, except for an array or
+ * tuple parameter, which takes JSON (`[1, 2]`, `{"amount": 1}`); `--args-json` values are taken as
+ * parsed. `encodeEntryArguments` then checks every one against its declared type.
+ */
+function argumentValues(params, args) {
+    if (args.from === "--args-json")
+        return args.values;
+    return args.values.map((raw, index) => {
+        const param = params[index];
+        if (param === undefined || !/^\{|\[\]$/.test(param.type.trim()))
+            return raw;
+        try {
+            return JSON.parse(raw);
+        }
+        catch {
+            throw new UsageError(`--args: argument ${index + 1} (${param.name}: ${param.type}) takes JSON, such as ` +
+                `${param.type.trim().startsWith("{") ? '{"field": 1}' : "[1, 2]"}; got '${raw}'`);
+        }
+    });
+}
+/** A define or parameter whose name says it is a pool's price limit. */
+const LIMIT_NAME = /sqrt.*price|price.*limit|sqrt.*limit/i;
+/**
+ * A note for each price limit — a define or one of `main`'s arguments named like one
+ * (`SQRT_PRICE_LIMIT_X96`, `sqrtPriceLimitX96`) — at or past the bounds a V3-style pool takes. A
+ * pool takes a limit strictly between MIN_SQRT_RATIO and MAX_SQRT_RATIO and reverts "SPL" at
+ * either, so such a limit cannot fill; `0` is the library's "no limit", and is left alone.
+ */
+export function priceLimitNotes(input, params, args) {
+    const values = Object.entries(input.defines).flatMap(([name, value]) => LIMIT_NAME.test(name) && typeof value === "bigint" ? [[name, value]] : []);
+    if (args !== undefined) {
+        params.forEach((param, index) => {
+            const raw = args.values[index];
+            if (!LIMIT_NAME.test(param.name) || param.type.trim() !== "Uint256")
+                return;
+            if (typeof raw === "string" && /^(\d+|0x[0-9a-fA-F]+)n?$/.test(raw)) {
+                values.push([param.name, BigInt(raw.replace(/n$/, ""))]);
+            }
+            else if (typeof raw === "number" && Number.isSafeInteger(raw)) {
+                values.push([param.name, BigInt(raw)]);
+            }
+        });
+    }
+    return values.flatMap(([name, value]) => {
+        if (value === 0n || (value > MIN_SQRT_PRICE_X96 && value < MAX_SQRT_PRICE_X96))
+            return [];
+        const where = value === MIN_SQRT_PRICE_X96
+            ? "is MIN_SQRT_RATIO"
+            : value === MAX_SQRT_PRICE_X96
+                ? "is MAX_SQRT_RATIO"
+                : value < MIN_SQRT_PRICE_X96
+                    ? "is below MIN_SQRT_RATIO"
+                    : "is past MAX_SQRT_RATIO";
+        return [
+            `${name} = ${value} ${where}: a V3-style pool takes a price limit strictly between ` +
+                `${MIN_SQRT_PRICE_X96} and ${MAX_SQRT_PRICE_X96}, and reverts "SPL" at or past either. ` +
+                "0 is no limit; `sauce price` gives the limit for a price",
+        ];
+    });
+}
+/**
+ * The program with its encoded arguments appended: the `program` a cook runs. `adapt` sees the
+ * values first (on Solana it turns a public key into the word the engine reads).
+ */
+export function payloadOf(program, args, adapt) {
+    const params = program.entryParams;
+    if (args === undefined) {
+        if (params.length > 0) {
+            throw new UsageError(`${signatureOf(params)} takes ${params.length} argument${params.length === 1 ? "" : "s"}: ` +
+                "pass them after --args, in order, or as --args-json");
+        }
+        return bytesToHex(program.bytecode);
+    }
+    let encoded;
+    try {
+        const values = argumentValues(params, args);
+        const adapted = adapt === undefined ? { program, values } : adapt(program, values);
+        encoded = encodeEntryArguments(adapted.program, adapted.values);
+    }
+    catch (error) {
+        if (error instanceof UsageError)
+            throw error;
+        throw new UsageError(`${args.from}: ${error.message}`);
+    }
+    return `${bytesToHex(program.bytecode)}${bytesToHex(encoded).slice(2)}`;
+}
+/** Compiles the file and builds the cook on its Pot — what `tx`, `simulate` and `run` all send. */
+export function cookOf(input, files) {
+    if (input.chain.kind !== "evm") {
+        throw new Error(`internal: ${input.chain.slug}'s cook is built by solana.ts`);
+    }
+    refusePastDeadline(input);
+    const target = input.target;
+    const pot = "pot" in target ? target.pot : v12PredictPot(target.owner, target.salt);
+    const engine = getAddress(v12EngineAddress());
+    const program = compileProgram(input, files);
+    // The cook `compileSauceRoute` would build, over the program with its arguments appended — the
+    // way the SDK's own intent children carry theirs.
+    const data = buildSauceEvmCall({ pot, engine, program: payloadOf(program, input.args) }).data;
+    return { pot, engine, data, program };
+}
+/** The `sauce pot` that deploys `target`'s Pot. */
+function deployHint(chain, target) {
+    // Any account may send the deployment; the hint names the owner, whose Pot it is.
+    return "owner" in target
+        ? `sauce pot --deploy --owner ${target.owner} --chain ${chain.slug}${target.flag === undefined ? "" : ` ${target.flag}`} --keystore <keystore>`
+        : `sauce pot --deploy --chain ${chain.slug} --keystore <its owner's keystore>`;
+}
+/** The cook's value: as given, or the Kitchen's fee — refusing a given one below the fee. */
+export function valueOf(given, fee, chain) {
+    if (given !== undefined && fee !== undefined && given < fee) {
+        throw new CliError(`--value ${given} is below the Kitchen's execution fee on ${chain.slug}, ${fee} wei: the ` +
+            "cook would revert with FeeNotPaid");
+    }
+    const value = given ?? fee;
+    if (value === undefined) {
+        throw new UsageError("missing --value <wei>: the cook pays the Kitchen's execution fee plus any native the " +
+            "program spends. Pass it, or an RPC endpoint (--rpc-url or --config) to read the fee.");
+    }
+    return value;
+}
+/** `sauce tx`: the unsigned cook transaction, for any wallet to sign. */
+export async function txCommand(input, files) {
+    if (input.value === undefined && input.rpcUrl === undefined)
+        valueOf(undefined, undefined, input.chain);
+    const cook = cookOf(input, files);
+    requireSupported("building the cook transaction", [
+        input.chain,
+        ...intentDestinations(cook.program.intents),
+    ]);
+    const client = input.rpcUrl === undefined ? undefined : await connect(input.rpcUrl, input.chain);
+    const fee = client === undefined ? undefined : await kitchenFee(client, input.chain);
+    const state = client === undefined ? undefined : await potState(client, cook.pot);
+    const value = valueOf(input.value, fee, input.chain);
+    const target = input.target;
+    const owner = state?.owner ?? ("owner" in target ? target.owner : undefined);
+    const notes = [
+        "owner" in target
+            ? `Pot ${cook.pot} belongs to ${target.owner} (salt ${target.salt}).`
+            : `Pot ${cook.pot}.`,
+        state === undefined
+            ? `It must be deployed (${deployHint(input.chain, target)}) and funded with what the ` +
+                "program spends; pass an RPC endpoint to check."
+            : state.deployed
+                ? "It is deployed. Fund it with what the program spends."
+                : `It is NOT deployed. Deploy it first (${deployHint(input.chain, target)}), then fund it.`,
+        `Send from ${owner ?? "the Pot's owner"}: cook() is onlyOwner.`,
+    ];
+    const json = { chainId: input.chain.id, to: cook.pot, data: cook.data, value: value.toString() };
+    return {
+        text: JSON.stringify(json, null, 2),
+        json,
+        cast: castSend(cook.pot, cook.data, value),
+        notes,
+    };
+}
+const sentText = (what, sent) => `${what} ${sent.hash}: ${sent.status}, gas used ${sent.gasUsed}, block ${sent.blockNumber}` +
+    (sent.reason === undefined ? "" : `, reverted: ${sent.reason}`);
+const sentJson = (sent) => ({
+    hash: sent.hash,
+    status: sent.status,
+    gasUsed: sent.gasUsed.toString(),
+    blockNumber: sent.blockNumber.toString(),
+    ...(sent.reason === undefined ? {} : { reason: sent.reason }),
+});
+/**
+ * Refuses a run that needs approvals with no terminal to ask on, before anything is sent: naming
+ * every action it would need approved, and how to approve them.
+ */
+export function unapproved(actions) {
+    return new CliError(`nothing was sent: this run needs ${actions.length === 1 ? "an approval" : "approvals"}, and ` +
+        "there is no terminal to ask on:\n" +
+        actions.map((action) => `  ${action}\n`).join("") +
+        "Pass --auto-approve to approve them (and --password-file with a keystore).");
+}
+/** `sauce run`: compile, sign, send and wait — deploying the Pot first once it is agreed to. */
+export async function runCommand(input, files) {
+    const signer = input.account.address;
+    const target = input.target;
+    if ("owner" in target && getAddress(target.owner) !== signer) {
+        throw new UsageError(`--owner ${target.owner} is not the signer, ${signer}: cook() is onlyOwner, so the Pot a ` +
+            "run cooks on must be the signer's. Leave --owner out to use the signer's own.");
+    }
+    const cook = cookOf(input, files);
+    requireSupported("sending the cook", [input.chain, ...intentDestinations(cook.program.intents)]);
+    const client = await connect(input.rpcUrl, input.chain);
+    const state = await potState(client, cook.pot);
+    const deployAction = `deploy Pot ${cook.pot}`;
+    // With no one to ask, every approval the run would need is named before anything is sent.
+    if (!input.approver.auto && !input.approver.canAsk) {
+        const needs = [
+            ...(!state.deployed && "owner" in target ? [deployAction] : []),
+            ...(input.fund === undefined
+                ? []
+                : ((await input.fund(client, cook.pot, signer, true)).needs ?? [])),
+        ];
+        if (needs.length > 0)
+            throw unapproved(needs);
+    }
+    let deployed;
+    if (!state.deployed) {
+        const missing = `Pot ${cook.pot} is not deployed on ${input.chain.slug}`;
+        if (!("owner" in target)) {
+            throw new CliError(`${missing}. Deploy it first: ${deployHint(input.chain, target)}`);
+        }
+        const agreed = await input.approver.approve(deployAction, `Pot ${cook.pot} (owner ${target.owner}, salt ${target.salt}) is not deployed on ` +
+            `${input.chain.slug}. Deploy it now? [y/N] `);
+        if (agreed !== true) {
+            throw new CliError(agreed === undefined
+                ? `${missing}. Deploy it first (${deployHint(input.chain, target)}), or pass ` +
+                    "--auto-approve to deploy it before the cook"
+                : `${missing}, so nothing was sent. Deploy it with: ${deployHint(input.chain, target)}`);
+        }
+        const deploy = sauceEvmDeployPotCall({
+            kitchen: kitchenAddress(),
+            owner: target.owner,
+            salt: target.salt,
+        });
+        deployed = await sendAndWait(client, input.rpcUrl, input.account, {
+            to: kitchenAddress(),
+            data: deploy.data,
+            value: 0n,
+        });
+        if (deployed.status !== "success") {
+            throw new CliError(`${sentText("deploying the Pot", deployed)}; the Pot is not there`);
+        }
+        // The cook is rehearsed next: on an endpoint behind the deployment it would "succeed" on an
+        // address with no code, so wait until the endpoint shows the Pot.
+        await awaitPot(client, cook.pot, deployed.blockNumber);
+    }
+    else if (state.owner !== signer) {
+        throw new CliError(`Pot ${cook.pot} belongs to ${state.owner}, not the signer ${signer}: cook() is onlyOwner`);
+    }
+    // Funding, once the Pot is there: approvals and transfers it needs first, the signatures the pulls
+    // carry, and the program wrapped to pull, run and sweep.
+    const funding = input.fund === undefined ? undefined : await input.fund(client, cook.pot, signer);
+    const funded = funding === undefined ? cook : cookOf({ ...input, text: funding.wrap(input.text) }, files);
+    const value = valueOf(input.value, await kitchenFee(client, input.chain), input.chain) +
+        (funding?.value ?? 0n);
+    const request = { to: cook.pot, data: funded.data, value };
+    const sent = await sendAndWait(client, input.rpcUrl, input.account, request);
+    const stored = input.onSent === undefined ? [] : await input.onSent(sent);
+    const notes = [...(funding?.notes ?? []), ...stored];
+    // What the cook cost, and what it moved, from its receipt.
+    const cost = sent.receipt === undefined ? undefined : costOf(sent.receipt, value);
+    const effects = sent.receipt === undefined || sent.status !== "success"
+        ? undefined
+        : receiptReport(await receiptEffects(client, input.chain, sent.receipt, [
+            [signer, "you"],
+            [cook.pot, "the Pot"],
+        ]));
+    return {
+        text: [
+            ...(deployed === undefined ? [] : [sentText(`deployed Pot ${cook.pot} in`, deployed)]),
+            ...(funding?.sent ?? []).map((step) => sentText(step.what, step.sent)),
+            sentText("cook", sent),
+            ...(cost === undefined
+                ? []
+                : [costLine(cost, input.chain, "the Kitchen's fee and any native the program spends")]),
+            ...(effects?.lines ?? []),
+        ].join("\n"),
+        json: {
+            chain: input.chain.slug,
+            from: signer,
+            pot: cook.pot,
+            value: value.toString(),
+            ...(deployed === undefined ? {} : { deployPot: sentJson(deployed) }),
+            ...(funding === undefined
+                ? {}
+                : { funding: funding.sent.map((step) => ({ what: step.what, ...sentJson(step.sent) })) }),
+            cook: {
+                ...sentJson(sent),
+                ...(cost === undefined ? {} : { cost: costJson(cost) }),
+                ...(effects === undefined ? {} : { effects: effects.json }),
+            },
+        },
+        ...(notes.length === 0 ? {} : { notes }),
+        ...(sent.status === "success" ? {} : { exitCode: 1 }),
+    };
+}
+/** What refuses the Pot's deployment on a preview chain: `sauce pot` predicts it there, and no more. */
+const POT_DEPLOYMENT = "building the Pot's deployment";
+/**
+ * `sauce pot`: the Pot an owner and salt give, and the unsigned Kitchen call that deploys it. On a
+ * preview chain only the prediction: the deployment is left out, and `refused` says why.
+ */
+export function potCommand(input) {
+    if (input.chain.kind !== "evm") {
+        throw new Error(`internal: ${input.chain.slug}'s Pot is predicted by solana.ts`);
+    }
+    const kitchen = kitchenAddress();
+    const pot = v12PredictPot(input.owner, input.salt);
+    const predicted = { chainId: input.chain.id, pot, owner: input.owner, salt: input.salt, kitchen };
+    const refused = previewRefusal(POT_DEPLOYMENT, [input.chain]);
+    if (refused !== undefined) {
+        const json = { ...predicted, refused };
+        return { text: JSON.stringify(json, null, 2), json, notes: [refused.message] };
+    }
+    const call = sauceEvmDeployPotCall({ kitchen, owner: input.owner, salt: input.salt });
+    const json = { ...predicted, to: kitchen, data: call.data, value: "0" };
+    return {
+        text: JSON.stringify(json, null, 2),
+        json,
+        cast: castSend(kitchen, call.data),
+        notes: [
+            `This is Kitchen.deployPot on the released Kitchen. Any account may send it: the Pot is ` +
+                `${input.owner}'s either way, and it deploys once.`,
+        ],
+    };
+}
+/** What `sauce pot` reads off a chain: the released engine and Kitchen, and the Pot. */
+function deploymentLines(chain, released, pot, state) {
+    const there = (deployed) => (deployed ? "deployed" : "NOT deployed");
+    const { engine, kitchen } = released;
+    return {
+        json: {
+            engine: { address: engine.address, deployed: engine.deployed },
+            kitchen: {
+                address: kitchen.address,
+                deployed: kitchen.deployed,
+                ...(kitchen.executionFee === undefined
+                    ? {}
+                    : { executionFee: kitchen.executionFee.toString() }),
+            },
+            pot: {
+                address: pot,
+                deployed: state.deployed,
+                ...(state.owner === undefined ? {} : { owner: state.owner }),
+            },
+        },
+        notes: [
+            `On ${chain.slug}: the engine ${engine.address} is ${there(engine.deployed)}; the Kitchen ` +
+                `${kitchen.address} is ${there(kitchen.deployed)}` +
+                (kitchen.executionFee === undefined
+                    ? ""
+                    : `, its execution fee ${kitchen.executionFee} wei`) +
+                `; the Pot ${pot} is ${there(state.deployed)}` +
+                (state.owner === undefined ? "." : `, owned by ${state.owner}.`),
+            ...(kitchen.deployed
+                ? []
+                : [
+                    `The released Kitchen has no code on ${chain.slug}: no Pot can be deployed there, and no ` +
+                        "cook runs.",
+                ]),
+            ...(engine.deployed || !kitchen.deployed
+                ? []
+                : [
+                    `The released engine has no code on ${chain.slug}: a cook there has nothing to run on.`,
+                ]),
+        ],
+    };
+}
+/** `sauce pot` with an endpoint: the prediction, and what is deployed on the chain. */
+export async function potStatusCommand(input) {
+    const predicted = potCommand(input);
+    const pot = predicted.json.pot;
+    const client = await connect(input.rpcUrl, input.chain);
+    const [released, state] = await Promise.all([releasedContracts(client), potState(client, pot)]);
+    const deployment = deploymentLines(input.chain, released, pot, state);
+    const json = { ...predicted.json, deployment: deployment.json };
+    return {
+        text: JSON.stringify(json, null, 2),
+        json,
+        ...(predicted.cast === undefined ? {} : { cast: predicted.cast }),
+        notes: [
+            ...deployment.notes,
+            ...(state.deployed && predicted.cast !== undefined ? [] : (predicted.notes ?? [])),
+        ],
+    };
+}
+/** `sauce pot --deploy`: sends the Kitchen call, unless the Pot is already there. */
+export async function potDeployCommand(input) {
+    requireSupported("deploying a Pot", [input.chain]);
+    const predicted = potCommand(input);
+    const pot = predicted.json.pot;
+    const client = await connect(input.rpcUrl, input.chain);
+    const released = await releasedContracts(client);
+    // A deployPot sent to an address with no code "succeeds" and deploys nothing.
+    if (!released.kitchen.deployed) {
+        throw new CliError(`the released Kitchen ${released.kitchen.address} has no code on ${input.chain.slug}: no Pot ` +
+            "can be deployed there, so nothing was sent");
+    }
+    const state = await potState(client, pot);
+    if (state.deployed) {
+        const json = { ...predicted.json, deployed: true, owner: state.owner };
+        const note = `Pot ${pot} is already deployed on ${input.chain.slug}, owned by ${state.owner}.`;
+        return { text: JSON.stringify(json, null, 2), json, notes: [note] };
+    }
+    const sent = await sendAndWait(client, input.rpcUrl, input.account, {
+        to: predicted.json.to,
+        data: predicted.json.data,
+        value: 0n,
+    });
+    // Deployed means the endpoint shows its code, not only that a receipt said success.
+    if (sent.status === "success")
+        await awaitPot(client, pot, sent.blockNumber);
+    const sender = input.account.address;
+    const json = {
+        ...predicted.json,
+        deployed: sent.status === "success",
+        sender,
+        deployPot: sentJson(sent),
+    };
+    return {
+        text: JSON.stringify(json, null, 2),
+        json,
+        notes: [
+            sentText(`deployed Pot ${pot} in`, sent),
+            ...(getAddress(input.owner) === sender
+                ? []
+                : [
+                    `The Pot is ${input.owner}'s: ${sender} sent and paid for the deployment, and has no ` +
+                        "control over it.",
+                ]),
+        ],
+        ...(sent.status === "success" ? {} : { exitCode: 1 }),
+    };
+}
+//# sourceMappingURL=commands.js.map