Expressions and control flow

​

Operators

function main(a: Uint256, b: Uint256): Uint256 {
  const spread = a > b ? a - b : b - a;
  const mixed = ((a + b) * 3) / 2 + (a % 7) + a ** 2;
  const bits = (a & b) | (a ^ b) | (a << 1) | (b >> 1);
  if ((a > 1 && b < 10) || !(a == b)) {
    return spread + mixed + bits;
  }
  return ~a;
}

• On a Uint256, / rounds down. a / 0 and a % 0 revert.
• && and || evaluate the right operand only when needed, and produce true or false, never one of the operands. That holds for a contract name too: UniswapV3.Factory || 0 is true where the chain has the factory, not its address.
• The two arms of ? : must have the same type. flag ? amount : true is refused with “the two arms of ? : must have the same type — the then arm is a number, the else arm is a bool”.
• On an Int256, the operators are signed. See Signed arithmetic.
• An array literal indexed at a literal position (or at a const bound to one) does not run every element. With no helper call, contract call or token read in it, only the element taken runs: [1 / zero, 7][1] returns 7 for zero = 0. With one, every element up to and including the last call or token read runs, in order, and a write inside a call happens: [1 / zero, pot.USDC][1] and [f(1 / zero), 7][1] revert. Elements after the last call are still skipped: [pot.USDC, 1 / zero][0] returns the Pot’s USDC. A builtin such as Math.mulDiv is not a call: [Math.mulDiv(1, 1, zero), 7][1] returns 7. Simulated on a local fork of Base at block 53166500 with the current contracts. Put a check or write that must run in its own statement (Arrays).

​

Precedence

function main(): Int256 {
  return -(2 ** 2);
}

​

Signed arithmetic

// a / b, a % b, a >> 1 and a < b, for signed a and b.
//
//   sauce simulate signed-ops.sauce.ts --chain <chain> --owner <address> --args <a> <b>
//
//   a: Int256   any signed integer: -7
//   b: Int256   nonzero: 2
function main(a: Int256, b: Int256): Int256[] {
  return [a / b, a % b, a >> 1, a < b ? 1 : 0];
}

• / and % are checked as on Uint256, and one more division overflows: the minimum, −2²⁵⁵, divided by -1. Int256.fromBits(word) / divisor with word equal to 2²⁵⁵ and divisor = -1 reverts on the Base fork, and the engine refuses it with Overflow on Solana (slot 460264648). Divided by 2, the same value gives −2²⁵⁴.
• Arithmetic takes two operands of the same kind: amount + delta, with amount a Uint256 and delta an Int256, is refused until one operand is converted with Int256(...) or Uint256(...).
• A comparison takes both kinds and compares the numeric values: with b = -1, b < a is true for a = 5 and for a = 2²⁵⁶ − 1 on the same fork.

​

Assignment

function main(a: Uint256): Uint256 {
  let i = a;
  i++;
  i--;
  i += 10;
  i *= 2;
  i <<= 1;
  return i;
}

​

Conditionals

function main(amount: Uint256): Uint256 {
  if (amount < 1000000) {
    return 30;
  } else if (amount < 100000000) {
    return 10;
  } else {
    return 5;
  }
}

​

Loops

function main(amounts: Uint256[], cap: Uint256): Uint256 {
  let total = 0;
  for (const amount of amounts) {
    total += amount;
  }
  for (let i = 0; i < amounts.length; i++) {
    if (amounts[i] == 0) {
      continue;
    }
    if (amounts[i] > cap) {
      break;
    }
    total += amounts[i];
  }
  let rounds = 0;
  while (rounds < 3) {
    rounds++;
  }
  return total + rounds;
}

function main(b: bytes): Uint256 {
  let total = 0;
  for (let i = 0; i < b.length; i++) {
    total += b[i];
  }
  return total;
}

function main(n: Uint256): Uint256 {
  let i = 0;
  while (true) {
    i += 1;
    if (i >= n) {
      break;
    }
  }
  return i;
}

​

What a loop costs

function main(n: Uint256): Uint256 {
  let total = 0;
  for (let i = 0; i < n; i++) {
    total = total + i;
  }
  return total;
}

​

Destructuring

function main(pool: Address, data: bytes): Uint256 {
  const [sqrtPriceX96, tick] = UniswapV3.Pool(pool).slot0();
  const [amount, to] = abi.decode(data, ["Uint256", "Address"]);
  const order = { size: amount, fee: 30 };
  const [size, fee] = order;
  return sqrtPriceX96 + size + fee;
}

• A hole skips a field: const [, tick] = UniswapV3.Pool(pool).slot0();. Taking fewer names than fields takes the leading ones.
• let [x, y] = … gives variables that can be reassigned.
• An array is indexed, not destructured: const [a, b] = xs is refused with “a destructuring binding needs an initializer that produces a tuple — this one does not, so bind it to one name instead”. Write xs[0] and xs[1].
• Object destructuring, const { fee } = order, is not supported: write const fee = order.fee;.

​

Methods and positions

function main(amount: Uint256): bytes {
  return "ab".concat((5).toBytesBe(2), amount.toBytesBe(1));
}

​

Constant folding

const FEE_BPS = 30;

function main(amount: Uint256): Uint256 {
  return (amount * (10000 - FEE_BPS)) / 10000;
}

​

Testing a name

function main(tokenA: Address, tokenB: Address): Address {
  if (UniswapV3.Factory) {
    return UniswapV3.Factory.getPool(tokenA, tokenB, 500);
  }
  return 0;
}

​

Not supported

​

Next steps

• Functions: helpers, return paths and call cost.
• Errors and reverts: require, throw, try/catch and .catch.
• Types: what each operator accepts.
• Names: token symbols, namespaces, and testing whether the chain has a name.