--- id: current-reference title: Tezos description: General operations for Tezos hide_table_of_contents: true --- import Syntax from '@theme/Syntax'; import SyntaxTitle from '@theme/SyntaxTitle'; type timestamp type timestamp type timestamp A date in the real world. type tez type tez type tez 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 : tez val balance : tez let balance: tez Get the balance for the contract. ```pascaligo 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*. ```cameligo let main (p,s : unit * tez) = ([] : operation list), Tezos.balance ``` > Note that `balance` and `Current.balance` are *deprecated*. ```reasonligo 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](https://en.wikipedia.org/wiki/Unix_time). 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 ```pascaligo group=b 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`. ```cameligo group=b 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*. ```reasonligo group=b 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 ```pascaligo group=c 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`. ```cameligo group=c 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*. ```reasonligo group=c 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 ```pascaligo group=c const not_tommorow: bool = (Tezos.now = in_24_hrs) ``` > Note that `now` is *deprecated*. Please use `Tezos.now`. ```cameligo group=c let not_tomorrow: bool = (Tezos.now = in_24_hrs) ``` > Note that `Current.time` is *deprecated*. ```reasonligo group=c let not_tomorrow: bool = (Tezos.now == in_24_hrs); ``` > Note that `Current.time` is *deprecated*. function amount : tez val amount : tez let amount: tez Get the amount of tez provided by the sender to complete this transaction. ```pascaligo function threshold (const p : unit) : int is if Tezos.amount = 100tz then 42 else 0 ``` > Note that `amount` is *deprecated*. ```cameligo let threshold (p : unit) : int = if Tezos.amount = 100tz then 42 else 0 ``` > Note that `Current.amount` is *deprecated*. ```reasonligo 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. ```pascaligo function main (const p : unit) : address is Tezos.sender ``` > Note that `sender` is *deprecated*. Please use `Tezos.sender`. ```cameligo let main (p: unit) : address = Tezos.sender ``` > Note that `Current.sender` is *deprecated*. ```reasonligo 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`. ```pascaligo 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. ```cameligo 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*. ```reasonligo 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. ```pascaligo function main (const p : unit) : address is Tezos.self_address ``` > Note that `self_address` is *deprecated*. Please use `Tezos.self_address`. ```cameligo let main (p : unit) : address = Tezos.self_address ``` > Note that `Current.self_address` is *deprecated*. ```reasonligo 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" ```pascaligo function main (const p : unit) : contract(unit) is block { const c : contract(unit) = Tezos.self("%Default") ; } with c ``` ```cameligo let main (p : unit) : unit contract = (Tezos.self("%Default") : unit contract) ``` ```reasonligo 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 ```pascaligo function main (const kh: key_hash) : contract (unit) is Tezos.implicit_account (kh) ``` > Note that `implicit_account` is *deprecated*. Please use `Tezos.implicit_account`. ```cameligo let main (kh : key_hash) : unit contract = Tezos.implicit_account kh ``` > Note that `Current.implicit_account` is *deprecated*. ```reasonligo 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. ```pascaligo function main (const p: unit) : address is Tezos.source ``` > Note that `source` is *deprecated*. Please use `Tezos.source`. ```cameligo let main (p : unit) : address = Tezos.source ``` > Note that `Current.source` is *deprecated*. ```reasonligo 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. ```pascaligo 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) ``` ```cameligo let main (p,s : int * unit) = if p > 10 then failwith "Failure." ``` ```reasonligo 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`. ```pascaligo 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) ``` ```cameligo 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)) ``` ```reasonligo 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.