Skip to main content

Operation

transfer

The transfer instruction generates an operation.

This operation is either a simple transfer operation of a part of the contract balance to an account or a contract, or a call to another contract's entrypoint.

Transfer balance

The following transfers an amount a of tez to address c:

transfer a to c

It fails if amount a is greater than the contract balance.

Call another contract

Consider a contract with address c that declares an entrypoint e with argument of type T as follows:

entry e(x : T) { /* ... */ }

The following calls entrypoint e with argument value x of type T:

transfer a to c call e<T>(x)

It fails if amount a is greater than the contract balance or if contract c does not have entrypoint e with corresponding signature.

For example, consider the following contract:

archetype called_contract

variable r : nat = 0

entry exec(x : nat, y : nat) {
r := r * x + y
}

Then the following transfer instruction calls the exec entrypoint:

transfer 0tz to c call exec<nat * nat>((4,5))

Note that the multiple arguments of exec is turned into a tuple of corresponding values.

Call current contract

It is possible to call another entrypoint e of the current contract with the follwing instruction:

transfer a to entry self.e(x)

For example, the following would call the exec entrypoint from another entrypoint of the same contract:

transfer 0tz to entry self.exec(4,5)

Low level instruction

The transfer instruction is pre-compiled to the low level instruction make_operation.

The following instruction:

transfer a to c call e<T>(x)

is equivalent to:

const e = get_entrypoint<T>("%e", c) ? the : fail("ENTRY_NOT_FOUND");
const o = make_operation(a, e, x);
operations := reverse(prepend(reverse(operations), o))

operations is the builtin list of operations returned by the entrypoint.

caution

Operations generated by the transfer instruction will be executed in the order transfer instructions appear in the code.

emit

The emit instruction emits an event of type T and value x:

emit<T>(x)

For example, consider the event declaration:

event HighestBidIncreased {
bidder : address;
amount : tez
}

Then the following emits the HighestBidIncreased event:

emit<HighestBidIncreased>({ source; transferred })

An operation to call the event well contract is then generated.

See this blog entry for further information.