Top-Level

These types and functions are available without any needed prefix.

type address

An untyped address which can refer to a smart contract or account.

type ('key, 'value) big_map

type big_map <'key, 'value>

The type of a big map from values of type key to values of type value is (key, value) big_map.

type move = int * int
type register = (address, move) big_map

The type of a big map from values of type key to values of type value is big_map<key, value>.

type move = [int, int];
type register = big_map<address, move>;

Be aware that a big_map cannot appear inside another big_map.

type bool

type bytes

type 'param contract

type contract<'param>

A typed contract.

Use unit as param to indicate an implicit account.

type chain_id

The identifier of a chain, used to indicate test or main chains.

type int

An integer.

The only size limit to integers is gas.

type key

A public cryptographic key.

type key_hash

The hash of a public cryptographic key.

type 't list

type list<'t>

A sequence of elements of the same type.

type ('key, 'value) map

type map <'key, 'value>

The type of a map from values of type key to values of type value is (key, value) map.

type move = int * int
type register = (address, move) map

The type of a map from values of type key to values of type value is map <key, value>.

type move = [int, int];
type register = map <address, move>;

type nat

A natural number.

The only size limit to natural numbers is gas.

type operation

An operation emitted by the contract

type 'value set

type set<'value>

type signature

A cryptographic signature.

type string

A sequence of characters.

type tez

A specific type for tokens.

type timestamp

A date in the real world.

type chest

A timelocked chest.

type chest_key

A key to open a timelocked chest.

type unit

val is_nat: int -> nat option

let is_nat: (i: int) => option<nat>

Convert an int to a nat if possible.

val abs: int -> nat

let abs: (i: int) => nat

Cast an int to nat.

val int: nat -> int

let int: (n: nat) => int

Cast an nat to int.

val unit: unit

let unit: unit

A helper to create a unit.

val failwith : 'a -> 'b

let failwith: (message: 'a) => 'b

Cause the contract to fail with an error message or integer. Other types are not supported at the moment.

Using this currently requires in general a type annotation on the failwith call.

let main (p : int) (_s : unit) : operation list * unit =
  if p > 10 then failwith "Failure." else [], ()

let main = (p: int, s: unit): [list<operation>, unit] => {
  if (p > 10) { failwith ("Failure."); } else return [list([]), []];
};

val assert : bool -> unit

let assert: (condition: bool) => unit

Check if a certain condition has been met. If not the contract will fail.

val ediv : int -> int -> (int * nat) option

val ediv : mutez -> nat -> (mutez * mutez) option

val ediv : mutez -> mutez -> (nat * mutez) option

val ediv : nat -> nat -> (nat * nat) option

let ediv: (value: int, divided_by: int) => option<[int, nat]>

let ediv: (value: mutez, divided_by: nat) => option<[mutez, mutez]>

let ediv: (value: mutez, divided_by: mutez) => option<[nat, mutez]>

let ediv: (value: nat, divided_by: nat) => option<[nat, nat]>

Compiles to Michelson EDIV, one operation to get both the quotient and remainder of a division. ediv x y returns None if y is zero, otherwise returns Some (quotient, remainder) such that x = (quotient * y) + remainder and 0 <= remainder < abs(y).

val ignore : 'a -> unit

let ignore: (value: 'a) => 'unit

Ignores a value, it can be an alternative to _ prefixed variables.

type 'n sapling_state

type 'n sapling_transaction

type 'v ticket

Edo protocol introduced the following ticket type. Follow this wallet example for an example of correct usage (it goes with its builder). This article might also be useful.

Note that a variable containing a ticket can only be used once (they are not DUP-able).

The ticket type can be defined over a comparable type 'v. 'v being the type of the value used to identify a given ticket.

type va = int
type my_ticket = va ticket