457 lines
8.9 KiB
Markdown
457 lines
8.9 KiB
Markdown
---
|
|
id: current-reference
|
|
title: Tezos - Things relating to the current execution context
|
|
---
|
|
|
|
import Syntax from '@theme/Syntax';
|
|
|
|
# Tezos.balance
|
|
|
|
Get the balance for the contract.
|
|
|
|
|
|
|
|
<Syntax syntax="pascaligo">
|
|
|
|
```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*.
|
|
|
|
</Syntax>
|
|
<Syntax syntax="cameligo">
|
|
|
|
```cameligo
|
|
let main (p,s : unit * tez) = ([] : operation list), Tezos.balance
|
|
```
|
|
|
|
> Note that `balance` and `Current.balance` are *deprecated*.
|
|
|
|
</Syntax>
|
|
<Syntax syntax="reasonligo">
|
|
|
|
```reasonligo
|
|
let main = ((p,s) : (unit, tez)) =>
|
|
([]: list (operation), Tezos.balance);
|
|
```
|
|
|
|
> Note that `balance` and `Current.balance` are *deprecated*.
|
|
|
|
</Syntax>
|
|
|
|
|
|
## Tezos.now
|
|
|
|
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
|
|
|
|
<Syntax syntax="pascaligo">
|
|
|
|
```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*.
|
|
|
|
</Syntax>
|
|
<Syntax syntax="cameligo">
|
|
|
|
```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*.
|
|
|
|
</Syntax>
|
|
<Syntax syntax="reasonligo">
|
|
|
|
```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*.
|
|
|
|
</Syntax>
|
|
|
|
|
|
#### 24 hours ago
|
|
|
|
|
|
<Syntax syntax="pascaligo">
|
|
|
|
```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*.
|
|
|
|
</Syntax>
|
|
<Syntax syntax="cameligo">
|
|
|
|
```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*.
|
|
|
|
</Syntax>
|
|
<Syntax syntax="reasonligo">
|
|
|
|
```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*.
|
|
|
|
</Syntax>
|
|
|
|
|
|
#### Comparing Timestamps
|
|
|
|
You can also compare timestamps using the same comparison operators as
|
|
for numbers
|
|
|
|
|
|
<Syntax syntax="pascaligo">
|
|
|
|
```pascaligo group=c
|
|
const not_tommorow: bool = (Tezos.now = in_24_hrs)
|
|
```
|
|
|
|
> Note that `now` is *deprecated*.
|
|
|
|
</Syntax>
|
|
<Syntax syntax="cameligo">
|
|
|
|
```cameligo group=c
|
|
let not_tomorrow: bool = (Tezos.now = in_24_hrs)
|
|
```
|
|
|
|
> Note that `Current.time` is *deprecated*.
|
|
|
|
</Syntax>
|
|
<Syntax syntax="reasonligo">
|
|
|
|
```reasonligo group=c
|
|
let not_tomorrow: bool = (Tezos.now == in_24_hrs);
|
|
```
|
|
|
|
> Note that `Current.time` is *deprecated*.
|
|
|
|
</Syntax>
|
|
|
|
|
|
|
|
## Amount
|
|
|
|
Get the amount of tez provided by the sender to complete this
|
|
transaction.
|
|
|
|
|
|
|
|
<Syntax syntax="pascaligo">
|
|
|
|
```pascaligo
|
|
function threshold (const p : unit) : int is
|
|
if Tezos.amount = 100tz then 42 else 0
|
|
```
|
|
|
|
> Note that `amount` is *deprecated*.
|
|
|
|
</Syntax>
|
|
<Syntax syntax="cameligo">
|
|
|
|
```cameligo
|
|
let threshold (p : unit) : int = if Tezos.amount = 100tz then 42 else 0
|
|
```
|
|
|
|
> Note that `Current.amount` is *deprecated*.
|
|
|
|
</Syntax>
|
|
<Syntax syntax="reasonligo">
|
|
|
|
```reasonligo
|
|
let threshold = (p : unit) : int =>
|
|
if (Tezos.amount == 100tz) { 42; } else { 0; };
|
|
```
|
|
|
|
> Note that `Current.amount` is *deprecated*.
|
|
|
|
</Syntax>
|
|
|
|
|
|
## Sender
|
|
|
|
Get the address that initiated the current transaction.
|
|
|
|
|
|
|
|
<Syntax syntax="pascaligo">
|
|
|
|
```pascaligo
|
|
function main (const p : unit) : address is Tezos.sender
|
|
```
|
|
|
|
> Note that `sender` is *deprecated*.
|
|
|
|
</Syntax>
|
|
<Syntax syntax="cameligo">
|
|
|
|
```cameligo
|
|
let main (p: unit) : address = Tezos.sender
|
|
```
|
|
|
|
> Note that `Current.sender` is *deprecated*.
|
|
|
|
</Syntax>
|
|
<Syntax syntax="reasonligo">
|
|
|
|
```reasonligo
|
|
let main = (p : unit) : address => Tezos.sender;
|
|
```
|
|
|
|
> Note that `Current.sender` is *deprecated*.
|
|
|
|
</Syntax>
|
|
|
|
|
|
|
|
## Address
|
|
|
|
Get the address associated with a value of type `contract`.
|
|
|
|
|
|
|
|
<Syntax syntax="pascaligo">
|
|
|
|
```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*.
|
|
|
|
</Syntax>
|
|
<Syntax syntax="cameligo">
|
|
|
|
```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*.
|
|
|
|
</Syntax>
|
|
<Syntax syntax="reasonligo">
|
|
|
|
```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*.
|
|
|
|
</Syntax>
|
|
|
|
|
|
## Self Address
|
|
|
|
Get the address of the currently running contract.
|
|
|
|
|
|
|
|
<Syntax syntax="pascaligo">
|
|
|
|
```pascaligo
|
|
function main (const p : unit) : address is Tezos.self_address
|
|
```
|
|
|
|
> Note that `self_address` is *deprecated*.
|
|
|
|
</Syntax>
|
|
<Syntax syntax="cameligo">
|
|
|
|
```cameligo
|
|
let main (p : unit) : address = Tezos.self_address
|
|
```
|
|
|
|
> Note that `Current.self_address` is *deprecated*.
|
|
|
|
</Syntax>
|
|
<Syntax syntax="reasonligo">
|
|
|
|
```reasonligo
|
|
let main = (p : unit) : address => Tezos.self_address;
|
|
```
|
|
|
|
> Note that `Current.self_address` is *deprecated*.
|
|
|
|
</Syntax>
|
|
|
|
|
|
## Implicit Account
|
|
|
|
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.
|
|
|
|
|
|
|
|
<Syntax syntax="pascaligo">
|
|
|
|
```pascaligo
|
|
function main (const kh: key_hash) : contract (unit) is
|
|
Tezos.implicit_account (kh)
|
|
```
|
|
|
|
> Note that `implicit_account` is *deprecated*.
|
|
|
|
</Syntax>
|
|
<Syntax syntax="cameligo">
|
|
|
|
```cameligo
|
|
let main (kh : key_hash) : unit contract = Tezos.implicit_account kh
|
|
```
|
|
|
|
> Note that `Current.implicit_account` is *deprecated*.
|
|
|
|
</Syntax>
|
|
<Syntax syntax="reasonligo">
|
|
|
|
```reasonligo
|
|
let main = (kh : key_hash): contract (unit) =>
|
|
Tezos.implicit_account (kh);
|
|
```
|
|
|
|
> Note that `Current.implicit_account` is *deprecated*.
|
|
|
|
</Syntax>
|
|
|
|
|
|
## Source
|
|
|
|
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.
|
|
|
|
|
|
|
|
<Syntax syntax="pascaligo">
|
|
|
|
```pascaligo
|
|
function main (const p: unit) : address is Tezos.source
|
|
```
|
|
|
|
> Note that `source` is *deprecated*.
|
|
|
|
</Syntax>
|
|
<Syntax syntax="cameligo">
|
|
|
|
```cameligo
|
|
let main (p : unit) : address = Tezos.source
|
|
```
|
|
|
|
> Note that `Current.source` is *deprecated*.
|
|
|
|
</Syntax>
|
|
<Syntax syntax="reasonligo">
|
|
|
|
```reasonligo
|
|
let main = (p : unit) : address => Tezos.source;
|
|
```
|
|
|
|
> Note that `Current.source` is *deprecated*.
|
|
|
|
</Syntax>
|
|
|
|
|
|
## Failwith
|
|
|
|
Cause the contract to fail with an error message.
|
|
|
|
> ⚠ Using this currently requires in general a type annotation on the
|
|
> `failwith` call.
|
|
|
|
|
|
|
|
<Syntax syntax="pascaligo">
|
|
|
|
```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)
|
|
```
|
|
|
|
</Syntax>
|
|
<Syntax syntax="cameligo">
|
|
|
|
```cameligo
|
|
let main (p,s : int * unit) = if p > 10 then failwith "Failure."
|
|
```
|
|
|
|
</Syntax>
|
|
<Syntax syntax="reasonligo">
|
|
|
|
```reasonligo
|
|
let main = ((p,s) : (int, unit)) =>
|
|
if (p > 10) { failwith ("Failure."); };
|
|
```
|
|
|
|
</Syntax>
|
|
|