Skip to main content

Language Basics

Core language features and syntax in the current implementation.

Ora is experimental. Current behavior may change without notice. behavior and may change without notice.

Overview​

Ora is a contract language with explicit regions, error unions, and verification-friendly constructs. The compiler focuses on correctness and transparent semantics rather than implicit magic.

Note: the current compiler requires explicit type annotations for local variables (var x: u256 = ...).

Contracts​

contract MyContract {
    // Contract contents
}

Variables and regions​

contract Counter {
    storage var count: u256;   // persistent storage
    storage var owner: address;
    storage var active: bool;
}

Immutables and constants​

contract Token {
    immutable name: string;
    storage const MAX_SUPPLY: u256 = 1000000;
}

Types​

Primitives​

var a: u8 = 255;
var b: u256 = 1;
var ok: bool = true;
var who: address = 0x742d35Cc6634C0532925a3b8D0C5e0E0f8d7D2;
var msg: string = "hello";

Composite types​

struct User {
    name: string;
    balance: u256;
}

enum Status : u8 { Pending, Active, Closed }

var balances: map<address, u256>;

Functions​

contract Math {
    pub fn add(a: u256, b: u256) -> u256 {
        return a + b;
    }

    fn internal_calc(x: u256) -> u256 {
        return x * 2;
    }
}

Error unions​

Ora uses explicit error unions:

error InsufficientBalance;
error InvalidAddress;

fn transfer(to: address, amount: u256) -> !u256 | InsufficientBalance | InvalidAddress {
    if (amount == 0) return error.InvalidAddress;
    if (balance < amount) return error.InsufficientBalance;
    balance -= amount;
    return balance;
}

Control flow​

fn classify(x: u32) -> u32 {
    if (x == 0) return 0;
    if (x < 10) return 1;
    return 2;
}

Switch works as expression or statement:

fn grade(score: u32) -> u8 {
    var g: u8 = 0;
    switch (score) {
        0...59   => g = 0;,
        60...69  => g = 1;,
        70...79  => g = 2;,
        80...89  => g = 3;,
        90...100 => g = 4;,
        else     => g = 5;,
    }
    return g;
}

Refinements (frontend)​

The type resolver supports refinement types such as:

  • MinValue<T, N>
  • MaxValue<T, N>
  • InRange<T, Min, Max>
  • NonZeroAddress

These refinements are enforced in the front-end and also surfaced to the verification pipeline.

Specification clauses​

Ora parses and type-checks specification clauses:

pub fn transfer(to: address, amount: u256) -> bool
    requires amount > 0
    ensures  amount > 0
{
    // ...
}

assume is verification-only; assert is runtime-visible and verification- visible.

Where to go next​