Solana from TypeScript

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

const source = `
function main(to: Address, amount: Uint256) {
  require(pot.USDC >= amount, "not enough USDC");
  USDC.transfer(to, amount);
}
`;

export const program = routes.compileSauceProgram("solana", source);

console.log("main takes:", program.entryParams.map((p) => `${p.name}: ${p.type}`).join(", "));
const slots = program.manifest?.accounts.flatMap((a) => (a.kind === "slot" ? [`${a.name} (${a.requires})`] : []));
console.log("accounts:", slots?.join(", "));
console.log("derived:", program.derivedAccounts);

// Buys WSOL with up to `amountIn` of the Pot's USDC at Orca's SOL/USDC whirlpool of tick spacing 4,
// never paying more than `priceLimit` a unit, and keeps it in the Pot. A pool already past the
// limit is skipped (the swap returns 0); below `minOut` the whole transaction reverts.
//
//   sauce compile orca-swap.sauce.ts --chain solana
//
//   amountIn: Uint256     the most USDC to pay, in its smallest units (6 decimals)
//   priceLimit: Uint256   the most one WSOL base unit may cost, fee included: USDC base units per
//                         WSOL base unit, times 10^18
//   minOut: Uint256       the least WSOL to receive, in its smallest units (9 decimals)
function main(amountIn: Uint256, priceLimit: Uint256, minOut: Uint256): Uint256 {
  return Orca.Whirlpool.swap(
    Orca.Whirlpool.pool(USDC, WSOL, 4),
    USDC,
    WSOL,
    amountIn,
    priceLimit,
    minOut,
  );
}

import { readFileSync } from "node:fs";
import { routes } from "@eco-incorp/sauce";

const program = routes.compileSauceProgram("solana", readFileSync("orca-swap.sauce.ts", "utf8"));

console.log(program.bytecode.length, "bytes");
console.log(program.entryParams.map((p) => `${p.name}: ${p.type}`).join(", "));
for (const [name, derivation] of Object.entries(program.derivedAccounts ?? {})) {
  console.log(`  ${name} = ${derivation}`);
}

import { requireChain, routes } from "@eco-incorp/sauce";
import { v12SvmKitchenProgramId } from "@eco-incorp/sauce/deployments";
import {
  address,
  derivePotPda,
  resolveSvmAccountName,
  type AccountResolution,
} from "@eco-incorp/sauce/svm";

const program = routes.compileSauceProgram(
  "solana",
  `function main(to: Address, amount: Uint256) { USDC.transfer(to, amount); }`,
);

const owner = address("GHRJMiop6cEM9E9oqHqyf4JfC4dMsr5pvJfzqkLiJ88p"); // signs and pays
const to = address("HstnoYUjLqBatkcYonFkiFk41XE99kMMY9YKykAoLKsL"); // main's `to`
const kitchen = address(v12SvmKitchenProgramId());
const { address: pot } = await derivePotPda(kitchen, owner, new Uint8Array(32)); // the default Pot

// Each derived account, resolved as `sauce run` resolves `--account NAME=<value>`.
const resolution: AccountResolution = {};
for (const [name, derivation] of Object.entries(program.derivedAccounts ?? {})) {
  const resolved = await resolveSvmAccountName(derivation, {
    chain: requireChain("solana"),
    owner,
    pot,
    args: { to },
  });
  // The Kitchen signs for the Pot during the cook, so the transaction attaches it unsigned.
  resolution[name] =
    resolved.value === "pot" ? { address: pot, signer: false }
    : resolved.value === "owner" ? owner
    : resolved.value;
  console.log(`${name} = ${derivation} -> ${resolved.kind} ${resolved.value === "pot" ? pot : resolved.value}`);
}

export { program, resolution, owner, pot };

import { routes } from "@eco-incorp/sauce";
import {
  address,
  coalescingOwnedAccountLoader,
  kitBatchAccountLoader,
  resolveSvmToken,
  svmTokenAccount,
} from "@eco-incorp/sauce/svm";
import { createSolanaRpc } from "@solana/kit";

const rpcUrl = process.argv[2]; // your mainnet-beta JSON-RPC URL: the SDK ships none
const load = coalescingOwnedAccountLoader(kitBatchAccountLoader(createSolanaRpc(rpcUrl)));
const holder = address("GHRJMiop6cEM9E9oqHqyf4JfC4dMsr5pvJfzqkLiJ88p");

for (const symbol of ["USDC", "PYUSD"]) {
  const row = routes.SVM_TOKEN_REGISTRY["mainnet-beta"].find((r) => r.symbol === symbol)!;
  const token = await resolveSvmToken(load, address(row.mint)); // reads the mint and its owner
  console.log(symbol, {
    tokenProgram: token.tokenProgram,
    decimals: token.decimals,
    transferFee: token.extensions.transferFee !== undefined,
    advisories: token.extensions.advisories,
    transferRefusals: token.transferRefusals,
    holderAccount: await svmTokenAccount(token, holder), // derived under the mint's program
  });
}

import { v12SvmEngineProgramId, v12SvmKitchenProgramId } from "@eco-incorp/sauce/deployments";
import {
  address,
  buildCookInstruction,
  buildHeapFramePrepend,
  deriveExecutionFeeConfigPda,
  fetchExecutionFee,
  getTransactionSize,
  measureExecuteTransaction,
  resolveAccounts,
  TRANSACTION_SIZE_LIMIT,
} from "@eco-incorp/sauce/svm";
import { createSolanaRpc } from "@solana/kit";
import { owner, pot, program, resolution } from "./sol-accounts.mts";

const rpcUrl = process.argv[2]; // your mainnet-beta JSON-RPC URL: the SDK ships none
const kitchen = address(v12SvmKitchenProgramId());
const engine = address(v12SvmEngineProgramId());

// The fee is read from the Kitchen's config account, and the cook signs it as its maximum.
const rpc = createSolanaRpc(rpcUrl);
const fee = await fetchExecutionFee(rpc, kitchen);
console.log("execution fee:", fee, "lamports, at slot", await rpc.getSlot().send());

if (program.manifest === undefined) throw new Error("expected an SVM account manifest");
const tail = resolveAccounts(program.manifest, resolution, owner); // in manifest order
const { address: feeConfig } = await deriveExecutionFeeConfigPda(kitchen);

const instructions = [
  buildHeapFramePrepend(), // exactly once: the engine's 262,144-byte heap frame
  buildCookInstruction({
    kitchen,
    owner,
    engineProgram: engine,
    potSalt: new Uint8Array(32),
    pot, // validated by the Kitchen with potSalt and the Pot's canonical bump, which the builder derives
    feeConfig,
    bytecode: program.bytecode, // with main's arguments appended in a real cook
    maxExecutionFee: fee,
    tail,
  }),
];

// Compiled with no signature and a placeholder blockhash: nothing is signed or sent.
const unsigned = measureExecuteTransaction({ feePayer: owner, instructions });
console.log("program accounts:", tail.map((meta) => meta.address).length);
console.log("size:", getTransactionSize(unsigned), "of", TRANSACTION_SIZE_LIMIT, "bytes");

import { routes } from "@eco-incorp/sauce";
import { v12SvmEngineProgramId, v12SvmKitchenProgramId } from "@eco-incorp/sauce/deployments";
import {
  address,
  createSauceSvmClient,
  fetchExecutionFee,
  type AccountResolution,
} from "@eco-incorp/sauce/svm";
import { createSolanaRpc, type TransactionSigner } from "@solana/kit";

export async function signedCook(
  rpcUrl: string,
  payer: TransactionSigner, // the Pot's owner: signs and pays
  feeBudgetLamports: bigint,
  compiled: routes.CompiledSauceProgram,
  accounts: AccountResolution,
) {
  const kitchen = address(v12SvmKitchenProgramId());
  const fee = await fetchExecutionFee(createSolanaRpc(rpcUrl), kitchen);
  if (fee > feeBudgetLamports) throw new Error(`the execution fee ${fee} exceeds the budget`);

  const client = await createSauceSvmClient({
    rpcUrl,
    payer,
    kitchen,
    programId: address(v12SvmEngineProgramId()),
    maxExecutionFee: fee, // a fee raised above this before the cook lands refuses the cook
  });
  if (compiled.manifest === undefined) throw new Error("expected an SVM account manifest");

  const simulated = await client.simulate(compiled.bytecode, compiled.manifest, accounts);
  if (!simulated.ok) throw new Error(`the cook would fail: ${JSON.stringify(simulated.err)}`);

  // Signed by `payer`, not sent: hand it to your own sender, or call client.execute(...) instead.
  return client.cookTransaction(compiled.bytecode, compiled.manifest, accounts, {
    computeUnitLimit: "auto",
  });
}

import { createHash } from "node:crypto";
import { readFileSync } from "node:fs";
import { routes } from "@eco-incorp/sauce";
import { v12SvmKitchenProgramId } from "@eco-incorp/sauce/deployments";
import {
  address,
  buildCreateCodeBufferInstruction,
  buildFinalizeCodeBufferInstruction,
  buildWriteCodeBufferInstruction,
  deriveCodeBufferPda,
  deriveCodePda,
  getTransactionSize,
  GROWTH_STEP,
  measureExecuteTransaction,
  TRANSACTION_SIZE_LIMIT,
} from "@eco-incorp/sauce/svm";

const program = routes.compileSauceProgram("solana", readFileSync("orca-swap.sauce.ts", "utf8"));
const bytecode = program.bytecode;
const sha256 = new Uint8Array(createHash("sha256").update(bytecode).digest());

const kitchen = address(v12SvmKitchenProgramId());
const owner = address("GHRJMiop6cEM9E9oqHqyf4JfC4dMsr5pvJfzqkLiJ88p");
const nonce = 0n; // one buffer per (owner, nonce)
const { address: codeBuffer } = await deriveCodeBufferPda(kitchen, owner, nonce);
const { address: code } = await deriveCodePda(kitchen, codeBuffer);
const accounts = { kitchen, owner, codeBuffer, code };

console.log("program:", bytecode.length, "bytes; growth steps needed:", Math.ceil(bytecode.length / GROWTH_STEP) - 1);

// 1. Create the buffer, sized for the program.
const steps = [[buildCreateCodeBufferInstruction({ ...accounts, nonce, capacity: bytecode.length })]];
// 2. Write the bytes, one chunk per transaction.
const CHUNK = 900;
for (let offset = 0; offset < bytecode.length; offset += CHUNK) {
  const chunk = bytecode.subarray(offset, offset + CHUNK);
  steps.push([buildWriteCodeBufferInstruction({ ...accounts, offset, chunk })]);
}
// 3. Finalize: the Kitchen checks the digest and shrinks the code account to the program's length.
steps.push([buildFinalizeCodeBufferInstruction({ ...accounts, len: bytecode.length, expectedSha256: sha256 })]);

for (const instructions of steps) {
  const size = getTransactionSize(measureExecuteTransaction({ feePayer: owner, instructions }));
  console.log(`transaction of ${size} bytes (limit ${TRANSACTION_SIZE_LIMIT})`);
}
// 4. Cook it with buildCookFromAccountInstruction({ codeBuffer, code, pin: sha256, ... }), or
//    client.executeStaged(codeBuffer, manifest, resolution).

import { v12SvmEngineProgramId, v12SvmKitchenProgramId } from "@eco-incorp/sauce/deployments";
import { address, deriveExecutionFeeConfigPda } from "@eco-incorp/sauce/svm";
import {
  buildCookAndPayInstruction,
  engineFaultName,
  ENGINE_GAS_LIMIT_CU,
  HEAP_FRAME_BYTES,
} from "@eco-incorp/sauce/svm/engine";
import { program } from "./sol-compile.mts";

const wallet = address("GHRJMiop6cEM9E9oqHqyf4JfC4dMsr5pvJfzqkLiJ88p");
const { address: feeConfig } = await deriveExecutionFeeConfigPda(address(v12SvmKitchenProgramId()));

// A direct cook: the engine itself, no Kitchen and no Pot, paying the fee from `feePayer`.
const instruction = buildCookAndPayInstruction({
  engineProgram: address(v12SvmEngineProgramId()),
  bytecode: program.bytecode,
  feeConfig,
  feePayer: wallet,
  maxExecutionFee: 85_672n,
  tail: [],
});

console.log("data:", instruction.data?.length, "bytes; accounts:", instruction.accounts?.length);
console.log("heap frame:", HEAP_FRAME_BYTES, "bytes; compute budget:", ENGINE_GAS_LIMIT_CU);
console.log("Custom(0) is", engineFaultName(0));

import { existsSync } from "node:fs";
import { basename } from "node:path";
import { svmEngineArtifacts } from "@eco-incorp/sauce/svm/engine-artifacts";

// File paths inside the installed package, for a local LiteSVM harness. Node only.
const paths = svmEngineArtifacts("mainnet");
for (const [name, path] of Object.entries(paths)) {
  console.log(name, basename(path), existsSync(path));
}