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

---
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>