The V12 engine

​

How a program executes

• The engine runs the program’s steps in order, inside the transaction that carries it: the cook on an EVM chain, the cook instruction on Solana.
• Every contract call the program makes is a call inside that transaction. On an EVM chain it comes from the Pot.
• An uncaught failure reverts the whole transaction: a failed require, a call that fails, an arithmetic error. On EVM chains a try/catch block rolls back its own calls, writes and assignments and runs its handler instead; work before the block remains. Solana has no catch.
• Arithmetic on numbers is checked. Overflow, underflow and division by zero revert as the program runs; with constant operands they are compile errors. The exception is a call-free array literal indexed at a literal position, where only the element taken is evaluated (Arrays).
• With a helper call, a contract call or a token read (pot.USDC, USDC.balanceOf(pot)) in an array literal, that call and the elements ahead of it run. [1 / zero, f()][1] and [f(1 / zero), 7][1] revert for zero = 0; a write inside f happens when execution reaches it.
• What main returns is the engine’s output. On an EVM chain it is the return data of cook().

// Returns a - b. Arithmetic is checked: when b > a, the program reverts.
//
//   sauce simulate checked.sauce.ts --chain base --owner <address> --args <a> <b>
//
//   a: Uint256   the number to subtract from
//   b: Uint256   the number to subtract
function main(a: Uint256, b: Uint256): Uint256 {
  return a - b;
}

The cook succeeds from 0x1111…1111: gas used 50656 for the cook, after the Pot's deploy (1. below), returns 0x0000000000000000000000000000000000000000000000000000000000000002
main returns Uint256: 2

The cook reverts: it reverted with no data (out of gas, or a revert with no reason)

​

Where the engine runs

​

On EVM chains

​

On Solana

​

Instruction set label

​

Compiler and engine pairing

• Compile with the version that sends the cook. Bytecode from another compiler runs only on the engines its own release set records. The sauce command compiles the file you give it each time.
• Build unsigned transactions with the installed SDK: a cook that sauce tx printed names the engine of the release set that built it.
• sauce pot list shows the release each recorded Pot was created under.

"compiler": { "name": "@eco-incorp/sauce-compiler", "version": "…" },
"engine": { "release": "v12-evm", "version": "…", "commit": "…", "address": "0x0F50…0f67" }

"engine": { "release": "v12-svm", "version": "…", "commit": "…", "programId": "53eS…2nSW" }

​

Addresses

sauce pot --chain base --owner <address>

On base: the engine 0x0F50…0f67 is deployed; the Kitchen 0x1984…506b is deployed, its execution fee 3744785386350 wei (0.00000374478538635 ETH); the Pot 0x6c91…D3Fe is NOT deployed.

​

In TypeScript

import {
  assertEngineRunsCompiler,
  v12DeployedAddresses,
  v12EngineAddress,
  v12ReleaseSet,
  v12RouterAddress,
  v12SvmEngineProgramId,
} from "@eco-incorp/sauce/deployments";

const set = v12ReleaseSet(); // the installed compiler and the four releases its output runs on
console.log(set.compiler, set["v12-evm"].version, set["v12-svm"].version);

console.log(v12EngineAddress()); // the EVM engine, the same address on every EVM chain
console.log(v12RouterAddress()); // the current execution Router
console.log(v12SvmEngineProgramId()); // the Solana engine's program id
console.log(v12DeployedAddresses().evm.pot.derivation); // how a Pot's address is derived

assertEngineRunsCompiler("evm", v12EngineAddress()); // passes: this engine runs this compiler's output

​

Next steps

• Kitchen: the contract and program that create Pots and charge the fee.
• Pot: the account a program runs in.
• Bytecode: what the compiler emits, and how to check that a cook carries it.
• cook(): the call that runs a program.