A
ABI. A contract’s interface: its functions, events and errors, with their argument and return types. A program calls a contract through its ABI, either the registry’s, reached by a namespace, or one it imports as JSON. See Contracts and ABIs. Account manifest. What compiling for Solana returns beside the bytecode: every account the program needs, in order, with the role each has and how to derive it. A compile for an EVM chain returns none. See EVM and Solana. ATA (associated token account). The token account at the address derived from a holder, the mint and the mint’s token program. It is where that holder’s balance of that token lives. See EVM and Solana.B
Bytecode. The instructions produced by compiling a program for the V12 engine. The output can differ by chain because token and contract names resolve to that chain’s addresses. See Bytecode.C
Chain-qualified name. A contract name prefixed with a chain, such asBase.UniswapV3.Factory. It is that chain’s address as a value; calling it from a program on another chain calls that address on the chain the program runs on. Tokens are never qualified. See Names.
Code buffer. On Solana, a Kitchen account that holds a program too large for one transaction. The program is uploaded into it in several transactions, run from it, and the buffer is closed after the cook, returning its rent. See EVM and Solana.
Compute units. Solana’s measure of a transaction’s work. A transaction has a compute budget; a cook fails if it exceeds that budget. See EVM and Solana.
Cook. A transaction that runs a Sauce program through a Pot. An unhandled failure reverts the transaction’s state changes. A program can handle some failures on EVM chains and continue. See cook().
cook(). The Pot’s function cook(engine, program), payable, where program is the bytecode followed by the encoded entry arguments and the value is the Kitchen fee plus any native coin the program spends. Only the Pot’s owner can call it on a private Pot; another account can submit a signed cook instead. See cook().
E
Engine. The V12 engine: the onchain code that executes Sauce bytecode. A cook names it, and on an EVM chain it runs only inside a Pot its Kitchen created. See V12. Entry arguments. The values ofmain’s parameters, encoded after the bytecode in each cook, so one compiled program serves every call. They are ABI-encoded by main’s parameter types, the one entry encoding, which the compiler reports as entryEncoding: "abi-v1". See Layout of a program.
F
Family alias. A name that groups a protocol’s versions, such asUniswap or Aave. It names a contract only when exactly one member has that contract on the chain: Uniswap.Factory is ambiguous and does not compile. See Names.
forceApprove. The approval pattern used by EVM token approval helpers such as USDC.approve(spender, amount): read the current allowance, reset a non-zero allowance to zero, then set the new amount. See Security considerations.
G
Gas. The measure of work used to price an EVM transaction. The sender pays the network fee in the chain’s native coin. A cook consumes gas for the Pot, Kitchen and program execution, and a reverted transaction still consumes gas. See cook().I
Int256. The signed 256-bit integer type, from −2²⁵⁵ through 2²⁵⁵ − 1. Negative literals, ABI intN outputs and Math.signExtend are Int256, and the division, remainder, shift and comparison operators are signed on it. Int256(x) and Uint256(x) are checked conversions, .fromBits(x) reinterprets the bits, and arithmetic that mixes Int256 and Uint256 does not compile. See Types.
Interface (registry). A registry ABI with no fixed address, such as UniswapV3.Pool or Erc4626.Vault. A program calls it with an address in the same expression: UniswapV3.Pool(pool).liquidity(). See Names.
ISA revision. The label the compiler reports with each artifact as isaRevision: "stack-v3", an opaque label. It does not distinguish engine releases and is not a compatibility check: the SDK’s release sets pair each compiler version with exact engine versions, and more than one compiler version can share an engine. See V12.
K
Kitchen. The contract that creates Pots, at the same address on every EVM chain it is deployed on, and sets the fee each cook pays. On Solana it is an upgradeable program, with the same id on every cluster, that signs for every Pot; its upgrade authority must be trusted with what Pots hold. See Kitchen. Kitchen fee. The flat fee each cook pays the Kitchen in the chain’s native coin, read on an EVM chain withexecutionFee(). Its owner sets it; a cook carrying less reverts, and a cook that reverts pays none. See Kitchen.
L
Lookup table. On Solana, an address lookup table: a list of addresses kept onchain that a transaction points into, one byte per account instead of 32, so a cook naming many accounts fits. Its creator pays its rent and owns it, and it stays open until its owner closes it. See EVM and Solana.M
main. The function a program’s execution starts at. Its typed parameters are the program’s inputs, passed with --args, and its return value comes back from the cook. See Layout of a program.
N
Namespace. A protocol’s name in a program, such asUniswapV3 or AaveV3. UniswapV3.Factory is that protocol’s contract on the chain the program is compiled for, with its ABI. See Names.
Native coin. The coin a chain charges its fees in: ETH on Ethereum and Base, USDC on Arc, SOL on Solana. The Kitchen fee is paid in it. See Kitchen.
Nonce invalidation. invalidateNonces(word, mask) on a Pot created by the current Kitchen: the call that cancels signed-cook authorizations before they are submitted, from the owner or from a cook the Pot runs. sauce sign --cancel <nonce> builds it. See Pot.
P
PDA (program-derived address). A Solana address a program computes from seeds, with no private key behind it. Only the program that derived it can sign for it; a Pot on Solana is one. See EVM and Solana. Pot. The account that holds tokens and executes Sauce programs. An EVM private Pot is a contract created for one owner and salt, and calls made by a program come from that Pot. On Solana, a Pot uses a program-derived address. Pot and engine compatibility depends on the release. See Pot. Pot’s Router. The contract a Pot delegatecalls when a pool calls back during a swap; it pays the pool from the Pot’s balances. A new Pot starts on the Kitchen’s current Router, and the owner can change it withsetRouter unless it was fixed at creation. The Router is content-addressed: its address follows from its code, so Routers are compared by address (v12RouterAddress()). See Pot.
Presence test. A registry name in a condition, such as if (UniswapV3.Factory), !USDT or USDT != 0, which asks whether the chain the program is compiled for has that contract or token. Every registry name is declared on every chain, and one the chain lacks is zero there. The SDK decides the test when the program compiles and leaves out the branch it rules out; any other use of a name the chain lacks is refused at the use, naming the chain. A name no chain has is a compile error. The compiler alone does not know registry names. See Names.
Preview chain. A registry chain other than the supported chains. Programs compile there and reads work, but the sauce command builds and sends no transaction, and a cook simulates only where the release’s engine is deployed. See Chains.
Program. A SauceScript file, compiled for one chain, that a cook runs. Its form is either a main function or a script. See Layout of a program.
program(closure, ...args). A builtin that compiles an arrow function as a separate program, returning { code, args }: its bytecode and its encoded arguments, run with eval(code.concat(args)). The arrow’s captures of the enclosing function’s values are read-only. See Builtins.
R
Rent. In these docs, the SOL reserved in a Solana account to keep it rent-exempt. The required balance depends on the account’s size and can be reclaimed when the account is closed. See EVM and Solana.S
Salt. A 32-byte value that, with the Kitchen and the owner, determines a Pot’s address. One owner has one Pot per salt; the default is zero. See Pot. SafeERC20. OpenZeppelin’s rules for calling a token, which every Sauce token write follows: a token that returns nothing works, and afalse return, a malformed return or an address with no code reverts. Writes through a raw IERC20 binding do not follow them. See Names.
SauceScript. The language of Sauce programs, a subset of TypeScript, in .sauce.ts files. See Introduction to Sauce.
Script (program form). A program of top-level statements with no main function. It takes no arguments. See Layout of a program.
Shared Pot. A Pot with no owner, created by the Kitchen with deploySharedPot. Anyone can cook on it and spend what it holds, so it is funded and emptied within one transaction. See Pot.
Signed cook. A cook the Pot’s owner signs as EIP-712 typed data and another account submits, paying the gas, through cookSigned(engine, program, maxExecutionFee, nonce, deadline, submitter, signature) on a Private Pot created by the current Kitchen. It runs with the owner’s full authority over the Pot, once, until its deadline. sauce sign, the MCP server’s sauce_signed_cook and sauce_sign, and signedCookTypedData with encodeCookSigned in TypeScript build one. See Pot.
Simulate. To run a cook against a chain’s current state, or a given block, without signing or sending it. sauce simulate reports the gas, the return value, every transfer and what stays in the Pot, or the reason for a revert. See Security considerations.
Smallest unit. The integer unit every token amount in a program is written in: a token with 6 decimals, such as USDC, has 1000000 smallest units per token. On Solana the native coin’s is the lamport. See Types.
Supported chain. A chain the sauce command builds and sends transactions on: Ethereum, Base, Arc and Solana, and the testnets Arc Testnet, Base Sepolia, Ethereum Sepolia, Solana Devnet and Solana Testnet. See Chains.
T
Target. The kind of chain a program is compiled for:evm or svm (Solana). A builtin one target lacks is a compile error there. See EVM and Solana.
Token account. On Solana, the account that holds one holder’s balance of one token. A wallet or Pot can own token accounts; an associated token account is the standard account derived for a holder and mint. A token program refuses a wallet address where it expects a token account. See EVM and Solana.
Token-2022. Solana’s second token program, with optional extensions such as transfer fees and transfer hooks. @sauce/token takes SPL Token and Token-2022, and refuses a Token-2022 mint whose transfer hook names a program. See EVM and Solana.
Token(address). A token given by its address, for a token the program does not name by symbol. Token(t).transfer(to, amount) and the other writes compile to the @sauce/token functions, with SafeERC20 behaviour; Token(t).balanceOf(holder) reads a balance. See Names.
try/catch. On an EVM chain, a block that continues after a failure. A block of several statements is atomic: a failure rolls back its calls, storage writes and assignments before the handler runs. A block holding one external call, and .catch on a call, catch only that call’s failure, not the decoding of its return. The handler receives at most 256 raw revert bytes. Solana has neither. See Errors and reverts.