Testmodule is only available inside the
ligo run testcommand. See also Testing LIGO.
A type for code that's compiled to Michelson.type michelson_program
A test error.type test_exec_error = ["Rejected", michelson_program, address] | ["Other"]
A test execution result.type test_exec_result = ["Success"] | ["Fail", test_exec_error]
A type for an address of a contract with parameter `'p` and storage `'s`.type typed_address <'p, 's>
let to_contract = (account: typed_address <'p, 's>) => contract <'p>
Get the contract corresponding to the default entrypoint of a typed
address: the contract parameter in the result will be the type of the
default entrypoint (generally
'p, but this might differ if
includes a "default" entrypoint).
let to_entrypoint = (entrypoint: string, account: typed_address <'p, 's>) => contract <'e>
Get the contract corresponding to an entrypoint of a typed address: the contract parameter in the result will be the type of the entrypoint, it needs to be annotated, entrypoint string should omit the prefix "%".
let originate_from_file = (filepath: string, entrypoint: string, init: michelson_program, balance: tez) => [address, michelson_program, int]
Originate a contract with a path to the contract file, an entrypoint, an initial storage and an initial balance.
let originate = (contract: ('parameter, 'storage) => (list <operation>, 'storage), init: 'storage, balance: tez) => [typed_address <'parameter, 'storage>, michelson_program, int]
Originate a contract with an entrypoint function, initial storage and initial balance.
Set the timestamp of the predecessor block.let set_now = (now: timestamp) => unit
Set the source for `Test.transfer` and `Test.originate`.let set_source = (source: address) => unit
Force the baker for `Test.transfer` and `Test.originate`. By default, the first bootstrapped account.let set_baker = (source: address) => unit
Bake a transaction by sending an amount of tez with a parameter from the current source to another account.let transfer = (addr: address, parameter: michelson_program, amount: tez) => test_exec_result
Similar as `Test.transfer`, but fails when anything goes wrong.let transfer_exn = (addr: address, parameter: michelson_program, amount: tez) => unit
Bake a transaction by sending an amount of tez with a parameter from the current source to a contract.let transfer_to_contract = (addr: contract<'p>, parameter: 'p, amount: tez) => test_exec_result
Similar as `Test.transfer_to_contract`, but fails when anything goes wrong.let transfer_to_contract_exn = (addr: contract<'p>, parameter: 'p, amount: tez) => unit
Get the storage of an account in `michelson_program`.let get_storage_of_address = (account: address) => michelson_program
Get the storage of a typed account.let get_storage = (account: typed_address <'p, 's>) => 's
Get the balance of an account in tez.let get_balance = (account: address) => tez
Compare two Michelson values.let michelson_equal = (a: michelson_program, b: michelson_program) => bool
Log a value.let log = (a: 'a) => unit
Generate a number of random bootstrapped accounts with a default amount of 4000000 tez. The passed list can be used to overwrite the amount. By default, the state only has two bootstrapped accounts.let reset_state = (no_of_accounts: nat, amount: list<tez>) => unit
Returns the address of the nth bootstrapped account.let nth_bootstrap_account = (nth: int) => address
Returns the address corresponding to the nth bootstrapped contract.let nth_bootstrap_contract = (nth: nat) => address
let bootstrap_contract = (balance: tez, contract: ('parameter, 'storage) => (list <operation>, 'storage), init: 'storage) => unit
Setup a bootstrap contract with an entrypoint function, initial storage and initial balance. Bootstrap contracts will be loaded in order, and they will be available only after reset.
Returns the typed address corresponding to the nth bootstrapped contract currently loaded. The types are inferred from those contracts loaded with `Test.bootstrap_contract` (before reset).let nth_bootstrap_typed_address = (nth: int) => typed_address <'p, 's>
Returns addresses of orginated accounts in the last transfer. It is given in the form of a map binding the address of the source of the origination operation to the addresses of newly originated accounts.let last_originations = (_: unit) => map<address , address list>
Compile a LIGO value to Michelson.let compile_value = (value: 'a) => michelson_program
Compile a LIGO value to Michelson. Currently it is a renaming of `compile_value`.let eval = (value: 'a) => michelson_program
let run = (func: ('a => 'b), value: 'a) => michelson_program
Run a function on an input, all in Michelson. More concretely:
a) compiles the function argument to Michelson
b) compiles the value argument (which was evaluated already) to Michelson
c) runs the Michelson interpreter on the code
f_mich with starting stack
[ v_mich ].
let mutate_value : (index: nat, value: 'a) => option <['a, mutation]>
Mutates a value using a natural number as an index for the available mutations, returns an option for indicating whether mutation was successful or not.
let mutation_test : (value: 'a, tester: ('a -> 'b)) => option <['b, mutation]>
Given a value to mutate (first argument), it will try all the mutations available of it, passing each one to the function (second argument). On the first case of non failure when running the function on a mutation, the value and mutation involved will be returned.
let mutation_test_all : (value: 'a, tester: ('a -> 'b)) => list <['b, mutation]>
Given a value to mutate (first argument), it will try all the mutations of it, passing each one to the function (second argument). In case no failure arises when running the function on a mutation, the failure and mutation involved will be added to the list to be returned.
let save_mutation : (path: string, mutation: mutation) => option <string>
This function reconstructs a file from a mutation (second argument),
and saves it to a file in the directory path (first argument). It
returns an optional string indicating the filename where the mutation
was saved, or
None if there was an error.
let save_mutation : adress => typed_address <'p, 's>
This function casts an address to a typed address. You will need to annotate the result with the type you expect.
let set_big_map: (id: 'int, big_map: big_map<'key, 'value>) => unit
The testing framework keeps an internal reference to the values corresponding to big map identifiers. This function allows to override the value of a particular big map identifier. It should not be normally needed, except in particular circumstances such as using custom bootstrap contracts that initialize big maps.