CHANGELOG update

Add Option.force_msg
Merge pull request #327 from aeternity/fix_doc
2021-07-15 20:43:11 +02:00 · 2021-07-15 20:41:38 +02:00 · 2021-07-13 20:40:49 +02:00 · 2021-07-13 20:01:54 +02:00 · 2021-07-06 17:31:35 +02:00 · 2021-07-05 10:33:26 +02:00
90 changed files with 2973 additions and 1009 deletions
@@ -8,6 +8,15 @@ executors:
    working_directory: ~/aesophia

 jobs:
+  verify_rebar_lock:
+    executor: aebuilder
+    steps:
+      - checkout
+      - run:
+          name: Ensure lock file is up-to-date
+          command: |
+            ./rebar3 upgrade
+            git diff --quiet -- rebar.lock || (echo "rebar.lock is not up-to-date" && exit 1)
  build:
    executor: aebuilder
    steps:
@@ -35,3 +44,10 @@ jobs:
            - _build/default/rebar3_20.3.8_plt
      - store_artifacts:
          path: _build/test/logs
+
+workflows:
+  version: 2
+  build_test:
+    jobs:
+      - build
+      - verify_rebar_lock
@@ -21,3 +21,4 @@ rebar3.crashdump
 aesophia
 .qcci
 current_counterexample.eqc
+test/contracts/test.aes
@@ -6,9 +6,108 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0

 ## [Unreleased]
 ### Added
+- `Option.force_msg`
 ### Changed
 ### Removed

+## [6.0.2] 2021-07-05
+### Changed
+- `List.from_to_step` now forbids non-positive step (this change does
+  *not* alter the behavior of the previously deployed contracts)
+- Fixed leaking state between contracts
+
+## [6.0.1] 2021-06-24
+### Changed
+- Fixed a bug in calldata encoding for contracts containing multiple contracts
+- Fixed a missing `include` in the `Frac` standard library
+
+## [6.0.0] 2021-05-26
+### Added
+- Child contracts
+- `Chain.clone`
+- `Chain.create`
+- `Chain.bytecode_hash`
+- Minor support for variadic functions
+- `void` type that represents an empty type
+- `Call.fee` builtin
+### Changed
+- Contract interfaces must be now invocated by `contract interface` keywords
+- `main` keyword to indicate the main contract in case there are child contracts around
+- `List.sum` and `List.product` no longer use `List.foldl`
+### Removed
+
+## [5.0.0] 2021-04-30
+### Added
+- A new and improved [`String` standard library](https://github.com/aeternity/aesophia/blob/master/docs/sophia_stdlib.md#string)
+  has been added. Use it by `include "String.aes"`. It includes functions for
+  turning strings into lists of characters for detailed manipulation. For
+  example:
+  ```
+  include "String.aes"
+  contract C =
+    entrypoint filter_all_a(s: string) : string =
+      String.from_list(List.filter((c : char) => c != 'a', String.to_list(s)))
+  ```
+  will return a list with all `a`'s removed.
+
+  There are also convenience functions `split`, `concat`, `to_upper`,
+  `to_lower`, etc.
+
+  All String functions in FATEv2 operate on unicode code points.
+- Operations for pairing-based cryptography has been added the operations
+  are in the standard library [BLS12_381](https://github.com/aeternity/aesophia/blob/master/docs/sophia_stdlib.md#bls12_381).
+  With these operations it is possible to do Zero Knowledge-proofs, etc.
+  The operations are for the BLS12-381 curve (as the name suggests).
+- Calls to functions in other contracts (i.e. _remote calls_) can now be
+  [`protected`](https://github.com/aeternity/aesophia/blob/master/docs/sophia.md#protected-contract-calls).
+  If a contract call fails for any reason (for instance, the remote contract
+  crashes or runs out of gas, or the entrypoint doesn't exist or has the
+  wrong type) the parent call also fails. To make it possible to recover
+  from failures, contract calls takes a named argument `protected : bool`
+  (default `false`).
+
+  If `protected = true` the result of the contract call is wrapped in an
+  `option`, and `Some(value)` indicates a succesful execution and `None`
+  indicates that the contract call failed. Note: any gas consumed until
+  the failure is still charged, but all side effects in the remote
+  contract are rolled back on failure.
+- A new chain operation [`AENS.update`](https://github.com/aeternity/aesophia/blob/master/docs/sophia.md#aens-interface)
+  is supported.
+- New chain exploring operations `AENS.lookup` and `Oracle.expiry` to
+  look up an AENS record and the expiry of an Oracle respectively, are added.
+- Transaction introspection (`Auth.tx`) has been added. When a Generalized
+  account is authorized, the authorization function needs access to the
+  transaction (and the transaction hash) for the wrapped transaction. The
+  transaction and the transaction hash is available `Auth.tx`, it is only
+  available during authentication if invoked by a normal contract call
+  it returns `None`. Example:
+  ```
+  switch(Auth.tx)
+    None      => abort("Not in Auth context")
+    Some(tx0) =>
+      switch(tx0.tx)
+        Chain.SpendTx(_, amount, _)  => amount > 400
+        Chain.ContractCallTx(_, _)   => true
+        _                            => false
+  ```
+- A debug mode is a added to the compiler. Right now its only use is to
+  turn off hermetization.
+### Changed
+- The function `Chain.block_hash(height)` is now (in FATEv2) defined for
+  the current height - this used to be an error.
+- Standard library: Sort is optimized to do `mergesort` and a `contains`
+  function is added.
+- Improved type errors and explicit errors for some syntax errors (empty code
+  blocks, etc.).
+- Compiler optimization: The ACI is generated alongside bytecode. This means
+  that multiple compiler passes can be avoided.
+- Compiler optimization: Improved parsing (less stack used when transpiled).
+- A bug where constraints were handled out of order fixed.
+- Fixed calldata decoding for singleton records.
+- Improved the documentation w.r.t. signatures, especially stressing the fact that
+  the network ID is a part of what is signed.
+### Removed
+
 ## [4.3.0]
 ### Added
 - Added documentation (moved from `protocol`)
@@ -211,7 +310,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Simplify calldata creation - instead of passing a compiled contract, simply
  pass a (stubbed) contract string.

-[Unreleased]: https://github.com/aeternity/aesophia/compare/v4.3.0...HEAD
+[Unreleased]: https://github.com/aeternity/aesophia/compare/v6.0.2...HEAD
+[6.0.2]: https://github.com/aeternity/aesophia/compare/v6.0.1...v6.0.2
+[6.0.1]: https://github.com/aeternity/aesophia/compare/v6.0.0...v6.0.1
+[6.0.0]: https://github.com/aeternity/aesophia/compare/v5.0.0...v6.0.0
+[5.0.0]: https://github.com/aeternity/aesophia/compare/v4.3.0...v5.0.0
 [4.3.0]: https://github.com/aeternity/aesophia/compare/v4.2.0...v4.3.0
 [4.2.0]: https://github.com/aeternity/aesophia/compare/v4.1.0...v4.2.0
 [4.1.0]: https://github.com/aeternity/aesophia/compare/v4.0.0...v4.1.0
@@ -15,11 +15,12 @@ The compiler is currently being used three places

 ## Versioning

-`aesophia` has a version that is only loosely connected to the version of the
-Aeternity node - in principle they will share the major version but not
-minor/patch version. The `aesophia` compiler version MUST be bumped whenever
-there is a change in how byte code is generated, but it MAY also be bumped upon
-API changes etc.
+Versioning should follow the [semantic versioning](https://semver.org/spec/v2.0.0) guidelines. Id est, given a version number MAJOR.MINOR.PATCH, increment the:
+
+- MAJOR version when you make incompatible API changes
+- MINOR version when you add functionality in a backwards compatible manner
+- PATCH version when you make backwards compatible bug fixes
+

 ## Interface Modules

@@ -1,60 +1,6 @@
 <!-- IMPORTANT: REMEMBER TO UPDATE THE TABLE OF CONTENTS AFTER YOUR EDIT -->

-**Table of Contents**
-
- [Language Features](#language-features)
-    - [Contracts](#contracts)
-        - [Calling other contracts](#calling-other-contracts)
-        - [Mutable state](#mutable-state)
-            - [Stateful functions](#stateful-functions)
-        - [Payable](#payable)
-            - [Payable contracts](#payable-contracts)
-            - [Payable entrypoints](#payable-entrypoints)
-        - [Namespaces](#namespaces)
-        - [Splitting code over multiple files](#splitting-code-over-multiple-files)
-        - [Standard library](#standard-library)
-        - [Types](#types)
-        - [Literals](#literals)
-        - [Arithmetic](#arithmetic)
-        - [Bit fields](#bit-fields)
-        - [Type aliases](#type-aliases)
-        - [Algebraic data types](#algebraic-data-types)
-        - [Lists](#lists)
-        - [Maps and records](#maps-and-records)
-            - [Constructing maps and records](#constructing-maps-and-records)
-            - [Accessing values](#accessing-values)
-            - [Updating a value](#updating-a-value)
-            - [Map implementation](#map-implementation)
-        - [Strings](#strings)
-        - [Byte arrays](#byte-arrays)
-        - [Cryptographic builins](#cryptographic-builins)
-            - [AEVM note](#aevm-note)
-        - [Authorization interface](#authorization-interface)
-        - [Oracle interface](#oracle-interface)
-            - [Example](#example)
-            - [Sanity checks](#sanity-checks)
-        - [AENS interface](#aens-interface)
-        - [Events](#events)
-            - [Argument order](#argument-order)
-        - [Compiler pragmas](#compiler-pragmas)
-        - [Exceptions](#exceptions)
-    - [Syntax](#syntax)
-        - [Lexical syntax](#lexical-syntax)
-            - [Comments](#comments)
-            - [Keywords](#keywords)
-            - [Tokens](#tokens)
-        - [Layout blocks](#layout-blocks)
-        - [Notation](#notation)
-        - [Declarations](#declarations)
-        - [Types](#types-1)
-        - [Statements](#statements)
-        - [Expressions](#expressions)
-        - [Operators types](#operators-types)
-        - [Operator precendences](#operator-precendences)
-    - [Examples](#examples)
-
-
-## The Sophia Language
+# The Sophia Language
 An Æternity BlockChain Language

 The Sophia is a language in the ML family. It is strongly typed and has
@@ -64,6 +10,65 @@ Sophia is customized for smart contracts, which can be published
 to a blockchain (the Æternity BlockChain). Thus some features of conventional
 languages, such as floating point arithmetic, are not present in Sophia, and
 some blockchain specific primitives, constructions and types have been added.
+
+**Table of Contents**
+
+  - [Language Features](#language-features)
+    - [Contracts](#contracts)
+      - [Calling other contracts](#calling-other-contracts)
+      - [Protected contract calls](#protected-contract-calls)
+      - [Contract factories and child contracts](#contract-factories-and-child-contracts)
+    - [Mutable state](#mutable-state)
+      - [Stateful functions](#stateful-functions)
+    - [Payable](#payable)
+      - [Payable contracts](#payable-contracts)
+      - [Payable entrypoints](#payable-entrypoints)
+    - [Namespaces](#namespaces)
+    - [Splitting code over multiple files](#splitting-code-over-multiple-files)
+    - [Standard library](#standard-library)
+    - [Types](#types)
+    - [Literals](#literals)
+    - [Arithmetic](#arithmetic)
+    - [Bit fields](#bit-fields)
+    - [Type aliases](#type-aliases)
+    - [Algebraic data types](#algebraic-data-types)
+    - [Lists](#lists)
+    - [Maps and records](#maps-and-records)
+      - [Constructing maps and records](#constructing-maps-and-records)
+      - [Accessing values](#accessing-values)
+      - [Updating a value](#updating-a-value)
+      - [Map implementation](#map-implementation)
+    - [Strings](#strings)
+    - [Chars](#chars)
+    - [Byte arrays](#byte-arrays)
+    - [Cryptographic builins](#cryptographic-builins)
+      - [AEVM note](#aevm-note)
+    - [Authorization interface](#authorization-interface)
+    - [Oracle interface](#oracle-interface)
+      - [Example](#example)
+      - [Sanity checks](#sanity-checks)
+    - [AENS interface](#aens-interface)
+      - [Example](#example)
+    - [Events](#events)
+      - [Argument order](#argument-order)
+    - [Compiler pragmas](#compiler-pragmas)
+    - [Exceptions](#exceptions)
+  - [Syntax](#syntax)
+    - [Lexical syntax](#lexical-syntax)
+      - [Comments](#comments)
+      - [Keywords](#keywords)
+      - [Tokens](#tokens)
+    - [Layout blocks](#layout-blocks)
+    - [Notation](#notation)
+    - [Declarations](#declarations)
+    - [Types](#types)
+    - [Statements](#statements)
+    - [Expressions](#expressions)
+    - [Operators types](#operators-types)
+    - [Operator precendences](#operator-precendences)
+  - [Examples](#examples)
+    - [Delegation signature](#delegation-signature)
+
 ## Language Features
 ### Contracts

@@ -89,16 +94,16 @@ To call a function in another contract you need the address to an instance of
 the contract. The type of the address must be a contract type, which consists
 of a number of type definitions and entrypoint declarations. For instance,

-```javascript
+```sophia
 // A contract type
-contract VotingType =
+contract interface VotingType =
  entrypoint vote : string => unit
 ```

 Now given contract address of type `VotingType` you can call the `vote`
 entrypoint of that contract:

-```javascript
+```sophia
 contract VoteTwice =
  entrypoint voteTwice(v : VotingType, alt : string) =
    v.vote(alt)
@@ -109,7 +114,7 @@ Contract calls take two optional named arguments `gas : int` and `value : int`
 that lets you set a gas limit and provide tokens to a contract call. If omitted
 the defaults are no gas limit and no tokens. Suppose there is a fee for voting:

-```javascript
+```sophia
  entrypoint voteTwice(v : VotingType, fee : int, alt : string) =
    v.vote(value = fee, alt)
    v.vote(value = fee, alt)
@@ -131,15 +136,77 @@ To recover the underlying `address` of a contract instance there is a field
 `address : address`. For instance, to send tokens to the voting contract (given that it is payable)
 without calling it you can write

-```javascript
+```sophia
  entrypoint pay(v : VotingType, amount : int) =
    Chain.spend(v.address, amount)
 ```

+#### Protected contract calls
+
+If a contract call fails for any reason (for instance, the remote contract
+crashes or runs out of gas, or the entrypoint doesn't exist or has the wrong
+type) the parent call also fails. To make it possible to recover from failures,
+contract calls takes a named argument `protected : bool` (default `false`).
+
+The protected argument must be a literal boolean, and when set to `true`
+changes the type of the contract call, wrapping the result in an `option` type.
+If the call fails the result is `None`, otherwise it's `Some(r)` where `r` is
+the return value of the call.
+
+```sophia
+contract interface VotingType =
+  entrypoint : vote : string => unit
+
+contract Voter =
+  entrypoint tryVote(v : VotingType, alt : string) =
+    switch(v.vote(alt, protected = true) : option(unit))
+      None    => "Voting failed"
+      Some(_) => "Voting successful"
+```
+
+Any gas that was consumed by the contract call before the failure stays
+consumed, which means that in order to protect against the remote contract
+running out of gas it is necessary to set a gas limit using the `gas` argument.
+However, note that errors that would normally consume all the gas in the
+transaction still only uses up the gas spent running the contract.
+
+
+#### Contract factories and child contracts
+
+Since the version 6.0.0 Sophia supports deploying contracts by other
+contracts. This can be done in two ways:
+
+- Contract cloning via [`Chain.clone`](sophia_stdlib.md#clone)
+- Direct deploy via [`Chain.create`](sophia_stdlib.md#create)
+
+These functions take variable number of arguments that must match the created
+contract's `init` function. Beside that they take some additional named
+arguments – please refer to their documentation for the details.
+
+While `Chain.clone` requires only a `contract interface` and a living instance
+of a given contract on the chain, `Chain.create` needs a full definition of a
+to-create contract defined by the standard `contract` syntax, for example
+
+```
+contract IntHolder =
+  type state = int
+  entrypoint init(x) = x
+  entrypoint get() = state
+  
+main contract IntHolderFactory =
+  stateful entrypoint new(x : int) : IntHolder =
+    let ih = Chain.create(x) : IntHolder
+    ih
+```
+
+In case of a presence of child contracts (`IntHolder` in this case), the main
+contract must be pointed out with the `main` keyword as shown in the example.
+
+
 ### Mutable state

-Sophia does not have arbitrary mutable state, but only a limited form of
-state associated with each contract instance.
+Sophia does not have arbitrary mutable state, but only a limited form of state
+associated with each contract instance.

 - Each contract defines a type `state` encapsulating its mutable state.
  The type `state` defaults to the `unit`.
@@ -165,7 +232,7 @@ Top-level functions and entrypoints must be annotated with the
 `stateful` keyword to be allowed to affect the state of the running contract.
 For instance,

-```javascript
+```sophia
  stateful entrypoint set_state(s : state) =
    put(s)
 ```
@@ -184,6 +251,7 @@ Without the `stateful` annotation the compiler does not allow the call to
  - `AENS.claim`
  - `AENS.transfer`
  - `AENS.revoke`
+  - `AENS.update`
 * Call a `stateful` function in the current contract
 * Call another contract with a non-zero `value` argument.

@@ -201,7 +269,7 @@ A concrete contract is by default *not* payable. Any attempt at spending to such
 a contract (either a `Chain.spend` or a normal spend transaction) will fail. If a
 contract shall be able to receive funds in this way it has to be declared `payable`:

-```javascript
+```sophia
 // A payable contract
 payable contract ExampleContract =
  stateful entrypoint do_stuff() = ...
@@ -217,7 +285,7 @@ A contract entrypoint is by default *not* payable. Any call to such a function
 that has a non-zero `value` will fail. Contract entrypoints that should be called
 with a non-zero value should be declared `payable`.

-```javascript
+```sophia
 payable stateful entrypoint buy(to : address) =
  if(Call.value > 42)
    transfer_item(to)
@@ -378,7 +446,7 @@ corresponding integer, so setting very high bits can be expensive).
 Type aliases can be introduced with the `type` keyword and can be
 parameterized. For instance

-```
+```sophia
 type number = int
 type string_map('a) = map(string, 'a)
 ```
@@ -398,7 +466,7 @@ datatype one_or_both('a, 'b) = Left('a) | Right('b) | Both('a, 'b)

 Elements of data types can be pattern matched against, using the `switch` construct:

-```
+```sophia
 function get_left(x : one_or_both('a, 'b)) : option('a) =
  switch(x)
    Left(x)    => Some(x)
@@ -407,7 +475,7 @@ function get_left(x : one_or_both('a, 'b)) : option('a) =
 ```

 or directly in the left-hand side:
-```
+```sophia
 function
  get_left : one_or_both('a, 'b) => option('a)
  get_left(Left(x))    = Some(x)
@@ -425,7 +493,7 @@ elements of a list can be any of datatype but they must have the same
 type. The type of lists with elements of type `'e` is written
 `list('e)`. For example we can have the following lists:

-```
+```sophia
 [1, 33, 2, 666]                                                   : list(int)
 [(1, "aaa"), (10, "jjj"), (666, "the beast")]                     : list(int * string)
 [{[1] = "aaa", [10] = "jjj"}, {[5] = "eee", [666] = "the beast"}] : list(map(int, string))
@@ -439,13 +507,13 @@ and returns the resulting list. So concatenating two lists

 Sophia supports list comprehensions known from languages like Python, Haskell or Erlang.
 Example syntax:
-```
+```sophia
 [x + y | x <- [1,2,3,4,5], let k = x*x, if (k > 5), y <- [k, k+1, k+2]]
 // yields [12,13,14,20,21,22,30,31,32]
 ```

 Lists can be constructed using the range syntax using special `..` operator:
-```
+```sophia
 [1..4] == [1,2,3,4]
 ```
 The ranges are always ascending and have step equal to 1.
@@ -457,7 +525,7 @@ Please refer to the [standard library](sophia_stdlib.md#List) for the predefined

 A Sophia record type is given by a fixed set of fields with associated,
 possibly different, types. For instance
-```
+```sophia
  record account = { name    : string,
                     balance : int,
                     history : list(transaction) }
@@ -474,12 +542,12 @@ Please refer to the [standard library](sophia_stdlib.md#Map) for the predefined

 A value of record type is constructed by giving a value for each of the fields.
 For the example above,
-```
+```sophia
  function new_account(name) =
    {name = name, balance = 0, history = []}
 ```
 Maps are constructed similarly, with keys enclosed in square brackets
-```
+```sophia
  function example_map() : map(string, int) =
    {["key1"] = 1, ["key2"] = 2}
 ```
@@ -488,7 +556,7 @@ The empty map is written `{}`.
 #### Accessing values

 Record fields access is written `r.f` and map lookup `m[k]`. For instance,
-```
+```sophia
  function get_balance(a : address, accounts : map(address, account)) =
    accounts[a].balance
 ```
@@ -513,14 +581,14 @@ in the map or execution fails, but a default value can be provided:
 `k` is not in the map.

 Updates can be nested:
-```
+```sophia
 function clear_history(a : address, accounts : map(address, account)) : map(address, account) =
  accounts{ [a].history = [] }
 ```
 This is equivalent to `accounts{ [a] @ acc = acc{ history = [] } }` and thus
 requires `a` to be present in the accounts map. To have `clear_history` create
 an account if `a` is not in the map you can write (given a function `empty_account`):
-```
+```sophia
  accounts{ [a = empty_account()].history = [] }
 ```

@@ -538,7 +606,16 @@ Strings can be compared for equality (`==`, `!=`), used as keys in maps and
 records, and used in builtin functions `String.length`, `String.concat` and
 the hash functions described below.

-Please refer to the `Map` [library documentation](sophia_stdlib.md#String).
+Please refer to the `String` [library documentation](sophia_stdlib.md#String).
+
+### Chars
+
+There is a builtin type `char` (the underlying representation being an integer),
+mainly used to manipulate strings via `String.to_list`/`String.from_list`.
+
+Characters can also be introduced as character literals (`'x', '+', ...).
+
+Please refer to the `Char` [library documentation](sophia_stdlib.md#Char).

 ### Byte arrays

@@ -565,11 +642,10 @@ string`, `String.sha3(s)` and `Crypto.sha3(s)` will give different results on AE
 ### Authorization interface

 When a Generalized account is authorized, the authorization function needs
-access to the transaction hash for the wrapped transaction. (A `GAMetaTx`
-wrapping a transaction.) The transaction hash is available in the primitive
-`Auth.tx_hash`, it is *only* available during authentication if invoked by a
-normal contract call it returns `None`.
-
+access to the transaction and the transaction hash for the wrapped transaction. (A `GAMetaTx`
+wrapping a transaction.) The transaction and the transaction hash is available in the primitive
+`Auth.tx` and `Auth.tx_hash` respectively, they are *only* available during authentication if invoked by a
+normal contract call they return `None`.

 ### Oracle interface
 You can attach an oracle to the current contract and you can interact with oracles
@@ -583,7 +659,7 @@ For a functionality documentation refer to the [standard library](sophia_stdlib.
 #### Example

 Example for an oracle answering questions of type `string` with answers of type `int`:
-```
+```sophia
 contract Oracles =

  stateful entrypoint registerOracle(acct : address,
@@ -645,6 +721,46 @@ Contracts can interact with the
 [Aeternity Naming System](https://github.com/aeternity/protocol/blob/master/AENS.md).
 For this purpose the [AENS](sophia_stdlib.md#AENS) library was exposed.

+#### Example
+
+In this example we assume that the name `name` already exists, and is owned by
+an account with address `addr`. In order to allow a contract `ct` to handle
+`name` the account holder needs to create a
+[signature](#delegation-signature) `sig` of `addr | name.hash | ct.address`.
+
+Armed with this information we can for example write a function that extends
+the name if it expires within 1000 blocks:
+```sophia
+  stateful entrypoint extend_if_necessary(addr : address, name : string, sig : signature) =
+    switch(AENS.lookup(name))
+      None => ()
+      Some(AENS.Name(_, FixedTTL(expiry), _)) =>
+        if(Chain.block_height + 1000 > expiry)
+          AENS.update(addr, name, Some(RelativeTTL(50000)), None, None, signature = sig)
+```
+
+And we can write functions that adds and removes keys from the pointers of the
+name:
+```sophia
+  stateful entrypoint add_key(addr : address, name : string, key : string,
+                              pt : AENS.pointee, sig : signature) =
+    switch(AENS.lookup(name))
+      None => ()
+      Some(AENS.Name(_, _, ptrs)) =>
+        AENS.update(addr, name, None, None, Some(ptrs{[key] = pt}), signature = sig)
+
+  stateful entrypoint delete_key(addr : address, name : string,
+                                 key : string, sig : signature) =
+    switch(AENS.lookup(name))
+      None => ()
+      Some(AENS.Name(_, _, ptrs)) =>
+        let ptrs = Map.delete(key, ptrs)
+        AENS.update(addr, name, None, None, Some(ptrs), signature = sig)
+```
+
+*Note:* From the Iris hardfork more strict rules apply for AENS pointers, when
+a Sophia contract lookup or update (bad) legacy pointers, the bad keys are
+automatically removed so they will not appear in the pointers map.

 ### Events

@@ -684,17 +800,17 @@ The fields can appear in any order.
 Events are emitted by using the `Chain.event` function. The following function
 will emit one Event of each kind in the example.

-```
+```sophia
  entrypoint emit_events() : () =
-    Chain.event(TheFirstEvent(42))
-    Chain.event(AnotherEvent(Contract.address, "This is not indexed"))
+    Chain.event(Event1(42, 34, "foo"))
+    Chain.event(Event2("This is not indexed", Contract.address))
 ```

 #### Argument order

 It is only possible to have one (1) `string` parameter in the event, but it can
 be placed in any position (and its value will end up in the `data` field), i.e.
-```
+```sophia
 AnotherEvent(string, indexed address)

 ...
@@ -753,7 +869,7 @@ and `*/` and can be nested.

 ```
 contract elif else entrypoint false function if import include let mod namespace
-private payable stateful switch true type record datatype
+private payable stateful switch true type record datatype main interface
 ```

 #### Tokens
@@ -857,7 +973,7 @@ Args ::= '(' Sep(Pattern, ',') ')'
 Contract declarations must appear at the top-level.

 For example,
-```
+```sophia
 contract Test =
  type t = int
  entrypoint add (x : t, y : t) = x + y
@@ -1005,7 +1121,7 @@ In order of highest to lowest precedence.

 ## Examples

-```
+```sophia
 /*
 * A simple crowd-funding example
 */
@@ -1069,3 +1185,11 @@ contract FundMe =
           amount    = state.contributions[to]})
    put(state{ contributions @ c = Map.delete(to, c) })
 ```
+
+### Delegation signature
+
+Some chain operations (`Oracle.<operation>` and `AENS.<operation>`) have an
+optional delegation signature. This is typically used when a user/accounts
+would like to allow a contract to act on it's behalf. The exact data to be
+signed varies for the different operations, but in all cases you should prepend
+the signature data with the `network_id` (`ae_mainnet` for the Aeternity mainnet, etc.).
@@ -0,0 +1,68 @@
+namespace BLS12_381 =
+  type fr    = MCL_BLS12_381.fr
+  type fp    = MCL_BLS12_381.fp
+  record fp2 = { x1 : fp, x2 : fp }
+  record g1  = { x : fp, y : fp, z : fp }
+  record g2  = { x : fp2, y : fp2, z : fp2 }
+  record gt  = { x1 : fp, x2 : fp, x3 : fp, x4 : fp, x5 : fp, x6 : fp,
+                 x7 : fp, x8 : fp, x9 : fp, x10 : fp, x11 : fp, x12 : fp }
+
+  function pairing_check(xs : list(g1), ys : list(g2)) =
+    switch((xs, ys))
+      ([], []) => true
+      (x :: xs, y :: ys) => pairing_check_(pairing(x, y), xs, ys)
+
+  function pairing_check_(acc : gt, xs : list(g1), ys : list(g2)) =
+    switch((xs, ys))
+      ([], []) => gt_is_one(acc)
+      (x :: xs, y :: ys) =>
+        pairing_check_(gt_mul(acc, pairing(x, y)), xs, ys)
+
+  function int_to_fr(x : int) = MCL_BLS12_381.int_to_fr(x)
+  function int_to_fp(x : int) = MCL_BLS12_381.int_to_fp(x)
+  function fr_to_int(x : fr)  = MCL_BLS12_381.fr_to_int(x)
+  function fp_to_int(x : fp)  = MCL_BLS12_381.fp_to_int(x)
+
+  function mk_g1(x : int, y : int, z : int) : g1 =
+    { x = int_to_fp(x), y = int_to_fp(y), z = int_to_fp(z) }
+
+  function mk_g2(x1 : int, x2 : int, y1 : int, y2 : int, z1 : int, z2 : int) : g2 =
+    { x = {x1 = int_to_fp(x1), x2 = int_to_fp(x2)},
+      y = {x1 = int_to_fp(y1), x2 = int_to_fp(y2)},
+      z = {x1 = int_to_fp(z1), x2 = int_to_fp(z2)} }
+
+  function pack_g1(t) = switch(t)
+                          (x, y, z) => {x = x, y = y, z = z} : g1
+  function pack_g2(t) = switch(t)
+                          ((x1, x2), (y1, y2), (z1, z2)) =>
+                            {x = {x1 = x1, x2 = x2}, y = {x1 = y1, x2 = y2}, z = {x1 = z1, x2 = z2}} : g2
+  function pack_gt(t) = switch(t)
+                          (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) =>
+                            {x1 = x1, x2 = x2, x3 = x3, x4 = x4, x5 = x5, x6 = x6,
+                             x7 = x7, x8 = x8, x9 = x9, x10 = x10, x11 = x11, x12 = x12} : gt
+
+  function g1_neg(p : g1)         = pack_g1(MCL_BLS12_381.g1_neg((p.x, p.y, p.z)))
+  function g1_norm(p : g1)        = pack_g1(MCL_BLS12_381.g1_norm((p.x, p.y, p.z)))
+  function g1_valid(p : g1)       = MCL_BLS12_381.g1_valid((p.x, p.y, p.z))
+  function g1_is_zero(p : g1)     = MCL_BLS12_381.g1_is_zero((p.x, p.y, p.z))
+  function g1_add(p : g1, q : g1) = pack_g1(MCL_BLS12_381.g1_add((p.x, p.y, p.z), (q.x, q.y, q.z)))
+  function g1_mul(k : fr, p : g1) = pack_g1(MCL_BLS12_381.g1_mul(k, (p.x, p.y, p.z)))
+
+  function g2_neg(p : g2)         = pack_g2(MCL_BLS12_381.g2_neg(((p.x.x1, p.x.x2), (p.y.x1, p.y.x2), (p.z.x1, p.z.x2))))
+  function g2_norm(p : g2)        = pack_g2(MCL_BLS12_381.g2_norm(((p.x.x1, p.x.x2), (p.y.x1, p.y.x2), (p.z.x1, p.z.x2))))
+  function g2_valid(p : g2)       = MCL_BLS12_381.g2_valid(((p.x.x1, p.x.x2), (p.y.x1, p.y.x2), (p.z.x1, p.z.x2)))
+  function g2_is_zero(p : g2)     = MCL_BLS12_381.g2_is_zero(((p.x.x1, p.x.x2), (p.y.x1, p.y.x2), (p.z.x1, p.z.x2)))
+  function g2_add(p : g2, q : g2) = pack_g2(MCL_BLS12_381.g2_add(((p.x.x1, p.x.x2), (p.y.x1, p.y.x2), (p.z.x1, p.z.x2)),
+                                                                 ((q.x.x1, q.x.x2), (q.y.x1, q.y.x2), (q.z.x1, q.z.x2))))
+  function g2_mul(k : fr, p : g2) = pack_g2(MCL_BLS12_381.g2_mul(k, ((p.x.x1, p.x.x2), (p.y.x1, p.y.x2), (p.z.x1, p.z.x2))))
+
+  function gt_inv(p : gt)              = pack_gt(MCL_BLS12_381.gt_inv((p.x1, p.x2, p.x3, p.x4, p.x5, p.x6, p.x7, p.x8, p.x9, p.x10, p.x11, p.x12)))
+  function gt_add(p : gt, q : gt)      = pack_gt(MCL_BLS12_381.gt_add((p.x1, p.x2, p.x3, p.x4, p.x5, p.x6, p.x7, p.x8, p.x9, p.x10, p.x11, p.x12),
+                                                                      (q.x1, q.x2, q.x3, q.x4, q.x5, q.x6, q.x7, q.x8, q.x9, q.x10, q.x11, q.x12)))
+  function gt_mul(p : gt, q : gt)      = pack_gt(MCL_BLS12_381.gt_mul((p.x1, p.x2, p.x3, p.x4, p.x5, p.x6, p.x7, p.x8, p.x9, p.x10, p.x11, p.x12),
+                                                                      (q.x1, q.x2, q.x3, q.x4, q.x5, q.x6, q.x7, q.x8, q.x9, q.x10, q.x11, q.x12)))
+  function gt_pow(p : gt, k : fr)      = pack_gt(MCL_BLS12_381.gt_pow((p.x1, p.x2, p.x3, p.x4, p.x5, p.x6, p.x7, p.x8, p.x9, p.x10, p.x11, p.x12), k))
+  function gt_is_one(p : gt)           = MCL_BLS12_381.gt_is_one((p.x1, p.x2, p.x3, p.x4, p.x5, p.x6, p.x7, p.x8, p.x9, p.x10, p.x11, p.x12))
+  function pairing(p : g1, q : g2)     = pack_gt(MCL_BLS12_381.pairing((p.x, p.y, p.z), ((q.x.x1, q.x.x2), (q.y.x1, q.y.x2), (q.z.x1, q.z.x2))))
+  function miller_loop(p : g1, q : g2) = pack_gt(MCL_BLS12_381.miller_loop((p.x, p.y, p.z), ((q.x.x1, q.x.x2), (q.y.x1, q.y.x2), (q.z.x1, q.z.x2))))
+  function final_exp(p : gt)           = pack_gt(MCL_BLS12_381.final_exp((p.x1, p.x2, p.x3, p.x4, p.x5, p.x6, p.x7, p.x8, p.x9, p.x10, p.x11, p.x12)))
@@ -1,3 +1,5 @@
+include "String.aes"
+
 namespace Frac =

  private function gcd(a : int, b : int) =
@@ -19,6 +19,16 @@ namespace List =
    [x]  => Some(x)
    _::t => last(t)

+  function drop_last(l : list('a)) : option(list('a)) = switch(l)
+    [] => None
+    _  => Some(drop_last_unsafe(l))
+
+  function drop_last_unsafe(l : list('a)) : list('a) = switch(l)
+    [_]  => []
+    h::t => h::drop_last_unsafe(t)
+    []   => abort("drop_last_unsafe: list empty")
+
+
  function contains(e : 'a, l : list('a)) = switch(l)
    []   => false
    h::t => h == e || contains(e, t)
@@ -32,14 +42,15 @@ namespace List =

 /** Returns list of all indices of elements from `l` that fulfill the predicate `p`.
 */
-  function find_indices(p : 'a => bool, l : list('a)) : list(int) = find_indices_(p, l, 0, [])
+  function find_indices(p : 'a => bool, l : list('a)) : list(int) = find_indices_(p, l, 0)
  private function find_indices_( p : 'a => bool
                                , l : list('a)
                                , n : int
-                                , acc : list(int)
                                ) : list(int) = switch(l)
-    []   => reverse(acc)
-    h::t => find_indices_(p, t, n+1, if(p(h)) n::acc else acc)
+    []   => []
+    h::t =>
+     let rest = find_indices_(p, t, n+1)
+     if(p(h)) n::rest else rest

  function nth(n : int, l : list('a)) : option('a) =
    switch(l)
@@ -68,44 +79,45 @@ namespace List =
 * `a` and `b` jumping by given `step`. Includes `a` and takes
 * `b` only if `(b - a) mod step == 0`. `step` should be bigger than 0.
 */
-  function from_to_step(a : int, b : int, s : int) : list(int) = from_to_step_(a, b, s, [])
-  private function from_to_step_(a, b, s, acc) =
-    if (a > b) reverse(acc) else from_to_step_(a + s, b, s, a :: acc)
+  function from_to_step(a : int, b : int, s : int) : list(int) =
+    require(s > 0, "List.from_to_step: non-positive step")
+    from_to_step_(a, b - (b-a) mod s, s, [])
+  private function from_to_step_(a : int, b : int, s : int, acc : list(int)) : list(int) =
+    if(b < a) acc
+    else from_to_step_(a, b - s, s, b::acc)


 /** Unsafe. Replaces `n`th element of `l` with `e`. Crashes on over/underflow
 */
  function replace_at(n : int, e : 'a, l : list('a)) : list('a) =
-    if(n<0) abort("insert_at underflow") else replace_at_(n, e, l, [])
-  private function replace_at_(n : int, e : 'a, l : list('a), acc : list('a)) : list('a) =
+    if(n<0) abort("insert_at underflow") else replace_at_(n, e, l)
+  private function replace_at_(n : int, e : 'a, l : list('a)) : list('a) =
   switch(l)
     []   => abort("replace_at overflow")
-     h::t => if (n == 0) reverse(e::acc) ++ t
-             else replace_at_(n-1, e, t, h::acc)
+     h::t => if (n == 0) e::t
+             else h::replace_at_(n-1, e, t)

 /** Unsafe. Adds `e` to `l` to be its `n`th element. Crashes on over/underflow
 */
  function insert_at(n : int, e : 'a, l : list('a)) : list('a) =
-    if(n<0) abort("insert_at underflow") else insert_at_(n, e, l, [])
-  private function insert_at_(n : int, e : 'a, l : list('a), acc : list('a)) : list('a) =
-   if (n == 0) reverse(e::acc) ++ l
+    if(n<0) abort("insert_at underflow") else insert_at_(n, e, l)
+  private function insert_at_(n : int, e : 'a, l : list('a)) : list('a) =
+   if (n == 0) e::l
   else switch(l)
     []   => abort("insert_at overflow")
-     h::t => insert_at_(n-1, e, t, h::acc)
+     h::t => h::insert_at_(n-1, e, t)

 /** Assuming that cmp represents `<` comparison, inserts `x` before
 * the first element in the list `l` which is greater than it
 */
  function insert_by(cmp : (('a, 'a) => bool), x : 'a, l : list('a)) : list('a) =
-    insert_by_(cmp, x, l, [])
-  private function insert_by_(cmp : (('a, 'a) => bool), x : 'a, l : list('a), acc : list('a)) : list('a) =
    switch(l)
-      []   => reverse(x::acc)
+      []   => [x]
      h::t =>
        if(cmp(x, h)) // x < h
-          reverse(acc) ++ (x::l)
+          x::l
        else
-          insert_by_(cmp, x, t, h::acc)
+          h::insert_by(cmp, x, t)


  function foldr(cons : ('a, 'b) => 'b, nil : 'b, l : list('a)) : 'b = switch(l)
@@ -123,49 +135,52 @@ namespace List =
       f(e)
       foreach(l', f)

-  function reverse(l : list('a)) : list('a) = foldl((lst, el) => el :: lst, [], l)
+  function reverse(l : list('a)) : list('a) = reverse_(l, [])
+  private function reverse_(l : list('a), acc : list('a)) : list('a) = switch(l)
+    [] => acc
+    h::t => reverse_(t, h::acc)

-  function map(f : 'a => 'b, l : list('a)) : list('b) = map_(f, l, [])
-  private function map_(f : 'a => 'b, l : list('a), acc : list('b)) : list('b) = switch(l)
-    []   => reverse(acc)
-    h::t => map_(f, t, f(h)::acc)
+  function map(f : 'a => 'b, l : list('a)) : list('b) = switch(l)
+    [] => []
+    h::t => f(h)::map(f, t)

 /** Effectively composition of `map` and `flatten`
 */
  function flat_map(f : 'a => list('b), l : list('a)) : list('b) =
    ListInternal.flat_map(f, l)

-  function filter(p : 'a => bool, l : list('a)) : list('a) = filter_(p, l, [])
-  private function filter_(p : 'a => bool, l : list('a), acc : list('a)) : list('a) = switch(l)
-    []   => reverse(acc)
-    h::t => filter_(p, t, if(p(h)) h::acc else acc)
+  function filter(p : 'a => bool, l : list('a)) : list('a) = switch(l)
+    []   => []
+    h::t =>
+      let rest = filter(p, t)
+      if(p(h)) h::rest else rest

-/** Take `n` first elements
+/** Take up to `n` first elements
 */
  function take(n : int, l : list('a)) : list('a) =
-    if(n < 0) abort("Take negative number of elements") else take_(n, l, [])
-  private function take_(n : int, l : list('a), acc : list('a)) : list('a) =
-    if(n == 0) reverse(acc)
+    if(n < 0) abort("Take negative number of elements") else take_(n, l)
+  private function take_(n : int, l : list('a)) : list('a) =
+    if(n == 0) []
    else switch(l)
-      []   => reverse(acc)
-      h::t => take_(n-1, t, h::acc)
+      []   => []
+      h::t => h::take_(n-1, t)

-/** Drop `n` first elements
+/** Drop up to `n` first elements
 */
  function drop(n : int, l : list('a)) : list('a) =
-   if(n < 0) abort("Drop negative number of elements")
-   elif (n == 0) l
+   if(n < 0) abort("Drop negative number of elements") else drop_(n, l)
+  private function drop_(n : int, l : list('a)) : list('a) =
+   if (n == 0) l
   else switch(l)
      []   => []
-      h::t => drop(n-1, t)
+      h::t => drop_(n-1, t)

 /** Get the longest prefix of a list in which every element
 * matches predicate `p`
 */
-  function take_while(p : 'a => bool, l : list('a)) : list('a) = take_while_(p, l, [])
-  private function take_while_(p : 'a => bool, l : list('a), acc : list('a)) : list('a) = switch(l)
-    []   => reverse(acc)
-    h::t => if(p(h)) take_while_(p, t, h::acc) else reverse(acc)
+  function take_while(p : 'a => bool, l : list('a)) : list('a) = switch(l)
+    []   => []
+    h::t => if(p(h)) h::take_while(p, t) else []

 /** Drop elements from `l` until `p` holds
 */
@@ -176,18 +191,15 @@ namespace List =
 /** Splits list into two lists of elements that respectively
 * match and don't match predicate `p`
 */
-  function partition(p : 'a => bool, l : list('a)) : (list('a) * list('a)) = partition_(p, l, [], [])
-  private function partition_( p : 'a => bool
-                             , l : list('a)
-                             , acc_t : list('a)
-                             , acc_f : list('a)
-                             ) : (list('a) * list('a)) = switch(l)
-    []   => (reverse(acc_t), reverse(acc_f))
-    h::t => if(p(h)) partition_(p, t, h::acc_t, acc_f) else partition_(p, t, acc_t, h::acc_f)
+  function partition(p : 'a => bool, l : list('a)) : (list('a) * list('a)) = switch(l)
+    []   => ([], [])
+    h::t =>
+      let (l, r) = partition(p, t)
+      if(p(h)) (h::l, r) else (l, h::r)

-/** Flattens list of lists into a single list
- */
-  function flatten(ll : list(list('a))) : list('a) = foldr((l1, l2) => l1 ++ l2, [], ll)
+  function flatten(l : list(list('a))) : list('a) = switch(l)
+    []   => []
+    h::t => h ++ flatten(t)

  function all(p : 'a => bool, l : list('a)) : bool = switch(l)
    []   => true
@@ -197,34 +209,34 @@ namespace List =
    []   => false
    h::t => if(p(h)) true else any(p, t)

-  function sum(l : list(int)) : int = foldl ((a, b) => a + b, 0, l)
-
-  function product(l : list(int)) : int = foldl((a, b) => a * b, 1, l)
+  function sum(l : list(int)) : int = switch(l)
+    []   => 0
+    h::t => h + sum(t)

+  function product(l : list(int)) : int = switch(l)
+    []   => 1
+    h::t => h * sum(t)

 /** Zips two list by applying bimapping function on respective elements.
- * Drops longer tail.
+ * Drops the tail of the longer list.
 */
-  function zip_with(f : ('a, 'b) => 'c, l1 : list('a), l2 : list('b)) : list('c) = zip_with_(f, l1, l2, [])
-  private function zip_with_( f : ('a, 'b) => 'c
+  private function zip_with( f : ('a, 'b) => 'c
                            , l1 : list('a)
                            , l2 : list('b)
-                            , acc : list('c)
                            ) : list('c) = switch ((l1, l2))
-    (h1::t1, h2::t2) => zip_with_(f, t1, t2, f(h1, h2)::acc)
-    _ => reverse(acc)
+    (h1::t1, h2::t2) => f(h1, h2)::zip_with(f, t1, t2)
+    _ => []

-/** Zips two lists into list of pairs. Drops longer tail.
+/** Zips two lists into list of pairs.
+ * Drops the tail of the longer list.
 */
  function zip(l1 : list('a), l2 : list('b)) : list('a * 'b) = zip_with((a, b) => (a, b), l1, l2)

-  function unzip(l : list('a * 'b)) : list('a) * list('b) = unzip_(l, [], [])
-  private function unzip_( l     : list('a * 'b)
-                         , acc_l : list('a)
-                         , acc_r : list('b)
-                         ) : (list('a) * list('b)) = switch(l)
-    []               => (reverse(acc_l), reverse(acc_r))
-    (left, right)::t => unzip_(t, left::acc_l, right::acc_r)
+  function unzip(l : list('a * 'b)) : (list('a) * list('b)) = switch(l)
+    []          => ([], [])
+    (h1, h2)::t =>
+      let (t1, t2) = unzip(t)
+      (h1::t1, h2::t2)


  /** Merges two sorted lists using `lt` comparator
@@ -291,17 +303,14 @@ namespace List =

 /** Puts `delim` between every two members of the list
 */
-  function intersperse(delim : 'a, l : list('a)) : list('a) = intersperse_(delim, l, [])
-  private function intersperse_(delim : 'a, l : list('a), acc : list('a)) : list('a) = switch(l)
-    []   => reverse(acc)
-    [e]  => reverse(e::acc)
-    h::t => intersperse_(delim, t, delim::h::acc)
-
+  function intersperse(delim : 'a, l : list('a)) : list('a) = switch(l)
+    []   => []
+    [e]  => [e]
+    h::t => h::delim::intersperse(delim, t)

 /** Effectively a zip with an infinite sequence of natural numbers
 */
-  function enumerate(l : list('a)) : list(int * 'a) = enumerate_(l, 0, [])
-  private function enumerate_(l : list('a), n : int, acc : list(int * 'a)) : list(int * 'a) = switch(l)
-    []   => reverse(acc)
-    h::t => enumerate_(t, n + 1, (n, h)::acc)
-
+  function enumerate(l : list('a)) : list(int * 'a) = enumerate_(l, 0)
+  private function enumerate_(l : list('a), n : int) : list(int * 'a) = switch(l)
+    []   => []
+    h::t => (n, h)::enumerate_(t, n + 1)
@@ -26,6 +26,12 @@ namespace Option =
    None    => abort("Forced None value")
    Some(x) => x

+/** Assume it is `Some` with custom error message
+ */
+  function force_msg(o : option('a), err : string) : 'a = switch(o)
+    None    => abort(err)
+    Some(x) => x
+
  function contains(e : 'a, o : option('a)) = o == Some(e)

  function on_elem(o : option('a), f : 'a => unit) : unit = match((), f, o)
@@ -69,20 +75,21 @@ namespace Option =
 /** Turns list of options into a list of elements that are under `Some`s.
 * Safe.
 */
-  function filter_options(l : list(option('a))) : list('a) = filter_options_(l, [])
-  private function filter_options_(l : list (option('a)), acc : list('a)) : list('a) = switch(l)
-    []         => List.reverse(acc)
-    None::t    => filter_options_(t, acc)
-    Some(x)::t => filter_options_(t, x::acc)
+  function filter_options(l : list(option('a))) : list('a) = switch(l)
+    []         => []
+    None::t    => filter_options(t)
+    Some(x)::t => x::filter_options(t)

 /** Just like `filter_options` but requires all elements to be `Some` and returns
 * None if any of them is not
 */
-  function seq_options(l : list (option('a))) : option (list('a)) = seq_options_(l, [])
-  private function seq_options_(l : list (option('a)), acc : list('a)) : option(list('a)) = switch(l)
-    []         => Some(List.reverse(acc))
-    None::t    => None
-    Some(x)::t => seq_options_(t, x::acc)
+  function seq_options(l : list (option('a))) : option (list('a)) = switch(l)
+    []         => Some([])
+    None::_    => None
+    Some(x)::t => switch(seq_options(t))
+      None => None
+      Some(st) => Some(x::st)
+

 /** Choose `Some` out of two if possible
 */
@@ -95,4 +102,3 @@ namespace Option =
    [] => None
    None::t    => choose_first(t)
    Some(x)::_ => Some(x)
-
@@ -0,0 +1,117 @@
+include "List.aes"
+namespace String =
+  // Computes the SHA3/Keccak hash of the string
+  function sha3(s : string) : hash    = StringInternal.sha3(s)
+  // Computes the SHA256 hash of the string.
+  function sha256(s : string) : hash  = StringInternal.sha256(s)
+  // Computes the Blake2B hash of the string.
+  function blake2b(s : string) : hash = StringInternal.blake2b(s)
+
+  // The length of a string - equivalent to List.lenght(to_list(s))
+  function length(s : string) : int = StringInternal.length(s)
+  // Concatenates `s1` and `s2`.
+  function concat(s1 : string, s2 : string) : string = StringInternal.concat(s1, s2)
+  // Concatenates a list of strings.
+  function
+    concats : (list(string)) => string
+    concats([])      = ""
+    concats(s :: ss) = List.foldl(StringInternal.concat, s, ss)
+
+  // Converts a `string` to a list of `char` - the code points are normalized, but
+  // composite characters are possibly converted to multiple `char`s.
+  function from_list(cs : list(char)) : string = StringInternal.from_list(cs)
+  // Converts a list of characters into a normalized UTF-8 string.
+  function to_list(s : string) : list(char) = StringInternal.to_list(s)
+
+  // Converts a string to lowercase.
+  function to_lower(s : string) = StringInternal.to_lower(s)
+  // Converts a string to uppercase.
+  function to_upper(s : string) = StringInternal.to_upper(s)
+
+  // Splits a string at (zero-based) index `ix`.
+  function split(i : int, s : string) : string * string =
+    let cs = StringInternal.to_list(s)
+    (StringInternal.from_list(List.take(i, cs)), StringInternal.from_list(List.drop(i, cs)))
+
+  // Returns the character/codepoint at (zero-based) index `ix`.
+  function at(ix : int, s : string) =
+    switch(List.drop(ix, StringInternal.to_list(s)))
+      []     => None
+      x :: _ => Some(x)
+
+  // Searches for `pat` in `str`, returning `Some(ix)` if `pat` is a substring
+  // of `str` starting at position `ix`, otherwise returns `None`.
+  function contains(str : string, substr : string) : option(int) =
+    if(substr == "") Some(0)
+    else
+      contains_(0, StringInternal.to_list(str), StringInternal.to_list(substr))
+
+  // Splits `s` into tokens, `pat` is the divider of tokens.
+  function tokens(s : string, pat : string) =
+    require(pat != "", "String.tokens: empty pattern")
+    tokens_(StringInternal.to_list(pat), StringInternal.to_list(s), [])
+
+  // Converts a decimal ("123", "-253") or a hexadecimal ("0xa2f", "-0xBBB") string
+  // into an integer. If the string doesn't contain a valid number `None` is returned.
+  function to_int(s : string) : option(int) =
+    let s = StringInternal.to_list(s)
+    switch(is_prefix(['-'], s))
+      None    => to_int_pos(s)
+      Some(s) => switch(to_int_pos(s))
+                   None => None
+                   Some(x) => Some(-x)
+
+  // Private helper functions below
+  private function to_int_pos(s : list(char)) =
+    switch(is_prefix(['0', 'x'], s))
+      None =>
+        to_int_(s, ch_to_int_10, 0, 10)
+      Some(s) =>
+        to_int_(s, ch_to_int_16, 0, 16)
+
+  private function
+    tokens_(_, [], acc) = [StringInternal.from_list(List.reverse(acc))]
+    tokens_(pat, str, acc) =
+      switch(is_prefix(pat, str))
+        Some(str') =>
+          StringInternal.from_list(List.reverse(acc)) :: tokens_(pat, str', [])
+        None =>
+          let c :: cs = str
+          tokens_(pat, cs, c :: acc)
+
+  private function
+    contains_(_, [], _) = None
+    contains_(ix, str, substr) =
+      switch(is_prefix(substr, str))
+        None =>
+          let _ :: str = str
+          contains_(ix + 1, str, substr)
+        Some(_) =>
+          Some(ix)
+
+  private function
+    is_prefix([], ys) = Some(ys)
+    is_prefix(_, [])  = None
+    is_prefix(x :: xs, y :: ys) =
+      if(x == y) is_prefix(xs, ys)
+      else       None
+
+  private function
+    to_int_([], _, x, _) = Some(x)
+    to_int_(i :: is, value, x, b) =
+      switch(value(i))
+        None => None
+        Some(i) => to_int_(is, value, x * b + i, b)
+
+  private function ch_to_int_10(c) =
+    let c = Char.to_int(c)
+    if(c >= 48 && c =< 57) Some(c - 48)
+    else None
+
+  private function ch_to_int_16(c) =
+    let c = Char.to_int(c)
+    if(c >= 48 && c =< 57)    Some(c - 48)
+    elif(c >= 65 && c =< 70)  Some(c - 55)
+    elif(c >= 97 && c =< 102) Some(c - 87)
+    else None
+
@@ -2,7 +2,7 @@

 {erl_opts, [debug_info]}.

-{deps, [ {aebytecode, {git, "https://github.com/aeternity/aebytecode.git", {ref,"4f4d6d3"}}}
+{deps, [ {aebytecode, {git, "https://github.com/aeternity/aebytecode.git", {ref,"05dfd7f"}}}
       , {getopt, "1.0.1"}
       , {eblake2, "1.0.0"}
       , {jsx, {git, "https://github.com/talentdeficit/jsx.git",
@@ -15,7 +15,7 @@
            {base_plt_apps, [erts, kernel, stdlib, crypto, mnesia]}
           ]}.

-{relx, [{release, {aesophia, "4.3.0"},
+{relx, [{release, {aesophia, "6.0.2"},
         [aesophia, aebytecode, getopt]},

        {dev_mode, true},
@@ -1,7 +1,7 @@
 {"1.1.0",
 [{<<"aebytecode">>,
  {git,"https://github.com/aeternity/aebytecode.git",
-       {ref,"4f4d6d30cd2c46b3830454d650a424d513f69134"}},
+       {ref,"05dfd7ffc7fb1e07ecc0b1e516da571f56d7dc8f"}},
  0},
 {<<"aeserialization">>,
  {git,"https://github.com/aeternity/aeserialization.git",
@@ -21,6 +21,8 @@
        , json_encode_expr/1
        , json_encode_type/1]).

+-include("aeso_utils.hrl").
+
 -type aci_type()  :: json | string.
 -type json()      :: jsx:json_term().
 -type json_text() :: binary().
@@ -68,9 +70,7 @@ do_contract_interface(Type, Contract, Options) when is_binary(Contract) ->
 do_contract_interface(Type, ContractString, Options) ->
    try
        Ast = aeso_compiler:parse(ContractString, Options),
-        %% io:format("~p\n", [Ast]),
        {TypedAst, _} = aeso_ast_infer_types:infer(Ast, [dont_unfold | Options]),
-        %% io:format("~p\n", [TypedAst]),
        from_typed_ast(Type, TypedAst)
    catch
        throw:{error, Errors} -> {error, Errors}
@@ -83,7 +83,7 @@ from_typed_ast(Type, TypedAst) ->
        string -> do_render_aci_json(JArray)
    end.

-encode_contract(Contract = {contract, _, {con, _, Name}, _}) ->
+encode_contract(Contract = {Head, _, {con, _, Name}, _}) when ?IS_CONTRACT_HEAD(Head) ->
    C0 = #{name => encode_name(Name)},

    Tdefs0 = [ encode_typedef(T) || T <- sort_decls(contract_types(Contract)) ],
@@ -107,7 +107,7 @@ encode_contract(Contract = {contract, _, {con, _, Name}, _}) ->
               || F <- sort_decls(contract_funcs(Contract)),
                  is_entrypoint(F) ],

-    #{contract => C3#{functions => Fdefs, payable => is_payable(Contract)}};
+    #{contract => C3#{kind => Head, functions => Fdefs, payable => is_payable(Contract)}};
 encode_contract(Namespace = {namespace, _, {con, _, Name}, _}) ->
    Tdefs = [ encode_typedef(T) || T <- sort_decls(contract_types(Namespace)) ],
    #{namespace => #{name => encode_name(Name),
@@ -232,13 +232,19 @@ do_render_aci_json(Json) ->
    {ok, list_to_binary(string:join(DecodedContracts, "\n"))}.

 decode_contract(#{contract := #{name := Name,
+                                kind := Kind,
                                payable := Payable,
                                type_defs := Ts0,
                                functions := Fs} = C}) ->
    MkTDef = fun(N, T) -> #{name => N, vars => [], typedef => T} end,
    Ts = [ MkTDef(<<"state">>, maps:get(state, C)) || maps:is_key(state, C) ] ++
         [ MkTDef(<<"event">>, maps:get(event, C)) || maps:is_key(event, C) ] ++ Ts0,
-    [payable(Payable), "contract ", io_lib:format("~s", [Name])," =\n",
+    [payable(Payable), case Kind of
+                           contract_main -> "main contract ";
+                           contract_child -> "contract ";
+                           contract_interface -> "contract interface "
+                       end,
+     io_lib:format("~s", [Name])," =\n",
     decode_tdefs(Ts), decode_funcs(Fs)];
 decode_contract(#{namespace := #{name := Name, type_defs := Ts}}) when Ts /= [] ->
    ["namespace ", io_lib:format("~s", [Name])," =\n",
@@ -332,10 +338,10 @@ payable(false) -> "".

 %% #contract{Ann, Con, [Declarations]}.

-contract_funcs({C, _, _, Decls}) when C == contract; C == namespace ->
+contract_funcs({C, _, _, Decls}) when ?IS_CONTRACT_HEAD(C); C == namespace ->
    [ D || D <- Decls, is_fun(D)].

-contract_types({C, _, _, Decls}) when C == contract; C == namespace ->
+contract_types({C, _, _, Decls}) when ?IS_CONTRACT_HEAD(C); C == namespace ->
    [ D || D <- Decls, is_type(D) ].

 is_fun({letfun, _, _, _, _, _}) -> true;
@@ -12,6 +12,8 @@
 -export([ast_to_fcode/2, format_fexpr/1]).
 -export_type([fcode/0, fexpr/0, fun_def/0]).

+-include("aeso_utils.hrl").
+
 %% -- Type definitions -------------------------------------------------------

 -type option() :: term().
@@ -36,7 +38,14 @@
              bits_intersection | bits_union | bits_difference |
              contract_to_address | address_to_contract | crypto_verify_sig | crypto_verify_sig_secp256k1 |
              crypto_sha3 | crypto_sha256 | crypto_blake2b |
-              crypto_ecverify_secp256k1 | crypto_ecrecover_secp256k1.
+              crypto_ecverify_secp256k1 | crypto_ecrecover_secp256k1 |
+              mcl_bls12_381_g1_neg | mcl_bls12_381_g1_norm | mcl_bls12_381_g1_valid |
+              mcl_bls12_381_g1_is_zero | mcl_bls12_381_g1_add | mcl_bls12_381_g1_mul |
+              mcl_bls12_381_g2_neg | mcl_bls12_381_g2_norm | mcl_bls12_381_g2_valid |
+              mcl_bls12_381_g2_is_zero | mcl_bls12_381_g2_add | mcl_bls12_381_g2_mul |
+              mcl_bls12_381_gt_inv | mcl_bls12_381_gt_add | mcl_bls12_381_gt_mul | mcl_bls12_381_gt_pow |
+              mcl_bls12_381_gt_is_one | mcl_bls12_381_pairing | mcl_bls12_381_miller_loop | mcl_bls12_381_final_exp |
+              mcl_bls12_381_int_to_fr | mcl_bls12_381_int_to_fp | mcl_bls12_381_fr_to_int | mcl_bls12_381_fp_to_int.

 -type flit() :: {int, integer()}
              | {string, binary()}
@@ -46,6 +55,7 @@
              | {oracle_pubkey, binary()}
              | {oracle_query_id, binary()}
              | {bool, false | true}
+              | {contract_code, string()} %% for CREATE, by name
              | {typerep, ftype()}.

 -type fexpr() :: {lit, flit()}
@@ -129,24 +139,27 @@
 -type type_env() :: #{ sophia_name() => type_def() }.
 -type fun_env()  :: #{ sophia_name() => {fun_name(), non_neg_integer()} }.
 -type con_env()  :: #{ sophia_name() => con_tag() }.
-type builtins() :: #{ sophia_name() => {builtin(), non_neg_integer() | none} }.
+-type child_con_env() :: #{sophia_name() => fcode()}.
+-type builtins() :: #{ sophia_name() => {builtin(), non_neg_integer() | none | variable} }.

-type context() :: {main_contract, string()}
+-type context() :: {contract_def, string()}
                 | {namespace, string()}
                 | {abstract_contract, string()}.

 -type state_layout() :: {tuple, [state_layout()]} | {reg, state_reg()}.

-type env() :: #{ type_env     := type_env(),
-                  fun_env      := fun_env(),
-                  con_env      := con_env(),
-                  event_type   => aeso_syntax:typedef(),
-                  builtins     := builtins(),
-                  options      := [option()],
-                  state_layout => state_layout(),
-                  context      => context(),
-                  vars         => [var_name()],
-                  functions    := #{ fun_name() => fun_def() } }.
+-type env() :: #{ type_env      := type_env(),
+                  fun_env       := fun_env(),
+                  con_env       := con_env(),
+                  child_con_env := child_con_env(),
+                  event_type    => aeso_syntax:typedef(),
+                  builtins      := builtins(),
+                  options       := [option()],
+                  state_layout  => state_layout(),
+                  context       => context(),
+                  vars          => [var_name()],
+                  functions     := #{ fun_name() => fun_def() }
+               }.

 -define(HASH_BYTES, 32).

@@ -154,33 +167,74 @@

 %% Main entrypoint. Takes typed syntax produced by aeso_ast_infer_types:infer/1,2
 %% and produces Fate intermediate code.
-spec ast_to_fcode(aeso_syntax:ast(), [option()]) -> fcode().
+-spec ast_to_fcode(aeso_syntax:ast(), [option()]) -> {env(), fcode()}.
 ast_to_fcode(Code, Options) ->
-    Verbose = lists:member(pp_fcode, Options),
    init_fresh_names(),
-    FCode1 = to_fcode(init_env(Options), Code),
+    {Env1, FCode1} = to_fcode(init_env(Options), Code),
+    FCode2 = optimize(FCode1, Options),
+    Env2 = Env1#{ child_con_env :=
+                      maps:map(
+                        fun (_, FC) -> optimize(FC, Options) end,
+                        maps:get(child_con_env, Env1)
+                       )},
+    clear_fresh_names(),
+    {Env2, FCode2}.
+
+optimize(FCode1, Options) ->
+    Verbose = lists:member(pp_fcode, Options),
    [io:format("-- Before lambda lifting --\n~s\n\n", [format_fcode(FCode1)]) || Verbose],
    FCode2 = optimize_fcode(FCode1),
    [ io:format("-- After optimization --\n~s\n\n", [format_fcode(FCode2)]) || Verbose, FCode2 /= FCode1 ],
    FCode3 = lambda_lift(FCode2),
    [ io:format("-- After lambda lifting --\n~s\n\n", [format_fcode(FCode3)]) || Verbose, FCode3 /= FCode2 ],
-    clear_fresh_names(),
    FCode3.

 %% -- Environment ------------------------------------------------------------

 -spec init_env([option()]) -> env().
 init_env(Options) ->
+    ChainTxArities = [3, 0, 0, 0, 0, 0, 1, 1, 1, 2, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1, 2, 0],
    #{ type_env  => init_type_env(),
       fun_env   => #{},
       builtins  => builtins(),
+       child_con_env => #{},
       con_env   => #{["None"]        => #con_tag{ tag = 0, arities = [0, 1] },
                      ["Some"]        => #con_tag{ tag = 1, arities = [0, 1] },
                      ["RelativeTTL"] => #con_tag{ tag = 0, arities = [1, 1] },
-                      ["FixedTTL"]    => #con_tag{ tag = 1, arities = [1, 1] }
+                      ["FixedTTL"]    => #con_tag{ tag = 1, arities = [1, 1] },
+                      ["AENS", "AccountPt"]  => #con_tag{ tag = 0, arities = [1, 1, 1, 1] },
+                      ["AENS", "OraclePt"]   => #con_tag{ tag = 1, arities = [1, 1, 1, 1] },
+                      ["AENS", "ContractPt"] => #con_tag{ tag = 2, arities = [1, 1, 1, 1] },
+                      ["AENS", "ChannelPt"]  => #con_tag{ tag = 3, arities = [1, 1, 1, 1] },
+                      ["AENS", "Name"]       => #con_tag{ tag = 0, arities = [3] },
+                      ["Chain", "GAMetaTx"]               => #con_tag{ tag = 0, arities = [2] },
+                      ["Chain", "PayingForTx"]            => #con_tag{ tag = 0, arities = [2] },
+                      ["Chain", "SpendTx"]                => #con_tag{ tag = 0, arities = ChainTxArities },
+                      ["Chain", "OracleRegisterTx"]       => #con_tag{ tag = 1, arities = ChainTxArities },
+                      ["Chain", "OracleQueryTx"]          => #con_tag{ tag = 2, arities = ChainTxArities },
+                      ["Chain", "OracleResponseTx"]       => #con_tag{ tag = 3, arities = ChainTxArities },
+                      ["Chain", "OracleExtendTx"]         => #con_tag{ tag = 4, arities = ChainTxArities },
+                      ["Chain", "NamePreclaimTx"]         => #con_tag{ tag = 5, arities = ChainTxArities },
+                      ["Chain", "NameClaimTx"]            => #con_tag{ tag = 6, arities = ChainTxArities },
+                      ["Chain", "NameUpdateTx"]           => #con_tag{ tag = 7, arities = ChainTxArities },
+                      ["Chain", "NameRevokeTx"]           => #con_tag{ tag = 8, arities = ChainTxArities },
+                      ["Chain", "NameTransferTx"]         => #con_tag{ tag = 9, arities = ChainTxArities },
+                      ["Chain", "ChannelCreateTx"]        => #con_tag{ tag = 10, arities = ChainTxArities },
+                      ["Chain", "ChannelDepositTx"]       => #con_tag{ tag = 11, arities = ChainTxArities },
+                      ["Chain", "ChannelWithdrawTx"]      => #con_tag{ tag = 12, arities = ChainTxArities },
+                      ["Chain", "ChannelForceProgressTx"] => #con_tag{ tag = 13, arities = ChainTxArities },
+                      ["Chain", "ChannelCloseMutualTx"]   => #con_tag{ tag = 14, arities = ChainTxArities },
+                      ["Chain", "ChannelCloseSoloTx"]     => #con_tag{ tag = 15, arities = ChainTxArities },
+                      ["Chain", "ChannelSlashTx"]         => #con_tag{ tag = 16, arities = ChainTxArities },
+                      ["Chain", "ChannelSettleTx"]        => #con_tag{ tag = 17, arities = ChainTxArities },
+                      ["Chain", "ChannelSnapshotSoloTx"]  => #con_tag{ tag = 18, arities = ChainTxArities },
+                      ["Chain", "ContractCreateTx"]       => #con_tag{ tag = 19, arities = ChainTxArities },
+                      ["Chain", "ContractCallTx"]         => #con_tag{ tag = 20, arities = ChainTxArities },
+                      ["Chain", "GAAttachTx"]             => #con_tag{ tag = 21, arities = ChainTxArities }
                     },
       options   => Options,
-       functions => #{} }.
+       functions => #{}
+    }.

 -spec builtins() -> builtins().
 builtins() ->
@@ -190,22 +244,29 @@ builtins() ->
    Scopes = [{[],           [{"abort", 1}, {"require", 2}]},
              {["Chain"],    [{"spend", 2}, {"balance", 1}, {"block_hash", 1}, {"coinbase", none},
                              {"timestamp", none}, {"block_height", none}, {"difficulty", none},
-                              {"gas_limit", none}]},
+                              {"gas_limit", none}, {"bytecode_hash", 1}, {"create", variable}, {"clone", variable}]},
              {["Contract"], [{"address", none}, {"balance", none}, {"creator", none}]},
-              {["Call"],     [{"origin", none}, {"caller", none}, {"value", none}, {"gas_price", none},
+              {["Call"],     [{"origin", none}, {"caller", none}, {"value", none}, {"gas_price", none}, {"fee", none},
                              {"gas_left", 0}]},
-              {["Oracle"],   [{"register", 4}, {"query_fee", 1}, {"query", 5}, {"get_question", 2},
+              {["Oracle"],   [{"register", 4}, {"expiry", 1}, {"query_fee", 1}, {"query", 5}, {"get_question", 2},
                              {"respond", 4}, {"extend", 3}, {"get_answer", 2},
                              {"check", 1}, {"check_query", 2}]},
              {["AENS"],     [{"resolve", 2}, {"preclaim", 3}, {"claim", 5}, {"transfer", 4},
-                              {"revoke", 3}]},
+                              {"revoke", 3}, {"update", 6}, {"lookup", 1}]},
              {["Map"],      [{"from_list", 1}, {"to_list", 1}, {"lookup", 2},
                              {"lookup_default", 3}, {"delete", 2}, {"member", 2}, {"size", 1}]},
              {["Crypto"],   [{"verify_sig", 3}, {"verify_sig_secp256k1", 3},
                              {"ecverify_secp256k1", 3}, {"ecrecover_secp256k1", 2},
                              {"sha3", 1}, {"sha256", 1}, {"blake2b", 1}]},
-              {["Auth"],     [{"tx_hash", none}]},
-              {["String"],   [{"length", 1}, {"concat", 2}, {"sha3", 1}, {"sha256", 1}, {"blake2b", 1}]},
+              {["MCL_BLS12_381"], [{"g1_neg", 1}, {"g1_norm", 1}, {"g1_valid", 1}, {"g1_is_zero", 1}, {"g1_add", 2}, {"g1_mul", 2},
+                                   {"g2_neg", 1}, {"g2_norm", 1}, {"g2_valid", 1}, {"g2_is_zero", 1}, {"g2_add", 2}, {"g2_mul", 2},
+                                   {"gt_inv", 1}, {"gt_add", 2}, {"gt_mul", 2}, {"gt_pow", 2}, {"gt_is_one", 1},
+                                   {"pairing", 2}, {"miller_loop", 2}, {"final_exp", 1},
+                                   {"int_to_fr", 1}, {"int_to_fp", 1}, {"fr_to_int", 1}, {"fp_to_int", 1}]},
+              {["StringInternal"], [{"length", 1}, {"concat", 2}, {"to_list", 1}, {"from_list", 1},
+                                    {"sha3", 1}, {"sha256", 1}, {"blake2b", 1}, {"to_lower", 1}, {"to_upper", 1}]},
+              {["Char"],     [{"to_int", 1}, {"from_int", 1}]},
+              {["Auth"],     [{"tx_hash", none}, {"tx", none}]},
              {["Bits"],     [{"set", 2}, {"clear", 2}, {"test", 2}, {"sum", 1}, {"intersection", 2},
                              {"union", 2}, {"difference", 2}, {"none", none}, {"all", none}]},
              {["Bytes"],    [{"to_int", 1}, {"to_str", 1}, {"concat", 2}, {"split", 1}]},
@@ -224,20 +285,32 @@ state_layout(Env) -> maps:get(state_layout, Env, {reg, 1}).

 -spec init_type_env() -> type_env().
 init_type_env() ->
-    #{ ["int"]          => ?type(integer),
-       ["bool"]         => ?type(boolean),
-       ["bits"]         => ?type(bits),
-       ["char"]         => ?type(integer),
-       ["string"]       => ?type(string),
-       ["address"]      => ?type(address),
-       ["hash"]         => ?type(hash),
-       ["signature"]    => ?type(signature),
-       ["oracle"]       => ?type(Q, R, {oracle, Q, R}),
-       ["oracle_query"] => ?type(_, _, oracle_query),
-       ["list"]         => ?type(T, {list, T}),
-       ["map"]          => ?type(K, V, {map, K, V}),
-       ["option"]       => ?type(T, {variant, [[], [T]]}),
-       ["Chain", "ttl"] => ?type({variant, [[integer], [integer]]})
+    BaseTx = {variant, [[address, integer, string], [], [], [], [], [], [string],
+                        [hash], [hash], [address, hash], [address],
+                        [address, integer], [address, integer], [address],
+                        [address], [address], [address], [address], [address],
+                        [integer], [address, integer], []]},
+    #{ ["int"]             => ?type(integer),
+       ["bool"]            => ?type(boolean),
+       ["bits"]            => ?type(bits),
+       ["char"]            => ?type(integer),
+       ["string"]          => ?type(string),
+       ["address"]         => ?type(address),
+       ["hash"]            => ?type(hash),
+       ["signature"]       => ?type(signature),
+       ["oracle"]          => ?type(Q, R, {oracle, Q, R}),
+       ["oracle_query"]    => ?type(_, _, oracle_query),    %% TODO: not in Fate
+       ["list"]            => ?type(T, {list, T}),
+       ["map"]             => ?type(K, V, {map, K, V}),
+       ["option"]          => ?type(T, {variant, [[], [T]]}),
+       ["Chain", "ttl"]    => ?type({variant, [[integer], [integer]]}),
+       ["AENS", "pointee"] => ?type({variant, [[address], [address], [address], [address]]}),
+       ["AENS", "name"]    => ?type({variant, [[address, {variant, [[integer], [integer]]}, {map, string, {variant, [[address], [address], [address], [address]]}}]]}),
+       ["Chain", "ga_meta_tx"]    => ?type({variant, [[address, integer]]}),
+       ["Chain", "paying_for_tx"] => ?type({variant, [[address, integer]]}),
+       ["Chain", "base_tx"]       => ?type(BaseTx),
+       ["MCL_BLS12_381", "fr"]  => ?type({bytes, 32}),
+       ["MCL_BLS12_381", "fp"]  => ?type({bytes, 48})
     }.

 is_no_code(Env) ->
@@ -251,31 +324,45 @@ get_option(Opt, Env, Default) ->

 %% -- Compilation ------------------------------------------------------------

-spec to_fcode(env(), aeso_syntax:ast()) -> fcode().
-to_fcode(Env, [{contract, Attrs, MainCon = {con, _, Main}, Decls}]) ->
-    #{ builtins := Builtins } = Env,
-    MainEnv = Env#{ context  => {main_contract, Main},
-                    builtins => Builtins#{[Main, "state"]          => {get_state, none},
-                                          [Main, "put"]            => {set_state, 1},
-                                          [Main, "Chain", "event"] => {chain_event, 1}} },
-    #{ functions := Funs } = Env1 =
-        decls_to_fcode(MainEnv, Decls),
-    StateType   = lookup_type(Env1, [Main, "state"], [], {tuple, []}),
-    EventType   = lookup_type(Env1, [Main, "event"], [], none),
-    StateLayout = state_layout(Env1),
-    Payable     = proplists:get_value(payable, Attrs, false),
-    #{ contract_name => Main,
-       state_type    => StateType,
-       state_layout  => StateLayout,
-       event_type    => EventType,
-       payable       => Payable,
-       functions     => add_init_function(Env1, MainCon, StateType,
-                        add_event_function(Env1, EventType, Funs)) };
-to_fcode(_Env, [NotContract]) ->
-    fcode_error({last_declaration_must_be_contract, NotContract});
-to_fcode(Env, [{contract, _, {con, _, Con}, Decls} | Code]) ->
-    Env1 = decls_to_fcode(Env#{ context => {abstract_contract, Con} }, Decls),
-    to_fcode(Env1, Code);
+-spec to_fcode(env(), aeso_syntax:ast()) -> {env(), fcode()}.
+to_fcode(Env, [{Contract, Attrs, Con = {con, _, Name}, Decls}|Rest])
+  when ?IS_CONTRACT_HEAD(Contract) ->
+    case Contract =:= contract_interface of
+        false ->
+            #{ builtins := Builtins } = Env,
+            ConEnv = maps:remove(state_layout,
+                     Env#{ context  => {contract_def, Name},
+                           builtins => Builtins#{[Name, "state"]          => {get_state, none},
+                                                 [Name, "put"]            => {set_state, 1},
+                                                 [Name, "Chain", "event"] => {chain_event, 1}} }),
+            #{ functions := PrevFuns } = ConEnv,
+            #{ functions := Funs } = Env1 =
+                decls_to_fcode(ConEnv, Decls),
+            StateType   = lookup_type(Env1, [Name, "state"], [], {tuple, []}),
+            EventType   = lookup_type(Env1, [Name, "event"], [], none),
+            StateLayout = state_layout(Env1),
+            Payable     = proplists:get_value(payable, Attrs, false),
+            ConFcode = #{ contract_name => Name,
+                          state_type    => StateType,
+                          state_layout  => StateLayout,
+                          event_type    => EventType,
+                          payable       => Payable,
+                          functions     => add_init_function(
+                                             Env1, Con, StateType,
+                                             add_event_function(Env1, EventType, Funs)) },
+            case Contract of
+                contract_main -> [] = Rest, {Env1, ConFcode};
+                contract_child ->
+                    Env2 = add_child_con(Env1, Name, ConFcode),
+                    Env3 = Env2#{ functions := PrevFuns },
+                    to_fcode(Env3, Rest)
+            end;
+        true ->
+            Env1 = decls_to_fcode(Env#{ context => {abstract_contract, Name} }, Decls),
+            to_fcode(Env1, Rest)
+    end;
+to_fcode(_Env, [NotMain = {NotMainHead, _ ,_ , _}]) when NotMainHead =/= contract_def ->
+    fcode_error({last_declaration_must_be_contract_def, NotMain});
 to_fcode(Env, [{namespace, _, {con, _, Con}, Decls} | Code]) ->
    Env1 = decls_to_fcode(Env#{ context => {namespace, Con} }, Decls),
    to_fcode(Env1, Code).
@@ -285,13 +372,11 @@ decls_to_fcode(Env, Decls) ->
    %% First compute mapping from Sophia names to fun_names and add it to the
    %% environment.
    Env1 = add_fun_env(Env, Decls),
-    lists:foldl(fun(D, E) ->
-                    R = decl_to_fcode(E, D),
-                    R
+    lists:foldl(fun(D, E) -> decl_to_fcode(E, D)
                end, Env1, Decls).

 -spec decl_to_fcode(env(), aeso_syntax:decl()) -> env().
-decl_to_fcode(Env = #{context := {main_contract, _}}, {fun_decl, _, Id, _}) ->
+decl_to_fcode(Env = #{context := {contract_def, _}}, {fun_decl, _, Id, _}) ->
    case is_no_code(Env) of
        false -> fcode_error({missing_definition, Id});
        true  -> Env
@@ -354,7 +439,7 @@ typedef_to_fcode(Env, Id = {id, _, Name}, Xs, Def) ->
    Env3 = compute_state_layout(Env2, Name, FDef),
    bind_type(Env3, Q, FDef).

-compute_state_layout(Env = #{ context := {main_contract, _} }, "state", Type) ->
+compute_state_layout(Env = #{ context := {contract_def, _} }, "state", Type) ->
    NoLayout = get_option(no_flatten_state, Env),
    Layout =
        case Type([]) of
@@ -380,7 +465,7 @@ compute_state_layout(R, [H | T]) ->
 compute_state_layout(R, _) ->
    {R + 1, {reg, R}}.

-check_state_and_event_types(#{ context := {main_contract, _} }, Id, [_ | _]) ->
+check_state_and_event_types(#{ context := {contract_def, _} }, Id, [_ | _]) ->
    case Id of
        {id, _, "state"} -> fcode_error({parameterized_state, Id});
        {id, _, "event"} -> fcode_error({parameterized_event, Id});
@@ -405,12 +490,18 @@ type_to_fcode(Env, Sub, {record_t, Fields}) ->
    type_to_fcode(Env, Sub, {tuple_t, [], lists:map(FieldType, Fields)});
 type_to_fcode(_Env, _Sub, {bytes_t, _, N}) ->
    {bytes, N};
+type_to_fcode(_Env, _Sub, {tvar, Ann, "void"}) ->
+    fcode_error({found_void, Ann});
 type_to_fcode(_Env, Sub, {tvar, _, X}) ->
    maps:get(X, Sub, {tvar, X});
+type_to_fcode(_Env, _Sub, {fun_t, Ann, _, var_args, _}) ->
+    fcode_error({var_args_not_set, {id, Ann, "a very suspicious function"}});
 type_to_fcode(Env, Sub, {fun_t, _, Named, Args, Res}) ->
    FNamed = [type_to_fcode(Env, Sub, Arg) || {named_arg_t, _, _, Arg, _} <- Named],
    FArgs  = [type_to_fcode(Env, Sub, Arg) || Arg <- Args],
    {function, FNamed ++ FArgs, type_to_fcode(Env, Sub, Res)};
+type_to_fcode(Env, Sub, {if_t, _, _, _, Else}) ->
+    type_to_fcode(Env, Sub, Else);  %% Hacky: this is only for remote calls, in which case we want the unprotected type
 type_to_fcode(_Env, _Sub, Type) ->
    error({todo, Type}).

@@ -620,14 +711,31 @@ expr_to_fcode(Env, _Type, {app, _Ann, {Op, _}, [A]}) when is_atom(Op) ->
    end;

 %% Function calls
-expr_to_fcode(Env, _Type, {app, _, Fun = {typed, _, _, {fun_t, _, NamedArgsT, _, _}}, Args}) ->
+expr_to_fcode(Env, Type, {app, _, Fun = {typed, _, FunE, {fun_t, _, NamedArgsT, ArgsT, _}}, Args}) ->
    Args1 = get_named_args(NamedArgsT, Args),
    FArgs = [expr_to_fcode(Env, Arg) || Arg <- Args1],
    case expr_to_fcode(Env, Fun) of
        {builtin_u, B, _Ar, TypeArgs}     -> builtin_to_fcode(state_layout(Env), B, FArgs ++ TypeArgs);
+        {builtin_u, chain_clone, _Ar}     ->
+            case ArgsT of
+                var_args -> fcode_error({var_args_not_set, FunE});
+                _ ->
+                    %% Here we little cheat on the typechecker, but this inconsistency
+                    %% is to be solved in `aeso_fcode_to_fate:type_to_scode/1`
+                    FInitArgsT = aeb_fate_data:make_typerep([type_to_fcode(Env, T) || T <- ArgsT]),
+                    builtin_to_fcode(state_layout(Env), chain_clone, [{lit, FInitArgsT}|FArgs])
+            end;
+        {builtin_u, chain_create, _Ar}     ->
+            case {ArgsT, Type} of
+                {var_args, _} -> fcode_error({var_args_not_set, FunE});
+                {_, {con, _, Contract}} ->
+                    FInitArgsT = aeb_fate_data:make_typerep([type_to_fcode(Env, T) || T <- ArgsT]),
+                    builtin_to_fcode(state_layout(Env), chain_create, [{lit, {contract_code, Contract}}, {lit, FInitArgsT}|FArgs]);
+                {_, _} -> fcode_error({not_a_contract_type, Type})
+            end;
        {builtin_u, B, _Ar}               -> builtin_to_fcode(state_layout(Env), B, FArgs);
        {def_u, F, _Ar}                   -> {def, F, FArgs};
-        {remote_u, ArgsT, RetT, Ct, RFun} -> {remote, ArgsT, RetT, Ct, RFun, FArgs};
+        {remote_u, RArgsT, RRetT, Ct, RFun} -> {remote, RArgsT, RRetT, Ct, RFun, FArgs};
        FFun ->
            %% FFun is a closure, with first component the function name and
            %% second component the environment
@@ -985,12 +1093,21 @@ stmts_to_fcode(Env, [Expr | Stmts]) ->

 op_builtins() ->
    [map_from_list, map_to_list, map_delete, map_member, map_size,
-     string_length, string_concat, string_sha3, string_sha256, string_blake2b,
+     stringinternal_length, stringinternal_concat, stringinternal_to_list, stringinternal_from_list,
+     stringinternal_sha3, stringinternal_sha256, stringinternal_blake2b,
+     char_to_int, char_from_int, stringinternal_to_lower, stringinternal_to_upper,
     bits_set, bits_clear, bits_test, bits_sum, bits_intersection, bits_union,
     bits_difference, int_to_str, address_to_str, crypto_verify_sig,
     address_to_contract,
     crypto_verify_sig_secp256k1, crypto_sha3, crypto_sha256, crypto_blake2b,
-     crypto_ecverify_secp256k1, crypto_ecrecover_secp256k1
+     crypto_ecverify_secp256k1, crypto_ecrecover_secp256k1,
+     mcl_bls12_381_g1_neg, mcl_bls12_381_g1_norm, mcl_bls12_381_g1_valid,
+     mcl_bls12_381_g1_is_zero, mcl_bls12_381_g1_add, mcl_bls12_381_g1_mul,
+     mcl_bls12_381_g2_neg, mcl_bls12_381_g2_norm, mcl_bls12_381_g2_valid,
+     mcl_bls12_381_g2_is_zero, mcl_bls12_381_g2_add, mcl_bls12_381_g2_mul,
+     mcl_bls12_381_gt_inv, mcl_bls12_381_gt_add, mcl_bls12_381_gt_mul, mcl_bls12_381_gt_pow,
+     mcl_bls12_381_gt_is_one, mcl_bls12_381_pairing, mcl_bls12_381_miller_loop, mcl_bls12_381_final_exp,
+     mcl_bls12_381_int_to_fr, mcl_bls12_381_int_to_fp, mcl_bls12_381_fr_to_int, mcl_bls12_381_fp_to_int
    ].

 set_state({reg, R}, Val) ->
@@ -1151,8 +1268,8 @@ lambda_lift_expr(Layout, UExpr) when element(1, UExpr) == def_u; element(1, UExp
 lambda_lift_expr(Layout, {remote_u, ArgsT, RetT, Ct, F}) ->
    FVs  = free_vars(Ct),
    Ct1  = lambda_lift_expr(Layout, Ct),
-    GasAndValueArgs = 2,
-    Xs   = [ lists:concat(["arg", I]) || I <- lists:seq(1, length(ArgsT) + GasAndValueArgs) ],
+    NamedArgCount = 3,
+    Xs   = [ lists:concat(["arg", I]) || I <- lists:seq(1, length(ArgsT) + NamedArgCount) ],
    Args = [{var, X} || X <- Xs],
    make_closure(FVs, Xs, {remote, ArgsT, RetT, Ct1, F, Args});
 lambda_lift_expr(Layout, Expr) ->
@@ -1547,6 +1664,10 @@ bind_constructors(Env = #{ con_env := ConEnv }, NewCons) ->

 %% -- Names --

+-spec add_child_con(env(), sophia_name(), fcode()) -> env().
+add_child_con(Env = #{child_con_env := CEnv}, Name, Fcode) ->
+    Env#{ child_con_env := CEnv#{Name => Fcode} }.
+
 -spec add_fun_env(env(), [aeso_syntax:decl()]) -> env().
 add_fun_env(Env = #{ context := {abstract_contract, _} }, _) -> Env;  %% no functions from abstract contracts
 add_fun_env(Env = #{ fun_env := FunEnv }, Decls) ->
@@ -1561,7 +1682,7 @@ add_fun_env(Env = #{ fun_env := FunEnv }, Decls) ->
 make_fun_name(#{ context := Context }, Ann, Name) ->
    Entrypoint = proplists:get_value(entrypoint, Ann, false),
    case Context of
-        {main_contract, Main} ->
+        {contract_def, Main} ->
            if Entrypoint     -> {entrypoint, list_to_binary(Name)};
               true           -> {local_fun, [Main, Name]}
            end;
@@ -1573,7 +1694,7 @@ make_fun_name(#{ context := Context }, Ann, Name) ->
 current_namespace(#{ context := Cxt }) ->
    case Cxt of
        {abstract_contract, Con} -> Con;
-        {main_contract, Con}     -> Con;
+        {contract_def, Con}     -> Con;
        {namespace, NS}          -> NS
    end.

@@ -1920,8 +2041,11 @@ internal_error(Error) ->
 %% -- Pretty printing --------------------------------------------------------

 format_fcode(#{ functions := Funs }) ->
-    prettypr:format(pp_above(
-        [ pp_fun(Name, Def) || {Name, Def} <- maps:to_list(Funs) ])).
+    prettypr:format(format_funs(Funs)).
+
+format_funs(Funs) ->
+    pp_above(
+      [ pp_fun(Name, Def) || {Name, Def} <- maps:to_list(Funs) ]).

 format_fexpr(E) ->
    prettypr:format(pp_fexpr(E)).
@@ -2038,7 +2162,9 @@ pp_fexpr({set_state, R, A}) ->
    pp_call(pp_text("set_state"), [{lit, {int, R}}, A]);
 pp_fexpr({get_state, R}) ->
    pp_call(pp_text("get_state"), [{lit, {int, R}}]);
-pp_fexpr({switch, Split}) -> pp_split(Split).
+pp_fexpr({switch, Split}) -> pp_split(Split);
+pp_fexpr({contract_code, Contract}) ->
+    pp_beside(pp_text("contract "), pp_text(Contract)).

 pp_call(Fun, Args) ->
    pp_beside(Fun, pp_fexpr({tuple, Args})).
@@ -14,12 +14,13 @@

 -include_lib("aebytecode/include/aeb_opcodes.hrl").
 -include("aeso_icode.hrl").
+-include("aeso_utils.hrl").

 -spec convert_typed(aeso_syntax:ast(), list()) -> aeso_icode:icode().
 convert_typed(TypedTree, Options) ->
    {Payable, Name} =
        case lists:last(TypedTree) of
-            {contract, Attrs, {con, _, Con}, _} ->
+            {Contr, Attrs, {con, _, Con}, _} when ?IS_CONTRACT_HEAD(Contr) ->
                {proplists:get_value(payable, Attrs, false), Con};
            Decl ->
                gen_error({last_declaration_must_be_contract, Decl})
@@ -29,7 +30,8 @@ convert_typed(TypedTree, Options) ->
    Icode    = code(TypedTree, NewIcode, Options),
    deadcode_elimination(Icode).

-code([{contract, _Attribs, Con, Code}|Rest], Icode, Options) ->
+code([{Contract, _Attribs, Con, Code}|Rest], Icode, Options)
+  when ?IS_CONTRACT_HEAD(Contract) ->
    NewIcode = contract_to_icode(Code, aeso_icode:set_namespace(Con, Icode)),
    code(Rest, NewIcode, Options);
 code([{namespace, _Ann, Name, Code}|Rest], Icode, Options) ->
@@ -469,6 +471,7 @@ is_builtin_fun({qid, _, ["AENS", "preclaim"]}, _Icode)                       ->
 is_builtin_fun({qid, _, ["AENS", "claim"]}, _Icode)                          -> true;
 is_builtin_fun({qid, _, ["AENS", "transfer"]}, _Icode)                       -> true;
 is_builtin_fun({qid, _, ["AENS", "revoke"]}, _Icode)                         -> true;
+is_builtin_fun({qid, _, ["AENS", "update"]}, _Icode)                         -> true;
 is_builtin_fun({qid, _, ["Map", "lookup"]}, _Icode)                          -> true;
 is_builtin_fun({qid, _, ["Map", "lookup_default"]}, _Icode)                  -> true;
 is_builtin_fun({qid, _, ["Map", "member"]}, _Icode)                          -> true;
@@ -624,6 +627,12 @@ builtin_code(_, {qid, _, ["AENS", "revoke"]}, Args, _, _, Icode) ->
              [ast_body(Addr, Icode), ast_body(Name, Icode), ast_body(Sign, Icode)],
              [word, word, sign_t()], {tuple, []});

+builtin_code(_, {qid, _, ["AENS", "update"]}, Args, _, _, Icode) ->
+    {Sign, [Addr, Name, TTL, ClientTTL, Pointers]} = get_signature_arg(Args),
+    prim_call(?PRIM_CALL_AENS_UPDATE, #integer{value = 0},
+              [ast_body(Addr, Icode), ast_body(Name, Icode), ast_body(TTL, Icode), ast_body(ClientTTL, Icode), ast_body(Pointers, Icode), ast_body(Sign, Icode)],
+              [word, string, word, word, word, sign_t()], {tuple, []});
+
 %% -- Maps
 %% -- lookup functions
 builtin_code(_, {qid, _, ["Map", "lookup"]}, [Key, Map], _, _, Icode) ->
@@ -927,11 +936,16 @@ ast_typerep1({variant_t, Cons}, Icode) ->
    {variant, [ begin
                  {constr_t, _, _, Args} = Con,
                  [ ast_typerep1(Arg, Icode) || Arg <- Args ]
-                end || Con <- Cons ]}.
+                end || Con <- Cons ]};
+ast_typerep1({if_t, _, _, _, Else}, Icode) ->
+    ast_typerep1(Else, Icode). %% protected remote calls are not in AEVM

 ttl_t(Icode) ->
    ast_typerep({qid, [], ["Chain", "ttl"]}, Icode).

+%% pointee_t(Icode) ->
+%%     ast_typerep({qid, [], ["AENS", "pointee"]}, Icode).
+
 sign_t() -> bytes_t(64).
 bytes_t(Len) when Len =< 32 -> word;
 bytes_t(Len)                -> {tuple, lists:duplicate((31 + Len) div 32, word)}.
@@ -10,9 +10,9 @@

 -export([format/1, pos/1]).

-format({last_declaration_must_be_contract, Decl = {namespace, _, {con, _, C}, _}}) ->
-    Msg = io_lib:format("Expected a contract as the last declaration instead of the namespace '~s'\n",
-                        [C]),
+format({last_declaration_must_be_main_contract, Decl = {Kind, _, {con, _, C}, _}}) ->
+    Msg = io_lib:format("Expected a main contract as the last declaration instead of the ~p '~s'\n",
+                        [Kind, C]),
    mk_err(pos(Decl), Msg);
 format({missing_init_function, Con}) ->
    Msg = io_lib:format("Missing init function for the contract '~s'.\n", [pp_expr(Con)]),
@@ -87,6 +87,12 @@ format({higher_order_state, {type_def, Ann, _, _, State}}) ->
    Msg = io_lib:format("Invalid state type\n~s\n", [pp_type(2, State)]),
    Cxt = "The state cannot contain functions in the AEVM. Use FATE if you need this.\n",
    mk_err(pos(Ann), Msg, Cxt);
+format({var_args_not_set, Expr}) ->
+    mk_err( pos(Expr), "Could not deduce type of variable arguments list"
+          , "When compiling " ++ pp_expr(Expr)
+          );
+format({found_void, Ann}) ->
+    mk_err(pos(Ann), "Found a void-typed value.", "`void` is a restricted, uninhabited type. Did you mean `unit`?");

 format(Err) ->
    mk_err(aeso_errors:pos(0, 0), io_lib:format("Unknown error: ~p\n", [Err])).
@@ -28,6 +28,7 @@

 -include_lib("aebytecode/include/aeb_opcodes.hrl").
 -include("aeso_icode.hrl").
+-include("aeso_utils.hrl").


 -type option() :: pp_sophia_code
@@ -137,8 +138,9 @@ from_string1(aevm, ContractString, Options) ->
    {ok, maybe_generate_aci(Res, FoldedTypedAst, Options)};
 from_string1(fate, ContractString, Options) ->
    #{ fcode := FCode
+     , fcode_env := #{child_con_env := ChildContracts}
     , folded_typed_ast := FoldedTypedAst } = string_to_code(ContractString, Options),
-    FateCode = aeso_fcode_to_fate:compile(FCode, Options),
+    FateCode = aeso_fcode_to_fate:compile(ChildContracts, FCode, Options),
    pp_assembler(fate, FateCode, Options),
    ByteCode = aeb_fate_code:serialize(FateCode, []),
    {ok, Version} = version(),
@@ -178,8 +180,9 @@ string_to_code(ContractString, Options) ->
             , type_env  => TypeEnv
             , ast => Ast };
        fate ->
-            Fcode = aeso_ast_to_fcode:ast_to_fcode(UnfoldedTypedAst, Options),
+            {Env, Fcode} = aeso_ast_to_fcode:ast_to_fcode(UnfoldedTypedAst, [{original_src, ContractString}|Options]),
            #{ fcode => Fcode
+             , fcode_env => Env
             , unfolded_typed_ast => UnfoldedTypedAst
             , folded_typed_ast => FoldedTypedAst
             , type_env  => TypeEnv
@@ -241,8 +244,9 @@ check_call1(ContractString0, FunName, Args, Options) ->
            fate ->
                %% First check the contract without the __call function
                #{ fcode := OrgFcode
+                 , fcode_env := #{child_con_env := ChildContracts}
                 , ast := Ast } = string_to_code(ContractString0, Options),
-                FateCode = aeso_fcode_to_fate:compile(OrgFcode, []),
+                FateCode = aeso_fcode_to_fate:compile(ChildContracts, OrgFcode, []),
                %% collect all hashes and compute the first name without hash collision to
                SymbolHashes = maps:keys(aeb_fate_code:symbols(FateCode)),
                CallName = first_none_match(?CALL_NAME, SymbolHashes,
@@ -468,7 +472,7 @@ error_missing_call_function() ->
    Msg = "Internal error: missing '__call'-function",
    aeso_errors:throw(aeso_errors:new(internal_error, Msg)).

-get_call_type([{contract, _, _, Defs}]) ->
+get_call_type([{Contract, _, _, Defs}]) when ?IS_CONTRACT_HEAD(Contract) ->
    case [ {lists:last(QFunName), FunType}
          || {letfun, _, {id, _, ?CALL_NAME}, [], _Ret,
                {typed, _,
@@ -482,7 +486,7 @@ get_call_type([_ | Contracts]) ->
    get_call_type(Contracts).

 -dialyzer({nowarn_function, get_decode_type/2}).
-get_decode_type(FunName, [{contract, Ann, _, Defs}]) ->
+get_decode_type(FunName, [{Contract, Ann, _, Defs}]) when ?IS_CONTRACT_HEAD(Contract) ->
    GetType = fun({letfun, _, {id, _, Name}, Args, Ret, _})               when Name == FunName -> [{Args, Ret}];
                 ({fun_decl, _, {id, _, Name}, {fun_t, _, _, Args, Ret}}) when Name == FunName -> [{Args, Ret}];
                 (_) -> [] end,
@@ -9,7 +9,7 @@
 %%%-------------------------------------------------------------------
 -module(aeso_fcode_to_fate).

-export([compile/2, term_to_fate/1]).
+-export([compile/2, compile/3, term_to_fate/1, term_to_fate/2]).

 -ifdef(TEST).
 -export([optimize_fun/4, to_basic_blocks/1]).
@@ -45,7 +45,7 @@
 -define(s(N), {store, N}).
 -define(void, {var, 9999}).

-record(env, { contract, vars = [], locals = [], current_function, tailpos = true }).
+-record(env, { contract, vars = [], locals = [], current_function, tailpos = true, child_contracts = #{}, options = []}).

 %% -- Debugging --------------------------------------------------------------

@@ -70,9 +70,11 @@ code_error(Err) ->

 %% @doc Main entry point.
 compile(FCode, Options) ->
+    compile(#{}, FCode, Options).
+compile(ChildContracts, FCode, Options) ->
    #{ contract_name := ContractName,
       functions     := Functions } = FCode,
-    SFuns  = functions_to_scode(ContractName, Functions, Options),
+    SFuns  = functions_to_scode(ChildContracts, ContractName, Functions, Options),
    SFuns1 = optimize_scode(SFuns, Options),
    FateCode = to_basic_blocks(SFuns1),
    ?debug(compile, Options, "~s\n", [aeb_fate_asm:pp(FateCode)]),
@@ -85,19 +87,20 @@ make_function_name(event)              -> <<"Chain.event">>;
 make_function_name({entrypoint, Name}) -> Name;
 make_function_name({local_fun, Xs})    -> list_to_binary("." ++ string:join(Xs, ".")).

-functions_to_scode(ContractName, Functions, Options) ->
+functions_to_scode(ChildContracts, ContractName, Functions, Options) ->
    FunNames = maps:keys(Functions),
    maps:from_list(
-        [ {make_function_name(Name), function_to_scode(ContractName, FunNames, Name, Attrs, Args, Body, Type, Options)}
+        [ {make_function_name(Name), function_to_scode(ChildContracts, ContractName, FunNames, Name, Attrs, Args, Body, Type, Options)}
        || {Name, #{args   := Args,
                    body   := Body,
                    attrs  := Attrs,
                    return := Type}} <- maps:to_list(Functions)]).

-function_to_scode(ContractName, Functions, Name, Attrs0, Args, Body, ResType, _Options) ->
+function_to_scode(ChildContracts, ContractName, Functions, Name, Attrs0, Args, Body, ResType, Options) ->
    {ArgTypes, ResType1} = typesig_to_scode(Args, ResType),
    Attrs = Attrs0 -- [stateful], %% Only track private and payable from here.
-    SCode = to_scode(init_env(ContractName, Functions, Name, Args), Body),
+    Env = init_env(ChildContracts, ContractName, Functions, Name, Args, Options),
+    SCode = to_scode(Env, Body),
    {Attrs, {ArgTypes, ResType1}, SCode}.

 -define(tvars, '$tvars').
@@ -133,7 +136,9 @@ type_to_scode({tvar, X}) ->
            put(?tvars, {I + 1, Vars#{ X => I }}),
            {tvar, I};
        J -> {tvar, J}
-    end.
+    end;
+type_to_scode(L) when is_list(L) -> {tuple, types_to_scode(L)}.
+

 types_to_scode(Ts) -> lists:map(fun type_to_scode/1, Ts).

@@ -142,11 +147,13 @@ types_to_scode(Ts) -> lists:map(fun type_to_scode/1, Ts).

 %% -- Environment functions --

-init_env(ContractName, FunNames, Name, Args) ->
+init_env(ChildContracts, ContractName, FunNames, Name, Args, Options) ->
    #env{ vars      = [ {X, {arg, I}} || {I, {X, _}} <- with_ixs(Args) ],
          contract  = ContractName,
+          child_contracts = ChildContracts,
          locals    = FunNames,
          current_function = Name,
+          options = Options,
          tailpos   = true }.

 next_var(#env{ vars = Vars }) ->
@@ -169,7 +176,7 @@ lookup_var(#env{vars = Vars}, X) ->

 %% -- The compiler --

-lit_to_fate(L) ->
+lit_to_fate(Env, L) ->
    case L of
        {int, N}             -> aeb_fate_data:make_integer(N);
        {string, S}          -> aeb_fate_data:make_string(S);
@@ -179,63 +186,80 @@ lit_to_fate(L) ->
        {contract_pubkey, K} -> aeb_fate_data:make_contract(K);
        {oracle_pubkey, K}   -> aeb_fate_data:make_oracle(K);
        {oracle_query_id, H} -> aeb_fate_data:make_oracle_query(H);
+        {contract_code, C}   ->
+            Options = Env#env.options,
+            FCode    = maps:get(C, Env#env.child_contracts),
+            FateCode = compile(Env#env.child_contracts, FCode, Options),
+            ByteCode = aeb_fate_code:serialize(FateCode, []),
+            {ok, Version} = aeso_compiler:version(),
+            OriginalSourceCode = proplists:get_value(original_src, Options, ""),
+            Code = #{byte_code => ByteCode,
+                     compiler_version => Version,
+                     source_hash => crypto:hash(sha256, OriginalSourceCode ++ [0] ++ C),
+                     type_info => [],
+                     abi_version => aeb_fate_abi:abi_version(),
+                     payable => maps:get(payable, FCode)
+                   },
+            Serialized = aeser_contract_code:serialize(Code),
+            aeb_fate_data:make_contract_bytearray(Serialized);
        {typerep, T}         -> aeb_fate_data:make_typerep(type_to_scode(T))
     end.

-term_to_fate(E) -> term_to_fate(#{}, E).
+term_to_fate(E) -> term_to_fate(#env{}, #{}, E).
+term_to_fate(GlobEnv, E) -> term_to_fate(GlobEnv, #{}, E).

-term_to_fate(_Env, {lit, L}) ->
-    lit_to_fate(L);
+term_to_fate(GlobEnv, _Env, {lit, L}) ->
+    lit_to_fate(GlobEnv, L);
 %% negative literals are parsed as 0 - N
-term_to_fate(_Env, {op, '-', [{lit, {int, 0}}, {lit, {int, N}}]}) ->
+term_to_fate(_GlobEnv, _Env, {op, '-', [{lit, {int, 0}}, {lit, {int, N}}]}) ->
    aeb_fate_data:make_integer(-N);
-term_to_fate(_Env, nil) ->
+term_to_fate(_GlobEnv, _Env, nil) ->
    aeb_fate_data:make_list([]);
-term_to_fate(Env, {op, '::', [Hd, Tl]}) ->
+term_to_fate(GlobEnv, Env, {op, '::', [Hd, Tl]}) ->
    %% The Tl will translate into a list, because FATE lists are just lists
-    [term_to_fate(Env, Hd) | term_to_fate(Env, Tl)];
-term_to_fate(Env, {tuple, As}) ->
-    aeb_fate_data:make_tuple(list_to_tuple([ term_to_fate(Env, A) || A<-As]));
-term_to_fate(Env, {con, Ar, I, As}) ->
-    FateAs = [ term_to_fate(Env, A) || A <- As ],
+    [term_to_fate(GlobEnv, Env, Hd) | term_to_fate(GlobEnv, Env, Tl)];
+term_to_fate(GlobEnv, Env, {tuple, As}) ->
+    aeb_fate_data:make_tuple(list_to_tuple([ term_to_fate(GlobEnv, Env, A) || A<-As]));
+term_to_fate(GlobEnv, Env, {con, Ar, I, As}) ->
+    FateAs = [ term_to_fate(GlobEnv, Env, A) || A <- As ],
    aeb_fate_data:make_variant(Ar, I, list_to_tuple(FateAs));
-term_to_fate(_Env, {builtin, bits_all, []}) ->
+term_to_fate(_GlobEnv, _Env, {builtin, bits_all, []}) ->
    aeb_fate_data:make_bits(-1);
-term_to_fate(_Env, {builtin, bits_none, []}) ->
+term_to_fate(_GlobEnv, _Env, {builtin, bits_none, []}) ->
    aeb_fate_data:make_bits(0);
-term_to_fate(_Env, {op, bits_set, [B, I]}) ->
-    {bits, N} = term_to_fate(B),
-    J         = term_to_fate(I),
+term_to_fate(GlobEnv, _Env, {op, bits_set, [B, I]}) ->
+    {bits, N} = term_to_fate(GlobEnv, B),
+    J         = term_to_fate(GlobEnv, I),
    {bits, N bor (1 bsl J)};
-term_to_fate(_Env, {op, bits_clear, [B, I]}) ->
-    {bits, N} = term_to_fate(B),
-    J         = term_to_fate(I),
+term_to_fate(GlobEnv, _Env, {op, bits_clear, [B, I]}) ->
+    {bits, N} = term_to_fate(GlobEnv, B),
+    J         = term_to_fate(GlobEnv, I),
    {bits, N band bnot (1 bsl J)};
-term_to_fate(Env, {'let', X, E, Body}) ->
-    Env1 = Env#{ X => term_to_fate(Env, E) },
-    term_to_fate(Env1, Body);
-term_to_fate(Env, {var, X}) ->
+term_to_fate(GlobEnv, Env, {'let', X, E, Body}) ->
+    Env1 = Env#{ X => term_to_fate(GlobEnv, Env, E) },
+    term_to_fate(GlobEnv, Env1, Body);
+term_to_fate(_GlobEnv, Env, {var, X}) ->
    case maps:get(X, Env, undefined) of
        undefined -> throw(not_a_fate_value);
        V         -> V
    end;
-term_to_fate(_Env, {builtin, map_empty, []}) ->
+term_to_fate(_GlobEnv, _Env, {builtin, map_empty, []}) ->
    aeb_fate_data:make_map(#{});
-term_to_fate(Env, {op, map_set, [M, K, V]}) ->
-    Map = term_to_fate(Env, M),
-    Map#{term_to_fate(Env, K) => term_to_fate(Env, V)};
-term_to_fate(_Env, _) ->
+term_to_fate(GlobEnv, Env, {op, map_set, [M, K, V]}) ->
+    Map = term_to_fate(GlobEnv, Env, M),
+    Map#{term_to_fate(GlobEnv, Env, K) => term_to_fate(GlobEnv, Env, V)};
+term_to_fate(_GlobEnv, _Env, _) ->
    throw(not_a_fate_value).

 to_scode(Env, T) ->
-    try term_to_fate(T) of
+    try term_to_fate(Env, T) of
        V -> [push(?i(V))]
    catch throw:not_a_fate_value ->
        to_scode1(Env, T)
    end.

-to_scode1(_Env, {lit, L}) ->
-    [push(?i(lit_to_fate(L)))];
+to_scode1(Env, {lit, L}) ->
+    [push(?i(lit_to_fate(Env, L)))];

 to_scode1(_Env, nil) ->
    [aeb_fate_ops:nil(?a)];
@@ -302,18 +326,27 @@ to_scode1(Env, {funcall, Fun, Args}) ->
 to_scode1(Env, {builtin, B, Args}) ->
    builtin_to_scode(Env, B, Args);

-to_scode1(Env, {remote, ArgsT, RetT, Ct, Fun, [Gas, Value | Args]}) ->
+to_scode1(Env, {remote, ArgsT, RetT, Ct, Fun, [Gas, Value, Protected | Args]}) ->
    Lbl = make_function_id(Fun),
    {ArgTypes, RetType0} = typesig_to_scode([{"_", T} || T <- ArgsT], RetT),
    ArgType = ?i(aeb_fate_data:make_typerep({tuple, ArgTypes})),
    RetType = ?i(aeb_fate_data:make_typerep(RetType0)),
-    case Gas of
-        {builtin, call_gas_left, _} ->
-            Call = aeb_fate_ops:call_r(?a, Lbl, ArgType, RetType, ?a),
-            call_to_scode(Env, Call, [Ct, Value | Args]);
+    case Protected of
+        {lit, {bool, false}} ->
+            case Gas of
+                {builtin, call_gas_left, _} ->
+                    Call = aeb_fate_ops:call_r(?a, Lbl, ArgType, RetType, ?a),
+                    call_to_scode(Env, Call, [Ct, Value | Args]);
+                _ ->
+                    Call = aeb_fate_ops:call_gr(?a, Lbl, ArgType, RetType, ?a, ?a),
+                    call_to_scode(Env, Call, [Ct, Value, Gas | Args])
+            end;
+        {lit, {bool, true}} ->
+            Call = aeb_fate_ops:call_pgr(?a, Lbl, ArgType, RetType, ?a, ?a, ?i(true)),
+            call_to_scode(Env, Call, [Ct, Value, Gas | Args]);
        _ ->
-            Call = aeb_fate_ops:call_gr(?a, Lbl, ArgType, RetType, ?a, ?a),
-            call_to_scode(Env, Call, [Ct, Value, Gas | Args])
+            Call = aeb_fate_ops:call_pgr(?a, Lbl, ArgType, RetType, ?a, ?a, ?a),
+            call_to_scode(Env, Call, [Ct, Value, Gas, Protected | Args])
    end;

 to_scode1(_Env, {get_state, Reg}) ->
@@ -494,10 +527,14 @@ builtin_to_scode(_Env, call_value, []) ->
    [aeb_fate_ops:call_value(?a)];
 builtin_to_scode(_Env, call_gas_price, []) ->
    [aeb_fate_ops:gasprice(?a)];
+builtin_to_scode(_Env, call_fee, []) ->
+    [aeb_fate_ops:fee(?a)];
 builtin_to_scode(_Env, call_gas_left, []) ->
    [aeb_fate_ops:gas(?a)];
 builtin_to_scode(Env, oracle_register, [_Sign,_Account,_QFee,_TTL,_QType,_RType] = Args) ->
    call_to_scode(Env, aeb_fate_ops:oracle_register(?a, ?a, ?a, ?a, ?a, ?a, ?a), Args);
+builtin_to_scode(Env, oracle_expiry, [_Oracle] = Args) ->
+    call_to_scode(Env, aeb_fate_ops:oracle_expiry(?a, ?a), Args);
 builtin_to_scode(Env, oracle_query_fee, [_Oracle] = Args) ->
    call_to_scode(Env, aeb_fate_ops:oracle_query_fee(?a, ?a), Args);
 builtin_to_scode(Env, oracle_query, [_Oracle, _Question, _QFee, _QTTL, _RTTL, _QType, _RType] = Args) ->
@@ -536,8 +573,35 @@ builtin_to_scode(Env, aens_transfer, [_Sign, _From, _To, _Name] = Args) ->
 builtin_to_scode(Env, aens_revoke, [_Sign, _Account, _Name] = Args) ->
    call_to_scode(Env, [aeb_fate_ops:aens_revoke(?a, ?a, ?a),
                        tuple(0)], Args);
+builtin_to_scode(Env, aens_update, [_Sign, _Account, _NameString, _TTL, _ClientTTL, _Pointers] = Args) ->
+    call_to_scode(Env, [aeb_fate_ops:aens_update(?a, ?a, ?a, ?a, ?a, ?a),
+                        tuple(0)], Args);
+builtin_to_scode(Env, aens_lookup, [_Name] = Args) ->
+    call_to_scode(Env, aeb_fate_ops:aens_lookup(?a, ?a), Args);
 builtin_to_scode(_Env, auth_tx_hash, []) ->
-    [aeb_fate_ops:auth_tx_hash(?a)].
+    [aeb_fate_ops:auth_tx_hash(?a)];
+builtin_to_scode(_Env, auth_tx, []) ->
+    [aeb_fate_ops:auth_tx(?a)];
+builtin_to_scode(Env, chain_bytecode_hash, [_Addr] = Args) ->
+    call_to_scode(Env, aeb_fate_ops:bytecode_hash(?a, ?a), Args);
+builtin_to_scode(Env, chain_clone,
+                 [InitArgsT, GasCap, Value, Prot, Contract | InitArgs]) ->
+    case GasCap of
+        {builtin, call_gas_left, _} ->
+            call_to_scode(Env, aeb_fate_ops:clone(?a, ?a, ?a, ?a),
+                          [Contract, InitArgsT, Value, Prot | InitArgs]
+                         );
+        _ ->
+            call_to_scode(Env, aeb_fate_ops:clone_g(?a, ?a, ?a, ?a, ?a),
+                          [Contract, InitArgsT, Value, GasCap, Prot | InitArgs]
+                         )
+    end;
+
+builtin_to_scode(Env, chain_create,
+                 [ Code, InitArgsT, Value | InitArgs]) ->
+    call_to_scode(Env, aeb_fate_ops:create(?a, ?a, ?a),
+                  [Code, InitArgsT, Value | InitArgs]
+                 ).

 %% -- Operators --

@@ -564,8 +628,14 @@ op_to_scode(map_to_list)       -> aeb_fate_ops:map_to_list(?a, ?a);
 op_to_scode(map_delete)        -> aeb_fate_ops:map_delete(?a, ?a, ?a);
 op_to_scode(map_member)        -> aeb_fate_ops:map_member(?a, ?a, ?a);
 op_to_scode(map_size)          -> aeb_fate_ops:map_size_(?a, ?a);
-op_to_scode(string_length)     -> aeb_fate_ops:str_length(?a, ?a);
-op_to_scode(string_concat)     -> aeb_fate_ops:str_join(?a, ?a, ?a);
+op_to_scode(stringinternal_length)    -> aeb_fate_ops:str_length(?a, ?a);
+op_to_scode(stringinternal_concat)    -> aeb_fate_ops:str_join(?a, ?a, ?a);
+op_to_scode(stringinternal_to_list)   -> aeb_fate_ops:str_to_list(?a, ?a);
+op_to_scode(stringinternal_from_list) -> aeb_fate_ops:str_from_list(?a, ?a);
+op_to_scode(stringinternal_to_lower)  -> aeb_fate_ops:str_to_lower(?a, ?a);
+op_to_scode(stringinternal_to_upper)  -> aeb_fate_ops:str_to_upper(?a, ?a);
+op_to_scode(char_to_int)       -> aeb_fate_ops:char_to_int(?a, ?a);
+op_to_scode(char_from_int)     -> aeb_fate_ops:char_from_int(?a, ?a);
 op_to_scode(bits_set)          -> aeb_fate_ops:bits_set(?a, ?a, ?a);
 op_to_scode(bits_clear)        -> aeb_fate_ops:bits_clear(?a, ?a, ?a);
 op_to_scode(bits_test)         -> aeb_fate_ops:bits_test(?a, ?a, ?a);
@@ -584,9 +654,33 @@ op_to_scode(crypto_ecrecover_secp256k1)  -> aeb_fate_ops:ecrecover_secp256k1(?a,
 op_to_scode(crypto_sha3)                 -> aeb_fate_ops:sha3(?a, ?a);
 op_to_scode(crypto_sha256)               -> aeb_fate_ops:sha256(?a, ?a);
 op_to_scode(crypto_blake2b)              -> aeb_fate_ops:blake2b(?a, ?a);
-op_to_scode(string_sha3)                 -> aeb_fate_ops:sha3(?a, ?a);
-op_to_scode(string_sha256)               -> aeb_fate_ops:sha256(?a, ?a);
-op_to_scode(string_blake2b)              -> aeb_fate_ops:blake2b(?a, ?a).
+op_to_scode(stringinternal_sha3)         -> aeb_fate_ops:sha3(?a, ?a);
+op_to_scode(stringinternal_sha256)       -> aeb_fate_ops:sha256(?a, ?a);
+op_to_scode(stringinternal_blake2b)      -> aeb_fate_ops:blake2b(?a, ?a);
+op_to_scode(mcl_bls12_381_g1_neg)        -> aeb_fate_ops:bls12_381_g1_neg(?a, ?a);
+op_to_scode(mcl_bls12_381_g1_norm)       -> aeb_fate_ops:bls12_381_g1_norm(?a, ?a);
+op_to_scode(mcl_bls12_381_g1_valid)      -> aeb_fate_ops:bls12_381_g1_valid(?a, ?a);
+op_to_scode(mcl_bls12_381_g1_is_zero)    -> aeb_fate_ops:bls12_381_g1_is_zero(?a, ?a);
+op_to_scode(mcl_bls12_381_g1_add)        -> aeb_fate_ops:bls12_381_g1_add(?a, ?a, ?a);
+op_to_scode(mcl_bls12_381_g1_mul)        -> aeb_fate_ops:bls12_381_g1_mul(?a, ?a, ?a);
+op_to_scode(mcl_bls12_381_g2_neg)        -> aeb_fate_ops:bls12_381_g2_neg(?a, ?a);
+op_to_scode(mcl_bls12_381_g2_norm)       -> aeb_fate_ops:bls12_381_g2_norm(?a, ?a);
+op_to_scode(mcl_bls12_381_g2_valid)      -> aeb_fate_ops:bls12_381_g2_valid(?a, ?a);
+op_to_scode(mcl_bls12_381_g2_is_zero)    -> aeb_fate_ops:bls12_381_g2_is_zero(?a, ?a);
+op_to_scode(mcl_bls12_381_g2_add)        -> aeb_fate_ops:bls12_381_g2_add(?a, ?a, ?a);
+op_to_scode(mcl_bls12_381_g2_mul)        -> aeb_fate_ops:bls12_381_g2_mul(?a, ?a, ?a);
+op_to_scode(mcl_bls12_381_gt_inv)        -> aeb_fate_ops:bls12_381_gt_inv(?a, ?a);
+op_to_scode(mcl_bls12_381_gt_add)        -> aeb_fate_ops:bls12_381_gt_add(?a, ?a, ?a);
+op_to_scode(mcl_bls12_381_gt_mul)        -> aeb_fate_ops:bls12_381_gt_mul(?a, ?a, ?a);
+op_to_scode(mcl_bls12_381_gt_pow)        -> aeb_fate_ops:bls12_381_gt_pow(?a, ?a, ?a);
+op_to_scode(mcl_bls12_381_gt_is_one)     -> aeb_fate_ops:bls12_381_gt_is_one(?a, ?a);
+op_to_scode(mcl_bls12_381_pairing)       -> aeb_fate_ops:bls12_381_pairing(?a, ?a, ?a);
+op_to_scode(mcl_bls12_381_miller_loop)   -> aeb_fate_ops:bls12_381_miller_loop(?a, ?a, ?a);
+op_to_scode(mcl_bls12_381_final_exp)     -> aeb_fate_ops:bls12_381_final_exp(?a, ?a);
+op_to_scode(mcl_bls12_381_int_to_fr)     -> aeb_fate_ops:bls12_381_int_to_fr(?a, ?a);
+op_to_scode(mcl_bls12_381_int_to_fp)     -> aeb_fate_ops:bls12_381_int_to_fp(?a, ?a);
+op_to_scode(mcl_bls12_381_fr_to_int)     -> aeb_fate_ops:bls12_381_fr_to_int(?a, ?a);
+op_to_scode(mcl_bls12_381_fp_to_int)     -> aeb_fate_ops:bls12_381_fp_to_int(?a, ?a).

 %% PUSH and STORE ?a are the same, so we use STORE to make optimizations
 %% easier, and specialize to PUSH (which is cheaper) at the end.
@@ -734,6 +828,7 @@ attributes(I) ->
        {'CALL', A}                           -> Impure(?a, [A]);
        {'CALL_R', A, _, B, C, D}             -> Impure(?a, [A, B, C, D]);
        {'CALL_GR', A, _, B, C, D, E}         -> Impure(?a, [A, B, C, D, E]);
+        {'CALL_PGR', A, _, B, C, D, E, F}     -> Impure(?a, [A, B, C, D, E, F]);
        {'CALL_T', A}                         -> Impure(pc, [A]);
        {'CALL_VALUE', A}                     -> Pure(A, []);
        {'JUMP', _}                           -> Impure(pc, []);
@@ -815,6 +910,7 @@ attributes(I) ->
        {'CONTRACT_TO_ADDRESS', A, B}         -> Pure(A, [B]);
        {'ADDRESS_TO_CONTRACT', A, B}         -> Pure(A, [B]);
        {'AUTH_TX_HASH', A}                   -> Pure(A, []);
+        {'AUTH_TX', A}                        -> Pure(A, []);
        {'BYTES_TO_INT', A, B}                -> Pure(A, [B]);
        {'BYTES_TO_STR', A, B}                -> Pure(A, [B]);
        {'BYTES_CONCAT', A, B, C}             -> Pure(A, [B, C]);
@@ -831,6 +927,7 @@ attributes(I) ->
        {'ORIGIN', A}                         -> Pure(A, []);
        {'CALLER', A}                         -> Pure(A, []);
        {'GASPRICE', A}                       -> Pure(A, []);
+        {'FEE', A}                            -> Pure(A, []);
        {'BLOCKHASH', A, B}                   -> Pure(A, [B]);
        {'BENEFICIARY', A}                    -> Pure(A, []);
        {'TIMESTAMP', A}                      -> Pure(A, []);
@@ -853,12 +950,48 @@ attributes(I) ->
        {'ORACLE_GET_ANSWER', A, B, C, D, E}  -> Pure(A, [B, C, D, E]);
        {'ORACLE_GET_QUESTION', A, B, C, D, E}-> Pure(A, [B, C, D, E]);
        {'ORACLE_QUERY_FEE', A, B}            -> Pure(A, [B]);
-        {'AENS_RESOLVE', A, B, C, D}          -> Pure(A, [B, C, D]);
+        {'ORACLE_EXPIRY', A, B}               -> Impure(A, [B]);
+        {'AENS_RESOLVE', A, B, C, D}          -> Impure(A, [B, C, D]);
        {'AENS_PRECLAIM', A, B, C}            -> Impure(none, [A, B, C]);
        {'AENS_CLAIM', A, B, C, D, E}         -> Impure(none, [A, B, C, D, E]);
-        'AENS_UPDATE'                         -> Impure(none, []);%% TODO
+        {'AENS_UPDATE', A, B, C, D, E, F}     -> Impure(none, [A, B, C, D, E, F]);
        {'AENS_TRANSFER', A, B, C, D}         -> Impure(none, [A, B, C, D]);
        {'AENS_REVOKE', A, B, C}              -> Impure(none, [A, B, C]);
+        {'AENS_LOOKUP', A, B}                 -> Impure(A, [B]);
+        {'BLS12_381_G1_NEG', A, B}            -> Pure(A, [B]);
+        {'BLS12_381_G1_NORM', A, B}           -> Pure(A, [B]);
+        {'BLS12_381_G1_VALID', A, B}          -> Pure(A, [B]);
+        {'BLS12_381_G1_IS_ZERO', A, B}        -> Pure(A, [B]);
+        {'BLS12_381_G1_ADD', A, B, C}         -> Pure(A, [B, C]);
+        {'BLS12_381_G1_MUL', A, B, C}         -> Pure(A, [B, C]);
+        {'BLS12_381_G2_NEG', A, B}            -> Pure(A, [B]);
+        {'BLS12_381_G2_NORM', A, B}           -> Pure(A, [B]);
+        {'BLS12_381_G2_VALID', A, B}          -> Pure(A, [B]);
+        {'BLS12_381_G2_IS_ZERO', A, B}        -> Pure(A, [B]);
+        {'BLS12_381_G2_ADD', A, B, C}         -> Pure(A, [B, C]);
+        {'BLS12_381_G2_MUL', A, B, C}         -> Pure(A, [B, C]);
+        {'BLS12_381_GT_INV', A, B}            -> Pure(A, [B]);
+        {'BLS12_381_GT_ADD', A, B, C}         -> Pure(A, [B, C]);
+        {'BLS12_381_GT_MUL', A, B, C}         -> Pure(A, [B, C]);
+        {'BLS12_381_GT_POW', A, B, C}         -> Pure(A, [B, C]);
+        {'BLS12_381_GT_IS_ONE', A, B}         -> Pure(A, [B]);
+        {'BLS12_381_PAIRING', A, B, C}        -> Pure(A, [B, C]);
+        {'BLS12_381_MILLER_LOOP', A, B, C}    -> Pure(A, [B, C]);
+        {'BLS12_381_FINAL_EXP', A, B}         -> Pure(A, [B]);
+        {'BLS12_381_INT_TO_FR', A, B}         -> Pure(A, [B]);
+        {'BLS12_381_INT_TO_FP', A, B}         -> Pure(A, [B]);
+        {'BLS12_381_FR_TO_INT', A, B}         -> Pure(A, [B]);
+        {'BLS12_381_FP_TO_INT', A, B}         -> Pure(A, [B]);
+        {'STR_TO_LIST', A, B}                 -> Pure(A, [B]);
+        {'STR_FROM_LIST', A, B}               -> Pure(A, [B]);
+        {'STR_TO_UPPER', A, B}                -> Pure(A, [B]);
+        {'STR_TO_LOWER', A, B}                -> Pure(A, [B]);
+        {'CHAR_TO_INT', A, B}                 -> Pure(A, [B]);
+        {'CHAR_FROM_INT', A, B}               -> Pure(A, [B]);
+        {'CREATE', A, B, C}                   -> Impure(?a, [A, B, C]);
+        {'CLONE', A, B, C, D}                 -> Impure(?a, [A, B, C, D]);
+        {'CLONE_G', A, B, C, D, E}            -> Impure(?a, [A, B, C, D, E]);
+        {'BYTECODE_HASH', A, B}               -> Impure(A, [B]);
        {'ABORT', A}                          -> Impure(pc, A);
        {'EXIT', A}                           -> Impure(pc, A);
        'NOP'                                 -> Pure(none, [])
@@ -1611,6 +1744,10 @@ split_calls(Ref, [], Acc, Blocks) ->
 split_calls(Ref, [I | Code], Acc, Blocks) when element(1, I) == 'CALL';
                                               element(1, I) == 'CALL_R';
                                               element(1, I) == 'CALL_GR';
+                                               element(1, I) == 'CALL_PGR';
+                                               element(1, I) == 'CREATE';
+                                               element(1, I) == 'CLONE';
+                                               element(1, I) == 'CLONE_G';
                                               element(1, I) == 'jumpif' ->
    split_calls(make_ref(), Code, [], [{Ref, lists:reverse([I | Acc])} | Blocks]);
 split_calls(Ref, [{'ABORT', _} = I | _Code], Acc, Blocks) ->
@@ -73,28 +73,33 @@ new(Options) ->

 builtin_types() ->
    Word = fun([]) -> word end,
-    #{ "bool"         => Word
-     , "int"          => Word
-     , "char"         => Word
-     , "bits"         => Word
-     , "string"       => fun([]) -> string end
-     , "address"      => Word
-     , "hash"         => Word
-     , "unit"         => fun([]) -> {tuple, []} end
-     , "signature"    => fun([]) -> {tuple, [word, word]} end
-     , "oracle"       => fun([_, _]) -> word end
-     , "oracle_query" => fun([_, _]) -> word end
-     , "list"         => fun([A]) -> {list, A} end
-     , "option"       => fun([A]) -> {variant, [[], [A]]} end
-     , "map"          => fun([K, V]) -> map_typerep(K, V) end
-     , ["Chain", "ttl"] => fun([]) -> {variant, [[word], [word]]} end
+    #{ "bool"              => Word
+     , "int"               => Word
+     , "char"              => Word
+     , "bits"              => Word
+     , "string"            => fun([]) -> string end
+     , "address"           => Word
+     , "hash"              => Word
+     , "unit"              => fun([]) -> {tuple, []} end
+     , "signature"         => fun([]) -> {tuple, [word, word]} end
+     , "oracle"            => fun([_, _]) -> word end
+     , "oracle_query"      => fun([_, _]) -> word end
+     , "list"              => fun([A]) -> {list, A} end
+     , "option"            => fun([A]) -> {variant, [[], [A]]} end
+     , "map"               => fun([K, V]) -> map_typerep(K, V) end
+     , ["Chain", "ttl"]    => fun([]) -> {variant, [[word], [word]]} end
+     , ["AENS", "pointee"] => fun([]) -> {variant, [[word], [word], [word]]} end
     }.

 builtin_constructors() ->
-    #{ ["RelativeTTL"] => 0
-     , ["FixedTTL"]    => 1
-     , ["None"]        => 0
-     , ["Some"]        => 1 }.
+    #{ ["RelativeTTL"]     => 0
+     , ["FixedTTL"]        => 1
+     , ["None"]            => 0
+     , ["Some"]            => 1
+     , ["AccountPointee"]  => 0
+     , ["OraclePointee"]   => 1
+     , ["ContractPointee"] => 2
+     }.

 map_typerep(K, V) ->
    {map, K, V}.
@@ -146,4 +151,3 @@ get_constructor_tag(Name, #{constructors := Constructors}) ->
        undefined -> error({undefined_constructor, Name});
        Tag       -> Tag
    end.
-
@@ -74,25 +74,31 @@
                    %%   first argument. I.e. no backtracking to the second argument if the first
                    %%   fails.

+trampoline({bounce, Cont}) when is_function(Cont, 0) ->
+    trampoline(Cont());
+trampoline(Res) ->
+    Res.
+-define(BOUNCE(X), {bounce, fun() -> X end}).
+
 %% Apply a parser to its continuation. This compiles a parser to its low-level representation.
 -spec apply_p(parser(A), fun((A) -> parser1(B))) -> parser1(B).
 apply_p(?lazy(F), K)           -> apply_p(F(), K);
 apply_p(?fail(Err), _)         -> {fail, Err};
-apply_p(?choice([P | Ps]), K)  -> lists:foldl(fun(Q, R) -> choice1(apply_p(Q, K), R) end,
-                                             apply_p(P, K), Ps);
+apply_p(?choice([P | Ps]), K)  -> lists:foldl(fun(Q, R) -> choice1(trampoline(apply_p(Q, K)), R) end,
+                                              trampoline(apply_p(P, K)), Ps);
 apply_p(?bind(P, F), K)        -> apply_p(P, fun(X) -> apply_p(F(X), K) end);
 apply_p(?right(P, Q), K)       -> apply_p(P, fun(_) -> apply_p(Q, K) end);
 apply_p(?left(P, Q), K)        -> apply_p(P, fun(X) -> apply_p(Q, fun(_) -> K(X) end) end);
 apply_p(?map(F, P), K)         -> apply_p(P, fun(X) -> K(F(X)) end);
 apply_p(?layout, K)            -> {layout, K, {fail, {expected, layout_block}}};
 apply_p(?tok(Atom), K)         -> {tok_bind, #{Atom => K}};
-apply_p(?return(X), K)         -> K(X);
+apply_p(?return(X), K)         -> ?BOUNCE(K(X));
 apply_p([P | Q], K)            -> apply_p(P, fun(H) -> apply_p(Q, fun(T) -> K([H | T]) end) end);
 apply_p(T, K) when is_tuple(T) -> apply_p(tuple_to_list(T), fun(Xs) -> K(list_to_tuple(Xs)) end);
 apply_p(M, K) when is_map(M) ->
    {Keys, Ps} = lists:unzip(maps:to_list(M)),
    apply_p(Ps, fun(Vals) -> K(maps:from_list(lists:zip(Keys, Vals))) end);
-apply_p(X, K) -> K(X).
+apply_p(X, K) -> ?BOUNCE(K(X)).

 %% -- Primitive combinators --------------------------------------------------

@@ -160,7 +166,7 @@ layout() -> ?layout.
 %% @doc Parse a sequence of tokens using a parser. Fails if the parse is ambiguous.
 -spec parse(parser(A), tokens()) -> {ok, A} | {error, term()}.
 parse(P, S) ->
-  case parse1(apply_p(P, fun(X) -> {return_plus, X, {fail, no_error}} end), S) of
+  case parse1(trampoline(apply_p(P, fun(X) -> {return_plus, X, {fail, no_error}} end)), S) of
    {[], {Pos, Err}} -> {error, {add_current_file(Pos), parse_error, flatten_error(Err)}};
    {[A], _}         -> {ok, A};
    {As, _}          -> {error, {{1, 1}, ambiguous_parse, As}}
@@ -241,7 +247,7 @@ col(T)  when is_tuple(T) -> element(2, pos(T)).

 %% If both parsers want the next token we grab it and merge the continuations.
 choice1({tok_bind, Map1}, {tok_bind, Map2}) ->
-    {tok_bind, merge_with(fun(F, G) -> fun(T) -> choice1(F(T), G(T)) end end, Map1, Map2)};
+    {tok_bind, merge_with(fun(F, G) -> fun(T) -> choice1(trampoline(F(T)), trampoline(G(T))) end end, Map1, Map2)};

 %% If both parsers fail we combine the error messages. If only one fails we discard it.
 choice1({fail, E1}, {fail, E2})             -> {fail, add_error(E1, E2)};
@@ -255,7 +261,7 @@ choice1(P, {return_plus, X, Q})             -> {return_plus, X, choice1(P, Q)};
 %% If both sides want a layout block we combine them. If only one side wants a layout block we
 %% will commit to a layout block is there is one.
 choice1({layout, F, P}, {layout, G, Q})     ->
-    {layout, fun(N) -> choice1(F(N), G(N)) end, choice1(P, Q)};
+    {layout, fun(N) -> choice1(trampoline(F(N)), trampoline(G(N))) end, choice1(P, Q)};
 choice1({layout, F, P}, Q)                  -> {layout, F, choice1(P, Q)};
 choice1(P, {layout, G, Q})                  -> {layout, G, choice1(P, Q)}.

@@ -278,6 +284,8 @@ parse1(P, S) ->
 %% The main work horse. Returns a list of possible parses and an error message in case parsing
 %% fails.
 -spec parse1(parser1(A), #ts{}, [A], term()) -> {[A], error()}.
+parse1({bounce, F}, Ts, Acc, Err) ->
+    parse1(F(), Ts, Acc, Err);
 parse1({tok_bind, Map}, Ts, Acc, Err) ->
    case next_token(Ts) of
        {T, Ts1} ->
@@ -93,8 +93,20 @@ decl() ->
    ?LAZY_P(
    choice(
      %% Contract declaration
-    [ ?RULE(keyword(contract),  con(), tok('='), maybe_block(decl()), {contract, _1, _2, _4})
-    , ?RULE(token(payable),     keyword(contract), con(), tok('='), maybe_block(decl()), add_modifiers([_1], {contract, _2, _3, _5}))
+    [ ?RULE(token(main), keyword(contract),
+            con(), tok('='), maybe_block(decl()), {contract_main, _2, _3, _5})
+    , ?RULE(keyword(contract),
+            con(), tok('='), maybe_block(decl()), {contract_child, _1, _2, _4})
+    , ?RULE(keyword(contract), token(interface),
+            con(), tok('='), maybe_block(decl()), {contract_interface, _1, _3, _5})
+    , ?RULE(token(payable), token(main), keyword(contract),
+            con(), tok('='), maybe_block(decl()), add_modifiers([_1], {contract_main, _3, _4, _6}))
+    , ?RULE(token(payable), keyword(contract),
+            con(), tok('='), maybe_block(decl()), add_modifiers([_1], {contract_child, _2, _3, _5}))
+    , ?RULE(token(payable), keyword(contract), token(interface),
+            con(), tok('='), maybe_block(decl()), add_modifiers([_1], {contract_interface, _2, _4, _6}))
+
+
    , ?RULE(keyword(namespace), con(), tok('='), maybe_block(decl()), {namespace, _1, _2, _4})
    , ?RULE(keyword(include),   str(), {include, get_ann(_1), _2})
    , pragma()
@@ -13,6 +13,8 @@

 -export_type([options/0]).

+-include("aeso_utils.hrl").
+
 -type doc() :: prettypr:document().
 -type options() :: [{indent, non_neg_integer()} | show_generated].

@@ -131,6 +133,10 @@ typed(A, Type) ->
        false -> follow(hsep(A, text(":")), type(Type))
    end.

+contract_head(contract_main)      -> text("main contract");
+contract_head(contract_child)     -> text("contract");
+contract_head(contract_interface) -> text("contract interface").
+
 %% -- Exports ----------------------------------------------------------------

 -spec decls([aeso_syntax:decl()], options()) -> doc().
@@ -145,11 +151,11 @@ decl(D, Options) ->
    with_options(Options, fun() -> decl(D) end).

 -spec decl(aeso_syntax:decl()) -> doc().
-decl({contract, Attrs, C, Ds}) ->
+decl({Con, Attrs, C, Ds}) when ?IS_CONTRACT_HEAD(Con) ->
    Mod = fun({Mod, true}) when Mod == payable ->
                  text(atom_to_list(Mod));
             (_) -> empty() end,
-    block(follow( hsep(lists:map(Mod, Attrs) ++ [text("contract")])
+    block(follow( hsep(lists:map(Mod, Attrs) ++ [contract_head(Con)])
                , hsep(name(C), text("="))), decls(Ds));
 decl({namespace, _, C, Ds}) ->
    block(follow(text("namespace"), hsep(name(C), text("="))), decls(Ds));
@@ -264,6 +270,8 @@ type({args_t, _, Args}) ->
 type({bytes_t, _, any}) -> text("bytes(_)");
 type({bytes_t, _, Len}) ->
    text(lists:concat(["bytes(", Len, ")"]));
+type({if_t, _, Id, Then, Else}) ->
+    beside(text("if"), args_type([Id, Then, Else]));
 type({named_arg_t, _, Name, Type, _Default}) ->
    %% Drop the default value
    %% follow(hsep(typed(name(Name), Type), text("=")), expr(Default));
@@ -290,12 +298,9 @@ tuple_type(Factors) ->
      , text(")")
      ]).

-spec arg_expr(aeso_syntax:arg_expr()) -> doc().
-arg_expr({named_arg, _, Name, E}) ->
-    follow(hsep(expr(Name), text("=")), expr(E));
-arg_expr(E) -> expr(E).
-
-spec expr_p(integer(), aeso_syntax:expr()) -> doc().
+-spec expr_p(integer(), aeso_syntax:arg_expr()) -> doc().
+expr_p(P, {named_arg, _, Name, E}) ->
+    paren(P > 100, follow(hsep(expr(Name), text("=")), expr(E)));
 expr_p(P, {lam, _, Args, E}) ->
    paren(P > 100, follow(hsep(args(Args), text("=>")), expr_p(100, E)));
 expr_p(P, If = {'if', Ann, Cond, Then, Else}) ->
@@ -377,8 +382,13 @@ expr_p(_, {char, _, C}) ->
    case C of
        $' -> text("'\\''");
        $" -> text("'\"'");
-        _  -> S = lists:flatten(io_lib:format("~p", [[C]])),
-              text("'" ++ tl(lists:droplast(S)) ++ "'")
+        _ when C < 16#80 ->
+            S = lists:flatten(io_lib:format("~p", [[C]])),
+            text("'" ++ tl(lists:droplast(S)) ++ "'");
+        _  ->
+            S = lists:flatten(
+                  io_lib:format("'~ts'", [list_to_binary(aeso_scan:utf8_encode([C]))])),
+            text(S)
    end;
 %% -- Names
 expr_p(_, E = {id, _, _})   -> name(E);
@@ -450,7 +460,7 @@ prefix(P, Op, A) ->
 app(P, F, Args) ->
    paren(P > 900,
    beside(expr_p(900, F),
-           tuple(lists:map(fun arg_expr/1, Args)))).
+           tuple(lists:map(fun expr/1, Args)))).

 field({field, _, LV, E}) ->
    follow(hsep(lvalue(LV), text("=")), expr(E));
@@ -7,7 +7,7 @@
 %%%-------------------------------------------------------------------
 -module(aeso_scan).

-export([scan/1]).
+-export([scan/1, utf8_encode/1]).

 -import(aeso_scan_lib, [token/1, token/2, symbol/0, skip/0,
                        override/2, push/2, pop/1]).
@@ -28,7 +28,13 @@ lexer() ->
    QID      = ["(", CON, "\\.)+", ID],
    QCON     = ["(", CON, "\\.)+", CON],
    OP       = "[=!<>+\\-*/:&|?~@^]+",
-    CHAR     = "'([^'\\\\]|(\\\\.))'",
+    %% Five cases for a character
+    %%  * 1 7-bit ascii, not \ or '
+    %%  * 2-4 8-bit values (UTF8)
+    %%  * \ followed by a known modifier [aernrtv]
+    %%  * \xhh
+    %%  * \x{hhh...}
+    CHAR     = "'(([\\x00-\\x26\\x28-\\x5b\\x5d-\\x7f])|([\\x00-\\xff][\\x80-\\xff]{1,3})|(\\\\[befnrtv'\\\\])|(\\\\x[0-9a-fA-F]{2,2})|(\\\\x\\{[0-9a-fA-F]*\\}))'",
    STRING   = "\"([^\"\\\\]|(\\\\.))*\"",

    CommentStart = {"/\\*", push(comment, skip())},
@@ -38,7 +44,9 @@ lexer() ->
        , {"[^/*]+|[/*]", skip()} ],

    Keywords = ["contract", "include", "let", "switch", "type", "record", "datatype", "if", "elif", "else", "function",
-                "stateful", "payable", "true", "false", "mod", "public", "entrypoint", "private", "indexed", "namespace"],
+                "stateful", "payable", "true", "false", "mod", "public", "entrypoint", "private", "indexed", "namespace",
+                "interface", "main"
+               ],
    KW = string:join(Keywords, "|"),

    Rules =
@@ -77,34 +85,34 @@ scan(String) ->
 %% -- Helpers ----------------------------------------------------------------

 parse_string([$" | Chars]) ->
-    unescape(Chars).
+    unicode:characters_to_nfc_binary(unescape(Chars)).

-parse_char([$', $\\, Code, $']) ->
-    case Code of
-        $'  -> $';
-        $\\ -> $\\;
-        $b  -> $\b;
-        $e  -> $\e;
-        $f  -> $\f;
-        $n  -> $\n;
-        $r  -> $\r;
-        $t  -> $\t;
-        $v  -> $\v;
-        _   -> {error, "Bad control sequence: \\" ++ [Code]}
-    end;
-parse_char([$', C, $']) -> C.
+parse_char([$' | Chars]) ->
+    case unicode:characters_to_nfc_list(unescape($', Chars, [])) of
+        [Char] -> Char;
+        _Bad   -> {error, "Bad character literal: '" ++ Chars}
+    end.

-unescape(Str) -> unescape(Str, []).
+utf8_encode(Cs) ->
+    binary_to_list(unicode:characters_to_binary(Cs)).

-unescape([$"], Acc) ->
+unescape(Str) -> unescape($", Str, []).
+
+unescape(Delim, [Delim], Acc) ->
    list_to_binary(lists:reverse(Acc));
-unescape([$\\, $x, D1, D2 | Chars ], Acc) ->
+unescape(Delim, [$\\, $x, ${ | Chars ], Acc) ->
+    {Ds, [_ | Cs]} = lists:splitwith(fun($}) -> false ; (_) -> true end, Chars),
+    C = list_to_integer(Ds, 16),
+    Utf8Cs = binary_to_list(unicode:characters_to_binary([C])),
+    unescape(Delim, Cs, [Utf8Cs | Acc]);
+unescape(Delim, [$\\, $x, D1, D2 | Chars ], Acc) ->
    C = list_to_integer([D1, D2], 16),
-    unescape(Chars, [C | Acc]);
-unescape([$\\, Code | Chars], Acc) ->
-    Ok = fun(C) -> unescape(Chars, [C | Acc]) end,
+    Utf8Cs = binary_to_list(unicode:characters_to_binary([C])),
+    unescape(Delim, Chars, [Utf8Cs | Acc]);
+unescape(Delim, [$\\, Code | Chars], Acc) ->
+    Ok = fun(C) -> unescape(Delim, Chars, [C | Acc]) end,
    case Code of
-        $"  -> Ok($");
+        Delim -> Ok(Delim);
        $\\ -> Ok($\\);
        $b  -> Ok($\b);
        $e  -> Ok($\e);
@@ -115,8 +123,8 @@ unescape([$\\, Code | Chars], Acc) ->
        $v  -> Ok($\v);
        _   -> error("Bad control sequence: \\" ++ [Code])  %% TODO
    end;
-unescape([C | Chars], Acc) ->
-    unescape(Chars, [C | Acc]).
+unescape(Delim, [C | Chars], Acc) ->
+    unescape(Delim, Chars, [C | Acc]).

 strip_underscores(S) ->
    lists:filter(fun(C) -> C /= $_ end, S).
@@ -25,7 +25,8 @@
 -type ann_origin() :: system | user.
 -type ann_format() :: '?:' | hex | infix | prefix | elif.

-type ann() :: [{line, ann_line()} | {col, ann_col()} | {format, ann_format()} | {origin, ann_origin()} | stateful | private].
+-type ann() :: [ {line, ann_line()} | {col, ann_col()} | {format, ann_format()} | {origin, ann_origin()}
+               | stateful | private | payable | main | interface].

 -type name() :: string().
 -type id()   :: {id,   ann(), name()}.
@@ -34,7 +35,9 @@
 -type qcon() :: {qcon, ann(), [name()]}.
 -type tvar() :: {tvar, ann(), name()}.

-type decl() :: {contract, ann(), con(), [decl()]}
+-type decl() :: {contract_main, ann(), con(), [decl()]}
+              | {contract_child, ann(), con(), [decl()]}
+              | {contract_interface, ann(), con(), [decl()]}
              | {namespace, ann(), con(), [decl()]}
              | {pragma, ann(), pragma()}
              | {type_decl, ann(), id(), [tvar()]} % Only for error msgs
@@ -0,0 +1,6 @@
+-define(IS_CONTRACT_HEAD(X),
+        (X =:= contract_main orelse
+         X =:= contract_interface orelse
+         X =:= contract_child
+        )
+       ).
@@ -1,6 +1,6 @@
 {application, aesophia,
- [{description, "Contract Language for aeternity"},
-  {vsn, "4.3.0"},
+ [{description, "Compiler for Aeternity Sophia language"},
+  {vsn, "6.0.2"},
  {registered, []},
  {applications,
   [kernel,
@@ -190,7 +190,7 @@ parameterized_contract(ExtraCode, FunName, Types) ->
    lists:flatten(
        ["contract Remote =\n"
         "  entrypoint bla : () => unit\n\n"
-         "contract Dummy =\n",
+         "main contract Dummy =\n",
         ExtraCode, "\n",
         "  type an_alias('a) = string * 'a\n"
         "  record r = {x : an_alias(int), y : variant}\n"
@@ -22,7 +22,8 @@ test_cases(1) ->
    MapACI = #{contract =>
 		   #{name => <<"C">>,
 		     type_defs => [],
-                     payable => true,
+         payable => true,
+         kind => contract_main,
 		     functions =>
 			 [#{name => <<"a">>,
 			    arguments =>
@@ -31,56 +32,57 @@ test_cases(1) ->
 			    returns => <<"int">>,
 			    stateful => true,
                            payable  => true}]}},
-    DecACI = <<"payable contract C =\n"
+    DecACI = <<"payable main contract C =\n"
 	       "  payable entrypoint a : (int) => int\n">>,
    {Contract,MapACI,DecACI};

 test_cases(2) ->
-    Contract = <<"contract C =\n"
+    Contract = <<"main contract C =\n"
 		 "  type allan = int\n"
 		 "  entrypoint a(i : allan) = i+1\n">>,
    MapACI = #{contract =>
-                       #{name => <<"C">>, payable => false,
-                         type_defs =>
-                             [#{name => <<"allan">>,
-                                typedef => <<"int">>,
-                                vars => []}],
-			 functions =>
-                             [#{arguments =>
-                                    [#{name => <<"i">>,
-                                       type => <<"C.allan">>}],
-                                name => <<"a">>,
-                                returns => <<"int">>,
-                                stateful => false,
-                                payable  => false}]}},
-    DecACI = <<"contract C =\n"
+                   #{name => <<"C">>, payable => false,
+                     kind => contract_main,
+                     type_defs =>
+                         [#{name => <<"allan">>,
+                            typedef => <<"int">>,
+                            vars => []}],
+                     functions =>
+                         [#{arguments =>
+                                [#{name => <<"i">>,
+                                   type => <<"C.allan">>}],
+                            name => <<"a">>,
+                            returns => <<"int">>,
+                            stateful => false,
+                            payable  => false}]}},
+    DecACI = <<"main contract C =\n"
               "  type allan = int\n"
               "  entrypoint a : (C.allan) => int\n">>,
    {Contract,MapACI,DecACI};
 test_cases(3) ->
-    Contract = <<"contract C =\n"
+    Contract = <<"main contract C =\n"
                 "  type state = unit\n"
                 "  datatype event = SingleEventDefined\n"
-		 "  datatype bert('a) = Bin('a)\n"
-		 "  entrypoint a(i : bert(string)) = 1\n">>,
+                 "  datatype bert('a) = Bin('a)\n"
+                 "  entrypoint a(i : bert(string)) = 1\n">>,
    MapACI = #{contract =>
 		   #{functions =>
-			 [#{arguments =>
-				[#{name => <<"i">>,
-				   type =>
-				       #{<<"C.bert">> => [<<"string">>]}}],
-			    name => <<"a">>,returns => <<"int">>,
-			    stateful => false, payable  => false}],
-		     name => <<"C">>, payable => false,
-                     event => #{variant => [#{<<"SingleEventDefined">> => []}]},
-                     state => <<"unit">>,
+             [#{arguments =>
+                    [#{name => <<"i">>,
+                       type =>
+                           #{<<"C.bert">> => [<<"string">>]}}],
+                name => <<"a">>,returns => <<"int">>,
+                stateful => false, payable  => false}],
+		     name => <<"C">>, payable => false, kind => contract_main,
+         event => #{variant => [#{<<"SingleEventDefined">> => []}]},
+         state => <<"unit">>,
 		     type_defs =>
-			 [#{name => <<"bert">>,
-			    typedef =>
-				#{variant =>
-				      [#{<<"Bin">> => [<<"'a">>]}]},
-			    vars => [#{name => <<"'a">>}]}]}},
-    DecACI = <<"contract C =\n"
+             [#{name => <<"bert">>,
+                typedef =>
+                    #{variant =>
+                          [#{<<"Bin">> => [<<"'a">>]}]},
+                vars => [#{name => <<"'a">>}]}]}},
+    DecACI = <<"main contract C =\n"
               "  type state = unit\n"
               "  datatype event = SingleEventDefined\n"
               "  datatype bert('a) = Bin('a)\n"
@@ -101,17 +103,24 @@ aci_test_contract(Name) ->
                 true  -> [debug_mode];
                 false -> []
             end ++ [{include, {file_system, [aeso_test_utils:contract_path()]}}],
-    {ok, JSON} = aeso_aci:contract_interface(json, String, Opts),
-    {ok, #{aci := JSON1}} = aeso_compiler:from_string(String, [{aci, json}, {backend, fate} | Opts]),
-    ?assertEqual(JSON, JSON1),
+    JSON = case aeso_aci:contract_interface(json, String, Opts) of
+               {ok, J} -> J;
+               {error, ErrorStringJ} when is_binary(ErrorStringJ) -> error(ErrorStringJ);
+               {error, ErrorJ} -> aeso_compiler_tests:print_and_throw(ErrorJ)
+           end,
+    case aeso_compiler:from_string(String, [{aci, json}, {backend, fate} | Opts]) of
+        {ok, #{aci := JSON1}} ->
+            ?assertEqual(JSON, JSON1),
+            io:format("JSON:\n~p\n", [JSON]),
+            {ok, ContractStub} = aeso_aci:render_aci_json(JSON),

-    io:format("JSON:\n~p\n", [JSON]),
-    {ok, ContractStub} = aeso_aci:render_aci_json(JSON),
+            io:format("STUB:\n~s\n", [ContractStub]),
+            check_stub(ContractStub, [{src_file, Name}]),

-    io:format("STUB:\n~s\n", [ContractStub]),
-    check_stub(ContractStub, [{src_file, Name}]),
-
-    ok.
+            ok;
+        {error, ErrorString} when is_binary(ErrorString) -> error(ErrorString);
+        {error, Error} -> aeso_compiler_tests:print_and_throw(Error)
+    end.

 check_stub(Stub, Options) ->
    try aeso_parser:string(binary_to_list(Stub), Options) of
@@ -59,8 +59,8 @@ calldata_aci_test_() ->
        end} || {ContractName, Fun, Args} <- compilable_contracts()].

 parse_args(Fun, Args) ->
-    [{contract, _, _, [{letfun, _, _, _, _, {app, _, _, AST}}]}] =
-        aeso_parser:string("contract Temp = function foo() = " ++ Fun ++ "(" ++ string:join(Args, ", ") ++ ")"),
+    [{contract_main, _, _, [{letfun, _, _, _, _, {app, _, _, AST}}]}] =
+        aeso_parser:string("main contract Temp = function foo() = " ++ Fun ++ "(" ++ string:join(Args, ", ") ++ ")"),
    strip_ann(AST).

 strip_ann(T) when is_tuple(T) ->
@@ -143,4 +143,4 @@ compilable_contracts() ->
 not_yet_compilable(fate) ->
    [];
 not_yet_compilable(aevm) ->
-    [].
+    ["funargs", "strings"].
@@ -34,9 +34,7 @@ simple_compile_test_() ->
               #{fate_code := Code} when Backend == fate ->
                   Code1 = aeb_fate_code:deserialize(aeb_fate_code:serialize(Code)),
                   ?assertMatch({X, X}, {Code1, Code});
-               ErrBin ->
-                   io:format("\n~s", [ErrBin]),
-                   error(ErrBin)
+               Error -> io:format("\n\n~p\n\n", [Error]), print_and_throw(Error)
           end
       end} || ContractName <- compilable_contracts(), Backend <- [aevm, fate],
               not lists:member(ContractName, not_compilable_on(Backend))] ++
@@ -92,6 +90,23 @@ simple_compile_test_() ->
       end} || Backend <- [aevm, fate] ] ++
    [].

+%% Check if all modules in the standard library compile
+stdlib_test_() ->
+    {ok, Files} = file:list_dir(aeso_stdlib:stdlib_include_path()),
+    [ { "Testing " ++ File ++ " from the stdlib",
+      fun() ->
+          String = "include \"" ++ File ++ "\"\nmain contract Test =\n  entrypoint f(x) = x",
+          Options = [{src_file, File}, {backend, fate}],
+          case aeso_compiler:from_string(String, Options) of
+              {ok, #{fate_code := Code}} ->
+                  Code1 = aeb_fate_code:deserialize(aeb_fate_code:serialize(Code)),
+                  ?assertMatch({X, X}, {Code1, Code});
+              {error, Error} -> io:format("\n\n~p\n\n", [Error]), print_and_throw(Error)
+          end
+      end} || File <- Files,
+              lists:suffix(".aes", File)
+    ].
+
 check_errors(no_error, Actual) -> ?assertMatch(#{}, Actual);
 check_errors(Expect, #{}) ->
    ?assertEqual({error, Expect}, ok);
@@ -154,6 +169,7 @@ compilable_contracts() ->
     "events",
     "include",
     "basic_auth",
+     "basic_auth_tx",
     "bitcoin_auth",
     "address_literals",
     "bytes_equality",
@@ -162,6 +178,7 @@ compilable_contracts() ->
     "bytes_to_x",
     "bytes_concat",
     "aens",
+     "aens_update",
     "tuple_match",
     "cyclic_include",
     "stdlib_include",
@@ -171,18 +188,23 @@ compilable_contracts() ->
     "payable",
     "unapplied_builtins",
     "underscore_number_literals",
+     "pairing_crypto",
     "qualified_constructor",
     "let_patterns",
     "lhs_matching",
-     "hermetization_turnoff"
+     "more_strings",
+     "protected_call",
+     "hermetization_turnoff",
+     "multiple_contracts",
+     "clone",
+     "clone_simple",
+     "create",
+     "child_contract_init_bug",
+     "test" % Custom general-purpose test file. Keep it last on the list.
    ].

 not_compilable_on(fate) -> [];
-not_compilable_on(aevm) ->
-    ["stdlib_include",
-     "manual_stdlib_include",
-     "hermetization_turnoff"
-    ].
+not_compilable_on(aevm) -> compilable_contracts().

 debug_mode_contracts() ->
    ["hermetization_turnoff"].
@@ -387,10 +409,10 @@ failing_contracts() ->
        [<<?Pos(12, 42)
           "Cannot unify int\n"
           "         and string\n"
-           "when checking the record projection at line 12, column 42\n"
-           "  r.foo : (gas : int, value : int) => Remote.themap\n"
+           "when checking the type of the expression at line 12, column 42\n"
+           "  r.foo() : map(int, string)\n"
           "against the expected type\n"
-           "  (gas : int, value : int) => map(string, int)">>])
+           "  map(string, int)">>])
    , ?TYPE_ERROR(not_toplevel_include,
                  [<<?Pos(2, 11)
                     "Include of 'included.aes' at line 2, column 11\nnot allowed, include only allowed at top level.">>])
@@ -555,11 +577,15 @@ failing_contracts() ->
         "Cannot unify int\n         and string\nwhen checking the type of the pattern at line 2, column 53\n  x : int\nagainst the expected type\n  string">>
      ])
    , ?TYPE_ERROR(map_as_map_key,
-       [<<?Pos(5, 25)
+       [<<?Pos(5, 47)
         "Invalid key type\n"
         "  map(int, int)\n"
         "Map keys cannot contain other maps.">>,
-        <<?Pos(6, 25)
+        <<?Pos(6, 31)
+         "Invalid key type\n"
+         "  list(map(int, int))\n"
+         "Map keys cannot contain other maps.">>,
+        <<?Pos(6, 31)
         "Invalid key type\n"
         "  lm\n"
         "Map keys cannot contain other maps.">>])
@@ -624,9 +650,9 @@ failing_contracts() ->
         <<?Pos(2, 1)
           "Cannot compile with this version of the compiler,\n"
           "because it does not satisfy the constraint ", Version/binary, " == 9.9.9">>])
-    , ?TYPE_ERROR(multiple_contracts,
+    , ?TYPE_ERROR(interface_with_defs,
         [<<?Pos(2, 3)
-            "Only the main contract can contain defined functions or entrypoints.\n"
+            "Contract interfaces cannot contain defined functions or entrypoints.\n"
            "Fix: replace the definition of 'foo' by a type signature.">>])
    , ?TYPE_ERROR(contract_as_namespace,
         [<<?Pos(5, 28)
@@ -681,6 +707,12 @@ failing_contracts() ->
           "Empty record/map update\n"
           "  r {}">>
        ])
+    , ?TYPE_ERROR(bad_protected_call,
+        [<<?Pos(6, 22)
+           "Invalid 'protected' argument\n"
+           "  (0 : int) == (1 : int) : bool\n"
+           "It must be either 'true' or 'false'.">>
+        ])
    , ?TYPE_ERROR(bad_function_block,
                  [<<?Pos(4, 5)
                     "Mismatch in the function block. Expected implementation/type declaration of g function">>,
@@ -716,6 +748,39 @@ failing_contracts() ->
    , ?TYPE_ERROR(bad_state,
                  [<<?Pos(4, 16)
                     "Conflicting updates for field 'foo'">>])
+    , ?TYPE_ERROR(factories_type_errors,
+                  [<<?Pos(10,18)
+                    "Chain.clone requires `ref` named argument of contract type.">>,
+                   <<?Pos(11,18)
+                     "Cannot unify (gas : int, value : int, protected : bool) => if(protected, option(void), void)\n         and (gas : int, value : int, protected : bool, int, bool) => 'b\n"
+                     "when checking contract construction of type\n  (gas : int, value : int, protected : bool) =>\n    if(protected, option(void), void) (at line 11, column 18)\nagainst the expected type\n  (gas : int, value : int, protected : bool, int, bool) => 'b">>,
+                   <<?Pos(12,37)
+                     "Cannot unify int\n         and bool\n"
+                     "when checking named argument\n  gas : int\nagainst inferred type\n  bool">>,
+                   <<?Pos(13,18),
+                     "Kaboom is not implemented.\n"
+                     "when resolving arguments of variadic function\n  Chain.create">>,
+                   <<?Pos(18,18)
+                     "Cannot unify (gas : int, value : int, protected : bool, int, bool) => if(protected, option(void), void)\n         and (gas : int, value : int, protected : bool) => 'a\n"
+                     "when checking contract construction of type\n  (gas : int, value : int, protected : bool, int, bool) =>\n    if(protected, option(void), void) (at line 18, column 18)\nagainst the expected type\n  (gas : int, value : int, protected : bool) => 'a">>,
+                   <<?Pos(19,42),
+                     "Named argument protected (at line 19, column 42) is not one of the expected named arguments\n  - value : int">>,
+                   <<?Pos(20,42),
+                     "Cannot unify int\n         and bool\n"
+                     "when checking named argument\n  value : int\nagainst inferred type\n  bool">>
+                  ])
+    , ?TYPE_ERROR(ambiguous_main,
+                  [<<?Pos(1,1)
+                    "Could not deduce the main contract. You can point it out manually with the `main` keyword.">>
+                  ])
+    , ?TYPE_ERROR(no_main_contract,
+                  [<<?Pos(0,0)
+                     "No contract defined.">>
+                  ])
+    , ?TYPE_ERROR(multiple_main_contracts,
+                   [<<?Pos(1,6)
+                      "Only one main contract can be defined.">>
+                   ])
    ].

 -define(Path(File), "code_errors/" ??File).
@@ -729,9 +794,7 @@ failing_contracts() ->
                       {fate, ?Msg(File, Line, Col, ErrFATE)}]}).

 failing_code_gen_contracts() ->
-    [ ?SAME(last_declaration_must_be_contract, 1, 1,
-            "Expected a contract as the last declaration instead of the namespace 'LastDeclarationIsNotAContract'")
-    , ?SAME(missing_definition, 2, 14,
+    [ ?SAME(missing_definition, 2, 14,
            "Missing definition of function 'foo'.")
    , ?AEVM(polymorphic_entrypoint, 2, 17,
            "The argument\n"
@@ -829,6 +892,8 @@ failing_code_gen_contracts() ->
            "Invalid state type\n"
            "  {f : (int) => int}\n"
            "The state cannot contain functions in the AEVM. Use FATE if you need this.")
+    , ?FATE(child_with_decls, 2, 14,
+            "Missing definition of function 'f'.")
    ].

 validation_test_() ->
@@ -866,14 +931,26 @@ validation_fails() ->
         "Byte code contract is not payable, but source code contract is.">>]}].

 validate(Contract1, Contract2) ->
-    ByteCode = #{ fate_code := FCode } = compile(fate, Contract1),
-    FCode1   = aeb_fate_code:serialize(aeb_fate_code:strip_init_function(FCode)),
-    Source   = aeso_test_utils:read_contract(Contract2),
-    aeso_compiler:validate_byte_code(
-      ByteCode#{ byte_code := FCode1 }, Source,
-      case lists:member(Contract2, debug_mode_contracts()) of
-          true  -> [debug_mode];
-          false -> []
-      end ++
-      [{backend, fate}, {include, {file_system, [aeso_test_utils:contract_path()]}}]).
+    case compile(fate, Contract1) of
+        ByteCode = #{ fate_code := FCode } ->
+            FCode1   = aeb_fate_code:serialize(aeb_fate_code:strip_init_function(FCode)),
+            Source   = aeso_test_utils:read_contract(Contract2),
+            aeso_compiler:validate_byte_code(
+              ByteCode#{ byte_code := FCode1 }, Source,
+              case lists:member(Contract2, debug_mode_contracts()) of
+                  true  -> [debug_mode];
+                  false -> []
+              end ++
+                  [{backend, fate}, {include, {file_system, [aeso_test_utils:contract_path()]}}]);
+        Error -> print_and_throw(Error)
+    end.

+print_and_throw(Err) ->
+    case Err of
+        ErrBin when is_binary(ErrBin) ->
+            io:format("\n~s", [ErrBin]),
+            error(ErrBin);
+        Errors ->
+            io:format("Compilation error:\n~s", [string:join([aeso_errors:pp(E) || E <- Errors], "\n\n")]),
+            error(compilation_error)
+    end.
@@ -12,10 +12,10 @@ simple_contracts_test_() ->
     fun(_) -> ok end,
     [{"Parse a contract with an identity function.",
       fun() ->
-            Text = "contract Identity =\n"
+            Text = "main contract Identity =\n"
                   "  function id(x) = x\n",
            ?assertMatch(
-                [{contract, _, {con, _, "Identity"},
+                [{contract_main, _, {con, _, "Identity"},
                    [{letfun, _, {id, _, "id"}, [{id, _, "x"}], {id, _, "_"},
                        {id, _, "x"}}]}], parse_string(Text)),
            ok
@@ -63,7 +63,8 @@ simple_contracts_test_() ->
     %% Parse tests of example contracts
     [ {lists:concat(["Parse the ", Contract, " contract."]),
        fun() -> roundtrip_contract(Contract) end}
-        || Contract <- [counter, voting, all_syntax, '05_greeter', aeproof, multi_sig, simple_storage, fundme, dutch_auction] ]
+        || Contract <- [counter, voting, all_syntax, '05_greeter', aeproof,
+                        multi_sig, simple_storage, fundme, dutch_auction, utf8] ]
    }.

 parse_contract(Name) ->
@@ -85,7 +86,7 @@ parse_expr(Text) ->
 round_trip(Text) ->
    Contract  = parse_string(Text),
    Text1     = prettypr:format(aeso_pretty:decls(strip_stdlib(Contract))),
-    Contract1 = parse_string(Text1),
+    Contract1 = parse_string(aeso_scan:utf8_encode(Text1)),
    NoSrcLoc  = remove_line_numbers(Contract),
    NoSrcLoc1 = remove_line_numbers(Contract1),
    ?assertMatch(NoSrcLoc, diff(NoSrcLoc, NoSrcLoc1)).
@@ -1,5 +1,5 @@

 contract Identity =
-  function main (x:int) = x
+  function main_fun (x:int) = x

  function __call() = 12
@@ -1,5 +1,5 @@
-contract Remote =
-  entrypoint main : (int) => unit
+contract interface Remote =
+  entrypoint main_fun : (int) => unit

 contract AddrChain =
  type o_type = oracle(string, map(string, int))
@@ -1,5 +1,5 @@

-contract Remote =
+contract interface Remote =
  entrypoint foo : () => unit

 contract AddressLiterals =
@@ -33,7 +33,22 @@ contract AENSTest =
                                sign : signature) : unit =
    AENS.claim(addr, name, salt, name_fee, signature = sign)

-  // TODO: update() -- how to handle pointers?
+
+  stateful entrypoint update(owner      : address,
+                             name       : string,
+                             ttl        : option(Chain.ttl),
+                             client_ttl : option(int),
+                             pointers   : option(map(string, AENS.pointee))) : unit =
+    AENS.update(owner, name, ttl, client_ttl, pointers)
+
+  stateful entrypoint signedUpdate(owner      : address,
+                                   name       : string,
+                                   ttl        : option(Chain.ttl),
+                                   client_ttl : option(int),
+                                   pointers   : option(map(string, AENS.pointee)),
+                                   sign       : signature) : unit =
+    AENS.update(owner, name, ttl, client_ttl, pointers, signature = sign)
+

  stateful entrypoint transfer(owner     : address,
                             new_owner : address,
@@ -0,0 +1,17 @@
+contract AENSUpdate =
+  stateful entrypoint update_name(owner : address, name : string) =
+    let p1 : AENS.pointee = AENS.AccountPt(Call.caller)
+    let p2 : AENS.pointee = AENS.OraclePt(Call.caller)
+    let p3 : AENS.pointee = AENS.ContractPt(Call.caller)
+    let p4 : AENS.pointee = AENS.ChannelPt(Call.caller)
+    AENS.update(owner, name, None, None,
+                Some({ ["account_pubkey"] = p1, ["oracle_pubkey"] = p2,
+                       ["contract_pubkey"] = p3, ["misc"] = p4 }))
+
+  entrypoint get_ttl(name : string) =
+    switch(AENS.lookup(name))
+     Some(AENS.Name(_, FixedTTL(ttl), _)) => ttl
+
+  entrypoint expiry(o : oracle(int, int)) : int =
+    Oracle.expiry(o)
+
@@ -36,6 +36,8 @@ contract AllSyntax =
  entrypoint init() = {
    johann = 1000,
    wolfgang = -10,
+
+/* TODO: This does not compile because of bug in the parser tester.
    von = (2 + 2, 0, List.sum([x | k <- [1,2,3]
                                 , let l = k + 1
                                 , if(l < 10)
@@ -43,11 +45,13 @@ contract AllSyntax =
                                 , Adam <- [Adam, Mickiewicz]
                                 , let x = f(l)
                                 ])),
+*/
+    von = (2 + 2, 0, List.sum([1,2,3,4])),
    goethe = () }

  function f() =
     let kp = "nietzsche"
-     let p = "Пушкин"
+     // let p = "Пушкин" // TODO: this also doesn't do right round_trip...
     let k(x : bytes(8)) : bytes(8) = Bytes.to_int(#fedcba9876543210)

     let f : () => address = () => ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt
@@ -0,0 +1,5 @@
+contract C =
+  entrypoint f() = 123
+
+contract D =
+  entrypoint f() = 123
@@ -1,5 +1,5 @@

-contract Remote =
+contract interface Remote =
  entrypoint foo : () => unit

 contract AddressLiterals =
@@ -0,0 +1,6 @@
+contract interface Remote =
+  entrypoint id : int => int
+
+contract ProtectedCall =
+  entrypoint bad(r : Remote) =
+    r.id(protected = 0 == 1, 18)
@@ -1,3 +1,3 @@
 function square(x) = x ^ 2
 contract Main =
-  entrypoint main() = square(10)
+  entrypoint main_fun() = square(10)
@@ -0,0 +1,74 @@
+// namespace Chain =
+//   record tx = { paying_for : option(Chain.paying_for_tx)
+//               , ga_metas : list(Chain.ga_meta_tx)
+//               , actor : address
+//               , fee   : int
+//               , ttl   : int
+//               , tx    : Chain.base_tx }
+
+//   datatype ga_meta_tx = GAMetaTx(address, int)
+//   datatype paying_for_tx = PayingForTx(address, int)
+//   datatype base_tx = SpendTx(address, int, string)
+//                    | OracleRegisterTx | OracleQueryTx | OracleResponseTx | OracleExtendTx
+//                    | NamePreclaimTx | NameClaimTx(hash) | NameUpdateTx(string)
+//                    | NameRevokeTx(hash) | NameTransferTx(address, string)
+//                    | ChannelCreateTx(address) | ChannelDepositTx(address, int) | ChannelWithdrawTx(address, int) |
+//                    | ChannelForceProgressTx(address) | ChannelCloseMutualTx(address) | ChannelCloseSoloTx(address)
+//                    | ChannelSlashTx(address) | ChannelSettleTx(address) | ChannelSnapshotSoloTx(address)
+//                    | ContractCreateTx(int) | ContractCallTx(address, int)
+//                    | GAAttachTx
+
+
+// Contract replicating "normal" Aeternity authentication
+contract BasicAuthTx =
+  record state = { nonce : int, owner : address }
+  datatype foo = Bar | Baz()
+
+  entrypoint init() = { nonce = 1, owner = Call.caller }
+
+  stateful entrypoint authorize(n : int, s : signature) : bool =
+    require(n >= state.nonce, "Nonce too low")
+    require(n =< state.nonce, "Nonce too high")
+    put(state{ nonce = n + 1 })
+    switch(Auth.tx_hash)
+      None          => abort("Not in Auth context")
+      Some(tx_hash) =>
+        let Some(tx0) = Auth.tx
+        let x : option(Chain.paying_for_tx) = tx0.paying_for
+        let x : list(Chain.ga_meta_tx) = tx0.ga_metas
+        let x : int = tx0.fee + tx0.ttl
+        let x : address = tx0.actor
+        let x : Chain.tx = { tx = Chain.NamePreclaimTx, paying_for = None, ga_metas = [],
+                             fee = 123, ttl = 0, actor = Call.caller }
+        switch(tx0.tx)
+          Chain.SpendTx(receiver, amount, payload) => verify(tx_hash, n, s)
+          Chain.OracleRegisterTx                   => false
+          Chain.OracleQueryTx                      => false
+          Chain.OracleResponseTx                   => false
+          Chain.OracleExtendTx                     => false
+          Chain.NamePreclaimTx                     => false
+          Chain.NameClaimTx(name)                  => false
+          Chain.NameUpdateTx(name)                 => false
+          Chain.NameRevokeTx(name)                 => false
+          Chain.NameTransferTx(to, name)           => false
+          Chain.ChannelCreateTx(other_party)       => false
+          Chain.ChannelDepositTx(channel, amount)  => false
+          Chain.ChannelWithdrawTx(channel, amount) => false
+          Chain.ChannelForceProgressTx(channel)    => false
+          Chain.ChannelCloseMutualTx(channel)      => false
+          Chain.ChannelCloseSoloTx(channel)        => false
+          Chain.ChannelSlashTx(channel)            => false
+          Chain.ChannelSettleTx(channel)           => false
+          Chain.ChannelSnapshotSoloTx(channel)     => false
+          Chain.ContractCreateTx(amount)           => false
+          Chain.ContractCallTx(ct_address, amount) => false
+          Chain.GAAttachTx                         => false
+
+  function verify(tx_hash, n, s) =
+    Crypto.verify_sig(to_sign(tx_hash, n), state.owner, s)
+
+  entrypoint to_sign(h : hash, n : int) =
+    Crypto.blake2b((h, n))
+
+  entrypoint weird_string() : string =
+    "\x19Weird String\x42\nMore\n"
@@ -1,4 +1,4 @@
-
+include "String.aes"
 contract BytesToX =

  entrypoint to_int(b : bytes(42)) : int = Bytes.to_int(b)
@@ -17,7 +17,7 @@ contract ChannelOnChainContractOracle =
      bets     = {}
      }

-  public stateful function place_bet(answer: string) = 
+  public stateful function place_bet(answer: string) =
    switch(Map.lookup(answer, state.bets))
      None =>
        put(state{ bets = state.bets{[answer] = Call.caller}})
@@ -25,6 +25,9 @@ contract ChannelOnChainContractOracle =
      Some(_value) =>
        "bet_already_taken"

+  public function expiry() =
+    Oracle.expiry(state.oracle)
+
  public function query_fee() =
    Oracle.query_fee(state.oracle)

@@ -35,7 +38,7 @@ contract ChannelOnChainContractOracle =
    switch(Oracle.get_answer(state.oracle, q))
      None         =>
        "no response"
-      Some(result) => 
+      Some(result) =>
        if(state.question == Oracle.get_question(state.oracle, q))
            switch(Map.lookup(result, state.bets))
              None         =>
@@ -0,0 +1,8 @@
+contract Identity =
+  record state = {foo: int, bar: string}
+  entrypoint init() = {foo = 0, bar = ""}
+
+main contract IdentityService =
+  stateful entrypoint createNewIdentity() : Identity =
+    put(())
+    Chain.create()
@@ -0,0 +1,28 @@
+
+contract interface HigherOrderState =
+  entrypoint init : () => void
+  entrypoint apply : int => int
+  stateful entrypoint inc : int => unit
+
+contract interface LowerDisorderAnarchy =
+  entrypoint init : (int) => void
+
+
+main contract C =
+  // both `s` and `l` should be of type `HigherOrderState` in this test
+  stateful entrypoint run_clone(s : HigherOrderState, l : LowerDisorderAnarchy) : HigherOrderState =
+    let s1 = Chain.clone(ref=s)
+    let Some(s2) = Chain.clone(ref=s, protected=true)
+    let None = Chain.clone(ref=s, protected=true, gas=1)
+    let None = Chain.clone(ref=l, protected=true, 123) // since it should be HigherOrderState underneath
+    let s3 = Chain.clone(ref=s1)
+    require(s1.apply(2137) == 2137, "APPLY_S1_0")
+    require(s2.apply(2137) == 2137, "APPLY_S2_0")
+    require(s3.apply(2137) == 2137, "APPLY_S3_0")
+    s1.inc(1)
+    s2.inc(1)
+    s1.inc(1)
+    require(s1.apply(2137) == 2139, "APPLY_S1_2")
+    require(s2.apply(2137) == 2138, "APPLY_S2_1")
+    require(s3.apply(2137) == 2137, "APPLY_S3_0")
+    s1
@@ -0,0 +1,7 @@
+contract interface I =
+  entrypoint init : () => void
+
+contract C =
+  stateful entrypoint f(i : I) =
+    let Some(c1) = Chain.clone(ref=i, protected = true)
+    2
@@ -5,5 +5,5 @@ contract BadAENSresolve =
  function fail() : t(int) =
    AENS.resolve("foo.aet", "whatever")

-  entrypoint main() = ()
+  entrypoint main_fun() = ()

@@ -0,0 +1,5 @@
+contract C =
+  entrypoint f : () => unit
+
+main contract M =
+  entrypoint f() = 123
@@ -3,4 +3,4 @@ contract MapAsMapKey =

  function foo(m) : t(int => int) = {[m] = 0}

-  entrypoint main() = ()
+  entrypoint main_fun() = ()
@@ -2,4 +2,4 @@ contract HigherOrderQueryType =
  stateful function foo(o) : oracle_query(_, string ) =
    Oracle.query(o, (x) => x + 1, 100, RelativeTTL(100), RelativeTTL(100))

-  entrypoint main() = ()
+  entrypoint main_fun() = ()
@@ -2,4 +2,4 @@ contract HigherOrderResponseType =
  stateful function foo(o, q : oracle_query(string, _)) =
    Oracle.respond(o, q, (x) => x + 1)

-  entrypoint main() = ()
+  entrypoint main_fun() = ()
@@ -1,2 +0,0 @@
-namespace LastDeclarationIsNotAContract =
-  function add(x, y) = x + y
@@ -1,3 +1,3 @@
 contract MissingDefinition =
  entrypoint foo : int => int
-  entrypoint main() = foo(0)
+  entrypoint main_fun() = foo(0)
@@ -3,5 +3,5 @@ contract PolymorphicAENSresolve =
  function fail() : option('a) =
    AENS.resolve("foo.aet", "whatever")

-  entrypoint main() = ()
+  entrypoint main_fun() = ()

@@ -3,4 +3,4 @@ contract MapAsMapKey =

  function foo(m) : t('a) = {[m] = 0}

-  entrypoint main() = ()
+  entrypoint main_fun() = ()
@@ -2,4 +2,4 @@ contract PolymorphicQueryType =
  stateful function is_oracle(o) =
    Oracle.check(o)

-  entrypoint main() = ()
+  entrypoint main_fun() = ()
@@ -2,4 +2,4 @@ contract PolymorphicResponseType =
  function is_oracle(o : oracle(string, 'r)) =
    Oracle.check(o)

-  entrypoint main(o : oracle(string, int)) = is_oracle(o)
+  entrypoint main_fun(o : oracle(string, int)) = is_oracle(o)
@@ -1,4 +1,4 @@
-contract Remote =
+contract interface Remote =
  entrypoint foo : int => int

 contract UnappliedContractCall =
@@ -1,5 +1,5 @@
 contract UnappliedNamedArgBuiltin =
  // Allowed in FATE, but not AEVM
-  stateful entrypoint main(s) =
+  stateful entrypoint main_fun(s) =
    let reg = Oracle.register
    reg(signature = s, Contract.address, 100, RelativeTTL(100)) : oracle(int, int)
@@ -1,5 +1,5 @@

-contract Remote =
+contract interface Remote =
  entrypoint up_to       : (int)               => list(int)
  entrypoint sum         : (list(int))         => int
  entrypoint some_string : ()                  => string
@@ -1,4 +1,4 @@
-contract Foo =
+contract interface Foo =
  entrypoint foo : () => int

 contract Fail =
@@ -0,0 +1,28 @@
+contract IntegerAdder =
+  entrypoint init() = ()
+  entrypoint addIntegers(x, y) = x + y
+
+contract IntegerAdderHolder =
+  type state = IntegerAdder
+  stateful entrypoint init() = Chain.create() : IntegerAdder
+  entrypoint get() = state
+
+contract IntegerAdderFactory =
+  entrypoint init() = ()
+  stateful entrypoint new() =
+    let i = Chain.create() : IntegerAdderHolder
+    i.get()
+
+payable contract ValueAdder =
+  entrypoint init() = ()
+  stateful entrypoint addValue(x) =
+    let integerAdderFactory = Chain.create()
+    let adder = integerAdderFactory.new()
+    adder.addIntegers(x, Contract.balance)
+
+main contract EnterpriseContract =
+  entrypoint init() = ()
+  stateful payable entrypoint increaseByThree(x) =
+    require(Call.value >= 3, "Price for addition = 3AEtto, insufficient funds")
+    let threeAdder = Chain.create(value = 3)
+    threeAdder.addValue(x)
@@ -1,6 +1,6 @@

 // Testing primitives for accessing the block chain environment
-contract Interface =
+contract interface Interface =
  entrypoint contract_address : () => address
  entrypoint call_origin      : () => address
  entrypoint call_caller      : () => address
@@ -44,6 +44,9 @@ contract Environment =
  // Gas price
  entrypoint call_gas_price() : int = Call.gas_price

+  // Fee
+  entrypoint call_fee() : int = Call.fee
+
  // -- Information about the chain ---

  // Account balances
@@ -1,4 +1,4 @@
-contract Remote =
+contract interface Remote =
  entrypoint dummy : () => unit

 contract Events =
@@ -1,6 +1,6 @@
 // An implementation of the factorial function where each recursive
 // call is to another contract. Not the cheapest way to compute factorial.
-contract FactorialServer =
+contract interface FactorialServer =
  entrypoint fac : (int) => int

 contract Factorial =
@@ -0,0 +1,24 @@
+contract interface Kaboom =
+  entrypoint init : () => void
+
+contract Bakoom =
+  type state = int
+  entrypoint init(x, b) = if(b) x else 0
+
+main contract Test =
+  stateful entrypoint test(k : Kaboom) =
+    let k_bad1 = Chain.clone() : Kaboom
+    let k_bad2 = Chain.clone(ref=k, 123, true)
+    let k_bad3 = Chain.clone(ref=k, gas=true)
+    let k_bad4 = Chain.create() : Kaboom
+    let k_gud1 = Chain.clone(ref=k)
+    let Some(k_gud2) = Chain.clone(ref=k, protected=true)
+    let Some(k_gud3) = Chain.clone(ref=k, value=10, protected=true, gas=123)
+
+    let b_bad1 = Chain.create() : Bakoom
+    let b_bad2 = Chain.create(123, true, protected=true) : Bakoom
+    let b_bad3 = Chain.create(123, true, value=true) : Bakoom
+    let b_gud1 = Chain.create(123, true) : Bakoom
+    let b_gud2 = Chain.create(123, true, value=100) : Bakoom
+
+    b_gud1
@@ -1,4 +1,4 @@
-
+include "String.aes"
 contract FunctionArguments =

  entrypoint sum(n : int, m: int) =
@@ -1,3 +1,2 @@
-
-contract Identity =
-  entrypoint main (x:int) = x
+main contract Identity =
+  entrypoint main_fun (x:int) = x
@@ -0,0 +1,5 @@
+contract interface ContractOne =
+  entrypoint foo() = "foo"
+
+contract ContractTwo =
+  entrypoint bar() = "bar"
@@ -16,7 +16,7 @@ contract LHSMatching =
    let null(_ :: _) = false
    !null(xs)

-  entrypoint main() =
+  entrypoint main_fun() =
    from_some(Some([0]))
      ++ append([length([true]), 2, 3], [4, 5, 6])
      ++ [7 | if (local_match([false]))]
@@ -1,3 +1,3 @@
 contract MissingEventType =
-  entrypoint main() =
+  entrypoint main_fun() =
    Chain.event("MAIN")
@@ -0,0 +1,14 @@
+include "String.aes"
+contract StringX =
+  entrypoint test() =
+    let s1 = "a string"
+    let s2 = "another string"
+    let s  = String.concat(s1, s2)
+    String.sha256(s)
+    String.length(s1)
+    String.from_list(String.to_list(s))
+    String.split(4, s1)
+    String.at(2, s2)
+    String.tokens(s, ",")
+    String.to_upper(s1)
+    String.to_lower(s2)
@@ -1,5 +1,7 @@
-contract ContractOne =
-  entrypoint foo() = "foo"
+contract Child =
+  entrypoint
+        add2 : int => int
+        add2(x) = x + 2

-contract ContractTwo =
-  entrypoint bar() = "bar"
+main contract Main =
+  entrypoint add4(x, c : Child) = c.add2(x) + 2
@@ -0,0 +1,5 @@
+main contract C =
+  entrypoint f() = 123
+
+main contract D =
+  entrypoint f() = 123
@@ -0,0 +1,2 @@
+contract interface C =
+  entrypoint f : () => unit
@@ -1,4 +1,4 @@
-contract C1 =
+contract interface C1 =
  entrypoint f : int

 contract C =
@@ -0,0 +1,30 @@
+include "BLS12_381.aes"
+
+contract GrothVerify =
+  type fr = BLS12_381.fr
+  type g1 = BLS12_381.g1
+  type g2 = BLS12_381.g2
+
+  record proof = { a : g1, b : g2, c : g1 }
+  record verify_key = { a : g1, b : g2, c : g2, d : g2, ic : list(g1) }
+
+  record state = { vk : verify_key }
+
+  entrypoint init(vk0 : verify_key) = {vk = vk0}
+
+  entrypoint verify_proof(p : proof, input : list(fr)) =
+    let vk = state.vk
+    let vk_x = calc_vk_x(vk.ic, input)
+
+    BLS12_381.pairing_check([BLS12_381.g1_neg(p.a), vk.a, vk_x, p.c],
+                            [p.b, vk.b, vk.c, vk.d])
+
+  function calc_vk_x(ics : list(g1), xs : list(fr)) =
+    switch(ics)
+      (ic :: ics) => calc_vk_x_(ic, ics, xs)
+
+  function calc_vk_x_(vk_x : g1, ics : list(g1), xs : list(fr)) =
+    switch((ics, xs))
+      ([], []) => vk_x
+      (ic :: ics, x :: xs) => calc_vk_x_(BLS12_381.g1_add(vk_x, BLS12_381.g1_mul(x, ic)), ics, xs)
+
@@ -0,0 +1,14 @@
+contract interface Remote =
+  entrypoint id : int => int
+
+contract ProtectedCall =
+
+  function higher_order(r : Remote) =
+    r.id
+
+  entrypoint test_ok(r : Remote) =
+    let f = higher_order(r)
+    let Some(n) = r.id(protected = true, 10)
+    let Some(m) = f(protected = true, 5)
+    n + m + r.id(protected = false, 100) + f(1)
+
@@ -1,18 +1,18 @@

-contract Remote1 =
-  entrypoint main : (int) => int
+contract interface Remote1 =
+  entrypoint main_fun : (int) => int

-contract Remote2 =
+contract interface Remote2 =
  entrypoint call : (Remote1, int) => int

-contract Remote3 =
+contract interface Remote3 =
  entrypoint get : () => int
  entrypoint tick : () => unit

 contract RemoteCall =

    stateful entrypoint call(r : Remote1, x : int) : int =
-        r.main(gas = 10000, value = 10, x)
+        r.main_fun(gas = 10000, value = 10, x)

    entrypoint staged_call(r1 : Remote1, r2 : Remote2, x : int) =
        r2.call(r1, x)
@@ -1,5 +1,5 @@

-contract SpendContract =
+contract interface SpendContract =
  entrypoint withdraw : (int) => int

 contract SpendTest =
@@ -1,4 +1,5 @@
-contract Remote =
+include "String.aes"
+contract interface Remote =
  record rstate = { i : int, s : string, m : map(int, int) }

  entrypoint look_at : (rstate) => unit
@@ -1,5 +1,5 @@

-contract Remote =
+contract interface Remote =
  stateful entrypoint remote_spend : (address, int) => unit
  entrypoint remote_pure : int => int

@@ -1,3 +1,4 @@
+include "String.aes"
 contract Strings =
    entrypoint str_len(s) = String.length(s)
    entrypoint str_concat(s1, s2) = String.concat(s1, s2)
@@ -1,102 +1,12 @@
+// This is a custom test file if you need to run a compiler without
+// changing aeso_compiler_tests.erl

-contract Identity =
-  // type xy = {x:int, y:int}
-  // type xz = {x:int, z:int}
-  // type yz = {y:int, z:int}
-  record point = {x:int,y:int}
-  record cp('a) = {color: string, p:'a}
-  //type intpoint = point(int)
-  //   //if (x==42) 1 else (x*x)
-  // }
-  //let baz() = {age:3, name:(4:int)}
-  //let foo(a,b,c) = c
-  // let rec fac(n) = if((n:int)==0) 1 else (n*fac(n-1))
-  //    and main(x) = x::[x+1]
-  // let lentr(l) = lent(0,l)
-  // let rec len(l) =
-  //    switch(l) {
-  //     | [] => 0
-  //     | x::xs => 1+len(xs)
-  //     }
-  // let lent(n,l) =
-  //   switch (l) {
-  //   | [] => n
-  //   | (x::xs) => lent(n+1,xs)
-  //   }
-  //  let rec app(a,b) =
-  //     switch(a) {
-  //     | [] => b
-  //     | (x::xs) => x::app(xs,b)
-  //     }
-  // let rec revt(l,r) =
-  //   switch(l) {
-  //   | [] => r
-  //   | x::xs => revt(xs,x::r)
-  //   }
-  // let rev(l) = revt(l,[])
-  // let main(x:int) = {
-  //   switch(rev([1,2,3])) {
-  //   | h::_ => h
-  //   }
-  //   }
-  //let fac(n:int) = {
-  //  if (n==0) 1 else (n*fac(n-1))
-  //}
-  //let main(x) = switch((12,34)) {
-  //| (13,_) => x
-  //| (_,a) => x+a
-  //    | y => y+1
-  //  }
-  //let main(x) = ({y:0>1, x:x==0}:point(bool))
-  //let main(x) = x
-  //let main(x) = len(1::2::[])
-  //let main(x) = ((x,x):list('a))
-  // let main(x) = switch("a") {
-  //    	  |  "b" => 0
-  // 	  |  "a" => 1
-  // 	  |  "c" => 2
-  // 	  }
-  //let main(x) = x.color+1
-  //let main(x) = switch(({x:x, y:x+1}:cp(int))) {
-  //              | {y:xx} => xx
-  //		}
-  //let main(x) = {x:0, y:1, z:2}
-  // let id(x) = x
-  // let double(x) = x+x
-  // let pair(x) = (1,2)
-  // let unit(x) = ()
-  // let tuples(x) = ((1,x),(2,3,4))
-  // let singleton(x) = [x]
-  // let rec seq(n) = if (n==0) [] else (app(seq(n-1),[n]))
-  // let idString(s:string) = s
-  // let pairString(s:string) = (s,s)
-  // let revStrings(ss:list(string))=rev(ss)
-  // let makePoint(x,y) = {x:x, y:y}
-  // let getx(x) = x.x
-  // let updatex(p,x) = p{x:x}
-  // let quad(x) = {let y=x+x; let z=y+y; z;}
- //  let noblock(x) = {x; x}
- //  let unit(x) = ()
-  // let foo(x) = switch (x) {
-  //     	       | y => y+1
-// 	       }
-  // let p(x) = {color:"blue", p:{x:x, y:x+1}}
-  //let twice(f,x) = f(f(x))
-  // let twice(f,x) = f(f(x))
-  // let double(x) = x+x
-  // let main(x) = twice((y=>y+y),x)
-  // let rec map(f,xs) = switch(xs) {
-  // | [] => []
-  // | (x::ys) => f(x)::map(f,ys)
-  // }
-  // let id(x) = x
-  // let main(xs) = map(double,xs)
-  function z(f,x) = x
-  function s(n) = (f,x)=>f(n(f,x))
-  function add(m,n) = (f,x)=>m(f,n(f,x))
+include "List.aes"

-  entrypoint main() =
-    let three=s(s(s(z)))
-    add(three,three)
-       (((i)=>i+1),0)
+contract IntegerHolder =
+  type state = int
+  entrypoint init(x) = x
+  entrypoint get() = state

+main contract Test =
+  stateful entrypoint f(c) = Chain.clone(ref=c, 123)
@@ -1,5 +1,5 @@

-contract Remote =
+contract interface Remote =

  type themap = map(int, string)
  entrypoint foo : () => themap
@@ -7,8 +7,9 @@
 //    AENS.transfer
 //    AENS.revoke
 //    Oracle.extend
+include "String.aes"
 contract UnappliedBuiltins =
-  entrypoint main() = ()
+  entrypoint main_fun() = ()
  type o = oracle(int, int)
  type t = list(int * string)
  type m = map(int, int)
@@ -21,6 +22,7 @@ contract UnappliedBuiltins =
  function b_abort()                     = abort
  function b_require()                   = require
  function oracle_query_fee()            = Oracle.query_fee
+  function oracle_expiry()               = Oracle.expiry
  stateful function oracle_query()       = Oracle.query        : (o, _, _, _, _) => _
  function oracle_get_question()         = Oracle.get_question : (o, _) => _
  function oracle_get_answer()           = Oracle.get_answer   : (o, _) => _
@@ -0,0 +1,21 @@
+contract UTF8 =
+  entrypoint f1() : char = '1'
+  entrypoint f2() : char = '+'
+  entrypoint f3() : char = 'd'
+  entrypoint f4() : char = 'X'
+  entrypoint f5() : char = 'å'
+  entrypoint f6() : char = 'Ä'
+  entrypoint f7() : char = 'æ'
+  entrypoint f8() : char = 'ë'
+  entrypoint f9() : char = 'ẻ'
+  entrypoint f10() : char = '\x27'
+  entrypoint f11() : char = '\x{2200}'
+  entrypoint f12() : char = '💩'
+  entrypoint f13() : char = '\n'
+
+
+
+  // entrypoint f13() : char = 'e̊'
+  // entrypoint f14() : char = '\Ì'
+
+  // '💩' vs. map('a,'b)
Author	SHA1	Message	Date
radrow	0320ac959b	CHANGELOG update	2021-07-15 20:43:11 +02:00
radrow	dcef89b486	Add Option.force_msg	2021-07-15 20:41:38 +02:00
Hans Svensson	4957d01e9e	Merge pull request #327 from aeternity/fix_doc Fix stdlib doc	2021-07-13 20:40:49 +02:00
Hans Svensson	9d76e6186a	Fix stdlib doc	2021-07-13 20:01:54 +02:00
Radosław Rowicki	ae3edac53e	Prepare 6.0.2 (#326 ) * Prepare 6.0.2 * Minor note	2021-07-06 17:31:35 +02:00
Ulf Norell	acec32e744	Merge pull request #325 from aeternity/issue324 Fix #324: bug when compiling default init in the presence of child contracts	2021-07-05 10:33:26 +02:00
Hans Svensson	5784f074a6	Merge pull request #323 from aeternity/fromtostep Add check in from_to_step	2021-07-05 09:39:32 +02:00
Ulf Norell	d07b321b25	Fix #324 : bug when compiling default init in the presence of child contracts	2021-07-05 09:29:43 +02:00
radrow	2e6c01cb75	Fix var	2021-06-26 19:10:49 +02:00
radrow	b22eeffc3d	Formatting in stdlib doc	2021-06-26 19:10:15 +02:00
radrow	b366bed24b	Add check in from_to_step	2021-06-25 11:19:19 +02:00
Hans Svensson	1975ccf804	Merge pull request #322 from aeternity/prepare_6.0.1 Prepare 6.0.1	2021-06-24 09:38:05 +02:00
Hans Svensson	4f68729631	Prepare v6.0.1	2021-06-24 09:34:05 +02:00
Denis Davidyuk	10c845d3cf	Use consistent event definitions between examples	2021-06-24 09:34:05 +02:00
Hans Svensson	393d7710c1	Merge pull request #318 from aeternity/stdlib-tests Fix Frac library and add stdlib compilation test	2021-06-24 09:29:12 +02:00
Hans Svensson	37e5a92b2e	Merge pull request #314 from aeternity/call-fee-doc Call.fee doc	2021-06-24 09:28:17 +02:00
Hans Svensson	cb9c9df103	Merge pull request #321 from aeternity/calldata-fix Fix calldata	2021-06-24 09:19:05 +02:00
radrow	c09313a92c	newline	2021-06-22 17:55:31 +02:00
radrow	75b2d6981f	Fix calldata	2021-06-22 17:54:05 +02:00
Hans Svensson	78d94786b6	Merge pull request #320 from aeternity/nikita-fuchs-patch-1 fix child contract deployment example	2021-06-22 14:52:36 +02:00
Nikita Fuchs	216f7f8a25	fix child contract deployment example	2021-06-22 14:47:58 +02:00
radrow	254172e3a3	Properly refer the stdlib	2021-06-02 17:06:36 +02:00
radrow	eadb4e8c83	Fix Frac library and add stdlib compilation test	2021-06-02 17:03:23 +02:00
Radosław Rowicki	e2af89287d	6.0.0 (#317 ) * Prepare 6.0.0 * Update docs * Prepare 6.0.0 one more time * the	2021-05-26 13:06:56 +02:00
radrow	3996b6a711	Call.fee doc	2021-05-25 10:53:40 +02:00
Radosław Rowicki	e8b32a6875	Call.fee (#313 ) * Call.fee * nice align	2021-05-24 14:30:57 +02:00
Radosław Rowicki	cca7bdff49	Prepare 5.1.0 (#312 )	2021-05-24 11:01:59 +02:00
Radosław Rowicki	1d9f59fec3	Contract factories and bytecode introspection (#305 ) * Support for CREATE, CLONE and BYTECODE_HASH * Add missing files * Pushed the clone example through the typechecker * CLONE compiles * Fix dependent type in CLONE * Bytecode hash fixes * Refactor * Refactor 2 * move some logic away * Fixed some error messages. Type inference of child contract still does some random shit\n(mistakes arguments with result type) * CREATE sometimes compiles and sometimes not * Fix some scoping/constraint issues * works, needs cleanup * cleanup * Fix some tests. Remove optimization of singleton tuples * Fix default argument for clone * Cleanup * CHANGELOG * Mention void type * Address review, fix some dialyzer errors * Please dialyzer * Fix failing tests * Write negative tests * Docs * TOC * missing 'the' * missing 'the' * missing 'the' * missing 'the' * mention pre-fund * format * pre-fund clarification * format * Grammar in docs	2021-05-18 12:21:57 +02:00
Hans Svensson	d82b42518e	Merge pull request #311 from aeternity/docs_fixing Add missing Auth.tx in stdlib documentation	2021-05-10 16:00:32 +02:00
Hans Svensson	00a3a51d0d	Add missing Auth.tx	2021-05-10 09:54:57 +02:00
Hans Svensson	6858329faa	Merge pull request #309 from aeternity/prepare_5.0.0 Preparing v5.0.0	2021-04-30 15:17:48 +02:00
Hans Svensson	c2a3e333c7	Preparing v5.0.0	2021-04-30 14:48:37 +02:00
Hans Svensson	4787830861	Merge pull request #308 from aeternity/merge_lima_to_master Merge lima to master	2021-04-30 14:43:16 +02:00
Hans Svensson	a0111066e7	Merge branch 'lima' into merge_lima_to_master	2021-04-30 14:07:06 +02:00
Hans Svensson	2311d19602	Merge pull request #291 from aeternity/GH-3282-aens_pointers_cleanup Add note about legacy (Lima) AENS pointers in update/lookup	2021-04-15 10:26:56 +02:00
Radosław Rowicki	3b2ce63fa7	Merge pull request #300 from aeternity/erlps-lima Trampoline in parser	2021-03-08 13:33:34 +01:00
radrow	8b4a1aaf0d	Trampoline	2021-03-08 12:45:21 +01:00
Radosław Rowicki	c6e7db2381	Merge pull request #299 from aeternity/fix-ets Fix constraints ordering	2021-03-05 10:42:16 +01:00
radrow	4e60d019ca	Fix constraints ordering	2021-02-23 11:05:02 +01:00
Radosław Rowicki	b8002029cf	Merge pull request #294 from aeternity/mergesort Upgrade sorting function	2021-02-23 08:58:36 +01:00
Hans Svensson	2a78189f31	Add note about legacy (Lima) AENS pointers in update/lookup	2021-01-07 12:14:04 +01:00
Radosław Rowicki	4504fb8dcf	Merge pull request #286 from aeternity/expose-interface-fix Fix interface exposure (master)	2020-10-21 14:00:48 +02:00
radrow	8798e0b2c9	Fix interface exposure	2020-10-21 12:40:13 +02:00
Radosław Rowicki	1dfc349065	Merge pull request #285 from aeternity/lima-master-merge Lima master merge	2020-10-15 19:50:48 +02:00
radrow	1266d9ea99	Fix one test2	2020-10-13 10:42:38 +02:00
radrow	bbb049cb2e	Merge branch 'lima' into lima-master-merge	2020-10-13 10:33:30 +02:00
radrow	787551b8bc	Fix one test	2020-10-13 10:29:14 +02:00
radrow	ac673602b9	Merge branch 'lima' into master	2020-10-13 10:22:05 +02:00
Hans Svensson	079b3a45c9	Merge pull request #283 from aeternity/GH-3002-blockhash_at_current_height Document Chain.block_hash at current height	2020-10-08 10:48:41 +02:00
Hans Svensson	c0d9759e60	Whitespace fixes	2020-10-07 16:53:24 +02:00
Hans Svensson	b7b242bc66	Document the (changed) behavior of Chain.block_hash	2020-10-07 16:53:10 +02:00
Hans Svensson	05b87fe200	Merge pull request #259 from kryptokrauts/master fix param description for AENS interface	2020-05-07 16:07:10 +02:00
Marco Walz	cc07e3a638	fix param description for AENS interface	2020-05-05 11:21:27 +02:00
Radosław Rowicki	ea5850cf93	Merge pull request #256 from radrow/master Merge lima – 4.3.0	2020-04-30 13:52:50 +02:00
radrow	d2dcb9e249	Add AENS example, readd delegation signature chapter, fix links	2020-04-30 00:02:26 +02:00
radrow	adb3cf5406	Update documentation to master	2020-04-29 15:27:40 +02:00
radrow	ad78f440d9	Merge lima	2020-04-02 15:32:26 +02:00
Ulf Norell	42cd47d1b3	Merge pull request #241 from aeternity/GH-203-protected-calls Add support for protected contract calls	2020-03-02 16:15:05 +01:00
Ulf Norell	93d2086ddf	aebytecode commit	2020-03-02 12:08:41 +01:00
Ulf Norell	9487b79f42	Fix dialyzer complaints	2020-03-02 12:08:41 +01:00
Ulf Norell	e64ac9396a	Test cases for protected calls	2020-03-02 12:08:41 +01:00
Ulf Norell	4a812b6f3b	Error message tweaks	2020-03-02 11:35:55 +01:00
Ulf Norell	fe2d93ea8a	Compile protected calls to CALL_PGR	2020-03-02 11:35:55 +01:00
Ulf Norell	ecbc15db1b	Add 'protected' named argument to remote calls If protected = true, the return type is wrapped in an option() which comes back None if the remote call fails for any reason.	2020-03-02 08:51:33 +01:00
Hans Svensson	d0caee24d9	Merge pull request #240 from aeternity/GH-176-additional_documentation Add some comments to String.aes	2020-02-28 11:16:38 +01:00
Hans Svensson	57eb77f2f8	Add some comments to String.aes	2020-02-28 11:07:02 +01:00
Hans Svensson	53ed60b498	Merge pull request #238 from aeternity/GH-176-more_string_functions Change Char.to_lower/upper into String.to_lower/upper	2020-02-26 20:01:10 +01:00
Hans Svensson	e49738c90c	New aebytecode reference	2020-02-26 18:23:12 +01:00
Hans Svensson	a38a365181	Change Char.to_lower/upper into String.to_lower/upper	2020-02-26 14:15:49 +01:00
Hans Svensson	0dddac3d86	Merge pull request #236 from aeternity/GH-176-more_string_functions Gh 176 more string functions	2020-02-25 09:49:00 +01:00
Hans Svensson	3da694e798	New aebytecode commit hash	2020-02-25 09:02:18 +01:00
Hans Svensson	e98edd4eef	Handle UTF-8 in character literals Also handle `\x{hhh..}` in strings... Character literals has to be a single character, not composite. + tests (and the corresponding fix to the char literal pretty printer)	2020-02-24 15:35:54 +01:00
Hans Svensson	2bad76314f	More efficient implementations in String.aes	2020-02-24 15:34:23 +01:00
Hans Svensson	b9acf24dca	Make String.aes a stdlib + add more string functions This means moving the FATE operations to StringInternal and adding to/from_list (and Char.to/from_int + Char.to_upper/lower).	2020-02-21 09:45:11 +01:00
Hans Svensson	6682b24156	Merge pull request #223 from aeternity/GH-202-Auth_tx_introspection Gh 202 auth tx introspection	2020-02-11 15:48:46 +01:00
Hans Svensson	b31be6227d	Update aebytecode reference	2020-02-11 14:20:41 +01:00
Hans Svensson	bbc8555331	Auth.tx implementation and types The arities field of the Chain.base_tx constructor is 22 integers long... This isn't very pretty but that is the design we've chosen.	2020-02-11 10:00:46 +01:00
Radosław Rowicki	13bc821211	Optimize stdlib (#215 )	2020-02-07 19:51:12 +01:00
Hans Svensson	34c10e1518	Merge pull request #214 from aeternity/GH-188-AENS_lookup Add AENS.lookup and Oracle.expiry	2020-02-03 14:37:55 +01:00
Hans Svensson	bb79e7dd89	Update aebytecode reference	2020-02-03 14:26:13 +01:00
Hans Svensson	c3426f0e65	Add AENS.lookup Also move Pointee-constructors inside AENS namespace.	2020-02-03 12:52:00 +01:00
Hans Svensson	db01e237c1	Add Oracle.expiry	2020-02-03 12:24:27 +01:00
Hans Svensson	760d2841d1	From Iris (with AENS.update) AENS.resolve is not Pure	2020-02-03 12:22:34 +01:00
Hans Svensson	43013ec920	Merge pull request #213 from aeternity/merge_lima_to_master Merge lima to master	2020-01-15 15:54:41 +01:00
Hans Svensson	d821de6381	Merge 'origin/lima' into 'origin/master'	2020-01-15 15:03:11 +01:00
Hans Svensson	282f743925	Merge pull request #209 from aeternity/merge_lima_to_master Merge lima to master	2019-12-19 15:34:26 +01:00
Hans Svensson	cf1072140e	Merge 'origin/lima' into merge_lima_to_master	2019-12-19 15:09:48 +01:00
Hans Svensson	75797686ad	Merge pull request #187 from aeternity/GH-2850-add_fancy_crypto_bls12_381 Add BLS12-381 operations (to FATE)	2019-11-29 15:27:38 +01:00
Tino Breddin	ed9384c2af	Merge pull request #185 from aeternity/tb-rebar-lock-check Add CI check to verify rebar.lock	2019-11-27 17:28:31 +01:00
Hans Svensson	1c24a700dc	Add BLS12-381 operations (to FATE)	2019-11-27 10:57:24 +01:00
Hans Svensson	f2e9fbcc51	Merge pull request #186 from aeternity/merge_lima Merge lima into master	2019-11-27 10:50:29 +01:00
Hans Svensson	2d49426fe0	Merge 'origin/lima' into master	2019-11-27 10:46:18 +01:00
Tino Breddin	f5df2c1a5f	Add CI workflow	2019-11-26 17:27:26 +01:00
Tino Breddin	04445e4dee	Add CI check to verify rebar.lock	2019-11-26 17:24:02 +01:00
Ulf Norell	eec70f03a5	Merge pull request #183 from aeternity/lima Merge lima into master	2019-11-25 13:16:17 +01:00
skkw	c2c8e297ae	Merge pull request #178 from aeternity/PT-158904718-aens-update-sophia changed type of client ttl to int option	2019-11-18 18:39:54 +01:00
skkw	5c5d3c60ef	changed type of client ttl to int option	2019-11-18 16:25:47 +01:00
Ulf Norell	2a3274ba25	Merge pull request #175 from aeternity/GH-174-encode-decode-bits Handle encoding/decoding bits	2019-11-18 12:12:45 +01:00
Ulf Norell	13b7bde44b	Prefix format annotation for negative numbers	2019-11-18 11:55:04 +01:00
Ulf Norell	baf527b5fa	Handle encoding/decoding bits Fixes GH-174	2019-11-18 11:35:08 +01:00
skkw	422baa5b65	Merge pull request #155 from aeternity/PT-158904718-aens-update-sophia support for AENS.update call	2019-11-12 14:49:42 +01:00
skkw	126e04ae42	support for AENS.update call	2019-11-12 14:27:46 +01:00