Quick reference¶

uint        // 256-bit unsigned integer
address     // 20-byte address; stored as uint at runtime
bool        // 0 or 1
bytes       // length-prefixed byte string (function returns only)

map[K, V]   // backed by SHA3(key_word || slot_word)
array[T]    // dynamic storage array

0  42  1_000_000  0xCAFE_BABE   // integers
true  false                      // booleans
"alice"                          // string → uint, right-padded to 32 bytes
""                               // empty string == 0

contract Name {
    // storage declarations (each pinned to a slot)
    storage value: uint @ 0;
    storage balances: map[address, uint] @ 1;

    // events
    event Updated(by: address, new_value: uint);

    // optional init — runs once on first call, no params, no return
    fn init() {
        value = 0;
    }

    // public entry points get selectors 0x01, 0x02, ... in declaration order
    pub fn set(v: uint) {
        require(caller() == 0);          // example check
        value = v;
        emit Updated(caller(), v);
    }

    pub fn get() -> uint {
        return value;
    }
}

let x: uint = 1;                         // declare local
x = x + 1;                                // assign local
value = 42;                               // assign storage scalar
balances[addr] = 100;                     // assign mapping slot

if cond { ... } else { ... }              // else optional
while cond { ... }
return EXPR;                              // or `return;` in void fn
require(cond);                            // revert if false
require(cond, msg_bytes);                 // revert with bytes payload
emit Updated(addr, val);
expr;                                     // expression statement

caller()           -> address    // msg.sender
callvalue()        -> uint        // WAVE attached to this call
origin()           -> address     // tx.origin
block_height()     -> uint
timestamp()        -> uint
balance(addr)      -> uint        // address WAVE balance
sha3(word)         -> uint        // SHA3-256 of one 32-byte word

require(cond)
require(cond, msg)                // msg is a `bytes` value

// Checked arithmetic — revert on overflow / underflow / div-by-zero
safe_add(a, b)     -> uint
safe_sub(a, b)     -> uint
safe_mul(a, b)     -> uint
safe_div(a, b)     -> uint

// Q64.64 fixed-point math (scale = 2**64; 1.0 == 2**64)
from_int(n)         -> uint        // lift integer to fixed
to_int(f)           -> uint        // truncate fractional bits
fmul(a, b)          -> uint        // (a * b) / 2**64
fdiv(a, b)          -> uint        // (a * 2**64) / b

// Storage array
len(arr)           -> uint
push(arr, v)       -> uint        // returns new length
pop(arr)           -> uint        // returns popped element; reverts if empty

// Cross-contract (calldata is a `bytes` value built with pack_sel)
pack_sel(sel, arg1, ..., argN)  -> bytes
call_b(addr, calldata, value, gas)    -> uint   // 1 = success
delegatecall_b(addr, calldata, gas)   -> uint
staticcall_b(addr, calldata, gas)     -> uint

// Library-call sugar — DELEGATECALL with auto-pack + auto-revert
lib_call(lib_addr, selector, args..., gas) -> uint   // returns callee's return word

// One-word legacy call (single 32-byte calldata word)
call(addr, calldata_word, value, gas) -> uint

// PQC signature verify — scheme_id must be a literal int
verify_sig(scheme_id, pk: bytes, msg: bytes, sig: bytes) -> uint