ligo/gitlab-pages/docs/reference/current.md

id	title	description	hide_table_of_contents
current-reference	Tezos	General operations for Tezos	true

import Syntax from '@theme/Syntax'; import SyntaxTitle from '@theme/SyntaxTitle';

type timestamp type timestamp type timestamp

A date in the real world.

type mutez type mutez type mutez

A specific type for tokens.

type address type address type address

An untyped address which can refer to a smart contract or account.

type contract('parameter) type 'parameter contract type contract('parameter)

A typed contract.

Use unit as parameter to indicate an implicit account.

type operation type operation type operation

An operation emitted by the contract

type chain_id type chain_id type chain_id

The identifier of a chain, used to indicate test or main chains.

function balance : mutez val balance : mutez let balance: mutez

Get the balance for the contract.

function main (const p : unit; const s: tez) : list (operation) * tez is
  ((nil : list (operation)), Tezos.balance)

Note that balance and Current.balance are deprecated.

let main (p,s : unit * tez) = ([] : operation list), Tezos.balance

Note that balance and Current.balance are deprecated.

let main = ((p,s) : (unit, tez)) =>
  ([]: list (operation), Tezos.balance);

Note that balance and Current.balance are deprecated.

function now : timestamp val now : timestamp let now: timestamp

Returns the current time as a unix timestamp.

In LIGO, timestamps are type compatible in operations with integers. This lets you set for instance time constraints for your smart contracts like this:

Examples

24 hours from now

const today: timestamp = Tezos.now;
const one_day: int = 86_400;
const in_24_hrs: timestamp = today + one_day;
const some_date: timestamp = ("2000-01-01T10:10:10Z" : timestamp);
const one_day_later: timestamp = some_date + one_day;

Note that now is deprecated. Please use Tezos.now.

let today: timestamp = Tezos.now
let one_day: int = 86_400
let in_24_hrs: timestamp = today + one_day
let some_date: timestamp = ("2000-01-01t10:10:10Z" : timestamp)
let one_day_later: timestamp = some_date + one_day

Note that Current.time is deprecated.

let today: timestamp = Tezos.now;
let one_day: int = 86_400;
let in_24_hrs: timestamp = today + one_day;
let some_date: timestamp = ("2000-01-01t10:10:10Z" : timestamp);
let one_day_later: timestamp = some_date + one_day;

Note that Current.time is deprecated.

24 hours ago

const today: timestamp = Tezos.now;
const one_day: int = 86_400;
const in_24_hrs: timestamp = today - one_day;

Note that now is deprecated. Please use Tezos.now.

let today: timestamp = Tezos.now
let one_day: int = 86_400
let in_24_hrs: timestamp = today - one_day

Note that Current.time is deprecated.

let today: timestamp = Tezos.now;
let one_day: int = 86_400;
let in_24_hrs: timestamp = today - one_day;

Note that Current.time is deprecated.

Comparing Timestamps

You can also compare timestamps using the same comparison operators as for numbers

const not_tommorow: bool = (Tezos.now = in_24_hrs)

Note that now is deprecated. Please use Tezos.now.

let not_tomorrow: bool = (Tezos.now = in_24_hrs)

Note that Current.time is deprecated.

let not_tomorrow: bool = (Tezos.now == in_24_hrs);

Note that Current.time is deprecated.

function amount : mutez val amount : mutez let amount: mutez

Get the amount of tez provided by the sender to complete this transaction.

function threshold (const p : unit) : int is
  if Tezos.amount = 100tz then 42 else 0

Note that amount is deprecated.

let threshold (p : unit) : int = if Tezos.amount = 100tz then 42 else 0

Note that Current.amount is deprecated.

let threshold = (p : unit) : int =>
  if (Tezos.amount == 100tz) { 42; } else { 0; };

Note that Current.amount is deprecated.

function sender : address val sender : address let sender: address

Get the address that initiated the current transaction.

function main (const p : unit) : address is Tezos.sender

Note that sender is deprecated. Please use Tezos.sender.

let main (p: unit) : address = Tezos.sender

Note that Current.sender is deprecated.

let main = (p : unit) : address => Tezos.sender;

Note that Current.sender is deprecated.

function address : contract 'a -> address val address : 'a contract -> address let address: contract('a) => address

Get the address associated with a value of type contract.

function main (const p : key_hash) : address is block {
  const c : contract (unit) = Tezos.implicit_account (p)
} with Tezos.address(c)

Note that implicit_account and address are deprecated. Please use Tezos.implicit_account and Tezos.address instead.

let main (p : key_hash) =
  let c : unit contract = Tezos.implicit_account p
  in Tezos.address c

Note that Current.implicit_account and Current.address are deprecated.

let main = (p : key_hash) : address => {
  let c : contract (unit) = Tezos.implicit_account (p);
  Tezos.address (c);
};

Note that Current.implicit_account and Current.address are deprecated.

function self_address : address val self_address : address let self_address: address

Get the address of the currently running contract.

function main (const p : unit) : address is Tezos.self_address

Note that self_address is deprecated. Please use Tezos.self_address.

let main (p : unit) : address = Tezos.self_address

Note that Current.self_address is deprecated.

let main = (p : unit) : address => Tezos.self_address;

Note that Current.self_address is deprecated.

function self : string -> contract 'a val self : string -> 'a contract let self: string => contract('a)

Typecast the currently running contract with an entrypoint annotation. If your are using entrypoints: use "%bar" for constructor Bar If you are not using entrypoints: use "%default"

function main (const p : unit) : contract(unit) is block {
  const c : contract(unit) = Tezos.self("%Default") ;
} with c

let main (p : unit) : unit contract =
  (Tezos.self("%Default") : unit contract)

let main = (p: unit) : contract(unit) =>
  (Tezos.self("%Default") : contract(unit));

function implicit_account : key_hash -> contract 'a val implicit_account : key_hash -> 'a contract let implicit_account: key_hash => contract('a)

Get the default contract associated with an on-chain key-pair. This contract does not execute code, instead it exists to receive tokens on behalf of a key's owner.

See also: http://tezos.gitlab.io/user/glossary.html#implicit-account

function main (const kh: key_hash) : contract (unit) is
  Tezos.implicit_account (kh)

Note that implicit_account is deprecated. Please use Tezos.implicit_account.

let main (kh : key_hash) : unit contract = Tezos.implicit_account kh

Note that Current.implicit_account is deprecated.

let main = (kh : key_hash): contract (unit) =>
  Tezos.implicit_account (kh);

Note that Current.implicit_account is deprecated.

function source : address val source : address let source: address

Get the originator (address) of the current transaction. That is, if a chain of transactions led to the current execution get the address that began the chain. Not to be confused with Tezos.sender, which gives the address of the contract or user which directly caused the current transaction.

⚠️ There are a few caveats you should keep in mind before using Tezos.source over Tezos.sender:

1. Tezos.source will never be a contract, so if you want to allow contracts (multisigs etc) to operate your contract, you need to use Tezos.sender
2. https://vessenes.com/tx-origin-and-ethereum-oh-my/ -- in general it is somewhat unsafe to assume that Tezos.source understands everything that is going to happen in a transaction. If Tezos.source transfers to a malicious (or sufficiently attackable) contract, that contract might potentially transfer to yours, without Tezos.source's consent. So if you are using Tezos.source for authentication, you risk being confused. A good historical example of this is bakers paying out delegation rewards. Naive bakers did (and probably still do) just use tezos-client to transfer to whatever KT1 delegates they had, even if those KT1 were malicious scripts.

function main (const p: unit) : address is Tezos.source

Note that source is deprecated. Please use Tezos.source.

let main (p : unit) : address = Tezos.source

Note that Current.source is deprecated.

let main = (p : unit) : address => Tezos.source;

Note that Current.source is deprecated.

function failwith : string -> unit function failwith : string -> unit function failwith : string -> unit

Cause the contract to fail with an error message.

⚠ Using this currently requires in general a type annotation on the failwith call.

function main (const p : int; const s : unit) : list (operation) * unit is
  block {
    if p > 10 then failwith ("Failure.") else skip
  }
  with ((nil : list (operation)), s)

let main (p,s : int * unit) = if p > 10 then failwith "Failure."

let main = ((p,s) : (int, unit)) =>
  if (p > 10) { failwith ("Failure."); };

function chain_id : chain_id val chain_id : chain_id let chain_id: chain_id

Get the identifier of the chain to distinguish between main and test chains.

This is mainly intended to avoid replay attacks between the chains, and can currently only be used together with Bytes.pack and Bytes.unpack.

type storage is bytes

function main (const ignore : unit; const storage: storage) : 
  (list(operation) * storage) is block {
  const packed : bytes = Bytes.pack (Tezos.chain_id);
  if (storage =/= packed) then {
   failwith("wrong chain")
  } else
    skip;
} with ((nil: list(operation)), packed)

type storage = bytes

let main ((ignore, storage): (unit * storage)) =
  let packed = Bytes.pack Tezos.chain_id in
  if (storage <> packed) then
    (failwith "wrong chain" : (operation list * storage))
  else
    (([]: operation list), (packed: storage))

type storage = bytes;

let main = ((ignore, storage): (unit, storage)) => {
  let packed = Bytes.pack(Tezos.chain_id);
  if (storage != packed) {
    (failwith("wrong chain"): (list(operation), storage));
  } else {
    ([]: list(operation), packed);
  }
};

function transaction : 'parameter -> mutez -> contract('parameter) -> operation val transaction : 'parameter -> mutez -> 'parameter contract -> operation let transaction: 'parameter -> mutez -> contract('parameter) -> operation

Create a transaction to a contract or account.

To indicate an account, use unit as parameter.

function set_delegate : option(key_hash) -> operation val set_delegate : key_hash option -> operation let set_delegate: option(key_hash) => operation

Create a delegation.

See also: http://tezos.gitlab.io/user/glossary.html?highlight=delegate#delegate

function get_contract_opt : address -> option(contract('parameter)) val get_contract_opt : address -> 'parameter contract option let get_contract_opt : address => option(contract('parameter))

Get a contract from an address.

When no contract is found or the contract doesn't match the type,
None is returned.

function get_entrypoint_opt : string -> address -> option(contract('parameter)) function get_entrypoint_opt : string -> address -> 'parameter contract option function get_entrypoint_opt: (string, address) => option(contract('parameter))

Get a contract from an address and entrypoint.

Entrypoints are written in the form of: %entrypoint.

When no contract is found or the contract doesn't match the type,
None is returned.