Skip to main content
Version: 1.5.0

tezos

Tezos-specific functions

let get_sender: (_: unit) => address

The call get_sender() is the address of the contract (that is, a smart contract or an implicit account) that initiated the current internal transaction. Note that, if transactions have been chained, that address could be different from get_source().

let get_source: (_: unit) => address

The call get_source() is the address of the implicit account that initiated the current transaction. If transactions have been chained, that address is different from get_sender().

let self: <a>(_: string) => contract<a>

The call self(entrypoint) is the address of the current smart contract, that is, the smart contract containing the call. For the address of the smart contract actually executing the call, because it is embedded in a lambda sent to another smart contract, use get_self_address instead. The string entrypoint is the name of a valid entrypoint such that entrypoint is not "default", or the empty string denoting the "default" entrypoint (which is the root of the smart contract parameter if no "default" entrypoint is explicitly defined). If the contract does not have the specified entrypoint, the call results in an type checking error.

let get_self_address: (_: unit) => address

The call get_self_address() is the address of the smart contract actually executing the call, as a value of type address. That contract can be different from the one containing the call if the call is in a lambda transmitted to another smart contract. Therefore, it is assumed that, in general, the type of the executing contract is statically unknown, so the return type of get_self_address is not 'a contract, but address. (See self.)

let address: <a>(_: contract<a>) => address

The call address(contract) casts the address of the smart contract contract into the more general value of type address.

let implicit_account: (_: key_hash) => contract<unit>

The call implicit_account(kh) casts the public key hash kh into the address of its implicit account. Note that addresses of implicit accounts always have the type contract<unit>.

let get_contract_opt: <param>(_: address) => option<contract<param>>

The call get_contract_opt(addr) casts the address addr into that of a contract address, if such contract exists. The value of the call is None() if no such contract exists, otherwise Some contract, where contract is the contract's address. Note: The address of an implicit account has type unit contract.

let get_contract_with_error: <param>(_: address) => (_: string) => contract<param>

The call get_contract_with_error(addr, error) casts the address addr into that of a contract address, if such contract exists. If not, the execution fails with the error message error.

let get_contract: <param>(_: address) => contract<param>

The call get_contract(addr) casts the address addr into that of a smart contract address, if such contract exists. The call fails with the message "bad address for get_contract" if no such smart contract exists. Note: The address of an implicit account has type contract<unit>.

let get_entrypoint_opt: <param>(_: string) => (_: address) => option<contract<param>>

The call get_entrypoint_opt(entrypoint, addr) has the same behaviour as get_contract_opt(addr), with the additional constraint that the contract must have an entrypoint named entrypoint. In other words, get_entrypoint_opt(entrypoint, addr) casts the address addr into that of a smart contract address, if such contract exists and has an entrypoint named entrypoint. The value of the call is None() if no such smart contract exists, otherwise Some(contract), where contract is the smart contract's address. Note: The address of an implicit account has type contract<unit>.

let get_entrypoint: <param>(_: string) => (_: address) => contract<param>

The call get_entrypoint(entrypoint, addr) casts the address addr into that of a smart contract address, if such contract exists and has an entrypoint named entrypoint. If no such smart contract exists, the execution fails with the error message "bad address for get_entrypoint". Note: The address of an implicit account has type contract<unit>.

let create_contract: <param, storage>(_: entrypoint<param, storage>) => (_: option<key_hash>) => (_: tez) => (_: storage) => [ operation, address ]

The call create_contract(e,d,a,s) returns a contract creation operation (origination) for the entrypoint e (as a function) with optional delegate d, initial amount a and initial storage s, together with the address of the created contract. Note that the created contract cannot be called immediately afterwards (that is, get_contract_opt on that address would return None()), as the origination must be performed successfully first, for example by calling a proxy contract or itself.

let set_delegate: (_: option<key_hash>) => operation

The call set_delegate(d) evaluates in an operation that sets the delegate of the current smart contract to be d, where d is an optional key hash. If None(), the delegation is withdrawn. If the contract has no delegation, then no change occurs. If d is Some(kh), where kh is the key hash of a registered delegate that is not the current delegate of the contract, then this operation sets the delegate of the contract to this registered delegate. A failure occurs if kh is the current delegate of the contract or if kh is not a registered delegate. However, the instruction in itself does not fail; it produces an operation that will fail when applied.

let transaction: <param>(_: param) => (_: tez) => (_: contract<param>) => operation

The call transaction(param, amount, contract_addr) evaluates in an operation that will send the amount amount in mutez to the contract at the valid address contract_addr, with parameter param. If the contract is an implicit account, the parameter must be unit.

let call_view: <param, return>(_: string) => (_: param) => (_: address) => option<return>

The call call_view(v, p, a) calls the view v with parameter param at the contract whose address is a. The value returned is None() if the view does not exist, or has a different type of parameter, or if the contract does not exist at that address. Otherwise, it is Some(v), where v is the return value of the view. Note: the storage of the view is the same as when the execution of the contract calling the view started.

let create_ticket: <a>(_: a) => (_: nat) => option<ticket<a>>

The call create_ticket(v, a) creates a ticket with value v and amount a. If the creation is a success, the value Some(t) is returned, where t is the ticket; otherwise, None() is the result. Note: Tickets cannot be duplicated.

let split_ticket: <a>(_: ticket<a>) => (_: [nat, nat]) => option<[ticket<a>, ticket<a>]>

The call split_ticket(t, [a1, a2]) results in a pair of tickets t1 and t2 such that the former owns the amount a1 and the later a2. More precisely, the value of the call is Some([t1, t2]) because signifying to the callee the failure of the splitting is achieved by returning the value None().

let join_tickets: <a>(_: [ticket<a>, ticket<a>]) => option<ticket<a>>

The call join_tickets(t1, t2) joins the tickets t1 and t2, which must have the same type of value.

let read_ticket: <a>(_: ticket<a>) => [[address, [a, nat]], ticket<a>]

The call read_ticket(t) returns t itself and the contents of t which is a pair [address, [value, amount]], where address is the address of the smart contract that created it.

let sapling_empty_state: <sap_t>sapling_state<sap_t>

The evaluation of the constant `sapling_empty_state` is an empty sapling state, that is, no one can spend tokens from it.

let sapling_verify_update: <sap_a>(_: sapling_transaction<sap_a>) => (_: sapling_state<sap_a>) => option<[bytes, [int, sapling_state<sap_a>]]>

The call sapling_verify_update(trans, state), where the transaction trans can be applied to the state state, returns Some ([data, [delta, new_state]]), where data is the bound data (as bytes), delta is the difference between the outputs and the inputs of the transaction, and new_state is the updated state.

let emit: <event_type>(_: string) => (_: event_type) => operation

The call emit event_tag(event_type) evaluates in an operation that will write an event into the transaction receipt after the successful execution of this contract. The event is annotated by the string event_tag if it is not empty. The argument event_type is used only to specify the type of data attachment.

let open_chest: (_: chest_key) => (_: chest) => (_: nat) => option<bytes>

The function [open_chest] opens a timelocked chest given its key and the time. The result is a byte option depending if the opening is correct or not.

let get_balance: (_: unit) => tez

The call get_balance() returns the balance in mutez of the account associated to the currently executed smart contract, including any mutez added by the calling transaction.

let get_amount: (_: unit) => tez

The call get_amount() returns the amount in mutez of the current transaction.

let get_now: (_: unit) => timestamp

The call get_now() returns the minimal injection time for the current block, namely the block whose application triggered this execution. The minimal injection time constitutes an estimate of the moment when the current block is injected, hence the name "now".

let get_min_block_time: (_: unit) => nat

The call get_min_block_time() returns the minimal delay between two consecutive blocks in the chain.

let get_level: (_: unit) => nat

The call get_level() returns the current block level.

let get_chain_id: (_: unit) => chain_id

The call get_chain_id () returns the identifier of the chain on which the smart contract is executed.

let get_total_voting_power: (_: unit) => nat

The call get_total_voting_power() returns the total voting power of all contracts. The total voting power coincides with the sum of the stake of every contract in the voting listings. The voting listings is calculated at the beginning of every voting period.

let voting_power: (_: key_hash) => nat

The call voting_power(contract_kh) returns the voting power of a given contract specified by the key hash contract_kh. This voting power coincides with the weight of the contract in the voting listings (that is, the stake) which is calculated at the beginning of every voting period.

let never: <a>(_: never) => a

The call never(n) is never meant to be executed, as the type never is inhabited, but to instruct the typechecker that a branch in the control flow, for example, in a pattern matching, is dead.

let pairing_check: (_: list<[bls12_381_g1, bls12_381_g2]>) => bool

The call pairing_check(pairings) verifies that the product of pairings of the given list of points pairings is equal to 1 in the field Fq12. It evaluates in true if the list is empty. This function can be used to verify if two pairings P1 and P2 are equal by verifying P1 * P2^(-1) = 1.

let constant: <a>(_: string) => a