Leo Syntax Cheatsheet
1. File Import
import foo.aleo;
2. Programs
program hello.aleo {
// code
}
3. Data Types
let b: bool = false; // boolean
let i: u8 = 1u8; // unsigned integer
let a: field = 1field; // field element
let g: group = 0group; // group element
let s: scalar = 1scalar; // scalar element
let receiver: address = aleo1ezamst4pjgj9zfxqq0fwfj8a4cjuqndmasgata3hggzqygggnyfq6kmyd4; // address
Type Casting
let a: u8 = 1u8;
let b: u32 = a as u32; // cast 1u8 to 1u32
The primitive types are: address
, bool
, field
, group
, i8
, i16
, i32
, i64
, i128
, u8
, u16
, u32
, u64
, u128
, scalar
.
We can cast between all of these types.
4. Records
record token {
owner: address,
amount: u64,
}
5. Structs
struct message {
sender: address,
object: u64,
}
6. Arrays
let arr: [bool; 2] = [true, false];
7. Transitions
transition mint_public(
public receiver: address,
public amount: u64,
) -> token { /* Your code here */ }
8. Functions
function compute(a: u64, b: u64) -> u64 {
return a + b;
}
9. Inline Functions
inline foo(
a: field,
b: field,
) -> field {
return a + b;
}
The rules for functions (in the traditional sense) are as follows:
There are three variants of functions: transition, function, inline. transitions can only call functions and inlines. functions can only call inlines. inlines can only call inlines. Direct/indirect recursive calls are not allowed
10. For Loops
let count: u32 = 0u32;
for i: u32 in 0u32..5u32 {
count += 1u32;
}
11. Mappings
mapping balances: address => u64;
let contains_bal: bool = Mapping::contains(balances, receiver);
let get_bal: u64 = Mapping::get(balances, receiver);
let get_or_use_bal: u64 = Mapping::get_or_use(balances, receiver, 0u64);
let set_bal: () = Mapping::set(balances, receiver, 100u64);
let remove_bal: () = Mapping::remove(balances, receiver);
12. Commands
transition matches(height: u32) -> Future {
return check_height_matches(height);
}
async function check_height_matches(height: u32) {
assert_eq(height, block.height); // block.height returns latest block height
}
let g: group = group::GEN; // the group generator
let result: u32 = ChaCha::rand_u32(); // generate a random type `ChaCha::rand_<type>()`
let owner: address = self.caller; // address of the program function caller
let hash: field = BHP256::hash_to_field(1u32); // hash any type to any type
let commit: group = Pedersen64::commit_to_group(1u64, 1scalar); // commit any type to a field, group, or address, using a scalar as blinding factor
let a: bool = true;
assert(a); // assert the value of a is true
let a: u8 = 1u8;
let b: u8 = 2u8;
assert_eq(a, a); // assert a and b are equal
assert_neq(a, b); // assert a and b are not equal
13. Operators
let sum: u64 = a + b; // arithmetic addition
let diff: u64 = a - b; // arithmetic subtraction
let prod: u64 = a * b; // arithmetic multiplication
let quot: u64 = a / b; // arithmetic division
let remainder: u64 = a % b; // arithmetic remainder
let neg: u64 = -a; // negation
let bitwise_and: u64 = a & b; // bitwise AND
let bitwise_or: u64 = a | b; // bitwise OR
let bitwise_xor: u64 = a ^ b; // bitwise XOR
let bitwise_not: u64 = !a; // bitwise NOT
let logical_and: bool = a && b; // logical AND
let logical_or: bool = a || b; // logical OR
let eq: bool = a == b; // equality
let neq: bool = a != b; // non-Equality
let lt: bool = a < b; // less than
let lte: bool = a <= b; // less than or equal
let gt: bool = a > b; // greater than
let gte: bool = a >= b; // greater than or equal