Types

​

Integers

function main(amount: Uint256): Uint256 {
  const oneToken = 10 ** 18;
  const mask = 0xff;
  const million = 1_000_000;
  const max = ~0;
  require(amount < max, "at the maximum");
  return (amount * oneToken) / million + mask;
}

• Integers are written as decimal (3000), hexadecimal (0xff) or with _ separators (1_000_000). Each literal is read from its text as a 256-bit integer, so a value above 2⁵³ is exact. TypeScript’s bigint suffix n compiles to the same integer; write integers without it.
• ~0 is the maximum Uint256, 2²⁵⁶ − 1.
• 1e18 and 1.5 are rejected: the compile fails with “1e18 is not a valid 256-bit literal”. Write 10 ** 18, as in the program above, or the amount in the smallest unit.

​

Checked arithmetic

function main(): Int256 {
  return 0 - 1;
}

​

Int256

• a negative literal, such as -10;
• a contract output that the ABI declares intN (int24, int128, int256), such as a pool’s tick;
• the result of Math.signExtend(value, byte), which reads the low byte + 1 bytes of value as a two’s-complement integer: Math.signExtend(0xfffff6, 2) is -10.

// The tick of the WETH/USDC 0.05% pool, moved by `shift` ticks in either direction.
//
//   sauce simulate int256.sauce.ts --chain base --owner <address> --args <shift>
//
//   shift: Int256   ticks to add: -100 moves the tick down by 100
function main(shift: Int256): Int256 {
  const pool = UniswapV3.Factory.getPool(WETH, USDC, 500);
  const [sqrtPriceX96, tick] = UniswapV3.Pool(pool).slot0();
  return tick + shift;
}

​

A negative literal is never a Uint256

​

Converting between the kinds

// Adds a signed `delta` to an unsigned `balance`.
//
//   sauce simulate conversions.sauce.ts --chain base --owner <address> --args <balance> <delta>
//
//   balance: Uint256   at most 2**255 - 1
//   delta: Int256      negative to subtract; the sum must not be negative
function main(balance: Uint256, delta: Int256): Uint256 {
  return Uint256(Int256(balance) + delta);
}

// Reads `word` as a signed integer and halves it.
//
//   sauce simulate from-bits.sauce.ts --chain base --owner <address> --args <word>
//
//   word: Uint256   a 256-bit word
function main(word: Uint256): Int256 {
  return Int256.fromBits(word) / 2;
}

​

Mixed arithmetic

​

Negation

// The negative of `amount`, as a signed value.
function main(amount: Uint256): Int256 {
  return -Int256(amount);
}

​

Reserved names

​

Signed values at a contract boundary

function main(poolId: Uint256, tick: Int256): Uint256 {
  const [gross, net] = UniswapV4.StateView.getTickLiquidity(poolId, tick);
  return gross;
}

// Calls Balancer V2's batchSwap with no swaps; the deltas of the two assets are both zero.
function main(): Int256[] {
  const swaps: { poolId: Uint256, assetInIndex: Uint256, assetOutIndex: Uint256, amount: Uint256, userData: bytes }[] = [];
  const funds = { sender: pot, fromInternalBalance: false, recipient: pot, toInternalBalance: false };
  const limits: Int256[] = [0, 0];
  return BalancerV2.Vault.batchSwap(0, swaps, [WETH, USDC], funds, limits, ctx.timestamp() + 60);
}

​

Booleans

​

Addresses

function main(recipient: Address): bool {
  return recipient != 0 && recipient != USDC;
}

​

Bytes and strings

function main(to: Address, amount: Uint256): bytes {
  const prefix = hex`00ff`;
  const packed = prefix.concat(to.toBytesBe(32), amount.toBytesBe(32));
  require(packed.length == 66, "bad length");
  require(packed[1] == 0xff, "bad prefix");
  require(packed.slice(34, 66).toBe() == amount, "bad amount");
  return packed;
}

function main(data: bytes): bytes {
  return hex`00ff`.concat(data);
}

function main(a: bytes, b: bytes): bool {
  return crypto.keccak256(a) == crypto.keccak256(b);
}

​

Arrays

function main(amounts: Uint256[]): Uint256 {
  let doubled = new Array(amounts.length);
  for (let i = 0; i < amounts.length; i++) {
    doubled[i] = amounts[i] * 2;
  }
  const fees = [100, 500, 3000];
  let none: Uint256[] = [];
  return doubled[0] + fees[1] + none.length;
}

• new Array(n) makes an array of n zeros, to fill by index. There is no push.
• [a, b, c] is an array literal; every element must have the same type. An empty literal needs a declared type: let none: Uint256[] = [];.
• xs.length is the element count and cannot be assigned. An index past the end reverts: on a local fork of Base at block 52965000 with the current contracts, xs[5] on the two-element argument [1,2] reverts with no data.
• T[][] nests arrays. A main parameter takes at most 4 levels.
• One caller-supplied collection in main’s arguments is limited to 16 KiB of elements: a Uint256[] takes up to 512. Oversized input reverts the cook; split a larger batch into separate cooks, each atomic independently. On a local fork of Base at block 53161500 with the current contracts, a Uint256[] argument of 512 elements was accepted and one of 513 reverted with no data, with main only returning its length. On Solana 513 elements are refused too, but one transaction’s 1,400,000 compute units run out first: simulated with the sauce command’s local copy of Solana (LiteSVM) and the current engine and Kitchen, the same length-only program used 1,149,685 compute units for 256 elements, and 384 and 512 elements exhausted the budget. Where main does more than return a length, the usable batch is smaller: simulate the largest batch you will send.
• Do not use an unread array element as a required validation step. A call-free array literal indexed at a literal position (or at a const bound to one) evaluates only the element it takes: function main(zero: Uint256): Uint256 { return [1 / zero, 7][1]; } returns 7 when zero is 0, where return 1 / zero; reverts, and an overflow in the unread element ([big * 2, 7][1], with big a Uint256 of 2²⁵⁵ or more) returns 7 too. Bound to a variable first (const a = [1 / zero, 7]; return a[1];), indexed at run time, at a let or at a computed position such as 0 + 1, the division reverts, as does an unused const x = 1 / zero;. All were simulated on a local fork of Base at block 53161500 with the current contracts; on Solana [1 / zero, 7][1] also returns 7.
• A call in the literal changes that. If a literal contains a helper call, a contract call or a token read (pot.USDC, USDC.balanceOf(pot)), every element up to and including the last one runs, in order, even when indexing takes another element. [1 / zero, f()][1] and [f(1 / zero), 7][1] both revert for zero = 0, and a write inside f runs when execution reaches it. Elements after the last call are still skipped: [pot.USDC, 1 / zero][0] returns the Pot’s USDC, and [f(1), 1 / zero][0] returns f(1). A builtin such as Math.mulDiv is not a call. Simulated on a local fork of Base at block 53166500 with the current contracts. Use an explicit require for a condition that must always be checked, and a statement of its own for a call that must run.
• An array is a reference. Assigning it to another variable, or passing it to a function, shares the same elements: after const b = a; b[0] = 7;, a[0] is 7 (simulated on the fork at block 52965000).

​

Records

interface Leg {
  pool: Address;
  amount: Uint256;
}

function main(legs: Leg[], to: Address): Uint256 {
  const order = { amount: legs[0].amount, recipient: to };
  order.amount = order.amount + 1;
  return order.amount + legs[0][1];
}

• { amount, recipient: to } builds a record; a field named like a variable can be written once (amount).
• A field is read by name: order.amount. This works on every record.
• A field is also read by a constant position, legs[0][1] for the second field of the first leg, but only on a record the compiler does not hold. A record that comes from a main parameter, an array element, a contract call, abi.decode or a function’s return value is read by position. A position is a number literal or a const bound to one:

function main(order: { amount: Uint256, fee: Uint256 }): Uint256 {
  const second = 1;
  return order[0] + order[second];
}

• An object literal bound to a variable in the same function is held by the compiler under its field names. Reading it by position is refused, even when some fields are run-time values: order[0] on const order = { amount: amount, fee: 30 }; fails with “a computed member of an object the compiler holds (read it by name: object.member) is not supported in SauceScript yet”. Write order.amount.
• A position that is not a literal or a bound const is refused on a record that comes from a parameter: order[i] fails with “a tuple index must be a number literal or a const bound to one”. Read the field by name, or branch on i between literal positions: i == 0 ? order[0] : order[1]. A computed position on an object literal is refused with the message of the previous item.
• const [a, b] = record destructures by position, and works on an object literal too. See Expressions and control flow.
• A record is a reference, like an array.

​

Accounts

function main(state: Account<Writable, Signer>, mint: Account, vault: Account<Writable>): Uint256 {
  require(mint.address != vault.address, "mint is the vault");
  require(state.owner == ctx.self(), "state is not the engine's");
  return mint.dataLen;
}

• acct.address is the account’s public key, acct.owner the program that owns it, acct.dataLen its data size in bytes. They are read-only.
• Accounts compare with == and != only.
• An account is not data. It cannot be returned, and arithmetic on it fails:

function main(mint: Account): Address {
  return mint.address;
}

• svm.sstore writes only an account declared Account<Writable, Signer>.

function main(target: Account): Address {
  return target.address;
}

​

Type names that are not types

`uint256` is not a type — write `Uint256`, `Address`, `Account`, `bool`, `bytes` or `string`, an array `T[]`, an inline object type `{ a: Uint256 }` for a tuple (or the name of an `interface` this module declares or `import`s), or `void` for a function that returns nothing

​

Not supported

​

Next steps

• Expressions and control flow: operators on these types, signed arithmetic, loops and destructuring.
• Functions: passing values by reference and by copy, and the : Int256 return annotation.
• Builtins: Math, crypto, abi and every value method.
• EVM and Solana: accounts and what differs between targets.