Exam

Question 1

What is correct about LIGO?

LIGO is a programming language for writing Tezos smart contracts.

Smart contracts are, by default, written in the LIGO language.

The LIGO compiler converts LIGO high-level code into Michelson script.

The LIGO syntax is PascaLigo.

Question 2

What notions are defined inside the smart contract?

The type-definition of the storage.

The balance on the contract.

The initial value of the storage.

The value of the entry point and its related parameters.

The type definition of the entry point.

The code of the smart contract.

The list of users allowed to call the smart contract.

Question 3

What is returned by the execution of a smart contract?

The modified storage state after invoking the smart contract.

The entry point that has been called (and its related parameters).

The list of emitted operations produced by the execution of the smart contract.

The balance of the contract.

The size of the storage.

The code of the smart contract.

The list of users allowed to call the smart contract.

Question 4

What is the right way to define a variable?

`var int : my_age = 25`

`int my_age = 25`

`var int = my_age : 25`

`var my_age : int = 25`

`var my_age : int := 25`

`var my_age = 25 : int`

Question 5

What is the right way to define a constant?

`const string : my_name = "Roger"`

`string my_age = "Roger"`

`const string = my_name : "Roger"`

`const my_name : string = "Roger"`

`const my_name : string := "Roger"`

`const my_name = "Roger" : string`

Question 6

Which of the following operations are correct?

`const a : int = 5 + 10`

`const c : tez = 5mutez + 0.000_010tez`

`const c : nat = 5n - 2n`

`const b : int = 5n + 10`

`const d : tez = 5mutez + 10n`

`const b : int = 5n - 2n`

`const d : tez = 5mutez - 1mutez`

Question 7

What is correct about type aliasing?

Type aliasing consists in naming a given type when the context calls for a more precise name.

Type aliasing increases the readability and maintainability of your smart contracts.

`type name = string` is the correct way to define a type.

`type name is string` is the correct way to define a type.

Question 8

What is a set?

A linear collection of elements of the same type.

A data structure that associates values of the same type to values of the same type.

An unordered collection of values of the same type.

One way that data of different types can be packed into a single type, which is made of a field name and a field type.

Question 9

What is a record?

A linear collection of elements of the same type.

A data structure that associates values of the same type to values of the same type.

An unordered collection of values of the same type.

One-way that data of different types can be packed into a single type, which is made of a field name and a field type.

Question 10

Consider the following smart contract.

type counterStorage is int

type counterEntrypoints is Increment of int | Decrement of int

type counterReturn is ########

function increment(const param : int; const s : counterStorage) : counterReturn is 
block { skip } with ((nil: list(operation)), s + param)

function decrement(const param : int; const s : counterStorage) : counterReturn is 
block { skip } with ((nil: list(operation)), s - param)

function main(const ep : counterEntrypoints; const store : counterStorage) : counterReturn is
block { 
    const ret : counterReturn = case ep of 
    | Increment(p) -> increment(p, store)
    | Decrement(p) -> decrement(p, store)
    end;
    
 } with ret

Complete the ######## part in the code to give the return type of the main function a correct definition. (More than one answer may be valid)

`type counterReturn is list(operation) * counterEntrypoints`

`type counterReturn is counterEntrypoints * counterStorage`

`type counterReturn is list(operation) * counterStorage`

`type counterReturn is counterStorage`

`type counterReturn is counterEntrypoints`

`type counterReturn is list(operation) * int`

Which of the following proposals is called an entrypoint for this smart contract?

`Increment(p)`

`Increment(p) -> increment(p, store)`

`indiceEntrypoints`

`Decrement(p)`

`Decrement(p) -> decrement(p, store)`

`increment`

`ret`

`decrement`

What command lines are correct for this smart contract? (Assume that the smart contract is stored in a file counter.ligo)

ligo compile-contract counter.ligo main

ligo compile-contract main counter.ligo

ligo dry-run counter.ligo main 'Increment(5)' '4'

ligo dry-run counter.ligo increment 'Increment(5)' '4'

ligo compile-parameter counter.ligo main 'Decrement(5)'

ligo compile-parameter counter.ligo decrement 'Decrement(5)'

ligo compile-parameter counter.ligo main 'decrement' '5'

ligo compile-parameter counter.ligo main '0'

ligo compile-storage counter.ligo main '0'

ligo compile-storage counter.ligo main 'counterStorage(0)'