Version: 0.11.0


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 big_map ('key, 'value)

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

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

Be aware that a big_map cannot appear inside another big_map.

type bool
type bytes
type contract('parameter)

A typed contract.

Use unit as parameter 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 list ('t)

A sequence of elements of the same type.

type map ('key, 'value)

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

type move is int * int
type register is 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 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 unit
function is_nat: int -> option(nat)

Convert an int to a nat if possible.

Note that Michelson.is_nat is deprecated. Please use is_nat instead.

function abs: int -> nat

Cast an int to nat.

function int: nat -> int

Cast an nat to int.

const unit: unit

A helper to create a unit.

function failwith : 'a -> unit

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.

function main (const p : int; const s : unit) : list (operation) * unit is
block {
if p > 10 then failwith ("Failure.") else skip
with ((nil : list (operation)), s)
function assert : bool -> unit

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

function ediv : int -> int -> option (int * nat)
function ediv : mutez -> nat -> option (mutez * mutez)
function ediv : mutez -> mutez -> option (nat * mutez)
function ediv : nat -> 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).

type sapling_state (N)
type sapling_transaction (N)
type ticket 'v

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 is int
type my_ticket is ticket (va)