Add constrained_t to fold

Update docs/sophia_features.md
Co-authored-by: Radosław Rowicki <35342116+radrow@users.noreply.github.com>
2022-06-20 10:28:17 +04:00 · 2022-06-19 21:44:47 +04:00 · 2022-06-19 21:07:41 +04:00 · 2022-06-19 20:54:58 +04:00 · 2022-06-19 19:19:15 +04:00 · 2022-06-19 19:18:10 +04:00
155 changed files with 6721 additions and 7751 deletions
@@ -3,7 +3,7 @@ version: 2.1
 executors:
  aebuilder:
    docker:
-      - image: aeternity/builder
+      - image: aeternity/builder:xenial-otp21
        user: builder
    working_directory: ~/aesophia

@@ -0,0 +1,7 @@
+import glob
+import shutil
+
+def pre_build(**kwargs):
+  for file in glob.glob('../docs/*.md'):
+    shutil.copy(file, 'docs')
+  shutil.copy('../CHANGELOG.md', 'docs')
@@ -0,0 +1,55 @@
+site_name: æternity Sophia Language
+plugins:
+  - search
+  - mkdocs-simple-hooks:
+      hooks:
+        on_pre_build: 'hook:pre_build'
+repo_url: 'https://github.com/aeternity/aesophia'
+edit_uri: ''
+
+extra:
+  version:
+    provider: mike
+
+theme:
+  favicon: favicon.png
+  name: material
+  custom_dir: overrides
+  language: en
+  palette:
+    - scheme: default
+      primary: pink
+      accent: pink
+      toggle:
+        icon: material/weather-night
+        name: Switch to dark mode
+    - scheme: slate
+      primary: pink
+      accent: pink
+      toggle:
+        icon: material/weather-sunny
+        name: Switch to light mode
+  features:
+    - content.tabs.link
+    - search.highlight
+    - search.share
+    - search.suggest
+
+  # Don't include MkDocs' JavaScript
+  include_search_page: false
+  search_index_only: true
+
+markdown_extensions:
+  - admonition
+  - pymdownx.highlight
+  - pymdownx.superfences
+  - toc:
+      toc_depth: 3
+
+nav:
+  - Introduction: index.md
+  - Syntax: sophia_syntax.md
+  - Features: sophia_features.md
+  - Standard library: sophia_stdlib.md
+  - Contract examples: sophia_examples.md
+  - Changelog: CHANGELOG.md
@@ -0,0 +1,8 @@
+{% extends "base.html" %}
+
+{% block outdated %}
+  You're not viewing the latest version.
+  <a href="{{ '../' ~ base_url }}">
+    <strong>Click here to go to latest.</strong>
+  </a>
+{% endblock %}
@@ -0,0 +1,25 @@
+name: Publish development docs
+on:
+  push:
+    branches: ['master']
+      
+jobs:
+  main:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-python@v2
+        with:
+          python-version: 3.8
+      - uses: actions/cache@v2
+        with:
+          path: ~/.cache/pip3
+          key: ${{ runner.os }}-pip-${{ hashFiles('.github/workflows/requirements.txt') }}
+      - run: pip3 install -r .github/workflows/requirements.txt -U
+      - run: git config --global user.email "github-action@users.noreply.github.com"
+      - run: git config --global user.name "GitHub Action"
+      - run: |
+          cd .docssite
+          mike deploy --push master
@@ -0,0 +1,26 @@
+name: Publish release docs
+on:
+  release:
+    types: [released]
+      
+jobs:
+  main:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-python@v2
+        with:
+          python-version: 3.8
+      - uses: actions/cache@v2
+        with:
+          path: ~/.cache/pip3
+          key: ${{ runner.os }}-pip-${{ hashFiles('.github/workflows/requirements.txt') }}
+      - run: pip3 install -r .github/workflows/requirements.txt -U
+      - run: git config --global user.email "github-action@users.noreply.github.com"
+      - run: git config --global user.name "GitHub Action"
+      - run: echo "RELEASE_VERSION=${GITHUB_REF:10}" >> $GITHUB_ENV
+      - run: |
+          cd .docssite
+          mike deploy --push --update-aliases $RELEASE_VERSION latest
@@ -0,0 +1,5 @@
+mkdocs==1.2.4
+mkdocs-simple-hooks==0.1.3
+mkdocs-material==7.1.9
+mike==1.0.1
+pygments==2.11.2
@@ -21,3 +21,6 @@ rebar3.crashdump
 aesophia
 .qcci
 current_counterexample.eqc
+test/contracts/test.aes
+__pycache__
+.docssite/docs/*.md
@@ -6,7 +6,149 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0

 ## [Unreleased]
 ### Added
+- Compiler warnings for the follwing: shadowing, negative spends, division by zero, unused functions, unused includes, unused stateful annotations, unused variables, unused parameters, unused user-defined type, dead return value.
+- The pipe operator |>
+  ```
+  [1, 2, 3] |> List.first |> Option.is_some  // Option.is_some(List.first([1, 2, 3]))
+  ```
+- Allow binary operators to be used as lambdas
+  ```
+  function sum(l : list(int)) : int = foldl((+), 0, l)
+  function logical_and(x, y) = (&&)(x, y)
+  ```
+- Add comparable typevar constraints (`ord` and `eq`)
+  ```
+  lt : 'a is ord ; ('a, 'a) => bool
+  lt(x, y) = x < y
+
+  is_eq : 'a is eq ; ('a, 'a) => bool
+  is_eq(x, y) = x == y
+  ```
 ### Changed
+- Error messages have been restructured (less newlines) to provide more unified errors. Also `pp_oneline/1` has been added.
+- Ban empty record definitions (e.g. `record r = {}` would give an error).
+### Removed
+- Support for AEVM has been entirely wiped
+
+## [6.1.0] - 2021-10-20
+### Added
+- `Bitwise` stdlib
+- `Set` stdlib
+- `Option.force_msg`
+- Loading namespaces into the current scope (e.g. `using Pair`)
+- Assign patterns to variables (e.g. `let x::(t = y::_) = [1, 2, 3, 4]` where `t == [2, 3, 4]`)
+- Add builtin types (`AENS.name, AENS.pointee, Chain.ttl, Chain.base_tx, Chain.ga_meta_tx, Chain.paying_for_tx`) to
+  the calldata and result decoder
+- Patterns guards
+  ```
+  switch(x)
+    a::[] | a > 10 => 1
+    _              => 2
+  ```
+  ```
+  function
+    f(a::[]) | a > 10 = 1
+    f(_)              = 2
+  ```
+### Changed
+- Fixed the ACI renderer, it shouldn't drop the `stateful` modifier
+
+## [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]
@@ -211,7 +353,12 @@ 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.1.0...HEAD
+[6.1.0]: https://github.com/aeternity/aesophia/compare/v6.0.2...v6.1.0
+[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
@@ -1,6 +1,6 @@
 ISC License

-Copyright (c) 2017, aeternity developers
+Copyright (c) 2017, æternity developers

 Permission to use, copy, modify, and/or distribute this software for any
 purpose with or without fee is hereby granted, provided that the above
@@ -5,25 +5,30 @@ This is the __sophia__ compiler for the æternity system which compiles contract
 The compiler is currently being used three places
 - [The command line compiler](https://github.com/aeternity/aesophia_cli)
 - [The HTTP compiler](https://github.com/aeternity/aesophia_http)
- - In [Aeternity node](https://github.com/aeternity/aeternity) tests
+ - In [æternity node](https://github.com/aeternity/aeternity) tests

 ## Documentation

-* [Smart Contracts on aeternity Blockchain](https://github.com/aeternity/protocol/blob/master/contracts/contracts.md).
-* [Sophia Documentation](docs/sophia.md).
-* [Sophia Standard Library](docs/sophia_stdlib.md).
+* [Introduction](docs/index.md)
+* [Syntax](docs/sophia_syntax.md)
+* [Features](docs/sophia_features.md)
+* [Standard library](docs/sophia_stdlib.md)
+* [Contract examples](docs/sophia_examples.md)
+
+Additionally you can check out the [contracts section](https://github.com/aeternity/protocol/blob/master/contracts/contracts.md) of the æternity blockchain specification.

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

 The basic modules for interfacing the compiler:

-* [aeso_compiler: the Sophia compiler](./docs/aeso_compiler.md)
-* [aeso_aci: the ACI interface](./docs/aeso_aci.md)
+* [aeso_compiler: the Sophia compiler](docs/aeso_compiler.md)
+* [aeso_aci: the ACI interface](docs/aeso_aci.md)
@@ -49,12 +49,8 @@ The **pp_** options all print to standard output the following:

 `pp_typed_ast` - print the AST with type information at each node

-`pp_icode` - print the internal code structure
-
 `pp_assembler` - print the generated assembler code

-`pp_bytecode` - print the bytecode instructions
-
 #### check_call(ContractString, Options) -> CheckRet

 Types
@@ -66,15 +62,6 @@ Type = term()
 ```
 Check a call in contract through the `__call` function.

-#### sophia_type_to_typerep(String) -> TypeRep
-
-Types
-``` erlang
- {ok,TypeRep} | {error, badtype}
-```
-
-Get the type representation of a type declaration.
-
 #### version() -> {ok, Version} | {error, term()}

 Types
@@ -0,0 +1,12 @@
+# Introduction
+Sophia is a functional language designed for smart contract development. It is strongly typed and has
+restricted mutable state.
+
+Sophia is customized for smart contracts, which can be published
+to a blockchain. Thus some features of conventional
+languages, such as floating point arithmetic, are not present in Sophia, and
+some [æternity blockchain](https://aeternity.com) specific primitives, constructions and types have been added.
+
+!!! Note
+    - For rapid prototyping of smart contracts check out [AEstudio](https://studio.aepps.com/)!
+    - For playing around and diving deeper into the language itself check out the [REPL](https://repl.aeternity.io/)!
@@ -0,0 +1,73 @@
+# Contract examples
+
+## Crowdfunding
+```sophia
+/*
+ * A simple crowd-funding example
+ */
+contract FundMe =
+
+  record spend_args = { recipient : address,
+                        amount    : int }
+
+  record state = { contributions : map(address, int),
+                   total         : int,
+                   beneficiary   : address,
+                   deadline      : int,
+                   goal          : int }
+
+  stateful function spend(args : spend_args) =
+    Chain.spend(args.recipient, args.amount)
+
+  entrypoint init(beneficiary, deadline, goal) : state =
+    { contributions = {},
+      beneficiary   = beneficiary,
+      deadline      = deadline,
+      total         = 0,
+      goal          = goal }
+
+  function is_contributor(addr) =
+    Map.member(addr, state.contributions)
+
+  stateful entrypoint contribute() =
+    if(Chain.block_height >= state.deadline)
+      spend({ recipient = Call.caller, amount = Call.value }) // Refund money
+      false
+    else
+      let amount =
+        switch(Map.lookup(Call.caller, state.contributions))
+          None    => Call.value
+          Some(n) => n + Call.value
+      put(state{ contributions[Call.caller] = amount,
+                 total @ tot = tot + Call.value })
+      true
+
+  stateful entrypoint withdraw() =
+    if(Chain.block_height < state.deadline)
+      abort("Cannot withdraw before deadline")
+    if(Call.caller == state.beneficiary)
+      withdraw_beneficiary()
+    elif(is_contributor(Call.caller))
+      withdraw_contributor()
+    else
+      abort("Not a contributor or beneficiary")
+
+  stateful function withdraw_beneficiary() =
+    require(state.total >= state.goal, "Project was not funded")
+    spend({recipient = state.beneficiary,
+           amount    = Contract.balance })
+
+  stateful function withdraw_contributor() =
+    if(state.total >= state.goal)
+      abort("Project was funded")
+    let to = Call.caller
+    spend({recipient = to,
+           amount    = state.contributions[to]})
+    put(state{ contributions @ c = Map.delete(to, c) })
+```
+
+## Repositories
+This is a list with repositories that include smart contracts written in Sophia:
+
+- [aepp-sophia-examples](https://github.com/aeternity/aepp-sophia-examples)
+    - A repository that contains lots of different examples. The functionality of these examples is - to some extent - also covered by tests written in JavaScript.
@@ -0,0 +1,925 @@
+# Features
+## Contracts
+
+The main unit of code in Sophia is the *contract*.
+
+- A contract implementation, or simply a contract, is the code for a
+  smart contract and consists of a list of types, entrypoints and local
+  functions. Only the entrypoints can be called from outside the contract.
+- A contract instance is an entity living on the block chain (or in a state
+  channel). Each instance has an address that can be used to call its
+  entrypoints, either from another contract or in a call transaction.
+- A contract may define a type `state` encapsulating its local
+  state. When creating a new contract the `init` entrypoint is executed and the
+  state is initialized to its return value.
+
+The language offers some primitive functions to interact with the blockchain and contracts.
+Please refer to the [Chain](sophia_stdlib.md#chain), [Contract](sophia_stdlib.md#contract)
+and the [Call](sophia_stdlib.md#call) namespaces in the documentation.
+
+### Calling other contracts
+
+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,
+
+```sophia
+// A contract type
+contract interface VotingType =
+  entrypoint vote : string => unit
+```
+
+Now given contract address of type `VotingType` you can call the `vote`
+entrypoint of that contract:
+
+```sophia
+contract VoteTwice =
+  entrypoint voteTwice(v : VotingType, alt : string) =
+    v.vote(alt)
+    v.vote(alt)
+```
+
+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:
+
+```sophia
+  entrypoint voteTwice(v : VotingType, fee : int, alt : string) =
+    v.vote(value = fee, alt)
+    v.vote(value = fee, alt)
+```
+
+Named arguments can be given in any order.
+
+Note that reentrant calls are not permitted. In other words, when calling
+another contract it cannot call you back (directly or indirectly).
+
+To construct a value of a contract type you can give a contract address literal
+(for instance `ct_2gPXZnZdKU716QBUFKaT4VdBZituK93KLvHJB3n4EnbrHHw4Ay`), or
+convert an account address to a contract address using `Address.to_contract`.
+Note that if the contract does not exist, or it doesn't have the entrypoint, or
+the type of the entrypoint does not match the stated contract type, the call
+fails.
+
+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
+
+```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.
+
+Any side effects (state change, token transfers, etc.) made by a failing
+protected call is rolled back, just like they would be in the unprotected case.
+
+
+### 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
+
+```sophia
+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.
+
+- Each contract defines a type `state` encapsulating its mutable state.
+  The type `state` defaults to the `unit`.
+- The initial state of a contract is computed by the contract's `init`
+  function. The `init` function is *pure* and returns the initial state as its
+  return value.
+  If the type `state` is `unit`, the `init` function defaults to returning the value `()`.
+  At contract creation time, the `init` function is executed and
+  its result is stored as the contract state.
+- The value of the state is accessible from inside the contract
+  through an implicitly bound variable `state`.
+- State updates are performed by calling a function `put : state => unit`.
+- Aside from the `put` function (and similar functions for transactions
+  and events), the language is purely functional.
+- Functions modifying the state need to be annotated with the `stateful` keyword (see below).
+
+To make it convenient to update parts of a deeply nested state Sophia
+provides special syntax for map/record updates.
+
+### Stateful functions
+
+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,
+
+```sophia
+  stateful entrypoint set_state(s : state) =
+    put(s)
+```
+
+Without the `stateful` annotation the compiler does not allow the call to
+`put`. A `stateful` annotation is required to
+
+* Use a stateful primitive function. These are
+  - `put`
+  - `Chain.spend`
+  - `Oracle.register`
+  - `Oracle.query`
+  - `Oracle.respond`
+  - `Oracle.extend`
+  - `AENS.preclaim`
+  - `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.
+
+A `stateful` annotation *is not* required to
+
+* Read the contract state.
+* Issue an event using the `event` function.
+* Call another contract with `value = 0`, even if the called function is stateful.
+
+## Payable
+
+### Payable contracts
+
+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`:
+
+```sophia
+// A payable contract
+payable contract ExampleContract =
+  stateful entrypoint do_stuff() = ...
+```
+
+If in doubt, it is possible to check if an address is payable using
+`Address.is_payable(addr)`.
+
+### Payable entrypoints
+
+A contract entrypoint is by default *not* payable. Any call to such a function
+(either a [Remote call](#calling-other-contracts) or a contract call transaction)
+that has a non-zero `value` will fail. Contract entrypoints that should be called
+with a non-zero value should be declared `payable`.
+
+```sophia
+payable stateful entrypoint buy(to : address) =
+  if(Call.value > 42)
+    transfer_item(to)
+  else
+    abort("Value too low")
+```
+
+## Namespaces
+
+Code can be split into libraries using the `namespace` construct. Namespaces
+can appear at the top-level and can contain type and function definitions, but
+not entrypoints. Outside the namespace you can refer to the (non-private) names
+by qualifying them with the namespace (`Namespace.name`).
+For example,
+
+```sophia
+namespace Library =
+  type number = int
+  function inc(x : number) : number = x + 1
+
+contract MyContract =
+  entrypoint plus2(x) : Library.number =
+    Library.inc(Library.inc(x))
+```
+
+Functions in namespaces have access to the same environment (including the
+`Chain`, `Call`, and `Contract`, builtin namespaces) as function in a contract,
+with the exception of `state`, `put` and `Chain.event` since these are
+dependent on the specific state and event types of the contract.
+
+To avoid mentioning the namespace every time it is used, Sophia allows
+including the namespace in the current scope with the `using` keyword:
+```
+include "Pair.aes"
+using Pair
+contract C =
+  type state = int
+  entrypoint init() =
+    let p = (1, 2)
+    fst(p)  // this is the same as Pair.fst(p)
+```
+
+It is also possible to make an alias for the namespace with the `as` keyword:
+```
+include "Pair.aes"
+contract C =
+  using Pair as P
+  type state = int
+  entrypoint init() =
+    let p = (1, 2)
+    P.fst(p)  // this is the same as Pair.fst(p)
+```
+
+Having the same alias for multiple namespaces is possible and it allows
+referening functions that are defined in different namespaces and have
+different names with the same alias:
+```
+namespace Xa = function f() = 1
+namespace Xb = function g() = 2
+contract Cntr =
+  using Xa as A
+  using Xb as A
+  type state = int
+  entrypoint init() = A.f() + A.g()
+```
+
+Note that using functions with the same name would result in an ambiguous name
+error:
+```
+namespace Xa = function f() = 1
+namespace Xb = function f() = 2
+contract Cntr =
+  using Xa as A
+  using Xb as A
+  type state = int
+
+  // the next line has an error because f is defined in both Xa and Xb
+  entrypoint init() = A.f()
+```
+
+Importing specific parts of a namespace or hiding these parts can also be
+done like this:
+```
+using Pair for [fst, snd]       // this will only import fst and snd
+using Triple hiding [fst, snd]  // this will import everything except for fst and snd
+```
+
+Note that it is possible to use a namespace in the top level of the file, in the
+contract level, namespace level, or in the function level.
+
+## Splitting code over multiple files
+
+Code from another file can be included in a contract using an `include`
+statement. These must appear at the top-level (outside the main contract). The
+included file can contain one or more namespaces and abstract contracts. For
+example, if the file `library.aes` contains
+
+```sophia
+namespace Library =
+  function inc(x) = x + 1
+```
+
+you can use it from another file using an `include`:
+
+```sophia
+include "library.aes"
+contract MyContract =
+  entrypoint plus2(x) = Library.inc(Library.inc(x))
+```
+
+This behaves as if the contents of `library.aes` was textually inserted into
+the file, except that error messages will refer to the original source
+locations. The language will try to include each file at most one time automatically,
+so even cyclic includes should be working without any special tinkering.
+
+## Standard library
+
+Sophia offers [standard library](sophia_stdlib.md) which exposes some
+primitive operations and some higher level utilities. The builtin
+namespaces like `Chain`, `Contract`, `Map`
+are included by default and are supported internally by the compiler.
+Others like `List`, `Frac`, `Option` need to be manually included using the
+`include` directive. For example
+```sophia
+include "List.aes"
+include "Pair.aes"
+-- Map is already there!
+
+namespace C =
+  entrypoint keys(m : map('a, 'b)) : list('a) =
+    List.map(Pair.fst, (Map.to_list(m)))
+```
+
+## Types
+Sophia has the following types:
+
+| Type                 | Description                                                                                 | Example                                                                       |
+|----------------------|---------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------|
+| int                  | A 2-complement integer                                                                      | ```-1```                                                                      |
+| char                 | A single character                                                                          | ```'c'```                                                                     |
+| address              | æternity address, 32 bytes                                                                  | ```Call.origin``` ```ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt``` |
+| bool                 | A Boolean                                                                                   | ```true```                                                                    |
+| bits                 | A bit field                                                                                 | ```Bits.none```                                                               |
+| bytes(n)             | A byte array with `n` bytes                                                                 | ```#fedcba9876543210```                                                       |
+| string               | An array of bytes                                                                           | ```"Foo"```                                                                   |
+| list                 | A homogeneous immutable singly linked list.                                                 | ```[1, 2, 3]```                                                               |
+| ('a, 'b) => 'c       | A function. Parentheses can be skipped if there is only one argument                        | ```(x : int, y : int) => x + y```                                             |
+| tuple                | An ordered heterogeneous array                                                              | ```(42, "Foo", true)```                                                       |
+| record               | An immutable key value store with fixed key names and typed values                          | ``` record balance = { owner: address, value: int } ```                       |
+| map                  | An immutable key value store with dynamic mapping of keys of one type to values of one type | ```type accounts = map(string, address)```                                    |
+| option('a)           | An optional value either None or Some('a)                                                   | ```Some(42)```                                                                |
+| state                | A user defined type holding the contract state                                              | ```record state = { owner: address, magic_key: bytes(4) }```                  |
+| event                | An append only list of blockchain events (or log entries)                                   | ```datatype event = EventX(indexed int, string)```                            |
+| hash                 | A 32-byte hash - equivalent to `bytes(32)`                                                  |                                                                               |
+| signature            | A signature - equivalent to `bytes(64)`                                                     |                                                                               |
+| Chain.ttl            | Time-to-live (fixed height or relative to current block)                                    | ```FixedTTL(1050)``` ```RelativeTTL(50)```                                    |
+| oracle('a, 'b)       | And oracle answering questions of type 'a with answers of type 'b                           | ```Oracle.register(acct, qfee, ttl)```                                        |
+| oracle_query('a, 'b) | A specific oracle query                                                                     | ```Oracle.query(o, q, qfee, qttl, rttl)```                                    |
+| contract             | A user defined, typed, contract address                                                     | ```function call_remote(r : RemoteContract) = r.fun()```                      |
+
+## Literals
+| Type                 | Constant/Literal example(s)                                                                                                         |
+| ----------           | -------------------------------                                                                                                     |
+| int                  | `-1`, `2425`, `4598275923475723498573485768`                                                                                        |
+| address              | `ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt`                                                                             |
+| bool                 | `true`, `false`                                                                                                                     |
+| bits                 | `Bits.none`, `Bits.all`                                                                                                             |
+| bytes(8)             | `#fedcba9876543210`                                                                                                                 |
+| string               | `"This is a string"`                                                                                                                |
+| list                 | `[1, 2, 3]`, `[(true, 24), (false, 19), (false, -42)]`                                                                              |
+| tuple                | `(42, "Foo", true)`                                                                                                                 |
+| record               | `{ owner = Call.origin, value = 100000000 }`                                                                                        |
+| map                  | `{["foo"] = 19, ["bar"] = 42}`, `{}`                                                                                                |
+| option(int)          | `Some(42)`, `None`                                                                                                                  |
+| state                | `state{ owner = Call.origin, magic_key = #a298105f }`                                                                               |
+| event                | `EventX(0, "Hello")`                                                                                                                |
+| hash                 | `#000102030405060708090a0b0c0d0e0f000102030405060708090a0b0c0d0e0f`                                                                 |
+| signature            | `#000102030405060708090a0b0c0d0e0f000102030405060708090a0b0c0d0e0f000102030405060708090a0b0c0d0e0f000102030405060708090a0b0c0d0e0f` |
+| Chain.ttl            | `FixedTTL(1050)`, `RelativeTTL(50)`                                                                                                 |
+| oracle('a, 'b)       | `ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5`                                                                             |
+| oracle_query('a, 'b) | `oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY`                                                                             |
+| contract             | `ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ`                                                                              |
+
+## Arithmetic
+
+Sophia integers (`int`) are represented by arbitrary-sized signed words and support the following
+arithmetic operations:
+- addition (`x + y`)
+- subtraction (`x - y`)
+- multiplication (`x * y`)
+- division (`x / y`), truncated towards zero
+- remainder (`x mod y`), satisfying `y * (x / y) + x mod y == x` for non-zero `y`
+- exponentiation (`x ^ y`)
+
+All operations are *safe* with respect to overflow and underflow. 
+The division and modulo operations throw an arithmetic error if the
+right-hand operand is zero.
+
+## Bit fields
+
+Sophia integers do not support bit arithmetic. Instead there is a separate
+type `bits`. See the standard library [documentation](sophia_stdlib.md#bits).
+
+A bit field can be of arbitrary size (but it is still represented by the
+corresponding integer, so setting very high bits can be expensive).
+
+## Type aliases
+
+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)
+```
+
+A type alias and its definition can be used interchangeably. Sophia does not support
+higher-kinded types, meaning that following type alias is invalid: `type wrap('f, 'a) = 'f('a)`
+
+## Algebraic data types
+
+Sophia supports algebraic data types (variant types) and pattern matching. Data
+types are declared by giving a list of constructors with
+their respective arguments. For instance,
+
+```sophia
+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)
+    Right(_)   => None
+    Both(x, _) => Some(x)
+```
+
+or directly in the left-hand side:
+```sophia
+function
+  get_left : one_or_both('a, 'b) => option('a)
+  get_left(Left(x))    = Some(x)
+  get_left(Right(_))   = None
+  get_left(Both(x, _)) = Some(x)
+```
+
+*NOTE: Data types cannot currently be recursive.*
+
+Sophia also supports the assignment of patterns to variables:
+```sophia
+function f(x) = switch(x)
+  h1::(t = h2::_) => (h1 + h2)::t  // same as `h1::h2::k => (h1 + h2)::h2::k`
+  _ => x
+
+function g(p : int * option(int)) : int =
+  let (a, (o = Some(b))) = p  // o is equal to Pair.snd(p)
+  b
+```
+
+Guards are boolean expressions that can be used on patterns in both switch
+statements and functions definitions. If a guard expression evaluates to
+`true`, then the corresponding body will be used. Otherwise, the next pattern
+will be checked:
+
+```sophia
+function get_left_if_positive(x : one_or_both(int, 'b)) : option(int) =
+  switch(x)
+    Left(x)    | x > 0 => Some(x)
+    Both(x, _) | x > 0 => Some(x)
+    _                  => None
+```
+
+```sophia
+function
+  get_left_if_positive : one_or_both(int, 'b) => option(int)
+  get_left_if_positive(Left(x))    | x > 0 = Some(x)
+  get_left_if_positive(Both(x, _)) | x > 0 = Some(x)
+  get_left_if_positive(_)                  = None
+```
+
+Guards cannot be stateful even when used inside a stateful function.
+
+## Comparable types
+
+Only certain types are allowed to be compared by equality (`==`, `!=`) and
+inequality (`<`, `>`, `=<`, `>=`). For instance, while it is legal to compare
+integers, comparing functions would lead to an error:
+
+```
+function f() = 
+  f == f  // type error
+```
+
+The rules apply as follows:
+
+- All types that are comparable by inequality are also comparable by equality.
+- The builtin types `bool`, `int`, `char`, `bits`, `bytes`, `string`, `unit`,
+  `hash`, `address` and `signature` are comparable by inequality (and thus by
+  equality).
+- The composite types `list`, `option`, and tuples are comparable by
+  equality/inequality if their type parameters are comparable by
+  equality/inequality.
+- The composite types `map`, `oracle`, and `oracle_query` are comparable by
+  equality if their type parameters are comparable by equality.
+- User-defined records and datatypes are comparable by equality if their type
+  parameters are comparable by equality.
+- Smart contracts are comparable by equality.
+- User-declared type variables are comparable according to the [type
+  constraints](#type-constraints) given in the function signature.
+
+In all other cases the types are not comparable.
+
+### Type constraints
+
+Polymorphic types are not declared as comparable by default. If the user
+specifies the type signature for a function, they need to manually declare type
+constraints in order to allow the variables to be compared. This can only be
+done if the type declaration is separated from the function definition. The
+constraints have to be prepended to the type declaration and separated with a
+semicolon:
+
+```
+
+function eq(x : 'a, y : 'a) = x == y  // Type error, 'a is not comparable
+
+function
+  eq : 'a is eq ; ('a, 'a) => bool
+  eq(x, y) = x == y                   // Compiles
+
+function eq(x, y) = x == y            // Compiles as the constraints are inferred
+```
+
+Currently only two constraints are allowed: `eq` for equality and `ord` for
+inequality. Declaring a type as `ord` automatically implies `eq`.
+
+## Lists
+
+A Sophia list is a dynamically sized, homogenous, immutable, singly
+linked list. A list is constructed with the syntax `[1, 2, 3]`. The
+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))
+```
+
+New elements can be prepended to the front of a list with the `::`
+operator. So `42 :: [1, 2, 3]` returns the list `[42, 1, 2, 3]`. The
+concatenation operator `++` appends its second argument to its first
+and returns the resulting list. So concatenating two lists
+`[1, 22, 33] ++ [10, 18, 55]` returns the list `[1, 22, 33, 10, 18, 55]`.
+
+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.
+
+
+Please refer to the [standard library](sophia_stdlib.md#list) for the predefined functionalities.
+
+## Maps and records
+
+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) }
+```
+
+Maps, on the other hand, can contain an arbitrary number of key-value bindings,
+but of a fixed type. The type of maps with keys of type `'k` and values of type
+`'v` is written `map('k, 'v)`. The key type can be any type that does not
+contain a map or a function type.
+
+Please refer to the [standard library](sophia_stdlib.md#map) for the predefined functionalities.
+
+### Constructing maps and records
+
+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}
+```
+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
+```
+Looking up a non-existing key in a map results in contract execution failing. A
+default value to return for non-existing keys can be provided using the syntax
+`m[k = default]`. See also `Map.member` and `Map.lookup` below.
+
+### Updating a value
+
+Record field updates are written `r{f = v}`. This creates a new record value
+which is the same as `r`, but with the value of the field `f` replaced by `v`.
+Similarly, `m{[k] = v}` constructs a map with the same values as `m` except
+that `k` maps to `v`. It makes no difference if `m` has a mapping for `k` or
+not.
+
+It is possible to give a name to the old value of a field or mapping in an
+update: instead of `acc{ balance = acc.balance + 100 }` it is possible to write
+`acc{ balance @ b = b + 100 }`, binding `b` to `acc.balance`. When giving a
+name to a map value (`m{ [k] @ x = v }`), the corresponding key must be present
+in the map or execution fails, but a default value can be provided:
+`m{ [k = default] @ x = v }`. In this case `x` is bound to `default` if
+`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 = [] }
+```
+
+### Map implementation
+
+Internally in the VM maps are implemented as hash maps and support fast lookup
+and update. Large maps can be stored in the contract state and the size of the
+map does not contribute to the gas costs of a contract call reading or updating
+it.
+
+## Strings
+
+There is a builtin type `string`, which can be seen as an array of bytes.
+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 `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
+
+Byte arrays are fixed size arrays of 8-bit integers. They are described in hexadecimal system,
+for example the literal `#cafe` creates a two-element array of bytes `ca` (202) and `fe` (254)
+and thus is a value of type `bytes(2)`.
+
+Please refer to the `Bytes` [library documentation](sophia_stdlib.md#bytes).
+
+## Cryptographic builtins
+
+Libraries [Crypto](sophia_stdlib.md#crypto) and [String](sophia_stdlib.md#string) provide functions to
+hash objects, verify signatures etc. The `hash` is a type alias for `bytes(32)`.
+
+## Authorization interface
+
+When a Generalized account is authorized, the authorization function needs
+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
+through the Oracle interface.
+
+For a full description of how Oracle works see
+[Oracles](https://github.com/aeternity/protocol/blob/master/oracles/oracles.md#oracles).
+For a functionality documentation refer to the [standard library](sophia_stdlib.md#oracle).
+
+### Example
+
+Example for an oracle answering questions of type `string` with answers of type `int`:
+```sophia
+contract Oracles =
+
+  stateful entrypoint registerOracle(acct : address,
+                                     sign : signature,   // Signed network id + oracle address + contract address
+                                     qfee : int,
+                                     ttl  : Chain.ttl) : oracle(string, int) =
+     Oracle.register(acct, signature = sign, qfee, ttl)
+
+  entrypoint queryFee(o : oracle(string, int)) : int =
+    Oracle.query_fee(o)
+
+  payable stateful entrypoint createQuery(o    : oracle_query(string, int),
+                                          q    : string,
+                                          qfee : int,
+                                          qttl : Chain.ttl,
+                                          rttl : int) : oracle_query(string, int) =
+    require(qfee =< Call.value, "insufficient value for qfee")
+    Oracle.query(o, q, qfee, qttl, RelativeTTL(rttl))
+
+  stateful entrypoint extendOracle(o   : oracle(string, int),
+                                   ttl : Chain.ttl) : unit =
+    Oracle.extend(o, ttl)
+
+  stateful entrypoint signExtendOracle(o    : oracle(string, int),
+                                       sign : signature,   // Signed network id + oracle address + contract address
+                                       ttl  : Chain.ttl) : unit =
+    Oracle.extend(o, signature = sign, ttl)
+
+  stateful entrypoint respond(o    : oracle(string, int),
+                              q    : oracle_query(string, int),
+                              sign : signature,        // Signed network id + oracle query id + contract address
+                              r    : int) =
+    Oracle.respond(o, q, signature = sign, r)
+
+  entrypoint getQuestion(o : oracle(string, int),
+                         q : oracle_query(string, int)) : string =
+    Oracle.get_question(o, q)
+
+  entrypoint hasAnswer(o : oracle(string, int),
+                       q : oracle_query(string, int)) =
+    switch(Oracle.get_answer(o, q))
+      None    => false
+      Some(_) => true
+
+  entrypoint getAnswer(o : oracle(string, int),
+                       q : oracle_query(string, int)) : option(int) =
+    Oracle.get_answer(o, q)
+```
+
+### Sanity checks
+
+When an Oracle literal is passed to a contract, no deep checks are performed.
+For extra safety [Oracle.check](sophia_stdlib.md#check) and [Oracle.check_query](sophia_stdlib.md#check_query)
+functions are provided.
+
+## AENS interface
+
+Contracts can interact with the
+[æternity 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
+
+Sophia contracts log structured messages to an event log in the resulting
+blockchain transaction. The event log is quite similar to [Events in
+Solidity](https://solidity.readthedocs.io/en/v0.4.24/contracts.html#events).
+Events are further discussed in the [protocol](https://github.com/aeternity/protocol/blob/master/contracts/events.md).
+
+
+To use events a contract must declare a datatype `event`, and events are then
+logged using the `Chain.event` function:
+
+```sophia
+  datatype event
+    = Event1(int, int, string)
+    | Event2(string, address)
+
+  Chain.event(e : event) : unit
+```
+
+The event can have 0-3 *indexed* fields, and an optional *payload* field. A
+field is indexed if it fits in a 32-byte word, i.e.
+- `bool`
+- `int`
+- `bits`
+- `address`
+- `oracle(_, _)`
+- `oracle_query(_, _)`
+- contract types
+- `bytes(n)` for `n` ≤ 32, in particular `hash`
+
+The payload field must be either a string or a byte array of more than 32 bytes.
+The fields can appear in any order.
+
+*NOTE:* Indexing is not part of the core æternity node.
+
+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(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)
+
+...
+
+Chain.event(AnotherEvent("This is not indexed", Contract.address))
+```
+would yield exactly the same result in the example above!
+
+## Compiler pragmas
+
+To enforce that a contract is only compiled with specific versions of the
+Sophia compiler, you can give one or more `@compiler` pragmas at the
+top-level (typically at the beginning) of a file. For instance, to enforce that
+a contract is compiled with version 4.3 of the compiler you write
+
+```sophia
+@compiler >= 4.3
+@compiler <  4.4
+```
+
+Valid operators in compiler pragmas are `<`, `=<`, `==`, `>=`, and `>`. Version
+numbers are given as a sequence of non-negative integers separated by dots.
+Trailing zeros are ignored, so `4.0.0 == 4`. If a constraint is violated an
+error is reported and compilation fails.
+
+## Exceptions
+
+Contracts can fail with an (uncatchable) exception using the built-in function
+
+```sophia
+abort(reason : string) : 'a
+```
+
+Calling abort causes the top-level call transaction to return an error result
+containing the `reason` string. Only the gas used up to and including the abort
+call is charged. This is different from termination due to a crash which
+consumes all available gas.
+
+For convenience the following function is also built-in:
+
+```sophia
+function require(b : bool, err : string) =
+    if(!b) abort(err)
+```
+
+## 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 æternity mainnet, etc.).
@@ -0,0 +1,267 @@
+# Syntax
+
+## Lexical syntax
+
+### Comments
+
+Single line comments start with `//` and block comments are enclosed in `/*`
+and `*/` and can be nested.
+
+### Keywords
+
+```
+contract elif else entrypoint false function if import include let mod namespace
+private payable stateful switch true type record datatype main interface
+```
+
+### Tokens
+
+- `Id = [a-z_][A-Za-z0-9_']*` identifiers start with a lower case letter.
+- `Con = [A-Z][A-Za-z0-9_']*` constructors start with an upper case letter.
+- `QId = (Con\.)+Id` qualified identifiers (e.g. `Map.member`)
+- `QCon = (Con\.)+Con` qualified constructor
+- `TVar = 'Id` type variable (e.g `'a`, `'b`)
+- `Int = [0-9]+(_[0-9]+)*|0x[0-9A-Fa-f]+(_[0-9A-Fa-f]+)*` integer literal with optional `_` separators
+- `Bytes = #[0-9A-Fa-f]+(_[0-9A-Fa-f]+)*` byte array literal with optional `_` separators
+- `String` string literal enclosed in `"` with escape character `\`
+- `Char` character literal enclosed in `'` with escape character `\`
+- `AccountAddress` base58-encoded 32 byte account pubkey with `ak_` prefix
+- `ContractAddress` base58-encoded 32 byte contract address with `ct_` prefix
+- `OracleAddress` base58-encoded 32 byte oracle address with `ok_` prefix
+- `OracleQueryId` base58-encoded 32 byte oracle query id with `oq_` prefix
+
+Valid string escape codes are
+
+| Escape        |       ASCII |   |
+|---------------|-------------|---|
+| `\b`          |           8 |   |
+| `\t`          |           9 |   |
+| `\n`          |          10 |   |
+| `\v`          |          11 |   |
+| `\f`          |          12 |   |
+| `\r`          |          13 |   |
+| `\e`          |          27 |   |
+| `\xHexDigits` | *HexDigits* |   |
+
+
+See the [identifier encoding scheme](https://github.com/aeternity/protocol/blob/master/node/api/api_encoding.md) for the
+details on the base58 literals.
+
+## Layout blocks
+
+Sophia uses Python-style layout rules to group declarations and statements. A
+layout block with more than one element must start on a separate line and be
+indented more than the currently enclosing layout block. Blocks with a single
+element can be written on the same line as the previous token.
+
+Each element of the block must share the same indentation and no part of an
+element may be indented less than the indentation of the block. For instance
+
+```sophia
+contract Layout =
+  function foo() = 0  // no layout
+  function bar() =    // layout block starts on next line
+    let x = foo()     // indented more than 2 spaces
+    x
+     + 1              // the '+' is indented more than the 'x'
+```
+
+## Notation
+
+In describing the syntax below, we use the following conventions:
+
+- Upper-case identifiers denote non-terminals (like `Expr`) or terminals with
+  some associated value (like `Id`).
+- Keywords and symbols are enclosed in single quotes: `'let'` or `'='`.
+- Choices are separated by vertical bars: `|`.
+- Optional elements are enclosed in `[` square brackets `]`.
+- `(` Parentheses `)` are used for grouping.
+- Zero or more repetitions are denoted by a postfix `*`, and one or more
+  repetitions by a `+`.
+- `Block(X)` denotes a layout block of `X`s.
+- `Sep(X, S)` is short for `[X (S X)*]`, i.e. a possibly empty sequence of `X`s
+  separated by `S`s.
+- `Sep1(X, S)` is short for `X (S X)*`, i.e. same as `Sep`, but must not be empty.
+
+
+## Declarations
+
+A Sophia file consists of a sequence of *declarations* in a layout block.
+
+```c
+File ::= Block(TopDecl)
+
+TopDecl ::= ['payable'] 'contract' Con '=' Block(Decl)
+       | 'namespace' Con '=' Block(Decl)
+       | '@compiler' PragmaOp Version
+       | 'include' String
+
+Decl ::= 'type'     Id ['(' TVar* ')'] '=' TypeAlias
+       | 'record'   Id ['(' TVar* ')'] '=' RecordType
+       | 'datatype' Id ['(' TVar* ')'] '=' DataType
+       | (EModifier* 'entrypoint' | FModifier* 'function') Block(FunDecl)
+
+FunDecl ::= Id ':' Type                             // Type signature
+          | Id Args [':' Type] '=' Block(Stmt)      // Definition
+
+PragmaOp ::= '<' | '=<' | '==' | '>=' | '>'
+Version  ::= Sep1(Int, '.')
+
+EModifier ::= 'payable' | 'stateful'
+FModifier ::= 'stateful' | 'private'
+
+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
+```
+
+There are three forms of type declarations: type aliases (declared with the
+`type` keyword), record type definitions (`record`) and data type definitions
+(`datatype`):
+
+```c
+TypeAlias  ::= Type
+RecordType ::= '{' Sep(FieldType, ',') '}'
+DataType   ::= Sep1(ConDecl, '|')
+
+FieldType  ::= Id ':' Type
+ConDecl    ::= Con ['(' Sep1(Type, ',') ')']
+```
+
+For example,
+```sophia
+record   point('a) = {x : 'a, y : 'a}
+datatype shape('a) = Circle(point('a), 'a) | Rect(point('a), point('a))
+type     int_shape = shape(int)
+```
+
+## Types
+
+```c
+Type ::= Domain '=>' Type             // Function type
+       | Type '(' Sep(Type, ',') ')'  // Type application
+       | '(' Type ')'                 // Parens
+       | 'unit' | Sep(Type, '*')      // Tuples
+       | Id | QId | TVar
+
+Domain ::= Type                       // Single argument
+         | '(' Sep(Type, ',') ')'     // Multiple arguments
+```
+
+The function type arrow associates to the right.
+
+Example,
+```sophia
+'a => list('a) => (int * list('a))
+```
+
+## Statements
+
+Function bodies are blocks of *statements*, where a statement is one of the following
+
+```c
+Stmt ::= 'switch' '(' Expr ')' Block(Case)
+       | 'if' '(' Expr ')' Block(Stmt)
+       | 'elif' '(' Expr ')' Block(Stmt)
+       | 'else' Block(Stmt)
+       | 'let' LetDef
+       | Expr
+
+LetDef ::= Id Args [':' Type] '=' Block(Stmt)   // Function definition
+         | Pattern '=' Block(Stmt)              // Value definition
+
+Case    ::= Pattern '=>' Block(Stmt)
+Pattern ::= Expr
+```
+
+`if` statements can be followed by zero or more `elif` statements and an optional final `else` statement. For example,
+
+```sophia
+let x : int = 4
+switch(f(x))
+  None => 0
+  Some(y) =>
+    if(y > 10)
+      "too big"
+    elif(y < 3)
+      "too small"
+    else
+      "just right"
+```
+
+## Expressions
+
+```c
+Expr ::= '(' LamArgs ')' '=>' Block(Stmt)   // Anonymous function    (x) => x + 1
+       | '(' BinOp ')'                      // Operator lambda       (+)
+       | 'if' '(' Expr ')' Expr 'else' Expr // If expression         if(x < y) y else x
+       | Expr ':' Type                      // Type annotation       5 : int
+       | Expr BinOp Expr                    // Binary operator       x + y
+       | UnOp Expr                          // Unary operator        ! b
+       | Expr '(' Sep(Expr, ',') ')'        // Application           f(x, y)
+       | Expr '.' Id                        // Projection            state.x
+       | Expr '[' Expr ']'                  // Map lookup            map[key]
+       | Expr '{' Sep(FieldUpdate, ',') '}' // Record or map update  r{ fld[key].x = y }
+       | '[' Sep(Expr, ',') ']'             // List                  [1, 2, 3]
+       | '[' Expr '|' Sep(Generator, ',') ']'
+                                            // List comprehension    [k | x <- [1], if (f(x)), let k = x+1]
+       | '[' Expr '..' Expr ']'             // List range            [1..n]
+       | '{' Sep(FieldUpdate, ',') '}'      // Record or map value   {x = 0, y = 1}, {[key] = val}
+       | '(' Expr ')'                       // Parens                (1 + 2) * 3
+       | Id | Con | QId | QCon              // Identifiers           x, None, Map.member, AELib.Token
+       | Int | Bytes | String | Char        // Literals              123, 0xff, #00abc123, "foo", '%'
+       | AccountAddress | ContractAddress   // Chain identifiers
+       | OracleAddress | OracleQueryId      // Chain identifiers
+
+Generator ::= Pattern '<-' Expr   // Generator
+            | 'if' '(' Expr ')'   // Guard
+            | LetDef              // Definition
+
+LamArgs ::= '(' Sep(LamArg, ',') ')'
+LamArg  ::= Id [':' Type]
+
+FieldUpdate ::= Path '=' Expr
+Path ::= Id                 // Record field
+       | '[' Expr ']'       // Map key
+       | Path '.' Id        // Nested record field
+       | Path '[' Expr ']'  // Nested map key
+
+BinOp ::= '||' | '&&' | '<' | '>' | '=<' | '>=' | '==' | '!='
+        | '::' | '++' | '+' | '-' | '*' | '/' | 'mod' | '^'
+        | '|>'
+UnOp  ::= '-' | '!'
+```
+
+## Operators types
+
+| Operators | Type
+| --- | ---
+| `-` `+` `*` `/` `mod` `^` | arithmetic operators
+| `!` `&&` `\|\|` | logical operators
+| `==` `!=` `<` `>` `=<` `>=` | comparison operators
+| `::` `++` | list operators
+| `\|>` | functional operators
+
+## Operator precendences
+
+In order of highest to lowest precedence.
+
+| Operators | Associativity
+| --- | ---
+| `!` | right
+| `^` | left
+| `*` `/` `mod` | left
+| `-` (unary) | right
+| `+` `-` | left
+| `::` `++` | right
+| `<` `>` `=<` `>=` `==` `!=` | none
+| `&&` | right
+| `\|\|` | right
+| `\|>` | left
@@ -7,13 +7,13 @@ namespace BLS12_381 =
  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))
+  function pairing_check(us : list(g1), vs : list(g2)) =
+    switch((us, vs))
      ([], []) => 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))
+  function pairing_check_(acc : gt, us : list(g1), vs : list(g2)) =
+    switch((us, vs))
      ([], []) => gt_is_one(acc)
      (x :: xs, y :: ys) =>
        pairing_check_(gt_mul(acc, pairing(x, y)), xs, ys)
@@ -0,0 +1,126 @@
+@compiler >= 4.3
+
+namespace Bitwise =
+
+  // bit shift 'x' right 'n' postions
+  function bsr(n : int, x : int) : int =
+    let step = 2^n
+    let res  = x / step
+    if (x >= 0 || x mod step == 0)
+      res
+    else
+      res - 1
+
+  // bit shift 'x' left 'n' positions
+  function bsl(n : int, x : int) : int =
+    x * 2^n
+
+  // bit shift 'x' left 'n' positions, limit at 'lim' bits
+  function bsli(n : int, x : int, lim : int) : int =
+    (x * 2^n) mod (2^lim)
+
+  // bitwise 'and' for arbitrary precision integers
+  function band(a : int, b : int) : int =
+      if (a >= 0 && b >= 0)
+        uband_(a, b)
+      elif (b >= 0)
+        ubnand_(b, -1 - a)
+      elif (a >= 0)
+        ubnand_(a, -1 - b)
+      else
+        -1 - ubor_(-1 - a, -1 - b)
+
+  // bitwise 'or' for arbitrary precision integers
+  function
+    bor : (int, int) => int
+    bor(0, b) = b
+    bor(a, 0) = a
+    bor(a : int, b : int) : int =
+      if (a >= 0 && b >= 0)
+        ubor_(a, b)
+      elif (b >= 0)
+        -1 - ubnand_(-1 - a, b)
+      elif (a >= 0)
+        -1 - ubnand_(-1 - b, a)
+      else
+        -1 - uband_(-1 - a, -1 - b)
+
+  // bitwise 'xor' for arbitrary precision integers
+  function
+    bxor : (int, int) => int
+    bxor(0, b) = b
+    bxor(a, 0) = a
+    bxor(a, b) =
+      if (a >= 0 && b >= 0)
+        ubxor_(a, b)
+      elif (b >= 0)
+        -1 - ubxor_(-1 - a, b)
+      elif (a >= 0)
+        -1 - ubxor_(a, -1 - b)
+      else
+        ubxor_(-1 - a, -1 - b)
+
+  // bitwise 'not' for arbitrary precision integers
+  function bnot(a : int) = bxor(a, -1)
+
+  // Bitwise 'and' for non-negative integers
+  function uband(a : int, b : int) : int =
+    require(a >= 0 && b >= 0, "uband is only defined for non-negative integers")
+    switch((a, b))
+      (0, _) => 0
+      (_, 0) => 0
+      _      => uband__(a, b, 1, 0)
+
+  private function uband_(a, b) = uband__(a, b, 1, 0)
+
+  private function
+    uband__(0, b, val, acc) = acc
+    uband__(a, 0, val, acc) = acc
+    uband__(a, b, val, acc) =
+      switch (a mod 2 + b mod 2)
+        2 => uband__(a / 2, b / 2, val * 2, acc + val)
+        _ => uband__(a / 2, b / 2, val * 2, acc)
+
+  // Bitwise 'or' for non-negative integers
+  function ubor(a, b) =
+    require(a >= 0 && b >= 0, "ubor is only defined for non-negative integers")
+    switch((a, b))
+      (0, _) => b
+      (_, 0) => a
+      _      => ubor__(a, b, 1, 0)
+
+  private function ubor_(a, b) = ubor__(a, b, 1, 0)
+
+  private function
+    ubor__(0, 0, val, acc) = acc
+    ubor__(a, b, val, acc) =
+      switch (a mod 2 + b mod 2)
+        0 => ubor__(a / 2, b / 2, val * 2, acc)
+        _ => ubor__(a / 2, b / 2, val * 2, acc + val)
+
+  //Bitwise 'xor' for non-negative integers
+  function
+    ubxor : (int, int) => int
+    ubxor(0, b) = b
+    ubxor(a, 0) = a
+    ubxor(a, b) =
+      require(a >= 0 && b >= 0, "ubxor is only defined for non-negative integers")
+      ubxor__(a, b, 1, 0)
+
+  private function ubxor_(a, b) = ubxor__(a, b, 1, 0)
+
+  private function
+    ubxor__(0, 0, val, acc) = acc
+    ubxor__(a, b, val, acc) =
+      switch(a mod 2 + b mod 2)
+        1 => ubxor__(a / 2, b / 2, val * 2, acc + val)
+        _ => ubxor__(a / 2, b / 2, val * 2, acc)
+
+  private function ubnand_(a, b) = ubnand__(a, b, 1, 0)
+
+  private function
+    ubnand__(0, b, val, acc) = acc
+    ubnand__(a, b, val, acc) =
+      switch((a mod 2, b mod 2))
+        (1, 0) => ubnand__(a / 2, b / 2, val * 2, acc + val)
+        _      => ubnand__(a / 2, b / 2, val * 2, acc)
@@ -1,3 +1,5 @@
+include "String.aes"
+
 namespace Frac =

  private function gcd(a : int, b : int) =
@@ -2,7 +2,7 @@ namespace Func =

  function id(x : 'a) : 'a = x

-  function const(x : 'a) : 'b => 'a = (y) => x
+  function const(x : 'a) : 'b => 'a = (_) => x

  function flip(f : ('a, 'b) => 'c) : ('b, 'a) => 'c = (b, a) => f(a, b)

@@ -29,7 +29,9 @@ namespace List =
    []   => abort("drop_last_unsafe: list empty")


-  function contains(e : 'a, l : list('a)) = switch(l)
+  function
+    contains : 'a is eq; ('a, list('a)) => bool
+    contains(e, l) = switch(l)
      []   => false
      h::t => h == e || contains(e, t)

@@ -80,6 +82,7 @@ namespace List =
 * `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) =
+    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
@@ -172,7 +175,7 @@ namespace List =
   if (n == 0) l
   else switch(l)
      []   => []
-      h::t => drop_(n-1, t)
+      _::t => drop_(n-1, t)

 /** Get the longest prefix of a list in which every element
 * matches predicate `p`
@@ -190,7 +193,7 @@ 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)) = switch(l)
+  function partition(p : 'a => bool, lst : list('a)) : (list('a) * list('a)) = switch(lst)
    []   => ([], [])
    h::t =>
      let (l, r) = partition(p, t)
@@ -208,10 +211,13 @@ 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 the tail of the longer list.
@@ -235,11 +241,67 @@ namespace List =
      (h1::t1, h2::t2)


-  // TODO: Improve?
-  function sort(lesser_cmp : ('a, 'a) => bool, l : list('a)) : list('a) = switch(l)
-    []   => []
-    h::t => switch (partition((x) => lesser_cmp(x, h), t))
-      (lesser, bigger) => sort(lesser_cmp, lesser) ++ h::sort(lesser_cmp, bigger)
+  /** Merges two sorted lists using `lt` comparator
+   */
+  function
+    merge : (('a, 'a) => bool, list('a), list('a)) => list('a)
+    merge(lt, x::xs, y::ys) =
+      if(lt(x, y)) x::merge(lt, xs, y::ys)
+      else y::merge(lt, x::xs, ys)
+    merge(_, [], ys) = ys
+    merge(_, xs, []) = xs
+
+
+  /** Mergesort inspired by
+   * https://hackage.haskell.org/package/base-4.14.1.0/docs/src/Data.OldList.html#sort
+   */
+  function
+    sort : (('a, 'a) => bool, list('a)) => list('a)
+    sort(_, []) = []
+    sort(lt, l) =
+      merge_all(lt, monotonic_subs(lt, l))
+
+  /** Splits list into compound increasing sublists
+   */
+  private function
+    monotonic_subs : (('a, 'a) => bool, list('a)) => list(list('a))
+    monotonic_subs(lt, x::y::rest) =
+      if(lt(y, x)) desc(lt, y, [x], rest)
+      else asc(lt, y, [x], rest)
+    monotonic_subs(_, l) = [l]
+
+  /** Extracts the longest descending prefix and proceeds with monotonic split
+   */
+  private function
+    desc : (('a, 'a) => bool, 'a, list('a), list('a)) => list(list('a))
+    desc(lt, x, acc, h::t) =
+      if(lt(x, h)) (x::acc) :: monotonic_subs(lt, h::t)
+      else desc(lt, h, x::acc, t)
+    desc(_, x, acc, []) = [x::acc]
+
+  /** Extracts the longest ascending prefix and proceeds with monotonic split
+   */
+  private function
+    asc : (('a, 'a) => bool, 'a, list('a), list('a)) => list(list('a))
+    asc(lt, x, acc, h::t) =
+      if(lt(h, x)) List.reverse(x::acc) :: monotonic_subs(lt, h::t)
+      else asc(lt, h, x::acc, t)
+    asc(_, x, acc, []) = [List.reverse(x::acc)]
+
+  /** Merges list of sorted lists
+   */
+  private function
+    merge_all : (('a, 'a) => bool, list(list('a))) => list('a)
+    merge_all(_, [part]) = part
+    merge_all(lt, parts) = merge_all(lt, merge_pairs(lt, parts))
+
+  /** Single round of `merge_all` – pairs of lists in a list of list
+   */
+  private function
+    merge_pairs : (('a, 'a) => bool, list(list('a))) => list(list('a))
+    merge_pairs(lt, x::y::rest) = merge(lt, x, y) :: merge_pairs(lt, rest)
+    merge_pairs(_, l) = l
+

 /** Puts `delim` between every two members of the list
 */
@@ -2,8 +2,8 @@ namespace ListInternal =

  // -- Flatmap ----------------------------------------------------------------

-  function flat_map(f : 'a => list('b), xs : list('a)) : list('b) =
-    switch(xs)
+  function flat_map(f : 'a => list('b), lst : list('a)) : list('b) =
+    switch(lst)
      []      => []
      x :: xs => f(x) ++ flat_map(f, xs)

@@ -1,5 +1,3 @@
-include "List.aes"
-
 namespace Option =

  function is_none(o : option('a)) : bool = switch(o)
@@ -26,7 +24,15 @@ namespace Option =
    None    => abort("Forced None value")
    Some(x) => x

-  function contains(e : 'a, o : option('a)) = o == Some(e)
+/** 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 : 'a is eq; ('a, option('a)) => bool
+    contains(e, o) = o == Some(e)

  function on_elem(o : option('a), f : 'a => unit) : unit = match((), f, o)

@@ -0,0 +1,51 @@
+include "List.aes"
+include "Option.aes"
+include "Pair.aes"
+
+namespace Set =
+  record set('a) = { to_map : map('a, unit) }
+
+  function new() : set('a) =
+    { to_map = {} }
+
+  function member(e : 'a, s : set('a)) : bool =
+    Map.member(e, s.to_map)
+
+  function insert(e : 'a, s : set('a)) : set('a) =
+    { to_map = s.to_map{[e] = ()} }
+
+  function delete(e : 'a, s : set('a)) : set('a) =
+    { to_map = Map.delete(e, s.to_map) }
+
+  function size(s : set('a)) : int =
+    Map.size(s.to_map)
+
+  function to_list(s : set('a)) : list('a) =
+    List.map(Pair.fst, Map.to_list(s.to_map))
+
+  function from_list(l : list('a)) : set('a) =
+    { to_map = Map.from_list(List.map((x) => (x, ()), l)) }
+
+  function filter(p : 'a => bool, s : set('a)) : set('a) =
+    from_list(List.filter(p, to_list(s)))
+
+  function fold(f : ('a, 'b) => 'b, acc : 'b, s : set('a)) : 'b =
+    List.foldr(f, acc, to_list(s))
+
+  function subtract(s1 : set('a), s2 : set('a)) : set('a) =
+    filter((x) => !member(x, s2), s1)
+
+  function intersection(s1 : set('a), s2 : set('a)) : set('a) =
+    filter((x) => member(x, s2), s1)
+
+  function intersection_list(sets : list(set('a))) : set('a) =
+    List.foldr(
+      intersection,
+      Option.default(new(), List.first(sets)),
+      Option.default([], List.tail(sets)))
+
+  function union(s1 : set('a), s2 : set('a)) : set('a) =
+    from_list(to_list(s1) ++ to_list(s2))
+
+  function union_list(sets : list(set('a))) : set('a) =
+    List.foldr(union, new(), sets)
@@ -53,21 +53,21 @@ namespace String =

  // 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)
+  function to_int(str : string) : option(int) =
+    let lst = StringInternal.to_list(str)
+    switch(is_prefix(['-'], lst))
+      None    => to_int_pos(lst)
      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))
+  private function to_int_pos(chs : list(char)) =
+    switch(is_prefix(['0', 'x'], chs))
      None =>
-        to_int_(s, ch_to_int_10, 0, 10)
-      Some(s) =>
-        to_int_(s, ch_to_int_16, 0, 16)
+        to_int_(chs, ch_to_int_10, 0, 10)
+      Some(str) =>
+        to_int_(str, ch_to_int_16, 0, 16)

  private function
    tokens_(_, [], acc) = [StringInternal.from_list(List.reverse(acc))]
@@ -84,12 +84,13 @@ namespace String =
    contains_(ix, str, substr) =
      switch(is_prefix(substr, str))
        None =>
-          let _ :: str = str
-          contains_(ix + 1, str, substr)
+          let _ :: tailstr = str
+          contains_(ix + 1, tailstr, substr)
        Some(_) =>
          Some(ix)

  private function
+    is_prefix : (list(char), list(char)) => option(list(char))
    is_prefix([], ys) = Some(ys)
    is_prefix(_, [])  = None
    is_prefix(x :: xs, y :: ys) =
@@ -98,18 +99,18 @@ namespace String =

  private function
    to_int_([], _, x, _) = Some(x)
-    to_int_(i :: is, value, x, b) =
+    to_int_(i :: ints, value, x, b) =
      switch(value(i))
        None => None
-        Some(i) => to_int_(is, value, x * b + i, b)
+        Some(i) => to_int_(ints, value, x * b + i, b)

-  private function ch_to_int_10(c) =
-    let c = Char.to_int(c)
+  private function ch_to_int_10(ch) =
+    let c = Char.to_int(ch)
    if(c >= 48 && c =< 57) Some(c - 48)
    else None

-  private function ch_to_int_16(c) =
-    let c = Char.to_int(c)
+  private function ch_to_int_16(ch) =
+    let c = Char.to_int(ch)
    if(c >= 48 && c =< 57)    Some(c - 48)
    elif(c >= 65 && c =< 70)  Some(c - 55)
    elif(c >= 97 && c =< 102) Some(c - 87)
@@ -2,7 +2,7 @@

 {erl_opts, [debug_info]}.

-{deps, [ {aebytecode, {git, "https://github.com/aeternity/aebytecode.git", {ref,"7f0d309"}}}
+{deps, [ {aebytecode, {git, "https://github.com/aeternity/aebytecode.git", {ref,"0699f35"}}}
       , {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.1.0"},
         [aesophia, aebytecode, getopt]},

        {dev_mode, true},
@@ -1,7 +1,7 @@
 {"1.1.0",
 [{<<"aebytecode">>,
  {git,"https://github.com/aeternity/aebytecode.git",
-       {ref,"7f0d3090d4dc6c4d5fca7645b0c21eb0e65ad208"}},
+       {ref,"0699f35b0398bac6cd4468da654d608375bd853d"}},
  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]),
+        {TypedAst, _, _} = aeso_ast_infer_types:infer(Ast, [dont_unfold | Options]),
        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",
@@ -248,8 +254,8 @@ decode_contract(_) -> [].
 decode_funcs(Fs) -> [ decode_func(F) || F <- Fs ].

 %% decode_func(#{name := init}) -> [];
-decode_func(#{name := Name, payable := Payable, arguments := As, returns := T}) ->
-    ["  ", payable(Payable), "entrypoint ", io_lib:format("~s", [Name]), " : ",
+decode_func(#{name := Name, stateful:= Stateful, payable := Payable, arguments := As, returns := T}) ->
+    ["  ", payable(Payable), stateful(Stateful), "entrypoint ", io_lib:format("~s", [Name]), " : ",
     decode_args(As), " => ", decode_type(T), $\n].

 decode_args(As) ->
@@ -330,12 +336,15 @@ decode_tvar(#{name := N}) -> io_lib:format("~s", [N]).
 payable(true)  -> "payable ";
 payable(false) -> "".

+stateful(true)  -> "stateful ";
+stateful(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().
@@ -53,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()}
@@ -93,7 +96,8 @@
                     | nil
                     | {'::', var_name(), var_name()}
                     | {con, arities(), tag(), [var_name()]}
-                     | {tuple, [var_name()]}.
+                     | {tuple, [var_name()]}
+                     | {assign, var_name(), var_name()}.

 -type ftype() :: integer
               | boolean
@@ -136,9 +140,10 @@
 -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()}.

@@ -147,13 +152,15 @@
 -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() } }.
+                  functions     := #{ fun_name() => fun_def() }
+               }.

 -define(HASH_BYTES, 32).

@@ -161,17 +168,26 @@

 %% 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 ------------------------------------------------------------
@@ -182,6 +198,7 @@ init_env(Options) ->
    #{ 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] },
@@ -217,7 +234,8 @@ init_env(Options) ->
                      ["Chain", "GAAttachTx"]             => #con_tag{ tag = 21, arities = ChainTxArities }
                     },
       options   => Options,
-       functions => #{} }.
+       functions => #{}
+    }.

 -spec builtins() -> builtins().
 builtins() ->
@@ -227,9 +245,9 @@ 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}, {"expiry", 1}, {"query_fee", 1}, {"query", 5}, {"get_question", 2},
                              {"respond", 4}, {"extend", 3}, {"get_answer", 2},
@@ -269,7 +287,7 @@ state_layout(Env) -> maps:get(state_layout, Env, {reg, 1}).
 -spec init_type_env() -> type_env().
 init_type_env() ->
    BaseTx = {variant, [[address, integer, string], [], [], [], [], [], [string],
-                        [hash], [hash], [address, hash], [address],
+                        [{bytes, 32}], [{bytes, 32}], [address, {bytes, 32}], [address],
                        [address, integer], [address, integer], [address],
                        [address], [address], [address], [address], [address],
                        [integer], [address, integer], []]},
@@ -307,31 +325,45 @@ get_option(Opt, Env, Default) ->

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

-spec to_fcode(env(), aeso_syntax:ast()) -> fcode().
-to_fcode(Env, [{contract, Attrs, MainCon = {con, _, Main}, Decls}]) ->
+-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,
-    MainEnv = Env#{ context  => {main_contract, Main},
-                    builtins => Builtins#{[Main, "state"]          => {get_state, none},
-                                          [Main, "put"]            => {set_state, 1},
-                                          [Main, "Chain", "event"] => {chain_event, 1}} },
+            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(MainEnv, Decls),
-    StateType   = lookup_type(Env1, [Main, "state"], [], {tuple, []}),
-    EventType   = lookup_type(Env1, [Main, "event"], [], none),
+                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),
-    #{ contract_name => Main,
+            ConFcode = #{ contract_name => Name,
                          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);
+                          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_main_contract, NotMain});
 to_fcode(Env, [{namespace, _, {con, _, Con}, Decls} | Code]) ->
    Env1 = decls_to_fcode(Env#{ context => {namespace, Con} }, Decls),
    to_fcode(Env1, Code).
@@ -341,13 +373,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
@@ -355,7 +385,7 @@ decl_to_fcode(Env = #{context := {main_contract, _}}, {fun_decl, _, Id, _}) ->
 decl_to_fcode(Env, {fun_decl, _, _, _})  -> Env;
 decl_to_fcode(Env, {type_def, _Ann, Name, Args, Def}) ->
    typedef_to_fcode(Env, Name, Args, Def);
-decl_to_fcode(Env = #{ functions := Funs }, {letfun, Ann, Id = {id, _, Name}, Args, Ret, Body}) ->
+decl_to_fcode(Env = #{ functions := Funs }, {letfun, Ann, Id = {id, _, Name}, Args, Ret, [{guarded, _, [], Body}]}) ->
    Attrs = get_attributes(Ann),
    FName = lookup_fun(Env, qname(Env, Name)),
    FArgs = args_to_fcode(Env, Args),
@@ -410,7 +440,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
@@ -436,7 +466,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});
@@ -461,8 +491,14 @@ 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, {constrained_t, _, _, TVar = {tvar, _, _}}) ->
+    type_to_fcode(Env, Sub, TVar);
+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],
@@ -628,8 +664,8 @@ expr_to_fcode(Env, _Type, {list_comp, As, Yield, [{comprehension_bind, Pat = {ty
    Arg  = fresh_name(),
    Env1 = bind_var(Env, Arg),
    Bind = {lam, [Arg], expr_to_fcode(Env1, {switch, As, {typed, As, {id, As, Arg}, PatType},
-                                                [{'case', As, Pat, {list_comp, As, Yield, Rest}},
-                                                 {'case', As, {id, As, "_"}, {list, As, []}}]})},
+                                                [{'case', As, Pat, [{guarded, As, [], {list_comp, As, Yield, Rest}}]},
+                                                 {'case', As, {id, As, "_"}, [{guarded, As, [], {list, As, []}}]}]})},
    {def_u, FlatMap, _} = resolve_fun(Env, ["ListInternal", "flat_map"]),
    {def, FlatMap, [Bind, expr_to_fcode(Env, BindExpr)]};
 expr_to_fcode(Env, Type, {list_comp, As, Yield, [{comprehension_if, _, Cond}|Rest]}) ->
@@ -649,9 +685,9 @@ expr_to_fcode(Env, _Type, {'if', _, Cond, Then, Else}) ->
            expr_to_fcode(Env, Else));

 %% Switch
-expr_to_fcode(Env, _, {switch, _, Expr = {typed, _, E, Type}, Alts}) ->
+expr_to_fcode(Env, _, S = {switch, _, Expr = {typed, _, E, Type}, Alts}) ->
    Switch = fun(X) ->
-                {switch, alts_to_fcode(Env, type_to_fcode(Env, Type), X, Alts)}
+                {switch, alts_to_fcode(Env, type_to_fcode(Env, Type), X, Alts, S)}
             end,
    case E of
        {id, _, X} -> Switch(X);
@@ -669,8 +705,11 @@ expr_to_fcode(Env, _Type, {block, _, Stmts}) ->
 expr_to_fcode(Env, _Type, Expr = {app, _, {Op, _}, [_, _]}) when Op == '&&'; Op == '||' ->
    Tree = expr_to_decision_tree(Env, Expr),
    decision_tree_to_fcode(Tree);
-expr_to_fcode(Env, _Type, {app, _Ann, {Op, _}, [A, B]}) when is_atom(Op) ->
-    {op, Op, [expr_to_fcode(Env, A), expr_to_fcode(Env, B)]};
+expr_to_fcode(Env, Type, {app, Ann, {Op, _}, [A, B]}) when is_atom(Op) ->
+    case Op of
+        '|>' -> expr_to_fcode(Env, Type, {app, Ann, B, [A]});
+        _    -> {op, Op, [expr_to_fcode(Env, A), expr_to_fcode(Env, B)]}
+    end;
 expr_to_fcode(Env, _Type, {app, _Ann, {Op, _}, [A]}) when is_atom(Op) ->
    case Op of
        '-' -> {op, '-', [{lit, {int, 0}}, expr_to_fcode(Env, A)]};
@@ -678,14 +717,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
@@ -747,6 +803,13 @@ make_if(Cond, Then, Else) ->
    X = fresh_name(),
    {'let', X, Cond, make_if({var, X}, Then, Else)}.

+make_if_no_else({var, X}, Then) ->
+    {switch, {split, boolean, X,
+        [{'case', {bool, true},  {nosplit, Then}}]}};
+make_if_no_else(Cond, Then) ->
+    X = fresh_name(),
+    {'let', X, Cond, make_if_no_else({var, X}, Then)}.
+
 -spec make_tuple([fexpr()]) -> fexpr().
 make_tuple([E]) -> E;
 make_tuple(Es) -> {tuple, Es}.
@@ -812,9 +875,9 @@ is_first_order(_)                      -> true.

 %% -- Pattern matching --

-spec alts_to_fcode(env(), ftype(), var_name(), [aeso_syntax:alt()]) -> fsplit().
-alts_to_fcode(Env, Type, X, Alts) ->
-    FAlts = [alt_to_fcode(Env, Alt) || Alt <- Alts],
+-spec alts_to_fcode(env(), ftype(), var_name(), [aeso_syntax:alt()], aeso_syntax:expr()) -> fsplit().
+alts_to_fcode(Env, Type, X, Alts, Switch) ->
+    FAlts = remove_guards(Env, Alts, Switch),
    split_tree(Env, [{X, Type}], FAlts).

 %% Intermediate format before case trees (fcase() and fsplit()).
@@ -825,7 +888,43 @@ alts_to_fcode(Env, Type, X, Alts) ->
              | {string, binary()}
              | nil | {'::', fpat(), fpat()}
              | {tuple, [fpat()]}
-              | {con, arities(), tag(), [fpat()]}.
+              | {con, arities(), tag(), [fpat()]}
+              | {assign, fpat(), fpat()}.
+
+remove_guards(_Env, [], _Switch) ->
+    [];
+remove_guards(Env, [Alt = {'case', _, _, [{guarded, _, [], _Expr}]} | Rest], Switch) ->
+    [alt_to_fcode(Env, Alt) | remove_guards(Env, Rest, Switch)];
+remove_guards(Env, [{'case', AnnC, Pat, [{guarded, AnnG, [Guard | Guards], Body} | GuardedBodies]} | Rest], Switch = {switch, Ann, Expr, _}) ->
+    FPat = pat_to_fcode(Env, Pat),
+    FGuard = expr_to_fcode(bind_vars(Env, pat_vars(FPat)), Guard),
+    FBody = expr_to_fcode(bind_vars(Env, pat_vars(FPat)), Body),
+    case Guards of
+        [] ->
+            R = case GuardedBodies of
+                    [] -> Rest;
+                    _  -> [{'case', AnnC, Pat, GuardedBodies} | Rest]
+                end,
+            case R of
+                [] ->
+                    [{'case', [FPat], make_if_no_else(FGuard, FBody)} | remove_guards(Env, Rest, Switch)];
+                _ ->
+                    FSwitch = expr_to_fcode(Env, {switch, Ann, Expr, R}),
+                    [{'case', [FPat], make_if(FGuard, FBody, FSwitch)} | remove_guards(Env, Rest, Switch)]
+            end;
+        _ ->
+            R1 = case GuardedBodies of
+                     [] -> [{'case', AnnC, Pat, [{guarded, AnnG, Guards, Body}]} | Rest];
+                     _  -> [{'case', AnnC, Pat, [{guarded, AnnG, Guards, Body} | GuardedBodies]} | Rest]
+                 end,
+            R2 = case GuardedBodies of
+                     [] -> Rest;
+                     _  -> [{'case', AnnC, Pat, GuardedBodies} | Rest]
+                 end,
+            FSwitch1 = expr_to_fcode(Env, {switch, Ann, Expr, R1}),
+            FSwitch2 = expr_to_fcode(Env, {switch, Ann, Expr, R2}),
+            [{'case', [FPat], make_if(FGuard, FSwitch1, FSwitch2)} | remove_guards(Env, Rest, Switch)]
+    end.

 %% %% Invariant: the number of variables matches the number of patterns in each falt.
 -spec split_tree(env(), [{var_name(), ftype()}], [falt()]) -> fsplit().
@@ -925,6 +1024,8 @@ split_pat({'::', P, Q}) -> {{'::', fresh_name(), fresh_name()}, [P, Q]};
 split_pat({con, As, I, Pats}) ->
    Xs = [fresh_name() || _ <- Pats],
    {{con, As, I, Xs}, Pats};
+split_pat({assign, X = {var, _}, P}) ->
+    {{assign, fresh_name(), fresh_name()}, [X, P]};
 split_pat({tuple, Pats}) ->
    Xs = [fresh_name() || _ <- Pats],
    {{tuple, Xs}, Pats}.
@@ -935,6 +1036,7 @@ split_vars({int, _},    integer)     -> [];
 split_vars({string, _}, string)      -> [];
 split_vars(nil,         {list, _})   -> [];
 split_vars({'::', X, Xs}, {list, T}) -> [{X, T}, {Xs, {list, T}}];
+split_vars({assign, X, P}, T)        -> [{X, T}, {P, T}];
 split_vars({con, _, I, Xs}, {variant, Cons}) ->
    lists:zip(Xs, lists:nth(I + 1, Cons));
 split_vars({tuple, Xs}, {tuple, Ts}) ->
@@ -950,7 +1052,7 @@ next_split(Pats) ->
    end.

 -spec alt_to_fcode(env(), aeso_syntax:alt()) -> falt().
-alt_to_fcode(Env, {'case', _, Pat, Expr}) ->
+alt_to_fcode(Env, {'case', _, Pat, [{guarded, _, [], Expr}]}) ->
    FPat  = pat_to_fcode(Env, Pat),
    FExpr = expr_to_fcode(bind_vars(Env, pat_vars(FPat)), Expr),
    {'case', [FPat], FExpr}.
@@ -990,6 +1092,8 @@ pat_to_fcode(Env, {record_t, Fields}, {record, _, FieldPats}) ->
                    end end,
    make_tuple([pat_to_fcode(Env, FieldPat(Field))
                || Field <- Fields]);
+pat_to_fcode(Env, _Type, {letpat, _, Id = {typed, _, {id, _, _}, _}, Pattern}) ->
+    {assign, pat_to_fcode(Env, Id), pat_to_fcode(Env, Pattern)};

 pat_to_fcode(_Env, Type, Pat) ->
    error({todo, Pat, ':', Type}).
@@ -1026,8 +1130,8 @@ decision_tree_to_fcode({'if', A, Then, Else}) ->
 stmts_to_fcode(Env, [{letval, _, {typed, _, {id, _, X}, _}, Expr} | Stmts]) ->
    {'let', X, expr_to_fcode(Env, Expr), stmts_to_fcode(bind_var(Env, X), Stmts)};
 stmts_to_fcode(Env, [{letval, Ann, Pat, Expr} | Stmts]) ->
-    expr_to_fcode(Env, {switch, Ann, Expr, [{'case', Ann, Pat, {block, Ann, Stmts}}]});
-stmts_to_fcode(Env, [{letfun, Ann, {id, _, X}, Args, _Type, Expr} | Stmts]) ->
+    expr_to_fcode(Env, {switch, Ann, Expr, [{'case', Ann, Pat, [{guarded, Ann, [], {block, Ann, Stmts}}]}]});
+stmts_to_fcode(Env, [{letfun, Ann, {id, _, X}, Args, _Type, [{guarded, _, [], Expr}]} | Stmts]) ->
    LamArgs = [ case Arg of
                    {typed, Ann1, Id, T} -> {arg, Ann1, Id, T};
                    _ -> internal_error({bad_arg, Arg})   %% pattern matching has been desugared
@@ -1480,6 +1584,7 @@ match_pat(L, {lit, L})                      -> [];
 match_pat(nil, nil)                         -> [];
 match_pat({'::', X, Y}, {op, '::', [A, B]}) -> [{X, A}, {Y, B}];
 match_pat({var, X}, E)                      -> [{X, E}];
+match_pat({assign, X, P}, E)                -> [{X, E}, {P, E}];
 match_pat(_, _)                             -> false.

 constructor_form(Env, Expr) ->
@@ -1614,6 +1719,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) ->
@@ -1628,7 +1737,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;
@@ -1640,7 +1749,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.

@@ -1711,6 +1820,7 @@ pat_vars(nil)                 -> [];
 pat_vars({'::', P, Q})        -> pat_vars(P) ++ pat_vars(Q);
 pat_vars({tuple, Ps})         -> pat_vars(Ps);
 pat_vars({con, _, _, Ps})     -> pat_vars(Ps);
+pat_vars({assign, X, P})      -> pat_vars(X) ++ pat_vars(P);
 pat_vars(Ps) when is_list(Ps) -> [X || P <- Ps, X <- pat_vars(P)].

 -spec fsplit_pat_vars(fsplit_pat()) -> [var_name()].
@@ -1931,7 +2041,11 @@ rename_spat(Ren, {con, Ar, C, Xs}) ->
    {{con, Ar, C, Zs}, Ren1};
 rename_spat(Ren, {tuple, Xs}) ->
    {Zs, Ren1} = rename_bindings(Ren, Xs),
-    {{tuple, Zs}, Ren1}.
+    {{tuple, Zs}, Ren1};
+rename_spat(Ren, {assign, X, P}) ->
+    {X1, Ren1} = rename_binding(Ren, X),
+    {P1, Ren2} = rename_binding(Ren1, P),
+    {{assign, X1, P1}, Ren2}.

 rename_split(Ren, {split, Type, X, Cases}) ->
    {split, Type, rename_var(Ren, X), [rename_case(Ren, C) || C <- Cases]};
@@ -1987,8 +2101,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)).
@@ -2105,7 +2222,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})).
@@ -1,684 +0,0 @@
-%%%-------------------------------------------------------------------
-%%% @copyright (C) 2018, Aeternity Anstalt
-%%% @doc
-%%%     Compiler builtin functions for Aeterinty Sophia language.
-%%% @end
-%%% Created : 20 Dec 2018
-%%%
-%%%-------------------------------------------------------------------
-
-module(aeso_builtins).
-
-export([ builtin_function/1
-        , bytes_to_raw_string/2
-        , check_event_type/1
-        , used_builtins/1 ]).
-
-import(aeso_ast_to_icode, [prim_call/5]).
-
-include_lib("aebytecode/include/aeb_opcodes.hrl").
-include("aeso_icode.hrl").
-
-used_builtins(#funcall{ function = #var_ref{ name = {builtin, Builtin} }, args = Args }) ->
-    lists:umerge(dep_closure([Builtin]), used_builtins(Args));
-used_builtins([H|T]) ->
-  lists:umerge(used_builtins(H), used_builtins(T));
-used_builtins(T) when is_tuple(T) ->
-  used_builtins(tuple_to_list(T));
-used_builtins(M) when is_map(M) ->
-  used_builtins(maps:to_list(M));
-used_builtins(_) -> [].
-
-builtin_deps(Builtin) ->
-    lists:usort(builtin_deps1(Builtin)).
-
-builtin_deps1({map_lookup_default, Type}) -> [{map_lookup, Type}];
-builtin_deps1({map_get, Type})            -> [{map_lookup, Type}];
-builtin_deps1(map_member)                 -> [{map_lookup, word}];
-builtin_deps1({map_upd, Type})            -> [{map_get, Type}, map_put];
-builtin_deps1({map_upd_default, Type})    -> [{map_lookup_default, Type}, map_put];
-builtin_deps1(map_from_list)              -> [map_put];
-builtin_deps1(str_equal)                  -> [str_equal_p];
-builtin_deps1(string_concat)              -> [string_concat_inner1, string_copy, string_shift_copy];
-builtin_deps1(int_to_str)                 -> [{baseX_int, 10}];
-builtin_deps1(addr_to_str)                -> [{baseX_int, 58}];
-builtin_deps1({baseX_int, X})             -> [{baseX_int_pad, X}];
-builtin_deps1({baseX_int_pad, X})         -> [{baseX_int_encode, X}];
-builtin_deps1({baseX_int_encode, X})      -> [{baseX_int_encode_, X}, {baseX_tab, X}, {baseX_digits, X}];
-builtin_deps1({bytes_to_str, _})          -> [bytes_to_str_worker, bytes_to_str_worker_x];
-builtin_deps1(string_reverse)             -> [string_reverse_];
-builtin_deps1(require)                    -> [abort];
-builtin_deps1(_)                          -> [].
-
-dep_closure(Deps) ->
-    case lists:umerge(lists:map(fun builtin_deps/1, Deps)) of
-        []    -> Deps;
-        Deps1 -> lists:umerge(Deps, dep_closure(Deps1))
-    end.
-
-%% Helper functions/macros
-v(X) when is_atom(X) -> v(atom_to_list(X));
-v(X) when is_list(X) -> #var_ref{name = X}.
-
-option_none()  -> {tuple, [{integer, 0}]}.
-option_some(X) -> {tuple, [{integer, 1}, X]}.
-
-define(HASH_BYTES, 32).
-
-define(call(Fun, Args), #funcall{ function = #var_ref{ name = {builtin, Fun} }, args = Args }).
-define(I(X), {integer, X}).
-define(V(X), v(X)).
-define(A(Op), aeb_opcodes:mnemonic(Op)).
-define(LET(Var, Expr, Body), {switch, Expr, [{v(Var), Body}]}).
-define(DEREF(Var, Ptr, Body), {switch, operand(Ptr), [{{tuple, [v(Var)]}, Body}]}).
-define(NXT(Ptr), op('+', Ptr, 32)).
-define(NEG(A), op('/', A, {unop, '-', {integer, 1}})).
-define(BYTE(Ix, Word), op('byte', Ix, Word)).
-
-define(EQ(A, B), op('==', A, B)).
-define(LT(A, B), op('<', A, B)).
-define(GT(A, B), op('>', A, B)).
-define(ADD(A, B), op('+', A, B)).
-define(SUB(A, B), op('-', A, B)).
-define(MUL(A, B), op('*', A, B)).
-define(DIV(A, B), op('div', A, B)).
-define(MOD(A, B), op('mod', A, B)).
-define(EXP(A, B), op('^', A, B)).
-define(AND(A, B), op('&&', A, B)).
-
-%% Bit shift operations takes their arguments backwards!?
-define(BSL(X, B), op('bsl', ?MUL(B, 8), X)).
-define(BSR(X, B), op('bsr', ?MUL(B, 8), X)).
-
-op(Op, A, B) -> simpl({binop, Op, operand(A), operand(B)}).
-
-%% We generate a lot of B * 8 for integer B from BSL and BSR.
-simpl({binop, '*', {integer, A}, {integer, B}}) when A >= 0, B >= 0, A * B < 1 bsl 256 ->
-    {integer, A * B};
-simpl(Op) -> Op.
-
-
-operand(A) when is_atom(A) -> v(A);
-operand(I) when is_integer(I) -> {integer, I};
-operand(T) -> T.
-
-check_event_type(Icode) ->
-    case maps:get(event_type, Icode) of
-        {variant_t, Cons} ->
-            check_event_type(Cons, Icode);
-        _ ->
-            error({event_should_be_variant_type})
-    end.
-
-check_event_type(Evts, Icode) ->
-    [ check_event_type(Name, Ix, T, Icode)
-      || {constr_t, Ann, {con, _, Name}, Types} <- Evts,
-         {Ix, T} <- lists:zip(aeso_syntax:get_ann(indices, Ann), Types) ].
-
-check_event_type(EvtName, Ix, Type, Icode) ->
-    VMType =
-        try
-           aeso_ast_to_icode:ast_typerep(Type, Icode)
-        catch _:_ ->
-            error({EvtName, could_not_resolve_type, Type})
-        end,
-    case {Ix, VMType, Type} of
-        {indexed, word, _}      -> ok;
-        {notindexed, string, _} -> ok;
-        {notindexed, _, {bytes_t, _, N}} when N > 32 -> ok;
-        {indexed, _, _}         -> error({EvtName, indexed_field_should_be_word, is, VMType});
-        {notindexed, _, _}      -> error({EvtName, payload_should_be_string, is, VMType})
-    end.
-
-bfun(B, {IArgs, IExpr, IRet}) ->
-    {{builtin, B}, [private], IArgs, IExpr, IRet}.
-
-builtin_function(BF) ->
-    case BF of
-        {event, EventT}            -> bfun(BF, builtin_event(EventT));
-        abort                      -> bfun(BF, builtin_abort());
-        block_hash                 -> bfun(BF, builtin_block_hash());
-        require                    -> bfun(BF, builtin_require());
-        {map_lookup, Type}         -> bfun(BF, builtin_map_lookup(Type));
-        map_put                    -> bfun(BF, builtin_map_put());
-        map_delete                 -> bfun(BF, builtin_map_delete());
-        map_size                   -> bfun(BF, builtin_map_size());
-        {map_get, Type}            -> bfun(BF, builtin_map_get(Type));
-        {map_lookup_default, Type} -> bfun(BF, builtin_map_lookup_default(Type));
-        map_member                 -> bfun(BF, builtin_map_member());
-        {map_upd, Type}            -> bfun(BF, builtin_map_upd(Type));
-        {map_upd_default, Type}    -> bfun(BF, builtin_map_upd_default(Type));
-        map_from_list              -> bfun(BF, builtin_map_from_list());
-        list_concat                -> bfun(BF, builtin_list_concat());
-        string_length              -> bfun(BF, builtin_string_length());
-        string_concat              -> bfun(BF, builtin_string_concat());
-        string_concat_inner1       -> bfun(BF, builtin_string_concat_inner1());
-        string_copy                -> bfun(BF, builtin_string_copy());
-        string_shift_copy          -> bfun(BF, builtin_string_shift_copy());
-        str_equal_p                -> bfun(BF, builtin_str_equal_p());
-        str_equal                  -> bfun(BF, builtin_str_equal());
-        popcount                   -> bfun(BF, builtin_popcount());
-        int_to_str                 -> bfun(BF, builtin_int_to_str());
-        addr_to_str                -> bfun(BF, builtin_addr_to_str());
-        {baseX_int, X}             -> bfun(BF, builtin_baseX_int(X));
-        {baseX_digits, X}          -> bfun(BF, builtin_baseX_digits(X));
-        {baseX_tab, X}             -> bfun(BF, builtin_baseX_tab(X));
-        {baseX_int_pad, X}         -> bfun(BF, builtin_baseX_int_pad(X));
-        {baseX_int_encode, X}      -> bfun(BF, builtin_baseX_int_encode(X));
-        {baseX_int_encode_, X}     -> bfun(BF, builtin_baseX_int_encode_(X));
-        {bytes_to_int, N}          -> bfun(BF, builtin_bytes_to_int(N));
-        {bytes_to_str, N}          -> bfun(BF, builtin_bytes_to_str(N));
-        {bytes_concat, A, B}       -> bfun(BF, builtin_bytes_concat(A, B));
-        {bytes_split, A, B}        -> bfun(BF, builtin_bytes_split(A, B));
-        bytes_to_str_worker        -> bfun(BF, builtin_bytes_to_str_worker());
-        bytes_to_str_worker_x      -> bfun(BF, builtin_bytes_to_str_worker_x());
-        string_reverse             -> bfun(BF, builtin_string_reverse());
-        string_reverse_            -> bfun(BF, builtin_string_reverse_())
-    end.
-
-%% Event primitive (dependent on Event type)
-%%
-%% We need to switch on the event and prepare the correct #event for icode_to_asm
-%% NOTE: we assume all errors are already checked!
-builtin_event(EventT) ->
-    A         = fun(X) -> aeb_opcodes:mnemonic(X) end,
-    VIx       = fun(Ix) -> v(lists:concat(["v", Ix])) end,
-    ArgPats   = fun(Ts) -> [ VIx(Ix) || Ix <- lists:seq(0, length(Ts) - 1) ] end,
-    Payload = %% Should put data ptr, length on stack.
-        fun([])            -> {inline_asm, [A(?PUSH1), 0, A(?PUSH1), 0]};
-           ([{{id, _, "string"}, V}]) ->
-                {seq, [V, {inline_asm, [A(?DUP1), A(?MLOAD),  %% length, ptr
-                       A(?SWAP1), A(?PUSH1), 32, A(?ADD)]}]}; %% ptr+32, length
-           ([{{bytes_t, _, N}, V}]) -> {seq, [V, {integer, N}, {inline_asm, A(?SWAP1)}]}
-        end,
-    Ix =
-        fun({bytes_t, _, N}, V) when N < 32 -> ?BSR(V, 32 - N);
-           (_, V) -> V end,
-    Clause =
-        fun(_Tag, {con, _, Con}, IxTypes) ->
-            Types     = [ T || {_Ix, T} <- IxTypes ],
-            Indexed   = [ Ix(Type, Var) || {Var, {indexed, Type}} <- lists:zip(ArgPats(Types), IxTypes) ],
-            Data      = [ {Type, Var} || {Var, {notindexed, Type}} <- lists:zip(ArgPats(Types), IxTypes) ],
-            {ok, <<EvtIndexN:256>>} = eblake2:blake2b(?HASH_BYTES, list_to_binary(Con)),
-            EvtIndex  = {integer, EvtIndexN},
-            {event, lists:reverse(Indexed) ++ [EvtIndex], Payload(Data)}
-        end,
-    Pat = fun(Tag, Types) -> {tuple, [{integer, Tag} | ArgPats(Types)]} end,
-
-    {variant_t, Cons} = EventT,
-    Tags              = lists:seq(0, length(Cons) - 1),
-
-    {[{"e", event}],
-     {switch, v(e),
-         [{Pat(Tag, Types), Clause(Tag, Con, lists:zip(aeso_syntax:get_ann(indices, Ann), Types))}
-          || {Tag, {constr_t, Ann, Con, Types}} <- lists:zip(Tags, Cons) ]},
-     {tuple, []}}.
-
-%% Abort primitive.
-builtin_abort() ->
-    A = fun(X) -> aeb_opcodes:mnemonic(X) end,
-    {[{"s", string}],
-     {inline_asm, [A(?PUSH1),0,  %% Push a dummy 0 for the first arg
-                   A(?REVERT)]}, %% Stack: 0,Ptr
-     {tuple,[]}}.
-
-builtin_block_hash() ->
-    {[{"height", word}],
-     ?LET(hash, #prim_block_hash{ height = ?V(height)},
-          {ifte, ?EQ(hash, 0), option_none(), option_some(?V(hash))}),
-     aeso_icode:option_typerep(word)}.
-
-builtin_require() ->
-    {[{"c", word}, {"msg", string}],
-     {ifte, ?V(c), {tuple, []}, ?call(abort, [?V(msg)])},
-     {tuple, []}}.
-
-%% Map primitives
-builtin_map_lookup(Type) ->
-    Ret = aeso_icode:option_typerep(Type),
-    {[{"m", word}, {"k", word}],
-     prim_call(?PRIM_CALL_MAP_GET, #integer{value = 0},
-               [#var_ref{name = "m"}, #var_ref{name = "k"}],
-               [word, word], Ret),
-     Ret}.
-
-builtin_map_put() ->
-    %% We don't need the types for put.
-    {[{"m", word}, {"k", word}, {"v", word}],
-     prim_call(?PRIM_CALL_MAP_PUT, #integer{value = 0},
-               [v(m), v(k), v(v)], [word, word, word], word),
-     word}.
-
-builtin_map_delete() ->
-    {[{"m", word}, {"k", word}],
-     prim_call(?PRIM_CALL_MAP_DELETE, #integer{value = 0},
-               [v(m), v(k)], [word, word], word),
-     word}.
-
-builtin_map_size() ->
-    {[{"m", word}],
-     prim_call(?PRIM_CALL_MAP_SIZE, #integer{value = 0},
-               [v(m)], [word], word),
-     word}.
-
-%% Map builtins
-builtin_map_get(Type) ->
-    %% function map_get(m, k) =
-    %%   switch(map_lookup(m, k))
-    %%     Some(v) => v
-    {[{"m", word}, {"k", word}],
-     {switch, ?call({map_lookup, Type}, [v(m), v(k)]), [{option_some(v(v)), v(v)}]},
-     Type}.
-
-builtin_map_lookup_default(Type) ->
-    %% function map_lookup_default(m, k, default) =
-    %%   switch(map_lookup(m, k))
-    %%     None    => default
-    %%     Some(v) => v
-    {[{"m", word}, {"k", word}, {"default", Type}],
-     {switch, ?call({map_lookup, Type}, [v(m), v(k)]),
-         [{option_none(),     v(default)},
-          {option_some(v(v)), v(v)}]},
-     Type}.
-
-builtin_map_member() ->
-    %% function map_member(m, k) : bool =
-    %%   switch(Map.lookup(m, k))
-    %%     None => false
-    %%     _    => true
-    {[{"m", word}, {"k", word}],
-     {switch, ?call({map_lookup, word}, [v(m), v(k)]),
-         [{option_none(), {integer, 0}},
-          {{var_ref, "_"}, {integer, 1}}]},
-     word}.
-
-builtin_map_upd(Type) ->
-    %% function map_upd(map, key, fun) =
-    %%   map_put(map, key, fun(map_get(map, key)))
-    {[{"map", word}, {"key", word}, {"valfun", word}],
-     ?call(map_put,
-        [v(map), v(key),
-         #funcall{ function = v(valfun),
-                   args     = [?call({map_get, Type}, [v(map), v(key)])] }]),
-     word}.
-
-builtin_map_upd_default(Type) ->
-    %% function map_upd(map, key, val, fun) =
-    %%   map_put(map, key, fun(map_lookup_default(map, key, val)))
-    {[{"map", word}, {"key", word}, {"val", word}, {"valfun", word}],
-     ?call(map_put,
-        [v(map), v(key),
-         #funcall{ function = v(valfun),
-                   args     = [?call({map_lookup_default, Type}, [v(map), v(key), v(val)])] }]),
-     word}.
-
-builtin_map_from_list() ->
-    %% function map_from_list(xs, acc) =
-    %%   switch(xs)
-    %%     [] => acc
-    %%     (k, v) :: xs => map_from_list(xs, acc { [k] = v })
-    {[{"xs", {list, {tuple, [word, word]}}}, {"acc", word}],
-     {switch, v(xs),
-        [{{list, []}, v(acc)},
-         {{binop, '::', {tuple, [v(k), v(v)]}, v(ys)},
-          ?call(map_from_list,
-            [v(ys), ?call(map_put, [v(acc), v(k), v(v)])])}]},
-     word}.
-
-%% list_concat
-%%
-%% Concatenates two lists.
-builtin_list_concat() ->
-    {[{"l1", {list, word}}, {"l2", {list, word}}],
-     {switch, v(l1),
-        [{{list, []}, v(l2)},
-         {{binop, '::', v(hd), v(tl)},
-          {binop, '::', v(hd), ?call(list_concat, [v(tl), v(l2)])}}
-        ]
-     },
-     word}.
-
-builtin_string_length() ->
-    %% function length(str) =
-    %%   switch(str)
-    %%      {n} -> n  // (ab)use the representation
-    {[{"s", string}],
-     ?DEREF(n, s, ?V(n)),
-     word}.
-
-%% str_concat - concatenate two strings
-%%
-%% Unless the second string is the empty string, a new string is created at the
-%% top of the Heap and the address to it is returned. The tricky bit is when
-%% the words from the second string has to be shifted to fit next to the first
-%% string.
-builtin_string_concat() ->
-    {[{"s1", string}, {"s2", string}],
-     ?DEREF(n1, s1,
-     ?DEREF(n2, s2,
-        {ifte, ?EQ(n1, 0),
-            ?V(s2), %% First string is empty return second string
-            {ifte, ?EQ(n2, 0),
-                ?V(s1), %% Second string is empty return first string
-                ?LET(ret, {inline_asm, [?A(?MSIZE)]},
-                    {seq, [?ADD(n1, n2), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]}, %% Store total len
-                           ?call(string_concat_inner1, [?V(n1), ?NXT(s1), ?V(n2), ?NXT(s2)]),
-                           {inline_asm, [?A(?POP)]}, %% Discard fun ret val
-                           ?V(ret)                   %% Put the actual return value
-                          ]})}
-        }
-     )),
-     word}.
-
-builtin_string_concat_inner1() ->
-    %% Copy all whole words from the first string, and set up for word fusion
-    %% Special case when the length of the first string is divisible by 32.
-    {[{"n1", word}, {"p1", pointer}, {"n2", word}, {"p2", pointer}],
-     ?LET(w1, ?call(string_copy, [?V(n1), ?V(p1)]),
-        ?LET(nx, ?MOD(n1, 32),
-        {ifte, ?EQ(nx, 0),
-            ?LET(w2, ?call(string_copy, [?V(n2), ?V(p2)]),
-                {seq, [?V(w2), {inline_asm, [?A(?MSIZE), ?A(?MSTORE), ?A(?MSIZE)]}]}),
-            ?call(string_shift_copy, [?V(nx), ?V(w1), ?V(n2), ?V(p2)])
-        })),
-     word}.
-
-builtin_string_copy() ->
-    {[{"n", word}, {"p", pointer}],
-     ?DEREF(w, p,
-        {ifte, ?GT(n, 31),
-            {seq, [?V(w), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]},
-                   ?call(string_copy, [?SUB(n, 32), ?NXT(p)])]},
-            ?V(w)
-        }),
-     word}.
-
-builtin_string_shift_copy() ->
-    {[{"off", word}, {"dst", word}, {"n", word}, {"p", pointer}],
-     ?DEREF(w, p,
-        {seq, [?ADD(dst, ?BSR(w, off)), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]},
-               {ifte, ?GT(n, ?SUB(32, off)),
-                    ?call(string_shift_copy, [?V(off), ?BSL(w, ?SUB(32, off)), ?SUB(n, 32), ?NXT(p)]),
-                    {inline_asm, [?A(?MSIZE)]}}]
-        }),
-     word}.
-
-builtin_str_equal_p() ->
-    %% function str_equal_p(n, p1, p2) =
-    %%   if(n =< 0) true
-    %%   else
-    %%      let w1 = *p1
-    %%      let w2 = *p2
-    %%      w1 == w2 && str_equal_p(n - 32, p1 + 32, p2 + 32)
-    {[{"n", word}, {"p1", pointer}, {"p2", pointer}],
-     {ifte, ?LT(n, 1),
-         ?I(1),
-         ?DEREF(w1, p1,
-         ?DEREF(w2, p2,
-             ?AND(?EQ(w1, w2),
-                  ?call(str_equal_p, [?SUB(n, 32), ?NXT(p1), ?NXT(p2)]))))},
-     word}.
-
-builtin_str_equal() ->
-    %% function str_equal(s1, s2) =
-    %%   let n1 = length(s1)
-    %%   let n2 = length(s2)
-    %%   n1 == n2 && str_equal_p(n1, s1 + 32, s2 + 32)
-    {[{"s1", string}, {"s2", string}],
-     ?DEREF(n1, s1,
-     ?DEREF(n2, s2,
-         ?AND(?EQ(n1, n2), ?call(str_equal_p, [?V(n1), ?NXT(s1), ?NXT(s2)]))
-     )),
-     word}.
-
-%% Count the number of 1s in a bit field.
-builtin_popcount() ->
-    %% function popcount(bits, acc) =
-    %%   if (bits == 0) acc
-    %%   else popcount(bits bsr 1, acc + bits band 1)
-    {[{"bits", word}, {"acc", word}],
-     {ifte, ?EQ(bits, 0),
-        ?V(acc),
-        ?call(popcount, [op('bsr', 1, bits), ?ADD(acc, op('band', bits, 1))])
-     }, word}.
-
-builtin_int_to_str() ->
-    {[{"i", word}], ?call({baseX_int, 10}, [?V(i)]), word}.
-
-builtin_baseX_tab(_X = 10) ->
-    {[{"ix", word}], ?ADD($0, ix), word};
-builtin_baseX_tab(_X = 58) ->
-    <<Fst32:256>> = <<"123456789ABCDEFGHJKLMNPQRSTUVWXY">>,
-    <<Lst26:256>> = <<"Zabcdefghijkmnopqrstuvwxyz", 0:48>>,
-    {[{"ix", word}],
-     {ifte, ?LT(ix, 32),
-         ?BYTE(ix, Fst32),
-         ?BYTE(?SUB(ix, 32), Lst26)
-     },
-     word}.
-
-builtin_baseX_int(X) ->
-    {[{"w", word}],
-     ?LET(ret, {inline_asm, [?A(?MSIZE)]},
-        {seq, [?call({baseX_int_pad, X}, [?V(w), ?I(0), ?I(0)]), {inline_asm, [?A(?POP)]}, ?V(ret)]}),
-     word}.
-
-builtin_baseX_int_pad(X = 10) ->
-    {[{"src", word}, {"ix", word}, {"dst", word}],
-     {ifte, ?LT(src, 0),
-        ?call({baseX_int_encode, X}, [?NEG(src), ?I(1), ?BSL($-, 31)]),
-        ?call({baseX_int_encode, X}, [?V(src), ?V(ix), ?V(dst)])},
-     word};
-builtin_baseX_int_pad(X = 16) ->
-    {[{"src", word}, {"ix", word}, {"dst", word}],
-        ?call({baseX_int_encode, X}, [?V(src), ?V(ix), ?V(dst)]),
-     word};
-builtin_baseX_int_pad(X = 58) ->
-    {[{"src", word}, {"ix", word}, {"dst", word}],
-     {ifte, ?GT(?ADD(?DIV(ix, 31), ?BYTE(ix, src)), 0),
-         ?call({baseX_int_encode, X}, [?V(src), ?V(ix), ?V(dst)]),
-         ?call({baseX_int_pad, X}, [?V(src), ?ADD(ix, 1), ?ADD(dst, ?BSL($1, ?SUB(31, ix)))])},
-     word}.
-
-builtin_baseX_int_encode(X) ->
-    {[{"src", word}, {"ix", word}, {"dst", word}],
-     ?LET(n, ?call({baseX_digits, X}, [?V(src), ?I(0)]),
-        {seq, [?ADD(n, ?ADD(ix, 1)), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]},
-               ?call({baseX_int_encode_, X}, [?V(src), ?V(dst), ?EXP(X, n), ?V(ix)])]}),
-     word}.
-
-builtin_baseX_int_encode_(X) ->
-    {[{"src", word}, {"dst", word}, {"fac", word}, {"ix", word}],
-     {ifte, ?EQ(fac, 0),
-         {seq, [?V(dst), {inline_asm, [?A(?MSIZE), ?A(?MSTORE), ?A(?MSIZE)]}]},
-         {ifte, ?EQ(ix, 32),
-              %% We've filled a word, write it and start on new word
-              {seq, [?V(dst), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]},
-                     ?call({baseX_int_encode_, X}, [?V(src), ?I(0), ?V(fac), ?I(0)])]},
-              ?call({baseX_int_encode_, X},
-                    [?MOD(src, fac), ?ADD(dst, ?BSL(?call({baseX_tab, X}, [?DIV(src, fac)]), ?SUB(31, ix))),
-                     ?DIV(fac, X), ?ADD(ix, 1)])}
-     },
-     word}.
-
-builtin_baseX_digits(X) ->
-    {[{"x0", word}, {"dgts", word}],
-     ?LET(x1, ?DIV(x0, X),
-        {ifte, ?EQ(x1, 0), ?V(dgts), ?call({baseX_digits, X}, [?V(x1), ?ADD(dgts, 1)])}),
-     word}.
-
-builtin_bytes_to_int(32) ->
-    {[{"w", word}], ?V(w), word};
-builtin_bytes_to_int(N) when N < 32 ->
-    {[{"w", word}], ?BSR(w, 32 - N), word};
-builtin_bytes_to_int(N) when N > 32 ->
-    LastFullWord = N div 32 - 1,
-    Body = case N rem 32 of
-                0 -> ?DEREF(n, ?ADD(b, LastFullWord * 32), ?V(n));
-                R ->
-                    ?DEREF(hi, ?ADD(b, LastFullWord * 32),
-                    ?DEREF(lo, ?ADD(b, (LastFullWord + 1) * 32),
-                    ?ADD(?BSR(lo, 32 - R), ?BSL(hi, R))))
-           end,
-    {[{"b", pointer}], Body, word}.
-
-%% Two versions of this helper function, worker for sections not even 16 bytes long
-%% and worker_x for the full sized chunks.
-builtin_bytes_to_str_worker_x() ->
-    <<Tab:256>> = <<"0123456789ABCDEF________________">>,
-    {[{"w", word}, {"offs", word}, {"acc", word}],
-     {ifte, ?EQ(offs, 16), {seq, [?V(acc), {inline_asm, [?A(?MSIZE), ?A(?MSTORE), ?A(?MSIZE)]}]},
-         ?LET(b,  ?BYTE(offs, w),
-         ?LET(lo, ?BYTE(?MOD(b, 16), Tab),
-         ?LET(hi, ?BYTE(op('bsr', 4 , b), Tab),
-         ?call(bytes_to_str_worker_x, [?V(w), ?ADD(offs, 1), ?ADD(?BSL(acc, 2), ?ADD(?BSL(hi, 1), lo))]))))
-     },
-     word}.
-
-builtin_bytes_to_str_worker() ->
-    <<Tab:256>> = <<"0123456789ABCDEF________________">>,
-    {[{"w", word}, {"offs", word}, {"acc", word}, {"stop", word}],
-     {ifte, ?EQ(stop, offs), {seq, [?BSL(acc, ?MUL(2, ?SUB(16, offs))), {inline_asm, [?A(?MSIZE), ?A(?MSTORE), ?A(?MSIZE)]}]},
-         ?LET(b,  ?BYTE(offs, w),
-         ?LET(lo, ?BYTE(?MOD(b, 16), Tab),
-         ?LET(hi, ?BYTE(op('bsr', 4 , b), Tab),
-         ?call(bytes_to_str_worker, [?V(w), ?ADD(offs, 1), ?ADD(?BSL(acc, 2), ?ADD(?BSL(hi, 1), lo)), ?V(stop)]))))
-     },
-     word}.
-
-builtin_bytes_to_str_body(Var, N) when N < 16 ->
-    [?call(bytes_to_str_worker, [?V(Var), ?I(0), ?I(0), ?I(N)])];
-builtin_bytes_to_str_body(Var, 16) ->
-    [?call(bytes_to_str_worker_x, [?V(Var), ?I(0), ?I(0)])];
-builtin_bytes_to_str_body(Var, N) when N < 32 ->
-    builtin_bytes_to_str_body(Var, 16) ++ [{inline_asm, [?A(?POP)]}] ++
-    [?call(bytes_to_str_worker, [?BSL(Var, 16), ?I(0), ?I(0), ?I(N - 16)])];
-builtin_bytes_to_str_body(Var, 32) ->
-    builtin_bytes_to_str_body(Var, 16) ++ [{inline_asm, [?A(?POP)]}] ++
-    [?call(bytes_to_str_worker_x, [?BSL(Var, 16), ?I(0), ?I(0)])];
-builtin_bytes_to_str_body(Var, N) when N > 32 ->
-    WholeWords = ((N + 31) div 32) - 1,
-    lists:append(
-    [ [?DEREF(w, ?ADD(Var, 32 * I), {seq, builtin_bytes_to_str_body(w, 32)}), {inline_asm, [?A(?POP)]}]
-      || I <- lists:seq(0, WholeWords - 1) ]) ++
-    [ ?DEREF(w, ?ADD(Var, 32 * WholeWords), {seq, builtin_bytes_to_str_body(w, N - WholeWords * 32)}) ].
-
-builtin_bytes_to_str(N) when N =< 32 ->
-    {[{"w", word}],
-     ?LET(ret, {inline_asm, [?A(?MSIZE)]},
-     {seq, [?I(N * 2), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]}] ++
-            builtin_bytes_to_str_body(w, N) ++
-            [{inline_asm, [?A(?POP)]}, ?V(ret)]}),
-     string};
-builtin_bytes_to_str(N) when N > 32 ->
-    {[{"p", pointer}],
-     ?LET(ret, {inline_asm, [?A(?MSIZE)]},
-     {seq, [?I(N * 2), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]}] ++
-            builtin_bytes_to_str_body(p, N) ++
-            [{inline_asm, [?A(?POP)]}, ?V(ret)]}),
-     string}.
-
-builtin_string_reverse() ->
-    {[{"s", string}],
-     ?DEREF(n, s,
-     ?LET(ret, {inline_asm, [?A(?MSIZE)]},
-         {seq, [?V(n), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]},
-                ?call(string_reverse_, [?NXT(s), ?I(0), ?I(31), ?SUB(?V(n), 1)]),
-                {inline_asm, [?A(?POP)]}, ?V(ret)]})),
-     word}.
-
-builtin_string_reverse_() ->
-    {[{"p", pointer}, {"x", word}, {"i1", word}, {"i2", word}],
-     {ifte, ?LT(i2, 0),
-         {seq, [?V(x), {inline_asm, [?A(?MSIZE), ?A(?MSTORE), ?A(?MSIZE)]}]},
-         ?LET(p1, ?ADD(p, ?MUL(?DIV(i2, 32), 32)),
-         ?DEREF(w, p1,
-         ?LET(b, ?BYTE(?MOD(i2, 32), w),
-         {ifte, ?LT(i1, 0),
-             {seq, [?V(x), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]},
-                    ?call(string_reverse_,
-                          [?V(p), ?BSL(b, 31), ?I(30), ?SUB(i2, 1)])]},
-             ?call(string_reverse_,
-                   [?V(p), ?ADD(x, ?BSL(b, i1)), ?SUB(i1, 1), ?SUB(i2, 1)])})))},
-     word}.
-
-builtin_addr_to_str() ->
-    {[{"a", word}], ?call({baseX_int, 58}, [?V(a)]), word}.
-
-%% At most one word
-%% | ..... | ========= | ........ |
-%%    Offs ^ ^- Len -^   TotalLen ^
-bytes_slice(Offs, Len, TotalLen, Bytes) when TotalLen =< 32 ->
-    %% Bytes are packed into a single word
-    Masked =
-        case Offs of
-            0 -> Bytes;
-            _ -> ?MOD(Bytes, 1 bsl ((32 - Offs) * 8))
-        end,
-    Unpadded =
-        case 32 - (Offs + Len) of
-            0 -> Masked;
-            N -> ?BSR(Masked, N)
-        end,
-    case Len of
-        32 -> Unpadded;
-        _  -> ?BSL(Unpadded, 32 - Len)
-    end;
-bytes_slice(Offs, Len, TotalLen, Bytes) when TotalLen > 32 ->
-    %% Bytes is a pointer to memory. The VM can read at non-aligned addresses.
-    %% Might read one word more than necessary.
-    Word = op('!', Offs, Bytes),
-    case Len == 32 of
-        true -> Word;
-        _    -> ?BSL(?BSR(Word, 32 - Len), 32 - Len)
-    end.
-
-builtin_bytes_concat(A, B) ->
-    Type     = fun(N) when N =< 32 -> word; (_) -> pointer end,
-    MkBytes  = fun([W]) -> W;
-                  (Ws)  -> {tuple, Ws} end,
-    Words    = fun(N) -> (N + 31) div 32 end,
-    WordsRes = Words(A + B),
-    Word = fun(I) when 32 * (I + 1) =< A -> bytes_slice(I * 32, 32, A, ?V(a));
-              (I) when 32 * I < A ->
-                   Len = A rem 32,
-                   Hi  = bytes_slice(32 * I, Len, A, ?V(a)),
-                   Lo  = bytes_slice(0, min(32 - Len, B), B, ?V(b)),
-                   ?ADD(Hi, ?BSR(Lo, Len));
-              (I) ->
-                   Offs = 32 * I - A,
-                   Len  = min(32, B - Offs),
-                   bytes_slice(Offs, Len, B, ?V(b))
-           end,
-    Body =
-        case {A, B} of
-            {0, _} -> ?V(b);
-            {_, 0} -> ?V(a);
-            _      -> MkBytes([ Word(I) || I <- lists:seq(0, WordsRes - 1) ])
-        end,
-    {[{"a", Type(A)}, {"b", Type(B)}], Body, Type(A + B)}.
-
-builtin_bytes_split(A, B) ->
-    Type    = fun(N) when N =< 32 -> word; (_) -> pointer end,
-    MkBytes = fun([W]) -> W;
-                 (Ws)  -> {tuple, Ws} end,
-    Word    = fun(I, Max) ->
-                bytes_slice(I, min(32, Max - I), A + B, ?V(c))
-              end,
-    Body =
-        case {A, B} of
-            {0, _} -> [?I(0), ?V(c)];
-            {_, 0} -> [?V(c), ?I(0)];
-            _      -> [MkBytes([ Word(I, A)     || I <- lists:seq(0, A - 1, 32) ]),
-                       MkBytes([ Word(I, A + B) || I <- lists:seq(A, A + B - 1, 32) ])]
-        end,
-    {[{"c", Type(A + B)}], {tuple, Body}, {tuple, [Type(A), Type(B)]}}.
-
-bytes_to_raw_string(N, Term) when N =< 32 ->
-    {tuple, [?I(N), Term]};
-bytes_to_raw_string(N, Term) when N > 32 ->
-    Elem  = fun(I) -> #binop{op = '!', left = ?I(32 * I), right = ?V(bin)}
-            end,
-    Words = (N + 31) div 32,
-    ?LET(bin, Term, {tuple, [?I(N) | [Elem(I) || I <- lists:seq(0, Words - 1)]]}).
-
@@ -10,22 +10,22 @@

 -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'",
+                        [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)]),
-    Cxt = "The 'init' function can only be omitted if the state type is 'unit'.\n",
+    Msg = io_lib:format("Missing init function for the contract '~s'.", [pp_expr(Con)]),
+    Cxt = "The 'init' function can only be omitted if the state type is 'unit'.",
    mk_err(pos(Con), Msg, Cxt);
 format({missing_definition, Id}) ->
-    Msg = io_lib:format("Missing definition of function '~s'.\n", [pp_expr(Id)]),
+    Msg = io_lib:format("Missing definition of function '~s'.", [pp_expr(Id)]),
    mk_err(pos(Id), Msg);
 format({parameterized_state, Decl}) ->
-    Msg = "The state type cannot be parameterized.\n",
+    Msg = "The state type cannot be parameterized.",
    mk_err(pos(Decl), Msg);
 format({parameterized_event, Decl}) ->
-    Msg = "The event type cannot be parameterized.\n",
+    Msg = "The event type cannot be parameterized.",
    mk_err(pos(Decl), Msg);
 format({invalid_entrypoint, Why, Ann, {id, _, Name}, Thing}) ->
    What = case Why of higher_order -> "higher-order (contains function types)";
@@ -38,55 +38,29 @@ format({invalid_entrypoint, Why, Ann, {id, _, Name}, Thing}) ->
              {argument, _, _} -> io_lib:format("has a ~s type", [What]);
              {result, _}      -> io_lib:format("is ~s", [What])
          end,
-    Msg = io_lib:format("The ~sof entrypoint '~s' ~s.\n",
+    Msg = io_lib:format("The ~sof entrypoint '~s' ~s.",
                        [ThingS, Name, Bad]),
    case Why of
-        polymorphic  -> mk_err(pos(Ann), Msg, "Use the FATE backend if you want polymorphic entrypoints.\n");
        higher_order -> mk_err(pos(Ann), Msg)
    end;
-format({cant_compare_type_aevm, Ann, Op, Type}) ->
-    StringAndTuple = [ "- type string\n"
-                       "- tuple or record of word type\n" || lists:member(Op, ['==', '!=']) ],
-    Msg = io_lib:format("Cannot compare values of type\n"
-                        "~s\n"
-                        "The AEVM only supports '~s' on values of\n"
-                        "- word type (int, bool, bits, address, oracle(_, _), etc)\n"
-                        "~s",
-                        [pp_type(2, Type), Op, StringAndTuple]),
-    Cxt = "Use FATE if you need to compare arbitrary types.\n",
-    mk_err(pos(Ann), Msg, Cxt);
 format({invalid_aens_resolve_type, Ann, T}) ->
    Msg = io_lib:format("Invalid return type of AENS.resolve:\n"
                        "~s\n"
-                        "It must be a string or a pubkey type (address, oracle, etc).\n",
+                        "It must be a string or a pubkey type (address, oracle, etc).",
                        [pp_type(2, T)]),
    mk_err(pos(Ann), Msg);
-format({unapplied_contract_call, Contract}) ->
-    Msg = io_lib:format("The AEVM does not support unapplied contract call to\n"
-                        "~s\n", [pp_expr(2, Contract)]),
-    Cxt = "Use FATE if you need this.\n",
-    mk_err(pos(Contract), Msg, Cxt);
-format({unapplied_builtin, Id}) ->
-    Msg = io_lib:format("The AEVM does not support unapplied use of ~s.\n", [pp_expr(0, Id)]),
-    Cxt = "Use FATE if you need this.\n",
-    mk_err(pos(Id), Msg, Cxt);
-format({invalid_map_key_type, Why, Ann, Type}) ->
-    Msg = io_lib:format("Invalid map key type\n~s\n", [pp_type(2, Type)]),
-    Cxt = case Why of
-             polymorphic -> "Map keys cannot be polymorphic in the AEVM. Use FATE if you need this.\n";
-             function    -> "Map keys cannot be higher-order.\n"
-          end,
-    mk_err(pos(Ann), Msg, Cxt);
 format({invalid_oracle_type, Why, What, Ann, Type}) ->
    WhyS = case Why of higher_order -> "higher-order (contain function types)";
                       polymorphic  -> "polymorphic (contain type variables)" end,
-    Msg = io_lib:format("Invalid oracle type\n~s\n", [pp_type(2, Type)]),
-    Cxt = io_lib:format("The ~s type must not be ~s.\n", [What, WhyS]),
-    mk_err(pos(Ann), Msg, Cxt);
-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",
+    Msg = io_lib:format("Invalid oracle type\n~s", [pp_type(2, Type)]),
+    Cxt = io_lib:format("The ~s type must not be ~s.", [What, WhyS]),
    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])).
@@ -2,7 +2,7 @@
 %%% @author Happi (Erik Stenman)
 %%% @copyright (C) 2017, Aeternity Anstalt
 %%% @doc
-%%%     Compiler from Aeterinty Sophia language to the Aeternity VM, aevm.
+%%%     Compiler from Aeterinty Sophia language to FATE.
 %%% @end
 %%% Created : 12 Dec 2017
 %%%-------------------------------------------------------------------
@@ -12,14 +12,13 @@
        , file/2
        , from_string/2
        , check_call/4
-        , create_calldata/3  %% deprecated
+        , create_calldata/3
        , create_calldata/4
        , version/0
        , numeric_version/0
-        , sophia_type_to_typerep/1
-        , to_sophia_value/4  %% deprecated, need a backend
+        , to_sophia_value/4
        , to_sophia_value/5
-        , decode_calldata/3  %% deprecated
+        , decode_calldata/3
        , decode_calldata/4
        , parse/2
        , add_include_path/2
@@ -27,20 +26,17 @@
        ]).

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


 -type option() :: pp_sophia_code
                | pp_ast
                | pp_types
                | pp_typed_ast
-                | pp_icode
                | pp_assembler
-                | pp_bytecode
                | no_code
                | keep_included
                | debug_mode
-                | {backend, aevm | fate}
                | {include, {file_system, [string()]} |
                            {explicit_files, #{string() => binary()}}}
                | {src_file, string()}
@@ -105,41 +101,22 @@ add_include_path(File, Options) ->
    end.

 -spec from_string(binary() | string(), options()) -> {ok, map()} | {error, [aeso_errors:error()]}.
-from_string(Contract, Options) ->
-    from_string(proplists:get_value(backend, Options, aevm), Contract, Options).
-
-from_string(Backend, ContractBin, Options) when is_binary(ContractBin) ->
-    from_string(Backend, binary_to_list(ContractBin), Options);
-from_string(Backend, ContractString, Options) ->
+from_string(ContractBin, Options) when is_binary(ContractBin) ->
+    from_string(binary_to_list(ContractBin), Options);
+from_string(ContractString, Options) ->
    try
-        from_string1(Backend, ContractString, Options)
+        from_string1(ContractString, Options)
    catch
        throw:{error, Errors} -> {error, Errors}
    end.

-from_string1(aevm, ContractString, Options) ->
-    #{ icode := Icode
-     , folded_typed_ast := FoldedTypedAst } = string_to_code(ContractString, Options),
-    TypeInfo  = extract_type_info(Icode),
-    Assembler = assemble(Icode, Options),
-    pp_assembler(aevm, Assembler, Options),
-    ByteCodeList = to_bytecode(Assembler, Options),
-    ByteCode = << << B:8 >> || B <- ByteCodeList >>,
-    pp_bytecode(ByteCode, Options),
-    {ok, Version} = version(),
-    Res = #{byte_code => ByteCode,
-            compiler_version => Version,
-            contract_source => ContractString,
-            type_info => TypeInfo,
-            abi_version => aeb_aevm_abi:abi_version(),
-            payable => maps:get(payable, Icode)
-           },
-    {ok, maybe_generate_aci(Res, FoldedTypedAst, Options)};
-from_string1(fate, ContractString, Options) ->
+from_string1(ContractString, Options) ->
    #{ fcode := FCode
-     , folded_typed_ast := FoldedTypedAst } = string_to_code(ContractString, Options),
-    FateCode = aeso_fcode_to_fate:compile(FCode, Options),
-    pp_assembler(fate, FateCode, Options),
+     , fcode_env := #{child_con_env := ChildContracts}
+     , folded_typed_ast := FoldedTypedAst
+     , warnings := Warnings } = string_to_code(ContractString, Options),
+    FateCode = aeso_fcode_to_fate:compile(ChildContracts, FCode, Options),
+    pp_assembler(FateCode, Options),
    ByteCode = aeb_fate_code:serialize(FateCode, []),
    {ok, Version} = version(),
    Res = #{byte_code => ByteCode,
@@ -148,7 +125,8 @@ from_string1(fate, ContractString, Options) ->
            type_info => [],
            fate_code => FateCode,
            abi_version => aeb_fate_abi:abi_version(),
-            payable => maps:get(payable, FCode)
+            payable => maps:get(payable, FCode),
+            warnings => Warnings
           },
    {ok, maybe_generate_aci(Res, FoldedTypedAst, Options)}.

@@ -166,28 +144,18 @@ string_to_code(ContractString, Options) ->
    Ast = parse(ContractString, Options),
    pp_sophia_code(Ast, Options),
    pp_ast(Ast, Options),
-    {TypeEnv, FoldedTypedAst, UnfoldedTypedAst} = aeso_ast_infer_types:infer(Ast, [return_env | Options]),
+    {TypeEnv, FoldedTypedAst, UnfoldedTypedAst, Warnings} = aeso_ast_infer_types:infer(Ast, [return_env | Options]),
    pp_typed_ast(UnfoldedTypedAst, Options),
-    case proplists:get_value(backend, Options, aevm) of
-        aevm ->
-            Icode = ast_to_icode(UnfoldedTypedAst, Options),
-            pp_icode(Icode, Options),
-            #{ icode => Icode
-             , unfolded_typed_ast => UnfoldedTypedAst
-             , folded_typed_ast => FoldedTypedAst
-             , 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
-             , ast => Ast }
-    end.
+    ,  ast => Ast
+    ,  warnings => Warnings }.

 -define(CALL_NAME,   "__call").
-define(DECODE_NAME, "__decode").

 %% Takes a string containing a contract with a declaration/prototype of a
 %% function (foo, say) and adds function __call() = foo(args) calling this
@@ -195,10 +163,8 @@ string_to_code(ContractString, Options) ->
 %% terms for the arguments.
 %% NOTE: Special treatment for "init" since it might be implicit and has
 %%       a special return type (typerep, T)
-spec check_call(string(), string(), [string()], options()) -> {ok, string(), {[Type], Type}, [term()]}
-                                                                   | {ok, string(), [term()]}
-                                                                   | {error, [aeso_errors:error()]}
-    when Type :: term().
+-spec check_call(string(), string(), [string()], options()) -> {ok, string(), [term()]}
+                                                             | {error, [aeso_errors:error()]}.
 check_call(Source, "init" = FunName, Args, Options) ->
    case check_call1(Source, FunName, Args, Options) of
        Err = {error, _} when Args == [] ->
@@ -215,34 +181,11 @@ check_call(Source, FunName, Args, Options) ->

 check_call1(ContractString0, FunName, Args, Options) ->
    try
-        case proplists:get_value(backend, Options, aevm) of
-            aevm ->
        %% First check the contract without the __call function
-                #{ast := Ast} = string_to_code(ContractString0, Options),
-                ContractString = insert_call_function(Ast, ContractString0, ?CALL_NAME, FunName, Args),
-                #{unfolded_typed_ast := TypedAst,
-                  icode     := Icode} = string_to_code(ContractString, Options),
-                {ok, {FunName, {fun_t, _, _, ArgTypes, RetType}}} = get_call_type(TypedAst),
-                ArgVMTypes = [ aeso_ast_to_icode:ast_typerep(T, Icode) || T <- ArgTypes ],
-                RetVMType  = case RetType of
-                                 {id, _, "_"} -> any;
-                                 _            -> aeso_ast_to_icode:ast_typerep(RetType, Icode)
-                             end,
-                #{ functions := Funs } = Icode,
-                ArgIcode = get_arg_icode(Funs),
-                ArgTerms = [ icode_to_term(T, Arg) ||
-                               {T, Arg} <- lists:zip(ArgVMTypes, ArgIcode) ],
-                RetVMType1 =
-                    case FunName of
-                        "init" -> {tuple, [typerep, RetVMType]};
-                        _ -> RetVMType
-                    end,
-                {ok, FunName, {ArgVMTypes, RetVMType1}, ArgTerms};
-            fate ->
-                %% First check the contract without the __call function
-                #{ fcode := OrgFcode
-                 , ast := Ast } = string_to_code(ContractString0, Options),
-                FateCode = aeso_fcode_to_fate:compile(OrgFcode, []),
+        #{fcode := OrgFcode
+        , fcode_env := #{child_con_env := ChildContracts}
+        , ast := Ast} = string_to_code(ContractString0, Options),
+        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,
@@ -250,8 +193,8 @@ check_call1(ContractString0, FunName, Args, Options) ->
        ContractString = insert_call_function(Ast, ContractString0, CallName, FunName, Args),
        #{fcode := Fcode} = string_to_code(ContractString, Options),
        CallArgs = arguments_of_body(CallName, FunName, Fcode),
+
        {ok, FunName, CallArgs}
-        end
    catch
        throw:{error, Errors} -> {error, Errors}
    end.
@@ -299,32 +242,21 @@ last_contract_indent(Decls) ->
        _                     -> 0
    end.

-spec to_sophia_value(string(), string(), ok | error | revert, aeb_aevm_data:data()) ->
+-spec to_sophia_value(string(), string(), ok | error | revert, binary()) ->
          {ok, aeso_syntax:expr()} | {error, [aeso_errors:error()]}.
 to_sophia_value(ContractString, Fun, ResType, Data) ->
-    to_sophia_value(ContractString, Fun, ResType, Data, [{backend, aevm}]).
-
+    to_sophia_value(ContractString, Fun, ResType, Data, []).
 -spec to_sophia_value(string(), string(), ok | error | revert, binary(), options()) ->
        {ok, aeso_syntax:expr()} | {error, [aeso_errors:error()]}.
 to_sophia_value(_, _, error, Err, _Options) ->
    {ok, {app, [], {id, [], "error"}, [{string, [], Err}]}};
-to_sophia_value(_, _, revert, Data, Options) ->
-    case proplists:get_value(backend, Options, aevm) of
-        aevm ->
-            case aeb_heap:from_binary(string, Data) of
-                {ok, Err} ->
-                    {ok, {app, [], {id, [], "abort"}, [{string, [], Err}]}};
-                {error, _} ->
-                    Msg = "Could not interpret the revert message\n",
-                    {error, [aeso_errors:new(data_error, Msg)]}
-            end;
-        fate ->
-            try aeb_fate_encoding:deserialize(Data) of
-                Err -> {ok, {app, [], {id, [], "abort"}, [{string, [], Err}]}}
+to_sophia_value(_, _, revert, Data, _Options) ->
+    try aeso_vm_decode:from_fate({id, [], "string"}, aeb_fate_encoding:deserialize(Data)) of
+        Err ->
+            {ok, {app, [], {id, [], "abort"}, [Err]}}
    catch _:_ ->
-                Msg = "Could not deserialize the revert message\n",
+            Msg = "Could not deserialize the revert message",
            {error, [aeso_errors:new(data_error, Msg)]}
-            end
    end;
 to_sophia_value(ContractString, FunName, ok, Data, Options0) ->
    Options = [no_code | Options0],
@@ -334,74 +266,44 @@ to_sophia_value(ContractString, FunName, ok, Data, Options0) ->
        {ok, _, Type0} = get_decode_type(FunName, TypedAst),
        Type   = aeso_ast_infer_types:unfold_types_in_type(TypeEnv, Type0, [unfold_record_types, unfold_variant_types]),

-        case proplists:get_value(backend, Options, aevm) of
-            aevm ->
-                Icode  = maps:get(icode, Code),
-                VmType = aeso_ast_to_icode:ast_typerep(Type, Icode),
-                case aeb_heap:from_binary(VmType, Data) of
-                    {ok, VmValue} ->
-                        try
-                            {ok, aeso_vm_decode:from_aevm(VmType, Type, VmValue)}
-                        catch throw:cannot_translate_to_sophia ->
-                            Type0Str = prettypr:format(aeso_pretty:type(Type0)),
-                            Msg = io_lib:format("Cannot translate VM value ~p\n  of type ~p\n  to Sophia type ~s\n",
-                                                [Data, VmType, Type0Str]),
-                            {error, [aeso_errors:new(data_error, Msg)]}
-                        end;
-                    {error, _Err} ->
-                        Msg = io_lib:format("Failed to decode binary as type ~p\n", [VmType]),
-                        {error, [aeso_errors:new(data_error, Msg)]}
-                end;
-            fate ->
        try
            {ok, aeso_vm_decode:from_fate(Type, aeb_fate_encoding:deserialize(Data))}
        catch throw:cannot_translate_to_sophia ->
                Type1 = prettypr:format(aeso_pretty:type(Type0)),
-                        Msg = io_lib:format("Cannot translate FATE value ~p\n  of Sophia type ~s\n",
+                Msg = io_lib:format("Cannot translate FATE value ~p\n  of Sophia type ~s",
                                    [aeb_fate_encoding:deserialize(Data), Type1]),
                {error, [aeso_errors:new(data_error, Msg)]};
              _:_ ->
                Type1 = prettypr:format(aeso_pretty:type(Type0)),
-                        Msg = io_lib:format("Failed to decode binary as type ~s\n", [Type1]),
+                Msg = io_lib:format("Failed to decode binary as type ~s", [Type1]),
                {error, [aeso_errors:new(data_error, Msg)]}
        end
-        end
    catch
        throw:{error, Errors} -> {error, Errors}
    end.

-
 -spec create_calldata(string(), string(), [string()]) ->
-                             {ok, binary(), aeb_aevm_data:type(), aeb_aevm_data:type()}
-                             | {error, [aeso_errors:error()]}.
+          {ok, binary()} | {error, [aeso_errors:error()]}.
 create_calldata(Code, Fun, Args) ->
-    create_calldata(Code, Fun, Args, [{backend, aevm}]).
-
+    create_calldata(Code, Fun, Args, []).
 -spec create_calldata(string(), string(), [string()], [{atom(), any()}]) ->
                             {ok, binary()} | {error, [aeso_errors:error()]}.
 create_calldata(Code, Fun, Args, Options0) ->
    Options = [no_code | Options0],
-    case proplists:get_value(backend, Options, aevm) of
-        aevm ->
-            case check_call(Code, Fun, Args, Options) of
-                {ok, FunName, {ArgTypes, RetType}, VMArgs} ->
-                    aeb_aevm_abi:create_calldata(FunName, VMArgs, ArgTypes, RetType);
-                {error, _} = Err -> Err
-            end;
-        fate ->
    case check_call(Code, Fun, Args, Options) of
        {ok, FunName, FateArgs} ->
            aeb_fate_abi:create_calldata(FunName, FateArgs);
        {error, _} = Err -> Err
-            end
    end.

 -spec decode_calldata(string(), string(), binary()) ->
          {ok, [aeso_syntax:type()], [aeso_syntax:expr()]}
        | {error, [aeso_errors:error()]}.
 decode_calldata(ContractString, FunName, Calldata) ->
-    decode_calldata(ContractString, FunName, Calldata, [{backend, aevm}]).
-
+    decode_calldata(ContractString, FunName, Calldata, []).
+-spec decode_calldata(string(), string(), binary(), options()) ->
+          {ok, [aeso_syntax:type()], [aeso_syntax:expr()]}
+        | {error, [aeso_errors:error()]}.
 decode_calldata(ContractString, FunName, Calldata, Options0) ->
    Options = [no_code | Options0],
    try
@@ -414,27 +316,6 @@ decode_calldata(ContractString, FunName, Calldata, Options0) ->
        Type0         = {tuple_t, [], ArgTypes},
        %% user defined data types such as variants needed to match against
        Type          = aeso_ast_infer_types:unfold_types_in_type(TypeEnv, Type0, [unfold_record_types, unfold_variant_types]),
-        case proplists:get_value(backend, Options, aevm) of
-            aevm ->
-                Icode  = maps:get(icode, Code),
-                VmType = aeso_ast_to_icode:ast_typerep(Type, Icode),
-                case aeb_heap:from_binary({tuple, [word, VmType]}, Calldata) of
-                    {ok, {_, VmValue}} ->
-                        try
-                            {tuple, [], Values} = aeso_vm_decode:from_aevm(VmType, Type, VmValue),
-                            %% Values are Sophia expressions in AST format
-                            {ok, ArgTypes, Values}
-                        catch throw:cannot_translate_to_sophia ->
-                            Type0Str = prettypr:format(aeso_pretty:type(Type0)),
-                            Msg = io_lib:format("Cannot translate VM value ~p\n  of type ~p\n  to Sophia type ~s\n",
-                                                [VmValue, VmType, Type0Str]),
-                            {error, [aeso_errors:new(data_error, Msg)]}
-                        end;
-                    {error, _Err} ->
-                        Msg = io_lib:format("Failed to decode calldata as type ~p\n", [VmType]),
-                        {error, [aeso_errors:new(data_error, Msg)]}
-                end;
-            fate ->
        case aeb_fate_abi:decode_calldata(FunName, Calldata) of
            {ok, FateArgs} ->
                try
@@ -444,45 +325,20 @@ decode_calldata(ContractString, FunName, Calldata, Options0) ->
                    {ok, ArgTypes, AstArgs}
                catch throw:cannot_translate_to_sophia ->
                        Type0Str = prettypr:format(aeso_pretty:type(Type0)),
-                                Msg = io_lib:format("Cannot translate FATE value ~p\n  to Sophia type ~s\n",
+                        Msg = io_lib:format("Cannot translate FATE value ~p\n  to Sophia type ~s",
                                            [FateArgs, Type0Str]),
                        {error, [aeso_errors:new(data_error, Msg)]}
                end;
            {error, _} ->
-                        Msg = io_lib:format("Failed to decode calldata binary\n", []),
+                Msg = io_lib:format("Failed to decode calldata binary", []),
                {error, [aeso_errors:new(data_error, Msg)]}
        end
-        end
    catch
        throw:{error, Errors} -> {error, Errors}
    end.

-get_arg_icode(Funs) ->
-    case [ Args || {[_, ?CALL_NAME], _, _, {funcall, _, Args}, _} <- Funs ] of
-        [Args] -> Args;
-        []     -> error_missing_call_function()
-    end.
-
-dialyzer({nowarn_function, error_missing_call_function/0}).
-error_missing_call_function() ->
-    Msg = "Internal error: missing '__call'-function",
-    aeso_errors:throw(aeso_errors:new(internal_error, Msg)).
-
-get_call_type([{contract, _, _, Defs}]) ->
-    case [ {lists:last(QFunName), FunType}
-          || {letfun, _, {id, _, ?CALL_NAME}, [], _Ret,
-                {typed, _,
-                    {app, _,
-                        {typed, _, {qid, _, QFunName}, FunType}, _}, _}} <- Defs ] of
-        [Call] -> {ok, Call};
-        []     -> error_missing_call_function()
-    end;
-get_call_type([_ | Contracts]) ->
-    %% The __call should be in the final contract
-    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,
@@ -492,7 +348,7 @@ get_decode_type(FunName, [{contract, Ann, _, Defs}]) ->
            case FunName of
                "init" -> {ok, [], {tuple_t, [], []}};
                 _ ->
-                    Msg = io_lib:format("Function '~s' is missing in contract\n", [FunName]),
+                    Msg = io_lib:format("Function '~s' is missing in contract", [FunName]),
                    Pos = aeso_code_errors:pos(Ann),
                    aeso_errors:throw(aeso_errors:new(data_error, Pos, Msg))
            end
@@ -501,87 +357,17 @@ get_decode_type(FunName, [_ | Contracts]) ->
    %% The __decode should be in the final contract
    get_decode_type(FunName, Contracts).

-%% Translate an icode value (error if not value) to an Erlang term that can be
-%% consumed by aeb_heap:to_binary().
-icode_to_term(word, {integer, N}) -> N;
-icode_to_term(word, {unop, '-', {integer, N}}) -> -N;
-icode_to_term(string, {tuple, [{integer, Len} | Words]}) ->
-    <<Str:Len/binary, _/binary>> = << <<W:256>> || {integer, W} <- Words >>,
-    Str;
-icode_to_term({list, T}, {list, Vs}) ->
-    [ icode_to_term(T, V) || V <- Vs ];
-icode_to_term({tuple, Ts}, {tuple, Vs}) ->
-    list_to_tuple(icodes_to_terms(Ts, Vs));
-icode_to_term({variant, Cs}, {tuple, [{integer, Tag} | Args]}) ->
-    Ts = lists:nth(Tag + 1, Cs),
-    {variant, Tag, icodes_to_terms(Ts, Args)};
-icode_to_term(T = {map, KT, VT}, M) ->
-    %% Maps are compiled to builtin and primop calls, so this gets a little hairy
-    case M of
-        {funcall, {var_ref, {builtin, map_put}}, [M1, K, V]} ->
-            Map = icode_to_term(T, M1),
-            Key = icode_to_term(KT, K),
-            Val = icode_to_term(VT, V),
-            Map#{ Key => Val };
-        #prim_call_contract{ address = {integer, 0},
-                             arg = {tuple, [{integer, ?PRIM_CALL_MAP_EMPTY}, _, _]} } ->
-            #{};
-        _ -> throw({todo, M})
-    end;
-icode_to_term(word, {unop, 'bnot', A}) ->
-    bnot icode_to_term(word, A);
-icode_to_term(word, {binop, 'bor', A, B}) ->
-    icode_to_term(word, A) bor icode_to_term(word, B);
-icode_to_term(word, {binop, 'bsl', A, B}) ->
-    icode_to_term(word, B) bsl icode_to_term(word, A);
-icode_to_term(word, {binop, 'band', A, B}) ->
-    icode_to_term(word, A) band icode_to_term(word, B);
-icode_to_term(typerep, _) ->
-    throw({todo, typerep});
-icode_to_term(T, V) ->
-    throw({not_a_value, T, V}).
-
-icodes_to_terms(Ts, Vs) ->
-    [ icode_to_term(T, V) || {T, V} <- lists:zip(Ts, Vs) ].
-
-ast_to_icode(TypedAst, Options) ->
-    aeso_ast_to_icode:convert_typed(TypedAst, Options).
-
-assemble(Icode, Options) ->
-    aeso_icode_to_asm:convert(Icode, Options).
-
-
-to_bytecode(['COMMENT',_|Rest],_Options) ->
-    to_bytecode(Rest,_Options);
-to_bytecode([Op|Rest], Options) ->
-    [aeb_opcodes:m_to_op(Op)|to_bytecode(Rest, Options)];
-to_bytecode([], _) -> [].
-
-extract_type_info(#{functions := Functions} =_Icode) ->
-    ArgTypesOnly = fun(As) -> [ T || {_, T} <- As ] end,
-    Payable = fun(Attrs) -> proplists:get_value(payable, Attrs, false) end,
-    TypeInfo = [aeb_aevm_abi:function_type_info(list_to_binary(lists:last(Name)),
-                                            Payable(Attrs), ArgTypesOnly(Args), TypeRep)
-                || {Name, Attrs, Args,_Body, TypeRep} <- Functions,
-                   not is_tuple(Name),
-                   not lists:member(private, Attrs)
-               ],
-    lists:sort(TypeInfo).
-
 pp_sophia_code(C, Opts)->  pp(C, Opts, pp_sophia_code, fun(Code) ->
                                io:format("~s\n", [prettypr:format(aeso_pretty:decls(Code))])
                            end).
 pp_ast(C, Opts)      ->  pp(C, Opts, pp_ast, fun aeso_ast:pp/1).
 pp_typed_ast(C, Opts)->  pp(C, Opts, pp_typed_ast, fun aeso_ast:pp_typed/1).
-pp_icode(C, Opts)    ->  pp(C, Opts, pp_icode, fun aeso_icode:pp/1).
-pp_bytecode(C, Opts) ->  pp(C, Opts, pp_bytecode, fun aeb_disassemble:pp/1).

-pp_assembler(aevm, C, Opts) ->  pp(C, Opts, pp_assembler, fun aeb_asm:pp/1);
-pp_assembler(fate, C, Opts) ->  pp(C, Opts, pp_assembler, fun(Asm) -> io:format("~s", [aeb_fate_asm:pp(Asm)]) end).
+pp_assembler(C, Opts) ->  pp(C, Opts, pp_assembler, fun(Asm) -> io:format("~s", [aeb_fate_asm:pp(Asm)]) end).

 pp(Code, Options, Option, PPFun) ->
    case proplists:lookup(Option, Options) of
-        {Option, true} ->
+        {Option1, true} when Option1 =:= Option ->
            PPFun(Code);
        none ->
            ok
@@ -594,16 +380,13 @@ pp(Code, Options, Option, PPFun) ->
 -spec validate_byte_code(map(), string(), options()) -> ok | {error, [aeso_errors:error()]}.
 validate_byte_code(#{ byte_code := ByteCode, payable := Payable }, Source, Options) ->
    Fail = fun(Err) -> {error, [aeso_errors:new(data_error, Err)]} end,
-    case proplists:get_value(backend, Options, aevm) of
-        B when B /= fate -> Fail(io_lib:format("Unsupported backend: ~s\n", [B]));
-        fate ->
    try
        FCode1 = ?protect(deserialize, aeb_fate_code:strip_init_function(aeb_fate_code:deserialize(ByteCode))),
        {FCode2, SrcPayable} =
            ?protect(compile,
                     begin
                         {ok, #{ byte_code := SrcByteCode, payable := SrcPayable }} =
-                                    from_string1(fate, Source, Options),
+                             from_string1(Source, Options),
                         FCode = aeb_fate_code:deserialize(SrcByteCode),
                         {aeb_fate_code:strip_init_function(FCode), SrcPayable}
                     end),
@@ -618,7 +401,6 @@ validate_byte_code(#{ byte_code := ByteCode, payable := Payable }, Source, Optio
    catch
        throw:{deserialize, _}         -> Fail("Invalid byte code");
        throw:{compile, {error, Errs}} -> {error, Errs}
-            end
    end.

 compare_fate_code(FCode1, FCode2) ->
@@ -670,14 +452,6 @@ pp_fate_type(T) -> io_lib:format("~w", [T]).

 %% -------------------------------------------------------------------

-spec sophia_type_to_typerep(string()) -> {error, bad_type} | {ok, aeb_aevm_data:type()}.
-sophia_type_to_typerep(String) ->
-    Ast = aeso_parser:run_parser(aeso_parser:type(), String),
-    try aeso_ast_to_icode:ast_typerep(Ast) of
-        Type -> {ok, Type}
-    catch _:_ -> {error, bad_type}
-    end.
-
 -spec parse(string(), aeso_compiler:options()) -> none() | aeso_syntax:ast().
 parse(Text, Options) ->
    parse(Text, sets:new(), Options).
@@ -30,12 +30,15 @@

 -export([ err_msg/1
        , msg/1
+        , msg_oneline/1
        , new/2
        , new/3
        , new/4
        , pos/2
        , pos/3
        , pp/1
+        , pp_oneline/1
+        , pp_pos/1
        , to_json/1
        , throw/1
        , type/1
@@ -65,10 +68,13 @@ throw(#err{} = Err) ->
    erlang:throw({error, [Err]}).

 msg(#err{ message = Msg, context = none }) -> Msg;
-msg(#err{ message = Msg, context = Ctxt }) -> Msg ++ Ctxt.
+msg(#err{ message = Msg, context = Ctxt }) -> Msg ++ "\n" ++ Ctxt.
+
+msg_oneline(#err{ message = Msg, context = none }) -> Msg;
+msg_oneline(#err{ message = Msg, context = Ctxt }) -> Msg ++ " - " ++ Ctxt.

 err_msg(#err{ pos = Pos } = Err) ->
-    lists:flatten(io_lib:format("~s~s", [str_pos(Pos), msg(Err)])).
+    lists:flatten(io_lib:format("~s~s\n", [str_pos(Pos), msg(Err)])).

 str_pos(#pos{file = no_file, line = L, col = C}) ->
    io_lib:format("~p:~p:", [L, C]);
@@ -78,7 +84,12 @@ str_pos(#pos{file = F, line = L, col = C}) ->
 type(#err{ type = Type }) -> Type.

 pp(#err{ type = Kind, pos = Pos } = Err) ->
-    lists:flatten(io_lib:format("~s~s:\n~s", [pp_kind(Kind), pp_pos(Pos), msg(Err)])).
+    lists:flatten(io_lib:format("~s~s:\n~s\n", [pp_kind(Kind), pp_pos(Pos), msg(Err)])).
+
+pp_oneline(#err{ type = Kind, pos = Pos } = Err) ->
+    Msg = msg_oneline(Err),
+    OneLineMsg = re:replace(Msg, "[\s\\n]+", " ", [global]),
+    lists:flatten(io_lib:format("~s~s: ~s", [pp_kind(Kind), pp_pos(Pos), OneLineMsg])).

 pp_kind(type_error)     -> "Type error";
 pp_kind(parse_error)    -> "Parse error";
@@ -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,33 @@ lookup_var(#env{vars = Vars}, X) ->

 %% -- The compiler --

-lit_to_fate(L) ->
+serialize_contract_code(Env, C) ->
+    Cache = case get(contract_code_cache) of
+                undefined -> put(contract_code_cache, #{}), #{};
+                Res       -> Res
+            end,
+    case maps:get(C, Cache, none) of
+        none ->
+            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),
+            put(contract_code_cache, maps:put(C, Serialized, Cache)),
+            Serialized;
+        Serialized -> Serialized
+    end.
+
+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 +212,65 @@ 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}   -> aeb_fate_data:make_contract_bytearray(serialize_contract_code(Env, C));
        {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)];
@@ -503,6 +538,8 @@ 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) ->
@@ -555,7 +592,27 @@ builtin_to_scode(Env, aens_lookup, [_Name] = Args) ->
 builtin_to_scode(_Env, auth_tx_hash, []) ->
    [aeb_fate_ops:auth_tx_hash(?a)];
 builtin_to_scode(_Env, auth_tx, []) ->
-    [aeb_fate_ops:auth_tx(?a)].
+    [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 --

@@ -881,6 +938,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, []);
@@ -941,6 +999,10 @@ attributes(I) ->
        {'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, [])
@@ -1694,6 +1756,9 @@ 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) ->
@@ -1,153 +0,0 @@
-%%%-------------------------------------------------------------------
-%%% @author Happi (Erik Stenman)
-%%% @copyright (C) 2017, Aeternity Anstalt
-%%% @doc
-%%%     Intermediate Code for Aeterinty Sophia language.
-%%% @end
-%%% Created : 21 Dec 2017
-%%%
-%%%-------------------------------------------------------------------
-module(aeso_icode).
-
-export([new/1,
-         pp/1,
-         set_name/2,
-         set_namespace/2,
-         set_payable/2,
-         enter_namespace/2,
-         get_namespace/1,
-         in_main_contract/1,
-         qualify/2,
-         set_functions/2,
-         map_typerep/2,
-         option_typerep/1,
-         get_constructor_tag/2]).
-
-export_type([icode/0]).
-
-include("aeso_icode.hrl").
-
-type type_def() :: fun(([aeb_aevm_data:type()]) -> aeb_aevm_data:type()).
-
-type bindings() :: any().
-type fun_dec() :: { string()
-                   , [modifier()]
-                   , arg_list()
-                   , expr()
-                   , aeb_aevm_data:type()}.
-
-type modifier() :: private | stateful.
-
-type type_name() :: string() | [string()].
-
-type icode() :: #{ contract_name => string()
-                  , functions => [fun_dec()]
-                  , namespace => aeso_syntax:con() | aeso_syntax:qcon()
-                  , env => [bindings()]
-                  , state_type => aeb_aevm_data:type()
-                  , event_type => aeb_aevm_data:type()
-                  , types => #{ type_name() => type_def() }
-                  , type_vars => #{ string() => aeb_aevm_data:type() }
-                  , constructors => #{ [string()] => integer() }  %% name to tag
-                  , options => [any()]
-                  , payable => boolean()
-                  }.
-
-pp(Icode) ->
-    %% TODO: Actually do *Pretty* printing.
-    io:format("~p~n", [Icode]).
-
-spec new([any()]) -> icode().
-new(Options) ->
-    #{ contract_name => ""
-     , functions => []
-     , env => new_env()
-       %% Default to unit type for state and event
-     , state_type => {tuple, []}
-     , event_type => {tuple, []}
-     , types => builtin_types()
-     , type_vars => #{}
-     , constructors => builtin_constructors()
-     , options => Options
-     , payable => false }.
-
-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
-     , ["AENS", "pointee"] => fun([]) -> {variant, [[word], [word], [word]]} end
-     }.
-
-builtin_constructors() ->
-    #{ ["RelativeTTL"]     => 0
-     , ["FixedTTL"]        => 1
-     , ["None"]            => 0
-     , ["Some"]            => 1
-     , ["AccountPointee"]  => 0
-     , ["OraclePointee"]   => 1
-     , ["ContractPointee"] => 2
-     }.
-
-map_typerep(K, V) ->
-    {map, K, V}.
-
-option_typerep(A) ->
-    {variant, [[], [A]]}.
-
-new_env() ->
-    [].
-
-spec set_name(string(), icode()) -> icode().
-set_name(Name, Icode) ->
-    maps:put(contract_name, Name, Icode).
-
-spec set_payable(boolean(), icode()) -> icode().
-set_payable(Payable, Icode) ->
-    maps:put(payable, Payable, Icode).
-
-spec set_namespace(aeso_syntax:con() | aeso_syntax:qcon(), icode()) -> icode().
-set_namespace(NS, Icode) -> Icode#{ namespace => NS }.
-
-spec enter_namespace(aeso_syntax:con(), icode()) -> icode().
-enter_namespace(NS, Icode = #{ namespace := NS1 }) ->
-    Icode#{ namespace => aeso_syntax:qualify(NS1, NS) };
-enter_namespace(NS, Icode) ->
-    Icode#{ namespace => NS }.
-
-spec in_main_contract(icode()) -> boolean().
-in_main_contract(#{ namespace := {con, _, Main}, contract_name := Main }) -> true;
-in_main_contract(_Icode) -> false.
-
-spec get_namespace(icode()) -> false | aeso_syntax:con() | aeso_syntax:qcon().
-get_namespace(Icode) -> maps:get(namespace, Icode, false).
-
-spec qualify(aeso_syntax:id() | aeso_syntax:con(), icode()) -> aeso_syntax:id() | aeso_syntax:qid() | aeso_syntax:con() | aeso_syntax:qcon().
-qualify(X, Icode) ->
-    case get_namespace(Icode) of
-        false -> X;
-        NS    -> aeso_syntax:qualify(NS, X)
-    end.
-
-spec set_functions([fun_dec()], icode()) -> icode().
-set_functions(NewFuns, Icode) ->
-    maps:put(functions, NewFuns, Icode).
-
-spec get_constructor_tag([string()], icode()) -> integer().
-get_constructor_tag(Name, #{constructors := Constructors}) ->
-    case maps:get(Name, Constructors, undefined) of
-        undefined -> error({undefined_constructor, Name});
-        Tag       -> Tag
-    end.
@@ -1,59 +0,0 @@
-
-include_lib("aebytecode/include/aeb_typerep_def.hrl").
-
-record(arg, {name::string(), type::?Type()}).
-
-type expr() :: term().
-type arg() :: #arg{name::string(), type::?Type()}.
-type arg_list() :: [arg()].
-
-record(fun_dec, { name :: string()
-                 , args :: arg_list()
-                 , body :: expr()}).
-
-record(var_ref, { name :: string() | list(string()) | {builtin, atom() | tuple()}}).
-
-record(prim_call_contract,
-    { gas      :: expr()
-    , address  :: expr()
-    , value    :: expr()
-    , arg      :: expr()
-    , type_hash:: expr()
-    }).
-
-record(prim_balance,    { address :: expr() }).
-record(prim_block_hash, { height :: expr() }).
-record(prim_put,        { state :: expr() }).
-
-record(integer, {value :: integer()}).
-
-record(tuple,   {cpts  :: [expr()]}).
-
-record(list,    {elems :: [expr()]}).
-
-record(unop,    { op   :: term()
-                 , rand :: expr()}).
-
-record(binop,   { op   :: term()
-                 , left :: expr()
-                 , right :: expr()}).
-
-record(ifte,    { decision :: expr()
-                 , then :: expr()
-                 , else :: expr()}).
-
-record(switch,  { expr  :: expr()
-                 , cases :: [{expr(),expr()}]}).
-
-record(funcall, { function :: expr()
-                 , args     :: [expr()]}).
-
-record(lambda,  { args :: arg_list(),
-                   body :: expr()}).
-
-record(missing_field, { format :: string()
-                       , args   :: [term()]}).
-
-record(seq, {exprs :: [expr()]}).
-
-record(event, {topics :: [expr()], payload :: expr()}).
@@ -1,983 +0,0 @@
-%%%-------------------------------------------------------------------
-%%% @author Happi (Erik Stenman)
-%%% @copyright (C) 2017, Aeternity Anstalt
-%%% @doc
-%%%     Translator from Aesophia Icode to Aevm Assebly
-%%% @end
-%%% Created : 21 Dec 2017
-%%%
-%%%-------------------------------------------------------------------
-module(aeso_icode_to_asm).
-
-export([convert/2]).
-
-include_lib("aebytecode/include/aeb_opcodes.hrl").
-include("aeso_icode.hrl").
-
-i(Code) -> aeb_opcodes:mnemonic(Code).
-
-%% We don't track purity or statefulness in the type checker yet.
-is_stateful({FName, _, _, _, _}) -> lists:last(FName) /= "init".
-
-is_public({_Name, Attrs, _Args, _Body, _Type}) -> not lists:member(private, Attrs).
-
-convert(#{ contract_name := _ContractName
-         , state_type := StateType
-         , functions := Functions
-              },
-        _Options) ->
-    %% Create a function dispatcher
-    DispatchFun = {"%main", [], [{"arg", "_"}],
-                   {switch, {var_ref, "arg"},
-                    [{{tuple, [fun_hash(Fun),
-                               {tuple, make_args(Args)}]},
-                      icode_seq([ hack_return_address(Fun, length(Args) + 1) ] ++
-                                [ {funcall, {var_ref, FName}, make_args(Args)}]
-                               )}
-                     || Fun={FName, _, Args, _,_TypeRep} <- Functions, is_public(Fun) ]},
-                   word},
-    NewFunctions = Functions ++ [DispatchFun],
-    %% Create a function environment
-    Funs = [{Name, length(Args), make_ref()}
-            || {Name, _Attrs, Args, _Body, _Type} <- NewFunctions],
-    %% Create dummy code to call the main function with one argument
-    %% taken from the stack
-    StopLabel = make_ref(),
-    StatefulStopLabel = make_ref(),
-    MainFunction = lookup_fun(Funs, "%main"),
-
-    StateTypeValue = aeso_ast_to_icode:type_value(StateType),
-
-    DispatchCode = [%% push two return addresses to stop, one for stateful
-                    %% functions and one for non-stateful functions.
-                    push_label(StatefulStopLabel),
-                    push_label(StopLabel),
-                    %% The calldata is already on the stack when we start. Put
-                    %% it on top (also reorders StatefulStop and Stop).
-                    swap(2),
-
-                    jump(MainFunction),
-                    jumpdest(StatefulStopLabel),
-
-                    %% We need to encode the state type and put it
-                    %% underneath the return value.
-                    assemble_expr(Funs, [], nontail, StateTypeValue), %% StateT Ret
-                    swap(1),                                          %% Ret StateT
-
-                    %% We should also change the state value at address 0 to a
-                    %% pointer to the state value (to allow 0 to represent an
-                    %% unchanged state).
-                    i(?MSIZE),             %% Ptr
-                    push(0), i(?MLOAD),    %% Val Ptr
-                    i(?MSIZE), i(?MSTORE), %% Ptr   Mem[Ptr] := Val
-                    push(0), i(?MSTORE),   %%       Mem[0]   := Ptr
-
-                    %% The pointer to the return value is on top of
-                    %% the stack, but the return instruction takes two
-                    %% stack arguments.
-                    push(0),
-                    i(?RETURN),
-                    jumpdest(StopLabel),
-                    %% Set state pointer to 0 to indicate that we didn't change state
-                    push(0), dup(1), i(?MSTORE),
-                    %% Same as StatefulStopLabel above
-                    push(0),
-                    i(?RETURN)
-                   ],
-    %% Code is a deep list of instructions, containing labels and
-    %% references to them. Labels take the form {'JUMPDEST', Ref}, and
-    %% references take the form {push_label, Ref}, which is translated
-    %% into a PUSH instruction.
-    Code = [assemble_function(Funs, Name, Args, Body)
-            || {Name, _, Args, Body, _Type} <- NewFunctions],
-    resolve_references(
-        [%% i(?COMMENT), "CONTRACT: " ++ ContractName,
-         DispatchCode,
-         Code]).
-
-%% Generate error on correct format.
-
-gen_error(Error) ->
-    error({code_errors, [Error]}).
-
-make_args(Args) ->
-    [{var_ref, [I-1 + $a]} || I <- lists:seq(1, length(Args))].
-
-fun_hash({FName, _, Args, _, TypeRep}) ->
-    ArgType = {tuple, [T || {_, T} <- Args]},
-    <<Hash:256>> = aeb_aevm_abi:function_type_hash(list_to_binary(lists:last(FName)), ArgType, TypeRep),
-    {integer, Hash}.
-
-%% Expects two return addresses below N elements on the stack. Picks the top
-%% one for stateful functions and the bottom one for non-stateful.
-hack_return_address(Fun, N) ->
-    case is_stateful(Fun) of
-        true  -> {inline_asm, [i(?MSIZE)]};
-        false ->
-            {inline_asm,     %% X1 .. XN State NoState
-             [ dup(N + 2)    %% NoState X1 .. XN State NoState
-             , swap(N + 1)   %% State X1 .. XN NoState NoState
-             ]}  %% Top of the stack will be discarded.
-    end.
-
-assemble_function(Funs, Name, Args, Body) ->
-    [jumpdest(lookup_fun(Funs, Name)),
-     assemble_expr(Funs, lists:reverse(Args), tail, Body),
-     %% swap return value and first argument
-     pop_args(length(Args)),
-     swap(1),
-     i(?JUMP)].
-
-%% {seq, Es} - should be "one" operation in terms of stack content
-%% i.e. after the `seq` there should be one new element on the stack.
-assemble_expr(Funs, Stack, Tail, {seq, [E]}) ->
-    assemble_expr(Funs, Stack, Tail, E);
-assemble_expr(Funs, Stack, Tail, {seq, [E | Es]}) ->
-    [assemble_expr(Funs, Stack, nontail, E),
-     assemble_expr(Funs, Stack, Tail, {seq, Es})];
-assemble_expr(_Funs, _Stack, _Tail, {inline_asm, Code}) ->
-    Code;   %% Unsafe! Code should take care to respect the stack!
-assemble_expr(Funs, Stack, _TailPosition, {var_ref, Id}) ->
-    case lists:keymember(Id, 1, Stack) of
-        true ->
-            dup(lookup_var(Id, Stack));
-        false ->
-            %% Build a closure
-            %% When a top-level fun is called directly, we do not
-            %% reach this case.
-            Eta = make_ref(),
-            Continue = make_ref(),
-            [i(?MSIZE),
-             push_label(Eta),
-             dup(2),
-             i(?MSTORE),
-             jump(Continue),
-             %% the code of the closure
-             jumpdest(Eta),
-             %% pop the pointer to the function
-             pop(1),
-             jump(lookup_fun(Funs, Id)),
-             jumpdest(Continue)]
-    end;
-assemble_expr(_, _, _, {missing_field, Format, Args}) ->
-    io:format(Format, Args),
-    gen_error(missing_field);
-assemble_expr(_Funs, _Stack, _, {integer, N}) ->
-    push(N);
-assemble_expr(Funs, Stack, _, {tuple, Cpts}) ->
-    %% We build tuples right-to-left, so that the first write to the
-    %% tuple extends the memory size. Because we use ?MSIZE as the
-    %% heap pointer, we must allocate the tuple AFTER computing the
-    %% first element.
-    %% We store elements into the tuple as soon as possible, to avoid
-    %% keeping them for a long time on the stack.
-    case lists:reverse(Cpts) of
-        [] ->
-            i(?MSIZE);
-        [Last|Rest] ->
-            [assemble_expr(Funs, Stack, nontail, Last),
-             %% allocate the tuple memory
-             i(?MSIZE),
-             %% compute address of last word
-             push(32 * (length(Cpts) - 1)), i(?ADD),
-             %% Stack: <last-value> <pointer>
-             %% Write value to memory (allocates the tuple)
-             swap(1), dup(2), i(?MSTORE),
-             %% Stack: pointer to last word written
-             [[%% Update pointer to next word to be written
-               push(32), swap(1), i(?SUB),
-               %% Compute element
-               assemble_expr(Funs, [pointer|Stack], nontail, A),
-               %% Write element to memory
-               dup(2), i(?MSTORE)]
-               %% And we leave a pointer to the last word written on
-               %% the stack
-              || A <- Rest]]
-            %% The pointer to the entire tuple is on the stack
-    end;
-assemble_expr(_Funs, _Stack, _, {list, []}) ->
-    %% Use Erik's value of -1 for []
-    [push(0), i(?NOT)];
-assemble_expr(Funs, Stack, _, {list, [A|B]}) ->
-    assemble_expr(Funs, Stack, nontail, {tuple, [A, {list, B}]});
-assemble_expr(Funs, Stack, _, {unop, '!', A}) ->
-    case A of
-        {binop, Logical, _, _} when Logical=='&&'; Logical=='||' ->
-            assemble_expr(Funs, Stack, nontail, {ifte, A, {integer, 0}, {integer, 1}});
-        _ ->
-            [assemble_expr(Funs, Stack, nontail, A),
-             i(?ISZERO)
-            ]
-    end;
-assemble_expr(Funs, Stack, _, {event, Topics, Payload}) ->
-    [assemble_exprs(Funs, Stack, Topics ++ [Payload]),
-     case length(Topics) of
-        0 -> i(?LOG0);
-        1 -> i(?LOG1);
-        2 -> i(?LOG2);
-        3 -> i(?LOG3);
-        4 -> i(?LOG4)
-     end, i(?MSIZE)];
-assemble_expr(Funs, Stack, _, {unop, Op, A}) ->
-    [assemble_expr(Funs, Stack, nontail, A),
-     assemble_prefix(Op)];
-assemble_expr(Funs, Stack, Tail, {binop, '&&', A, B}) ->
-    assemble_expr(Funs, Stack, Tail, {ifte, A, B, {integer, 0}});
-assemble_expr(Funs, Stack, Tail, {binop, '||', A, B}) ->
-    assemble_expr(Funs, Stack, Tail, {ifte, A, {integer, 1}, B});
-assemble_expr(Funs, Stack, Tail, {binop, '::', A, B}) ->
-    %% Take advantage of optimizations in tuple construction.
-    assemble_expr(Funs, Stack, Tail, {tuple, [A, B]});
-assemble_expr(Funs, Stack, _, {binop, Op, A, B}) ->
-    %% EEVM binary instructions take their first argument from the top
-    %% of the stack, so to get operands on the stack in the right
-    %% order, we evaluate from right to left.
-    [assemble_expr(Funs, Stack, nontail, B),
-     assemble_expr(Funs, [dummy|Stack], nontail, A),
-     assemble_infix(Op)];
-assemble_expr(Funs, Stack, _, {lambda, Args, Body}) ->
-    Function = make_ref(),
-    FunBody  = make_ref(),
-    Continue = make_ref(),
-    NoMatch  = make_ref(),
-    FreeVars = free_vars({lambda, Args, Body}),
-    {NewVars, MatchingCode} = assemble_pattern(FunBody, NoMatch, {tuple, [{var_ref, "_"}|FreeVars]}),
-    BodyCode = assemble_expr(Funs, NewVars ++ lists:reverse([ {Arg#arg.name, Arg#arg.type} || Arg <- Args ]), tail, Body),
-    [assemble_expr(Funs, Stack, nontail, {tuple, [{label, Function}|FreeVars]}),
-     jump(Continue), %% will be optimized away
-     jumpdest(Function),
-     %% A pointer to the closure is on the stack
-     MatchingCode,
-     jumpdest(FunBody),
-     BodyCode,
-     pop_args(length(Args)+length(NewVars)),
-     swap(1),
-     i(?JUMP),
-     jumpdest(NoMatch), %% dead code--raise an exception just in case
-     push(0),
-     i(?NOT),
-     i(?MLOAD),
-     i(?STOP),
-     jumpdest(Continue)];
-assemble_expr(_, _, _, {label, Label}) ->
-    push_label(Label);
-assemble_expr(Funs, Stack, nontail, {funcall, Fun, Args}) ->
-    Return = make_ref(),
-    %% This is the obvious code:
-    %%   [{push_label, Return},
-    %%    assemble_exprs(Funs, [return_address|Stack], Args++[Fun]),
-    %%    'JUMP',
-    %%    {'JUMPDEST', Return}];
-    %% Its problem is that it stores the return address on the stack
-    %% while the arguments are computed, which is unnecessary. To
-    %% avoid that, we compute the last argument FIRST, and replace it
-    %% with the return address using a SWAP.
-    %%
-    %% assemble_function leaves the code pointer of the function to
-    %% call on top of the stack, and--if the function is not a
-    %% top-level name--a pointer to its tuple of free variables. In
-    %% either case a JUMP is the right way to call it.
-    case Args of
-        [] ->
-            [push_label(Return),
-             assemble_function(Funs, [return_address|Stack], Fun),
-             i(?JUMP),
-             jumpdest(Return)];
-        _ ->
-            {Init, [Last]} = lists:split(length(Args) - 1, Args),
-            [assemble_exprs(Funs, Stack, [Last|Init]),
-             %% Put the return address in the right place, which also
-             %% reorders the args correctly.
-             push_label(Return),
-             swap(length(Args)),
-             assemble_function(Funs, [dummy || _ <- Args] ++ [return_address|Stack], Fun),
-             i(?JUMP),
-             jumpdest(Return)]
-    end;
-assemble_expr(Funs, Stack, tail, {funcall, Fun, Args}) ->
-    IsTopLevel = is_top_level_fun(Stack, Fun),
-    %% If the fun is not top-level, then it may refer to local
-    %% variables and must be computed before stack shuffling.
-    ArgsAndFun = Args++[Fun || not IsTopLevel],
-    ComputeArgsAndFun = assemble_exprs(Funs, Stack, ArgsAndFun),
-    %% Copy arguments back down the stack to the start of the frame
-    ShuffleSpec = lists:seq(length(ArgsAndFun), 1, -1) ++ [discard || _ <- Stack],
-    Shuffle = shuffle_stack(ShuffleSpec),
-    [ComputeArgsAndFun, Shuffle,
-     if IsTopLevel ->
-             %% still need to compute function
-             assemble_function(Funs, [], Fun);
-        true ->
-             %% need to unpack a closure
-             [dup(1), i(?MLOAD)]
-     end,
-     i(?JUMP)];
-assemble_expr(Funs, Stack, Tail, {ifte, Decision, Then, Else}) ->
-    %% This compilation scheme introduces a lot of labels and
-    %% jumps. Unnecessary ones are removed later in
-    %% resolve_references.
-    Close = make_ref(),
-    ThenL = make_ref(),
-    ElseL = make_ref(),
-    [assemble_decision(Funs, Stack, Decision, ThenL, ElseL),
-     jumpdest(ElseL),
-     assemble_expr(Funs, Stack, Tail, Else),
-     jump(Close),
-     jumpdest(ThenL),
-     assemble_expr(Funs, Stack, Tail, Then),
-     jumpdest(Close)
-    ];
-assemble_expr(Funs, Stack, Tail, {switch, A, Cases}) ->
-    Close = make_ref(),
-    [assemble_expr(Funs, Stack, nontail, A),
-     assemble_cases(Funs, Stack, Tail, Close, Cases),
-     {'JUMPDEST', Close}];
-%% State primitives
-%%  (A pointer to) the contract state is stored at address 0.
-assemble_expr(_Funs, _Stack, _Tail, prim_state) ->
-    [push(0), i(?MLOAD)];
-assemble_expr(Funs, Stack, _Tail, #prim_put{ state = State }) ->
-    [assemble_expr(Funs, Stack, nontail, State),
-     push(0), i(?MSTORE),   %% We need something for the unit value on the stack,
-     i(?MSIZE)];            %% MSIZE is the cheapest instruction.
-%% Environment primitives
-assemble_expr(_Funs, _Stack, _Tail, prim_contract_address) ->
-    [i(?ADDRESS)];
-assemble_expr(_Funs, _Stack, _Tail, prim_contract_creator) ->
-    [i(?CREATOR)];
-assemble_expr(_Funs, _Stack, _Tail, prim_call_origin) ->
-    [i(?ORIGIN)];
-assemble_expr(_Funs, _Stack, _Tail, prim_caller) ->
-    [i(?CALLER)];
-assemble_expr(_Funs, _Stack, _Tail, prim_call_value) ->
-    [i(?CALLVALUE)];
-assemble_expr(_Funs, _Stack, _Tail, prim_gas_price) ->
-    [i(?GASPRICE)];
-assemble_expr(_Funs, _Stack, _Tail, prim_gas_left) ->
-    [i(?GAS)];
-assemble_expr(_Funs, _Stack, _Tail, prim_coinbase) ->
-    [i(?COINBASE)];
-assemble_expr(_Funs, _Stack, _Tail, prim_timestamp) ->
-    [i(?TIMESTAMP)];
-assemble_expr(_Funs, _Stack, _Tail, prim_block_height) ->
-    [i(?NUMBER)];
-assemble_expr(_Funs, _Stack, _Tail, prim_difficulty) ->
-    [i(?DIFFICULTY)];
-assemble_expr(_Funs, _Stack, _Tail, prim_gas_limit) ->
-    [i(?GASLIMIT)];
-assemble_expr(Funs, Stack, _Tail, #prim_balance{ address = Addr }) ->
-    [assemble_expr(Funs, Stack, nontail, Addr),
-     i(?BALANCE)];
-assemble_expr(Funs, Stack, _Tail, #prim_block_hash{ height = Height }) ->
-    [assemble_expr(Funs, Stack, nontail, Height),
-     i(?BLOCKHASH)];
-assemble_expr(Funs, Stack, _Tail,
-              #prim_call_contract{ gas      = Gas
-                                 , address  = To
-                                 , value    = Value
-                                 , arg      = Arg
-                                 , type_hash= TypeHash
-                                 }) ->
-    %% ?CALL takes (from the top)
-    %%   Gas, To, Value, Arg, TypeHash, _OOffset,_OSize
-    %% So assemble these in reverse order.
-    [ assemble_exprs(Funs, Stack, [ {integer, 0}, {integer, 0}, TypeHash
-                                  , Arg, Value, To, Gas ])
-    , i(?CALL)
-    ].
-
-
-assemble_exprs(_Funs, _Stack, []) ->
-    [];
-assemble_exprs(Funs, Stack, [E|Es]) ->
-    [assemble_expr(Funs, Stack, nontail, E),
-     assemble_exprs(Funs, [dummy|Stack], Es)].
-
-assemble_decision(Funs, Stack, {binop, '&&', A, B}, Then, Else) ->
-    Label = make_ref(),
-    [assemble_decision(Funs, Stack, A, Label, Else),
-     jumpdest(Label),
-     assemble_decision(Funs, Stack, B, Then, Else)];
-assemble_decision(Funs, Stack, {binop, '||', A, B}, Then, Else) ->
-    Label = make_ref(),
-    [assemble_decision(Funs, Stack, A, Then, Label),
-     jumpdest(Label),
-     assemble_decision(Funs, Stack, B, Then, Else)];
-assemble_decision(Funs, Stack, {unop, '!', A}, Then, Else) ->
-    assemble_decision(Funs, Stack, A, Else, Then);
-assemble_decision(Funs, Stack, {ifte, A, B, C}, Then, Else) ->
-    TrueL  = make_ref(),
-    FalseL = make_ref(),
-    [assemble_decision(Funs, Stack, A, TrueL, FalseL),
-     jumpdest(TrueL),  assemble_decision(Funs, Stack, B, Then, Else),
-     jumpdest(FalseL), assemble_decision(Funs, Stack, C, Then, Else)];
-assemble_decision(Funs, Stack, Decision, Then, Else) ->
-    [assemble_expr(Funs, Stack, nontail, Decision),
-     jump_if(Then), jump(Else)].
-
-%% Entered with value to switch on on top of the stack
-%% Evaluate selected case, then jump to Close with result on the
-%% stack.
-assemble_cases(_Funs, _Stack, _Tail, _Close, []) ->
-    %% No match! What should be do? There's no real way to raise an
-    %% exception, except consuming all the gas.
-    %% There should not be enough gas to do this:
-    [push(1), i(?NOT),
-     i(?MLOAD),
-     %% now stop, so that jump optimizer realizes we will not fall
-     %% through this code.
-     i(?STOP)];
-assemble_cases(Funs, Stack, Tail, Close, [{Pattern, Body}|Cases]) ->
-    Succeed = make_ref(),
-    Fail = make_ref(),
-    {NewVars, MatchingCode} =
-        assemble_pattern(Succeed, Fail, Pattern),
-    %% In the code that follows, if this is NOT the last case, then we
-    %% save the value being switched on, and discard it on
-    %% success. The code is simpler if this IS the last case.
-    [[dup(1) || Cases /= []],   %% save value for next case, if there is one
-     MatchingCode,
-     jumpdest(Succeed),
-     %% Discard saved value, if we saved one
-     [case NewVars of
-          [] ->
-              pop(1);
-          [_] ->
-              %% Special case for peep-hole optimization
-              pop_args(1);
-          _ ->
-              [swap(length(NewVars)), pop(1)]
-      end
-      || Cases/=[]],
-     assemble_expr(Funs,
-                   case Cases of
-                       [] -> NewVars;
-                       _  -> reorder_vars(NewVars)
-                   end
-                   ++Stack, Tail, Body),
-     %% If the Body makes a tail call, then we will not return
-     %% here--but it doesn't matter, because
-     %% (a) the NewVars will be popped before the tailcall
-     %% (b) the code below will be deleted since it is dead
-     pop_args(length(NewVars)),
-     jump(Close),
-     jumpdest(Fail),
-     assemble_cases(Funs, Stack, Tail, Close, Cases)].
-
-%% Entered with value to match on top of the stack.
-%% Generated code removes value, and
-%%   - jumps to Fail if no match, or
-%%   - binds variables, leaves them on the stack, and jumps to Succeed
-%% Result is a list of variables to add to the stack, and the matching
-%% code.
-assemble_pattern(Succeed, Fail, {integer, N}) ->
-    {[], [push(N),
-         i(?EQ),
-         jump_if(Succeed),
-         jump(Fail)]};
-assemble_pattern(Succeed, _Fail, {var_ref, "_"}) ->
-    {[], [i(?POP), jump(Succeed)]};
-assemble_pattern(Succeed, Fail, {missing_field, _, _}) ->
-    %% Missing record fields are quite ok in patterns.
-    assemble_pattern(Succeed, Fail, {var_ref, "_"});
-assemble_pattern(Succeed, _Fail, {var_ref, Id}) ->
-    {[{Id, "_"}], jump(Succeed)};
-assemble_pattern(Succeed, _Fail, {tuple, []}) ->
-    {[], [pop(1), jump(Succeed)]};
-assemble_pattern(Succeed, Fail, {tuple, [A]}) ->
-    %% Treat this case specially, because we don't need to save the
-    %% pointer to the tuple.
-    {AVars, ACode} = assemble_pattern(Succeed, Fail, A),
-    {AVars, [i(?MLOAD),
-            ACode]};
-assemble_pattern(Succeed, Fail, {tuple, [A|B]}) ->
-    %% Entered with the address of the tuple on the top of the
-    %% stack. We will duplicate the address before matching on A.
-    Continue = make_ref(),  %% the label for matching B
-    Pop1Fail = make_ref(),  %% pop 1 word and goto Fail
-    PopNFail = make_ref(),  %% pop length(AVars) words and goto Fail
-    {AVars, ACode} =
-        assemble_pattern(Continue, Pop1Fail, A),
-    {BVars, BCode} =
-        assemble_pattern(Succeed, PopNFail, {tuple, B}),
-    {BVars ++ reorder_vars(AVars),
-     [%% duplicate the pointer so we don't lose it when we match on A
-      dup(1),
-      i(?MLOAD),
-      ACode,
-      jumpdest(Continue),
-      %% Bring the pointer to the top of the stack--this reorders AVars!
-      swap(length(AVars)),
-      push(32),
-      i(?ADD),
-      BCode,
-      case AVars of
-          [] ->
-              [jumpdest(Pop1Fail), pop(1),
-               jumpdest(PopNFail),
-               jump(Fail)];
-          _ ->
-              [{'JUMPDEST', PopNFail}, pop(length(AVars)-1),
-               {'JUMPDEST', Pop1Fail}, pop(1),
-               {push_label, Fail}, 'JUMP']
-      end]};
-assemble_pattern(Succeed, Fail, {list, []}) ->
-    %% [] is represented by -1.
-    {[], [push(1),
-          i(?ADD),
-          jump_if(Fail),
-          jump(Succeed)]};
-assemble_pattern(Succeed, Fail, {list, [A|B]}) ->
-    assemble_pattern(Succeed, Fail, {binop, '::', A, {list, B}});
-assemble_pattern(Succeed, Fail, {binop, '::', A, B}) ->
-    %% Make sure it's not [], then match as tuple.
-    NotNil = make_ref(),
-    {Vars, Code} = assemble_pattern(Succeed, Fail, {tuple, [A, B]}),
-    {Vars, [dup(1), push(1), i(?ADD),   %% Check for [] without consuming the value
-            jump_if(NotNil),            %% so it's still there when matching the tuple.
-            pop(1),                     %% It was [] so discard the saved value.
-            jump(Fail),
-            jumpdest(NotNil),
-            Code]}.
-
-%% When Vars are on the stack, with a value we want to discard
-%% below them, then we swap the top variable with that value and pop.
-%% This reorders the variables on the stack, as follows:
-reorder_vars([]) ->
-    [];
-reorder_vars([V|Vs]) ->
-    Vs ++ [V].
-
-assemble_prefix('sha3') -> [i(?DUP1), i(?MLOAD),          %% length, ptr
-                            i(?SWAP1), push(32), i(?ADD), %% ptr+32, length
-                            i(?SHA3)];
-assemble_prefix('-') -> [push(0), i(?SUB)];
-assemble_prefix('bnot') -> i(?NOT).
-
-assemble_infix('+')    -> i(?ADD);
-assemble_infix('-')    -> i(?SUB);
-assemble_infix('*')    -> i(?MUL);
-assemble_infix('/')    -> i(?SDIV);
-assemble_infix('div')  -> i(?DIV);
-assemble_infix('mod')  -> i(?MOD);
-assemble_infix('^')    -> i(?EXP);
-assemble_infix('bor')  -> i(?OR);
-assemble_infix('band') -> i(?AND);
-assemble_infix('bxor') -> i(?XOR);
-assemble_infix('bsl')  -> i(?SHL);
-assemble_infix('bsr')  -> i(?SHR);
-assemble_infix('<')    -> i(?SLT);    %% comparisons are SIGNED
-assemble_infix('>')    -> i(?SGT);
-assemble_infix('==')   -> i(?EQ);
-assemble_infix('<=')   -> [i(?SGT), i(?ISZERO)];
-assemble_infix('=<')   -> [i(?SGT), i(?ISZERO)];
-assemble_infix('>=')   -> [i(?SLT), i(?ISZERO)];
-assemble_infix('!=')   -> [i(?EQ), i(?ISZERO)];
-assemble_infix('!')    -> [i(?ADD), i(?MLOAD)];
-assemble_infix('byte') -> i(?BYTE).
-%% assemble_infix('::') -> [i(?MSIZE), write_word(0), write_word(1)].
-
-%% a function may either refer to a top-level function, in which case
-%% we fetch the code label from Funs, or it may be a lambda-expression
-%% (including a top-level function passed as a parameter). In the
-%% latter case, the function value is a pointer to a tuple of the code
-%% pointer and the free variables: we keep the pointer and push the
-%% code pointer onto the stack. In either case, we are ready to enter
-%% the function with JUMP.
-assemble_function(Funs, Stack, Fun) ->
-    case is_top_level_fun(Stack, Fun) of
-        true ->
-            {var_ref, Name} = Fun,
-            {push_label, lookup_fun(Funs, Name)};
-        false ->
-            [assemble_expr(Funs, Stack, nontail, Fun),
-             dup(1),
-             i(?MLOAD)]
-    end.
-
-free_vars(V={var_ref, _}) ->
-    [V];
-free_vars({switch, E, Cases}) ->
-    lists:umerge(free_vars(E),
-                 lists:umerge([free_vars(Body)--free_vars(Pattern)
-                               || {Pattern, Body} <- Cases]));
-free_vars({lambda, Args, Body}) ->
-    free_vars(Body) -- [{var_ref, Arg#arg.name} || Arg <- Args];
-free_vars(T) when is_tuple(T) ->
-    free_vars(tuple_to_list(T));
-free_vars([H|T]) ->
-    lists:umerge(free_vars(H), free_vars(T));
-free_vars(_) ->
-    [].
-
-
-
-%% shuffle_stack reorders the stack, for example before a tailcall. It is called
-%% with a description of the current stack, and how the final stack
-%% should appear. The argument is a list containing
-%%   a NUMBER for each element that should be kept, the number being
-%%     the position this element should occupy in the final stack
-%%   discard, for elements that can be discarded.
-%% The positions start at 1, referring to the variable to be placed at
-%% the bottom of the stack, and ranging up to the size of the final stack.
-shuffle_stack([]) ->
-    [];
-shuffle_stack([discard|Stack]) ->
-    [i(?POP) | shuffle_stack(Stack)];
-shuffle_stack([N|Stack]) ->
-    case length(Stack) + 1 - N of
-        0 ->
-            %% the job should be finished
-            CorrectStack = lists:seq(N - 1, 1, -1),
-            CorrectStack = Stack,
-            [];
-        MoveBy ->
-            {Pref, [_|Suff]} = lists:split(MoveBy - 1, Stack),
-            [swap(MoveBy) | shuffle_stack([lists:nth(MoveBy, Stack) | Pref ++ [N|Suff]])]
-    end.
-
-
-
-lookup_fun(Funs, Name) ->
-    case [Ref || {Name1, _, Ref} <- Funs,
-                 Name == Name1] of
-        [Ref] -> Ref;
-        []    -> gen_error({undefined_function, Name})
-    end.
-
-is_top_level_fun(Stack, {var_ref, Id}) ->
-    not lists:keymember(Id, 1, Stack);
-is_top_level_fun(_, _) ->
-    false.
-
-lookup_var(Id, Stack) ->
-    lookup_var(1, Id, Stack).
-
-lookup_var(N, Id, [{Id, _Type}|_]) ->
-    N;
-lookup_var(N, Id, [_|Stack]) ->
-    lookup_var(N + 1, Id, Stack);
-lookup_var(_, Id, []) ->
-    gen_error({var_not_in_scope, Id}).
-
-%% Smart instruction generation
-
-%% TODO: handle references to the stack beyond depth 16. Perhaps the
-%% best way is to repush variables that will be needed in
-%% subexpressions before evaluating he subexpression... i.e. fix the
-%% problem in assemble_expr, rather than here. A fix here would have
-%% to save the top elements of the stack in memory, duplicate the
-%% targetted element, and then repush the values from memory.
-dup(N) when 1 =< N, N =< 16 ->
-    i(?DUP1 + N - 1).
-
-push(N) ->
-    Bytes = binary:encode_unsigned(N),
-    true = size(Bytes) =< 32,
-    [i(?PUSH1 + size(Bytes) - 1) |
-     binary_to_list(Bytes)].
-
-%% Pop N values from UNDER the top element of the stack.
-%% This is a pseudo-instruction so peephole optimization can
-%% combine pop_args(M), pop_args(N) to pop_args(M+N)
-pop_args(0) ->
-    [];
-pop_args(N) ->
-    {pop_args, N}.
-%%    [swap(N), pop(N)].
-
-pop(N) ->
-    [i(?POP) || _ <- lists:seq(1, N)].
-
-swap(0) ->
-    %% Doesn't exist, but is logically a no-op.
-    [];
-swap(N) when 1 =< N, N =< 16 ->
-    i(?SWAP1 + N - 1).
-
-jumpdest(Label)   -> {i(?JUMPDEST), Label}.
-push_label(Label) -> {push_label, Label}.
-
-jump(Label)    -> [push_label(Label), i(?JUMP)].
-jump_if(Label) -> [push_label(Label), i(?JUMPI)].
-
-%% ICode utilities (TODO: move to separate module)
-
-icode_noname() -> #var_ref{name = "_"}.
-
-icode_seq([A]) -> A;
-icode_seq([A | As]) ->
-    icode_seq(A, icode_seq(As)).
-
-icode_seq(A, B) ->
-    #switch{ expr = A, cases = [{icode_noname(), B}] }.
-
-%% Stack: <N elements> ADDR
-%% Write elements at addresses ADDR, ADDR+32, ADDR+64...
-%% Stack afterwards: ADDR
-% write_words(N) ->
-%      [write_word(I) || I <- lists:seq(N-1, 0, -1)].
-
-%% Unused at the moment. Comment out to please dialyzer.
-%% write_word(I) ->
-%%     [%% Stack: elements e ADDR
-%%        swap(1),
-%%        dup(2),
-%%        %% Stack: elements ADDR e ADDR
-%%        push(32*I),
-%%        i(?ADD),
-%%        %% Stack: elements ADDR e ADDR+32I
-%%        i(?MSTORE)].
-
-%% Resolve references, and convert code from deep list to flat list.
-%% List elements are:
-%%   Opcodes
-%%   Byte values
-%%   {'JUMPDEST', Ref}   -- assembles to ?JUMPDEST and sets Ref
-%%   {push_label, Ref}  -- assembles to ?PUSHN address bytes
-
-%% For now, we assemble all code addresses as three bytes.
-
-resolve_references(Code) ->
-    Peephole = peep_hole(lists:flatten(Code)),
-    %% WARNING: Optimizing jumps reorders the code and deletes
-    %% instructions. When debugging the assemble_ functions, it can be
-    %% useful to replace the next line by:
-    %% Instrs = lists:flatten(Code),
-    %% thus disabling the optimization.
-    OptimizedJumps = optimize_jumps(Peephole),
-    Instrs = lists:reverse(peep_hole_backwards(lists:reverse(OptimizedJumps))),
-    Labels = define_labels(0, Instrs),
-    lists:flatten([use_labels(Labels, I) || I <- Instrs]).
-
-define_labels(Addr, [{'JUMPDEST', Lab}|More]) ->
-    [{Lab, Addr}|define_labels(Addr + 1, More)];
-define_labels(Addr, [{push_label, _}|More]) ->
-    define_labels(Addr + 4, More);
-define_labels(Addr, [{pop_args, N}|More]) ->
-    define_labels(Addr + N + 1, More);
-define_labels(Addr, [_|More]) ->
-    define_labels(Addr + 1, More);
-define_labels(_, []) ->
-    [].
-
-use_labels(_, {'JUMPDEST', _}) ->
-    'JUMPDEST';
-use_labels(Labels, {push_label, Ref}) ->
-    case proplists:get_value(Ref, Labels) of
-        undefined ->
-            gen_error({undefined_label, Ref});
-        Addr when is_integer(Addr) ->
-            [i(?PUSH3),
-             Addr div 65536, (Addr div 256) rem 256, Addr rem 256]
-    end;
-use_labels(_, {pop_args, N}) ->
-    [swap(N), pop(N)];
-use_labels(_, I) ->
-    I.
-
-%% Peep-hole optimization.
-%% The compilation of conditionals can introduce jumps depending on
-%% constants 1 and 0. These are removed by peep-hole optimization.
-
-peep_hole(['PUSH1', 0, {push_label, _}, 'JUMPI'|More]) ->
-    peep_hole(More);
-peep_hole(['PUSH1', 1, {push_label, Lab}, 'JUMPI'|More]) ->
-    [{push_label, Lab}, 'JUMP'|peep_hole(More)];
-peep_hole([{pop_args, M}, {pop_args, N}|More]) when M + N =< 16 ->
-    peep_hole([{pop_args, M + N}|More]);
-peep_hole([I|More]) ->
-    [I|peep_hole(More)];
-peep_hole([]) ->
-    [].
-
-%% Peep-hole optimization on reversed instructions lists.
-
-peep_hole_backwards(Code) ->
-    NewCode = peep_hole_backwards1(Code),
-    if Code == NewCode -> Code;
-       true            -> peep_hole_backwards(NewCode)
-    end.
-
-peep_hole_backwards1(['ADD', 0, 'PUSH1'|Code]) ->
-    peep_hole_backwards1(Code);
-peep_hole_backwards1(['POP', UnOp|Code]) when UnOp=='MLOAD';UnOp=='ISZERO';UnOp=='NOT' ->
-    peep_hole_backwards1(['POP'|Code]);
-peep_hole_backwards1(['POP', BinOp|Code]) when
-    %% TODO: more binary operators
-    BinOp=='ADD';BinOp=='SUB';BinOp=='MUL';BinOp=='SDIV' ->
-    peep_hole_backwards1(['POP', 'POP'|Code]);
-peep_hole_backwards1(['POP', _, 'PUSH1'|Code]) ->
-    peep_hole_backwards1(Code);
-peep_hole_backwards1([I|Code]) ->
-    [I|peep_hole_backwards1(Code)];
-peep_hole_backwards1([]) ->
-    [].
-
-%% Jump optimization:
-%%   Replaces a jump to a jump with a jump to the final destination
-%%   Moves basic blocks to eliminate an unconditional jump to them.
-
-%% The compilation of conditionals generates a lot of labels and
-%% jumps, some of them unnecessary. This optimization phase reorders
-%% code so that as many jumps as possible can be eliminated, and
-%% replaced by just falling through to the destination label. This
-%% both optimizes the code generated by conditionals, and converts one
-%% call of a function into falling through into its code--so it
-%% reorders code quite aggressively. Function returns are indirect
-%% jumps, however, and are never optimized away.
-
-%% IMPORTANT: since execution begins at address zero, then the first
-%% block of code must never be moved elsewhere. The code below has
-%% this property, because it processes blocks from left to right, and
-%% because the first block does not begin with a label, and so can
-%% never be jumped to--hence no code can be inserted before it.
-
-%% The optimization works by taking one block of code at a time, and
-%% then prepending blocks that jump directly to it, and appending
-%% blocks that it jumps directly to, resulting in a jump-free sequence
-%% that is as long as possible. To do so, we store blocks in the form
-%% {OptionalLabel, Body, OptionalJump} which represents the code block
-%% OptionalLabel++Body++OptionalJump; the optional parts are the empty
-%% list of instructions if not present.  Two blocks can be merged if
-%% the first ends in an OptionalJump to the OptionalLabel beginning
-%% the second; the OptionalJump can then be removed (and the
-%% OptionalLabel if there are no other references to it--this happens
-%% during dead code elimination.
-
-%% TODO: the present implementation is QUADRATIC, because we search
-%% repeatedly for matching blocks to merge with the first one, storing
-%% the blocks in a list. A near linear time implementation could use
-%% two ets tables, one keyed on the labels, and the other keyed on the
-%% final jumps.
-
-optimize_jumps(Code) ->
-    JJs = jumps_to_jumps(Code),
-    ShortCircuited = [short_circuit_jumps(JJs, Instr) || Instr <- Code],
-    NoDeadCode = eliminate_dead_code(ShortCircuited),
-    MovedCode = merge_blocks(moveable_blocks(NoDeadCode)),
-    %% Moving code may have made some labels superfluous.
-    eliminate_dead_code(MovedCode).
-
-
-jumps_to_jumps([{'JUMPDEST', Label}, {push_label, Target}, 'JUMP'|More]) ->
-    [{Label, Target}|jumps_to_jumps(More)];
-jumps_to_jumps([{'JUMPDEST', Label}, {'JUMPDEST', Target}|More]) ->
-    [{Label, Target}|jumps_to_jumps([{'JUMPDEST', Target}|More])];
-jumps_to_jumps([_|More]) ->
-    jumps_to_jumps(More);
-jumps_to_jumps([]) ->
-    [].
-
-short_circuit_jumps(JJs, {push_label, Lab}) ->
-    case proplists:get_value(Lab, JJs) of
-        undefined ->
-            {push_label, Lab};
-        Target ->
-            %% I wonder if this will ever loop infinitely?
-            short_circuit_jumps(JJs, {push_label, Target})
-    end;
-short_circuit_jumps(_JJs, Instr) ->
-    Instr.
-
-eliminate_dead_code(Code) ->
-    Jumps = lists:usort([Lab || {push_label, Lab} <- Code]),
-    NewCode = live_code(Jumps, Code),
-    if Code==NewCode ->
-            Code;
-       true ->
-            eliminate_dead_code(NewCode)
-    end.
-
-live_code(Jumps, ['JUMP'|More]) ->
-    ['JUMP'|dead_code(Jumps, More)];
-live_code(Jumps, ['STOP'|More]) ->
-    ['STOP'|dead_code(Jumps, More)];
-live_code(Jumps, [{'JUMPDEST', Lab}|More]) ->
-    case lists:member(Lab, Jumps) of
-        true ->
-            [{'JUMPDEST', Lab}|live_code(Jumps, More)];
-        false ->
-            live_code(Jumps, More)
-    end;
-live_code(Jumps, [I|More]) ->
-    [I|live_code(Jumps, More)];
-live_code(_, []) ->
-    [].
-
-dead_code(Jumps, [{'JUMPDEST', Lab}|More]) ->
-    case lists:member(Lab, Jumps) of
-        true ->
-            [{'JUMPDEST', Lab}|live_code(Jumps, More)];
-        false ->
-            dead_code(Jumps, More)
-    end;
-dead_code(Jumps, [_I|More]) ->
-    dead_code(Jumps, More);
-dead_code(_, []) ->
-    [].
-
-%% Split the code into "moveable blocks" that control flow only
-%% reaches via jumps.
-moveable_blocks([]) ->
-    [];
-moveable_blocks([I]) ->
-    [[I]];
-moveable_blocks([Jump|More]) when Jump=='JUMP'; Jump=='STOP' ->
-    [[Jump]|moveable_blocks(More)];
-moveable_blocks([I|More]) ->
-    [Block|MoreBlocks] = moveable_blocks(More),
-    [[I|Block]|MoreBlocks].
-
-%% Merge blocks to eliminate jumps where possible.
-merge_blocks(Blocks) ->
-    BlocksAndTargets = [label_and_jump(B) || B <- Blocks],
-    [I || {Pref, Body, Suff} <- merge_after(BlocksAndTargets),
-          I <- Pref++Body++Suff].
-
-%% Merge the first block with other blocks that come after it
-merge_after(All=[{Label, Body, [{push_label, Target}, 'JUMP']}|BlocksAndTargets]) ->
-    case [{B, J} || {[{'JUMPDEST', L}], B, J} <- BlocksAndTargets,
-                   L == Target] of
-        [{B, J}|_] ->
-            merge_after([{Label, Body ++ [{'JUMPDEST', Target}] ++ B, J}|
-                         lists:delete({[{'JUMPDEST', Target}], B, J},
-                                      BlocksAndTargets)]);
-        [] ->
-            merge_before(All)
-    end;
-merge_after(All) ->
-    merge_before(All).
-
-%% The first block cannot be merged with any blocks that it jumps
-%% to... but maybe it can be merged with a block that jumps to it!
-merge_before([Block={[{'JUMPDEST', Label}], Body, Jump}|BlocksAndTargets]) ->
-    case [{L, B, T} || {L, B, [{push_label, T}, 'JUMP']} <- BlocksAndTargets,
-                     T == Label] of
-        [{L, B, T}|_] ->
-            merge_before([{L, B ++ [{'JUMPDEST', Label}] ++ Body, Jump}
-                          |lists:delete({L, B, [{push_label, T}, 'JUMP']}, BlocksAndTargets)]);
-        _ ->
-            [Block | merge_after(BlocksAndTargets)]
-    end;
-merge_before([Block|BlocksAndTargets]) ->
-    [Block | merge_after(BlocksAndTargets)];
-merge_before([]) ->
-    [].
-
-%% Convert each block to a PREFIX, which is a label or empty, a
-%% middle, and a SUFFIX which is a JUMP to a label, or empty.
-label_and_jump(B) ->
-    {Label, B1} = case B of
-                     [{'JUMPDEST', L}|More1] ->
-                         {[{'JUMPDEST', L}], More1};
-                     _ ->
-                         {[], B}
-                 end,
-    {Target, B2} = case lists:reverse(B1) of
-                      ['JUMP', {push_label, T}|More2] ->
-                          {[{push_label, T}, 'JUMP'], lists:reverse(More2)};
-                      _ ->
-                          {[], B1}
-                  end,
-    {Label, B2, Target}.
@@ -15,7 +15,8 @@
         many/1, many1/1, sep/2, sep1/2,
         infixl/2, infixr/2]).

-export([current_file/0, set_current_file/1]).
+-export([current_file/0, set_current_file/1,
+         current_include_type/0, set_current_include_type/1]).

 %% -- Types ------------------------------------------------------------------

@@ -74,25 +75,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 +167,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 +248,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 +262,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 +285,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} ->
@@ -457,6 +466,13 @@ merge_with(Fun, Map1, Map2) ->
                        end, Map2, maps:to_list(Map1))
    end.

+%% Current include type
+current_include_type() ->
+    get('$current_include_type').
+
+set_current_include_type(IncludeType) ->
+    put('$current_include_type', IncludeType).
+
 %% Current source file
 current_file() ->
    get('$current_file').
@@ -14,7 +14,9 @@
 -define(RULE(A, B, C,                Do), map(fun({_1, _2, _3}) ->                     Do end, {A, B, C}               )).
 -define(RULE(A, B, C, D,             Do), map(fun({_1, _2, _3, _4}) ->                 Do end, {A, B, C, D}            )).
 -define(RULE(A, B, C, D, E,          Do), map(fun({_1, _2, _3, _4, _5}) ->             Do end, {A, B, C, D, E}         )).
-define(RULE(A, B, C, D, E, F, Do), map(fun({_1, _2, _3, _4, _5, _6}) -> Do end, {A, B, C, D, E, F})).
+-define(RULE(A, B, C, D, E, F,       Do), map(fun({_1, _2, _3, _4, _5, _6}) ->         Do end, {A, B, C, D, E, F}      )).
+-define(RULE(A, B, C, D, E, F, G,    Do), map(fun({_1, _2, _3, _4, _5, _6, _7}) ->     Do end, {A, B, C, D, E, F, G}   )).
+-define(RULE(A, B, C, D, E, F, G, H, Do), map(fun({_1, _2, _3, _4, _5, _6, _7, _8}) -> Do end, {A, B, C, D, E, F, G, H})).

 -import(aeso_parse_lib,
        [tok/1, tok/2, between/3, many/1, many1/1, sep/2, sep1/2,
@@ -18,7 +18,8 @@
         run_parser/3]).

 -include("aeso_parse_lib.hrl").
-import(aeso_parse_lib, [current_file/0, set_current_file/1]).
+-import(aeso_parse_lib, [current_file/0, set_current_file/1,
+                         current_include_type/0, set_current_include_type/1]).

 -type parse_result() :: aeso_syntax:ast() | {aeso_syntax:ast(), sets:set(include_hash())} | none().

@@ -57,6 +58,7 @@ run_parser(P, Inp, Opts) ->

 parse_and_scan(P, S, Opts) ->
    set_current_file(proplists:get_value(src_file, Opts, no_file)),
+    set_current_include_type(proplists:get_value(include_type, Opts, none)),
    case aeso_scan:scan(S) of
        {ok, Tokens} -> aeso_parse_lib:parse(P, Tokens);
        {error, {{Input, Pos}, _}} ->
@@ -93,10 +95,23 @@ 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})
+    , using()
    , pragma()

      %% Type declarations  TODO: format annotation for "type bla" vs "type bla()"
@@ -119,9 +134,34 @@ fun_block(Mods, Kind, [Decl]) ->
 fun_block(Mods, Kind, Decls) ->
    {block, get_ann(Kind), [ add_modifiers(Mods, Kind, Decl) || Decl <- Decls ]}.

+typevar_constraint() ->
+    ?RULE(tvar(), keyword(is), id(), {constraint, get_ann(_1), _1, _3}).
+
+typevars_constraints() ->
+    ?RULE(comma_sep1(typevar_constraint()), tok(';'), _1).
+
+fundecl() ->
+    choice([?RULE(id(), tok(':'), typevars_constraints(), type(),
+                  {fun_decl, get_ann(_1), _1, {constrained_t, get_ann(_1), _3, _4}}),
+            ?RULE(id(), tok(':'), type(), {fun_decl, get_ann(_1), _1, _3})]).
+
 fundef_or_decl() ->
-    choice([?RULE(id(), tok(':'), type(), {fun_decl, get_ann(_1), _1, _3}),
-            fundef()]).
+    choice([fundecl(), fundef()]).
+
+using() ->
+    Alias = {keyword(as), con()},
+    For = ?RULE(keyword(for), bracket_list(id()), {for, _2}),
+    Hiding = ?RULE(keyword(hiding), bracket_list(id()), {hiding, _2}),
+    ?RULE(keyword(using), con(), optional(Alias), optional(choice(For, Hiding)), using(get_ann(_1), _2, _3, _4)).
+
+using(Ann, Con, none, none) ->
+    {using, Ann, Con, none, none};
+using(Ann, Con, {ok, {_, Alias}}, none) ->
+    {using, Ann, Con, Alias, none};
+using(Ann, Con, none, {ok, List}) ->
+    {using, Ann, Con, none, List};
+using(Ann, Con, {ok, {_, Alias}}, {ok, List}) ->
+    {using, Ann, Con, Alias, List}.

 pragma() ->
    Op = choice([token(T) || T <- ['<', '=<', '==', '>=', '>']]),
@@ -183,10 +223,16 @@ letdef() -> choice(valdef(), fundef()).
 valdef() ->
    ?RULE(pattern(), tok('='), body(), {letval, [], _1, _3}).

+guarded_fundefs() ->
+    choice(
+    [ ?RULE(keyword('='), body(), [{guarded, _1, [], _2}])
+    , maybe_block(?RULE(keyword('|'), comma_sep(expr()), tok('='), body(), {guarded, _1, _2, _4}))
+    ]).
+
 fundef() ->
    choice(
-    [ ?RULE(id(), args(),                   tok('='), body(), {letfun, get_ann(_1), _1, _2, type_wildcard(get_ann(_1)), _4})
-    , ?RULE(id(), args(), tok(':'), type(), tok('='), body(), {letfun, get_ann(_1), _1, _2, _4, _6})
+    [ ?RULE(id(), args(),                   guarded_fundefs(), {letfun, get_ann(_1), _1, _2, type_wildcard(get_ann(_1)), _3})
+    , ?RULE(id(), args(), tok(':'), type(), guarded_fundefs(), {letfun, get_ann(_1), _1, _2, _4, _5})
    ]).

 args() -> paren_list(pattern()).
@@ -196,6 +242,9 @@ arg() -> choice(
    ?RULE(id(),                   {arg, get_ann(_1), _1, type_wildcard(get_ann(_1))}),
    ?RULE(id(), tok(':'), type(), {arg, get_ann(_1), _1, _3})).

+letpat() ->
+    ?RULE(keyword('('), id(), tok('='), pattern(), tok(')'), {letpat, get_ann(_1), _2, _4}).
+
 %% -- Types ------------------------------------------------------------------

 type_vars() -> paren_list(tvar()).
@@ -242,7 +291,8 @@ body() ->

 stmt() ->
    ?LAZY_P(choice(
-    [ expr()
+    [ using()
+    , expr()
    , letdecl()
    , {switch, keyword(switch), parens(expr()), maybe_block(branch())}
    , {'if', keyword('if'), parens(expr()), body()}
@@ -251,7 +301,13 @@ stmt() ->
    ])).

 branch() ->
-    ?RULE(pattern(), keyword('=>'), body(), {'case', _2, _1, _3}).
+    ?RULE(pattern(), guarded_branches(), {'case', get_ann(lists:nth(1, _2)), _1, _2}).
+
+guarded_branches() ->
+    choice(
+    [ ?RULE(keyword('=>'), body(), [{guarded, _1, [], _2}])
+    , maybe_block(?RULE(tok('|'), comma_sep(expr()), keyword('=>'), body(), {guarded, _3, _2, _4}))
+    ]).

 pattern() ->
    ?LET_P(E, expr(), parse_pattern(E)).
@@ -262,17 +318,18 @@ expr() -> expr100().

 expr100() ->
    Expr100 = ?LAZY_P(expr100()),
-    Expr200 = ?LAZY_P(expr200()),
+    Expr150 = ?LAZY_P(expr150()),
    choice(
    [ ?RULE(lam_args(), keyword('=>'), body(), {lam, _2, _1, _3})   %% TODO: better location
-    , {'if', keyword('if'), parens(Expr100), Expr200, right(tok(else), Expr100)}
-    , ?RULE(Expr200, optional(right(tok(':'), type())),
+    , {'if', keyword('if'), parens(Expr100), Expr150, right(tok(else), Expr100)}
+    , ?RULE(Expr150, optional(right(tok(':'), type())),
            case _2 of
                none       -> _1;
                {ok, Type} -> {typed, get_ann(_1), _1, Type}
            end)
    ]).

+expr150() -> infixl(expr200(), binop('|>')).
 expr200() -> infixr(expr300(), binop('||')).
 expr300() -> infixr(expr400(), binop('&&')).
 expr400() -> infix(expr500(),  binop(['<', '>', '=<', '>=', '==', '!='])).
@@ -288,7 +345,7 @@ exprAtom() ->
    ?LAZY_P(begin
        Expr = ?LAZY_P(expr()),
        choice(
-        [ id_or_addr(), con(), token(qid), token(qcon)
+        [ id_or_addr(), con(), token(qid), token(qcon), binop_as_lam()
        , token(bytes), token(string), token(char)
        , token(int)
        , ?RULE(token(hex), set_ann(format, hex, setelement(1, _1, int)))
@@ -299,6 +356,7 @@ exprAtom() ->
        , ?RULE(keyword('['), Expr, token('|'), comma_sep(comprehension_exp()), tok(']'), list_comp_e(_1, _2, _4))
        , ?RULE(tok('['), Expr, binop('..'), Expr, tok(']'), _3(_2, _4))
        , ?RULE(keyword('('), comma_sep(Expr), tok(')'), tuple_e(_1, _2))
+        , letpat()
        ])
    end).

@@ -424,6 +482,19 @@ id()       -> token(id).
 tvar()     -> token(tvar).
 str()      -> token(string).

+binop_as_lam() ->
+    BinOps = ['&&', '||',
+              '+', '-', '*', '/', '^', 'mod',
+              '==', '!=', '<', '>', '<=', '=<', '>=',
+              '::', '++', '|>'],
+    OpToLam = fun(Op = {_, Ann}) ->
+                  IdL = {id, Ann, "l"},
+                  IdR = {id, Ann, "r"},
+                  Arg = fun(Id) -> {arg, Ann, Id, type_wildcard(Ann)} end,
+                  {lam, Ann, [Arg(IdL), Arg(IdR)], infix(IdL, Op, IdR)}
+              end,
+    ?RULE(parens(choice(lists:map(fun token/1, BinOps))), OpToLam(_1)).
+
 token(Tag) ->
    ?RULE(tok(Tag),
    case _1 of
@@ -466,6 +537,7 @@ parens(P)   -> between(tok('('), P, tok(')')).
 braces(P)   -> between(tok('{'), P, tok('}')).
 brackets(P) -> between(tok('['), P, tok(']')).
 comma_sep(P) -> sep(P, tok(',')).
+comma_sep1(P) -> sep1(P, tok(',')).

 paren_list(P)   -> parens(comma_sep(P)).
 brace_list(P)   -> braces(comma_sep(P)).
@@ -478,7 +550,11 @@ bracket_list(P) -> brackets(comma_sep(P)).
 -type ann_col()  :: aeso_syntax:ann_col().

 -spec pos_ann(ann_line(), ann_col()) -> ann().
-pos_ann(Line, Col) -> [{file, current_file()}, {line, Line}, {col, Col}].
+pos_ann(Line, Col) ->
+    [ {file, current_file()}
+    , {include_type, current_include_type()}
+    , {line, Line}
+    , {col, Col} ].

 ann_pos(Ann) ->
    {proplists:get_value(file, Ann),
@@ -559,6 +635,8 @@ tuple_e(Ann, Exprs)   -> {tuple, Ann, Exprs}.
 list_comp_e(Ann, Expr, Binds) -> {list_comp, Ann, Expr, Binds}.

 -spec parse_pattern(aeso_syntax:expr()) -> aeso_parse_lib:parser(aeso_syntax:pat()).
+parse_pattern({letpat, Ann, Id, Pat}) ->
+    {letpat, Ann, Id, parse_pattern(Pat)};
 parse_pattern({app, Ann, Con = {'::', _}, Es}) ->
    {app, Ann, Con, lists:map(fun parse_pattern/1, Es)};
 parse_pattern({app, Ann, {'-', _}, [{int, _, N}]}) ->
@@ -618,9 +696,15 @@ expand_includes([{include, Ann, {string, _SAnn, File}} | AST], Included, Acc, Op
            Hashed = hash_include(File, Code),
            case sets:is_element(Hashed, Included) of
                false ->
+                    SrcFile = proplists:get_value(src_file, Opts, no_file),
+                    IncludeType = case proplists:get_value(file, Ann) of
+                                      SrcFile -> direct;
+                                      _       -> indirect
+                                  end,
                    Opts1 = lists:keystore(src_file, 1, Opts, {src_file, File}),
+                    Opts2 = lists:keystore(include_type, 1, Opts1, {include_type, IncludeType}),
                    Included1 = sets:add_element(Hashed, Included),
-                    case parse_and_scan(file(), Code, Opts1) of
+                    case parse_and_scan(file(), Code, Opts2) of
                        {ok, AST1} ->
                            expand_includes(AST1 ++ AST, Included1, Acc, Opts);
                        Err = {error, _} ->
@@ -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));
@@ -206,8 +212,10 @@ name({typed, _, Name, _}) -> name(Name).
 -spec letdecl(string(), aeso_syntax:letbind()) -> doc().
 letdecl(Let, {letval, _, P, E}) ->
    block_expr(0, hsep([text(Let), expr(P), text("=")]), E);
-letdecl(Let, {letfun, _, F, Args, T, E}) ->
-    block_expr(0, hsep([text(Let), typed(beside(name(F), expr({tuple, [], Args})), T), text("=")]), E).
+letdecl(Let, {letfun, _, F, Args, T, [GuardedBody]}) ->
+    beside(hsep([text(Let), typed(beside(name(F), expr({tuple, [], Args})), T)]), guarded_body(GuardedBody, "="));
+letdecl(Let, {letfun, _, F, Args, T, GuardedBodies}) ->
+    block(hsep([text(Let), typed(beside(name(F), expr({tuple, [], Args})), T)]), above(lists:map(fun(GB) -> guarded_body(GB, "=") end, GuardedBodies))).

 -spec args([aeso_syntax:arg()]) -> doc().
 args(Args) ->
@@ -276,7 +284,9 @@ type(T = {id, _, _})   -> name(T);
 type(T = {qid, _, _})  -> name(T);
 type(T = {con, _, _})  -> name(T);
 type(T = {qcon, _, _}) -> name(T);
-type(T = {tvar, _, _}) -> name(T).
+type(T = {tvar, _, _}) -> name(T);
+type({constrained_t, _, Cs, T}) ->
+    beside([name(T), text(" is "), tuple(lists:map(fun expr/1, Cs))]).

 -spec args_type([aeso_syntax:type()]) -> doc().
 args_type(Args) ->
@@ -293,6 +303,8 @@ tuple_type(Factors) ->
      ]).

 -spec expr_p(integer(), aeso_syntax:arg_expr()) -> doc().
+expr_p(P, {letpat, _, Id, Pat}) ->
+    paren(P > 100, follow(hsep(expr(Id), text("=")), expr(Pat)));
 expr_p(P, {named_arg, _, Name, E}) ->
    paren(P > 100, follow(hsep(expr(Name), text("=")), expr(E)));
 expr_p(P, {lam, _, Args, E}) ->
@@ -474,8 +486,18 @@ elim1(Proj={proj, _, _})      -> beside(text("."), elim(Proj));
 elim1(Get={map_get, _, _})    -> elim(Get);
 elim1(Get={map_get, _, _, _}) -> elim(Get).

-alt({'case', _, Pat, Body}) ->
-    block_expr(0, hsep(expr(Pat), text("=>")), Body).
+alt({'case', _, Pat, [GuardedBody]}) ->
+    beside(expr(Pat), guarded_body(GuardedBody, "=>"));
+alt({'case', _, Pat, GuardedBodies}) ->
+    block(expr(Pat), above(lists:map(fun(GB) -> guarded_body(GB, "=>") end, GuardedBodies))).
+
+guarded_body({guarded, _, Guards, Body}, Then) ->
+    block_expr(0, hsep(guards(Guards), text(Then)), Body).
+
+guards([]) ->
+    text("");
+guards(Guards) ->
+    hsep([text(" |"), par(punctuate(text(","), lists:map(fun expr/1, Guards)), 0)]).

 block_expr(_, Header, {block, _, Ss}) ->
    block(Header, statements(Ss));
@@ -44,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", "using", "as", "for", "hiding", "is"
+               ],
    KW = string:join(Keywords, "|"),

    Rules =
@@ -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,13 +35,19 @@
 -type qcon() :: {qcon, ann(), [name()]}.
 -type tvar() :: {tvar, ann(), name()}.

-type decl() :: {contract, ann(), con(), [decl()]}
+-type namespace_alias() :: none | con().
+-type namespace_parts() :: none | {for, [id()]} | {hiding, [id()]}.
+
+-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
              | {type_def, ann(), id(), [tvar()], typedef()}
              | {fun_clauses, ann(), id(), type(), [letfun() | fundecl()]}
              | {block, ann(), [decl()]}
+              | {using, ann(), con(), namespace_alias(), namespace_parts()}
              | fundecl()
              | letfun()
              | letval(). % Only for error msgs
@@ -49,9 +56,12 @@

 -type pragma() :: {compiler, '==' | '<' | '>' | '=<' | '>=', compiler_version()}.

+-type guard() :: expr().
+-type guarded_expr() :: {guarded, ann(), [guard()], expr()}.

 -type letval()  :: {letval, ann(), pat(), expr()}.
-type letfun()  :: {letfun, ann(), id(), [pat()], type(), expr()}.
+-type letfun()  :: {letfun, ann(), id(), [pat()], type(), [guarded_expr(),...]}.
+-type letpat()  :: {letpat, ann(), id(), pat()}.
 -type fundecl() :: {fun_decl, ann(), id(), type()}.

 -type letbind()
@@ -69,11 +79,14 @@

 -type constructor_t() :: {constr_t, ann(), con(), [type()]}.

+-type tvar_constraint() :: {constraint, ann(), tvar(), id()}.
+
 -type type() :: {fun_t, ann(), [named_arg_t()], [type()], type()}
              | {app_t, ann(), type(), [type()]}
              | {tuple_t, ann(), [type()]}
              | {args_t, ann(), [type()]}   %% old tuple syntax, old for error messages
              | {bytes_t, ann(), integer() | any}
+              | {constrained_t, ann(), [tvar_constraint()], type()}
              | id()  | qid()
              | con() | qcon()  %% contracts
              | tvar().
@@ -116,7 +129,8 @@
     | {block, ann(), [stmt()]}
     | {op(), ann()}
     | id() | qid() | con() | qcon()
-     | constant().
+     | constant()
+     | letpat().

 -type record_or_map() :: record | map | record_or_map_error.

@@ -137,7 +151,7 @@
 -type stmt() :: letbind()
              | expr().

-type alt() :: {'case', ann(), pat(), expr()}.
+-type alt() :: {'case', ann(), pat(), [guarded_expr(),...]}.

 -type lvalue() :: nonempty_list(elim()).

@@ -150,6 +164,7 @@
             | {list, ann(), [pat()]}
             | {typed, ann(), pat(), type()}
             | {record, ann(), [field(pat())]}
+             | letpat()
             | constant()
             | con()
             | id().
@@ -48,7 +48,7 @@ fold(Alg = #alg{zero = Zero, plus = Plus, scoped = Scoped}, Fun, K, X) ->
            {type_def, _, I, _, D}        -> Plus(BindType(I), Decl(D));
            {fun_decl, _, _, T}           -> Type(T);
            {letval, _, P, E}             -> Scoped(BindExpr(P), Expr(E));
-            {letfun, _, F, Xs, T, E} -> Sum([BindExpr(F), Type(T), Expr(Xs ++ [E])]);
+            {letfun, _, F, Xs, T, GEs} -> Sum([BindExpr(F), Type(T), Expr(Xs ++ GEs)]);
            {fun_clauses, _, _, T, Cs}    -> Sum([Type(T) | [Decl(C) || C <- Cs]]);
            %% typedef()
            {alias_t, T}    -> Type(T);
@@ -61,6 +61,7 @@ fold(Alg = #alg{zero = Zero, plus = Plus, scoped = Scoped}, Fun, K, X) ->
            {fun_t, _, Named, Args, Ret} -> Type([Named, Args, Ret]);
            {app_t, _, T, Ts}            -> Type([T | Ts]);
            {tuple_t, _, Ts}             -> Type(Ts);
+            {constrained_t, _, _, T}     -> Type(T);
            %% named_arg_t()
            {named_arg_t, _, _, T, E} -> Plus(Type(T), Expr(E));
            %% expr()
@@ -88,13 +89,15 @@ fold(Alg = #alg{zero = Zero, plus = Plus, scoped = Scoped}, Fun, K, X) ->
            {map_get, _, A, B}     -> Expr([A, B]);
            {map_get, _, A, B, C}  -> Expr([A, B, C]);
            {block, _, Ss}         -> Expr(Ss);
+            {letpat, _, X, P}      -> Plus(BindExpr(X), Expr(P));
+            {guarded, _, Gs, E}    -> Expr([E | Gs]);
            %% field()
            {field, _, LV, E}    -> Expr([LV, E]);
            {field, _, LV, _, E} -> Expr([LV, E]);
            %% arg()
            {arg, _, Y, T} -> Plus(BindExpr(Y), Type(T));
            %% alt()
-            {'case', _, P, E} -> Scoped(BindExpr(P), Expr(E));
+            {'case', _, P, GEs} -> Scoped(BindExpr(P), Expr(GEs));
            %% elim()
            {proj, _, _}    -> Zero;
            {map_get, _, E} -> Expr(E);
@@ -0,0 +1,6 @@
+-define(IS_CONTRACT_HEAD(X),
+        (X =:= contract_main orelse
+         X =:= contract_interface orelse
+         X =:= contract_child
+        )
+       ).
@@ -1,75 +1,15 @@
 %%%-------------------------------------------------------------------
 %%% @copyright (C) 2017, Aeternity Anstalt
-%%% @doc Decoding aevm and fate data to AST
-%%%
+%%% @doc Decoding fate data to AST
 %%% @end
 %%%-------------------------------------------------------------------

 -module(aeso_vm_decode).

-export([ from_aevm/3, from_fate/2 ]).
+-export([ from_fate/2 ]).

 -include_lib("aebytecode/include/aeb_fate_data.hrl").

-address_literal(Type, N) -> {Type, [], <<N:256>>}.
-
-spec from_aevm(aeb_aevm_data:type(), aeso_syntax:type(), aeb_aevm_data:data()) -> aeso_syntax:expr().
-from_aevm(word, {id, _, "address"},                     N) -> address_literal(account_pubkey, N);
-from_aevm(word, {app_t, _, {id, _, "oracle"}, _},       N) -> address_literal(oracle_pubkey, N);
-from_aevm(word, {app_t, _, {id, _, "oracle_query"}, _}, N) -> address_literal(oracle_query_id, N);
-from_aevm(word, {con, _, _Name},                        N) -> address_literal(contract_pubkey, N);
-from_aevm(word, {id, _, "int"}, N0) ->
-    <<N:256/signed>> = <<N0:256>>,
-    if N < 0 -> {app, [{format, prefix}], {'-', []}, [{int, [], -N}]};
-       true  -> {int, [], N} end;
-from_aevm(word, {id, _, "bits"}, N0) ->
-    <<N:256/signed>> = <<N0:256>>,
-    make_bits(N);
-from_aevm(word, {id, _, "bool"}, N) -> {bool, [], N /= 0};
-from_aevm(word, {bytes_t, _, Len}, Val) when Len =< 32 ->
-    <<Bytes:Len/unit:8, _/binary>> = <<Val:32/unit:8>>,
-    {bytes, [], <<Bytes:Len/unit:8>>};
-from_aevm({tuple, _}, {bytes_t, _, Len}, Val) ->
-    {bytes, [], binary:part(<< <<W:32/unit:8>> || W <- tuple_to_list(Val) >>, 0, Len)};
-from_aevm(string, {id, _, "string"}, S) -> {string, [], S};
-from_aevm({list, VmType}, {app_t, _, {id, _, "list"}, [Type]}, List) ->
-    {list, [], [from_aevm(VmType, Type, X) || X <- List]};
-from_aevm({variant, [[], [VmType]]}, {app_t, _, {id, _, "option"}, [Type]}, Val) ->
-    case Val of
-        {variant, 0, []}  -> {con, [], "None"};
-        {variant, 1, [X]} -> {app, [], {con, [], "Some"}, [from_aevm(VmType, Type, X)]}
-    end;
-from_aevm({tuple, VmTypes}, {tuple_t, _, Types}, Val)
-        when length(VmTypes) == length(Types),
-             length(VmTypes) == tuple_size(Val) ->
-    {tuple, [], [from_aevm(VmType, Type, X)
-                 || {VmType, Type, X} <- lists:zip3(VmTypes, Types, tuple_to_list(Val))]};
-from_aevm({tuple, VmTypes}, {record_t, Fields}, Val)
-        when length(VmTypes) == length(Fields),
-             length(VmTypes) == tuple_size(Val) ->
-    {record, [], [ {field, [], [{proj, [], FName}], from_aevm(VmType, FType, X)}
-                   || {VmType, {field_t, _, FName, FType}, X} <- lists:zip3(VmTypes, Fields, tuple_to_list(Val)) ]};
-from_aevm({map, VmKeyType, VmValType}, {app_t, _, {id, _, "map"}, [KeyType, ValType]}, Map)
-        when is_map(Map) ->
-    {map, [], [ {from_aevm(VmKeyType, KeyType, Key),
-                 from_aevm(VmValType, ValType, Val)}
-                || {Key, Val} <- maps:to_list(Map) ]};
-from_aevm({variant, VmCons}, {variant_t, Cons}, {variant, Tag, Args})
-        when length(VmCons) == length(Cons),
-             length(VmCons) > Tag ->
-    VmTypes = lists:nth(Tag + 1, VmCons),
-    ConType = lists:nth(Tag + 1, Cons),
-    from_aevm(VmTypes, ConType, Args);
-from_aevm([], {constr_t, _, Con, []}, []) -> Con;
-from_aevm(VmTypes, {constr_t, _, Con, Types}, Args)
-        when length(VmTypes) == length(Types),
-             length(VmTypes) == length(Args) ->
-    {app, [], Con, [ from_aevm(VmType, Type, Arg)
-                     || {VmType, Type, Arg} <- lists:zip3(VmTypes, Types, Args) ]};
-from_aevm(_VmType, _Type, _Data) ->
-    throw(cannot_translate_to_sophia).
-
-
 -spec from_fate(aeso_syntax:type(), aeb_fate_data:fate_type()) -> aeso_syntax:expr().
 from_fate({id, _, "address"}, ?FATE_ADDRESS(Bin)) -> {account_pubkey, [], Bin};
 from_fate({app_t, _, {id, _, "oracle"}, _}, ?FATE_ORACLE(Bin)) -> {oracle_pubkey, [], Bin};
@@ -120,10 +60,105 @@ from_fate({constr_t, _, Con, Types}, Args)
        when length(Types) == length(Args) ->
    {app, [], Con, [ from_fate(Type, Arg)
                     || {Type, Arg} <- lists:zip(Types, Args) ]};
+from_fate({qid, _, QType}, Val) ->
+    from_fate_builtin(QType, Val);
 from_fate(_Type, _Data) ->
    throw(cannot_translate_to_sophia).


+from_fate_builtin(QType, Val) ->
+    Con = fun([Name | _] = Names) when is_list(Name) -> {qcon, [], Names};
+             (Name) -> {con, [], Name} end,
+    App = fun(Name, []) -> Con(Name);
+             (Name, Value) -> {app, [], Con(Name), Value} end,
+    Chk = fun(Type, Value) -> from_fate(Type, Value) end,
+    Int = {id, [], "int"},
+    Str = {id, [], "string"},
+    Adr = {id, [], "address"},
+    Hsh = {bytes_t, [], 32},
+    I32 = {bytes_t, [], 32},
+    I48 = {bytes_t, [], 48},
+    Qid = fun(Name) -> {qid, [], Name} end,
+    Map = fun(KT, VT) -> {app_t, [], {id, [], "map"}, [KT, VT]} end,
+    ChainTxArities = [3, 0, 0, 0, 0, 0, 1, 1, 1, 2, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1, 2, 0],
+
+    case {QType, Val} of
+        {["Chain", "ttl"], {variant, [1, 1], 0, {X}}} -> App("RelativeTTL", [Chk(Int, X)]);
+        {["Chain", "ttl"], {variant, [1, 1], 1, {X}}} -> App("FixedTTL", [Chk(Int, X)]);
+
+        {["AENS", "name"], {variant, [3], 0, {Addr, TTL, Ptrs}}} ->
+            App(["AENS","Name"], [Chk(Adr, Addr), Chk(Qid(["Chain", "ttl"]), TTL),
+                              Chk(Map(Str, Qid(["AENS", "pointee"])), Ptrs)]);
+
+        {["AENS", "pointee"], {variant, [1, 1, 1, 1], 0, {Addr}}} ->
+            App(["AENS","AccountPt"], [Chk(Adr, Addr)]);
+        {["AENS", "pointee"], {variant, [1, 1, 1, 1], 1, {Addr}}} ->
+            App(["AENS","OraclePt"], [Chk(Adr, Addr)]);
+        {["AENS", "pointee"], {variant, [1, 1, 1, 1], 2, {Addr}}} ->
+            App(["AENS","ContractPt"], [Chk(Adr, Addr)]);
+        {["AENS", "pointee"], {variant, [1, 1, 1, 1], 3, {Addr}}} ->
+            App(["AENS","ChannelPt"], [Chk(Adr, Addr)]);
+
+        {["Chain", "ga_meta_tx"], {variant, [2], 0, {Addr, X}}} ->
+            App(["Chain","GAMetaTx"], [Chk(Adr, Addr), Chk(Int, X)]);
+
+        {["Chain", "paying_for_tx"], {variant, [2], 0, {Addr, X}}} ->
+            App(["Chain","PayingForTx"], [Chk(Adr, Addr), Chk(Int, X)]);
+
+        {["Chain", "base_tx"], {variant, ChainTxArities, 0, {Addr, Fee, Payload}}} ->
+            App(["Chain","SpendTx"], [Chk(Adr, Addr), Chk(Int, Fee), Chk(Str, Payload)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 1, {}}} ->
+            App(["Chain","OracleRegisterTx"], []);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 2, {}}} ->
+            App(["Chain","OracleQueryTx"], []);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 3, {}}} ->
+            App(["Chain","OracleResponseTx"], []);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 4, {}}} ->
+            App(["Chain","OracleExtendTx"], []);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 5, {}}} ->
+            App(["Chain","NamePreclaimTx"], []);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 6, {Name}}} ->
+            App(["Chain","NameClaimTx"], [Chk(Str, Name)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 7, {NameHash}}} ->
+            App(["Chain","NameUpdateTx"], [Chk(Hsh, NameHash)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 8, {NameHash}}} ->
+            App(["Chain","NameRevokeTx"], [Chk(Hsh, NameHash)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 9, {NewOwner, NameHash}}} ->
+            App(["Chain","NameTransferTx"], [Chk(Adr, NewOwner), Chk(Hsh, NameHash)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 10, {Addr}}} ->
+            App(["Chain","ChannelCreateTx"], [Chk(Adr, Addr)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 11, {Addr, Amount}}} ->
+            App(["Chain","ChannelDepositTx"], [Chk(Adr, Addr), Chk(Int, Amount)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 12, {Addr, Amount}}} ->
+            App(["Chain","ChannelWithdrawTx"], [Chk(Adr, Addr), Chk(Int, Amount)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 13, {Addr}}} ->
+            App(["Chain","ChannelForceProgressTx"], [Chk(Adr, Addr)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 14, {Addr}}} ->
+            App(["Chain","ChannelCloseMutualTx"], [Chk(Adr, Addr)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 15, {Addr}}} ->
+            App(["Chain","ChannelCloseSoloTx"], [Chk(Adr, Addr)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 16, {Addr}}} ->
+            App(["Chain","ChannelSlashTx"], [Chk(Adr, Addr)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 17, {Addr}}} ->
+            App(["Chain","ChannelSettleTx"], [Chk(Adr, Addr)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 18, {Addr}}} ->
+            App(["Chain","ChannelSnapshotSoloTx"], [Chk(Adr, Addr)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 19, {Amount}}} ->
+            App(["Chain","ContractCreateTx"], [Chk(Int, Amount)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 20, {Addr, Amount}}} ->
+            App(["Chain","ContractCallTx"], [Chk(Adr, Addr), Chk(Int, Amount)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 21, {}}} ->
+            App(["Chain","GAAttachTx"], []);
+
+        {["MCL_BLS12_381", "fp"], X} ->
+            App(["MCL_BLS12_381", "fp"], [Chk(I32, X)]);
+        {["MCL_BLS12_381", "fr"], X} ->
+            App(["MCL_BLS12_381", "fr"], [Chk(I48, X)]);
+
+        _ ->
+            throw(cannot_translate_to_sophia)
+    end.
+
 make_bits(N) ->
    Id = fun(F) -> {qid, [], ["Bits", F]} end,
    if N < 0 -> make_bits(Id("clear"), Id("all"), 0, bnot N);
@@ -0,0 +1,31 @@
+-module(aeso_warnings).
+
+-record(warn, { pos     :: aeso_errors:pos()
+              , message :: iolist()
+              }).
+
+-opaque warning() :: #warn{}.
+
+-export_type([warning/0]).
+
+-export([ new/1
+        , new/2
+        , warn_to_err/2
+        , sort_warnings/1
+        , pp/1
+        ]).
+
+new(Msg) ->
+    new(aeso_errors:pos(0, 0), Msg).
+
+new(Pos, Msg) ->
+    #warn{ pos = Pos, message = Msg }.
+
+warn_to_err(Kind, #warn{ pos = Pos, message = Msg }) ->
+    aeso_errors:new(Kind, Pos, lists:flatten(Msg)).
+
+sort_warnings(Warnings) ->
+    lists:sort(fun(W1, W2) -> W1#warn.pos =< W2#warn.pos end, Warnings).
+
+pp(#warn{ pos = Pos, message = Msg }) ->
+    lists:flatten(io_lib:format("Warning~s:\n~s", [aeso_errors:pp_pos(Pos), Msg])).
@@ -1,6 +1,6 @@
 {application, aesophia,
- [{description, "Contract Language for aeternity"},
-  {vsn, "4.3.0"},
+ [{description, "Compiler for Aeternity Sophia language"},
+  {vsn, "6.1.0"},
  {registered, []},
  {applications,
   [kernel,
@@ -5,7 +5,6 @@

 -define(SANDBOX(Code), sandbox(fun() -> Code end)).
 -define(DUMMY_HASH_WORD, 16#123).
-define(DUMMY_HASH, <<0:30/unit:8, 127, 119>>). %% 16#123
 -define(DUMMY_HASH_LIT, "#0000000000000000000000000000000000000000000000000000000000000123").

 sandbox(Code) ->
@@ -20,12 +19,6 @@ sandbox(Code) ->
        {error, loop}
    end.

-malicious_from_binary_test() ->
-    CircularList = from_words([32, 1, 32]), %% Xs = 1 :: Xs
-    {ok, {error, circular_references}}   = ?SANDBOX(aeb_heap:from_binary({list, word}, CircularList)),
-    {ok, {error, {binary_too_short, _}}} = ?SANDBOX(aeb_heap:from_binary(word, <<1, 2, 3, 4>>)),
-    ok.
-
 from_words(Ws) ->
    << <<(from_word(W))/binary>> || W <- Ws >>.

@@ -37,23 +30,14 @@ from_word(S) when is_list(S) ->
    <<Len:256, Bin/binary>>.

 encode_decode_test() ->
-    encode_decode(word, 42),
-    42 = encode_decode(word, 42),
-    -1 = encode_decode(signed_word, -1),
-    <<"Hello world">> = encode_decode(string, <<"Hello world">>),
-    {} = encode_decode({tuple, []}, {}),
-    {42} = encode_decode({tuple, [word]}, {42}),
-    {42, 0} = encode_decode({tuple, [word, word]}, {42, 0}),
-    [] = encode_decode({list, word}, []),
-    [32] = encode_decode({list, word}, [32]),
-    none = encode_decode({option, word}, none),
-    {some, 1} = encode_decode({option, word}, {some, 1}),
-    string = encode_decode(typerep, string),
-    word = encode_decode(typerep, word),
-    {list, word} = encode_decode(typerep, {list, word}),
-    {tuple, [word]} = encode_decode(typerep, {tuple, [word]}),
-    1 = encode_decode(word, 1),
-    0 = encode_decode(word, 0),
+    Tests =
+        [42, 1, 0 -1, <<"Hello">>,
+         {tuple, {}}, {tuple, {42}}, {tuple, {21, 37}},
+         [], [42], [21, 37],
+         {variant, [0, 1], 0, {}}, {variant, [0, 1], 1, {42}}, {variant, [2], 0, {21, 37}},
+         {typerep, string}, {typerep, integer}, {typerep, {list, integer}}, {typerep, {tuple, [integer]}}
+        ],
+    [?assertEqual(Test, encode_decode(Test)) || Test <- Tests],
    ok.

 encode_decode_sophia_test() ->
@@ -72,55 +56,67 @@ encode_decode_sophia_test() ->
    ok = Check("r", "{x = (\"foo\", 0), y = Red}"),
    ok.

+to_sophia_value_mcl_bls12_381_test() ->
+    Code = "include \"BLS12_381.aes\"\n"
+           "contract C =\n"
+           "  entrypoint test_bls12_381_fp(x : int) = BLS12_381.int_to_fp(x)\n"
+           "  entrypoint test_bls12_381_fr(x : int) = BLS12_381.int_to_fr(x)\n"
+           "  entrypoint test_bls12_381_g1(x : int) = BLS12_381.mk_g1(x, x, x)\n",
+
+    Opts = [{backend, fate}],
+
+    CallValue32 = aeb_fate_encoding:serialize({bytes, <<20:256>>}),
+    CallValue48 = aeb_fate_encoding:serialize({bytes, <<55:384>>}),
+    CallValueTp = aeb_fate_encoding:serialize({tuple, {{bytes, <<15:256>>}, {bytes, <<160:256>>}, {bytes, <<1234:256>>}}}),
+
+    {ok,     _} = aeso_compiler:to_sophia_value(Code, "test_bls12_381_fp", ok, CallValue32, Opts),
+    {error,  _} = aeso_compiler:to_sophia_value(Code, "test_bls12_381_fp", ok, CallValue48, Opts),
+    {ok,     _} = aeso_compiler:to_sophia_value(Code, "test_bls12_381_fr", ok, CallValue48, Opts),
+    {error,  _} = aeso_compiler:to_sophia_value(Code, "test_bls12_381_fr", ok, CallValue32, Opts),
+    {ok,     _} = aeso_compiler:to_sophia_value(Code, "test_bls12_381_g1", ok, CallValueTp, Opts),
+
+    ok.
+
 to_sophia_value_neg_test() ->
    Code = [ "contract Foo =\n"
-             "  entrypoint x(y : int) : string = \"hello\"\n" ],
+             "  entrypoint f(x : int) : string = \"hello\"\n" ],

-    {error, [Err1]} = aeso_compiler:to_sophia_value(Code, "x", ok, encode(12)),
-    ?assertEqual("Data error:\nFailed to decode binary as type string\n", aeso_errors:pp(Err1)),
-    {error, [Err2]} = aeso_compiler:to_sophia_value(Code, "x", ok, encode(12), [{backend, fate}]),
-    ?assertEqual("Data error:\nFailed to decode binary as type string\n", aeso_errors:pp(Err2)),
+    {error, [Err1]} = aeso_compiler:to_sophia_value(Code, "f", ok, encode(12)),
+    ?assertEqual("Data error:\nCannot translate FATE value 12\n  of Sophia type string\n", aeso_errors:pp(Err1)),

-    {error, [Err3]} = aeso_compiler:to_sophia_value(Code, "x", revert, encode(12)),
-    ?assertEqual("Data error:\nCould not interpret the revert message\n", aeso_errors:pp(Err3)),
-    {error, [Err4]} = aeso_compiler:to_sophia_value(Code, "x", revert, encode(12), [{backend, fate}]),
-    ?assertEqual("Data error:\nCould not deserialize the revert message\n", aeso_errors:pp(Err4)),
+    {error, [Err2]} = aeso_compiler:to_sophia_value(Code, "f", revert, encode(12)),
+    ?assertEqual("Data error:\nCould not deserialize the revert message\n", aeso_errors:pp(Err2)),
    ok.

 encode_calldata_neg_test() ->
    Code = [ "contract Foo =\n"
-             "  entrypoint x(y : int) : string = \"hello\"\n" ],
+             "  entrypoint f(x : int) : string = \"hello\"\n" ],

-    ExpErr1 = "Type error at line 5, col 34:\nCannot unify int\n         and bool\n"
-              "when checking the application at line 5, column 34 of\n"
-              "  x : (int) => string\nto arguments\n  true : bool\n",
-    {error, [Err1]} = aeso_compiler:create_calldata(Code, "x", ["true"]),
+    ExpErr1 = "Type error at line 5, col 34:\nCannot unify `int` and `bool`\n"
+              "when checking the application of\n"
+              "  `f : (int) => string`\n"
+              "to arguments\n"
+              "  `true : bool`\n",
+    {error, [Err1]} = aeso_compiler:create_calldata(Code, "f", ["true"]),
    ?assertEqual(ExpErr1, aeso_errors:pp(Err1)),
-    {error, [Err2]} = aeso_compiler:create_calldata(Code, "x", ["true"], [{backend, fate}]),
-    ?assertEqual(ExpErr1, aeso_errors:pp(Err2)),

    ok.

 decode_calldata_neg_test() ->
    Code1 = [ "contract Foo =\n"
-              "  entrypoint x(y : int) : string = \"hello\"\n" ],
+              "  entrypoint f(x : int) : string = \"hello\"\n" ],
    Code2 = [ "contract Foo =\n"
-              "  entrypoint x(y : string) : int = 42\n" ],
+              "  entrypoint f(x : string) : int = 42\n" ],

-    {ok, CallDataAEVM} = aeso_compiler:create_calldata(Code1, "x", ["42"]),
-    {ok, CallDataFATE} = aeso_compiler:create_calldata(Code1, "x", ["42"], [{backend, fate}]),
+    {ok, CallDataFATE} = aeso_compiler:create_calldata(Code1, "f", ["42"]),

-    {error, [Err1]} = aeso_compiler:decode_calldata(Code2, "x", CallDataAEVM),
-    ?assertEqual("Data error:\nFailed to decode calldata as type {tuple,[string]}\n", aeso_errors:pp(Err1)),
-    {error, [Err2]} = aeso_compiler:decode_calldata(Code2, "x", <<1,2,3>>, [{backend, fate}]),
-    ?assertEqual("Data error:\nFailed to decode calldata binary\n", aeso_errors:pp(Err2)),
-    {error, [Err3]} = aeso_compiler:decode_calldata(Code2, "x", CallDataFATE, [{backend, fate}]),
-    ?assertEqual("Data error:\nCannot translate FATE value \"*\"\n  to Sophia type (string)\n", aeso_errors:pp(Err3)),
+    {error, [Err1]} = aeso_compiler:decode_calldata(Code2, "f", <<1,2,3>>),
+    ?assertEqual("Data error:\nFailed to decode calldata binary\n", aeso_errors:pp(Err1)),
+    {error, [Err2]} = aeso_compiler:decode_calldata(Code2, "f", CallDataFATE),
+    ?assertEqual("Data error:\nCannot translate FATE value \"*\"\n  to Sophia type (string)\n", aeso_errors:pp(Err2)),

-    {error, [Err4]} = aeso_compiler:decode_calldata(Code2, "y", CallDataAEVM),
-    ?assertEqual("Data error at line 1, col 1:\nFunction 'y' is missing in contract\n", aeso_errors:pp(Err4)),
-    {error, [Err5]} = aeso_compiler:decode_calldata(Code2, "y", CallDataFATE, [{backend, fate}]),
-    ?assertEqual("Data error at line 1, col 1:\nFunction 'y' is missing in contract\n", aeso_errors:pp(Err5)),
+    {error, [Err3]} = aeso_compiler:decode_calldata(Code2, "x", CallDataFATE),
+    ?assertEqual("Data error at line 1, col 1:\nFunction 'x' is missing in contract\n", aeso_errors:pp(Err3)),
    ok.


@@ -133,8 +129,7 @@ encode_decode_sophia_string(SophiaType, String) ->
           , "  datatype variant = Red | Blue(map(string, int))\n"
           , "  entrypoint foo : arg_type => arg_type\n" ],
    case aeso_compiler:check_call(lists:flatten(Code), "foo", [String], [no_code]) of
-        {ok, _, {[Type], _}, [Arg]} ->
-            io:format("Type ~p~n", [Type]),
+        {ok, _, [Arg]} ->
            Data = encode(Arg),
            case aeso_compiler:to_sophia_value(Code, "foo", ok, Data, [no_code]) of
                {ok, Sophia} ->
@@ -150,30 +145,32 @@ encode_decode_sophia_string(SophiaType, String) ->

 calldata_test() ->
    [42, <<"foobar">>] = encode_decode_calldata("foo", ["int", "string"], ["42", "\"foobar\""]),
-    Map = #{ <<"a">> => 4 },
-    [{variant, 1, [Map]}, {{<<"b">>, 5}, {variant, 0, []}}] =
+    [{variant, [0,1], 1, {#{ <<"a">> := 4 }}}, {tuple, {{tuple, {<<"b">>, 5}}, {variant, [0,1], 0, {}}}}] =
        encode_decode_calldata("foo", ["variant", "r"], ["Blue({[\"a\"] = 4})", "{x = (\"b\", 5), y = Red}"]),
-    [?DUMMY_HASH_WORD, 16#456] = encode_decode_calldata("foo", ["bytes(32)", "address"],
+    [{bytes, <<291:256>>}, {address, <<1110:256>>}] =
+        encode_decode_calldata("foo", ["bytes(32)", "address"],
                               [?DUMMY_HASH_LIT, "ak_1111111111111111111111111111113AFEFpt5"]),
-    [?DUMMY_HASH_WORD, ?DUMMY_HASH_WORD] =
+    [{bytes, <<291:256>>}, {bytes, <<291:256>>}] =
        encode_decode_calldata("foo", ["bytes(32)", "hash"], [?DUMMY_HASH_LIT, ?DUMMY_HASH_LIT]),

-    [119, {0, 0}] = encode_decode_calldata("foo", ["int", "signature"], ["119", [$# | lists:duplicate(128, $0)]]),
+    [119, {bytes, <<0:64/unit:8>>}] = encode_decode_calldata("foo", ["int", "signature"], ["119", [$# | lists:duplicate(128, $0)]]),

-    [16#456] = encode_decode_calldata("foo", ["Remote"], ["ct_1111111111111111111111111111113AFEFpt5"]),
+    [{contract, <<1110:256>>}] = encode_decode_calldata("foo", ["Remote"], ["ct_1111111111111111111111111111113AFEFpt5"]),

    ok.

 calldata_init_test() ->
-    encode_decode_calldata("init", ["int"], ["42"], {tuple, [typerep, word]}),
+    encode_decode_calldata("init", ["int"], ["42"]),

    Code = parameterized_contract("foo", ["int"]),
-    encode_decode_calldata_(Code, "init", [], {tuple, [typerep, {tuple, []}]}).
+    encode_decode_calldata_(Code, "init", []),
+
+    ok.

 calldata_indent_test() ->
    Test = fun(Extra) ->
            Code = parameterized_contract(Extra, "foo", ["int"]),
-            encode_decode_calldata_(Code, "foo", ["42"], word)
+            encode_decode_calldata_(Code, "foo", ["42"])
           end,
    Test("  stateful entrypoint bla() = ()"),
    Test("  type x = int"),
@@ -190,7 +187,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"
@@ -202,9 +199,9 @@ oracle_test() ->
        "contract OracleTest =\n"
        "  entrypoint question(o, q : oracle_query(list(string), option(int))) =\n"
        "    Oracle.get_question(o, q)\n",
-    {ok, _, {[word, word], {list, string}}, [16#123, 16#456]} =
+    ?assertEqual({ok, "question", [{oracle, <<291:256>>}, {oracle_query, <<1110:256>>}]},
                 aeso_compiler:check_call(Contract, "question", ["ok_111111111111111111111111111111ZrdqRz9",
-                                                        "oq_1111111111111111111111111111113AFEFpt5"], [no_code]),
+                                                                 "oq_1111111111111111111111111111113AFEFpt5"], [no_code])),

    ok.

@@ -220,35 +217,26 @@ permissive_literals_fail_test() ->
    ok.

 encode_decode_calldata(FunName, Types, Args) ->
-    encode_decode_calldata(FunName, Types, Args, word).
-
-encode_decode_calldata(FunName, Types, Args, RetType) ->
    Code = parameterized_contract(FunName, Types),
-    encode_decode_calldata_(Code, FunName, Args, RetType).
+    encode_decode_calldata_(Code, FunName, Args).

-encode_decode_calldata_(Code, FunName, Args, RetVMType) ->
+encode_decode_calldata_(Code, FunName, Args) ->
    {ok, Calldata} = aeso_compiler:create_calldata(Code, FunName, Args, []),
-    {ok, _, {ArgTypes, RetType}, _} = aeso_compiler:check_call(Code, FunName, Args, [{backend, aevm}, no_code]),
-    ?assertEqual(RetType, RetVMType),
-    CalldataType = {tuple, [word, {tuple, ArgTypes}]},
-    {ok, {_Hash, ArgTuple}} = aeb_heap:from_binary(CalldataType, Calldata),
+    {ok, _, _} = aeso_compiler:check_call(Code, FunName, Args, [no_code]),
    case FunName of
        "init" ->
-            ok;
+            [];
        _ ->
-            {ok, _ArgTypes, ValueASTs} = aeso_compiler:decode_calldata(Code, FunName, Calldata, []),
-            Values = [ prettypr:format(aeso_pretty:expr(V)) || V <- ValueASTs ],
-            ?assertMatch({X, X}, {Args, Values})
-    end,
-    tuple_to_list(ArgTuple).
+            {ok, FateArgs} = aeb_fate_abi:decode_calldata(FunName, Calldata),
+            FateArgs
+    end.

-encode_decode(T, D) ->
-    ?assertEqual(D, decode(T, encode(D))),
+encode_decode(D) ->
+    ?assertEqual(D, decode(encode(D))),
    D.

 encode(D) ->
-    aeb_heap:to_binary(D).
+    aeb_fate_encoding:serialize(D).

-decode(T,B) ->
-    {ok, D} = aeb_heap:from_binary(T, B),
-    D.
+decode(B) ->
+    aeb_fate_encoding:deserialize(B).
@@ -23,6 +23,7 @@ test_cases(1) ->
 		   #{name => <<"C">>,
 		     type_defs => [],
         payable => true,
+         kind => contract_main,
 		     functions =>
 			 [#{name => <<"a">>,
 			    arguments =>
@@ -31,16 +32,17 @@ test_cases(1) ->
 			    returns => <<"int">>,
 			    stateful => true,
                            payable  => true}]}},
-    DecACI = <<"payable contract C =\n"
-	       "  payable entrypoint a : (int) => int\n">>,
+    DecACI = <<"payable main contract C =\n"
+	       "  payable stateful 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,
+                     kind => contract_main,
                     type_defs =>
                         [#{name => <<"allan">>,
                            typedef => <<"int">>,
@@ -53,12 +55,12 @@ test_cases(2) ->
                            returns => <<"int">>,
                            stateful => false,
                            payable  => false}]}},
-    DecACI = <<"contract C =\n"
+    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"
@@ -71,7 +73,7 @@ test_cases(3) ->
                           #{<<"C.bert">> => [<<"string">>]}}],
                name => <<"a">>,returns => <<"int">>,
                stateful => false, payable  => false}],
-		     name => <<"C">>, payable => false,
+		     name => <<"C">>, payable => false, kind => contract_main,
         event => #{variant => [#{<<"SingleEventDefined">> => []}]},
         state => <<"unit">>,
 		     type_defs =>
@@ -80,7 +82,7 @@ test_cases(3) ->
                    #{variant =>
                          [#{<<"Bin">> => [<<"'a">>]}]},
                vars => [#{name => <<"'a">>}]}]}},
-    DecACI = <<"contract C =\n"
+    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]),
+    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} | 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("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
@@ -19,19 +19,9 @@ calldata_test_() ->
     [ {"Testing " ++ ContractName ++ " contract calling " ++ Fun,
        fun() ->
           ContractString = aeso_test_utils:read_contract(ContractName),
-           AevmExprs =
-              case not lists:member(ContractName, not_yet_compilable(aevm)) of
-                  true -> ast_exprs(ContractString, Fun, Args, [{backend, aevm}]);
-                  false -> undefined
-              end,
-           FateExprs =
-              case not lists:member(ContractName, not_yet_compilable(fate)) of
-                  true -> ast_exprs(ContractString, Fun, Args, [{backend, fate}]);
-                  false -> undefined
-              end,
+           FateExprs = ast_exprs(ContractString, Fun, Args),
           ParsedExprs = parse_args(Fun, Args),
-           [ ?assertEqual(ParsedExprs, AevmExprs) || AevmExprs /= undefined ],
-           [ ?assertEqual(ParsedExprs, FateExprs) || FateExprs /= undefined ],
+           ?assertEqual(ParsedExprs, FateExprs),
           ok
        end} || {ContractName, Fun, Args} <- compilable_contracts()].

@@ -42,25 +32,15 @@ calldata_aci_test_() ->
           {ok, ContractACIBin} = aeso_aci:contract_interface(string, ContractString),
           ContractACI = binary_to_list(ContractACIBin),
           io:format("ACI:\n~s\n", [ContractACIBin]),
-           AevmExprs =
-              case not lists:member(ContractName, not_yet_compilable(aevm)) of
-                  true -> ast_exprs(ContractACI, Fun, Args, [{backend, aevm}]);
-                  false -> undefined
-              end,
-           FateExprs =
-              case not lists:member(ContractName, not_yet_compilable(fate)) of
-                  true -> ast_exprs(ContractACI, Fun, Args, [{backend, fate}]);
-                  false -> undefined
-              end,
+           FateExprs = ast_exprs(ContractACI, Fun, Args),
           ParsedExprs = parse_args(Fun, Args),
-           [ ?assertEqual(ParsedExprs, AevmExprs) || AevmExprs /= undefined ],
-           [ ?assertEqual(ParsedExprs, FateExprs) || FateExprs /= undefined ],
+           ?assertEqual(ParsedExprs, FateExprs),
           ok
        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, _, _, _, _, [{guarded, _, [], {app, _, _, AST}}]}]}] =
+        aeso_parser:string("main contract Temp = function foo() = " ++ Fun ++ "(" ++ string:join(Args, ", ") ++ ")"),
    strip_ann(AST).

 strip_ann(T) when is_tuple(T) ->
@@ -75,6 +55,8 @@ strip_ann1(L) when is_list(L) ->
    lists:map(fun strip_ann/1, L);
 strip_ann1(X) -> X.

+ast_exprs(ContractString, Fun, Args) ->
+    ast_exprs(ContractString, Fun, Args, []).
 ast_exprs(ContractString, Fun, Args, Opts) ->
    {ok, Data} = (catch aeso_compiler:create_calldata(ContractString, Fun, Args, Opts)),
    {ok, _Types, Exprs} = (catch aeso_compiler:decode_calldata(ContractString, Fun, Data, Opts)),
@@ -112,8 +94,28 @@ compilable_contracts() ->
     {"funargs", "traffic_light", ["Green"]},
     {"funargs", "traffic_light", ["Pantone(12)"]},
     {"funargs", "tuples", ["()"]},
-     %% TODO {"funargs", "due", ["FixedTTL(1020)"]},
+     {"funargs", "due", ["FixedTTL(1020)"]},
     {"funargs", "singleton_rec", ["{x = 1000}"]},
+     {"funargs", "aens_name", ["AENS.Name(ak_2dATVcZ9KJU5a8hdsVtTv21pYiGWiPbmVcU1Pz72FFqpk9pSRR, RelativeTTL(100), {[\"pt1\"] = AENS.AccountPt(ak_2dATVcZ9KJU5a8hdsVtTv21pYiGWiPbmVcU1Pz72FFqpk9pSRR)})"]},
+     {"funargs", "aens_pointee", ["AENS.AccountPt(ak_2dATVcZ9KJU5a8hdsVtTv21pYiGWiPbmVcU1Pz72FFqpk9pSRR)"]},
+     {"funargs", "aens_pointee", ["AENS.OraclePt(ak_2dATVcZ9KJU5a8hdsVtTv21pYiGWiPbmVcU1Pz72FFqpk9pSRR)"]},
+     {"funargs", "aens_pointee", ["AENS.ContractPt(ak_2dATVcZ9KJU5a8hdsVtTv21pYiGWiPbmVcU1Pz72FFqpk9pSRR)"]},
+     {"funargs", "aens_pointee", ["AENS.ChannelPt(ak_2dATVcZ9KJU5a8hdsVtTv21pYiGWiPbmVcU1Pz72FFqpk9pSRR)"]},
+     {"funargs", "chain_ga_meta_tx", ["Chain.GAMetaTx(ak_2dATVcZ9KJU5a8hdsVtTv21pYiGWiPbmVcU1Pz72FFqpk9pSRR, 42)"]},
+     {"funargs", "chain_paying_for_tx", ["Chain.PayingForTx(ak_2dATVcZ9KJU5a8hdsVtTv21pYiGWiPbmVcU1Pz72FFqpk9pSRR, 42)"]},
+     {"funargs", "chain_base_tx", ["Chain.SpendTx(ak_2dATVcZ9KJU5a8hdsVtTv21pYiGWiPbmVcU1Pz72FFqpk9pSRR, 42,\"foo\")"]},
+     {"funargs", "chain_base_tx", ["Chain.ContractCreateTx(12234)"]},
+     {"funargs", "chain_base_tx", ["Chain.ContractCallTx(ak_2dATVcZ9KJU5a8hdsVtTv21pYiGWiPbmVcU1Pz72FFqpk9pSRR, 12234)"]},
+     {"funargs", "chain_base_tx", ["Chain.OracleRegisterTx"]},
+     {"funargs", "chain_base_tx", ["Chain.OracleQueryTx"]},
+     {"funargs", "chain_base_tx", ["Chain.OracleResponseTx"]},
+     {"funargs", "chain_base_tx", ["Chain.OracleExtendTx"]},
+     {"funargs", "chain_base_tx", ["Chain.NamePreclaimTx"]},
+     {"funargs", "chain_base_tx", ["Chain.NameClaimTx(\"acoolname.chain\")"]},
+     {"funargs", "chain_base_tx", ["Chain.NameUpdateTx(#ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)"]},
+     {"funargs", "chain_base_tx", ["Chain.NameRevokeTx(#ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)"]},
+     {"funargs", "chain_base_tx", ["Chain.NameTransferTx(ak_2dATVcZ9KJU5a8hdsVtTv21pYiGWiPbmVcU1Pz72FFqpk9pSRR, #ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)"]},
+     {"funargs", "chain_base_tx", ["Chain.GAAttachTx"]},
     {"variant_types", "init", []},
     {"basic_auth", "init", []},
     {"address_literals", "init", []},
@@ -139,8 +141,3 @@ compilable_contracts() ->
     {"stub", "foo", ["-42"]},
     {"payable", "foo", ["42"]}
    ].
-
-not_yet_compilable(fate) ->
-    [];
-not_yet_compilable(aevm) ->
-    ["funargs", "strings"].
@@ -12,12 +12,12 @@ 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)),
+                        [{guarded, _, [], {id, _, "x"}}]}]}], parse_string(Text)),
            ok
       end},
      {"Operator precedence test.",
@@ -1,15 +0,0 @@
-
-## Requires ocaml >= 4.02, < 4.06
-## and reason-3.0.0 (opam install reason).
-
-default : voting_test
-
-%.ml : %.re
-	refmt -p ml $< > $@
-
-
-voting_test : rte.ml voting.ml voting_test.ml
-	ocamlopt -o $@ $^
-
-clean :
-	rm -f *.cmi *.cmx *.ml *.o voting_test
@@ -1,5 +1,5 @@

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

  function __call() = 12
@@ -1,31 +0,0 @@
-// A simple test of the abort built-in function.
-
-contract AbortTest =
-
-  record state = { value : int }
-
-  public function init(v : int) =
-    { value = v }
-
-  // Aborting
-  public function do_abort(v : int, s : string) : unit =
-    put_value(v)
-    revert_abort(s)
-
-  // Accessing the value
-  public function get_value() = state.value
-  public function put_value(v : int) = put(state{value = v})
-  public function get_values() : list(int) = [state.value]
-  public function put_values(v : int) = put(state{value = v})
-
-  // Some basic statistics
-  public function get_stats(acct : address) =
-    ( Contract.balance, Chain.balance(acct) )
-
-  // Abort functions.
-  private function revert_abort(s : string) =
-    abort(s)
-
-  // This is still legal but will be stripped out.
-  // TODO: This function confuses the type inference, so it cannot be present.
-  //private function abort(s : string) = 42
@@ -1,27 +0,0 @@
-contract Interface =
-  function do_abort : (int, string) => unit
-  function get_value : () => int
-  function put_value : (int) => unit
-  function get_values : () => list(int)
-  function put_values : (int) => unit
-
-contract AbortTestInt =
-
-  record state = {r : Interface, value : int}
-
-  public function init(r : Interface, value : int) =
-    {r = r, value = value}
-
-  // Aborting
-  public function do_abort(v : int, s : string) =
-    put_value(v)
-    state.r.do_abort(v + 100, s)
-
-  // Accessing the value
-  public function put_value(v : int) = put(state{value = v})
-  public function get_value() = state.value
-  public function get_values() : list(int) =
-    state.value :: state.r.get_values()
-  public function put_values(v : int) =
-    put_value(v)
-    state.r.put_values(v + 1000)
@@ -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 =
@@ -0,0 +1,5 @@
+contract C =
+  entrypoint f() = 123
+
+contract D =
+  entrypoint f() = 123
@@ -0,0 +1,4 @@
+contract AssignPatternToPattern =
+    entrypoint f() =
+        let x::(t::z = y) = [1, 2, 3]
+        (x + t)::y
@@ -0,0 +1,16 @@
+include "List.aes"
+
+contract AssignPatterns =
+
+  entrypoint test() = foo([1, 0, 2], (2, Some(3)), Some([4, 5]))
+
+  entrypoint foo(xs : list(int), p : int * option(int), some : option(list(int))) =
+    let x::(t = y::_)  = xs
+    let z::_ = t
+
+    let (a, (o = Some(b)))  = p
+
+    let Some((f = g::_)) = some
+    g + List.get(1, f)
+
+    x + y + z + a + b
@@ -1,5 +1,5 @@

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

 contract AddressLiterals =
@@ -1,4 +1,4 @@
-contract Remote =
+contract interface Remote =
  entrypoint id : int => int

 contract ProtectedCall =
@@ -0,0 +1,5 @@
+contract C =
+  record state = { foo : int }
+  entrypoint init(i : int) =
+    state{ foo = i,
+           foo = 42 }
@@ -1,3 +1,3 @@
 function square(x) = x ^ 2
 contract Main =
-  entrypoint main() = square(10)
+  entrypoint main_fun() = square(10)
@@ -1,8 +0,0 @@
-contract ChannelEnv =
-  public function coinbase() : address = Chain.coinbase
-
-  public function timestamp() : int = Chain.timestamp
-
-  public function block_height() : int = Chain.block_height
-
-  public function difficulty() : int = Chain.difficulty
@@ -1,7 +0,0 @@
-contract ChannelOnChainContractNameResolution =
-
-  public function can_resolve(name: string, key: string) : bool =
-    switch(AENS.resolve(name, key) : option(string))
-      None           => false
-      Some(_address) => true
-
@@ -1,51 +0,0 @@
-contract ChannelOnChainContractOracle =
-
-  type query_t  = string
-  type answer_t = string
-  type oracle_id = oracle(query_t, answer_t)
-  type query_id = oracle_query(query_t, answer_t)
-
-  record state = { oracle        : oracle_id,
-                   question      : string,
-                   bets          : map(string, address)
-                   }
-
-
-  public function init(oracle: oracle_id, question: string) : state =
-    { oracle   = oracle,
-      question = question,
-      bets     = {}
-      }
-
-  public stateful function place_bet(answer: string) =
-    switch(Map.lookup(answer, state.bets))
-      None =>
-        put(state{ bets = state.bets{[answer] = Call.caller}})
-        "ok"
-      Some(_value) =>
-        "bet_already_taken"
-
-  public function expiry() =
-    Oracle.expiry(state.oracle)
-
-  public function query_fee() =
-    Oracle.query_fee(state.oracle)
-
-  public function get_question(q: query_id) =
-    Oracle.get_question(state.oracle, q)
-
-  public stateful function resolve(q: query_id) =
-    switch(Oracle.get_answer(state.oracle, q))
-      None         =>
-        "no response"
-      Some(result) =>
-        if(state.question == Oracle.get_question(state.oracle, q))
-            switch(Map.lookup(result, state.bets))
-              None         =>
-                "no winning bet"
-              Some(winner) =>
-                Chain.spend(winner, Contract.balance)
-                "ok"
-        else
-          "different question"
-
@@ -1,9 +0,0 @@
-contract Remote =
-  function get : () => int
-  function can_resolve : (string, string) => bool
-
-contract RemoteCall =
-
-    function remote_resolve(r : Remote, name: string, key: string) : bool =
-        r.can_resolve(name, key)
-
@@ -1,51 +0,0 @@
-
-contract Chess =
-
-  type board = map(int, map(int, string))
-  type state = board
-
-  private function get_row(r, m : board) =
-    Map.lookup_default(r, m, {})
-
-  private function set_piece(r, c, p, m : board) =
-    m { [r] = get_row(r, m) { [c] = p } }
-
-  private function get_piece(r, c, m : board) =
-    Map.lookup(c, get_row(r, m))
-
-  private function from_list(xs, m : board) =
-    switch(xs)
-      []              => m
-      (r, c, p) :: xs => from_list(xs, set_piece(r, c, p, m))
-
-  function init() =
-    from_list([ (2, 1, "white pawn"),   (7, 1, "black pawn")
-              , (2, 2, "white pawn"),   (7, 2, "black pawn")
-              , (2, 3, "white pawn"),   (7, 3, "black pawn")
-              , (2, 4, "white pawn"),   (7, 4, "black pawn")
-              , (2, 5, "white pawn"),   (7, 5, "black pawn")
-              , (2, 6, "white pawn"),   (7, 6, "black pawn")
-              , (2, 7, "white pawn"),   (7, 7, "black pawn")
-              , (2, 8, "white pawn"),   (7, 8, "black pawn")
-              , (1, 1, "white rook"),   (8, 1, "black rook")
-              , (1, 2, "white knight"), (8, 2, "black knight")
-              , (1, 3, "white bishop"), (8, 3, "black bishop")
-              , (1, 4, "white queen"),  (8, 4, "black queen")
-              , (1, 5, "white king"),   (8, 5, "black king")
-              , (1, 6, "white bishop"), (8, 6, "black bishop")
-              , (1, 7, "white knight"), (8, 7, "black knight")
-              , (1, 8, "white rook"),   (8, 8, "black rook")
-              ], {})
-
-  function piece(r, c) = get_piece(r, c, state)
-
-  function move_piece(r, c, r1, c1) =
-    switch(piece(r, c))
-      Some(p) => put(set_piece(r1, c1, p, state))
-
-  function destroy_piece(r, c) =
-    put(state{ [r] = Map.delete(c, get_row(r, state)) })
-
-  function delete_row(r) =
-    put(Map.delete(r, state))
-
@@ -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,4 @@
 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)
@@ -0,0 +1,169 @@
+contract A = entrypoint init() = ()
+
+main contract C =
+    datatype custom_datatype('a) = CD('a)
+
+    record custom_record('a) = { f : 'a }
+
+    // pass
+    function
+        passing_ord : 'a is ord ; ('a, 'a) => bool
+        passing_ord(x, y) = x >= y
+
+    // pass
+    function
+        passing_eq : 'a is eq ; ('a, 'a) => bool
+        passing_eq(x, y) = x == y
+
+    // fail because eq is not specified for 'a
+    function
+        fail_no_eq : ('a, 'a) => bool
+        fail_no_eq(x, y) = x == y
+
+    // fail because 'b is not used
+    function
+        fail_unused_tvar : 'a is eq, 'b is eq ; ('a, 'a) => bool
+        fail_unused_tvar(x, y) = x == y
+
+    function
+        fail_unknown_constraint : 'a is foo ; ('a) => 'a
+        fail_unknown_constraint(x) = x
+
+    // Ord types
+
+    function bool_ord(x : bool, y : bool) = x >= y  // pass
+    function bool_eq (x : bool, y : bool) = x == y  // pass
+
+    function int_ord(x : int, y : int) = x >= y  // pass
+    function int_eq (x : int, y : int) = x == y  // pass
+
+    function char_ord(x : char, y : char) = x >= y  // pass
+    function char_eq (x : char, y : char) = x == y  // pass
+
+    function bits_ord(x : bits, y : bits) = x >= y  // pass
+    function bits_eq (x : bits, y : bits) = x == y  // pass
+
+    function bytes_ord(x : bytes(16), y : bytes(16)) = x >= y  // pass
+    function bytes_eq (x : bytes(16), y : bytes(16)) = x == y  // pass
+
+    function string_ord(x : string, y : string) = x >= y  // pass
+    function string_eq (x : string, y : string) = x == y  // pass
+
+    function hash_ord(x : hash, y : hash) = x >= y  // pass
+    function hash_eq (x : hash, y : hash) = x == y  // pass
+
+    function signature_ord(x : signature, y : signature) = x >= y  // pass
+    function signature_eq (x : signature, y : signature) = x == y  // pass
+
+    function address_ord(x : address, y : address) = x >= y  // pass
+    function address_eq (x : address, y : address) = x == y  // pass
+
+    // Eq types
+
+    function event_ord(x : Chain.ttl, y : Chain.ttl) = x >= y  // fail
+    function event_eq (x : Chain.ttl, y : Chain.ttl) = x == y  // pass
+
+    function contract_ord(x : A, y : A) = x >= y  // fail
+    function contract_eq (x : A, y : A) = x == y  // pass
+
+    // Noncomparable types
+
+    type lam = (int, char) => bool
+
+    function lambda_ord(x : lam, y : lam) = x >= y  // fail
+    function lambda_eq (x : lam, y : lam) = x == y  // fail
+
+    // Ord composite types of ord
+
+    function list_of_ord_ord(x : list(int), y : list(int)) = x >= y  // pass
+    function list_of_ord_eq (x : list(int), y : list(int)) = x == y  // pass
+
+    function option_of_ord_ord(x : option(int), y : option(int)) = x >= y  // pass
+    function option_of_ord_eq (x : option(int), y : option(int)) = x == y  // pass
+
+    function tuple_of_ord_ord(x : (int * bool), y : (int * bool)) = x >= y  // pass
+    function tuple_of_ord_eq (x : (int * bool), y : (int * bool)) = x == y  // pass
+
+    // Ord composite types of eq
+
+    function list_of_eq_ord(x : list(A), y : list(A)) = x >= y  // fail
+    function list_of_eq_eq (x : list(A), y : list(A)) = x == y  // pass
+
+    function option_of_eq_ord(x : option(A), y : option(A)) = x >= y  // fail
+    function option_of_eq_eq (x : option(A), y : option(A)) = x == y  // pass
+
+    function tuple_of_eq_ord(x : (A * int), y : (A * int)) = x >= y  // fail
+    function tuple_of_eq_eq (x : (A * int), y : (A * int)) = x == y  // pass
+
+    // Ord composite types of nomcomparable
+
+    function list_of_noncomp_ord(x : list(lam), y : list(lam)) = x >= y  // fail
+    function list_of_noncomp_eq (x : list(lam), y : list(lam)) = x == y  // fail
+
+    function option_of_noncomp_ord(x : option(lam), y : option(lam)) = x >= y  // fail
+    function option_of_noncomp_eq (x : option(lam), y : option(lam)) = x == y  // fail
+
+    function tuple_of_noncomp_ord(x : (lam * int), y : (lam * int)) = x >= y  // fail
+    function tuple_of_noncomp_eq (x : (lam * int), y : (lam * int)) = x == y  // fail
+
+    // Eq composite types of ord
+
+    function map_of_ord_ord(x : map(int, int), y : map(int, int)) = x >= y  // fail
+    function map_of_ord_eq (x : map(int, int), y : map(int, int)) = x == y  // pass
+
+    function oracle_of_ord_ord(x : oracle(int, int), y : oracle(int, int)) = x >= y  // fail
+    function oracle_of_ord_eq (x : oracle(int, int), y : oracle(int, int)) = x == y  // pass
+
+    function oracle_query_of_ord_ord(x : oracle_query(int, int), y : oracle_query(int, int)) = x >= y  // fail
+    function oracle_query_of_ord_eq (x : oracle_query(int, int), y : oracle_query(int, int)) = x == y  // pass
+
+    function datatype_of_ord_ord(x : custom_datatype(int), y : custom_datatype(int)) = x >= y  // fail
+    function datatype_of_ord_eq (x : custom_datatype(int), y : custom_datatype(int)) = x == y  // pass
+
+    function record_of_ord_ord(x : custom_record(int), y : custom_record(int)) = x >= y  // fail
+    function record_of_ord_eq (x : custom_record(int), y : custom_record(int)) = x == y  // pass
+
+    // Eq composite types of eq
+
+    function map_of_eq_ord(x : map(A, A), y : map(A, A)) = x >= y  // fail
+    function map_of_eq_eq (x : map(A, A), y : map(A, A)) = x == y  // pass
+
+    function oracle_of_eq_ord(x : oracle(A, A), y : oracle(A, A)) = x >= y  // fail
+    function oracle_of_eq_eq (x : oracle(A, A), y : oracle(A, A)) = x == y  // pass
+
+    function oracle_query_of_eq_ord(x : oracle_query(A, A), y : oracle_query(A, A)) = x >= y  // fail
+    function oracle_query_of_eq_eq (x : oracle_query(A, A), y : oracle_query(A, A)) = x == y  // pass
+
+    function datatype_of_eq_ord(x : custom_datatype(A), y : custom_datatype(A)) = x >= y  // fail
+    function datatype_of_eq_eq (x : custom_datatype(A), y : custom_datatype(A)) = x == y  // pass
+
+    function record_of_eq_ord(x : custom_record(A), y : custom_record(A)) = x >= y  // fail
+    function record_of_eq_eq (x : custom_record(A), y : custom_record(A)) = x == y  // pass
+
+    // Eq composite types of nomcomparable
+
+    function map_of_noncomp_ord(x : map(lam, lam), y : map(lam, lam)) = x >= y  // fail
+    function map_of_noncomp_eq (x : map(lam, lam), y : map(lam, lam)) = x == y  // fail
+
+    function oracle_of_noncomp_ord(x : oracle(lam, lam), y : oracle(lam, lam)) = x >= y  // fail
+    function oracle_of_noncomp_eq (x : oracle(lam, lam), y : oracle(lam, lam)) = x == y  // fail
+
+    function oracle_query_of_noncomp_ord(x : oracle_query(lam, lam), y : oracle_query(lam, lam)) = x >= y  // fail
+    function oracle_query_of_noncomp_eq (x : oracle_query(lam, lam), y : oracle_query(lam, lam)) = x == y  // fail
+
+    function datatype_of_noncomp_ord(x : custom_datatype(lam), y : custom_datatype(lam)) = x >= y  // fail
+    function datatype_of_noncomp_eq (x : custom_datatype(lam), y : custom_datatype(lam)) = x == y  // pass
+
+    function record_of_nomcomp_ord(x : custom_record(lam), y : custom_record(lam)) = x >= y  // fail
+    function record_of_nomcomp_eq (x : custom_record(lam), y : custom_record(lam)) = x == y  // pass
+
+    entrypoint init() =
+        let passing_ord_ord     = passing_ord([1], [2])              // pass
+        let passing_ord_eq      = passing_ord({[1] = 2}, {[2] = 3})  // fail
+        let passing_ord_noncomp = passing_ord((x) => x, (x) => x)    // fail
+
+        let passing_eq_ord     = passing_eq([1], [2])              // pass
+        let passing_eq_eq      = passing_eq({[1] = 2}, {[2] = 3})  // pass
+        let passing_eq_noncomp = passing_eq((x) => x, (x) => x)    // fail
+
+        ()
@@ -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 =
@@ -1,20 +0,0 @@
-
-contract OtherContract =
-
-  function multiply : (int, int) => int
-
-contract ThisContract =
-
-  record state = { server : OtherContract, n : int }
-
-  function init(server : OtherContract) =
-    { server = server, n = 2 }
-
-  function square() =
-    put(state{ n @ n = state.server.multiply(value = 100, n, n) })
-
-  function get_n() = state.n
-
-  function tip_server() =
-    Chain.spend(state.server.address, Call.value)
-
@@ -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)
@@ -0,0 +1,3 @@
+contract C =
+    record r = {}
+    entrypoint init() = ()
@@ -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,87 +0,0 @@
-contract ERC20Token =
-  record state = {
-    totalSupply : int,
-    decimals : int,
-    name : string,
-    symbol : string,
-    balances : map(address, int),
-    allowed : map(address, map(address,int)),
-    // Logs, remove when native Events are there
-    transfer_log : list((address,address,int)),
-    approval_log : list((address,address,int))}
-
-  // init(100000000, 10, "Token Name", "TKN")
-  public stateful function init(_totalSupply : int, _decimals : int, _name : string, _symbol : string ) = {
-    totalSupply = _totalSupply,
-    decimals = _decimals,
-    name = _name,
-    symbol = _symbol,
-    balances = {[Call.caller] = _totalSupply }, // creator gets all Tokens
-    allowed = {},
-    // Logs, remove when native Events are there
-    transfer_log = [],
-    approval_log = []}
-
-  public stateful function totalSupply() : int = state.totalSupply
-  public stateful function decimals() : int = state.decimals
-  public stateful function name() : string = state.name
-  public stateful function symbol() : string = state.symbol
-
-  public stateful function balanceOf(tokenOwner : address ) : int =
-    Map.lookup_default(tokenOwner, state.balances, 0)
-
-  public stateful function transfer(to : address, tokens : int) =
-    put( state{balances[Call.caller] = sub(state.balances[Call.caller], tokens) })
-    put( state{balances[to] = add(Map.lookup_default(to, state.balances, 0), tokens) })
-    transferEvent(Call.caller, to, tokens)
-    true
-
-  public stateful function approve(spender : address, tokens : int) =
-    // allowed[Call.caller] field must have a value!
-    ensure_allowed(Call.caller)
-    put( state{allowed[Call.caller][spender] = tokens} )
-    approvalEvent(Call.caller, spender, tokens)
-    true
-
-  public stateful function transferFrom(from : address, to : address, tokens : int) =
-    put( state{ balances[from] = sub(state.balances[from], tokens) })
-    put( state{ allowed[from][Call.caller] = sub(state.allowed[from][Call.caller], tokens) })
-    put( state{ balances[to] = add(balanceOf(to), tokens) })
-    transferEvent(from, to, tokens)
-    true
-
-  public function allowance(_owner : address, _spender : address) : int =
-    state.allowed[_owner][_spender]
-
-  public stateful function getTransferLog() : list((address,address,int)) =
-    state.transfer_log
-  public stateful function getApprovalLog() : list((address,address,int)) =
-    state.approval_log
-
-  //
-  // Private Functions
-  //
-
-  private function ensure_allowed(key : address) =
-    switch(Map.lookup(key, state.allowed))
-      None => put(state{allowed[key] = {}})
-      Some(_) => ()
-
-  private function transferEvent(from : address, to : address, tokens : int) =
-    let e = (from, to, tokens)
-    put( state{transfer_log = e :: state.transfer_log })
-    e
-
-  private function approvalEvent(from : address, to : address, tokens : int) =
-    let e = (from, to, tokens)
-    put( state{approval_log = e :: state.approval_log })
-    e
-
-  private function sub(_a : int, _b : int) : int =
-    require(_b =< _a, "Error")
-    _a - _b
-
-  private function add(_a : int, _b : int) : int =
-    let c : int = _a + _b
-    require(c >= _a, "Error")
-    c
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Gaith Hallak	21cc6f2b3e	Add constrained_t to fold	2022-06-20 10:28:17 +04:00
Gaith Hallak	e8da0a7cfe	Update docs/sophia_features.md Co-authored-by: Radosław Rowicki <35342116+radrow@users.noreply.github.com>	2022-06-19 21:44:47 +04:00
Gaith Hallak	4562a7166c	Fix the tests after changing address to ord	2022-06-19 21:07:41 +04:00
Gaith Hallak	fc2875965e	Make address comparable by inequality	2022-06-19 20:54:58 +04:00
Gaith Hallak	9d296f04cb	Formatting fix	2022-06-19 19:19:15 +04:00
Gaith Hallak	ea98fc97bb	Add an example of address type to the docs	2022-06-19 19:18:10 +04:00
Gaith Hallak	46ac9bfa82	Update the docs	2022-06-14 22:19:35 +04:00
Gaith Hallak	75f2711148	Update CHANGELOG	2022-06-14 19:04:20 +04:00
Gaith Hallak	8e6c6d81ad	Add char type to the docs	2022-06-14 18:29:27 +04:00
Gaith Hallak	2d17ce3ee2	Add test for unknown tvar constraints	2022-06-14 18:29:27 +04:00
Gaith Hallak	fc08fe09a5	Add tests for calling constrained functions	2022-06-14 18:29:27 +04:00
Gaith Hallak	6c17e57a7c	Fix dialyzer warnings	2022-06-14 18:29:27 +04:00
Gaith Hallak	69713036d0	Add constraints to typechecker, fix old tests, add new ones	2022-06-14 18:29:26 +04:00
Gaith Hallak	f56eeb0b2b	Use id() for constraints instead of keywords	2022-06-14 18:26:22 +04:00
Gaith Hallak	3f177d363f	Add constraints to the syntax and parser	2022-06-14 18:25:21 +04:00
Gaith Hallak	b599d581ee	Fix warnings reporting and stdlib warnings (#367 ) * Fix stdlib warnings * Mark unused includes when used from non-included files * Do not mark indirectly included files as unused * Show unused include warning only for files that are never used * Remove unused include from Option.aes * Consider functions passed as args as used * Return warnings as a sorted list * Fix failing tests * Fix dialyzer warning * Fix warning in Func.aes	2022-06-14 12:22:32 +04:00
Gaith Hallak	b3767071a8	Allow binary operators to be used as lambdas (#385 ) * Add operator lambdas * Do not register anonymous functions as called functions * Add tests * Update CHANGELOG * Update the docs * Do not allow (..) to be used as a lambda * Rename the function sum to any	2022-06-03 13:12:23 +04:00
Gaith Hallak	b0e6418161	Ban empty record definitions (#384 ) * Ban empty record declarations * Use definition instead of declaration * Fix the failing test	2022-05-25 17:59:46 +04:00
Gaith Hallak	a894876f56	Show the file name in the location if the file is included (#383 )	2022-05-10 18:27:06 +04:00
Radosław Rowicki	0af45dfd19	Deprecate AEVM (#375 ) * Deprecate AEVM * Fix test, changelog * Restore old rebar * rebar lock fix * undo export Co-authored-by: Gaith Hallak <gaithhallak@gmail.com> * undo export Co-authored-by: Gaith Hallak <gaithhallak@gmail.com> * Solve GH suggestions * Fix the docs * update docs * Remove unused tests * undo weird change Co-authored-by: Gaith Hallak <gaithhallak@gmail.com>	2022-05-10 15:33:59 +02:00
Gaith Hallak	c5bfcd3bdc	Add MCL_BLS12_381 types to from_fate_builtin (#382 ) * Add MCL_BLS12_381 types to from_fate_builtin * Add tests for mcl_bls12_381 types to sophia value	2022-05-05 13:19:43 +04:00
Dincho Todorov	85879f5380	Fix BLS12_381.fp and BLS12_381.fr size in the docs (#377 )	2022-04-27 17:10:56 +03:00
Dincho Todorov	8897cc6cbd	Fix bls12_381 anchor in the stdlib docs (#376 )	2022-04-26 20:10:11 +03:00
Marco Walz	0ec7fdc6ac	Merge pull request #368 from aeternity/docs/improve-stdlib-structure docs: order namespaces alphabetically and place Set in includables	2022-04-12 12:49:40 +02:00
Gaith Hallak	74aff5401b	Introduce pipe operator \|> (#371 ) * Add pipe operator * Add tests * Update docs and CHANGELOG	2022-04-12 12:40:32 +03:00
Marco Walz	cfcf0a8a81	Merge pull request #372 from aeternity/pygments-version chore(deps): bump pygments version	2022-03-28 12:09:20 +02:00
marc0olo	ca31db7cad	chore(deps): bump mkdocs version from 1.2.3 to 1.2.4	2022-03-28 10:43:37 +02:00
marc0olo	196460a607	chore(deps): bump pygments version	2022-03-22 13:19:11 +01:00
marc0olo	bf04362f9a	docs: order namespaces alphabetically and place Set in includables	2022-02-04 12:41:08 +01:00
Hans Svensson	d4ea7d5d3b	Clarify signature format for ecverify/ecrecover (#365 )	2022-01-11 14:02:40 +01:00
Hans Svensson	c1c3c29393	Add oneline error pretty-printing (#364 )	2022-01-11 14:02:05 +01:00
Gaith Hallak	b474bb22cd	Implement caching for compiled child contracts (#363 )	2022-01-11 16:50:59 +04:00
Hans Svensson	c04f66a00a	Merge pull request #362 from aeternity/ghallak/354 Simplify error messages reported by the compiler	2022-01-11 11:48:11 +04:00
Gaith Hallak	37d86ad45b	Simplify error messages reported by the compiler Add raw error message for 2 errors The errors: `unnamed_map_update_with_default` and `unbound_variable`. Revert "Add raw error message for 2 errors" This reverts commit `0db6d16140`. Remove trailing new lines and at POS from error messages Convert multiple line error messages into single line error messages Remove at POS from pp_why_record context Change error message with new line before code Fix tests for changed error messages Fix the rest of the error messages Add new line after error message Remove new line from the end of data error messages	2022-01-11 11:48:08 +04:00
Gaith Hallak	60f3a484e6	Solve constraints together and in the order they are added (#360 ) * Solve named argument constraints when record type dereferencing fails * Revert "Solve named argument constraints when record type dereferencing fails" This reverts commit ca38a171a9eefdddbc3f6a41f8a268c42662cd7a. * Solve constraints together and in order * Fix dialyzer warnings * Add comment on solve_known_record_types * Remove unused function	2021-12-16 13:54:06 +02:00
Hans Svensson	40c78c1707	Merge pull request #361 from aeternity/clarify_protected_calls Clarify documentation on protected calls	2021-12-10 14:52:11 +01:00
Hans Svensson	cf08aeee04	Clarify documentation on protected calls	2021-12-10 14:46:44 +01:00
Marco Walz	a04dd6c86d	Merge pull request #359 from marc0olo/feature/syntax-highlighting feat: activate Sophia syntax highlighting by using specific pygments …	2021-12-03 17:26:14 +01:00
marc0olo	f488b35f2e	chore: make sure python libs are updated on install	2021-12-01 10:06:07 +01:00
marc0olo	cc1de9baba	feat: activate Sophia syntax highlighting by using specific pygments version	2021-12-01 08:37:49 +01:00
Gaith Hallak	fe5f5545d3	Add compiler warnings (#346 ) * Add compiler warnings Add include_type annotation to position Add warning for unused includes Add warning for unused stateful annotation Add warning for unused functions Add warning for shadowed variables Add division by zero warning Add warning for negative spends Add warning for unused variables Add warning for unused parameters Change the ets table type to set for unused vars Add warning for unused type defs Move unused variables warning to the top level Temporarily disable unused functions warnings Add all kinds of warnings to a single ets table Enable warnings separately through options Use when_option instead of enabled_warnings Turn warnings into type errors with warn_error option Enable warning package warn_all Re-enable unused functions warnings Report warnings as type errors in a separate function Make unused_function a recognized warning Report warnings as a result of compilation Fix tests and error for unknown warnings options Fix dialyzer warnings Do not show warning for variables called "_" Move warnings handling into a separate module Do not show warning for unused public functions in namespaces Add src file name to unused include warning Mark public functions in namespaces as used Add tests for added warnings Add warning for unused return value Add test for turning warnings into type errors * Update CHANGELOG	2021-11-24 11:46:21 +02:00
Dincho Todorov	98a4049f03	Use OTP 21 for builds (#332 )	2021-11-11 23:08:31 +02:00
seanhinde	3dce0e627b	Merge pull request #353 from aeternity/otp-24-deps Update aebytecode dep for otp-24	2021-11-11 10:51:40 +01:00
Sean Hinde	6b46fc268b	Use older rebar3 for upgrade	2021-11-10 14:32:29 +01:00
Sean Hinde	30bedad164	Use older rebar3 for upgrade	2021-11-10 14:25:33 +01:00
Sean Hinde	4d6938c741	Update aebytecode dep for otp-24	2021-11-10 14:21:23 +01:00
Hans Svensson	10fc88a21d	Merge pull request #349 from aeternity/fix_oracle_expiry_doc Fix docs Oracle.expire -> Oracle.expiry	2021-10-21 14:16:32 +02:00
Hans Svensson	3218a2c172	Fix docs Oracle.expire -> Oracle.expiry	2021-10-21 14:08:03 +02:00
Gaith Hallak	5ad5270e38	Bump version to 6.1.0 and fix CHANGELOG (#348 )	2021-10-20 12:42:48 +03:00
Gaith Hallak	a982f25262	Pattern guards for functions and switch statements (#339 ) * Add case guards to parser * Add pattern guards to infer types and fcode generation * Add functions guards * Add test for patterns guards * Update docs * Update CHANGELOG.md * Remove stateful context from Env for guards * Elaborate on guards * Add failing test for stateful pattern guards * Implement multiple guards * Fix tests * Disable aevm related tests * Split the sentence before if and otherwise * Fix type in docs * Implement multiple exprs in the same guard * Fix pretty printing * Change tests to include multiple guards * Add test for non-boolean guards * Desugar clauses with guards * Fix incomplete patterns bug * Fix docs * Compile to icode when no guards are used * Revert "Disable aevm related tests" This reverts commit e828099bd97dffe11438f2e48f3a92ce3641e85b.	2021-10-20 11:04:00 +03:00
Hans Svensson	20cab3ae57	Merge pull request #347 from marc0olo/chore/update-mkdocs-version chore: mkdocs v1.2.3	2021-10-18 10:33:10 +02:00
marc0olo	1ffb20178c	chore: mkdocs v1.2.3	2021-10-15 12:03:46 +02:00
Hans Svensson	6d79d2d558	GH344 - Add builtin types in decoder (#345 ) * Only use basic types in type_env * Add builtin types to the calldata/result decoder for FATE	2021-09-30 19:11:00 +02:00
Hans Svensson	24c579a5d3	Merge pull request #342 from aeternity/fix_aci_rendering Don't forget stateful when rendering the ACI	2021-09-24 14:21:42 +02:00
Hans Svensson	1be24c94c5	Don't forget stateful when rendering the ACI	2021-09-20 14:50:16 +02:00
Hans Svensson	ebb1f9ecf9	Merge pull request #340 from aeternity/add_bitwise_stdlib Add Bitwise.aes to stdlib	2021-09-16 10:49:00 +02:00
Hans Svensson	9cb3158dfd	Fix documentation and comments	2021-09-12 16:24:08 +02:00
Hans Svensson	becafe4001	Add Bitwise.aes to stdlib	2021-09-12 14:57:45 +02:00
Gaith Hallak	e8a171dc45	Allow assigning patterns to variables (#336 ) * Change syntax tree and parser * Add assign pattern to type inference * Use check_expr instead of hard-coded type * Add fcode generation for assign pattern * Implement rename_spat for assign pattern * Add tests * Update CHANGELOG.md * Update docs and changelog * Add letpat to aeso_syntax_utils:fold * Use Plus instead of Scoped	2021-09-11 16:18:30 +02:00
Gaith Hallak	a7b7aafced	Implement loading namespaces with the `using` keyword (#338 ) * Add using namespace as to scanner and parser * Change the alias from id() to con() * Add using namespace to AST type inference * Allow using namespace to appear in the top level * Allow using namespace to appear inside functions * Add a compiler test for using namespace * Handle name collisions * Implement mk_error for ambiguous_name * Add failing test for ambiguous names * Limit the scope of the used namespaces * Add test for wrong scope of using namespace * Use a single using declaration * Split long line * Forbid using undefined namespaces * Add a test for using undefined namespaces * Change the type of used_namespaces * Add using namespace parts to scanner and parser * Add using namespace parts to ast type inference * Add tests for using namespace parts * Update CHANGELOG.md * Code cleaning * Update the docs * Update the docs about the same alias for multiple namespaces	2021-09-07 17:45:28 +03:00
Marco Walz	262452fb70	Feature/mkdocs with versioning (#333 ) * docs: restructuring & introduction of mkdocs with versioning provided by mike * docs: ad repositories section to sophia examples * docs: refactoring and consistent naming of æternity * docs: hint for new file destination * docs: revert capital letter * docs: accept proposed changes * docs: fix anchors in stdlib	2021-08-27 17:46:18 +03:00
Gaith Hallak	3029bf31cb	Implement `Set` stdlib (#335 ) * Implement Set stdlib * Rename an argument of the function Set.fold * Add docs for Set stdlib * Correct the usage of articles in the docs * Fix bug * Fix the link to Set stdlib section Co-authored-by: Radosław Rowicki <35342116+radrow@users.noreply.github.com>	2021-08-07 10:08:45 +02:00
Radosław Rowicki	4896ad3b36	Add Option.force_msg (#328 ) * Add Option.force_msg * CHANGELOG update	2021-08-03 11:39:53 +02:00
Hans Svensson	b20b9c5df5	Merge pull request #329 from callbay/fix_var_in_example Fix var in example	2021-07-26 12:04:55 +02:00
Frank Feng	d793660545	Fix var in example	2021-07-24 16:46:13 +08: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
radrow	1a14602f36	Upgrade sorting function	2021-02-09 14:18:42 +01:00
Hans Svensson	e2ef95d6fd	Merge pull request #293 from aeternity/GH-292-desugar_error Properly handle type errors during desugar	2021-02-05 11:14:47 +01:00
Hans Svensson	22aaeceba8	Properly handle type errors during desugar	2021-01-25 21:28:10 +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	f1d95484a5	Merge pull request #288 from aeternity/expose-interface-fix-lima Fix interface exposure (lima)	2020-10-21 14:01:21 +02: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	7e65f26211	Fix interface exposure	2020-10-21 12:42:42 +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