A friendly smart-contract language for Tezos

Michelson was never so easy

PascaLIGO

CameLIGO

ReasonLIGO

// variant defining pseudo multi-entrypoint actions
type action is
| Increment of int
| Decrement of int

function add (const a : int ; const b : int) : int is a + b

function subtract (const a : int ; const b : int) : int is a - b

// real entrypoint that re-routes the flow based on the action provided
function main (const p : action ; const s : int) : (list(operation) * int) is 
  ((nil : list(operation)),
    case p of
    | Increment (n) -> add (s, n)
    | Decrement (n) -> subtract (s, n)
    end)

type storage = int

(* variant defining pseudo multi-entrypoint 
  actions *)
type action =
  | Increment of int
  | Decrement of int

let add (a: int) (b: int): int = a + b

let subtract (a: int) (b: int): int = a - b

(* real entrypoint that re-routes the flow 
   based on the action provided *)
let%entry main(p : action) storage =
  let storage =
    match p with
    | Increment n -> add storage n
    | Decrement n -> subtract storage n
  in (([] : operation list), storage)

type storage = int;

/* variant defining pseudo multi-entrypoint
   actions */
type action =
  | Increment(int)
  | Decrement(int);

let add = (a: int, b: int): int => a + b;

let subtract = (a: int, b: int): int => a - b;

/* real entrypoint that re-routes the flow
   based on the action provided */
let main = (p: action, storage) => {
  let storage =
    switch (p) {
    | Increment(n) => add(storage, n)
    | Decrement(n) => subtract(storage, n)
    };
  ([]: list(operation), storage);
};

Strong Type System

Write types, then code. Benefit from the safety of type systems.

Syntax Agnostic

Code in your language. Write PascaLIGO, CameLIGO, or add your own syntax.

Easy Integration

You can use LIGO as a NodeJS library with Granary

Our Partners