ligo compile contract SOURCE_LIGO_FILE

ligo compile contract examples/counter.ligo

ligo run dry-run [flags] SOURCE_LIGO_FILE 'ACTION(P)' 'STORAGE_STATE'

ligo run dry-run counter.ligo 'Increment(5)' 3
// Outputs: ( LIST_EMPTY() , 8 )

ligo compile storage SOURCE_LIGO_FILE 'STORAGE_STATE'

ligo compile storage counter.ligo 5
// Outputs: 5

ligo compile-parameter SOURCE_LIGO_FILE MAIN_FUNCTION 'ACTION(P)'

ligo compile parameter examples/counter.ligo main 'Increment(5)'
// Outputs: (Right 5)

octez-client originate contract CONTRACT_NAME transferring AMOUNT_TEZ from FROM_USER \\
             running MICHELSON_FILE \\
             --init 'INITIAL_STORAGE' --burn-cap GAZ_FEE

octez-client transfer AMOUNT_TEZ from USER to CONTRACT_NAME --arg 'ENTRYPOINT_INVOCATION' --dry-run

where:

• AMOUNT_TEZ is the quantity of Tez being transferred to the contract.

• CONTRACT_NAME is the name given to the contract.

• ENTRYPOINT_INVOCATION is a Michelson expression of the entrypoint and the corresponding parameter. The --arg parameter specifies an entrypoint call.

⚠️ Notice that the --dry-run parameter simulates the invocation of the entrypoint.

Example​

Let’s consider a counter contract for our example.

Our counter contract will store a single int as its storage, and will accept an action variant in order to re-route our single main function to two entrypoints for add (addition) and sub (subtraction).

type parameter is
  Increment of int
| Decrement of int

type storage is int

type return is list (operation) * storage

function add (const n : int; const store : storage) : storage is store + n
function sub (const n : int; const store : storage) : storage is store - n

function main (const action : parameter; const store : storage) : return is
  ((nil : list(operation)),
  case action of [
    | Increment (n) -> add (n, store)
    | Decrement (n) -> sub (n, store)
  ])

Compile

ligo compile contract counter.ligo > counter.tz

The command above outputs the following Michelson code:

{ parameter (or (int %decrement) (int %increment)) ;
  storage int ;
  code { UNPAIR ; IF_LEFT { SWAP ; SUB } { ADD } ; NIL operation ; PAIR } }

Initial storage​

However, in order to originate a Michelson contract on Tezos, we also need to provide its initial storage value, we can use compile storage to compile the LIGO representation of the storage to Michelson.

ligo compile storage counter.ligo 5
// Outputs: 5

Invocation parameter​

The same rules apply to the parameters. We will need to use compile parameter to compile our action variant into Michelson, here’s how:

ligo compile parameter counter.ligo 'Increment(5)'
// Outputs: (Right 5)

We can now use (Right 5), which is a Michelson value, to invoke our contract via octez-client.

Simulating​

To dry-run the counter-contract, we provide a main function with a variant parameter of value Increment (5) and an initial storage value of 3.

ligo run dry-run counter.ligo 'Increment(5)' 3
// Outputs: ( LIST_EMPTY() , 8 )

The simulation shows that our storage would have been incremented to 8.

Deploy​

Now that we have verified that our code compiles well and that it was functional, we can deploy our contract on the blockchain.

octez-client originate contract counterContract for boostrap1 transferring 1 from boostrap2 \\
             running code.tz \\
             --init '0' --burn-cap 0.12525

Invoke​

Let’s invoke the entrypoint Increment(5) of the smart contract. Remember that the output of the compile parameter of this entrypoint was (Right 5)

octez-client transfer 5 from boostrap1 to counterContract --arg '(Right 5)'

Accessing storage​

You can access the stored value with the following command:

octez-client get contract storage for counterContract

Some specificities for Maps, Tuples, and Records​

Consider the following LIGO code snippet for the storage definition

//starmap.ligo
type coordinates is ( int * int * int)
type storage is map (string, coordinates)

function main (const _action : unit; const store : storage) : list(operation) * storage is
  ((nil : list(operation)), store)

Maps​

The initialization of the elements of a map is specified between map [ and ] and elements are separated by a semi-colon ;. Each element is a key/value pair separated by ->.

Initialization of the elements of a map follows the syntax:

map[ KEY1 -> VALUE1; KEY2 -> VALUE2 ]

Here is an example of a command-line ligo compile storage for transpiling a map.

ligo compile storage starmap.ligo 'map [ "earth" -> (2,7,1); "sun" -> (0,0,0) ]'

This command returns:

{ Elt "earth" (Pair (Pair 2 7) 1) ; Elt "sun" (Pair (Pair 0 0) 0) }

Tuples​

Initialization of the tuple elements is specified between ( and ), and separated by comma ,.

(VALUE1, VALUE2, VALUE3)

Here is an example of a command-line ligo compile storage for compiling a map containing a tuple.

ligo compile storage starmap.ligo 'map [ "earth" -> (2,7,1) ]'

This command returns:

{ Elt "earth" (Pair (Pair 2 7) 1) }

When specifying an empty map, one must set the map [] into the expected type.

ligo compile storage starmap.ligo '(map []: map(string,coordinates))'

Records​

Initialization of elements in a record is specified between map [ and ] and elements separated by a semi-colon ;.
Each element is a key/value pair separated by = and follows the syntax:

record[ KEY1 = VALUE1; KEY2 = VALUE2 ]

We should now have a record instead of a tuple for coordinates.

//starmap2.ligo
type coordinates is record [
  x : int;
  y : int;
  z : int
]
type storage is map (string, coordinates)

function main (const _action : unit; const store : storage) : list(operation) * storage is
  ((nil : list(operation)), store)

We can compile the storage as follows:

ligo compile storage starmap2.ligo 'map [ "earth" -> record [x=2;y=7;z=1] ]'

This command returns:

{ Elt "earth" (Pair (Pair 2 7) 1) }

With this, you complete this workshop successfully!!