Merge pull request #130 from aeternity/PT-168026424-prepare_sophia_4_0_RC1

Preparing 4.0.0-rc1

.gitignore

@@ -1,5 +1,5 @@
 .rebar3
-_*
+_[^_]*
 .eunit
 *.o
 *.beam
@@ -19,3 +19,5 @@ rebar3.crashdump
 *.erl~
 *.aes~
 aesophia
+.qcci
+current_counterexample.eqc

CHANGELOG.md

@@ -9,6 +9,85 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Changed
 ### Removed
 
+## [4.0.0-rc1] - 2019-08-22
+### Added
+- FATE backend - the compiler is able to produce VM code for both `AEVM` and `FATE`. Many
+  of the APIs now take `{backend, aevm | fate}` to decide wich backend to produce artifacts
+  for.
+- New builtin functions `Crypto.ecrecover_secp256k1: (hash, bytes(65)) => option(bytes(20))`
+  and `Crypto.ecverify_secp256k1 : (hash, bytes(20), bytes(65)) => bool` for recovering
+  and verifying an Ethereum address for a message hash and a signature.
+- Sophia supports list comprehensions known from languages like Python, Haskell or Erlang.
+  Example syntax:
+```
+[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]
+```
+- A new contract, and endpoint, modifier `payable` is introduced. Contracts, and enpoints,
+  that shall be able to receive funds should be marked as payable. `Address.is_payable(a)`
+  can be used to check if an (contract) address is payable or not.
+### Changed
+- New syntax for tuple types. Now 0-tuple type is encoded as `unit` instead of `()` and
+  regular tuples are encoded by interspersing inner types with `*`, for instance `int * string`.
+  Parens are not necessary. Note it only affects the types, values remain as their were before,
+  so `(1, "a") : int * string`
+- The `AENS.transfer` and `AENS.revoke` functions have been updated to take a name `string`
+  instead of a name `hash`.
+- Fixed a bug where the `AEVM` backend complained about a missing `init` function when
+  trying to generate calldata from an ACI-generated interface.
+- Compiler now returns the ABI-version in the compiler result map.
+- Renamed `Crypto.ecverify` and `Crypto.ecverify_secp256k1` into `Crypto.verify_sig` and
+  `Crypto.verify_sig_secp256k1` respectively.
+### Removed
+
+## [3.2.0] - 2019-06-28
+### Added
+- New builtin function `require : (bool, string) => ()`. Defined as
+    ```
+    function require(b, err) = if(!b) abort(err)
+    ```
+- New builtin functions
+    ```
+    Bytes.to_str : bytes(_) => string
+    Bytes.to_int : bytes(_) => int
+    ```
+  for converting a byte array to a hex string and interpreting it as a
+  big-endian encoded integer respectively.
+### Changed
+- Public contract functions must now be declared as *entrypoints*:
+  ```
+  contract Example =
+    // Exported
+    entrypoint exported_fun(x) = local_fun(x)
+    // Not exported
+    function local_fun(x) = x
+  ```
+  Functions in namespaces still use `function` (and `private function` for
+  private functions).
+- The return type of `Chain.block_hash(height)` has changed, it used to
+  be `int`, where `0` denoted an incorrect height. New return type is
+  `option(hash)`, where `None` represents an incorrect height.
+- Event name hashes now use BLAKE2b instead of Keccak256.
+- Fixed bugs when defining record types in namespaces.
+- Fixed a bug in include path handling when passing options to the compiler.
+### Removed
+
+## [3.1.0] - 2019-06-03
+### Added
+### Changed
+- Keyword `indexed` is now optional for word typed (`bool`, `int`, `address`,
+  ...) event arguments.
+- State variable pretty printing now produce `'a, 'b, ...` instead of `'1, '2, ...`.
+- ACI is restructured and improved:
+    - `state` and `event` types (if present) now appear at the top level.
+    - Namespaces and remote interfaces are no longer ignored.
+    - All type definitions are included in the interface rendering.
+    - API functions are renamed, new functions are `contract_interface`
+      and `render_aci_json`.
+- Fixed a bug in `create_calldata`/`to_sophia_value` - it can now handle negative
+  literals.
+### Removed
+
 ## [3.0.0] - 2019-05-21
 ### Added
 - `stateful` annotations are now properly enforced. Functions must be marked stateful
@@ -55,7 +134,10 @@ 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/v3.0.0...HEAD
+[Unreleased]: https://github.com/aeternity/aesophia/compare/v4.0.0-rc1...HEAD
+[4.0.0-rc1]: https://github.com/aeternity/aesophia/compare/v3.2.0...v4.0.0-rc1
+[3.2.0]: https://github.com/aeternity/aesophia/compare/v3.1.0...v3.2.0
+[3.1.0]: https://github.com/aeternity/aesophia/compare/v3.0.0...v3.1.0
 [3.0.0]: https://github.com/aeternity/aesophia/compare/v2.1.0...v3.0.0
 [2.1.0]: https://github.com/aeternity/aesophia/compare/v2.0.0...v2.1.0
 [2.0.0]: https://github.com/aeternity/aesophia/tag/v2.0.0

docs/aeso_aci.md

@@ -30,28 +30,14 @@ generates the following JSON structure representing the contract interface:
 ``` json
 {
   "contract": {
-    "name": "Answers",
-    "type_defs": [
-      {
-        "name": "state",
-        "vars": [],
-        "typedef": "{a : map(string,int)}"
-      },
-      {
-        "name": "answers",
-        "vars": [],
-        "typedef": "map(string,int)"
-      }
-    ],
     "functions": [
       {
-        "name": "init",
         "arguments": [],
-        "type": "{a : map(string,int)}",
+        "name": "init",
+        "returns": "Answers.state",
         "stateful": true
       },
       {
-        "name": "new_answer",
         "arguments": [
           {
             "name": "q",
@@ -62,9 +48,36 @@ generates the following JSON structure representing the contract interface:
             "type": "int"
           }
         ],
-        "type": "map(string,int)",
+        "name": "new_answer",
+        "returns": {
+          "map": [
+            "string",
+            "int"
+          ]
+        },
         "stateful": false
       }
+    ],
+    "name": "Answers",
+    "state": {
+      "record": [
+        {
+          "name": "a",
+          "type": "Answers.answers"
+        }
+      ]
+    },
+    "type_defs": [
+      {
+        "name": "answers",
+        "typedef": {
+          "map": [
+            "string",
+            "int"
+          ]
+        },
+        "vars": []
+      }
     ]
   }
 }
@@ -74,62 +87,70 @@ When that encoding is decoded the following include definition is generated:
 
 ```
 contract Answers =
-  function new_answer : (string, int) => map(string,int)
+  record state = {a : Answers.answers}
+  type answers = map(string, int)
+  function init : () => Answers.state
+  function new_answer : (string, int) => map(string, int)
 ```
 
 ### Types
-``` erlang
+```erlang
-contract_string() = string() | binary()
+-type aci_type()  :: json | string.
-json_string() = binary()
+-type json()      :: jsx:json_term().
+-type json_text() :: binary().
 ```
 
 ### Exports
 
-#### encode(ContractString) -> {ok,JSONstring} | {error,ErrorString}
+#### contract\_interface(aci\_type(), string()) -> {ok, json() | string()} | {error, term()}
 
-Types
+Generate the JSON encoding of the interface to a contract. The type definitions
+and non-private functions are included in the JSON string.
 
-``` erlang
+#### render\_aci\_json(json() | json\_text()) -> string().
-ConstractString = contract_string()
-JSONstring = json_string()
-```
 
-Generate the JSON encoding of the interface to a contract. The type definitions and non-private functions are included in the JSON string.
+Take a JSON encoding of a contract interface and generate a contract interface
-
+that can be included in another contract.
-#### decode(JSONstring) -> ConstractString.
-
-Types
-
-``` erlang
-ConstractString = contract_string()
-JSONstring = json_string()
-```
-
-Take a JSON encoding of a contract interface and generate and generate a contract definition which can be included in another contract.
 
 ### Example run
 
-This is an example of using the ACI generator from an Erlang shell. The file called `aci_test.aes` contains the contract in the description from which we want to generate files `aci_test.json` which is the JSON encoding of the contract interface and `aci_test.include` which is the contract definition to be included inside another contract.
+This is an example of using the ACI generator from an Erlang shell. The file
+called `aci_test.aes` contains the contract in the description from which we
+want to generate files `aci_test.json` which is the JSON encoding of the
+contract interface and `aci_test.include` which is the contract definition to
+be included inside another contract.
 
 ``` erlang
 1> {ok,Contract} = file:read_file("aci_test.aes").
 {ok,<<"contract Answers =\n  record state = { a : answers }\n  type answers() = map(string, int)\n\n  stateful function"...>>}
-2> {ok,Encoding} = aeso_aci:encode(Contract).
+2> {ok,JsonACI} = aeso_aci:contract_interface(json, Contract).
-<<"{\"contract\":{\"name\":\"Answers\",\"type_defs\":[{\"name\":\"state\",\"vars\":[],\"typedef\":\"{a : map(string,int)}\"},{\"name\":\"ans"...>>
+{ok,[#{contract =>
-3> file:write_file("aci_test.aci", Encoding).
+           #{functions =>
+                 [#{arguments => [],name => <<"init">>,
+                    returns => <<"Answers.state">>,stateful => true},
+                  #{arguments =>
+                        [#{name => <<"q">>,type => <<"string">>},
+                         #{name => <<"a">>,type => <<"int">>}],
+                    name => <<"new_answer">>,
+                    returns => #{<<"map">> => [<<"string">>,<<"int">>]},
+                    stateful => false}],
+             name => <<"Answers">>,
+             state =>
+                 #{record =>
+                       [#{name => <<"a">>,type => <<"Answers.answers">>}]},
+             type_defs =>
+                 [#{name => <<"answers">>,
+                    typedef => #{<<"map">> => [<<"string">>,<<"int">>]},
+                    vars => []}]}}]}
+3> file:write_file("aci_test.aci", jsx:encode(JsonACI)).
 ok
-4> Decoded = aeso_aci:decode(Encoding).
+4> {ok,InterfaceStub} = aeso_aci:render_aci_json(JsonACI).
-<<"contract Answers =\n  function new_answer : (string, int) => map(string,int)\n">>
+{ok,<<"contract Answers =\n  record state = {a : Answers.answers}\n  type answers = map(string, int)\n  function init "...>>}
-5> file:write_file("aci_test.include", Decoded).
+5> file:write_file("aci_test.include", InterfaceStub).
 ok
-6> jsx:prettify(Encoding).
+6> jsx:prettify(jsx:encode(JsonACI)).
-<<"{\n  \"contract\": {\n    \"name\": \"Answers\",\n    \"type_defs\": [\n      {\n        \"name\": \"state\",\n        \"vars\": [],\n   "...>>
+<<"[\n  {\n    \"contract\": {\n      \"functions\": [\n        {\n          \"arguments\": [],\n          \"name\": \"init\",\n        "...>>
 ```
 
-The final call to `jsx:prettify(Encoding)` returns the encoding in a
+The final call to `jsx:prettify(jsx:encode(JsonACI))` returns the encoding in a
-more easily readable form. This is what is shown in the description
+more easily readable form. This is what is shown in the description above.
-above.
-
-### Notes
-
-The ACI generator currently cannot properly handle types defined using `datatype`.

rebar.config

@@ -2,9 +2,9 @@
 
 {erl_opts, [debug_info]}.
 
-{deps, [ {aebytecode, {git, "https://github.com/aeternity/aebytecode.git",
+{deps, [ {aebytecode, {git, "https://github.com/aeternity/aebytecode.git", {ref,"10cc127"}}}
-                            {ref, "2f4e188"}}}
        , {getopt, "1.0.1"}
+       , {eblake2, "1.0.0"}
        , {jsx, {git, "https://github.com/talentdeficit/jsx.git",
                      {tag, "2.8.0"}}}
        ]}.
@@ -15,7 +15,7 @@
             {base_plt_apps, [erts, kernel, stdlib, crypto, mnesia]}
            ]}.
 
-{relx, [{release, {aesophia, "3.0.0"},
+{relx, [{release, {aesophia, "4.0.0-rc1"},
          [aesophia, aebytecode, getopt]},
 
         {dev_mode, true},

rebar.lock

@@ -1,7 +1,7 @@
 {"1.1.0",
 [{<<"aebytecode">>,
   {git,"https://github.com/aeternity/aebytecode.git",
-       {ref,"2f4e1888c241a7347ffec855ab6761c2c2972f37"}},
+       {ref,"10cc1278831ad7e90138533466ceef4bcafd74a9"}},
   0},
  {<<"aeserialization">>,
   {git,"https://github.com/aeternity/aeserialization.git",
@@ -11,7 +11,7 @@
   {git,"https://github.com/aeternity/erl-base58.git",
        {ref,"60a335668a60328a29f9731b67c4a0e9e3d50ab6"}},
   2},
- {<<"eblake2">>,{pkg,<<"eblake2">>,<<"1.0.0">>},1},
+ {<<"eblake2">>,{pkg,<<"eblake2">>,<<"1.0.0">>},0},
  {<<"getopt">>,{pkg,<<"getopt">>,<<"1.0.1">>},0},
  {<<"jsx">>,
   {git,"https://github.com/talentdeficit/jsx.git",

src/aeso_aci.erl

@@ -9,76 +9,70 @@
 
 -module(aeso_aci).
 
--export([encode/1,encode/2,decode/1]).
+-export([ file/2
--export([encode_type/1,encode_stmt/1,encode_expr/1]).
+        , file/3
+        , contract_interface/2
+        , contract_interface/3
 
-%% Define records for the various typed syntactic forms. These make
+        , render_aci_json/1
-%% the code easier but don't seem to exist elsewhere.
 
-%% Top-level
+        , json_encode_expr/1
--record(contract, {ann,con,decls}).
+        , json_encode_type/1]).
-%% -record(namespace, {ann,con,decls}).
--record(letfun, {ann,id,args,type,body}).
--record(type_def, {ann,id,vars,typedef}).
 
-%% Types
+-type aci_type()  :: json | string.
--record(app_t, {ann,id,fields}).
+-type json()      :: jsx:json_term().
--record(tuple_t, {ann,args}).
+-type json_text() :: binary().
--record(bytes_t, {ann,len}).
--record(record_t, {fields}).
--record(field_t, {ann,id,type}).
--record(alias_t, {type}).
--record(variant_t, {cons}).
--record(constr_t, {ann,con,args}).
--record(fun_t, {ann,named,args,type}).
 
-%% Tokens
+%% External API
--record(arg, {ann,id,type}).
+-spec file(aci_type(), string()) -> {ok, json() | string()} | {error, term()}.
--record(id, {ann,name}).
+file(Type, File) ->
--record(con, {ann,name}).
+    file(Type, File, []).
--record(qid, {ann,names}).
--record(qcon, {ann,names}).
--record(tvar, {ann,name}).
 
-%% Expressions
+file(Type, File, Options0) ->
--record(bool, {ann,bool}).
+    Options = aeso_compiler:add_include_path(File, Options0),
--record(int, {ann,value}).
+    case file:read_file(File) of
--record(string, {ann,bin}).
+        {ok, BinCode} ->
--record(bytes, {ann,bin}).
+            do_contract_interface(Type, binary_to_list(BinCode), Options);
--record(tuple, {ann,args}).
+        {error, _} = Err -> Err
--record(list, {ann,args}).
+    end.
--record(app, {ann,func,args}).
--record(typed, {ann,expr,type}).
 
-%% encode(ContractString) -> {ok,JSON} | {error,String}.
+-spec contract_interface(aci_type(), string()) ->
-%% encode(ContractString, Options) -> {ok,JSON} | {error,String}.
+    {ok, json() | string()} | {error, term()}.
-%%  Build a JSON structure with lists and tuples, not maps, as this
+contract_interface(Type, ContractString) ->
-%%  allows us to order the fields in the contructed JSON string.
+    contract_interface(Type, ContractString, []).
 
-encode(ContractString) -> encode(ContractString, []).
+-spec contract_interface(aci_type(), string(), [term()]) ->
+    {ok, json() | string()} | {error, term()}.
+contract_interface(Type, ContractString, CompilerOpts) ->
+    do_contract_interface(Type, ContractString, CompilerOpts).
 
-encode(ContractString, Options) when is_binary(ContractString) ->
+-spec render_aci_json(json() | json_text()) -> {ok, binary()}.
-    encode(binary_to_list(ContractString), Options);
+render_aci_json(Json) ->
-encode(ContractString, Options) ->
+    do_render_aci_json(Json).
+
+-spec json_encode_expr(aeso_syntax:expr()) -> json().
+json_encode_expr(Expr) ->
+    encode_expr(Expr).
+
+-spec json_encode_type(aeso_syntax:type()) -> json().
+json_encode_type(Type) ->
+    encode_type(Type).
+
+%% Internal functions
+do_contract_interface(Type, Contract, Options) when is_binary(Contract) ->
+    do_contract_interface(Type, binary_to_list(Contract), Options);
+do_contract_interface(Type, ContractString, Options) ->
     try
-        Ast = parse(ContractString, Options),
+        Ast = aeso_compiler:parse(ContractString, Options),
         %% io:format("~p\n", [Ast]),
-        %% aeso_ast:pp(Ast),
+        TypedAst = aeso_ast_infer_types:infer(Ast, [dont_unfold]),
-        TypedAst = aeso_ast_infer_types:infer(Ast, Options),
         %% io:format("~p\n", [TypedAst]),
-        %% aeso_ast:pp_typed(TypedAst),
+        JArray = [ encode_contract(C) || C <- TypedAst ],
-        %% We find and look at the last contract.
+
-        Contract = lists:last(TypedAst),
+        case Type of
-        Cname = contract_name(Contract),
+            json   -> {ok, JArray};
-        Tdefs = [ encode_typedef(T) ||
+            string -> do_render_aci_json(JArray)
-                    T <- sort_decls(contract_types(Contract)) ],
+        end
-        Fdefs = [ encode_func(F) || F <- sort_decls(contract_funcs(Contract)),
-                                    not is_private_func(F) ],
-        Jmap = [{<<"contract">>, [{<<"name">>, encode_name(Cname)},
-                                  {<<"type_defs">>, Tdefs},
-                                  {<<"functions">>, Fdefs}]}],
-        %% io:format("~p\n", [Jmap]),
-        {ok,jsx:encode(Jmap)}
     catch
         %% The compiler errors.
         error:{parse_errors, Errors} ->
@@ -95,201 +89,222 @@ join_errors(Prefix, Errors, Pfun) ->
     Ess = [ Pfun(E) || E <- Errors ],
     list_to_binary(string:join([Prefix|Ess], "\n")).
 
-%% encode_func(Function) -> JSON
+encode_contract(Contract = {contract, _, {con, _, Name}, _}) ->
+    C0 = #{name => encode_name(Name)},
+
+    Tdefs0 = [ encode_typedef(T) || T <- sort_decls(contract_types(Contract)) ],
+    FilterT = fun(N) -> fun(#{name := N1}) -> N == N1 end end,
+    {Es, Tdefs1} = lists:partition(FilterT(<<"event">>), Tdefs0),
+    {Ss, Tdefs}  = lists:partition(FilterT(<<"state">>), Tdefs1),
+
+    C1 = C0#{type_defs => Tdefs},
+
+    C2 = case Es of
+             []                 -> C1;
+             [#{typedef := ET}] -> C1#{event => ET}
+         end,
+
+    C3 = case Ss of
+             []                 -> C2;
+             [#{typedef := ST}] -> C2#{state => ST}
+         end,
+
+    Fdefs  = [ encode_function(F)
+               || F <- sort_decls(contract_funcs(Contract)),
+                  is_entrypoint(F) ],
+
+    #{contract => C3#{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),
+                     type_defs => Tdefs}}.
+
 %%  Encode a function definition. Currently we are only interested in
 %%  the interface and type.
+encode_function(FDef = {letfun, _, {id, _, Name}, Args, Type, _}) ->
+    #{name      => encode_name(Name),
+      arguments => encode_args(Args),
+      returns   => encode_type(Type),
+      stateful  => is_stateful(FDef),
+      payable   => is_payable(FDef)};
+encode_function(FDecl = {fun_decl, _, {id, _, Name}, {fun_t, _, _, Args, Type}}) ->
+    #{name      => encode_name(Name),
+      arguments => encode_anon_args(Args),
+      returns   => encode_type(Type),
+      stateful  => is_stateful(FDecl),
+      payable   => is_payable(FDecl)}.
 
-encode_func(Fdef) ->
+encode_anon_args(Types) ->
-    Name = function_name(Fdef),
+    Anons = [ list_to_binary("_" ++ integer_to_list(X)) || X <- lists:seq(1, length(Types))],
-    Args = function_args(Fdef),
+    [ #{name => V, type => encode_type(T)}
-    Type = function_type(Fdef),
+      || {V, T} <- lists:zip(Anons, Types) ].
-    [{<<"name">>, encode_name(Name)},
-     {<<"arguments">>, encode_args(Args)},
-     {<<"returns">>, encode_type(Type)},
-     {<<"stateful">>, is_stateful_func(Fdef)}].
 
-%% encode_args(Args) -> [JSON].
+encode_args(Args) -> [ encode_arg(A) || A <- Args ].
-%% encode_arg(Args) -> JSON.
 
-encode_args(Args) ->
+encode_arg({arg, _, Id, T}) ->
-    [ encode_arg(A) || A <- Args ].
+    #{name => encode_type(Id),
-
+      type => encode_type(T)}.
-encode_arg(#arg{id=Id,type=T}) ->
-    [{<<"name">>,encode_type(Id)},
-     {<<"type">>,[encode_type(T)]}].
-
-%% encode_types(Types) -> [JSON].
-%% encode_type(Type) -> JSON.
-
-encode_types(Types) ->
-    [ encode_type(T) || T <- Types ].
-
-encode_type(#tvar{name=N}) -> encode_name(N);
-encode_type(#id{name=N}) -> encode_name(N);
-encode_type(#con{name=N}) -> encode_name(N);
-encode_type(#qid{names=Ns}) ->
-    encode_name(lists:join(".", Ns));
-encode_type(#qcon{names=Ns}) ->
-    encode_name(lists:join(".", Ns));           %?
-encode_type(#tuple_t{args=As}) ->
-    Eas = encode_types(As),
-    [{<<"tuple">>,Eas}];
-encode_type(#bytes_t{len=Len}) ->
-    {<<"bytes">>, Len};
-encode_type(#record_t{fields=Fs}) ->
-    Efs = encode_fields(Fs),
-    [{<<"record">>,Efs}];
-encode_type(#app_t{id=Id,fields=Fs}) ->
-    Name = encode_type(Id),
-    Efs = encode_types(Fs),
-    [{Name,Efs}];
-encode_type(#variant_t{cons=Cs}) ->
-    Ecs = encode_types(Cs),
-    [{<<"variant">>,Ecs}];
-encode_type(#constr_t{con=C,args=As}) ->
-    Ec = encode_type(C),
-    Eas = encode_types(As),
-    [{Ec,Eas}];
-encode_type(#fun_t{args=As,type=T}) ->
-    Eas = encode_types(As),
-    Et = encode_type(T),
-    [{<<"function">>,[{<<"arguments">>,Eas},{<<"returns">>,Et}]}].
-
-encode_name(Name) ->
-    list_to_binary(Name).
-
-%% encode_fields(Fields) -> [JSON].
-%% encode_field(Field) -> JSON.
-%%  Encode a record field.
-
-encode_fields(Fs) ->
-    [ encode_field(F) || F <- Fs ].
-
-encode_field(#field_t{id=Id,type=T}) ->
-    [{<<"name">>,encode_type(Id)},
-     {<<"type">>,[encode_type(T)]}].
-
-%% encode_typedef(TypeDef) -> JSON.
 
 encode_typedef(Type) ->
     Name = typedef_name(Type),
     Vars = typedef_vars(Type),
-    Def = typedef_def(Type),
+    Def  = typedef_def(Type),
-    [{<<"name">>, encode_name(Name)},
+    #{name    => encode_name(Name),
-     {<<"vars">>, encode_tvars(Vars)},
+      vars    => encode_tvars(Vars),
-     {<<"typedef">>, encode_alias(Def)}].
+      typedef => encode_type(Def)}.
 
 encode_tvars(Vars) ->
-    [ encode_tvar(V) || V <- Vars ].
+    [ #{name => encode_type(V)} || V <- Vars ].
 
-encode_tvar(#tvar{name=N}) ->
+%% Encode type
-    [{<<"name">>, encode_name(N)}].
+encode_type({tvar, _, N})         -> encode_name(N);
+encode_type({id, _, N})           -> encode_name(N);
+encode_type({con, _, N})          -> encode_name(N);
+encode_type({qid, _, Ns})         -> encode_name(lists:join(".", Ns));
+encode_type({qcon, _, Ns})        -> encode_name(lists:join(".", Ns));
+encode_type({tuple_t, _, As})     -> #{tuple => encode_types(As)};
+encode_type({bytes_t, _, Len})    -> #{bytes => Len};
+encode_type({record_t, Fs})       -> #{record => encode_type_fields(Fs)};
+encode_type({app_t, _, Id, Fs})   -> #{encode_type(Id) => encode_types(Fs)};
+encode_type({variant_t, Cs})      -> #{variant => encode_types(Cs)};
+encode_type({constr_t, _, C, As}) -> #{encode_type(C) => encode_types(As)};
+encode_type({alias_t, Type})      -> encode_type(Type);
+encode_type({fun_t, _, _, As, T}) -> #{function =>
+                                         #{arguments => encode_types(As),
+                                           returns => encode_type(T)}}.
 
-encode_alias(#alias_t{type=T}) ->
+encode_types(Ts) -> [ encode_type(T) || T <- Ts ].
-    encode_type(T);
-encode_alias(A) -> encode_type(A).
 
-%% encode_stmt(Stmt) -> JSON.
+encode_type_fields(Fs) -> [ encode_type_field(F) || F <- Fs ].
 
-encode_stmt(E) ->
+encode_type_field({field_t, _, Id, T}) ->
-    encode_expr(E).
+    #{name => encode_type(Id),
+      type => encode_type(T)}.
 
-%% encode_exprs(Exprs) -> [JSON].
+encode_name(Name) when is_list(Name) ->
-%% encode_expr(Expr) -> JSON.
+    list_to_binary(Name);
+encode_name(Name) when is_binary(Name) ->
+    Name.
 
-encode_exprs(Es) ->
+%% Encode Expr
-    [ encode_expr(E) || E <- Es ].
+encode_exprs(Es) -> [ encode_expr(E) || E <- Es ].
 
-encode_expr(#id{name=N}) -> encode_name(N);
+encode_expr({id, _, N})     -> encode_name(N);
-encode_expr(#con{name=N}) -> encode_name(N);
+encode_expr({con, _, N})    -> encode_name(N);
-encode_expr(#qid{names=Ns}) ->
+encode_expr({qid, _, Ns})   -> encode_name(lists:join(".", Ns));
-    encode_name(lists:join(".", Ns));
+encode_expr({qcon, _, Ns})  -> encode_name(lists:join(".", Ns));
-encode_expr(#qcon{names=Ns}) ->
+encode_expr({typed, _, E})  -> encode_expr(E);
-    encode_name(lists:join(".", Ns));           %?
+encode_expr({bool, _, B})   -> B;
-encode_expr(#typed{expr=E}) ->
+encode_expr({int, _, V})    -> V;
-    encode_expr(E);
+encode_expr({string, _, S}) -> S;
-encode_expr(#bool{bool=B}) -> B;
+encode_expr({tuple, _, As}) -> encode_exprs(As);
-encode_expr(#int{value=V}) -> V;
+encode_expr({list, _, As})  -> encode_exprs(As);
-encode_expr(#string{bin=B}) -> B;
+encode_expr({bytes, _, B})  ->
-encode_expr(#bytes{bin=B}) -> B;
+    Digits = byte_size(B),
-encode_expr(#tuple{args=As}) ->
+    <<N:Digits/unit:8>> = B,
-    Eas = encode_exprs(As),
+    list_to_binary(lists:flatten(io_lib:format("#~*.16.0b", [Digits*2, N])));
-    [{<<"tuple">>,Eas}];
+encode_expr({Lit, _, L}) when Lit == oracle_pubkey; Lit == oracle_query_id;
-encode_expr(#list{args=As}) ->
+                              Lit == contract_pubkey; Lit == account_pubkey ->
-    Eas = encode_exprs(As),
+    aeser_api_encoder:encode(Lit, L);
-    [{<<"list">>,Eas}];
+encode_expr({app, _, F, As}) ->
-encode_expr(#app{func=F,args=As}) ->
     Ef = encode_expr(F),
     Eas = encode_exprs(As),
-    [{<<"apply">>,[{<<"function">>,Ef},
+    #{Ef => Eas};
-		   {<<"arguments">>,Eas}]}];
+encode_expr({record, _, Flds}) -> maps:from_list(encode_fields(Flds));
+encode_expr({map, _, KVs})     -> [ [encode_expr(K), encode_expr(V)] || {K, V} <- KVs ];
 encode_expr({Op,_Ann}) ->
-    list_to_binary(atom_to_list(Op)).
+    error({encode_expr_todo, Op}).
 
-%% decode(JSON) -> ContractString.
+encode_fields(Flds) -> [ encode_field(F) || F <- Flds ].
-%%  Decode a JSON string and generate a suitable contract string which
-%%  can be included in a contract definition. We decode into a map
-%%  here as this is easier to work with and order is not important.
 
-decode(Json) ->
+encode_field({field, _, [{proj, _, {id, _, Fld}}], Val}) ->
-    Map = jsx:decode(Json, [return_maps]),
+    {encode_name(Fld), encode_expr(Val)}.
-    %% io:format("~p\n", [Map]),
-    #{<<"contract">> := C} = Map,
-    list_to_binary(decode_contract(C)).
 
-decode_contract(#{<<"name">> := Name,
+do_render_aci_json(Json) ->
-                  <<"type_defs">> := Ts,
+    Contracts =
-                  <<"functions">> := Fs}) ->
+        case Json of
-    ["contract"," ",io_lib:format("~s", [Name])," =\n",
+            JArray when is_list(JArray)  -> JArray;
-     decode_tdefs(Ts),
+            JObject when is_map(JObject) -> [JObject];
-     decode_funcs(Fs)].
+            JText when is_binary(JText)  ->
+                case jsx:decode(Json, [{labels, atom}, return_maps]) of
+                    JArray when is_list(JArray)  -> JArray;
+                    JObject when is_map(JObject) -> [JObject];
+                    _                            -> error(bad_aci_json)
+                end
+        end,
+    DecodedContracts = [ decode_contract(C) || C <- Contracts ],
+    {ok, list_to_binary(string:join(DecodedContracts, "\n"))}.
+
+decode_contract(#{contract := #{name := Name,
+                                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",
+     decode_tdefs(Ts), decode_funcs(Fs)];
+decode_contract(#{namespace := #{name := Name, type_defs := Ts}}) when Ts /= [] ->
+    ["namespace ", io_lib:format("~s", [Name])," =\n",
+     decode_tdefs(Ts)];
+decode_contract(_) -> [].
 
 decode_funcs(Fs) -> [ decode_func(F) || F <- Fs ].
 
-decode_func(#{<<"name">> := <<"init">>}) -> [];
+%% decode_func(#{name := init}) -> [];
-decode_func(#{<<"name">> := Name,<<"arguments">> := As,<<"returns">> := T}) ->
+decode_func(#{name := Name, payable := Payable, arguments := As, returns := T}) ->
-    ["  function"," ",io_lib:format("~s", [Name])," : ",
+    ["  ", payable(Payable), "entrypoint ", io_lib:format("~s", [Name]), " : ",
-     decode_args(As)," => ",decode_type(T),$\n].
+     decode_args(As), " => ", decode_type(T), $\n].
 
 decode_args(As) ->
     Das = [ decode_arg(A) || A <- As ],
     [$(,lists:join(", ", Das),$)].
 
-decode_arg(#{<<"type">> := [T]}) -> decode_type(T).
+decode_arg(#{type := T}) -> decode_type(T).
 
 decode_types(Ets) ->
     [ decode_type(Et) || Et <- Ets ].
 
-decode_type(#{<<"tuple">> := Ets}) ->
+decode_type(#{tuple := Ets}) ->
     Ts = decode_types(Ets),
-    [$(,lists:join(",", Ts),$)];
+    case Ts of
-decode_type(#{<<"record">> := Efs}) ->
+        [] -> ["unit"];
+        _ -> [$(,lists:join(" * ", Ts),$)]
+    end;
+decode_type(#{record := Efs}) ->
     Fs = decode_fields(Efs),
     [${,lists:join(",", Fs),$}];
-decode_type(#{<<"list">> := [Et]}) ->
+decode_type(#{list := [Et]}) ->
     T = decode_type(Et),
     ["list",$(,T,$)];
-decode_type(#{<<"map">> := Ets}) ->
+decode_type(#{map := Ets}) ->
     Ts = decode_types(Ets),
     ["map",$(,lists:join(",", Ts),$)];
-decode_type(#{<<"variant">> := Ets}) ->
+decode_type(#{bytes := Len}) ->
+    ["bytes(", integer_to_list(Len), ")"];
+decode_type(#{variant := Ets}) ->
     Ts = decode_types(Ets),
     lists:join(" | ", Ts);
+decode_type(#{function := #{arguments := Args, returns := R}}) ->
+    [decode_type(#{tuple => Args}), " => ", decode_type(R)];
 decode_type(Econs) when is_map(Econs) ->	%General constructor
     [{Ec,Ets}] = maps:to_list(Econs),
-    C = decode_name(Ec),
+    AppName = decode_name(Ec),
-    Ts = decode_types(Ets),
+    AppArgs = decode_types(Ets),
-    [C,$(,lists:join(",", Ts),$)];
+    case AppArgs of
+        [] -> [AppName];
+        _  -> [AppName,$(,lists:join(", ", AppArgs),$)]
+    end;
 decode_type(T) ->				%Just raw names.
     decode_name(T).
 
-decode_name(En) ->
+decode_name(En) when is_atom(En)   -> erlang:atom_to_list(En);
-    binary_to_list(En).
+decode_name(En) when is_binary(En) -> binary_to_list(En).
 
 decode_fields(Efs) ->
     [ decode_field(Ef) || Ef <- Efs ].
 
-decode_field(#{<<"name">> := En,<<"type">> := [Et]}) ->
+decode_field(#{name := En, type := Et}) ->
     Name = decode_name(En),
     Type = decode_type(Et),
     [Name," : ",Type].
@@ -298,39 +313,41 @@ decode_field(#{<<"name">> := En,<<"type">> := [Et]}) ->
 %%  Here we are only interested in the type definitions and ignore the
 %%  aliases. We find them as they always have variants.
 
-decode_tdefs(Ts) -> [ decode_tdef(T) ||
+decode_tdefs(Ts) -> [ decode_tdef(T) || T <- Ts ].
-			#{<<"typedef">> := #{<<"variant">> := _}} = T <- Ts
-		    ].
 
-decode_tdef(#{<<"name">> := Name,<<"vars">> := Vs,<<"typedef">> := T}) ->
+decode_tdef(#{name := Name, vars := Vs, typedef := T}) ->
-    ["  datatype"," ",decode_name(Name),decode_tvars(Vs),
+    TypeDef = decode_type(T),
-     " = ",decode_type(T),$\n].
+    DefType = decode_deftype(T),
+    ["  ", DefType, " ", decode_name(Name), decode_tvars(Vs), " = ", TypeDef, $\n].
 
-decode_tvars([]) -> [];                         %No tvars, no parentheses
+decode_deftype(#{record := _Efs}) -> "record";
+decode_deftype(#{variant := _})   -> "datatype";
+decode_deftype(_T)                      -> "type".
+
+decode_tvars([]) -> [];  %No tvars, no parentheses
 decode_tvars(Vs) ->
     Dvs = [ decode_tvar(V) || V <- Vs ],
     [$(,lists:join(", ", Dvs),$)].
 
-decode_tvar(#{<<"name">> := N}) -> io_lib:format("~s", [N]).
+decode_tvar(#{name := N}) -> io_lib:format("~s", [N]).
+
+payable(true)  -> "payable ";
+payable(false) -> "".
 
 %% #contract{Ann, Con, [Declarations]}.
 
-contract_name(#contract{con=#con{name=N}}) -> N.
+contract_funcs({C, _, _, Decls}) when C == contract; C == namespace ->
+    [ D || D <- Decls, is_fun(D)].
 
-contract_funcs(#contract{decls=Decls}) ->
+contract_types({C, _, _, Decls}) when C == contract; C == namespace ->
-    [ D || D <- Decls, is_record(D, letfun) ].
+    [ D || D <- Decls, is_type(D) ].
 
-contract_types(#contract{decls=Decls}) ->
+is_fun({letfun, _, _, _, _, _}) -> true;
-    [ D || D <- Decls, is_record(D, type_def) ].
+is_fun({fun_decl, _, _, _})     -> true;
+is_fun(_)                       -> false.
 
-%% To keep dialyzer happy and quiet.
+is_type({type_def, _, _, _, _}) -> true;
-%% namespace_name(#namespace{con=#con{name=N}}) -> N.
+is_type(_)                      -> false.
-%%
-%% namespace_funcs(#namespace{decls=Decls}) ->
-%%     [ D || D <- Decls, is_record(D, letfun) ].
-%%
-%% namespace_types(#namespace{decls=Decls}) ->
-%%     [ D || D <- Decls, is_record(D, type_def) ].
 
 sort_decls(Ds) ->
     Sort = fun (D1, D2) ->
@@ -339,58 +356,12 @@ sort_decls(Ds) ->
            end,
     lists:sort(Sort, Ds).
 
-%% #letfun{Ann, Id, [Arg], Type, Typedef}.
+is_entrypoint(Node) -> aeso_syntax:get_ann(entrypoint, Node, false).
+is_stateful(Node) -> aeso_syntax:get_ann(stateful, Node, false).
+is_payable(Node) -> aeso_syntax:get_ann(payable, Node, false).
 
-function_name(#letfun{id=#id{name=N}}) -> N.
+typedef_name({type_def, _, {id, _, Name}, _, _}) -> Name.
 
-function_args(#letfun{args=Args}) -> Args.
+typedef_vars({type_def, _, _, Vars, _}) -> Vars.
 
-function_type(#letfun{type=Type}) -> Type.
+typedef_def({type_def, _, _, _, Def}) -> Def.
-
-is_private_func(#letfun{ann=A}) -> aeso_syntax:get_ann(private, A, false).
-
-is_stateful_func(#letfun{ann=A}) -> aeso_syntax:get_ann(stateful, A, false).
-
-%% #type_def{Ann, Id, [Var], Typedef}.
-
-typedef_name(#type_def{id=#id{name=N}}) -> N.
-
-typedef_vars(#type_def{vars=Vars}) -> Vars.
-
-typedef_def(#type_def{typedef=Def}) -> Def.
-
-%% parse(ContractString, Options) -> {ok,AST}.
-%%  Signal errors, the sophia compiler way. Sigh!
-
-parse(Text, Options) ->
-    %% Try and return something sensible here!
-    case aeso_parser:string(Text, Options) of
-        %% Yay, it worked!
-        {ok, Contract} -> Contract;
-        %% Scan errors.
-        {error, {Pos, scan_error}} ->
-            parse_error(Pos, "scan error");
-        {error, {Pos, scan_error_no_state}} ->
-            parse_error(Pos, "scan error");
-        %% Parse errors.
-        {error, {Pos, parse_error, Error}} ->
-            parse_error(Pos, Error);
-        {error, {Pos, ambiguous_parse, As}} ->
-            ErrorString = io_lib:format("Ambiguous ~p", [As]),
-            parse_error(Pos, ErrorString);
-        %% Include error
-        {error, {Pos, include_error, File}} ->
-            parse_error(Pos, io_lib:format("could not find include file '~s'", [File]))
-    end.
-
-parse_error(Pos, ErrorString) ->
-    %% io:format("Error ~p ~p\n", [Pos,ErrorString]),
-    Error = io_lib:format("~s: ~s", [pos_error(Pos), ErrorString]),
-    error({parse_errors, [Error]}).
-
-pos_error({Line, Pos}) ->
-    io_lib:format("line ~p, column ~p", [Line, Pos]);
-pos_error({no_file, Line, Pos}) ->
-    pos_error({Line, Pos});
-pos_error({File, Line, Pos}) ->
-    io_lib:format("file ~s, line ~p, column ~p", [File, Line, Pos]).

src/aeso_ast_infer_types.erl

@@ -83,7 +83,7 @@
 
 -type fun_info()  :: {aeso_syntax:ann(), typesig() | type()}.
 -type type_info() :: {aeso_syntax:ann(), typedef()}.
--type var_info()  :: {aeso_syntax:ann(), type()}.
+-type var_info()  :: {aeso_syntax:ann(), utype()}.
 
 -type fun_env()  :: [{name(), fun_info()}].
 -type type_env() :: [{name(), type_info()}].
@@ -135,11 +135,15 @@ on_current_scope(Env = #env{ namespace = NS, scopes = Scopes }, Fun) ->
     Scope = maps:get(NS, Scopes),
     Env#env{ scopes = Scopes#{ NS => Fun(Scope) } }.
 
--spec bind_var(aeso_syntax:id(), type(), env()) -> env().
+-spec on_scopes(env(), fun((scope()) -> scope())) -> env().
+on_scopes(Env = #env{ scopes = Scopes }, Fun) ->
+    Env#env{ scopes = maps:map(fun(_, Scope) -> Fun(Scope) end, Scopes) }.
+
+-spec bind_var(aeso_syntax:id(), utype(), env()) -> env().
 bind_var({id, Ann, X}, T, Env) ->
     Env#env{ vars = [{X, {Ann, T}} | Env#env.vars] }.
 
--spec bind_vars([{aeso_syntax:id(), type()}], env()) -> env().
+-spec bind_vars([{aeso_syntax:id(), utype()}], env()) -> env().
 bind_vars([], Env) -> Env;
 bind_vars([{X, T} | Vars], Env) ->
     bind_vars(Vars, bind_var(X, T, Env)).
@@ -152,7 +156,7 @@ bind_tvars(Xs, Env) ->
 check_tvar(#env{ typevars = TVars}, T = {tvar, _, X}) ->
     case TVars == unrestricted orelse lists:member(X, TVars) of
         true  -> ok;
-        false -> type_error({unbound_type_variable, T})
+        false -> type_error({unbound_type, T})
     end,
     T.
 
@@ -359,6 +363,8 @@ global_env() ->
     Pair    = fun(A, B) -> {tuple_t, Ann, [A, B]} end,
     Fun     = fun(Ts, T) -> {type_sig, Ann, [], Ts, T} end,
     Fun1    = fun(S, T) -> Fun([S], T) end,
+    %% Lambda    = fun(Ts, T) -> {fun_t, Ann, [], Ts, T} end,
+    %% Lambda1   = fun(S, T) -> Lambda([S], T) end,
     StateFun  = fun(Ts, T) -> {type_sig, [stateful|Ann], [], Ts, T} end,
     TVar      = fun(X) -> {tvar, Ann, "'" ++ X} end,
     SignId    = {id, Ann, "signature"},
@@ -380,9 +386,11 @@ global_env() ->
                      {"RelativeTTL", Fun1(Int, TTL)},
                      {"FixedTTL",    Fun1(Int, TTL)},
                      %% Abort
-                     {"abort", Fun1(String, A)}])
+                     {"abort", Fun1(String, A)},
+                     {"require", Fun([Bool, String], Unit)}])
         , types = MkDefs(
                     [{"int", 0}, {"bool", 0}, {"char", 0}, {"string", 0}, {"address", 0},
+                     {"unit", {[], {alias_t, Unit}}},
                      {"hash", {[], {alias_t, Bytes(32)}}},
                      {"signature", {[], {alias_t, Bytes(64)}}},
                      {"bits", 0},
@@ -396,7 +404,7 @@ global_env() ->
                     [{"spend",        StateFun([Address, Int], Unit)},
                      %% Chain environment
                      {"balance",      Fun1(Address, Int)},
-                     {"block_hash",   Fun1(Int, Int)},
+                     {"block_hash",   Fun1(Int, Option(Hash))},
                      {"coinbase",     Address},
                      {"timestamp",    Int},
                      {"block_height", Int},
@@ -436,8 +444,8 @@ global_env() ->
                      [{"resolve",  Fun([String, String], option_t(Ann, A))},
                       {"preclaim", SignFun([Address, Hash], Unit)},
                       {"claim",    SignFun([Address, String, Int], Unit)},
-                      {"transfer", SignFun([Address, Address, Hash], Unit)},
+                      {"transfer", SignFun([Address, Address, String], Unit)},
-                      {"revoke",   SignFun([Address, Hash], Unit)}]) },
+                      {"revoke",   SignFun([Address, String], Unit)}]) },
 
     MapScope = #scope
         { funs = MkDefs(
@@ -452,8 +460,10 @@ global_env() ->
     %% Crypto/Curve operations
     CryptoScope = #scope
         { funs = MkDefs(
-                     [{"ecverify", Fun([Hash, Address, SignId], Bool)},
+                     [{"verify_sig",           Fun([Hash, Address, SignId], Bool)},
-                      {"ecverify_secp256k1", Fun([Hash, Bytes(64), Bytes(64)], Bool)},
+                      {"verify_sig_secp256k1", Fun([Hash, Bytes(64), SignId], Bool)},
+                      {"ecverify_secp256k1",   Fun([Hash, Bytes(20), Bytes(65)], Bool)},
+                      {"ecrecover_secp256k1",  Fun([Hash, Bytes(65)], Option(Bytes(20)))},
                       {"sha3",     Fun1(A, Hash)},
                       {"sha256",   Fun1(A, Hash)},
                       {"blake2b",  Fun1(A, Hash)}]) },
@@ -485,11 +495,18 @@ global_env() ->
                       {"none",         Bits},
                       {"all",          Bits}]) },
 
+    %% Bytes
+    BytesScope = #scope
+        { funs = MkDefs(
+                   [{"to_int", Fun1(Bytes(any), Int)},
+                    {"to_str", Fun1(Bytes(any), String)}]) },
+
     %% Conversion
     IntScope     = #scope{ funs = MkDefs([{"to_str", Fun1(Int,     String)}]) },
     AddressScope = #scope{ funs = MkDefs([{"to_str", Fun1(Address, String)},
                                           {"is_oracle", Fun1(Address, Bool)},
-                                          {"is_contract", Fun1(Address, Bool)}]) },
+                                          {"is_contract", Fun1(Address, Bool)},
+                                          {"is_payable", Fun1(Address, Bool)}]) },
 
     #env{ scopes =
             #{ []           => TopScope
@@ -503,6 +520,7 @@ global_env() ->
              , ["Crypto"]   => CryptoScope
              , ["String"]   => StringScope
              , ["Bits"]     => BitsScope
+             , ["Bytes"]    => BytesScope
              , ["Int"]      => IntScope
              , ["Address"]  => AddressScope
              } }.
@@ -514,7 +532,7 @@ map_t(As, K, V) -> {app_t, As, {id, As, "map"}, [K, V]}.
 infer(Contracts) ->
     infer(Contracts, []).
 
--type option() :: return_env.
+-type option() :: return_env | dont_unfold.
 
 -spec init_env(list(option())) -> env().
 init_env(_Options) -> global_env().
@@ -526,30 +544,38 @@ infer(Contracts, Options) ->
         Env = init_env(Options),
         create_options(Options),
         ets_new(type_vars, [set]),
-        {Env1, Decls} = infer1(Env, Contracts, []),
+        check_modifiers(Env, Contracts),
+        {Env1, Decls} = infer1(Env, Contracts, [], Options),
+        {Env2, Decls2} =
+            case proplists:get_value(dont_unfold, Options, false) of
+                true  -> {Env1, Decls};
+                false -> E = on_scopes(Env1, fun(Scope) -> unfold_record_types(Env1, Scope) end),
+                         {E, unfold_record_types(E, Decls)}
+            end,
         case proplists:get_value(return_env, Options, false) of
-            false -> Decls;
+            false -> Decls2;
-            true  -> {Env1, Decls}
+            true  -> {Env2, Decls2}
         end
     after
         clean_up_ets()
     end.
 
--spec infer1(env(), [aeso_syntax:decl()], [aeso_syntax:decl()]) -> {env(), [aeso_syntax:decl()]}.
+-spec infer1(env(), [aeso_syntax:decl()], [aeso_syntax:decl()], list(option())) ->
-infer1(Env, [], Acc) -> {Env, lists:reverse(Acc)};
+    {env(), [aeso_syntax:decl()]}.
-infer1(Env, [{contract, Ann, ConName, Code} | Rest], Acc) ->
+infer1(Env, [], Acc, _Options) -> {Env, lists:reverse(Acc)};
+infer1(Env, [{contract, Ann, ConName, Code} | Rest], Acc, Options) ->
     %% do type inference on each contract independently.
     check_scope_name_clash(Env, contract, ConName),
-    {Env1, Code1} = infer_contract_top(push_scope(contract, ConName, Env), contract, Code),
+    {Env1, Code1} = infer_contract_top(push_scope(contract, ConName, Env), contract, Code, Options),
     Contract1 = {contract, Ann, ConName, Code1},
     Env2 = pop_scope(Env1),
     Env3 = bind_contract(Contract1, Env2),
-    infer1(Env3, Rest, [Contract1 | Acc]);
+    infer1(Env3, Rest, [Contract1 | Acc], Options);
-infer1(Env, [{namespace, Ann, Name, Code} | Rest], Acc) ->
+infer1(Env, [{namespace, Ann, Name, Code} | Rest], Acc, Options) ->
     check_scope_name_clash(Env, namespace, Name),
-    {Env1, Code1} = infer_contract_top(push_scope(namespace, Name, Env), namespace, Code),
+    {Env1, Code1} = infer_contract_top(push_scope(namespace, Name, Env), namespace, Code, Options),
     Namespace1 = {namespace, Ann, Name, Code1},
-    infer1(pop_scope(Env1), Rest, [Namespace1 | Acc]).
+    infer1(pop_scope(Env1), Rest, [Namespace1 | Acc], Options).
 
 check_scope_name_clash(Env, Kind, Name) ->
     case get_scope(Env, qname(Name)) of
@@ -560,13 +586,11 @@ check_scope_name_clash(Env, Kind, Name) ->
             destroy_and_report_type_errors(Env)
     end.
 
--spec infer_contract_top(env(), contract | namespace, [aeso_syntax:decl()]) -> {env(), [aeso_syntax:decl()]}.
+-spec infer_contract_top(env(), contract | namespace, [aeso_syntax:decl()], list(option())) ->
-infer_contract_top(Env, Kind, Defs0) ->
+    {env(), [aeso_syntax:decl()]}.
+infer_contract_top(Env, Kind, Defs0, _Options) ->
     Defs = desugar(Defs0),
-    {Env1, Defs1} = infer_contract(Env, Kind, Defs),
+    infer_contract(Env, Kind, Defs).
-    Env2  = on_current_scope(Env1, fun(Scope) -> unfold_record_types(Env1, Scope) end),
-    Defs2 = unfold_record_types(Env2, Defs1),
-    {Env2, Defs2}.
 
 %% TODO: revisit
 infer_constant({letval, Attrs,_Pattern, Type, E}) ->
@@ -611,11 +635,11 @@ infer_contract(Env, What, Defs) ->
     {Env4, TypeDefs ++ Decls ++ Defs1}.
 
 -spec check_typedefs(env(), [aeso_syntax:decl()]) -> {env(), [aeso_syntax:decl()]}.
-check_typedefs(Env, Defs) ->
+check_typedefs(Env = #env{ namespace = Ns }, Defs) ->
     create_type_errors(),
     GetName  = fun({type_def, _, {id, _, Name}, _, _}) -> Name end,
     TypeMap  = maps:from_list([ {GetName(Def), Def} || Def <- Defs ]),
-    DepGraph = maps:map(fun(_, Def) -> aeso_syntax_utils:used_types(Def) end, TypeMap),
+    DepGraph = maps:map(fun(_, Def) -> aeso_syntax_utils:used_types(Ns, Def) end, TypeMap),
     SCCs     = aeso_utils:scc(DepGraph),
     {Env1, Defs1} = check_typedef_sccs(Env, TypeMap, SCCs, []),
     destroy_and_report_type_errors(Env),
@@ -668,6 +692,40 @@ check_typedef(Env, {variant_t, Cons}) ->
 check_unexpected(Xs) ->
     [ type_error(X) || X <- Xs ].
 
+check_modifiers(Env, Contracts) ->
+    create_type_errors(),
+    [ case C of
+          {contract, _, Con, Decls}  ->
+              check_modifiers1(contract, Decls),
+              case {lists:keymember(letfun, 1, Decls),
+                    [ D || D <- Decls, aeso_syntax:get_ann(entrypoint, D, false) ]} of
+                  {true, []} -> type_error({contract_has_no_entrypoints, Con});
+                  _          -> ok
+              end;
+          {namespace, _, _, Decls} -> check_modifiers1(namespace, Decls)
+      end || C <- Contracts ],
+    destroy_and_report_type_errors(Env).
+
+-spec check_modifiers1(contract | namespace, [aeso_syntax:decl()] | aeso_syntax:decl()) -> ok.
+check_modifiers1(What, Decls) when is_list(Decls) ->
+    _ = [ check_modifiers1(What, Decl) || Decl <- Decls ],
+    ok;
+check_modifiers1(What, Decl) when element(1, Decl) == letfun; element(1, Decl) == fun_decl ->
+    Public     = aeso_syntax:get_ann(public,     Decl, false),
+    Private    = aeso_syntax:get_ann(private,    Decl, false),
+    Entrypoint = aeso_syntax:get_ann(entrypoint, Decl, false),
+    FunDecl    = element(1, Decl) == fun_decl,
+    {id, _, Name} = element(3, Decl),
+    _ = [ type_error({proto_must_be_entrypoint, Decl})    || FunDecl, Private orelse not Entrypoint, What == contract ],
+    _ = [ type_error({proto_in_namespace, Decl})          || FunDecl, What == namespace ],
+    _ = [ type_error({init_must_be_an_entrypoint, Decl})  || not Entrypoint, Name == "init", What == contract ],
+    _ = [ type_error({public_modifier_in_contract, Decl}) || Public, not Private, not Entrypoint, What == contract ],
+    _ = [ type_error({entrypoint_in_namespace, Decl})     || Entrypoint, What == namespace ],
+    _ = [ type_error({private_entrypoint, Decl})          || Private, Entrypoint ],
+    _ = [ type_error({private_and_public, Decl})          || Private, Public ],
+    ok;
+check_modifiers1(_, _) -> ok.
+
 -spec check_type(env(), aeso_syntax:type()) -> aeso_syntax:type().
 check_type(Env, T) ->
     check_type(Env, T, 0).
@@ -738,35 +796,35 @@ check_event(Env, "event", Ann, Def) ->
 check_event(_Env, _Name, _Ann, Def) -> Def.
 
 check_event_con(Env, {constr_t, Ann, Con, Args}) ->
-    IsIndexed  = fun(T) -> case aeso_syntax:get_ann(indexed, T, false) of
+    IsIndexed  = fun(T) ->
-                               true  -> indexed;
+                     T1 = unfold_types_in_type(Env, T),
-                               false -> notindexed
+                     %% `indexed` is optional but if used it has to be correctly used
-                           end end,
+                     case {is_word_type(T1), is_string_type(T1), aeso_syntax:get_ann(indexed, T, false)} of
+                         {true, _, _}        -> indexed;
+                         {false, true, true} -> type_error({indexed_type_must_be_word, T, T1});
+                         {false, true, _}    -> notindexed;
+                         {false, false, _}   -> type_error({event_arg_type_word_or_string, T, T1}), error
+                     end
+                 end,
     Indices    = lists:map(IsIndexed, Args),
     Indexed    = [ T || T <- Args, IsIndexed(T) == indexed ],
     NonIndexed = Args -- Indexed,
-    [ check_event_arg_type(Env, Ix, Type) || {Ix, Type} <- lists:zip(Indices, Args) ],
     [ type_error({event_0_to_3_indexed_values, Con}) || length(Indexed) > 3 ],
     [ type_error({event_0_to_1_string_values, Con}) || length(NonIndexed) > 1 ],
     {constr_t, [{indices, Indices} | Ann], Con, Args}.
 
-check_event_arg_type(Env, Ix, Type0) ->
-    Type = unfold_types_in_type(Env, Type0),
-    case Ix of
-        indexed    -> [ type_error({indexed_type_must_be_word, Type0, Type})   || not is_word_type(Type) ];
-        notindexed -> [ type_error({payload_type_must_be_string, Type0, Type}) || not is_string_type(Type) ]
-    end.
-
 %% Not so nice.
 is_word_type({id, _, Name}) ->
     lists:member(Name, ["int", "address", "hash", "bits", "bool"]);
 is_word_type({app_t, _, {id, _, Name}, [_, _]}) ->
     lists:member(Name, ["oracle", "oracle_query"]);
+is_word_type({bytes_t, _, N}) -> N =< 32;
 is_word_type({con, _, _}) -> true;
 is_word_type({qcon, _, _}) -> true;
 is_word_type(_) -> false.
 
 is_string_type({id, _, "string"}) -> true;
+is_string_type({bytes_t, _, N}) -> N > 32;
 is_string_type(_) -> false.
 
 -spec check_constructor_overlap(env(), aeso_syntax:con(), type()) -> ok | no_return().
@@ -913,8 +971,8 @@ lookup_name(Env, As, Id, Options) ->
             Freshen = proplists:get_value(freshen, Options, false),
             check_stateful(Env, Id, Ty),
             Ty1 = case Ty of
-                    {type_sig, _, _, _, _} -> freshen_type(typesig_to_fun_t(Ty));
+                    {type_sig, _, _, _, _} -> freshen_type(As, typesig_to_fun_t(Ty));
-                    _ when Freshen         -> freshen_type(Ty);
+                    _ when Freshen         -> freshen_type(As, Ty);
                     _                      -> Ty
                   end,
             {set_qname(QId, Id), Ty1}
@@ -1021,6 +1079,58 @@ infer_expr(Env, {list, As, Elems}) ->
     ElemType = fresh_uvar(As),
     NewElems = [check_expr(Env, X, ElemType) || X <- Elems],
     {typed, As, {list, As, NewElems}, {app_t, As, {id, As, "list"}, [ElemType]}};
+infer_expr(Env, {list_comp, As, Yield, []}) ->
+    {typed, _, TypedYield, Type} = infer_expr(Env, Yield),
+    {typed, As, {list_comp, As, TypedYield, []}, {app_t, As, {id, As, "list"}, [Type]}};
+infer_expr(Env, {list_comp, As, Yield, [{comprehension_bind, Arg, BExpr}|Rest]}) ->
+    BindVarType = fresh_uvar(As),
+    TypedBind = {typed, As2, _, TypeBExpr} = infer_expr(Env, BExpr),
+    unify( Env
+         , TypeBExpr
+         , {app_t, As, {id, As, "list"}, [BindVarType]}
+         , {list_comp, TypedBind, TypeBExpr, {app_t, As2, {id, As, "list"}, [BindVarType]}}),
+    NewE = bind_var(Arg, BindVarType, Env),
+    {typed, _, {list_comp, _, TypedYield, TypedRest}, ResType} =
+        infer_expr(NewE, {list_comp, As, Yield, Rest}),
+    { typed
+    , As
+    , {list_comp, As, TypedYield, [{comprehension_bind, {typed, Arg, BindVarType}, TypedBind}|TypedRest]}
+    , ResType};
+infer_expr(Env, {list_comp, AttrsL, Yield, [{comprehension_if, AttrsIF, Cond}|Rest]}) ->
+    NewCond = check_expr(Env, Cond, {id, AttrsIF, "bool"}),
+    {typed, _, {list_comp, _, TypedYield, TypedRest}, ResType} =
+        infer_expr(Env, {list_comp, AttrsL, Yield, Rest}),
+    { typed
+    , AttrsL
+    , {list_comp, AttrsL, TypedYield, [{comprehension_if, AttrsIF, NewCond}|TypedRest]}
+    , ResType};
+infer_expr(Env, {list_comp, AsLC, Yield, [{letval, AsLV, Pattern, Type, E}|Rest]}) ->
+    NewE = {typed, _, _, PatType} = infer_expr(Env, {typed, AsLV, E, arg_type(Type)}),
+    BlockType = fresh_uvar(AsLV),
+    {'case', _, NewPattern, NewRest} =
+        infer_case( Env
+                  , AsLC
+                  , Pattern
+                  , PatType
+                  , {list_comp, AsLC, Yield, Rest}
+                  , BlockType),
+    {typed, _, {list_comp, _, TypedYield, TypedRest}, ResType} = NewRest,
+    { typed
+    , AsLC
+    , {list_comp, AsLC, TypedYield, [{letval, AsLV, NewPattern, Type, NewE}|TypedRest]}
+    , ResType
+    };
+infer_expr(Env, {list_comp, AsLC, Yield, [Def={letfun, AsLF, _, _, _, _}|Rest]}) ->
+    {{Name, TypeSig}, LetFun} = infer_letfun(Env, Def),
+    FunT = freshen_type(AsLF, typesig_to_fun_t(TypeSig)),
+    NewE = bind_var({id, AsLF, Name}, FunT, Env),
+    {typed, _, {list_comp, _, TypedYield, TypedRest}, ResType} =
+        infer_expr(NewE, {list_comp, AsLC, Yield, Rest}),
+    { typed
+    , AsLC
+    , {list_comp, AsLC, TypedYield, [LetFun|TypedRest]}
+    , ResType
+    };
 infer_expr(Env, {typed, As, Body, Type}) ->
     Type1 = check_type(Env, Type),
     {typed, _, NewBody, NewType} = check_expr(Env, Body, Type1),
@@ -1131,7 +1241,13 @@ infer_expr(Env, {lam, Attrs, Args, Body}) ->
     {'case', _, {typed, _, {tuple, _, NewArgPatterns}, _}, NewBody} =
         infer_case(Env, Attrs, {tuple, Attrs, ArgPatterns}, {tuple_t, Attrs, ArgTypes}, Body, ResultType),
     NewArgs = [{arg, As, NewPat, NewT} || {typed, As, NewPat, NewT} <- NewArgPatterns],
-    {typed, Attrs, {lam, Attrs, NewArgs, NewBody}, {fun_t, Attrs, [], ArgTypes, ResultType}}.
+    {typed, Attrs, {lam, Attrs, NewArgs, NewBody}, {fun_t, Attrs, [], ArgTypes, ResultType}};
+infer_expr(Env, Let = {letval, Attrs, _, _, _}) ->
+    type_error({missing_body_for_let, Attrs}),
+    infer_expr(Env, {block, Attrs, [Let, abort_expr(Attrs, "missing body")]});
+infer_expr(Env, Let = {letfun, Attrs, _, _, _, _}) ->
+    type_error({missing_body_for_let, Attrs}),
+    infer_expr(Env, {block, Attrs, [Let, abort_expr(Attrs, "missing body")]}).
 
 infer_named_arg(Env, NamedArgs, {named_arg, Ann, Id, E}) ->
     CheckedExpr = {typed, _, _, ArgType} = infer_expr(Env, E),
@@ -1205,9 +1321,11 @@ infer_case(Env, Attrs, Pattern, ExprType, Branch, SwitchType) ->
 %% NewStmts = infer_block(Env, Attrs, Stmts, BlockType)
 infer_block(_Env, Attrs, [], BlockType) ->
     error({impossible, empty_block, Attrs, BlockType});
+infer_block(Env, _, [E], BlockType) ->
+    [check_expr(Env, E, BlockType)];
 infer_block(Env, Attrs, [Def={letfun, Ann, _, _, _, _}|Rest], BlockType) ->
     {{Name, TypeSig}, LetFun} = infer_letfun(Env, Def),
-    FunT = freshen_type(typesig_to_fun_t(TypeSig)),
+    FunT = freshen_type(Ann, typesig_to_fun_t(TypeSig)),
     NewE = bind_var({id, Ann, Name}, FunT, Env),
     [LetFun|infer_block(NewE, Attrs, Rest, BlockType)];
 infer_block(Env, _, [{letval, Attrs, Pattern, Type, E}|Rest], BlockType) ->
@@ -1215,8 +1333,6 @@ infer_block(Env, _, [{letval, Attrs, Pattern, Type, E}|Rest], BlockType) ->
     {'case', _, NewPattern, {typed, _, {block, _, NewRest}, _}} =
         infer_case(Env, Attrs, Pattern, PatType, {block, Attrs, Rest}, BlockType),
     [{letval, Attrs, NewPattern, Type, NewE}|NewRest];
-infer_block(Env, _, [E], BlockType) ->
-    [check_expr(Env, E, BlockType)];
 infer_block(Env, Attrs, [E|Rest], BlockType) ->
     [infer_expr(Env, E)|infer_block(Env, Attrs, Rest, BlockType)].
 
@@ -1252,6 +1368,9 @@ infer_prefix({IntOp,As}) when IntOp =:= '-' ->
     Int = {id, As, "int"},
     {fun_t, As, [], [Int], Int}.
 
+abort_expr(Ann, Str) ->
+    {app, Ann, {id, Ann, "abort"}, [{string, Ann, Str}]}.
+
 free_vars({int, _, _}) ->
     [];
 free_vars({char, _, _}) ->
@@ -1346,14 +1465,17 @@ when_option(Opt, Do) ->
 
 create_constraints() ->
     create_named_argument_constraints(),
+    create_bytes_constraints(),
     create_field_constraints().
 
 solve_constraints(Env) ->
     solve_named_argument_constraints(Env),
+    solve_bytes_constraints(Env),
     solve_field_constraints(Env).
 
 destroy_and_report_unsolved_constraints(Env) ->
     destroy_and_report_unsolved_field_constraints(Env),
+    destroy_and_report_unsolved_bytes_constraints(Env),
     destroy_and_report_unsolved_named_argument_constraints(Env).
 
 %% -- Named argument constraints --
@@ -1402,6 +1524,37 @@ destroy_and_report_unsolved_named_argument_constraints(Env) ->
     destroy_named_argument_constraints(),
     ok.
 
+%% -- Bytes constraints --
+
+-type byte_constraint() :: {is_bytes, utype()}.
+
+create_bytes_constraints() ->
+    ets_new(bytes_constraints, [bag]).
+
+get_bytes_constraints() ->
+    ets_tab2list(bytes_constraints).
+
+-spec add_bytes_constraint(byte_constraint()) -> true.
+add_bytes_constraint(Constraint) ->
+    ets_insert(bytes_constraints, Constraint).
+
+solve_bytes_constraints(_Env) ->
+    ok.
+
+destroy_bytes_constraints() ->
+    ets_delete(bytes_constraints).
+
+destroy_and_report_unsolved_bytes_constraints(Env) ->
+    [ check_bytes_constraint(Env, C) || C <- get_bytes_constraints() ],
+    destroy_bytes_constraints().
+
+check_bytes_constraint(Env, {is_bytes, Type}) ->
+    Type1 = unfold_types_in_type(Env, instantiate(Type)),
+    case Type1 of
+        {bytes_t, _, _} -> ok;
+        _               -> type_error({cannot_unify, Type1, {bytes_t, [], any}, {at, Type}})
+    end.
+
 %% -- Field constraints --
 
 create_field_constraints() ->
@@ -1811,6 +1964,10 @@ occurs_check1(R, {tuple_t, _, Ts}) ->
     occurs_check(R, Ts);
 occurs_check1(R, {named_arg_t, _, _, T, _}) ->
     occurs_check(R, T);
+occurs_check1(R, {record_t, Fields}) ->
+    occurs_check(R, Fields);
+occurs_check1(R, {field_t, _, _, T}) ->
+    occurs_check(R, T);
 occurs_check1(R, [H | T]) ->
     occurs_check(R, H) orelse occurs_check(R, T);
 occurs_check1(_, []) -> false.
@@ -1824,26 +1981,31 @@ create_freshen_tvars() ->
 destroy_freshen_tvars() ->
     ets_delete(freshen_tvars).
 
-freshen_type(Type) ->
+freshen_type(Ann, Type) ->
     create_freshen_tvars(),
-    Type1 = freshen(Type),
+    Type1 = freshen(Ann, Type),
     destroy_freshen_tvars(),
     Type1.
 
-freshen({tvar, As, Name}) ->
+freshen(Type) ->
+    freshen(aeso_syntax:get_ann(Type), Type).
+
+freshen(Ann, {tvar, _, Name}) ->
     NewT = case ets_lookup(freshen_tvars, Name) of
-               [] ->
+               []          -> fresh_uvar(Ann);
-                   fresh_uvar(As);
+               [{Name, T}] -> T
-               [{Name, T}] ->
-                   T
            end,
     ets_insert(freshen_tvars, {Name, NewT}),
     NewT;
-freshen(T) when is_tuple(T) ->
+freshen(Ann, {bytes_t, _, any}) ->
-    list_to_tuple(freshen(tuple_to_list(T)));
+    X = fresh_uvar(Ann),
-freshen([A|B]) ->
+    add_bytes_constraint({is_bytes, X}),
-    [freshen(A)|freshen(B)];
+    X;
-freshen(X) ->
+freshen(Ann, T) when is_tuple(T) ->
+    list_to_tuple(freshen(Ann, tuple_to_list(T)));
+freshen(Ann, [A | B]) ->
+    [freshen(Ann, A) | freshen(Ann, B)];
+freshen(_, X) ->
     X.
 
 %% Dereferences all uvars and replaces the uninstantiated ones with a
@@ -1852,8 +2014,8 @@ instantiate(E) ->
     instantiate1(dereference(E)).
 
 instantiate1({uvar, Attr, R}) ->
-    Next = proplists:get_value(next, ets_lookup(type_vars, next), 1),
+    Next = proplists:get_value(next, ets_lookup(type_vars, next), 0),
-    TVar = {tvar, Attr, "'" ++ integer_to_list(Next)},
+    TVar = {tvar, Attr, "'" ++ integer_to_tvar(Next)},
     ets_insert(type_vars, [{next, Next + 1}, {R, TVar}]),
     TVar;
 instantiate1({fun_t, Ann, Named, Args, Ret}) ->
@@ -1873,6 +2035,12 @@ instantiate1([A|B]) ->
 instantiate1(X) ->
     X.
 
+integer_to_tvar(X) when X < 26 ->
+    [$a + X];
+integer_to_tvar(X) ->
+    [integer_to_tvar(X div 26)] ++ [$a + (X rem 26)].
+
+
 %% Save unification failures for error messages.
 
 cannot_unify(A, B, When) ->
@@ -1995,7 +2163,7 @@ pp_error({duplicate_definition, Name, Locs}) ->
 pp_error({duplicate_scope, Kind, Name, OtherKind, L}) ->
     io_lib:format("The ~p ~s (at ~s) has the same name as a ~p at ~s\n",
                   [Kind, pp(Name), pp_loc(Name), OtherKind, pp_loc(L)]);
-pp_error({include, {string, Pos, Name}}) ->
+pp_error({include, _, {string, Pos, Name}}) ->
     io_lib:format("Include of '~s' at ~s\nnot allowed, include only allowed at top level.\n",
                   [binary_to_list(Name), pp_loc(Pos)]);
 pp_error({namespace, _Pos, {con, Pos, Name}, _Def}) ->
@@ -2016,10 +2184,52 @@ pp_error({init_depends_on_state, Which, [_Init | Chain]}) ->
                   [if Which == put -> "write"; true -> "read" end,
                    [ io_lib:format("  - ~s (at ~s)~s\n", [Fun, pp_loc(Ann), WhichCalls(Fun)])
                      || {[_, Fun], Ann} <- Chain]]);
+pp_error({missing_body_for_let, Ann}) ->
+    io_lib:format("Let binding at ~s must be followed by an expression\n", [pp_loc(Ann)]);
+pp_error({public_modifier_in_contract, Decl}) ->
+    Decl1 = mk_entrypoint(Decl),
+    io_lib:format("Use 'entrypoint' instead of 'function' for public function ~s (at ~s):\n~s\n",
+                  [pp_expr("", element(3, Decl)), pp_loc(Decl),
+                   prettypr:format(prettypr:nest(2, aeso_pretty:decl(Decl1)))]);
+pp_error({init_must_be_an_entrypoint, Decl}) ->
+    Decl1 = mk_entrypoint(Decl),
+    io_lib:format("The init function (at ~s) must be an entrypoint:\n~s\n",
+                  [pp_loc(Decl),
+                   prettypr:format(prettypr:nest(2, aeso_pretty:decl(Decl1)))]);
+pp_error({proto_must_be_entrypoint, Decl}) ->
+    Decl1 = mk_entrypoint(Decl),
+    io_lib:format("Use 'entrypoint' for declaration of ~s (at ~s):\n~s\n",
+                  [pp_expr("", element(3, Decl)), pp_loc(Decl),
+                   prettypr:format(prettypr:nest(2, aeso_pretty:decl(Decl1)))]);
+pp_error({proto_in_namespace, Decl}) ->
+    io_lib:format("Namespaces cannot contain function prototypes (at ~s).\n",
+                  [pp_loc(Decl)]);
+pp_error({entrypoint_in_namespace, Decl}) ->
+    io_lib:format("Namespaces cannot contain entrypoints (at ~s). Use 'function' instead.\n",
+                  [pp_loc(Decl)]);
+pp_error({private_entrypoint, Decl}) ->
+    io_lib:format("The entrypoint ~s (at ~s) cannot be private. Use 'function' instead.\n",
+                  [pp_expr("", element(3, Decl)), pp_loc(Decl)]);
+pp_error({private_and_public, Decl}) ->
+    io_lib:format("The function ~s (at ~s) cannot be both public and private.\n",
+                  [pp_expr("", element(3, Decl)), pp_loc(Decl)]);
+pp_error({contract_has_no_entrypoints, Con}) ->
+    io_lib:format("The contract ~s (at ~s) has no entrypoints. Since Sophia version 3.2, public\n"
+                  "contract functions must be declared with the 'entrypoint' keyword instead of\n"
+                  "'function'.\n", [pp_expr("", Con), pp_loc(Con)]);
+pp_error({unbound_type, Type}) ->
+    io_lib:format("Unbound type ~s (at ~s).\n", [pp_type("", Type), pp_loc(Type)]);
 pp_error(Err) ->
     io_lib:format("Unknown error: ~p\n", [Err]).
 
+mk_entrypoint(Decl) ->
+    Ann   = [entrypoint | lists:keydelete(public, 1,
+                          lists:keydelete(private, 1,
+                            aeso_syntax:get_ann(Decl))) -- [public, private]],
+    aeso_syntax:set_ann(Ann, Decl).
+
 pp_when({todo, What}) -> io_lib:format("[TODO] ~p\n", [What]);
+pp_when({at, Ann}) -> io_lib:format("at ~s\n", [pp_loc(Ann)]);
 pp_when({check_typesig, Name, Inferred, Given}) ->
     io_lib:format("when checking the definition of ~s\n"
                   "  inferred type: ~s\n"
@@ -2100,6 +2310,13 @@ pp_when({check_expr, Expr, Inferred0, Expected0}) ->
 pp_when({checking_init_type, Ann}) ->
     io_lib:format("when checking that 'init' returns a value of type 'state' at ~s\n",
                   [pp_loc(Ann)]);
+pp_when({list_comp, BindExpr, Inferred0, Expected0}) ->
+    {Inferred, Expected} = instantiate({Inferred0, Expected0}),
+    io_lib:format("when checking rvalue of list comprehension binding at ~s\n~s\n"
+                  "against type \n~s\n",
+                  [pp_loc(BindExpr), pp_typed("  ", BindExpr, Inferred), pp_type("  ", Expected)]
+                 );
+
 pp_when(unknown) -> "".
 
 -spec pp_why_record(why_record()) -> iolist().
@@ -2170,8 +2387,11 @@ pp({uvar, _, Ref}) ->
     ["?u" | integer_to_list(erlang:phash2(Ref, 16384)) ];
 pp({tvar, _, Name}) ->
     Name;
+pp({tuple_t, _, []}) ->
+    "unit";
 pp({tuple_t, _, Cpts}) ->
-    ["(", pp(Cpts), ")"];
+    ["(", string:join(lists:map(fun pp/1, Cpts), " * "), ")"];
+pp({bytes_t, _, any}) -> "bytes(_)";
 pp({bytes_t, _, Len}) ->
     ["bytes(", integer_to_list(Len), ")"];
 pp({app_t, _, T, []}) ->
@@ -2183,7 +2403,9 @@ pp({named_arg_t, _, Name, Type, Default}) ->
 pp({fun_t, _, Named = {uvar, _, _}, As, B}) ->
     ["(", pp(Named), " | ", pp(As), ") => ", pp(B)];
 pp({fun_t, _, Named, As, B}) when is_list(Named) ->
-    ["(", pp(Named ++ As), ") => ", pp(B)].
+    ["(", pp(Named ++ As), ") => ", pp(B)];
+pp(Other) ->
+    io_lib:format("~p", [Other]).
 
 %% -- Pre-type checking desugaring -------------------------------------------
 

src/aeso_ast_to_fcode.erl

@@ -16,11 +16,11 @@
 
 -type option() :: term().
 
--type attribute() :: stateful | pure.
+-type attribute() :: stateful | payable | pure | private.
 
 -type fun_name() :: {entrypoint, binary()}
                   | {local_fun, [string()]}
-                  | init.
+                  | init | event.
 -type var_name() :: string().
 -type sophia_name() :: [string()].
 
@@ -31,21 +31,26 @@
               map_get | map_get_d | map_set | map_from_list | map_to_list |
               map_delete | map_member | map_size | string_length |
               string_concat | bits_set | bits_clear | bits_test | bits_sum |
-              bits_intersection | bits_union | bits_difference.
+              bits_intersection | bits_union | bits_difference |
+              contract_to_address | crypto_verify_sig | crypto_verify_sig_secp256k1 |
+              crypto_sha3 | crypto_sha256 | crypto_blake2b |
+              crypto_ecverify_secp256k1 | crypto_ecrecover_secp256k1.
 
 -type flit() :: {int, integer()}
               | {string, binary()}
+              | {bytes, binary()}
               | {account_pubkey, binary()}
               | {contract_pubkey, binary()}
               | {oracle_pubkey, binary()}
               | {oracle_query_id, binary()}
-              | {bool, false | true}.
+              | {bool, false | true}
+              | {typerep, ftype()}.
 
 -type fexpr() :: {lit, flit()}
                | nil
                | {var, var_name()}
                | {def, fun_name(), [fexpr()]}
-               | {remote, fexpr(), fun_name(), [fexpr()]}
+               | {remote, [ftype()], ftype(), fexpr(), fun_name(), [fexpr()]}
                | {builtin, builtin(), [fexpr()]}
                | {con, arities(), tag(), [fexpr()]}
                | {tuple, [fexpr()]}
@@ -60,7 +65,7 @@
                %% lambdas) are generated by the fcode compiler, but translated
                %% to closures by the lambda lifter.
                | {def_u, fun_name(), arity()}
-               | {remote_u, fexpr(), fun_name(), arity()}
+               | {remote_u, [ftype()], ftype(), fexpr(), fun_name()}
                | {builtin_u, builtin(), arity()}
                | {lam, [var_name()], fexpr()}.
 
@@ -85,17 +90,16 @@
                | {map, ftype(), ftype()}
                | {tuple, [ftype()]}
                | address
-               | hash
+               | {bytes, non_neg_integer()}
-               | signature
                | contract
-               | oracle
+               | {oracle, ftype(), ftype()} %% Query type, Response type
                | oracle_query
                | name
                | channel
                | bits
                | {variant, [[ftype()]]}
                | {function, [ftype()], ftype()}
-               | any.
+               | any | {tvar, var_name()}.
 
 -type fun_def() :: #{ attrs  := [attribute()],
                       args   := [{var_name(), ftype()}],
@@ -105,7 +109,8 @@
 -type fcode() :: #{ contract_name := string(),
                     state_type    := ftype(),
                     event_type    := ftype() | none,
-                    functions     := #{ fun_name() => fun_def() } }.
+                    functions     := #{ fun_name() => fun_def() },
+                    payable       := boolean() }.
 
 -type type_def() :: fun(([ftype()]) -> ftype()).
 
@@ -124,15 +129,17 @@
                  | {namespace, string()}
                  | {abstract_contract, string()}.
 
--type env() :: #{ type_env  := type_env(),
+-type env() :: #{ type_env   := type_env(),
-                  fun_env   := fun_env(),
+                  fun_env    := fun_env(),
-                  con_env   := con_env(),
+                  con_env    := con_env(),
-                  builtins  := builtins(),
+                  event_type => aeso_syntax:typedef(),
-                  options   := [option()],
+                  builtins   := builtins(),
-                  context   => context(),
+                  options    := [option()],
-                  vars      => [var_name()],
+                  context    => context(),
-                  functions := #{ fun_name() => fun_def() } }.
+                  vars       => [var_name()],
+                  functions  := #{ fun_name() => fun_def() } }.
 
+-define(HASH_BYTES, 32).
 %% -- Entrypoint -------------------------------------------------------------
 
 %% Main entrypoint. Takes typed syntax produced by aeso_ast_infer_types:infer/1,2
@@ -168,27 +175,30 @@ builtins() ->
     MkName = fun(NS, Fun) ->
                 list_to_atom(string:to_lower(string:join(NS ++ [Fun], "_")))
              end,
-    Scopes = [{[],           [{"abort", 1}]},
+    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}]},
-              {["Contract"], [{"address", none}, {"balance", none}]},
+              {["Contract"], [{"address", none}, {"balance", none}, {"creator", none}]},
               {["Call"],     [{"origin", none}, {"caller", none}, {"value", none}, {"gas_price", none},
                               {"gas_left", 0}]},
               {["Oracle"],   [{"register", 4}, {"query_fee", 1}, {"query", 5}, {"get_question", 2},
-                              {"respond", 4}, {"extend", 3}, {"get_answer", 2}]},
+                              {"respond", 4}, {"extend", 3}, {"get_answer", 2},
+                              {"check", 1}, {"check_query", 2}]},
               {["AENS"],     [{"resolve", 2}, {"preclaim", 3}, {"claim", 4}, {"transfer", 4},
                               {"revoke", 3}]},
               {["Map"],      [{"from_list", 1}, {"to_list", 1}, {"lookup", 2},
                               {"lookup_default", 3}, {"delete", 2}, {"member", 2}, {"size", 1}]},
-              {["Crypto"],   [{"ecverify", 3}, {"ecverify_secp256k1", 3}, {"sha3", 1},
+              {["Crypto"],   [{"verify_sig", 3}, {"verify_sig_secp256k1", 3},
-                              {"sha256", 1}, {"blake2b", 1}]},
+                              {"ecverify_secp256k1", 3}, {"ecrecover_secp256k1", 2},
+                              {"sha3", 1}, {"sha256", 1}, {"blake2b", 1}]},
               {["Auth"],     [{"tx_hash", none}]},
               {["String"],   [{"length", 1}, {"concat", 2}, {"sha3", 1}, {"sha256", 1}, {"blake2b", 1}]},
               {["Bits"],     [{"set", 2}, {"clear", 2}, {"test", 2}, {"sum", 1}, {"intersection", 2},
                               {"union", 2}, {"difference", 2}, {"none", none}, {"all", none}]},
+              {["Bytes"],    [{"to_int", 1}, {"to_str", 1}]},
               {["Int"],      [{"to_str", 1}]},
-              {["Address"],  [{"to_str", 1}]}
+              {["Address"],  [{"to_str", 1}, {"is_oracle", 1}, {"is_contract", 1}, {"is_payable", 1}]}
              ],
     maps:from_list([ {NS ++ [Fun], {MkName(NS, Fun), Arity}}
                      || {NS, Funs} <- Scopes,
@@ -208,7 +218,7 @@ init_type_env() ->
        ["address"]      => ?type(address),
        ["hash"]         => ?type(hash),
        ["signature"]    => ?type(signature),
-       ["oracle"]       => ?type(_, _, oracle),
+       ["oracle"]       => ?type(Q, R, {oracle, Q, R}),
        ["oracle_query"] => ?type(_, _, oracle_query),    %% TODO: not in Fate
        ["list"]         => ?type(T, {list, T}),
        ["map"]          => ?type(K, V, {map, K, V}),
@@ -216,23 +226,29 @@ init_type_env() ->
        ["Chain", "ttl"] => ?type({variant, [[integer], [integer]]})
      }.
 
+is_no_code(Env) ->
+    proplists:get_value(no_code, maps:get(options, Env, []), false).
+
 %% -- Compilation ------------------------------------------------------------
 
 -spec to_fcode(env(), aeso_syntax:ast()) -> fcode().
-to_fcode(Env, [{contract, _, {con, _, Main}, Decls}]) ->
+to_fcode(Env, [{contract, Attrs, {con, _, Main}, Decls}]) ->
     #{ builtins := Builtins } = Env,
     MainEnv = Env#{ context  => {main_contract, Main},
                     builtins => Builtins#{[Main, "state"]          => {get_state, none},
                                           [Main, "put"]            => {set_state, 1},
-                                          [Main, "Chain", "event"] => {event, 1}} },
+                                          [Main, "Chain", "event"] => {chain_event, 1}} },
     #{ functions := Funs } = Env1 =
         decls_to_fcode(MainEnv, Decls),
     StateType = lookup_type(Env1, [Main, "state"], [], {tuple, []}),
     EventType = lookup_type(Env1, [Main, "event"], [], none),
+    Payable   = proplists:get_value(payable, Attrs, false),
     #{ contract_name => Main,
        state_type    => StateType,
        event_type    => EventType,
-       functions     => Funs };
+       payable       => Payable,
+       functions     => add_init_function(Env1, StateType,
+                        add_event_function(Env1, EventType, Funs)) };
 to_fcode(Env, [{contract, _, {con, _, Con}, Decls} | Code]) ->
     Env1 = decls_to_fcode(Env#{ context => {abstract_contract, Con} }, Decls),
     to_fcode(Env1, Code);
@@ -254,6 +270,11 @@ decls_to_fcode(Env, Decls) ->
 
 -spec decl_to_fcode(env(), aeso_syntax:decl()) -> env().
 decl_to_fcode(Env, {type_decl, _, _, _}) -> Env;
+decl_to_fcode(Env = #{context := {main_contract, _}}, {fun_decl, Ann, {id, _, Name}, _}) ->
+    case is_no_code(Env) of
+        false -> fcode_error({missing_definition, Name, lists:keydelete(entrypoint, 1, Ann)});
+        true  -> Env
+    end;
 decl_to_fcode(Env, {fun_decl, _, _, _})  -> Env;
 decl_to_fcode(Env, {type_def, _Ann, Name, Args, Def}) ->
     typedef_to_fcode(Env, Name, Args, Def);
@@ -298,7 +319,11 @@ typedef_to_fcode(Env, {id, _, Name}, Xs, Def) ->
             _ -> #{}
         end,
     Env1 = bind_constructors(Env, Constructors),
-    bind_type(Env1, Q, FDef).
+    Env2 = case Name of
+             "event" -> Env1#{ event_type => Def };
+             _       -> Env1
+           end,
+    bind_type(Env2, Q, FDef).
 
 -spec type_to_fcode(env(), aeso_syntax:type()) -> ftype().
 type_to_fcode(Env, Type) ->
@@ -315,10 +340,10 @@ type_to_fcode(Env, Sub, {tuple_t, _, Types}) ->
 type_to_fcode(Env, Sub, {record_t, Fields}) ->
     FieldType = fun({field_t, _, _, Ty}) -> Ty end,
     type_to_fcode(Env, Sub, {tuple_t, [], lists:map(FieldType, Fields)});
-type_to_fcode(_Env, _Sub, {bytes_t, _, _N}) ->
+type_to_fcode(_Env, _Sub, {bytes_t, _, N}) ->
-    string; %% TODO: add bytes type to FATE?
+    {bytes, N};
 type_to_fcode(_Env, Sub, {tvar, _, X}) ->
-    maps:get(X, Sub, any);
+    maps:get(X, Sub, {tvar, X});
 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],
@@ -330,6 +355,19 @@ type_to_fcode(_Env, _Sub, Type) ->
 args_to_fcode(Env, Args) ->
     [ {Name, type_to_fcode(Env, Type)} || {arg, _, {id, _, Name}, Type} <- Args ].
 
+-define(make_let(X, Expr, Body),
+        make_let(Expr, fun(X) -> Body end)).
+
+make_let(Expr, Body) ->
+    case Expr of
+        {var, _}         -> Body(Expr);
+        {lit, {int, _}}  -> Body(Expr);
+        {lit, {bool, _}} -> Body(Expr);
+        _                ->
+            X = fresh_name(),
+            {'let', X, Expr, Body({var, X})}
+    end.
+
 -spec expr_to_fcode(env(), aeso_syntax:expr()) -> fexpr().
 expr_to_fcode(Env, {typed, _, Expr, Type}) ->
     expr_to_fcode(Env, Type, Expr);
@@ -347,8 +385,7 @@ expr_to_fcode(_Env, _Type, {account_pubkey,  _, K}) -> {lit, {account_pubkey, K}
 expr_to_fcode(_Env, _Type, {contract_pubkey, _, K}) -> {lit, {contract_pubkey, K}};
 expr_to_fcode(_Env, _Type, {oracle_pubkey,   _, K}) -> {lit, {oracle_pubkey, K}};
 expr_to_fcode(_Env, _Type, {oracle_query_id, _, K}) -> {lit, {oracle_query_id, K}};
-
+expr_to_fcode(_Env, _Type, {bytes,           _, B}) -> {lit, {bytes, B}};
-expr_to_fcode(_Env, _Type, {bytes, _, Bin}) -> {lit, {string, Bin}};
 
 %% Variables
 expr_to_fcode(Env, _Type, {id, _, X})  -> resolve_var(Env, [X]);
@@ -372,10 +409,13 @@ expr_to_fcode(Env, _Type, {tuple, _, Es}) ->
 %% Records
 expr_to_fcode(Env, Type, {proj, _Ann, Rec = {typed, _, _, RecType}, {id, _, X}}) ->
     case RecType of
+        {con, _, _} when X == "address" ->
+            {op, contract_to_address, [expr_to_fcode(Env, Rec)]};
         {con, _, _} ->
-            {fun_t, _, Named, Args, _} = Type,
+            {fun_t, _, _, Args, Ret} = Type,
-            Arity = length(Named) + length(Args),
+            FArgs = [type_to_fcode(Env, Arg) || Arg <- Args],
-            {remote_u, expr_to_fcode(Env, Rec), {entrypoint, list_to_binary(X)}, Arity};
+            {remote_u, FArgs, type_to_fcode(Env, Ret), expr_to_fcode(Env, Rec),
+                       {entrypoint, list_to_binary(X)}};
         {record_t, _} ->
             {proj, expr_to_fcode(Env, Rec), field_index(Rec, X)}
     end;
@@ -413,19 +453,28 @@ expr_to_fcode(Env, _Type, {list, _, Es}) ->
     lists:foldr(fun(E, L) -> {op, '::', [expr_to_fcode(Env, E), L]} end,
                 nil, Es);
 
+expr_to_fcode(Env, _Type, {list_comp, _, Yield, []}) ->
+    {op, '::', [expr_to_fcode(Env, Yield), nil]};
+expr_to_fcode(Env, _Type, {list_comp, As, Yield, [{comprehension_bind, {typed, {id, _, Arg}, _}, BindExpr}|Rest]}) ->
+    Env1 = bind_var(Env, Arg),
+    Bind = {lam, [Arg], expr_to_fcode(Env1, {list_comp, As, Yield, Rest})},
+    {def_u, FlatMap, _} = resolve_fun(Env, ["List", "flat_map"]),
+    {def, FlatMap, [Bind, expr_to_fcode(Env, BindExpr)]};
+expr_to_fcode(Env, Type, {list_comp, As, Yield, [{comprehension_if, _, Cond}|Rest]}) ->
+    make_if(expr_to_fcode(Env, Cond),
+            expr_to_fcode(Env, Type, {list_comp, As, Yield, Rest}),
+            nil
+           );
+expr_to_fcode(Env, Type, {list_comp, As, Yield, [LV = {letval, _, _, _, _}|Rest]}) ->
+    expr_to_fcode(Env, Type, {block, As, [LV, {list_comp, As, Yield, Rest}]});
+expr_to_fcode(Env, Type, {list_comp, As, Yield, [LF = {letfun, _, _, _, _, _}|Rest]}) ->
+    expr_to_fcode(Env, Type, {block, As, [LF, {list_comp, As, Yield, Rest}]});
+
 %% Conditionals
 expr_to_fcode(Env, _Type, {'if', _, Cond, Then, Else}) ->
-    Switch = fun(X) ->
+    make_if(expr_to_fcode(Env, Cond),
-                 {switch, {split, boolean, X,
+            expr_to_fcode(Env, Then),
-                    [{'case', {bool, false}, {nosplit, expr_to_fcode(Env, Else)}},
+            expr_to_fcode(Env, Else));
-                     {'case', {bool, true},  {nosplit, expr_to_fcode(Env, Then)}}]}}
-             end,
-    case Cond of
-        {var, X} -> Switch(X);
-        _          ->
-            X = fresh_name(),
-            {'let', X, expr_to_fcode(Env, Cond), Switch(X)}
-    end;
 
 %% Switch
 expr_to_fcode(Env, _, {switch, _, Expr = {typed, _, E, Type}, Alts}) ->
@@ -457,13 +506,30 @@ expr_to_fcode(Env, _Type, {app, _Ann, {Op, _}, [A]}) when is_atom(Op) ->
     end;
 
 %% Function calls
-expr_to_fcode(Env, _Type, {app, _Ann, Fun = {typed, _, _, {fun_t, _, NamedArgsT, _, _}}, Args}) ->
+expr_to_fcode(Env, Type, {app, _Ann, Fun = {typed, _, _, {fun_t, _, NamedArgsT, _, _}}, 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, _} when B =:= oracle_query;
+                               B =:= oracle_get_question;
+                               B =:= oracle_get_answer;
+                               B =:= oracle_respond;
+                               B =:= oracle_register;
+                               B =:= oracle_check;
+                               B =:= oracle_check_query ->
+            %% Get the type of the oracle from the args or the expression itself
+            OType = get_oracle_type(B, Type, Args1),
+            {oracle, QType, RType} = type_to_fcode(Env, OType),
+            TypeArgs = [{lit, {typerep, QType}}, {lit, {typerep, RType}}],
+            builtin_to_fcode(B, FArgs ++ TypeArgs);
+        {builtin_u, B, _} when B =:= aens_resolve ->
+            %% Get the type we are assuming the name resolves to
+            AensType = type_to_fcode(Env, Type),
+            TypeArgs = [{lit, {typerep, AensType}}],
+            builtin_to_fcode(B, FArgs ++ TypeArgs);
         {builtin_u, B, _Ar}       -> builtin_to_fcode(B, FArgs);
         {def_u, F, _Ar}           -> {def, F, FArgs};
-        {remote_u, Ct, RFun, _Ar} -> {remote, Ct, RFun, FArgs};
+        {remote_u, ArgsT, RetT, Ct, RFun} -> {remote, ArgsT, RetT, Ct, RFun, FArgs};
         FFun ->
             %% FFun is a closure, with first component the function name and
             %% second component the environment
@@ -484,19 +550,26 @@ expr_to_fcode(Env, Type, {map, Ann, KVs}) ->
     Fields = [{field, Ann, [{map_get, Ann, K}], V} || {K, V} <- KVs],
     expr_to_fcode(Env, Type, {map, Ann, {map, Ann, []}, Fields});
 expr_to_fcode(Env, _Type, {map, _, Map, KVs}) ->
-    X    = fresh_name(),
+    ?make_let(Map1, expr_to_fcode(Env, Map),
-    Map1 = {var, X},
-    {'let', X, expr_to_fcode(Env, Map),
         lists:foldr(fun(Fld, M) ->
                         case Fld of
                             {field, _, [{map_get, _, K}], V} ->
                                 {op, map_set, [M, expr_to_fcode(Env, K), expr_to_fcode(Env, V)]};
-                            {field_upd, _, [{map_get, _, K}], {typed, _, {lam, _, [{arg, _, {id, _, Z}, _}], V}, _}} ->
+                            {field_upd, _, [MapGet], {typed, _, {lam, _, [{arg, _, {id, _, Z}, _}], V}, _}} when element(1, MapGet) == map_get ->
-                                Y = fresh_name(),
+                                [map_get, _, K | Default] = tuple_to_list(MapGet),
-                                {'let', Y, expr_to_fcode(Env, K),
+                                ?make_let(Key, expr_to_fcode(Env, K),
-                                {'let', Z, {op, map_get, [Map1, {var, Y}]},
+                                begin
-                                {op, map_set, [M, {var, Y}, expr_to_fcode(bind_var(Env, Z), V)]}}}
+                                    %% Z might shadow Map1 or Key
-                        end end, Map1, KVs)};
+                                    Z1 = fresh_name(),
+                                    GetExpr =
+                                        case Default of
+                                            []  -> {op, map_get, [Map1, Key]};
+                                            [D] -> {op, map_get_d, [Map1, Key, expr_to_fcode(Env, D)]}
+                                        end,
+                                    {'let', Z1, GetExpr,
+                                    {op, map_set, [M, Key, rename([{Z, Z1}], expr_to_fcode(bind_var(Env, Z), V))]}}
+                                end)
+                        end end, Map1, KVs));
 expr_to_fcode(Env, _Type, {map_get, _, Map, Key}) ->
     {op, map_get, [expr_to_fcode(Env, Map), expr_to_fcode(Env, Key)]};
 expr_to_fcode(Env, _Type, {map_get, _, Map, Key, Def}) ->
@@ -510,6 +583,23 @@ expr_to_fcode(Env, _Type, {lam, _, Args, Body}) ->
 expr_to_fcode(_Env, Type, Expr) ->
     error({todo, {Expr, ':', Type}}).
 
+make_if({var, X}, Then, Else) ->
+    {switch, {split, boolean, X,
+        [{'case', {bool, false}, {nosplit, Else}},
+         {'case', {bool, true},  {nosplit, Then}}]}};
+make_if(Cond, Then, Else) ->
+    X = fresh_name(),
+    {'let', X, Cond, make_if({var, X}, Then, Else)}.
+
+
+get_oracle_type(oracle_register,     OType, _Args) -> OType;
+get_oracle_type(oracle_query,        _Type, [{typed, _, _Expr, OType} | _])   -> OType;
+get_oracle_type(oracle_get_question, _Type, [{typed, _, _Expr, OType} | _])   -> OType;
+get_oracle_type(oracle_get_answer,   _Type, [{typed, _, _Expr, OType} | _])   -> OType;
+get_oracle_type(oracle_check,        _Type, [{typed, _, _Expr, OType}])       -> OType;
+get_oracle_type(oracle_check_query,  _Type, [{typed, _, _Expr, OType} | _])   -> OType;
+get_oracle_type(oracle_respond,      _Type, [_, {typed, _,_Expr, OType} | _]) -> OType.
+
 %% -- Pattern matching --
 
 -spec alts_to_fcode(env(), ftype(), var_name(), [aeso_syntax:alt()]) -> fsplit().
@@ -736,10 +826,25 @@ op_builtins() ->
     [map_from_list, map_to_list, map_delete, map_member, map_size,
      string_length, string_concat, string_sha3, string_sha256, string_blake2b,
      bits_set, bits_clear, bits_test, bits_sum, bits_intersection, bits_union,
-     bits_difference, int_to_str, address_to_str].
+     bits_difference, int_to_str, address_to_str, crypto_verify_sig,
+     crypto_verify_sig_secp256k1, crypto_sha3, crypto_sha256, crypto_blake2b,
+     crypto_ecverify_secp256k1, crypto_ecrecover_secp256k1
+    ].
 
-builtin_to_fcode(map_lookup, [Key, Map]) ->
+builtin_to_fcode(require, [Cond, Msg]) ->
-    {op, map_get, [Map, Key]};
+    make_if(Cond, {tuple, []}, {builtin, abort, [Msg]});
+builtin_to_fcode(chain_event, [Event]) ->
+    {def, event, [Event]};
+builtin_to_fcode(map_delete, [Key, Map]) ->
+    {op, map_delete, [Map, Key]};
+builtin_to_fcode(map_member, [Key, Map]) ->
+    {op, map_member, [Map, Key]};
+builtin_to_fcode(map_lookup, [Key0, Map0]) ->
+    ?make_let(Key, Key0,
+    ?make_let(Map, Map0,
+     make_if({op, map_member, [Map, Key]},
+             {con, [0, 1], 1, [{op, map_get, [Map, Key]}]},
+             {con, [0, 1], 0, []})));
 builtin_to_fcode(map_lookup_default, [Key, Map, Def]) ->
     {op, map_get_d, [Map, Key, Def]};
 builtin_to_fcode(Builtin, Args) ->
@@ -748,6 +853,62 @@ builtin_to_fcode(Builtin, Args) ->
         false -> {builtin, Builtin, Args}
     end.
 
+%% -- Init function --
+
+add_init_function(Env, StateType, Funs0) ->
+    case is_no_code(Env) of
+        true  -> Funs0;
+        false ->
+            Funs     = add_default_init_function(Env, StateType, Funs0),
+            InitName = {entrypoint, <<"init">>},
+            InitFun  = #{ args := InitArgs } = maps:get(InitName, Funs, none),
+            Vars     = [ {var, X} || {X, _} <- InitArgs ],
+            Funs#{ init => InitFun#{ return => {tuple, []},
+                                     body   => {builtin, set_state, [{def, InitName, Vars}]} } }
+    end.
+
+add_default_init_function(_Env, StateType, Funs) ->
+    InitName = {entrypoint, <<"init">>},
+    case maps:get(InitName, Funs, none) of
+        %% Only add default init function if state is unit.
+        none when StateType == {tuple, []} ->
+            Funs#{ InitName => #{attrs  => [],
+                                 args   => [],
+                                 return => {tuple, []},
+                                 body   => {tuple, []}} };
+        none -> fcode_error(missing_init_function);
+        _    -> Funs
+    end.
+
+%% -- Event function --
+
+add_event_function(_Env, none, Funs) -> Funs;
+add_event_function(Env, EventFType, Funs) ->
+    Funs#{ event => event_function(Env, EventFType) }.
+
+event_function(_Env = #{event_type := {variant_t, EventCons}}, EventType = {variant, FCons}) ->
+    Cons = [ {Name, I - 1, proplists:get_value(indices, Ann)}
+             || {I, {constr_t, Ann, {con, _, Name}, _}} <- indexed(EventCons) ],
+    Arities = [length(Ts) || Ts <- FCons],
+    Case = fun({Name, Tag, Ixs}) ->
+                {ok, HashValue} = eblake2:blake2b(?HASH_BYTES, list_to_binary(Name)),
+                Hash = {lit, {bytes, HashValue}},
+                Vars = [ "arg" ++ integer_to_list(I) || I <- lists:seq(1, length(Ixs)) ],
+                IVars = lists:zip(Ixs, Vars),
+                Payload =
+                    case [ V || {notindexed, V} <- IVars ] of
+                        []  -> {lit, {string, <<>>}};
+                        [V] -> {var, V}
+                    end,
+                Indices = [ {var, V} || {indexed, V} <- IVars ],
+                Body = {builtin, chain_event, [Payload, Hash | Indices]},
+                {'case', {con, Arities, Tag, Vars}, {nosplit, Body}}
+           end,
+    #{ attrs  => [private],
+       args   => [{"e", EventType}],
+       return => {tuple, []},
+       body   => {switch, {split, EventType, "e", lists:map(Case, Cons)}} }.
+
 %% -- Lambda lifting ---------------------------------------------------------
 %% The expr_to_fcode compiler lambda expressions to {lam, Xs, Body}, but in
 %% FATE we can only call top-level functions, so we need to lift the lambda to
@@ -805,12 +966,13 @@ lambda_lift_expr({Tag, F, Ar}) when Tag == def_u; Tag == builtin_u ->
                def_u     -> {def, F, Args}
            end,
     make_closure([], Xs, Body);
-lambda_lift_expr({remote_u, Ct, F, Ar}) ->
+lambda_lift_expr({remote_u, ArgsT, RetT, Ct, F}) ->
     FVs  = free_vars(Ct),
     Ct1  = lambda_lift_expr(Ct),
-    Xs   = [ lists:concat(["arg", I]) || I <- lists:seq(1, Ar) ],
+    GasAndValueArgs = 2,
+    Xs   = [ lists:concat(["arg", I]) || I <- lists:seq(1, length(ArgsT) + GasAndValueArgs) ],
     Args = [{var, X} || X <- Xs],
-    make_closure(FVs, Xs, {remote, Ct1, F, Args});
+    make_closure(FVs, Xs, {remote, ArgsT, RetT, Ct1, F, Args});
 lambda_lift_expr(Expr) ->
     case Expr of
         {lit, _}               -> Expr;
@@ -819,7 +981,7 @@ lambda_lift_expr(Expr) ->
         {closure, _, _}        -> Expr;
         {def, D, As}           -> {def, D, lambda_lift_exprs(As)};
         {builtin, B, As}       -> {builtin, B, lambda_lift_exprs(As)};
-        {remote, Ct, F, As}    -> {remote, lambda_lift_expr(Ct), F, lambda_lift_exprs(As)};
+        {remote, ArgsT, RetT, Ct, F, As} -> {remote, ArgsT, RetT, lambda_lift_expr(Ct), F, lambda_lift_exprs(As)};
         {con, Ar, C, As}       -> {con, Ar, C, lambda_lift_exprs(As)};
         {tuple, As}            -> {tuple, lambda_lift_exprs(As)};
         {proj, A, I}           -> {proj, lambda_lift_expr(A), I};
@@ -845,12 +1007,54 @@ lambda_lift_exprs(As) -> [lambda_lift_expr(A) || A <- As].
 
 -spec optimize_fcode(fcode()) -> fcode().
 optimize_fcode(Code = #{ functions := Funs }) ->
-    Code#{ functions := maps:map(fun(Name, Def) -> optimize_fun(Code, Name, Def) end, Funs) }.
+    Code1 = Code#{ functions := maps:map(fun(Name, Def) -> optimize_fun(Code, Name, Def) end, Funs) },
+    eliminate_dead_code(Code1).
 
 -spec optimize_fun(fcode(), fun_name(), fun_def()) -> fun_def().
-optimize_fun(_Fcode, _Fun, Def = #{ body := _Body }) ->
+optimize_fun(Fcode, Fun, Def = #{ body := Body }) ->
     %% io:format("Optimizing ~p =\n~s\n", [_Fun, prettypr:format(pp_fexpr(_Body))]),
-    Def.
+    Def#{ body := inliner(Fcode, Fun, Body) }.
+
+%% --- Inlining ---
+
+-spec inliner(fcode(), fun_name(), fexpr()) -> fexpr().
+inliner(Fcode, Fun, {def, Fun1, Args} = E) when Fun1 /= Fun ->
+    case should_inline(Fcode, Fun1) of
+        false -> E;
+        true  -> inline(Fcode, Fun1, Args)
+    end;
+inliner(_Fcode, _Fun, E) -> E.
+
+should_inline(_Fcode, _Fun1) -> false == list_to_atom("true").  %% Dialyzer
+
+inline(_Fcode, Fun, Args) -> {def, Fun, Args}. %% TODO
+
+%% --- Deadcode elimination ---
+
+-spec eliminate_dead_code(fcode()) -> fcode().
+eliminate_dead_code(Code = #{ functions := Funs }) ->
+    UsedFuns = used_functions(Funs),
+    Code#{ functions := maps:filter(fun(Name, _) -> maps:is_key(Name, UsedFuns) end,
+                                    Funs) }.
+
+-spec used_functions(#{ fun_name() => fun_def() }) -> #{ fun_name() => true }.
+used_functions(Funs) ->
+    Exported = [ Fun || {Fun, #{ attrs := Attrs }} <- maps:to_list(Funs),
+                        not lists:member(private, Attrs) ],
+    used_functions(#{}, Exported, Funs).
+
+used_functions(Used, [], _) -> Used;
+used_functions(Used, [Name | Rest], Defs) ->
+    case maps:is_key(Name, Used) of
+        true  -> used_functions(Used, Rest, Defs);
+        false ->
+            New =
+                case maps:get(Name, Defs, undef) of
+                    undef             -> []; %% We might be compiling a stub
+                    #{ body := Body } -> used_defs(Body)
+                end,
+            used_functions(Used#{ Name => true }, New ++ Rest, Defs)
+    end.
 
 %% -- Helper functions -------------------------------------------------------
 
@@ -889,18 +1093,18 @@ add_fun_env(Env = #{ context := {abstract_contract, _} }, _) -> Env;  %% no func
 add_fun_env(Env = #{ fun_env := FunEnv }, Decls) ->
     Entry = fun({letfun, Ann, {id, _, Name}, Args, _, _}) ->
                 [{qname(Env, Name), {make_fun_name(Env, Ann, Name), length(Args)}}];
+               ({fun_decl, Ann, {id, _, Name}, {fun_t, _, _, ArgTypes, _}}) ->
+                [{qname(Env, Name), {make_fun_name(Env, Ann, Name), length(ArgTypes)}}];
                (_) -> [] end,
     FunEnv1 = maps:from_list(lists:flatmap(Entry, Decls)),
     Env#{ fun_env := maps:merge(FunEnv, FunEnv1) }.
 
 make_fun_name(#{ context := Context }, Ann, Name) ->
-    Private = proplists:get_value(private, Ann, false) orelse
+    Entrypoint = proplists:get_value(entrypoint, Ann, false),
-              proplists:get_value(internal, Ann, false),
     case Context of
         {main_contract, Main} ->
-            if Private        -> {local_fun, [Main, Name]};
+            if Entrypoint     -> {entrypoint, list_to_binary(Name)};
-               Name == "init" -> init;
+               true           -> {local_fun, [Main, Name]}
-               true           -> {entrypoint, list_to_binary(Name)}
             end;
         {namespace, Lib} ->
             {local_fun, [Lib, Name]}
@@ -983,6 +1187,16 @@ pat_vars({tuple, Ps})         -> pat_vars(Ps);
 pat_vars({con, _, _, Ps})     -> pat_vars(Ps);
 pat_vars(Ps) when is_list(Ps) -> [X || P <- Ps, X <- pat_vars(P)].
 
+-spec fsplit_pat_vars(fsplit_pat()) -> [var_name()].
+fsplit_pat_vars({var, X})            -> [X || X /= "_"];
+fsplit_pat_vars({bool, _})           -> [];
+fsplit_pat_vars({int, _})            -> [];
+fsplit_pat_vars({string, _})         -> [];
+fsplit_pat_vars(nil)                 -> [];
+fsplit_pat_vars({'::', P, Q})        -> [P, Q];
+fsplit_pat_vars({tuple, Ps})         -> Ps;
+fsplit_pat_vars({con, _, _, Ps})     -> Ps.
+
 free_vars(Xs) when is_list(Xs) ->
     lists:umerge([ free_vars(X) || X <- Xs ]);
 free_vars(Expr) ->
@@ -992,8 +1206,8 @@ free_vars(Expr) ->
         nil                  -> [];
         {def, _, As}         -> free_vars(As);
         {def_u, _, _}        -> [];
-        {remote, Ct, _, As}  -> free_vars([Ct | As]);
+        {remote, _, _, Ct, _, As} -> free_vars([Ct | As]);
-        {remote_u, Ct, _, _} -> free_vars(Ct);
+        {remote_u, _, _, Ct, _}   -> free_vars(Ct);
         {builtin, _, As}     -> free_vars(As);
         {builtin_u, _, _}    -> [];
         {con, _, _, As}      -> free_vars(As);
@@ -1008,7 +1222,35 @@ free_vars(Expr) ->
         {switch, A}          -> free_vars(A);
         {split, _, X, As}    -> free_vars([{var, X} | As]);
         {nosplit, A}         -> free_vars(A);
-        {'case', P, A}       -> free_vars(A) -- lists:sort(pat_vars(P))
+        {'case', P, A}       -> free_vars(A) -- lists:sort(fsplit_pat_vars(P))
+    end.
+
+used_defs(Xs) when is_list(Xs) ->
+    lists:umerge([ used_defs(X) || X <- Xs ]);
+used_defs(Expr) ->
+    case Expr of
+        {var, _}             -> [];
+        {lit, _}             -> [];
+        nil                  -> [];
+        {def, F, As}         -> lists:umerge([F], used_defs(As));
+        {def_u, F, _}        -> [F];
+        {remote, _, _, Ct, _, As} -> used_defs([Ct | As]);
+        {remote_u, _, _, Ct, _}   -> used_defs(Ct);
+        {builtin, _, As}     -> used_defs(As);
+        {builtin_u, _, _}    -> [];
+        {con, _, _, As}      -> used_defs(As);
+        {tuple, As}          -> used_defs(As);
+        {proj, A, _}         -> used_defs(A);
+        {set_proj, A, _, B}  -> used_defs([A, B]);
+        {op, _, As}          -> used_defs(As);
+        {'let', _, A, B}     -> used_defs([A, B]);
+        {funcall, A, Bs}     -> used_defs([A | Bs]);
+        {lam, _, B}          -> used_defs(B);
+        {closure, F, A}      -> lists:umerge([F], used_defs(A));
+        {switch, A}          -> used_defs(A);
+        {split, _, _, As}    -> used_defs(As);
+        {nosplit, A}         -> used_defs(A);
+        {'case', _, A}       -> used_defs(A)
     end.
 
 get_named_args(NamedArgsT, Args) ->
@@ -1036,8 +1278,8 @@ rename(Ren, Expr) ->
         {def_u, _, _}         -> Expr;
         {builtin, B, Es}      -> {builtin, B, [rename(Ren, E) || E <- Es]};
         {builtin_u, _, _}     -> Expr;
-        {remote, Ct, F, Es}   -> {remote, rename(Ren, Ct), F, [rename(Ren, E) || E <- Es]};
+        {remote, ArgsT, RetT, Ct, F, Es} -> {remote,   ArgsT, RetT, rename(Ren, Ct), F, [rename(Ren, E) || E <- Es]};
-        {remote_u, Ct, F, Ar} -> {remote_u, rename(Ren, Ct), F, Ar};
+        {remote_u, ArgsT, RetT, Ct, F}   -> {remote_u, ArgsT, RetT, rename(Ren, Ct), F};
         {con, Ar, I, Es}      -> {con, Ar, I, [rename(Ren, E) || E <- Es]};
         {tuple, Es}           -> {tuple, [rename(Ren, E) || E <- Es]};
         {proj, E, I}          -> {proj, rename(Ren, E), I};
@@ -1141,7 +1383,9 @@ field_value({field_t, _, {id, _, X}, _}, Fields) ->
 %% -- Attributes --
 
 get_attributes(Ann) ->
-    [stateful || proplists:get_value(stateful, Ann, false)].
+    [stateful || proplists:get_value(stateful, Ann, false)] ++
+    [payable  || proplists:get_value(payable, Ann, false)] ++
+    [private  || not proplists:get_value(entrypoint, Ann, false)].
 
 %% -- Basic utilities --
 
@@ -1167,13 +1411,17 @@ pp_fun(Name, #{ args := Args, return := Return, body := Body }) ->
                pp_text(" : "), pp_ftype(Return), pp_text(" =")]),
              prettypr:nest(2, pp_fexpr(Body))).
 
-pp_fun_name(init)            -> pp_text("init");
+pp_fun_name(init)            -> pp_text('INIT');
+pp_fun_name(event)           -> pp_text(event);
 pp_fun_name({entrypoint, E}) -> pp_text(binary_to_list(E));
 pp_fun_name({local_fun, Q})  -> pp_text(string:join(Q, ".")).
 
 pp_text(<<>>) -> prettypr:text("\"\"");
 pp_text(Bin) when is_binary(Bin) -> prettypr:text(lists:flatten(io_lib:format("~p", [binary_to_list(Bin)])));
-pp_text(S) -> prettypr:text(lists:concat([S])).
+pp_text(S) when is_list(S) -> prettypr:text(lists:concat([S]));
+pp_text(A) when is_atom(A) -> prettypr:text(atom_to_list(A)).
+
+pp_int(I) -> prettypr:text(integer_to_list(I)).
 
 pp_beside([])       -> prettypr:empty();
 pp_beside([X])      -> X;
@@ -1196,6 +1444,8 @@ pp_punctuate(Sep, [X | Xs]) -> [pp_beside(X, Sep) | pp_punctuate(Sep, Xs)].
 
 pp_par([]) -> prettypr:empty();
 pp_par(Xs) -> prettypr:par(Xs).
+pp_fexpr({lit, {typerep, T}}) ->
+    pp_ftype(T);
 pp_fexpr({lit, {Tag, Lit}}) ->
     aeso_pretty:expr({Tag, [], Lit});
 pp_fexpr(nil) ->
@@ -1203,18 +1453,18 @@ pp_fexpr(nil) ->
 pp_fexpr({var, X})   -> pp_text(X);
 pp_fexpr({def, Fun}) -> pp_fun_name(Fun);
 pp_fexpr({def_u, Fun, Ar}) ->
-    pp_beside([pp_fun_name(Fun), pp_text("/"), pp_text(Ar)]);
+    pp_beside([pp_fun_name(Fun), pp_text("/"), pp_int(Ar)]);
 pp_fexpr({def, Fun, Args}) ->
     pp_call(pp_fun_name(Fun), Args);
 pp_fexpr({con, _, I, []}) ->
-    pp_beside(pp_text("C"), pp_text(I));
+    pp_beside(pp_text("C"), pp_int(I));
 pp_fexpr({con, _, I, Es}) ->
     pp_beside(pp_fexpr({con, [], I, []}),
               pp_fexpr({tuple, Es}));
 pp_fexpr({tuple, Es}) ->
     pp_parens(pp_par(pp_punctuate(pp_text(","), [pp_fexpr(E) || E <- Es])));
 pp_fexpr({proj, E, I}) ->
-    pp_beside([pp_fexpr(E), pp_text("."), pp_text(I)]);
+    pp_beside([pp_fexpr(E), pp_text("."), pp_int(I)]);
 pp_fexpr({lam, Xs, A}) ->
     pp_par([pp_fexpr({tuple, [{var, X} || X <- Xs]}), pp_text("=>"),
             prettypr:nest(2, pp_fexpr(A))]);
@@ -1225,7 +1475,7 @@ pp_fexpr({closure, Fun, ClEnv}) ->
           end,
     pp_call(pp_text("__CLOSURE__"), [{def, Fun} | FVs]);
 pp_fexpr({set_proj, E, I, A}) ->
-    pp_beside(pp_fexpr(E), pp_braces(pp_beside([pp_text(I), pp_text(" = "), pp_fexpr(A)])));
+    pp_beside(pp_fexpr(E), pp_braces(pp_beside([pp_int(I), pp_text(" = "), pp_fexpr(A)])));
 pp_fexpr({op, Op, [A, B] = Args}) ->
     case is_infix(Op) of
         false -> pp_call(pp_text(Op), Args);
@@ -1245,10 +1495,10 @@ pp_fexpr({builtin_u, B, N}) ->
     pp_beside([pp_text(B), pp_text("/"), pp_text(N)]);
 pp_fexpr({builtin, B, As}) ->
     pp_call(pp_text(B), As);
-pp_fexpr({remote_u, Ct, Fun, Ar}) ->
+pp_fexpr({remote_u, ArgsT, RetT, Ct, Fun}) ->
-    pp_beside([pp_fexpr(Ct), pp_text("."), pp_fun_name(Fun), pp_text("/"), pp_text(Ar)]);
+    pp_beside([pp_fexpr(Ct), pp_text("."), pp_fun_name(Fun), pp_text(" : "), pp_ftype({function, ArgsT, RetT})]);
-pp_fexpr({remote, Ct, Fun, As}) ->
+pp_fexpr({remote, ArgsT, RetT, Ct, Fun, As}) ->
-    pp_call(pp_beside([pp_fexpr(Ct), pp_text("."), pp_fun_name(Fun)]), As);
+    pp_call(pp_parens(pp_beside([pp_fexpr(Ct), pp_text("."), pp_fun_name(Fun), pp_text(" : "), pp_ftype({function, ArgsT, RetT})])), As);
 pp_fexpr({funcall, Fun, As}) ->
     pp_call(pp_fexpr(Fun), As);
 pp_fexpr({switch, Split}) -> pp_split(Split).
@@ -1256,16 +1506,23 @@ pp_fexpr({switch, Split}) -> pp_split(Split).
 pp_call(Fun, Args) ->
     pp_beside(Fun, pp_fexpr({tuple, Args})).
 
+pp_call_t(Fun, Args) ->
+    pp_beside(pp_text(Fun), pp_ftype({tuple, Args})).
+
+-spec pp_ftype(ftype()) -> any().
 pp_ftype(T) when is_atom(T) -> pp_text(T);
 pp_ftype(any) -> pp_text("_");
+pp_ftype({tvar, X}) -> pp_text(X);
+pp_ftype({bytes, N}) -> pp_call(pp_text("bytes"), [{lit, {int, N}}]);
+pp_ftype({oracle, Q, R}) -> pp_call_t("oracle", [Q, R]);
 pp_ftype({tuple, Ts}) ->
     pp_parens(pp_par(pp_punctuate(pp_text(","), [pp_ftype(T) || T <- Ts])));
 pp_ftype({list, T}) ->
-    pp_beside([pp_text("list("), pp_ftype(T), pp_text(")")]);
+    pp_call_t("list", [T]);
 pp_ftype({function, Args, Res}) ->
     pp_par([pp_ftype({tuple, Args}), pp_text("=>"), pp_ftype(Res)]);
 pp_ftype({map, Key, Val}) ->
-    pp_beside([pp_text("map"), pp_ftype({tuple, [Key, Val]})]);
+    pp_call_t("map", [Key, Val]);
 pp_ftype({variant, Cons}) ->
     pp_par(
     pp_punctuate(pp_text(" |"),

src/aeso_ast_to_icode.erl

@@ -17,22 +17,27 @@
 
 -spec convert_typed(aeso_syntax:ast(), list()) -> aeso_icode:icode().
 convert_typed(TypedTree, Options) ->
-    Name = case lists:last(TypedTree) of
+    {Payable, Name} =
-               {contract, _, {con, _, Con}, _} -> Con;
+        case lists:last(TypedTree) of
-               _ -> gen_error(last_declaration_must_be_contract)
+            {contract, Attrs, {con, _, Con}, _} ->
+                {proplists:get_value(payable, Attrs, false), Con};
+            _ ->
+                gen_error(last_declaration_must_be_contract)
            end,
-    Icode = code(TypedTree, aeso_icode:set_name(Name, aeso_icode:new(Options))),
+    NewIcode = aeso_icode:set_payable(Payable,
+                   aeso_icode:set_name(Name, aeso_icode:new(Options))),
+    Icode    = code(TypedTree, NewIcode, Options),
     deadcode_elimination(Icode).
 
-code([{contract, _Attribs, Con, Code}|Rest], Icode) ->
+code([{contract, _Attribs, Con, Code}|Rest], Icode, Options) ->
     NewIcode = contract_to_icode(Code, aeso_icode:set_namespace(Con, Icode)),
-    code(Rest, NewIcode);
+    code(Rest, NewIcode, Options);
-code([{namespace, _Ann, Name, Code}|Rest], Icode) ->
+code([{namespace, _Ann, Name, Code}|Rest], Icode, Options) ->
-                                            %% TODO: nested namespaces
+    %% TODO: nested namespaces
     NewIcode = contract_to_icode(Code, aeso_icode:set_namespace(Name, Icode)),
-    code(Rest, NewIcode);
+    code(Rest, NewIcode, Options);
-code([], Icode) ->
+code([], Icode, Options) ->
-    add_default_init_function(add_builtins(Icode)).
+    add_default_init_function(add_builtins(Icode), Options).
 
 %% Generate error on correct format.
 
@@ -40,10 +45,12 @@ gen_error(Error) ->
     error({code_errors, [Error]}).
 
 %% Create default init function (only if state is unit).
-add_default_init_function(Icode = #{functions := Funs, state_type := State}) ->
+add_default_init_function(Icode = #{functions := Funs, state_type := State}, Options) ->
+    NoCode        = proplists:get_value(no_code, Options, false),
     {_, _, QInit} = aeso_icode:qualify({id, [], "init"}, Icode),
     case lists:keymember(QInit, 1, Funs) of
         true -> Icode;
+        false when NoCode -> Icode;
         false when State /= {tuple, []} ->
             gen_error(missing_init_function);
         false ->
@@ -84,6 +91,7 @@ contract_to_icode([{type_def, _Attrib, Id = {id, _, Name}, Args, Def} | Rest],
     contract_to_icode(Rest, Icode2);
 contract_to_icode([{letfun, Attrib, Name, Args, _What, Body={typed,_,_,T}}|Rest], Icode) ->
     FunAttrs = [ stateful || proplists:get_value(stateful, Attrib, false) ] ++
+               [ payable  || proplists:get_value(payable, Attrib, false) ] ++
                [ private  || is_private(Attrib, Icode) ],
     %% TODO: Handle types
     FunName = ast_id(Name),
@@ -141,7 +149,7 @@ ast_body(?qid_app([Con, "Chain", "event"], [Event], _, _), Icode = #{ contract_n
 ast_body(?qid_app(["Chain", "balance"], [Address], _, _), Icode) ->
     #prim_balance{ address = ast_body(Address, Icode) };
 ast_body(?qid_app(["Chain", "block_hash"], [Height], _, _), Icode) ->
-    #prim_block_hash{ height = ast_body(Height, Icode) };
+    builtin_call(block_hash, [ast_body(Height, Icode)]);
 ast_body(?qid_app(["Call", "gas_left"], [], _, _), _Icode) ->
     prim_gas_left;
 ast_body({qid, _, ["Contract", "address"]}, _Icode)      -> prim_contract_address;
@@ -173,8 +181,9 @@ ast_body({qid, _, [Con, "put"]}, #{ contract_name := Con }) ->
 
 %% Abort
 ast_body(?id_app("abort", [String], _, _), Icode) ->
-    #funcall{ function = #var_ref{ name = {builtin, abort} },
+    builtin_call(abort, [ast_body(String, Icode)]);
-              args     = [ast_body(String, Icode)] };
+ast_body(?id_app("require", [Bool, String], _, _), Icode) ->
+    builtin_call(require, [ast_body(Bool, Icode), ast_body(String, Icode)]);
 
 %% Authentication
 ast_body({qid, _, ["Auth", "tx_hash"]}, _Icode) ->
@@ -265,15 +274,15 @@ ast_body(?qid_app(["AENS", "claim"], Args, _, _), Icode) ->
               [word, string, word, sign_t()], {tuple, []});
 
 ast_body(?qid_app(["AENS", "transfer"], Args, _, _), Icode) ->
-    {Sign, [FromAddr, ToAddr, NameHash]} = get_signature_arg(Args),
+    {Sign, [FromAddr, ToAddr, Name]} = get_signature_arg(Args),
     prim_call(?PRIM_CALL_AENS_TRANSFER, #integer{value = 0},
-              [ast_body(FromAddr, Icode), ast_body(ToAddr, Icode), ast_body(NameHash, Icode), ast_body(Sign, Icode)],
+              [ast_body(FromAddr, Icode), ast_body(ToAddr, Icode), ast_body(Name, Icode), ast_body(Sign, Icode)],
               [word, word, word, sign_t()], {tuple, []});
 
 ast_body(?qid_app(["AENS", "revoke"], Args, _, _), Icode) ->
-    {Sign, [Addr, NameHash]} = get_signature_arg(Args),
+    {Sign, [Addr, Name]} = get_signature_arg(Args),
     prim_call(?PRIM_CALL_AENS_REVOKE, #integer{value = 0},
-              [ast_body(Addr, Icode), ast_body(NameHash, Icode), ast_body(Sign, Icode)],
+              [ast_body(Addr, Icode), ast_body(Name, Icode), ast_body(Sign, Icode)],
               [word, word, sign_t()], {tuple, []});
 
 ast_body({qid, _, ["AENS", "resolve"]}, _Icode)  -> gen_error({underapplied_primitive, 'AENS.resolve'});
@@ -346,16 +355,26 @@ ast_body({map, Ann, Map, [Upd | Upds]}, Icode) ->
     ast_body({map, Ann, {map, Ann, Map, [Upd]}, Upds}, Icode);
 
 %% Crypto
-ast_body(?qid_app(["Crypto", "ecverify"], [Msg, PK, Sig], _, _), Icode) ->
+ast_body(?qid_app(["Crypto", "verify_sig"], [Msg, PK, Sig], _, _), Icode) ->
-    prim_call(?PRIM_CALL_CRYPTO_ECVERIFY, #integer{value = 0},
+    prim_call(?PRIM_CALL_CRYPTO_VERIFY_SIG, #integer{value = 0},
               [ast_body(Msg, Icode), ast_body(PK, Icode), ast_body(Sig, Icode)],
               [word, word, sign_t()], word);
 
-ast_body(?qid_app(["Crypto", "ecverify_secp256k1"], [Msg, PK, Sig], _, _), Icode) ->
+ast_body(?qid_app(["Crypto", "verify_sig_secp256k1"], [Msg, PK, Sig], _, _), Icode) ->
-    prim_call(?PRIM_CALL_CRYPTO_ECVERIFY_SECP256K1, #integer{value = 0},
+    prim_call(?PRIM_CALL_CRYPTO_VERIFY_SIG_SECP256K1, #integer{value = 0},
               [ast_body(Msg, Icode), ast_body(PK, Icode), ast_body(Sig, Icode)],
               [bytes_t(32), bytes_t(64), bytes_t(64)], word);
 
+ast_body(?qid_app(["Crypto", "ecverify_secp256k1"], [Msg, Addr, Sig], _, _), Icode) ->
+    prim_call(?PRIM_CALL_CRYPTO_ECVERIFY_SECP256K1, #integer{value = 0},
+              [ast_body(Msg, Icode), ast_body(Addr, Icode), ast_body(Sig, Icode)],
+              [word, bytes_t(20), bytes_t(65)], word);
+
+ast_body(?qid_app(["Crypto", "ecrecover_secp256k1"], [Msg, Sig], _, _), Icode) ->
+    prim_call(?PRIM_CALL_CRYPTO_ECRECOVER_SECP256K1, #integer{value = 0},
+              [ast_body(Msg, Icode), ast_body(Sig, Icode)],
+              [word, bytes_t(65)], aeso_icode:option_typerep(bytes_t(20)));
+
 ast_body(?qid_app(["Crypto", "sha3"], [Term], [Type], _), Icode) ->
     generic_hash_primop(?PRIM_CALL_CRYPTO_SHA3, Term, Type, Icode);
 ast_body(?qid_app(["Crypto", "sha256"], [Term], [Type], _), Icode) ->
@@ -370,13 +389,11 @@ ast_body(?qid_app(["String", "blake2b"], [String], _, _), Icode) ->
 %% Strings
 %% -- String length
 ast_body(?qid_app(["String", "length"], [String], _, _), Icode) ->
-    #funcall{ function = #var_ref{ name = {builtin, string_length} },
+    builtin_call(string_length, [ast_body(String, Icode)]);
-              args     = [ast_body(String, Icode)] };
 
 %% -- String concat
 ast_body(?qid_app(["String", "concat"], [String1, String2], _, _), Icode) ->
-    #funcall{ function = #var_ref{ name = {builtin, string_concat} },
+    builtin_call(string_concat, [ast_body(String1, Icode), ast_body(String2, Icode)]);
-              args     = [ast_body(String1, Icode), ast_body(String2, Icode)] };
 
 %% -- String hash (sha3)
 ast_body(?qid_app(["String", "sha3"], [String], _, _), Icode) ->
@@ -421,6 +438,16 @@ ast_body(?qid_app(["Address", "is_oracle"], [Addr], _, _), Icode) ->
 ast_body(?qid_app(["Address", "is_contract"], [Addr], _, _), Icode) ->
     prim_call(?PRIM_CALL_ADDR_IS_CONTRACT, #integer{value = 0},
               [ast_body(Addr, Icode)], [word], word);
+ast_body(?qid_app(["Address", "is_payable"], [Addr], _, _), Icode) ->
+    prim_call(?PRIM_CALL_ADDR_IS_PAYABLE, #integer{value = 0},
+              [ast_body(Addr, Icode)], [word], word);
+
+ast_body(?qid_app(["Bytes", "to_int"], [Bytes], _, _), Icode) ->
+    {typed, _, _, {bytes_t, _, N}} = Bytes,
+    builtin_call({bytes_to_int, N}, [ast_body(Bytes, Icode)]);
+ast_body(?qid_app(["Bytes", "to_str"], [Bytes], _, _), Icode) ->
+    {typed, _, _, {bytes_t, _, N}} = Bytes,
+    builtin_call({bytes_to_str, N}, [ast_body(Bytes, Icode)]);
 
 %% Other terms
 ast_body({id, _, Name}, _Icode) ->
@@ -468,7 +495,7 @@ ast_body({app, _, {typed, _, {proj, _, {typed, _, Addr, {con, _, Contract}}, {id
     Gas    = proplists:get_value("gas",   ArgOpts ++ Defaults),
     Value  = proplists:get_value("value", ArgOpts ++ Defaults),
     OutType = ast_typerep(OutT, Icode),
-    <<TypeHash:256>> = aeb_abi:function_type_hash(list_to_binary(FunName), ArgType, OutType),
+    <<TypeHash:256>> = aeb_aevm_abi:function_type_hash(list_to_binary(FunName), ArgType, OutType),
     %% The function is represented by its type hash (which includes the name)
     Fun    = #integer{value = TypeHash},
     #prim_call_contract{
@@ -510,6 +537,24 @@ ast_body({app,As,Fun,Args}, Icode) ->
             #funcall{function=ast_body(Fun, Icode),
                      args=[ast_body(A, Icode) || A <- Args]}
     end;
+ast_body({list_comp, _, Yield, []}, Icode) ->
+    #list{elems = [ast_body(Yield, Icode)]};
+ast_body({list_comp, As, Yield, [{comprehension_bind, {typed, Arg, ArgType}, BindExpr}|Rest]}, Icode) ->
+    #funcall
+        { function = #var_ref{ name = ["List", "flat_map"] }
+        , args =
+              [ #lambda{ args=[#arg{name = ast_id(Arg), type = ast_type(ArgType, Icode)}]
+                       , body = ast_body({list_comp, As, Yield, Rest}, Icode)
+                       }
+              , ast_body(BindExpr, Icode)
+              ]
+        };
+ast_body({list_comp, As, Yield, [{comprehension_if, AsIF, Cond}|Rest]}, Icode) ->
+    ast_body({'if', AsIF, Cond, {list_comp, As, Yield, Rest}, {list, As, []}}, Icode);
+ast_body({list_comp, As, Yield, [LV = {letval, _, _, _, _}|Rest]}, Icode) ->
+    ast_body({block, As, [LV, {list_comp, As, Yield, Rest}]}, Icode);
+ast_body({list_comp, As, Yield, [LF = {letfun, _, _, _, _, _}|Rest]}, Icode) ->
+    ast_body({block, As, [LF, {list_comp, As, Yield, Rest}]}, Icode);
 ast_body({'if',_,Dec,Then,Else}, Icode) ->
     #ifte{decision = ast_body(Dec, Icode)
          ,then     = ast_body(Then, Icode)
@@ -602,13 +647,11 @@ ast_binop(Op, Ann, {typed, _, A, Type}, B, Icode)
             Builtin =
                 case OtherType of
                     string ->
-                        #funcall{ function = #var_ref{name = {builtin, str_equal}},
+                        builtin_call(str_equal, Args);
-                                  args     = Args };
                     {tuple, Types} ->
                         case lists:usort(Types) of
                             [word] ->
-                                #funcall{ function = #var_ref{name = {builtin, str_equal_p}},
+                                builtin_call(str_equal_p, [ #integer{value = 32 * length(Types)} | Args]);
-                                          args = [ #integer{value = 32 * length(Types)} | Args] };
                             _ -> gen_error({cant_compare, Ann, Op, Type})
                         end;
                     _ ->
@@ -617,8 +660,7 @@ ast_binop(Op, Ann, {typed, _, A, Type}, B, Icode)
             Neg(Builtin)
     end;
 ast_binop('++', _, A, B, Icode) ->
-    #funcall{ function = #var_ref{ name = {builtin, list_concat} },
+    builtin_call(list_concat, [ast_body(A, Icode), ast_body(B, Icode)]);
-              args     = [ast_body(A, Icode), ast_body(B, Icode)] };
 ast_binop(Op, _, A, B, Icode) ->
     #binop{op = Op, left = ast_body(A, Icode), right = ast_body(B, Icode)}.
 
@@ -685,7 +727,7 @@ prim_call(Prim, Amount, Args, ArgTypes, OutType) ->
             true ->
                 PrimBin = binary:encode_unsigned(Prim),
                 ArgType = {tuple, ArgTypes},
-                <<TH:256>> = aeb_abi:function_type_hash(PrimBin, ArgType, OutType),
+                <<TH:256>> = aeb_aevm_abi:function_type_hash(PrimBin, ArgType, OutType),
                 TH;
             false ->
                 0
@@ -725,7 +767,7 @@ ast_typerep({con, _, _}, _) ->
     word;   %% Contract type
 ast_typerep({bytes_t, _, Len}, _) ->
     bytes_t(Len);
-ast_typerep({app_t, _, {id, _, Name}, Args}, Icode) ->
+ast_typerep({app_t, _, {I, _, Name}, Args}, Icode) when I =:= id; I =:= qid ->
     ArgReps = [ ast_typerep(Arg, Icode) || Arg <- Args ],
     lookup_type_id(Name, ArgReps, Icode);
 ast_typerep({tvar,_,A}, #{ type_vars := TypeVars }) ->
@@ -814,13 +856,11 @@ has_maps({list, T})     -> has_maps(T);
 has_maps({tuple, Ts})   -> lists:any(fun has_maps/1, Ts);
 has_maps({variant, Cs}) -> lists:any(fun has_maps/1, lists:append(Cs)).
 
-%% A function is private if marked 'private' or 'internal', or if it's not
+%% A function is private if not an 'entrypoint', or if it's not defined in the
-%% defined in the main contract name space. (NOTE: changes when we introduce
+%% main contract name space. (NOTE: changes when we introduce inheritance).
-%% inheritance).
 is_private(Ann, #{ contract_name := MainContract } = Icode) ->
     {_, _, CurrentNamespace} = aeso_icode:get_namespace(Icode),
-    proplists:get_value(private,  Ann, false) orelse
+    not proplists:get_value(entrypoint, Ann, false) orelse
-    proplists:get_value(internal, Ann, false) orelse
     MainContract /= CurrentNamespace.
 
 %% -------------------------------------------------------------------

src/aeso_builtins.erl

@@ -44,7 +44,9 @@ 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];
 builtin_deps1(string_reverse)             -> [string_reverse_];
+builtin_deps1(require)                    -> [abort];
 builtin_deps1(_)                          -> [].
 
 dep_closure(Deps) ->
@@ -60,12 +62,14 @@ 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, v(Ptr), [{{tuple, [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)).
@@ -91,12 +95,6 @@ operand(A) when is_atom(A) -> v(A);
 operand(I) when is_integer(I) -> {integer, I};
 operand(T) -> T.
 
-str_to_icode(String) when is_list(String) ->
-    str_to_icode(list_to_binary(String));
-str_to_icode(BinStr) ->
-    Cpts = [size(BinStr) | aeb_memory:binary_to_words(BinStr)],
-    #tuple{ cpts = [ #integer{value = X} || X <- Cpts ] }.
-
 check_event_type(Icode) ->
     case maps:get(event_type, Icode) of
         {variant_t, Cons} ->
@@ -117,11 +115,12 @@ check_event_type(EvtName, Ix, Type, Icode) ->
         catch _:_ ->
             error({EvtName, could_not_resolve_type, Type})
         end,
-    case {Ix, VMType} of
+    case {Ix, VMType, Type} of
-        {indexed, word}      -> ok;
+        {indexed, word, _}      -> ok;
-        {notindexed, string} -> ok;
+        {notindexed, string, _} -> ok;
-        {indexed, _}         -> error({EvtName, indexed_field_should_be_word, is, VMType});
+        {notindexed, _, {bytes_t, _, N}} when N > 32 -> ok;
-        {notindexed, _}      -> error({EvtName, payload_should_be_string, is, VMType})
+        {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}) ->
@@ -131,6 +130,8 @@ 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());
@@ -158,6 +159,9 @@ builtin_function(BF) ->
         {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_to_str_worker        -> bfun(BF, builtin_bytes_to_str_worker());
         string_reverse             -> bfun(BF, builtin_string_reverse());
         string_reverse_            -> bfun(BF, builtin_string_reverse_())
     end.
@@ -171,16 +175,23 @@ builtin_event(EventT) ->
     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]};
+        fun([])            -> {inline_asm, [A(?PUSH1), 0, A(?PUSH1), 0]};
-           ([V]) -> {seq, [V, {inline_asm, [A(?DUP1), A(?MLOAD),                  %% length, ptr
+           ([{{id, _, "string"}, V}]) ->
-                                            A(?SWAP1), A(?PUSH1), 32, A(?ADD)]}]} %% ptr+32, length
+                {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   = [ Var || {Var, {indexed, _Type}} <- lists:zip(ArgPats(Types), IxTypes) ],
+            Indexed   = [ Ix(Type, Var) || {Var, {indexed, Type}} <- lists:zip(ArgPats(Types), IxTypes) ],
-            EvtIndex  = {unop, 'sha3', str_to_icode(Con)},
+            Data      = [ {Type, Var} || {Var, {notindexed, Type}} <- lists:zip(ArgPats(Types), IxTypes) ],
-            {event, lists:reverse(Indexed) ++ [EvtIndex], Payload(ArgPats(Types) -- Indexed)}
+            {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,
 
@@ -201,6 +212,17 @@ builtin_abort() ->
                    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),
@@ -437,6 +459,10 @@ builtin_baseX_int_pad(X = 10) ->
         ?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),
@@ -471,6 +497,57 @@ builtin_baseX_digits(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}.
+
+builtin_bytes_to_str_worker() ->
+    <<Tab:256>> = <<"0123456789ABCDEF________________">>,
+    {[{"w", word}, {"offs", word}, {"acc", word}],
+     {seq, [{ifte, ?AND(?GT(offs, 0), ?EQ(0, ?MOD(offs, 16))),
+                    {seq, [?V(acc), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]}]},
+                    {inline_asm, []}},
+            {ifte, ?EQ(offs, 32), {inline_asm, [?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))]))))
+            }
+           ]},
+     word}.
+
+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)]},
+            ?call(bytes_to_str_worker, [?V(w), ?I(0), ?I(0)]),
+            {inline_asm, [?A(?POP)]},
+            ?V(ret)]}),
+     string};
+builtin_bytes_to_str(N) when N > 32 ->
+    Work = fun(I) ->
+            [?DEREF(w, ?ADD(p, 32 * I), ?call(bytes_to_str_worker, [?V(w), ?I(0), ?I(0)])),
+             {inline_asm, [?A(?POP)]}]
+           end,
+    {[{"p", pointer}],
+     ?LET(ret, {inline_asm, [?A(?MSIZE)]},
+     {seq, [?I(N * 2), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]}] ++
+           lists:append([ Work(I) || I <- lists:seq(0, (N + 31) div 32 - 1) ]) ++
+           [?V(ret)]}),
+     string}.
+
 builtin_string_reverse() ->
     {[{"s", string}],
      ?DEREF(n, s,

src/aeso_compiler.erl

@@ -12,12 +12,16 @@
         , file/2
         , from_string/2
         , check_call/4
-        , create_calldata/3
+        , create_calldata/3  %% deprecated
+        , create_calldata/4
         , version/0
         , sophia_type_to_typerep/1
-        , to_sophia_value/4
+        , to_sophia_value/4  %% deprecated, need a backend
         , to_sophia_value/5
-        , decode_calldata/3
+        , decode_calldata/3  %% deprecated
+        , decode_calldata/4
+        , parse/2
+        , add_include_path/2
         ]).
 
 -include_lib("aebytecode/include/aeb_opcodes.hrl").
@@ -31,6 +35,9 @@
                 | pp_icode
                 | pp_assembler
                 | pp_bytecode
+                | no_code
+                | no_implicit_stdlib
+                | {backend, aevm | fate}
                 | {include, {file_system, [string()]} |
                             {explicit_files, #{string() => binary()}}}
                 | {src_file, string()}.
@@ -61,12 +68,11 @@ version() ->
 
 -spec file(string()) -> {ok, map()} | {error, binary()}.
 file(Filename) ->
-    Dir = filename:dirname(Filename),
+    file(Filename, []).
-    {ok, Cwd} = file:get_cwd(),
-    file(Filename, [{include, {file_system, [Cwd, Dir]}}]).
 
 -spec file(string(), options()) -> {ok, map()} | {error, binary()}.
-file(File, Options) ->
+file(File, Options0) ->
+    Options = add_include_path(File, Options0),
     case read_contract(File) of
         {ok, Bin} -> from_string(Bin, [{src_file, File} | Options]);
         {error, Error} ->
@@ -74,24 +80,24 @@ file(File, Options) ->
 	    {error, join_errors("File errors", [ErrorString], fun(E) -> E end)}
     end.
 
+add_include_path(File, Options) ->
+    case lists:keymember(include, 1, Options) of
+        true  -> Options;
+        false ->
+            Dir = filename:dirname(File),
+            {ok, Cwd} = file:get_cwd(),
+            [{include, {file_system, [Cwd, Dir]}} | Options]
+    end.
+
 -spec from_string(binary() | string(), options()) -> {ok, map()} | {error, binary()}.
-from_string(ContractBin, Options) when is_binary(ContractBin) ->
+from_string(Contract, Options) ->
-    from_string(binary_to_list(ContractBin), Options);
+    from_string(proplists:get_value(backend, Options, aevm), Contract, Options).
-from_string(ContractString, Options) ->
+
+from_string(Backend, ContractBin, Options) when is_binary(ContractBin) ->
+    from_string(Backend, binary_to_list(ContractBin), Options);
+from_string(Backend, ContractString, Options) ->
     try
-        #{icode := Icode} = string_to_icode(ContractString, Options),
+        from_string1(Backend, ContractString, Options)
-        TypeInfo  = extract_type_info(Icode),
-        Assembler = assemble(Icode, Options),
-        pp_assembler(Assembler, Options),
-        ByteCodeList = to_bytecode(Assembler, Options),
-        ByteCode = << << B:8 >> || B <- ByteCodeList >>,
-        pp_bytecode(ByteCode, Options),
-        {ok, Version} = version(),
-        {ok, #{byte_code => ByteCode,
-               compiler_version => Version,
-               contract_source => ContractString,
-               type_info => TypeInfo
-              }}
     catch
         %% The compiler errors.
         error:{parse_errors, Errors} ->
@@ -104,18 +110,65 @@ from_string(ContractString, Options) ->
         %% General programming errors in the compiler just signal error.
     end.
 
--spec string_to_icode(string(), [option()]) -> map().
+from_string1(aevm, ContractString, Options) ->
-string_to_icode(ContractString, Options) ->
+    #{icode := Icode} = string_to_code(ContractString, Options),
-    Ast = parse(ContractString, Options),
+    TypeInfo  = extract_type_info(Icode),
+    Assembler = assemble(Icode, Options),
+    pp_assembler(Assembler, Options),
+    ByteCodeList = to_bytecode(Assembler, Options),
+    ByteCode = << << B:8 >> || B <- ByteCodeList >>,
+    pp_bytecode(ByteCode, Options),
+    {ok, Version} = version(),
+    {ok, #{byte_code => ByteCode,
+           compiler_version => Version,
+           contract_source => ContractString,
+           type_info => TypeInfo,
+           abi_version => aeb_aevm_abi:abi_version(),
+           payable => maps:get(payable, Icode)
+          }};
+from_string1(fate, ContractString, Options) ->
+    #{fcode := FCode} = string_to_code(ContractString, Options),
+    FateCode = aeso_fcode_to_fate:compile(FCode, Options),
+    ByteCode = aeb_fate_code:serialize(FateCode, []),
+    {ok, Version} = version(),
+    {ok, #{byte_code => ByteCode,
+           compiler_version => Version,
+           contract_source => ContractString,
+           type_info => [],
+           fate_code => FateCode,
+           abi_version => aeb_fate_abi:abi_version(),
+           payable => maps:get(payable, FCode)
+          }}.
+
+-spec string_to_code(string(), options()) -> map().
+string_to_code(ContractString, Options) ->
+    Ast = case lists:member(no_implicit_stdlib, Options) of
+              true -> parse(ContractString, Options);
+              false ->
+                  IncludedSTD = sets:from_list(
+                                  [aeso_parser:hash_include(F, C)
+                                   || {F, C} <- aeso_stdlib:stdlib_list()]),
+                  InitAst = parse(ContractString, IncludedSTD, Options),
+                  STD = parse_stdlib(),
+                  STD ++ InitAst
+          end,
     pp_sophia_code(Ast, Options),
     pp_ast(Ast, Options),
     {TypeEnv, TypedAst} = aeso_ast_infer_types:infer(Ast, [return_env]),
     pp_typed_ast(TypedAst, Options),
-    Icode = ast_to_icode(TypedAst, Options),
+    case proplists:get_value(backend, Options, aevm) of
-    pp_icode(Icode, Options),
+        aevm ->
-    #{ typed_ast => TypedAst,
+            Icode = ast_to_icode(TypedAst, Options),
-       type_env  => TypeEnv,
+            pp_icode(Icode, Options),
-       icode     => Icode }.
+            #{ icode => Icode,
+               typed_ast => TypedAst,
+               type_env  => TypeEnv};
+        fate ->
+            Fcode = aeso_ast_to_fcode:ast_to_fcode(TypedAst, Options),
+            #{ fcode => Fcode,
+               typed_ast => TypedAst,
+               type_env  => TypeEnv}
+    end.
 
 join_errors(Prefix, Errors, Pfun) ->
     Ess = [ Pfun(E) || E <- Errors ],
@@ -130,14 +183,15 @@ join_errors(Prefix, Errors, Pfun) ->
 %% 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()]} | {error, term()}
+-spec check_call(string(), string(), [string()], options()) -> {ok, string(), {[Type], Type}, [term()]}
+                                                                   | {ok, string(), [term()]}
+                                                                   | {error, term()}
     when Type :: term().
 check_call(Source, "init" = FunName, Args, Options) ->
-    PatchFun = fun(T) -> {tuple, [typerep, T]} end,
+    case check_call1(Source, FunName, Args, Options) of
-    case check_call(Source, FunName, Args, Options, PatchFun) of
         Err = {error, _} when Args == [] ->
             %% Try with default init-function
-            case check_call(insert_init_function(Source, Options), FunName, Args, Options, PatchFun) of
+            case check_call1(insert_init_function(Source, Options), FunName, Args, Options) of
                 {error, _} -> Err; %% The first error is most likely better...
                 Res        -> Res
             end;
@@ -145,27 +199,46 @@ check_call(Source, "init" = FunName, Args, Options) ->
             Res
     end;
 check_call(Source, FunName, Args, Options) ->
-    PatchFun = fun(T) -> T end,
+    check_call1(Source, FunName, Args, Options).
-    check_call(Source, FunName, Args, Options, PatchFun).
 
-check_call(ContractString0, FunName, Args, Options, PatchFun) ->
+check_call1(ContractString0, FunName, Args, Options) ->
     try
-        %% First check the contract without the __call function
+        case proplists:get_value(backend, Options, aevm) of
-        #{} = string_to_icode(ContractString0, Options),
+            aevm ->
-        ContractString = insert_call_function(ContractString0, FunName, Args, Options),
+                %% First check the contract without the __call function
-        #{typed_ast := TypedAst,
+                #{} = string_to_code(ContractString0, Options),
-          icode     := Icode} = string_to_icode(ContractString, Options),
+                ContractString = insert_call_function(ContractString0, ?CALL_NAME, FunName, Args, Options),
-        {ok, {FunName, {fun_t, _, _, ArgTypes, RetType}}} = get_call_type(TypedAst),
+                #{typed_ast := TypedAst,
-        ArgVMTypes = [ aeso_ast_to_icode:ast_typerep(T, Icode) || T <- ArgTypes ],
+                  icode     := Icode} = string_to_code(ContractString, Options),
-        RetVMType  = case RetType of
+                {ok, {FunName, {fun_t, _, _, ArgTypes, RetType}}} = get_call_type(TypedAst),
-                         {id, _, "_"} -> any;
+                ArgVMTypes = [ aeso_ast_to_icode:ast_typerep(T, Icode) || T <- ArgTypes ],
-                         _            -> aeso_ast_to_icode:ast_typerep(RetType, Icode)
+                RetVMType  = case RetType of
-                     end,
+                                 {id, _, "_"} -> any;
-        #{ functions := Funs } = Icode,
+                                 _            -> aeso_ast_to_icode:ast_typerep(RetType, Icode)
-        ArgIcode = get_arg_icode(Funs),
+                             end,
-        ArgTerms = [ icode_to_term(T, Arg) ||
+                #{ functions := Funs } = Icode,
-                       {T, Arg} <- lists:zip(ArgVMTypes, ArgIcode) ],
+                ArgIcode = get_arg_icode(Funs),
-        {ok, FunName, {ArgVMTypes, PatchFun(RetVMType)}, ArgTerms}
+                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} = string_to_code(ContractString0, Options),
+                FateCode = aeso_fcode_to_fate:compile(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,
+                                            lists:seq($1, $9) ++ lists:seq($A, $Z) ++ lists:seq($a, $z)),
+                ContractString = insert_call_function(ContractString0, CallName, FunName, Args, Options),
+                #{fcode := Fcode} = string_to_code(ContractString, Options),
+                CallArgs = arguments_of_body(CallName, FunName, Fcode),
+                {ok, FunName, CallArgs}
+        end
     catch
         error:{parse_errors, Errors} ->
             {error, join_errors("Parse errors", Errors, fun (E) -> E end)};
@@ -179,16 +252,32 @@ check_call(ContractString0, FunName, Args, Options, PatchFun) ->
                                 fun (E) -> io_lib:format("~p", [E]) end)}
     end.
 
+arguments_of_body(CallName, _FunName, Fcode) ->
+    #{body := Body} = maps:get({entrypoint, list_to_binary(CallName)}, maps:get(functions, Fcode)),
+    {def, _FName, Args} = Body,
+    %% FName is either {entrypoint, list_to_binary(FunName)} or 'init'
+    [ aeso_fcode_to_fate:term_to_fate(A) || A <- Args ].
+
+first_none_match(_CallName, _Hashes, []) ->
+    error(unable_to_find_unique_call_name);
+first_none_match(CallName, Hashes, [Char|Chars]) ->
+    case not lists:member(aeb_fate_code:symbol_identifier(list_to_binary(CallName)), Hashes) of
+        true ->
+            CallName;
+        false ->
+            first_none_match(?CALL_NAME++[Char], Hashes, Chars)
+    end.
+
 %% Add the __call function to a contract.
--spec insert_call_function(string(), string(), [string()], options()) -> string().
+-spec insert_call_function(string(), string(), string(), [string()], options()) -> string().
-insert_call_function(Code, FunName, Args, Options) ->
+insert_call_function(Code, Call, FunName, Args, Options) ->
     Ast = parse(Code, Options),
     Ind = last_contract_indent(Ast),
     lists:flatten(
         [ Code,
           "\n\n",
           lists:duplicate(Ind, " "),
-          "stateful function __call() = ", FunName, "(", string:join(Args, ","), ")\n"
+          "stateful entrypoint ", Call, "() = ", FunName, "(", string:join(Args, ","), ")\n"
         ]).
 
 -spec insert_init_function(string(), options()) -> string().
@@ -198,7 +287,7 @@ insert_init_function(Code, Options) ->
     lists:flatten(
         [ Code,
           "\n\n",
-          lists:duplicate(Ind, " "), "function init() = ()\n"
+          lists:duplicate(Ind, " "), "entrypoint init() = ()\n"
         ]).
 
 last_contract_indent(Decls) ->
@@ -210,38 +299,60 @@ last_contract_indent(Decls) ->
 -spec to_sophia_value(string(), string(), ok | error | revert, aeb_aevm_data:data()) ->
         {ok, aeso_syntax:expr()} | {error, term()}.
 to_sophia_value(ContractString, Fun, ResType, Data) ->
-    to_sophia_value(ContractString, Fun, ResType, Data, []).
+    to_sophia_value(ContractString, Fun, ResType, Data, [{backend, aevm}]).
 
 -spec to_sophia_value(string(), string(), ok | error | revert, binary(), options()) ->
         {ok, aeso_syntax:expr()} | {error, term()}.
 to_sophia_value(_, _, error, Err, _Options) ->
     {ok, {app, [], {id, [], "error"}, [{string, [], Err}]}};
-to_sophia_value(_, _, revert, Data, _Options) ->
+to_sophia_value(_, _, revert, Data, Options) ->
-    case aeb_heap:from_binary(string, Data) of
+    case proplists:get_value(backend, Options, aevm) of
-        {ok, Err} -> {ok, {app, [], {id, [], "abort"}, [{string, [], Err}]}};
+        aevm ->
-        {error, _} = Err -> Err
+            case aeb_heap:from_binary(string, Data) of
+                {ok, Err} -> {ok, {app, [], {id, [], "abort"}, [{string, [], Err}]}};
+                {error, _} = Err -> Err
+            end;
+        fate ->
+            Err = aeb_fate_encoding:deserialize(Data),
+            {ok, {app, [], {id, [], "abort"}, [{string, [], Err}]}}
     end;
-to_sophia_value(ContractString, FunName, ok, Data, Options) ->
+to_sophia_value(ContractString, FunName, ok, Data, Options0) ->
+    Options = [no_implicit_stdlib, no_code | Options0],
     try
-        #{ typed_ast := TypedAst,
+        Code = string_to_code(ContractString, Options),
-           type_env  := TypeEnv,
+        #{ typed_ast := TypedAst, type_env  := TypeEnv} = Code,
-           icode     := Icode } = string_to_icode(ContractString, Options),
         {ok, _, Type0} = get_decode_type(FunName, TypedAst),
         Type   = aeso_ast_infer_types:unfold_types_in_type(TypeEnv, Type0, [unfold_record_types, unfold_variant_types]),
-        VmType = aeso_ast_to_icode:ast_typerep(Type, Icode),
+
-        case aeb_heap:from_binary(VmType, Data) of
+        case proplists:get_value(backend, Options, aevm) of
-            {ok, VmValue} ->
+            aevm ->
-                try
+                Icode  = maps:get(icode, Code),
-                    {ok, translate_vm_value(VmType, Type, VmValue)}
+                VmType = aeso_ast_to_icode:ast_typerep(Type, Icode),
-                catch throw:cannot_translate_to_sophia ->
+                case aeb_heap:from_binary(VmType, Data) of
-                    Type0Str = prettypr:format(aeso_pretty:type(Type0)),
+                    {ok, VmValue} ->
-                    {error, join_errors("Translation error", [lists:flatten(io_lib:format("Cannot translate VM value ~p\n  of type ~p\n  to Sophia type ~s\n",
+                        try
-                                                                            [Data, VmType, Type0Str]))],
+                            {ok, aeso_vm_decode:from_aevm(VmType, Type, VmValue)}
-                                        fun (E) -> E end)}
+                        catch throw:cannot_translate_to_sophia ->
+                            Type0Str = prettypr:format(aeso_pretty:type(Type0)),
+                            {error, join_errors("Translation error", [lists:flatten(io_lib:format("Cannot translate VM value ~p\n  of type ~p\n  to Sophia type ~s\n",
+                                                                                    [Data, VmType, Type0Str]))],
+                                                fun (E) -> E end)}
+                        end;
+                    {error, _Err} ->
+                        {error, join_errors("Decode errors", [lists:flatten(io_lib:format("Failed to decode binary at type ~p", [VmType]))],
+                                            fun(E) -> E end)}
                 end;
-            {error, _Err} ->
+            fate ->
-                {error, join_errors("Decode errors", [lists:flatten(io_lib:format("Failed to decode binary at type ~p", [VmType]))],
+               try
-                                    fun(E) -> E end)}
+                   {ok, aeso_vm_decode:from_fate(Type, aeb_fate_encoding:deserialize(Data))}
+               catch throw:cannot_translate_to_sophia ->
+                   {error, join_errors("Translation error",
+                                       [lists:flatten(io_lib:format("Cannot translate fate value ~p\n of Sophia type ~s\n",
+                                                                    [aeb_fate_encoding:deserialize(Data), Type]))],
+                                       fun (E) -> E end)};
+                     _:R ->
+                   {error, iolist_to_binary(io_lib:format("Decode error ~p: ~p\n", [R, erlang:get_stacktrace()]))}
+               end
         end
     catch
         error:{parse_errors, Errors} ->
@@ -256,101 +367,91 @@ to_sophia_value(ContractString, FunName, ok, Data, Options) ->
                                 fun (E) -> io_lib:format("~p", [E]) end)}
     end.
 
-address_literal(Type, N) -> {Type, [], <<N:256>>}.
-
-%% TODO: somewhere else
--spec translate_vm_value(aeb_aevm_data:type(), aeso_syntax:type(), aeb_aevm_data:data()) -> aeso_syntax:expr().
-translate_vm_value(word, {id, _, "address"},                     N) -> address_literal(account_pubkey, N);
-translate_vm_value(word, {app_t, _, {id, _, "oracle"}, _},       N) -> address_literal(oracle_pubkey, N);
-translate_vm_value(word, {app_t, _, {id, _, "oracle_query"}, _}, N) -> address_literal(oracle_query_id, N);
-translate_vm_value(word, {con, _, _Name},                        N) -> address_literal(contract_pubkey, N);
-translate_vm_value(word, {id, _, "int"},     N) -> {int, [], N};
-translate_vm_value(word, {id, _, "bits"},    N) -> error({todo, bits, N});
-translate_vm_value(word, {id, _, "bool"},    N) -> {bool, [], N /= 0};
-translate_vm_value(word, {bytes_t, _, Len}, Val) when Len =< 32 ->
-    {bytes, [], <<Val:Len/unit:8>>};
-translate_vm_value({tuple, _}, {bytes_t, _, Len}, Val) ->
-    {bytes, [], binary:part(<< <<W:32/unit:8>> || W <- tuple_to_list(Val) >>, 0, Len)};
-translate_vm_value(string, {id, _, "string"}, S) -> {string, [], S};
-translate_vm_value({list, VmType}, {app_t, _, {id, _, "list"}, [Type]}, List) ->
-    {list, [], [translate_vm_value(VmType, Type, X) || X <- List]};
-translate_vm_value({option, VmType}, {app_t, _, {id, _, "option"}, [Type]}, Val) ->
-    case Val of
-        none              -> {con, [], "None"};
-        {some, X}         -> {app, [], {con, [], "Some"}, [translate_vm_value(VmType, Type, X)]}
-    end;
-translate_vm_value({variant, [[], [VmType]]}, {app_t, _, {id, _, "option"}, [Type]}, Val) ->
-    case Val of
-        {variant, 0, []}  -> {con, [], "None"};
-        {variant, 1, [X]} -> {app, [], {con, [], "Some"}, [translate_vm_value(VmType, Type, X)]}
-    end;
-translate_vm_value({tuple, VmTypes}, {tuple_t, _, Types}, Val)
-        when length(VmTypes) == length(Types),
-             length(VmTypes) == tuple_size(Val) ->
-    {tuple, [], [translate_vm_value(VmType, Type, X)
-                 || {VmType, Type, X} <- lists:zip3(VmTypes, Types, tuple_to_list(Val))]};
-translate_vm_value({tuple, VmTypes}, {record_t, Fields}, Val)
-        when length(VmTypes) == length(Fields),
-             length(VmTypes) == tuple_size(Val) ->
-    {record, [], [ {field, [], [{proj, [], FName}], translate_vm_value(VmType, FType, X)}
-                   || {VmType, {field_t, _, FName, FType}, X} <- lists:zip3(VmTypes, Fields, tuple_to_list(Val)) ]};
-translate_vm_value({map, VmKeyType, VmValType}, {app_t, _, {id, _, "map"}, [KeyType, ValType]}, Map)
-        when is_map(Map) ->
-    {map, [], [ {translate_vm_value(VmKeyType, KeyType, Key),
-                 translate_vm_value(VmValType, ValType, Val)}
-                || {Key, Val} <- maps:to_list(Map) ]};
-translate_vm_value({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),
-    translate_vm_value(VmTypes, ConType, Args);
-translate_vm_value(VmTypes, {constr_t, _, Con, Types}, Args)
-        when length(VmTypes) == length(Types),
-             length(VmTypes) == length(Args) ->
-    {app, [], Con, [ translate_vm_value(VmType, Type, Arg)
-                     || {VmType, Type, Arg} <- lists:zip3(VmTypes, Types, Args) ]};
-translate_vm_value(_VmType, _Type, _Data) ->
-    throw(cannot_translate_to_sophia).
 
 -spec create_calldata(string(), string(), [string()]) ->
                              {ok, binary(), aeb_aevm_data:type(), aeb_aevm_data:type()}
                              | {error, term()}.
 create_calldata(Code, Fun, Args) ->
-    case check_call(Code, Fun, Args, []) of
+    create_calldata(Code, Fun, Args, [{backend, aevm}]).
-        {ok, FunName, {ArgTypes, RetType}, VMArgs} ->
+
-            aeb_abi:create_calldata(FunName, VMArgs, ArgTypes, RetType);
+-spec create_calldata(string(), string(), [string()], [{atom(), any()}]) ->
-        {error, _} = Err -> Err
+                             {ok, binary()}
+                             | {error, term()}.
+create_calldata(Code, Fun, Args, Options0) ->
+    Options = [no_implicit_stdlib, 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, term()}.
 decode_calldata(ContractString, FunName, Calldata) ->
+    decode_calldata(ContractString, FunName, Calldata, [{backend, aevm}]).
+
+decode_calldata(ContractString, FunName, Calldata, Options0) ->
+    Options = [no_implicit_stdlib, no_code | Options0],
     try
-        #{ typed_ast := TypedAst,
+        Code = string_to_code(ContractString, Options),
-           type_env  := TypeEnv,
+        #{ typed_ast := TypedAst, type_env  := TypeEnv} = Code,
-           icode     := Icode } = string_to_icode(ContractString, []),
+
         {ok, Args, _} = get_decode_type(FunName, TypedAst),
         DropArg       = fun({arg, _, _, T}) -> T; (T) -> T end,
         ArgTypes      = lists:map(DropArg, Args),
         Type0         = {tuple_t, [], ArgTypes},
-        Type   = aeso_ast_infer_types:unfold_types_in_type(TypeEnv, Type0, [unfold_record_types, unfold_variant_types]),
+        %% user defined data types such as variants needed to match against
-        VmType = aeso_ast_to_icode:ast_typerep(Type, Icode),
+        Type          = aeso_ast_infer_types:unfold_types_in_type(TypeEnv, Type0, [unfold_record_types, unfold_variant_types]),
-        case aeb_heap:from_binary({tuple, [word, VmType]}, Calldata) of
+        case proplists:get_value(backend, Options, aevm) of
-            {ok, {_, VmValue}} ->
+            aevm ->
-                try
+                Icode  = maps:get(icode, Code),
-                    {tuple, [], Values} = translate_vm_value(VmType, Type, VmValue),
+                VmType = aeso_ast_to_icode:ast_typerep(Type, Icode),
-                    {ok, ArgTypes, Values}
+                case aeb_heap:from_binary({tuple, [word, VmType]}, Calldata) of
-                catch throw:cannot_translate_to_sophia ->
+                    {ok, {_, VmValue}} ->
-                    Type0Str = prettypr:format(aeso_pretty:type(Type0)),
+                        try
-                    {error, join_errors("Translation error", [lists:flatten(io_lib:format("Cannot translate VM value ~p\n  of type ~p\n  to Sophia type ~s\n",
+                            {tuple, [], Values} = aeso_vm_decode:from_aevm(VmType, Type, VmValue),
-                                                                            [VmValue, VmType, Type0Str]))],
+                            %% Values are Sophia expressions in AST format
-                                        fun (E) -> E end)}
+                            {ok, ArgTypes, Values}
+                        catch throw:cannot_translate_to_sophia ->
+                                Type0Str = prettypr:format(aeso_pretty:type(Type0)),
+                                {error, join_errors("Translation error",
+                                                    [lists:flatten(io_lib:format("Cannot translate VM value ~p\n  of type ~p\n  to Sophia type ~s\n",
+                                                                                 [VmValue, VmType, Type0Str]))],
+                                                    fun (E) -> E end)}
+                        end;
+                    {error, _Err} ->
+                        {error, join_errors("Decode errors", [lists:flatten(io_lib:format("Failed to decode binary at type ~p", [VmType]))],
+                                            fun(E) -> E end)}
                 end;
-            {error, _Err} ->
+            fate ->
-                {error, join_errors("Decode errors", [lists:flatten(io_lib:format("Failed to decode binary at type ~p", [VmType]))],
+                case aeb_fate_abi:decode_calldata(FunName, Calldata) of
-                                    fun(E) -> E end)}
+                    {ok, FateArgs} ->
+                        try
+                            {tuple_t, [], ArgTypes1} = Type,
+                            AstArgs = [ aeso_vm_decode:from_fate(ArgType, FateArg)
+                                        || {ArgType, FateArg} <- lists:zip(ArgTypes1, FateArgs)],
+                            {ok, ArgTypes, AstArgs}
+                        catch throw:cannot_translate_to_sophia ->
+                                Type0Str = prettypr:format(aeso_pretty:type(Type0)),
+                                {error, join_errors("Translation error",
+                                                    [lists:flatten(io_lib:format("Cannot translate fate value ~p\n of Sophia type ~s\n",
+                                                                                 [FateArgs, Type0Str]))],
+                                                    fun (E) -> E end)}
+                        end;
+                    {error, _} ->
+                        {error, join_errors("Decode errors", ["Failed to decode binary"],
+                                            fun(E) -> E end)}
+                end
         end
     catch
         error:{parse_errors, Errors} ->
@@ -365,7 +466,6 @@ decode_calldata(ContractString, FunName, Calldata) ->
                                 fun (E) -> io_lib:format("~p", [E]) end)}
     end.
 
-
 get_arg_icode(Funs) ->
     case [ Args || {[_, ?CALL_NAME], _, _, {funcall, _, Args}, _} <- Funs ] of
         [Args] -> Args;
@@ -391,7 +491,11 @@ get_decode_type(FunName, [{contract, _, _, Defs}]) ->
                  (_) -> [] end,
     case lists:flatmap(GetType, Defs) of
         [{Args, Ret}] -> {ok, Args, Ret};
-        []            -> {error, missing_function}
+        []            ->
+            case FunName of
+                "init" -> {ok, [], {tuple_t, [], []}};
+                 _ -> {error, missing_function}
+            end
     end;
 get_decode_type(FunName, [_ | Contracts]) ->
     %% The __decode should be in the final contract
@@ -400,6 +504,7 @@ 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;
@@ -446,8 +551,9 @@ to_bytecode([], _) -> [].
 
 extract_type_info(#{functions := Functions} =_Icode) ->
     ArgTypesOnly = fun(As) -> [ T || {_, T} <- As ] end,
-    TypeInfo = [aeb_abi:function_type_info(list_to_binary(lists:last(Name)),
+    Payable = fun(Attrs) -> proplists:get_value(payable, Attrs, false) end,
-                                            ArgTypesOnly(Args), TypeRep)
+    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)
@@ -471,9 +577,16 @@ pp(Code, Options, Option, PPFun) ->
             ok
     end.
 
-
 %% -------------------------------------------------------------------
-%% TODO: Tempoary parser hook below...
+
+-spec parse_stdlib() -> none() | aeso_syntax:ast().
+parse_stdlib() ->
+    lists:foldr(
+      fun ({Lib, LibCode}, Acc) ->
+              parse(LibCode, [{src_file, binary_to_list(Lib)}]) ++ Acc
+      end,
+      [],
+      aeso_stdlib:stdlib_list()).
 
 sophia_type_to_typerep(String) ->
     {ok, Ast} = aeso_parser:type(String),
@@ -482,9 +595,14 @@ sophia_type_to_typerep(String) ->
     catch _:_ -> {error, bad_type}
     end.
 
+-spec parse(string(), aeso_compiler:options()) -> none() | aeso_syntax:ast().
 parse(Text, Options) ->
+    parse(Text, sets:new(), Options).
+
+-spec parse(string(), sets:set(), aeso_compiler:options()) -> none() | aeso_syntax:ast().
+parse(Text, Included, Options) ->
     %% Try and return something sensible here!
-    case aeso_parser:string(Text, Options) of
+    case aeso_parser:string(Text, Included, Options) of
         %% Yay, it worked!
         {ok, Contract} -> Contract;
         %% Scan errors.
@@ -503,6 +621,7 @@ parse(Text, Options) ->
             parse_error(Pos, io_lib:format("could not find include file '~s'", [File]))
     end.
 
+-spec parse_error(aeso_parse_lib:pos(), string()) -> none().
 parse_error(Pos, ErrorString) ->
     Error = io_lib:format("~s: ~s", [pos_error(Pos), ErrorString]),
     error({parse_errors, [Error]}).
@@ -516,4 +635,3 @@ pos_error({no_file, Line, Pos}) ->
     pos_error({Line, Pos});
 pos_error({File, Line, Pos}) ->
     io_lib:format("file ~s, line ~p, column ~p", [File, Line, Pos]).
-

src/aeso_fcode_to_fate.erl

@@ -9,7 +9,7 @@
 %%%-------------------------------------------------------------------
 -module(aeso_fcode_to_fate).
 
--export([compile/2]).
+-export([compile/2, term_to_fate/1]).
 
 %% -- Preamble ---------------------------------------------------------------
 
@@ -18,7 +18,7 @@
                 | switch_body
                 | tuple().    %% FATE instruction
 
--type arg() :: tuple(). %% Not exported: aeb_fate_code:fate_arg().
+-type arg() :: tuple(). %% Not exported: aeb_fate_ops:fate_arg().
 
 %% Annotated scode
 -type scode_a()  :: [sinstr_a()].
@@ -39,6 +39,9 @@
 -define(i(X), {immediate, X}).
 -define(a, {stack, 0}).
 -define(s, {var, -1}).  %% TODO: until we have state support in FATE
+-define(void, {var, 9999}).
+
+-define(IsState(X), (is_tuple(X) andalso tuple_size(X) =:= 2 andalso element(1, X) =:= var andalso element(2, X) < 0)).
 
 -define(IsOp(Op), (
      Op =:= 'STORE'           orelse
@@ -65,6 +68,8 @@
      Op =:= 'MAP_DELETE'      orelse
      Op =:= 'MAP_MEMBER'      orelse
      Op =:= 'MAP_FROM_LIST'   orelse
+     Op =:= 'MAP_TO_LIST'     orelse
+     Op =:= 'MAP_SIZE'        orelse
      Op =:= 'NIL'             orelse
      Op =:= 'IS_NIL'          orelse
      Op =:= 'CONS'            orelse
@@ -76,6 +81,7 @@
      Op =:= 'INT_TO_STR'      orelse
      Op =:= 'ADDR_TO_STR'     orelse
      Op =:= 'STR_REVERSE'     orelse
+     Op =:= 'STR_LENGTH'      orelse
      Op =:= 'INT_TO_ADDR'     orelse
      Op =:= 'VARIANT_TEST'    orelse
      Op =:= 'VARIANT_ELEMENT' orelse
@@ -89,6 +95,23 @@
      Op =:= 'BITS_OR'         orelse
      Op =:= 'BITS_AND'        orelse
      Op =:= 'BITS_DIFF'       orelse
+     Op =:= 'SHA3'            orelse
+     Op =:= 'SHA256'          orelse
+     Op =:= 'BLAKE2B'         orelse
+     Op =:= 'VERIFY_SIG'           orelse
+     Op =:= 'VERIFY_SIG_SECP256K1' orelse
+     Op =:= 'ECVERIFY_SECP256K1'   orelse
+     Op =:= 'ECRECOVER_SECP256K1'  orelse
+     Op =:= 'CONTRACT_TO_ADDRESS'  orelse
+     Op =:= 'AUTH_TX_HASH'         orelse
+     Op =:= 'BYTES_TO_INT'         orelse
+     Op =:= 'BYTES_TO_STR'         orelse
+     Op =:= 'ORACLE_CHECK'         orelse
+     Op =:= 'ORACLE_CHECK_QUERY'   orelse
+     Op =:= 'IS_ORACLE'            orelse
+     Op =:= 'IS_CONTRACT'          orelse
+     Op =:= 'IS_PAYABLE'           orelse
+     Op =:= 'CREATOR'              orelse
      false)).
 
 -record(env, { contract, vars = [], locals = [], tailpos = true }).
@@ -107,41 +130,69 @@ debug(Tag, Options, Fmt, Args) ->
 %% @doc Main entry point.
 compile(FCode, Options) ->
     #{ contract_name := ContractName,
-       state_type    := _StateType,
        functions     := Functions } = FCode,
     SFuns  = functions_to_scode(ContractName, Functions, Options),
     SFuns1 = optimize_scode(SFuns, Options),
-    BBFuns = to_basic_blocks(SFuns1, Options),
+    FateCode = to_basic_blocks(SFuns1),
-    FateCode = #{ functions   => BBFuns,
-                  symbols     => #{},
-                  annotations => #{} },
     debug(compile, Options, "~s\n", [aeb_fate_asm:pp(FateCode)]),
     FateCode.
 
-make_function_name(init)               -> <<"init">>;
+make_function_id(X) ->
+    aeb_fate_code:symbol_identifier(make_function_name(X)).
+
+make_function_name(init)               -> <<"INIT">>;
+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) ->
     FunNames = maps:keys(Functions),
     maps:from_list(
-        [ {make_function_name(Name), function_to_scode(ContractName, FunNames, Name, Args, Body, Type, Options)}
+        [ {make_function_name(Name), function_to_scode(ContractName, FunNames, Name, Attrs, Args, Body, Type, Options)}
         || {Name, #{args   := Args,
                     body   := Body,
-                    return := Type}} <- maps:to_list(Functions),
+                    attrs  := Attrs,
-           Name /= init ]).  %% TODO: skip init for now
+                    return := Type}} <- maps:to_list(Functions)]).
 
-function_to_scode(ContractName, Functions, _Name, Args, Body, ResType, _Options) ->
+function_to_scode(ContractName, Functions, _Name, Attrs0, Args, Body, ResType, _Options) ->
-    ArgTypes = [ type_to_scode(T) || {_, T} <- Args ],
+    {ArgTypes, ResType1} = typesig_to_scode(Args, ResType),
-    SCode    = to_scode(init_env(ContractName, Functions, Args), Body),
+    Attrs = Attrs0 -- [stateful], %% Only track private and payable from here.
-    {{ArgTypes, type_to_scode(ResType)}, SCode}.
+    SCode = to_scode(init_env(ContractName, Functions, Args), Body),
+    {Attrs, {ArgTypes, ResType1}, SCode}.
 
-type_to_scode({variant, Cons}) -> {variant, lists:map(fun length/1, Cons)};
+-define(tvars, '$tvars').
+
+typesig_to_scode(Args, Res) ->
+    put(?tvars, {0, #{}}),
+    R = {[type_to_scode(T) || {_, T} <- Args], type_to_scode(Res)},
+    erase(?tvars),
+    R.
+
+type_to_scode(integer)         -> integer;
+type_to_scode(boolean)         -> boolean;
+type_to_scode(string)          -> string;
+type_to_scode(address)         -> address;
+type_to_scode({bytes, N})      -> {bytes, N};
+type_to_scode(contract)        -> contract;
+type_to_scode({oracle, _, _})  -> oracle;
+type_to_scode(oracle_query)    -> oracle_query;
+type_to_scode(name)            -> name;
+type_to_scode(channel)         -> channel;
+type_to_scode(bits)            -> bits;
+type_to_scode(any)             -> any;
+type_to_scode({variant, Cons}) -> {variant, lists:map(fun(T) -> type_to_scode({tuple, T}) end, Cons)};
 type_to_scode({list, Type})    -> {list, type_to_scode(Type)};
 type_to_scode({tuple, Types})  -> {tuple, lists:map(fun type_to_scode/1, Types)};
 type_to_scode({map, Key, Val}) -> {map, type_to_scode(Key), type_to_scode(Val)};
 type_to_scode({function, _Args, _Res}) -> {tuple, [string, any]};
-type_to_scode(T)               -> T.
+type_to_scode({tvar, X}) ->
+    {I, Vars} = get(?tvars),
+    case maps:get(X, Vars, false) of
+        false ->
+            put(?tvars, {I + 1, Vars#{ X => I }}),
+            {tvar, I};
+        J -> {tvar, J}
+    end.
 
 %% -- Phase I ----------------------------------------------------------------
 %%  Icode to structured assembly
@@ -176,19 +227,49 @@ lookup_var(#env{vars = Vars}, X) ->
 
 %% -- The compiler --
 
-to_scode(_Env, {lit, L}) ->
+lit_to_fate(L) ->
     case L of
-        {int, N}             -> [push(?i(N))];
+        {int, N}             -> aeb_fate_data:make_integer(N);
-        {string, S}          -> [push(?i(aeb_fate_data:make_string(S)))];
+        {string, S}          -> aeb_fate_data:make_string(S);
-        {bool, B}            -> [push(?i(B))];
+        {bytes, B}           -> aeb_fate_data:make_bytes(B);
-        {account_pubkey, K}  -> [push(?i(aeb_fate_data:make_address(K)))];
+        {bool, B}            -> aeb_fate_data:make_boolean(B);
-        {contract_pubkey, K} -> [push(?i(aeb_fate_data:make_contract(K)))];
+        {account_pubkey, K}  -> aeb_fate_data:make_address(K);
-        {oracle_pubkey, K}   -> [push(?i(aeb_fate_data:make_oracle(K)))];
+        {contract_pubkey, K} -> aeb_fate_data:make_contract(K);
-        {oracle_query_id, _} -> ?TODO(fate_oracle_query_id_value)
+        {oracle_pubkey, K}   -> aeb_fate_data:make_oracle(K);
-    end;
+        {oracle_query_id, H} -> aeb_fate_data:make_oracle_query(H);
+        {typerep, T}         -> aeb_fate_data:make_typerep(type_to_scode(T))
+     end.
+
+term_to_fate({lit, L}) ->
+    lit_to_fate(L);
+%% negative literals are parsed as 0 - N
+term_to_fate({op, '-', [{lit, {int, 0}}, {lit, {int, N}}]}) ->
+    aeb_fate_data:make_integer(-N);
+term_to_fate(nil) ->
+    aeb_fate_data:make_list([]);
+term_to_fate({op, '::', [Hd, Tl]}) ->
+    %% The Tl will translate into a list, because FATE lists are just lists
+    [term_to_fate(Hd) | term_to_fate(Tl)];
+term_to_fate({tuple, As}) ->
+    aeb_fate_data:make_tuple(list_to_tuple([ term_to_fate(A) || A<-As]));
+term_to_fate({con, Ar, I, As}) ->
+    FateAs = [ term_to_fate(A) || A <- As ],
+    aeb_fate_data:make_variant(Ar, I, list_to_tuple(FateAs));
+term_to_fate({builtin, map_empty, []}) ->
+    aeb_fate_data:make_map(#{});
+term_to_fate({'let', _, {builtin, map_empty, []}, Set}) ->
+    aeb_fate_data:make_map(map_to_fate(Set)).
+
+map_to_fate({op, map_set, [{var, _}, K, V]}) ->
+    #{term_to_fate(K) => term_to_fate(V)};
+map_to_fate({op, map_set, [Set, K, V]}) ->
+    Map = map_to_fate(Set), Map#{term_to_fate(K) => term_to_fate(V)}.
+
+to_scode(_Env, {lit, L}) ->
+    [push(?i(lit_to_fate(L)))];
 
 to_scode(_Env, nil) ->
-    [aeb_fate_code:nil(?a)];
+    [aeb_fate_ops:nil(?a)];
 
 to_scode(Env, {var, X}) ->
     [push(lookup_var(Env, X))];
@@ -196,21 +277,21 @@ to_scode(Env, {var, X}) ->
 to_scode(Env, {con, Ar, I, As}) ->
     N = length(As),
     [[to_scode(notail(Env), A) || A <- As],
-     aeb_fate_code:variant(?a, ?i(Ar), ?i(I), ?i(N))];
+     aeb_fate_ops:variant(?a, ?i(Ar), ?i(I), ?i(N))];
 
 to_scode(Env, {tuple, As}) ->
     N = length(As),
     [[ to_scode(notail(Env), A) || A <- As ],
-     aeb_fate_code:tuple(N)];
+     tuple(N)];
 
 to_scode(Env, {proj, E, I}) ->
     [to_scode(notail(Env), E),
-     aeb_fate_code:element_op(?a, ?i(I), ?a)];
+     aeb_fate_ops:element_op(?a, ?i(I), ?a)];
 
 to_scode(Env, {set_proj, R, I, E}) ->
     [to_scode(notail(Env), E),
      to_scode(notail(Env), R),
-     aeb_fate_code:setelement(?a, ?i(I), ?a, ?a)];
+     aeb_fate_ops:setelement(?a, ?i(I), ?a, ?a)];
 
 to_scode(Env, {op, Op, Args}) ->
     call_to_scode(Env, op_to_scode(Op), Args);
@@ -221,11 +302,11 @@ to_scode(Env, {'let', X, {var, Y}, Body}) ->
 to_scode(Env, {'let', X, Expr, Body}) ->
     {I, Env1} = bind_local(X, Env),
     [ to_scode(notail(Env), Expr),
-      aeb_fate_code:store({var, I}, {stack, 0}),
+      aeb_fate_ops:store({var, I}, {stack, 0}),
       to_scode(Env1, Body) ];
 
 to_scode(Env, {def, Fun, Args}) ->
-    FName = make_function_name(Fun),
+    FName = make_function_id(Fun),
     Lbl   = aeb_fate_data:make_string(FName),
     call_to_scode(Env, local_call(Env, ?i(Lbl)), Args);
 to_scode(Env, {funcall, Fun, Args}) ->
@@ -234,30 +315,28 @@ to_scode(Env, {funcall, Fun, Args}) ->
 to_scode(Env, {builtin, B, Args}) ->
     builtin_to_scode(Env, B, Args);
 
-to_scode(Env, {remote, Ct, Fun, [{builtin, call_gas_left, _}, Value | Args]}) ->
+to_scode(Env, {remote, ArgsT, RetT, Ct, Fun, [Gas, Value | Args]}) ->
-    %% Gas is not limited.
+    Lbl = make_function_id(Fun),
-    Lbl = make_function_name(Fun),
+    {ArgTypes, RetType0} = typesig_to_scode([{"_", T} || T <- ArgsT], RetT),
-    Call = if Env#env.tailpos -> aeb_fate_code:call_tr(?a, Lbl, ?a);
+    ArgType = ?i(aeb_fate_data:make_typerep({tuple, ArgTypes})),
-              true            -> aeb_fate_code:call_r(?a, Lbl, ?a)
+    RetType = ?i(aeb_fate_data:make_typerep(RetType0)),
-           end,
+    case Gas of
-    call_to_scode(Env, Call, [Ct, Value | Args]);
+        {builtin, call_gas_left, _} ->
-
+            Call = aeb_fate_ops:call_r(?a, Lbl, ArgType, RetType, ?a),
-to_scode(Env, {remote, Ct, Fun, [Gas, Value | Args]}) ->
+            call_to_scode(Env, Call, [Ct, Value | Args]);
-    %% Gas is limited.
+        _ ->
-    Lbl = make_function_name(Fun),
+            Call = aeb_fate_ops:call_gr(?a, Lbl, ArgType, RetType, ?a, ?a),
-    Call = if Env#env.tailpos -> aeb_fate_code:call_gtr(?a, Lbl, ?a, ?a);
+            call_to_scode(Env, Call, [Ct, Value, Gas | Args])
-              true            -> aeb_fate_code:call_gr(?a, Lbl, ?a, ?a)
+    end;
-           end,
-    call_to_scode(Env, Call, [Ct, Value, Gas | Args]);
 
 to_scode(Env, {closure, Fun, FVs}) ->
-    to_scode(Env, {tuple, [{lit, {string, make_function_name(Fun)}}, FVs]});
+    to_scode(Env, {tuple, [{lit, {string, make_function_id(Fun)}}, FVs]});
 
 to_scode(Env, {switch, Case}) ->
     split_to_scode(Env, Case).
 
-local_call( Env, Fun) when Env#env.tailpos -> aeb_fate_code:call_t(Fun);
+local_call( Env, Fun) when Env#env.tailpos -> aeb_fate_ops:call_t(Fun);
-local_call(_Env, Fun)                      -> aeb_fate_code:call(Fun).
+local_call(_Env, Fun)                      -> aeb_fate_ops:call(Fun).
 
 split_to_scode(Env, {nosplit, Expr}) ->
     [switch_body, to_scode(Env, Expr)];
@@ -295,13 +374,13 @@ split_to_scode(Env, {split, {list, _}, X, Alts}) ->
                      [{'case', {'::', Y, Z}, S} | _] ->
                          {I, Env1} = bind_local(Y, Env),
                          {J, Env2} = bind_local(Z, Env1),
-                         [aeb_fate_code:hd({var, I}, Arg),
+                         [aeb_fate_ops:hd({var, I}, Arg),
-                          aeb_fate_code:tl({var, J}, Arg),
+                          aeb_fate_ops:tl({var, J}, Arg),
                           split_to_scode(Env2, S)]
                  end
              end,
     SAlts = [GetAlt('::'), GetAlt(nil)],
-    [aeb_fate_code:is_nil(?a, Arg),
+    [aeb_fate_ops:is_nil(?a, Arg),
      {switch, ?a, boolean, SAlts, Def}];
 split_to_scode(Env, {split, Type, X, Alts}) when Type == integer; Type == string ->
     {Def, Alts1} = catchall_to_scode(Env, X, Alts),
@@ -337,7 +416,7 @@ literal_split_to_scode(Env, Type, Arg, [{'case', Lit, Body} | Alts], Def) when T
                {int, N} -> N;
                {string, S} -> aeb_fate_data:make_string(S)
            end,
-    [aeb_fate_code:eq(?a, Arg, ?i(SLit)),
+    [aeb_fate_ops:eq(?a, Arg, ?i(SLit)),
      {switch, ?a, boolean, [False, True], Def}].
 
 catchall_to_scode(Env, X, Alts) -> catchall_to_scode(Env, X, Alts, []).
@@ -351,10 +430,10 @@ catchall_to_scode(_, _, [], Acc) -> {missing, lists:reverse(Acc)}.
 
 %% Tuple is in the accumulator. Arguments are the variable names.
 match_tuple(Env, Arg, Xs) ->
-    match_tuple(Env, 0, fun aeb_fate_code:element_op/3, Arg, Xs).
+    match_tuple(Env, 0, fun aeb_fate_ops:element_op/3, Arg, Xs).
 
 match_variant(Env, Arg, Xs) ->
-    Elem = fun(Dst, I, Val) -> aeb_fate_code:variant_element(Dst, Val, I) end,
+    Elem = fun(Dst, I, Val) -> aeb_fate_ops:variant_element(Dst, Val, I) end,
     match_tuple(Env, 0, Elem, Arg, Xs).
 
 match_tuple(Env, I, Elem, Arg, ["_" | Xs]) ->
@@ -375,126 +454,153 @@ call_to_scode(Env, CallCode, Args) ->
 builtin_to_scode(_Env, get_state, []) ->
     [push(?s)];
 builtin_to_scode(Env, set_state, [_] = Args) ->
-    call_to_scode(Env, [aeb_fate_code:store(?s, ?a),
+    call_to_scode(Env, [aeb_fate_ops:store(?s, ?a),
-                        aeb_fate_code:tuple(0)], Args);
+                        tuple(0)], Args);
-builtin_to_scode(_Env, event, [_] = _Args) ->
+builtin_to_scode(Env, chain_event, Args) ->
-    ?TODO(fate_event_instruction);
+    call_to_scode(Env, [erlang:apply(aeb_fate_ops, log, lists:duplicate(length(Args), ?a)),
+                        tuple(0)], Args);
 builtin_to_scode(_Env, map_empty, []) ->
-    [aeb_fate_code:map_empty(?a)];
+    [aeb_fate_ops:map_empty(?a)];
 builtin_to_scode(_Env, bits_none, []) ->
-    [aeb_fate_code:bits_none(?a)];
+    [aeb_fate_ops:bits_none(?a)];
 builtin_to_scode(_Env, bits_all, []) ->
-    [aeb_fate_code:bits_all(?a)];
+    [aeb_fate_ops:bits_all(?a)];
+builtin_to_scode(Env, bytes_to_int, [_] = Args) ->
+    call_to_scode(Env, aeb_fate_ops:bytes_to_int(?a, ?a), Args);
+builtin_to_scode(Env, bytes_to_str, [_] = Args) ->
+    call_to_scode(Env, aeb_fate_ops:bytes_to_str(?a, ?a), Args);
 builtin_to_scode(Env, abort, [_] = Args) ->
-    call_to_scode(Env, aeb_fate_code:abort(?a), Args);
+    call_to_scode(Env, aeb_fate_ops:abort(?a), Args);
 builtin_to_scode(Env, chain_spend, [_, _] = Args) ->
-    call_to_scode(Env, [aeb_fate_code:spend(?a, ?a),
+    call_to_scode(Env, [aeb_fate_ops:spend(?a, ?a),
-                        aeb_fate_code:tuple(0)], Args);
+                        tuple(0)], Args);
 builtin_to_scode(Env, chain_balance, [_] = Args) ->
-    call_to_scode(Env, aeb_fate_code:balance_other(?a, ?a), Args);
+    call_to_scode(Env, aeb_fate_ops:balance_other(?a, ?a), Args);
 builtin_to_scode(Env, chain_block_hash, [_] = Args) ->
-    call_to_scode(Env, aeb_fate_code:blockhash(?a, ?a), Args);
+    call_to_scode(Env, aeb_fate_ops:blockhash(?a, ?a), Args);
 builtin_to_scode(_Env, chain_coinbase, []) ->
-    [aeb_fate_code:beneficiary(?a)];
+    [aeb_fate_ops:beneficiary(?a)];
 builtin_to_scode(_Env, chain_timestamp, []) ->
-    [aeb_fate_code:timestamp(?a)];
+    [aeb_fate_ops:timestamp(?a)];
 builtin_to_scode(_Env, chain_block_height, []) ->
-    [aeb_fate_code:generation(?a)];
+    [aeb_fate_ops:generation(?a)];
 builtin_to_scode(_Env, chain_difficulty, []) ->
-    [aeb_fate_code:difficulty(?a)];
+    [aeb_fate_ops:difficulty(?a)];
 builtin_to_scode(_Env, chain_gas_limit, []) ->
-    [aeb_fate_code:gaslimit(?a)];
+    [aeb_fate_ops:gaslimit(?a)];
 builtin_to_scode(_Env, contract_balance, []) ->
-    [aeb_fate_code:balance(?a)];
+    [aeb_fate_ops:balance(?a)];
 builtin_to_scode(_Env, contract_address, []) ->
-    [aeb_fate_code:address(?a)];
+    [aeb_fate_ops:address(?a)];
+builtin_to_scode(_Env, contract_creator, []) ->
+    [aeb_fate_ops:contract_creator(?a)];
 builtin_to_scode(_Env, call_origin, []) ->
-    [aeb_fate_code:origin(?a)];
+    [aeb_fate_ops:origin(?a)];
 builtin_to_scode(_Env, call_caller, []) ->
-    [aeb_fate_code:caller(?a)];
+    [aeb_fate_ops:caller(?a)];
 builtin_to_scode(_Env, call_value, []) ->
-    [aeb_fate_code:call_value(?a)];
+    [aeb_fate_ops:call_value(?a)];
 builtin_to_scode(_Env, call_gas_price, []) ->
-    [aeb_fate_code:gasprice(?a)];
+    [aeb_fate_ops:gasprice(?a)];
 builtin_to_scode(_Env, call_gas_left, []) ->
-    [aeb_fate_code:gas(?a)];
+    [aeb_fate_ops:gas(?a)];
-builtin_to_scode(_Env, oracle_register, [_, _, _, _] = _Args) ->
+builtin_to_scode(Env, oracle_register, [_Sign,_Account,_QFee,_TTL,_QType,_RType] = Args) ->
-    ?TODO(fate_oracle_register_instruction);
+    call_to_scode(Env, aeb_fate_ops:oracle_register(?a, ?a, ?a, ?a, ?a, ?a, ?a), Args);
-builtin_to_scode(_Env, oracle_query_fee, [_] = _Args) ->
+builtin_to_scode(Env, oracle_query_fee, [_Oracle] = Args) ->
-    ?TODO(fate_oracle_query_fee_instruction);
+    call_to_scode(Env, aeb_fate_ops:oracle_query_fee(?a, ?a), Args);
-builtin_to_scode(_Env, oracle_query, [_, _, _, _, _] = _Args) ->
+builtin_to_scode(Env, oracle_query, [_Oracle, _Question, _QFee, _QTTL, _RTTL, _QType, _RType] = Args) ->
-    ?TODO(fate_oracle_query_instruction);
+    call_to_scode(Env, aeb_fate_ops:oracle_query(?a, ?a, ?a, ?a, ?a, ?a, ?a, ?a), Args);
-builtin_to_scode(_Env, oracle_get_question, [_, _] = _Args) ->
+builtin_to_scode(Env, oracle_get_question, [_Oracle, _QueryId, _QType, _RType] = Args) ->
-    ?TODO(fate_oracle_get_question_instruction);
+    call_to_scode(Env, aeb_fate_ops:oracle_get_question(?a, ?a, ?a, ?a, ?a), Args);
-builtin_to_scode(_Env, oracle_respond, [_, _, _, _] = _Args) ->
+builtin_to_scode(Env, oracle_respond, [_Sign, _Oracle, _QueryId, _Response, _QType, _RType] = Args) ->
-    ?TODO(fate_oracle_respond_instruction);
+    call_to_scode(Env, [aeb_fate_ops:oracle_respond(?a, ?a, ?a, ?a, ?a, ?a),
-builtin_to_scode(_Env, oracle_extend, [_, _, _] = _Args) ->
+                        tuple(0)], Args);
-    ?TODO(fate_oracle_extend_instruction);
+builtin_to_scode(Env, oracle_extend, [_Sign, _Oracle, _TTL] = Args) ->
-builtin_to_scode(_Env, oracle_get_answer, [_, _] = _Args) ->
+    call_to_scode(Env, [aeb_fate_ops:oracle_extend(?a, ?a, ?a),
-    ?TODO(fate_oracle_get_answer_instruction);
+                        tuple(0)], Args);
-builtin_to_scode(_Env, aens_resolve, [_, _] = _Args) ->
+builtin_to_scode(Env, oracle_get_answer, [_Oracle, _QueryId, _QType, _RType] = Args) ->
-    ?TODO(fate_aens_resolve_instruction);
+    call_to_scode(Env, aeb_fate_ops:oracle_get_answer(?a, ?a, ?a, ?a, ?a), Args);
-builtin_to_scode(_Env, aens_preclaim, [_, _, _] = _Args) ->
+builtin_to_scode(Env, oracle_check, [_Oracle, _QType, _RType] = Args) ->
-    ?TODO(fate_aens_preclaim_instruction);
+    call_to_scode(Env, aeb_fate_ops:oracle_check(?a, ?a, ?a, ?a), Args);
-builtin_to_scode(_Env, aens_claim, [_, _, _, _] = _Args) ->
+builtin_to_scode(Env, oracle_check_query, [_Oracle, _Query, _QType, _RType] = Args) ->
-    ?TODO(fate_aens_claim_instruction);
+    call_to_scode(Env, aeb_fate_ops:oracle_check_query(?a, ?a, ?a, ?a, ?a), Args);
-builtin_to_scode(_Env, aens_transfer, [_, _, _, _] = _Args) ->
+builtin_to_scode(Env, address_is_oracle, [_] = Args) ->
-    ?TODO(fate_aens_transfer_instruction);
+    call_to_scode(Env, aeb_fate_ops:is_oracle(?a, ?a), Args);
-builtin_to_scode(_Env, aens_revoke, [_, _, _] = _Args) ->
+builtin_to_scode(Env, address_is_contract, [_] = Args) ->
-    ?TODO(fate_aens_revoke_instruction);
+    call_to_scode(Env, aeb_fate_ops:is_contract(?a, ?a), Args);
-builtin_to_scode(_Env, crypto_ecverify, [_, _, _] = _Args) ->
+builtin_to_scode(Env, address_is_payable, [_] = Args) ->
-    ?TODO(fate_crypto_ecverify_instruction);
+    call_to_scode(Env, aeb_fate_ops:is_payable(?a, ?a), Args);
-builtin_to_scode(_Env, crypto_ecverify_secp256k1, [_, _, _] = _Args) ->
+builtin_to_scode(Env, aens_resolve, [_Name, _Key, _Type] = Args) ->
-    ?TODO(fate_crypto_ecverify_secp256k1_instruction);
+    call_to_scode(Env, aeb_fate_ops:aens_resolve(?a, ?a, ?a, ?a), Args);
-builtin_to_scode(_Env, crypto_sha3, [_] = _Args) ->
+builtin_to_scode(Env, aens_preclaim, [_Sign, _Account, _Hash] = Args) ->
-    ?TODO(fate_crypto_sha3_instruction);
+    call_to_scode(Env, [aeb_fate_ops:aens_preclaim(?a, ?a, ?a),
-builtin_to_scode(_Env, crypto_sha256, [_] = _Args) ->
+                        tuple(0)], Args);
-    ?TODO(fate_crypto_sha256_instruction);
+builtin_to_scode(Env, aens_claim, [_Sign, _Account, _NameString, _Salt] = Args) ->
-builtin_to_scode(_Env, crypto_blake2b, [_] = _Args) ->
+    call_to_scode(Env, [aeb_fate_ops:aens_claim(?a, ?a, ?a, ?a),
-    ?TODO(fate_crypto_blake2b_instruction);
+                        tuple(0)], Args);
+builtin_to_scode(Env, aens_transfer, [_Sign, _From, _To, _Name] = Args) ->
+    call_to_scode(Env, [aeb_fate_ops:aens_transfer(?a, ?a, ?a, ?a),
+                        tuple(0)], Args);
+builtin_to_scode(Env, aens_revoke, [_Sign, _Account, _Name] = Args) ->
+    call_to_scode(Env, [aeb_fate_ops:aens_revoke(?a, ?a, ?a),
+                        tuple(0)], Args);
 builtin_to_scode(_Env, auth_tx_hash, []) ->
-    ?TODO(fate_auth_tx_hash_instruction).
+    [aeb_fate_ops:auth_tx_hash(?a)].
 
 %% -- Operators --
 
-op_to_scode('+')               -> aeb_fate_code:add(?a, ?a, ?a);
+op_to_scode('+')               -> aeb_fate_ops:add(?a, ?a, ?a);
-op_to_scode('-')               -> aeb_fate_code:sub(?a, ?a, ?a);
+op_to_scode('-')               -> aeb_fate_ops:sub(?a, ?a, ?a);
-op_to_scode('*')               -> aeb_fate_code:mul(?a, ?a, ?a);
+op_to_scode('*')               -> aeb_fate_ops:mul(?a, ?a, ?a);
-op_to_scode('/')               -> aeb_fate_code:divide(?a, ?a, ?a);
+op_to_scode('/')               -> aeb_fate_ops:divide(?a, ?a, ?a);
-op_to_scode(mod)               -> aeb_fate_code:modulo(?a, ?a, ?a);
+op_to_scode(mod)               -> aeb_fate_ops:modulo(?a, ?a, ?a);
-op_to_scode('^')               -> aeb_fate_code:pow(?a, ?a, ?a);
+op_to_scode('^')               -> aeb_fate_ops:pow(?a, ?a, ?a);
-op_to_scode('++')              -> aeb_fate_code:append(?a, ?a, ?a);
+op_to_scode('++')              -> aeb_fate_ops:append(?a, ?a, ?a);
-op_to_scode('::')              -> aeb_fate_code:cons(?a, ?a, ?a);
+op_to_scode('::')              -> aeb_fate_ops:cons(?a, ?a, ?a);
-op_to_scode('<')               -> aeb_fate_code:lt(?a, ?a, ?a);
+op_to_scode('<')               -> aeb_fate_ops:lt(?a, ?a, ?a);
-op_to_scode('>')               -> aeb_fate_code:gt(?a, ?a, ?a);
+op_to_scode('>')               -> aeb_fate_ops:gt(?a, ?a, ?a);
-op_to_scode('=<')              -> aeb_fate_code:elt(?a, ?a, ?a);
+op_to_scode('=<')              -> aeb_fate_ops:elt(?a, ?a, ?a);
-op_to_scode('>=')              -> aeb_fate_code:egt(?a, ?a, ?a);
+op_to_scode('>=')              -> aeb_fate_ops:egt(?a, ?a, ?a);
-op_to_scode('==')              -> aeb_fate_code:eq(?a, ?a, ?a);
+op_to_scode('==')              -> aeb_fate_ops:eq(?a, ?a, ?a);
-op_to_scode('!=')              -> aeb_fate_code:neq(?a, ?a, ?a);
+op_to_scode('!=')              -> aeb_fate_ops:neq(?a, ?a, ?a);
-op_to_scode('!')               -> aeb_fate_code:not_op(?a, ?a);
+op_to_scode('!')               -> aeb_fate_ops:not_op(?a, ?a);
-op_to_scode(map_get)           -> aeb_fate_code:map_lookup(?a, ?a, ?a);
+op_to_scode(map_get)           -> aeb_fate_ops:map_lookup(?a, ?a, ?a);
-op_to_scode(map_get_d)         -> aeb_fate_code:map_lookup(?a, ?a, ?a, ?a);
+op_to_scode(map_get_d)         -> aeb_fate_ops:map_lookup(?a, ?a, ?a, ?a);
-op_to_scode(map_set)           -> aeb_fate_code:map_update(?a, ?a, ?a, ?a);
+op_to_scode(map_set)           -> aeb_fate_ops:map_update(?a, ?a, ?a, ?a);
-op_to_scode(map_from_list)     -> aeb_fate_code:map_from_list(?a, ?a);
+op_to_scode(map_from_list)     -> aeb_fate_ops:map_from_list(?a, ?a);
-op_to_scode(map_to_list)       -> ?TODO(fate_map_to_list_instruction);
+op_to_scode(map_to_list)       -> aeb_fate_ops:map_to_list(?a, ?a);
-op_to_scode(map_delete)        -> aeb_fate_code:map_delete(?a, ?a, ?a);
+op_to_scode(map_delete)        -> aeb_fate_ops:map_delete(?a, ?a, ?a);
-op_to_scode(map_member)        -> aeb_fate_code:map_member(?a, ?a, ?a);
+op_to_scode(map_member)        -> aeb_fate_ops:map_member(?a, ?a, ?a);
-op_to_scode(map_size)          -> ?TODO(fate_map_size_instruction);
+op_to_scode(map_size)          -> aeb_fate_ops:map_size_(?a, ?a);
-op_to_scode(string_length)     -> ?TODO(fate_string_length_instruction);
+op_to_scode(string_length)     -> aeb_fate_ops:str_length(?a, ?a);
-op_to_scode(string_concat)     -> aeb_fate_code:str_join(?a, ?a, ?a);
+op_to_scode(string_concat)     -> aeb_fate_ops:str_join(?a, ?a, ?a);
-op_to_scode(bits_set)          -> aeb_fate_code:bits_set(?a, ?a, ?a);
+op_to_scode(bits_set)          -> aeb_fate_ops:bits_set(?a, ?a, ?a);
-op_to_scode(bits_clear)        -> aeb_fate_code:bits_clear(?a, ?a, ?a);
+op_to_scode(bits_clear)        -> aeb_fate_ops:bits_clear(?a, ?a, ?a);
-op_to_scode(bits_test)         -> aeb_fate_code:bits_test(?a, ?a, ?a);
+op_to_scode(bits_test)         -> aeb_fate_ops:bits_test(?a, ?a, ?a);
-op_to_scode(bits_sum)          -> aeb_fate_code:bits_sum(?a, ?a);
+op_to_scode(bits_sum)          -> aeb_fate_ops:bits_sum(?a, ?a);
-op_to_scode(bits_intersection) -> aeb_fate_code:bits_and(?a, ?a, ?a);
+op_to_scode(bits_intersection) -> aeb_fate_ops:bits_and(?a, ?a, ?a);
-op_to_scode(bits_union)        -> aeb_fate_code:bits_or(?a, ?a, ?a);
+op_to_scode(bits_union)        -> aeb_fate_ops:bits_or(?a, ?a, ?a);
-op_to_scode(bits_difference)   -> aeb_fate_code:bits_diff(?a, ?a, ?a);
+op_to_scode(bits_difference)   -> aeb_fate_ops:bits_diff(?a, ?a, ?a);
-op_to_scode(address_to_str)    -> aeb_fate_code:addr_to_str(?a, ?a);
+op_to_scode(address_to_str)    -> aeb_fate_ops:addr_to_str(?a, ?a);
-op_to_scode(int_to_str)        -> aeb_fate_code:int_to_str(?a, ?a).
+op_to_scode(int_to_str)        -> aeb_fate_ops:int_to_str(?a, ?a);
+op_to_scode(contract_to_address)         -> aeb_fate_ops:contract_to_address(?a, ?a);
+op_to_scode(crypto_verify_sig)           -> aeb_fate_ops:verify_sig(?a, ?a, ?a, ?a);
+op_to_scode(crypto_verify_sig_secp256k1) -> aeb_fate_ops:verify_sig_secp256k1(?a, ?a, ?a, ?a);
+op_to_scode(crypto_ecverify_secp256k1)   -> aeb_fate_ops:ecverify_secp256k1(?a, ?a, ?a, ?a);
+op_to_scode(crypto_ecrecover_secp256k1)  -> aeb_fate_ops:ecrecover_secp256k1(?a, ?a, ?a);
+op_to_scode(crypto_sha3)                 -> aeb_fate_ops:sha3(?a, ?a);
+op_to_scode(crypto_sha256)               -> aeb_fate_ops:sha256(?a, ?a);
+op_to_scode(crypto_blake2b)              -> aeb_fate_ops:blake2b(?a, ?a);
+op_to_scode(string_sha3)                 -> aeb_fate_ops:sha3(?a, ?a);
+op_to_scode(string_sha256)               -> aeb_fate_ops:sha256(?a, ?a);
+op_to_scode(string_blake2b)              -> aeb_fate_ops:blake2b(?a, ?a).
 
 %% PUSH and STORE ?a are the same, so we use STORE to make optimizations
 %% easier, and specialize to PUSH (which is cheaper) at the end.
-push(A) -> aeb_fate_code:store(?a, A).
+push(A) -> aeb_fate_ops:store(?a, A).
+
+tuple(0) -> push(?i({tuple, {}}));
+tuple(N) -> aeb_fate_ops:tuple(?a, N).
 
 %% -- Phase II ---------------------------------------------------------------
 %%  Optimize
@@ -512,12 +618,12 @@ flatten_s(I) -> I.
 
 -define(MAX_SIMPL_ITERATIONS, 10).
 
-optimize_fun(_Funs, Name, {{Args, Res}, Code}, Options) ->
+optimize_fun(_Funs, Name, {Attrs, Sig, Code}, Options) ->
     Code0 = flatten(Code),
     debug(opt, Options, "Optimizing ~s\n", [Name]),
     Code1 = simpl_loop(0, Code0, Options),
     Code2 = desugar(Code1),
-    {{Args, Res}, Code2}.
+    {Attrs, Sig, Code2}.
 
 simpl_loop(N, Code, Options) when N >= ?MAX_SIMPL_ITERATIONS ->
     debug(opt, Options, "  No simpl_loop fixed_point after ~p iterations.\n\n", [N]),
@@ -565,6 +671,7 @@ pp_ann(_, []) -> [].
 
 pp_arg(?i(I))    -> io_lib:format("~w", [I]);
 pp_arg({arg, N}) -> io_lib:format("arg~p", [N]);
+pp_arg({var, N}) when N < 0 -> io_lib:format("store~p", [-N]);
 pp_arg({var, N}) -> io_lib:format("var~p", [N]);
 pp_arg(?a)       -> "a".
 
@@ -585,7 +692,7 @@ ann_writes([{switch, Arg, Type, Alts, Def} | Code], Writes, Acc) ->
     Writes1 = ordsets:union(Writes, ordsets:intersection([WritesDef | WritesAlts])),
     ann_writes(Code, Writes1, [{switch, Arg, Type, Alts1, Def1} | Acc]);
 ann_writes([I | Code], Writes, Acc) ->
-    Ws = var_writes(I),
+    Ws = [ W || W <- var_writes(I), not ?IsState(W) ],
     Writes1 = ordsets:union(Writes, Ws),
     Ann = #{ writes_in => Writes, writes_out => Writes1 },
     ann_writes(Code, Writes1, [{i, Ann, I} | Acc]);
@@ -630,11 +737,9 @@ attributes(I) ->
         'RETURN'                              -> Impure(pc, []);
         {'RETURNR', A}                        -> Impure(pc, A);
         {'CALL', _}                           -> Impure(?a, []);
-        {'CALL_R', A, _, B}                   -> Impure(?a, [A, B]);
+        {'CALL_R', A, _, B, C, D}             -> Impure(?a, [A, B, C, D]);
-        {'CALL_GR', A, _, B, C}               -> Impure(?a, [A, B, C]);
+        {'CALL_GR', A, _, B, C, D, E}         -> Impure(?a, [A, B, C, D, E]);
         {'CALL_T', _}                         -> Impure(pc, []);
-        {'CALL_TR', A, _, B}                  -> Impure(pc, [A, B]);
-        {'CALL_GTR', A, _, B, C}              -> Impure(pc, [A, B, C]);
         {'CALL_VALUE', A}                     -> Pure(A, []);
         {'JUMP', _}                           -> Impure(pc, []);
         {'JUMPIF', A, _}                      -> Impure(pc, A);
@@ -642,13 +747,13 @@ attributes(I) ->
         {'SWITCH_V3', A, _, _, _}             -> Impure(pc, A);
         {'SWITCH_VN', A, _}                   -> Impure(pc, A);
         {'PUSH', A}                           -> Pure(?a, A);
-        'DUPA'                                -> Pure(?a, []);
+        'DUPA'                                -> Pure(?a, ?a);
         {'DUP', A}                            -> Pure(?a, A);
         {'POP', A}                            -> Pure(A, ?a);
         {'STORE', A, B}                       -> Pure(A, B);
         'INCA'                                -> Pure(?a, ?a);
         {'INC', A}                            -> Pure(A, A);
-        'DECA'                                -> Pure(?a, []);
+        'DECA'                                -> Pure(?a, ?a);
         {'DEC', A}                            -> Pure(A, A);
         {'ADD', A, B, C}                      -> Pure(A, [B, C]);
         {'SUB', A, B, C}                      -> Pure(A, [B, C]);
@@ -665,7 +770,7 @@ attributes(I) ->
         {'AND', A, B, C}                      -> Pure(A, [B, C]);
         {'OR', A, B, C}                       -> Pure(A, [B, C]);
         {'NOT', A, B}                         -> Pure(A, B);
-        {'TUPLE', _}                          -> Pure(?a, []);
+        {'TUPLE', A, N}                       -> Pure(A, [?a || N > 0]);
         {'ELEMENT', A, B, C}                  -> Pure(A, [B, C]);
         {'SETELEMENT', A, B, C, D}            -> Pure(A, [B, C, D]);
         {'MAP_EMPTY', A}                      -> Pure(A, []);
@@ -675,6 +780,8 @@ attributes(I) ->
         {'MAP_DELETE', A, B, C}               -> Pure(A, [B, C]);
         {'MAP_MEMBER', A, B, C}               -> Pure(A, [B, C]);
         {'MAP_FROM_LIST', A, B}               -> Pure(A, B);
+        {'MAP_TO_LIST', A, B}                 -> Pure(A, B);
+        {'MAP_SIZE', A, B}                    -> Pure(A, B);
         {'NIL', A}                            -> Pure(A, []);
         {'IS_NIL', A, B}                      -> Pure(A, B);
         {'CONS', A, B, C}                     -> Pure(A, [B, C]);
@@ -686,6 +793,7 @@ attributes(I) ->
         {'INT_TO_STR', A, B}                  -> Pure(A, B);
         {'ADDR_TO_STR', A, B}                 -> Pure(A, B);
         {'STR_REVERSE', A, B}                 -> Pure(A, B);
+        {'STR_LENGTH', A, B}                  -> Pure(A, B);
         {'INT_TO_ADDR', A, B}                 -> Pure(A, B);
         {'VARIANT', A, B, C, D}               -> Pure(A, [?a, B, C, D]);
         {'VARIANT_TEST', A, B, C}             -> Pure(A, [B, C]);
@@ -702,13 +810,30 @@ attributes(I) ->
         {'BITS_OR', A, B, C}                  -> Pure(A, [B, C]);
         {'BITS_AND', A, B, C}                 -> Pure(A, [B, C]);
         {'BITS_DIFF', A, B, C}                -> Pure(A, [B, C]);
+        {'SHA3', A, B}                        -> Pure(A, [B]);
+        {'SHA256', A, B}                      -> Pure(A, [B]);
+        {'BLAKE2B', A, B}                     -> Pure(A, [B]);
+        {'VERIFY_SIG', A, B, C, D}            -> Pure(A, [B, C, D]);
+        {'VERIFY_SIG_SECP256K1', A, B, C, D}  -> Pure(A, [B, C, D]);
+        {'ECVERIFY_SECP256K1', A, B, C, D}    -> Pure(A, [B, C, D]);
+        {'ECRECOVER_SECP256K1', A, B, C}      -> Pure(A, [B, C]);
+        {'CONTRACT_TO_ADDRESS', A, B}         -> Pure(A, [B]);
+        {'AUTH_TX_HASH', A}                   -> Pure(A, []);
+        {'BYTES_TO_INT', A, B}                -> Pure(A, [B]);
+        {'BYTES_TO_STR', A, B}                -> Pure(A, [B]);
+        {'ORACLE_CHECK', A, B, C, D}          -> Impure(A, [B, C, D]);
+        {'ORACLE_CHECK_QUERY', A, B, C, D, E} -> Impure(A, [B, C, D, E]);
+        {'IS_ORACLE', A, B}                   -> Impure(A, [B]);
+        {'IS_CONTRACT', A, B}                 -> Impure(A, [B]);
+        {'IS_PAYABLE', A, B}                  -> Impure(A, [B]);
+        {'CREATOR', A}                        -> Pure(A, []);
         {'ADDRESS', A}                        -> Pure(A, []);
         {'BALANCE', A}                        -> Impure(A, []);
         {'BALANCE_OTHER', A, B}               -> Impure(A, [B]);
         {'ORIGIN', A}                         -> Pure(A, []);
         {'CALLER', A}                         -> Pure(A, []);
         {'GASPRICE', A}                       -> Pure(A, []);
-        {'BLOCKHASH', A}                      -> Pure(A, []);
+        {'BLOCKHASH', A, B}                   -> Impure(A, [B]);
         {'BENEFICIARY', A}                    -> Pure(A, []);
         {'TIMESTAMP', A}                      -> Pure(A, []);
         {'GENERATION', A}                     -> Pure(A, []);
@@ -716,31 +841,26 @@ attributes(I) ->
         {'DIFFICULTY', A}                     -> Pure(A, []);
         {'GASLIMIT', A}                       -> Pure(A, []);
         {'GAS', A}                            -> Impure(?a, A);
-        {'LOG0', A, B}                        -> Impure(none, [A, B]);
+        {'LOG0', A}                           -> Impure(none, [A]);
-        {'LOG1', A, B, C}                     -> Impure(none, [A, B, C]);
+        {'LOG1', A, B}                        -> Impure(none, [A, B]);
-        {'LOG2', A, B, C, D}                  -> Impure(none, [A, B, C, D]);
+        {'LOG2', A, B, C}                     -> Impure(none, [A, B, C]);
-        {'LOG3', A, B, C, D, E}               -> Impure(none, [A, B, C, D, E]);
+        {'LOG3', A, B, C, D}                  -> Impure(none, [A, B, C, D]);
-        {'LOG4', A, B, C, D, E, F}            -> Impure(none, [A, B, C, D, E, F]);
+        {'LOG4', A, B, C, D, E}               -> Impure(none, [A, B, C, D, E]);
         'DEACTIVATE'                          -> Impure(none, []);
         {'SPEND', A, B}                       -> Impure(none, [A, B]);
-
+        {'ORACLE_REGISTER', A, B, C, D, E, F, G} -> Impure(A, [B, C, D, E, F, G]);
-        {'ORACLE_REGISTER', A, B, C, D, E, F} -> Impure(A, [B, C, D, E, F]);
+        {'ORACLE_QUERY', A, B, C, D, E, F, G, H} -> Impure(A, [B, C, D, E, F, G, H]);
-        'ORACLE_QUERY'                        -> Impure(?a, []);  %% TODO
+        {'ORACLE_RESPOND', A, B, C, D, E, F}  -> Impure(none, [A, B, C, D, E, F]);
-        'ORACLE_RESPOND'                      -> Impure(?a, []);  %% TODO
+        {'ORACLE_EXTEND', A, B, C}            -> Impure(none, [A, B, C]);
-        'ORACLE_EXTEND'                       -> Impure(?a, []);  %% TODO
+        {'ORACLE_GET_ANSWER', A, B, C, D, E}  -> Impure(A, [B, C, D, E]);
-        'ORACLE_GET_ANSWER'                   -> Impure(?a, []);  %% TODO
+        {'ORACLE_GET_QUESTION', A, B, C, D, E}-> Impure(A, [B, C, D, E]);
-        'ORACLE_GET_QUESTION'                 -> Impure(?a, []);  %% TODO
+        {'ORACLE_QUERY_FEE', A, B}            -> Impure(A, [B]);
-        'ORACLE_QUERY_FEE'                    -> Impure(?a, []);  %% TODO
+        {'AENS_RESOLVE', A, B, C, D}          -> Impure(A, [B, C, D]);
-        'AENS_RESOLVE'                        -> Impure(?a, []);  %% TODO
+        {'AENS_PRECLAIM', A, B, C}            -> Impure(none, [A, B, C]);
-        'AENS_PRECLAIM'                       -> Impure(?a, []);  %% TODO
+        {'AENS_CLAIM', A, B, C, D}            -> Impure(none, [A, B, C, D]);
-        'AENS_CLAIM'                          -> Impure(?a, []);  %% TODO
+        'AENS_UPDATE'                         -> Impure(none, []);%% TODO
-        'AENS_UPDATE'                         -> Impure(?a, []);  %% TODO
+        {'AENS_TRANSFER', A, B, C, D}         -> Impure(none, [A, B, C, D]);
-        'AENS_TRANSFER'                       -> Impure(?a, []);  %% TODO
+        {'AENS_REVOKE', A, B, C}              -> Impure(none, [A, B, C]);
-        'AENS_REVOKE'                         -> Impure(?a, []);  %% TODO
-        'ECVERIFY'                            -> Pure(?a, []);  %% TODO
-        'SHA3'                                -> Pure(?a, []);  %% TODO
-        'SHA256'                              -> Pure(?a, []);  %% TODO
-        'BLAKE2B'                             -> Pure(?a, []);  %% TODO
         {'ABORT', A}                          -> Impure(pc, A);
         {'EXIT', A}                           -> Impure(pc, A);
         'NOP'                                 -> Pure(none, [])
@@ -792,6 +912,7 @@ swap_instrs({i, #{ live_in := Live1 }, I}, {i, #{ live_in := Live2, live_out :=
     {{i, #{ live_in => Live1,  live_out => Live2_ }, J},
      {i, #{ live_in => Live2_, live_out => Live3  }, I}}.
 
+live_in(R, _) when ?IsState(R) -> true;
 live_in(R, #{ live_in  := LiveIn  }) -> ordsets:is_element(R, LiveIn);
 live_in(R, {i, Ann, _}) -> live_in(R, Ann);
 live_in(R, [I = {i, _, _} | _]) -> live_in(R, I);
@@ -801,6 +922,7 @@ live_in(R, [{switch, A, _, Alts, Def} | _]) ->
 live_in(_, missing) -> false;
 live_in(_, []) -> false.
 
+live_out(R, _) when ?IsState(R) -> true;
 live_out(R, #{ live_out := LiveOut }) -> ordsets:is_element(R, LiveOut).
 
 %% -- Optimizations --
@@ -845,8 +967,7 @@ merge_rules() ->
 
 rules() ->
     merge_rules() ++
-    [?RULE(r_dup_to_push),
+    [?RULE(r_swap_push),
-     ?RULE(r_swap_push),
      ?RULE(r_swap_write),
      ?RULE(r_constant_propagation),
      ?RULE(r_prune_impossible_branches),
@@ -855,11 +976,6 @@ rules() ->
     ].
 
 %% Removing pushes that are immediately consumed.
-r_push_consume({i, Ann1, {'STORE', ?a, A}}, [{i, Ann2, {'POP', B}} | Code]) ->
-    case live_out(B, Ann2) of
-        true  -> {[{i, merge_ann(Ann1, Ann2), {'STORE', B, A}}], Code};
-        false -> {[], Code}
-    end;
 r_push_consume({i, Ann1, {'STORE', ?a, A}}, Code) ->
     inline_push(Ann1, A, 0, Code, []);
 %% Writing directly to memory instead of going through the accumulator.
@@ -905,14 +1021,6 @@ split_stack_arg(N, [A | As], Acc) ->
             true    -> N end,
     split_stack_arg(N1, As, [A | Acc]).
 
-%% Changing PUSH A, DUPA to PUSH A, PUSH A enables further optimisations
-r_dup_to_push({i, Ann1, Push={'STORE', ?a, _}}, [{i, Ann2, 'DUPA'} | Code]) ->
-    #{ live_in  := LiveIn  } = Ann1,
-    Ann1_ = Ann1#{ live_out => LiveIn },
-    Ann2_ = Ann2#{ live_in  => LiveIn },
-    {[{i, Ann1_, Push}, {i, Ann2_, Push}], Code};
-r_dup_to_push(_, _) -> false.
-
 %% Move PUSH A past non-stack instructions.
 r_swap_push(Push = {i, _, {'STORE', ?a, _}}, [I | Code]) ->
     case independent(Push, I) of
@@ -1112,15 +1220,15 @@ r_one_shot_var({i, Ann1, I}, [{i, Ann2, J} | Code]) ->
 r_one_shot_var(_, _) -> false.
 
 %% Remove writes to dead variables
+r_write_to_dead_var({i, _, {'STORE', ?void, ?a}}, _) -> false; %% Avoid looping
 r_write_to_dead_var({i, Ann, I}, Code) ->
     case op_view(I) of
         {_Op, R = {var, _}, As} ->
             case live_out(R, Ann) of
                 false ->
                     %% Subtle: we still have to pop the stack if any of the arguments
-                    %% came from there. In this case we pop to R, which we know is
+                    %% came from there.
-                    %% unused.
+                    {[{i, Ann, {'STORE', ?void, ?a}} || X <- As, X == ?a], Code};
-                    {[{i, Ann, {'POP', R}} || X <- As, X == ?a], Code};
                 true -> false
             end;
         _ -> false
@@ -1150,9 +1258,9 @@ unannotate(Code) when is_list(Code) ->
 unannotate({i, _Ann, I}) -> [I].
 
 %% Desugar and specialize
-desugar({'ADD', ?a, ?i(1), ?a})     -> [aeb_fate_code:inc()];
+desugar({'ADD', ?a, ?i(1), ?a})     -> [aeb_fate_ops:inc()];
-desugar({'SUB', ?a, ?a, ?i(1)})     -> [aeb_fate_code:dec()];
+desugar({'SUB', ?a, ?a, ?i(1)})     -> [aeb_fate_ops:dec()];
-desugar({'STORE', ?a, A})           -> [aeb_fate_code:push(A)];
+desugar({'STORE', ?a, A})           -> [aeb_fate_ops:push(A)];
 desugar({switch, Arg, Type, Alts, Def}) ->
     [{switch, Arg, Type, [desugar(A) || A <- Alts], desugar(Def)}];
 desugar(missing) -> missing;
@@ -1163,12 +1271,16 @@ desugar(I) -> [I].
 %% -- Phase III --------------------------------------------------------------
 %%  Constructing basic blocks
 
-to_basic_blocks(Funs, Options) ->
+to_basic_blocks(Funs) ->
-    maps:from_list([ {Name, {{Args, Res},
+    to_basic_blocks(maps:to_list(Funs), aeb_fate_code:new()).
-                             bb(Name, Code ++ [aeb_fate_code:return()], Options)}}
-                     || {Name, {{Args, Res}, Code}} <- maps:to_list(Funs) ]).
 
-bb(_Name, Code, _Options) ->
+to_basic_blocks([{Name, {Attrs, Sig, Code}}|Left], Acc) ->
+    BB = bb(Name, Code ++ [aeb_fate_ops:return()]),
+    to_basic_blocks(Left, aeb_fate_code:insert_fun(Name, Attrs, Sig, BB, Acc));
+to_basic_blocks([], Acc) ->
+    Acc.
+
+bb(_Name, Code) ->
     Blocks0 = blocks(Code),
     Blocks1 = optimize_blocks(Blocks0),
     Blocks  = lists:flatmap(fun split_calls/1, Blocks1),
@@ -1219,7 +1331,7 @@ block(Blk = #blk{code     = [{switch, Arg, Type, Alts, Default} | Code],
     {DefRef, DefBlk} =
         case Default of
             missing when Catchall == none ->
-                FreshBlk([aeb_fate_code:abort(?i(<<"Incomplete patterns">>))], none);
+                FreshBlk([aeb_fate_ops:exit(?i(<<"Incomplete patterns">>))], none);
             missing -> {Catchall, []};
             _       -> FreshBlk(Default ++ [{jump, RestRef}], Catchall)
                        %% ^ fall-through to the outer catchall
@@ -1292,8 +1404,7 @@ reorder_blocks(Ref, Code, Blocks, Acc) ->
         ['RETURN'|_]          -> reorder_blocks(Blocks, Acc1);
         [{'RETURNR', _}|_]    -> reorder_blocks(Blocks, Acc1);
         [{'CALL_T', _}|_]     -> reorder_blocks(Blocks, Acc1);
-        [{'CALL_TR', _, _, _}|_] -> reorder_blocks(Blocks, Acc1);
+        [{'EXIT', _}|_]       -> reorder_blocks(Blocks, Acc1);
-        [{'CALL_GTR', _, _, _}|_] -> reorder_blocks(Blocks, Acc1);
         [{'ABORT', _}|_]      -> reorder_blocks(Blocks, Acc1);
         [{switch, _, _}|_]    -> reorder_blocks(Blocks, Acc1);
         [{jump, L}|_]         ->
@@ -1332,22 +1443,29 @@ chase_labels([L | Ls], Map, Live) ->
     chase_labels(New ++ Ls, Map, Live#{ L => true }).
 
 %% Replace PUSH, RETURN by RETURNR, drop returns after tail calls.
-tweak_returns(['RETURN', {'PUSH', A} | Code])              -> [{'RETURNR', A} | Code];
+tweak_returns(['RETURN', {'PUSH', A} | Code])          -> [{'RETURNR', A} | Code];
-tweak_returns(['RETURN' | Code = [{'CALL_T', _} | _]])     -> Code;
+tweak_returns(['RETURN' | Code = [{'CALL_T', _} | _]]) -> Code;
-tweak_returns(['RETURN' | Code = [{'CALL_TR', _, _} | _]]) -> Code;
+tweak_returns(['RETURN' | Code = [{'ABORT', _} | _]])  -> Code;
-tweak_returns(['RETURN' | Code = [{'ABORT', _} | _]])      -> Code;
+tweak_returns(['RETURN' | Code = [{'EXIT', _} | _]])   -> Code;
 tweak_returns(Code) -> Code.
 
 %% -- Split basic blocks at CALL instructions --
-%%  Calls can only return to a new basic block.
+%%  Calls can only return to a new basic block. Also splits at JUMPIF instructions.
 
 split_calls({Ref, Code}) ->
     split_calls(Ref, Code, [], []).
 
 split_calls(Ref, [], Acc, Blocks) ->
     lists:reverse([{Ref, lists:reverse(Acc)} | Blocks]);
-split_calls(Ref, [I | Code], Acc, Blocks) when element(1, I) == 'CALL'; element(1, I) == 'CALL_R' ->
+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) == 'jumpif' ->
     split_calls(make_ref(), Code, [], [{Ref, lists:reverse([I | Acc])} | Blocks]);
+split_calls(Ref, [{'ABORT', _} = I | _Code], Acc, Blocks) ->
+    lists:reverse([{Ref, lists:reverse([I | Acc])} | Blocks]);
+split_calls(Ref, [{'EXIT', _} = I | _Code], Acc, Blocks) ->
+    lists:reverse([{Ref, lists:reverse([I | Acc])} | Blocks]);
 split_calls(Ref, [I | Code], Acc, Blocks) ->
     split_calls(Ref, Code, [I | Acc], Blocks).
 
@@ -1355,13 +1473,13 @@ split_calls(Ref, [I | Code], Acc, Blocks) ->
 
 set_labels(Labels, {Ref, Code}) when is_reference(Ref) ->
     {maps:get(Ref, Labels), [ set_labels(Labels, I) || I <- Code ]};
-set_labels(Labels, {jump, Ref})   -> aeb_fate_code:jump(maps:get(Ref, Labels));
+set_labels(Labels, {jump, Ref})   -> aeb_fate_ops:jump(maps:get(Ref, Labels));
-set_labels(Labels, {jumpif, Arg, Ref}) -> aeb_fate_code:jumpif(Arg, maps:get(Ref, Labels));
+set_labels(Labels, {jumpif, Arg, Ref}) -> aeb_fate_ops:jumpif(Arg, maps:get(Ref, Labels));
 set_labels(Labels, {switch, Arg, Refs}) ->
     case [ maps:get(Ref, Labels) || Ref <- Refs ] of
-        [R1, R2]     -> aeb_fate_code:switch(Arg, R1, R2);
+        [R1, R2]     -> aeb_fate_ops:switch(Arg, R1, R2);
-        [R1, R2, R3] -> aeb_fate_code:switch(Arg, R1, R2, R3);
+        [R1, R2, R3] -> aeb_fate_ops:switch(Arg, R1, R2, R3);
-        Rs           -> aeb_fate_code:switch(Arg, Rs)
+        Rs           -> aeb_fate_ops:switch(Arg, Rs)
     end;
 set_labels(_, I) -> I.
 

src/aeso_icode.erl

@@ -13,6 +13,7 @@
          pp/1,
          set_name/2,
          set_namespace/2,
+         set_payable/2,
          enter_namespace/2,
          get_namespace/1,
          qualify/2,
@@ -48,6 +49,7 @@
                   , type_vars => #{ string() => aeb_aevm_data:type() }
                   , constructors => #{ [string()] => integer() }  %% name to tag
                   , options => [any()]
+                  , payable => boolean()
                   }.
 
 pp(Icode) ->
@@ -65,7 +67,8 @@ new(Options) ->
      , types => builtin_types()
      , type_vars => #{}
      , constructors => builtin_constructors()
-     , options => Options}.
+     , options => Options
+     , payable => false }.
 
 builtin_types() ->
     Word = fun([]) -> word end,
@@ -103,6 +106,10 @@ new_env() ->
 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 }.
 

src/aeso_icode_to_asm.erl

@@ -105,7 +105,7 @@ make_args(Args) ->
 
 fun_hash({FName, _, Args, _, TypeRep}) ->
     ArgType = {tuple, [T || {_, T} <- Args]},
-    <<Hash:256>> = aeb_abi:function_type_hash(list_to_binary(lists:last(FName)), ArgType, TypeRep),
+    <<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

src/aeso_parser.erl

@@ -6,6 +6,8 @@
 
 -export([string/1,
          string/2,
+         string/3,
+         hash_include/2,
          type/1]).
 
 -include("aeso_parse_lib.hrl").
@@ -14,15 +16,24 @@
                       | {error, {aeso_parse_lib:pos(), atom(), term()}}
                       | {error, {aeso_parse_lib:pos(), atom()}}.
 
+-type include_hash() :: {string(), binary()}.
+
 -spec string(string()) -> parse_result().
 string(String) ->
-    string(String, []).
+    string(String, sets:new(), []).
 
 -spec string(string(), aeso_compiler:options()) -> parse_result().
 string(String, Opts) ->
+    case lists:keyfind(src_file, 1, Opts) of
+        {src_file, File} -> string(String, sets:add_element(File, sets:new()), Opts);
+        false -> string(String, sets:new(), Opts)
+    end.
+
+-spec string(string(), sets:set(include_hash()), aeso_compiler:options()) -> parse_result().
+string(String, Included, Opts) ->
     case parse_and_scan(file(), String, Opts) of
         {ok, AST} ->
-            expand_includes(AST, Opts);
+            expand_includes(AST, Included, Opts);
         Err = {error, _} ->
             Err
     end.
@@ -46,8 +57,9 @@ decl() ->
     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(keyword(namespace), con(), tok('='), maybe_block(decl()), {namespace, _1, _2, _4})
-    , ?RULE(keyword(include),   str(), {include, _2})
+    , ?RULE(keyword(include),   str(), {include, get_ann(_1), _2})
 
       %% Type declarations  TODO: format annotation for "type bla" vs "type bla()"
     , ?RULE(keyword(type),     id(),                                          {type_decl, _1, _2, []})
@@ -60,13 +72,22 @@ decl() ->
     , ?RULE(keyword(datatype), id(), type_vars(), tok('='), typedef(variant), {type_def, _1, _2, _3, _5})
 
       %% Function declarations
-    , ?RULE(modifiers(), keyword(function), id(), tok(':'), type(), add_modifiers(_1, {fun_decl, _2, _3, _5}))
+    , ?RULE(modifiers(), fun_or_entry(), id(), tok(':'), type(), add_modifiers(_1, _2, {fun_decl, get_ann(_2), _3, _5}))
-    , ?RULE(modifiers(), keyword(function), fundef(),               add_modifiers(_1, set_pos(get_pos(_2), _3)))
+    , ?RULE(modifiers(), fun_or_entry(), fundef(),               add_modifiers(_1, _2, set_pos(get_pos(get_ann(_2)), _3)))
-    , ?RULE(keyword('let'),    valdef(),                            set_pos(get_pos(_1), _2))
+    , ?RULE(keyword('let'),    valdef(),                         set_pos(get_pos(_1), _2))
     ])).
 
+fun_or_entry() ->
+    choice([?RULE(keyword(function), {function, _1}),
+            ?RULE(keyword(entrypoint), {entrypoint, _1})]).
+
 modifiers() ->
-    many(choice([token(stateful), token(public), token(private), token(internal)])).
+    many(choice([token(stateful), token(payable), token(private), token(public)])).
+
+add_modifiers(Mods, Entry = {entrypoint, _}, Node) ->
+    add_modifiers(Mods ++ [Entry], Node);
+add_modifiers(Mods, {function, _}, Node) ->
+    add_modifiers(Mods, Node).
 
 add_modifiers([], Node) -> Node;
 add_modifiers(Mods = [Tok | _], Node) ->
@@ -131,7 +152,8 @@ type100() -> type200().
 type200() ->
     ?RULE(many({fun_domain(), keyword('=>')}), type300(), fun_t(_1, _2)).
 
-type300() -> type400().
+type300() ->
+    ?RULE(sep1(type400(), tok('*')), tuple_t(get_ann(lists:nth(1, _1)), _1)).
 
 type400() ->
     choice(
@@ -146,11 +168,18 @@ type400() ->
 
 typeAtom() ->
     ?LAZY_P(choice(
-    [ id(), token(con), token(qcon), token(qid), tvar()
+    [ parens(type())
-    , ?RULE(keyword('('), comma_sep(type()), tok(')'), tuple_t(_1, _2))
+    , id(), token(con), token(qcon), token(qid), tvar()
     ])).
 
-fun_domain() -> ?RULE(?LAZY_P(type300()), fun_domain(_1)).
+fun_domain() -> ?LAZY_P(choice(
+    [ ?RULE(tok('('), tok(')'), [])
+      %% Note avoidance of ambiguity: `(int)` can be treated as:
+      %% - literally `int`
+      %% - list of arguments with just one element – int. This approach is dropped.
+    , ?RULE(tok('('), type(), tok(','), sep1(type(), tok(',')), tok(')'), [_2|_4])
+    , ?RULE(type300(), [_1])
+    ])).
 
 %% -- Statements -------------------------------------------------------------
 
@@ -211,13 +240,27 @@ exprAtom() ->
         , ?RULE(token(hex), set_ann(format, hex, setelement(1, _1, int)))
         , {bool, keyword(true), true}
         , {bool, keyword(false), false}
-        , ?RULE(brace_list(?LAZY_P(field_assignment())), record(_1))
+        , ?LET_P(Fs, brace_list(?LAZY_P(field_assignment())), record(Fs))
         , {list, [], bracket_list(Expr)}
+        , ?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))
         ])
     end).
 
+comprehension_exp() ->
+    ?LAZY_P(choice(
+      [ comprehension_bind()
+      , letdecl()
+      , comprehension_if()
+      ])).
+
+comprehension_if() ->
+    ?RULE(keyword('if'), parens(expr()), {comprehension_if, _1, _2}).
+
+comprehension_bind() ->
+    ?RULE(id(), tok('<-'), expr(), {comprehension_bind, _1, _3}).
+
 arg_expr() ->
     ?LAZY_P(
         choice([ ?RULE(id(), tok('='), expr(), {named_arg, [], _1, _3})
@@ -254,14 +297,20 @@ record_update(Ann, E, Flds) ->
 record([]) -> {map, [], []};
 record(Fs) ->
     case record_or_map(Fs) of
-        record -> {record, get_ann(hd(Fs)), Fs};
+        record ->
+            Fld = fun({field, _, [_], _} = F) -> F;
+                     ({field, Ann, LV, Id, _}) ->
+                         bad_expr_err("Cannot use '@' in record construction", infix({lvalue, Ann, LV}, {'@', Ann}, Id));
+                     ({field, Ann, LV, _}) ->
+                         bad_expr_err("Cannot use nested fields or keys in record construction", {lvalue, Ann, LV}) end,
+            {record, get_ann(hd(Fs)), lists:map(Fld, Fs)};
         map    ->
             Ann = get_ann(hd(Fs ++ [{empty, []}])), %% TODO: source location for empty maps
             KV = fun({field, _, [{map_get, _, Key}], Val}) -> {Key, Val};
-                    ({field, _, LV, Id, _}) ->
+                    ({field, FAnn, LV, Id, _}) ->
-                        bad_expr_err("Cannot use '@' in map construction", infix(LV, {op, Ann, '@'}, Id));
+                        bad_expr_err("Cannot use '@' in map construction", infix({lvalue, FAnn, LV}, {'@', Ann}, Id));
-                    ({field, _, LV, _}) ->
+                    ({field, FAnn, LV, _}) ->
-                        bad_expr_err("Cannot use nested fields or keys in map construction", LV) end,
+                        bad_expr_err("Cannot use nested fields or keys in map construction", {lvalue, FAnn, LV}) end,
             {map, Ann, lists:map(KV, Fs)}
     end.
 
@@ -458,9 +507,7 @@ fun_t(Domains, Type) ->
 tuple_e(_Ann, [Expr]) -> Expr;  %% Not a tuple
 tuple_e(Ann, Exprs)   -> {tuple, Ann, Exprs}.
 
-%% TODO: not nice
+list_comp_e(Ann, Expr, Binds) -> {list_comp, Ann, Expr, Binds}.
-fun_domain({tuple_t, _, Args}) -> Args;
-fun_domain(T)                  -> [T].
 
 -spec parse_pattern(aeso_syntax:expr()) -> aeso_parse_lib:parser(aeso_syntax:pat()).
 parse_pattern({app, Ann, Con = {'::', _}, Es}) ->
@@ -491,37 +538,47 @@ return_error({no_file, L, C}, Err) ->
 return_error({F, L, C}, Err) ->
     fail(io_lib:format("In ~s at ~p:~p:\n~s", [F, L, C, Err])).
 
--spec ret_doc_err(ann(), prettypr:document()) -> no_return().
+-spec ret_doc_err(ann(), prettypr:document()) -> aeso_parse_lib:parser(none()).
 ret_doc_err(Ann, Doc) ->
     return_error(ann_pos(Ann), prettypr:format(Doc)).
 
--spec bad_expr_err(string(), aeso_syntax:expr()) -> no_return().
+-spec bad_expr_err(string(), aeso_syntax:expr()) -> aeso_parse_lib:parser(none()).
 bad_expr_err(Reason, E) ->
   ret_doc_err(get_ann(E),
               prettypr:sep([prettypr:text(Reason ++ ":"),
                             prettypr:nest(2, aeso_pretty:expr(E))])).
 
 %% -- Helper functions -------------------------------------------------------
-expand_includes(AST, Opts) ->
+expand_includes(AST, Included, Opts) ->
-    expand_includes(AST, [], Opts).
+    expand_includes(AST, Included, [], Opts).
 
-expand_includes([], Acc, _Opts) ->
+expand_includes([], _Included, Acc, _Opts) ->
     {ok, lists:reverse(Acc)};
-expand_includes([{include, S = {string, _, File}} | AST], Acc, Opts) ->
+expand_includes([{include, Ann, {string, SAnn, File}} | AST], Included, Acc, Opts) ->
-    case read_file(File, Opts) of
+    case get_include_code(File, Ann, Opts) of
-        {ok, Bin} ->
+        {ok, Code} ->
-            Opts1 = lists:keystore(src_file, 1, Opts, {src_file, File}),
+            Hashed = hash_include(File, Code),
-            case string(binary_to_list(Bin), Opts1) of
+            case sets:is_element(Hashed, Included) of
-                {ok, AST1} ->
+                false ->
-                    expand_includes(AST1 ++ AST, Acc, Opts);
+                    Opts1 = lists:keystore(src_file, 1, Opts, {src_file, File}),
-                Err = {error, _} ->
+                    Included1 = sets:add_element(Hashed, Included),
-                    Err
+                    case string(Code, Included1, Opts1) of
+                        {ok, AST1} ->
+                            Dependencies = [ {include, Ann, {string, SAnn, Dep}}
+                                             || Dep <- aeso_stdlib:dependencies(File)
+                                           ],
+                            expand_includes(Dependencies ++ AST1 ++ AST, Included1, Acc, Opts);
+                        Err = {error, _} ->
+                            Err
+                    end;
+                true ->
+                    expand_includes(AST, Included, Acc, Opts)
             end;
-        {error, _} ->
+        Err = {error, _} ->
-            {error, {get_pos(S), include_error, File}}
+            Err
     end;
-expand_includes([E | AST], Acc, Opts) ->
+expand_includes([E | AST], Included, Acc, Opts) ->
-    expand_includes(AST, [E | Acc], Opts).
+    expand_includes(AST, Included, [E | Acc], Opts).
 
 read_file(File, Opts) ->
     case proplists:get_value(include, Opts, {explicit_files, #{}}) of
@@ -536,3 +593,20 @@ read_file(File, Opts) ->
             end
     end.
 
+get_include_code(File, Ann, Opts) ->
+    case {read_file(File, Opts), maps:find(File, aeso_stdlib:stdlib())} of
+        {{ok, _}, {ok,_ }} ->
+            return_error(ann_pos(Ann), "Illegal redefinition of standard library " ++ File);
+        {_, {ok, Lib}} ->
+            {ok, Lib};
+        {{ok, Bin}, _} ->
+            {ok, binary_to_list(Bin)};
+        {_, _} ->
+            {error, {ann_pos(Ann), include_error, File}}
+    end.
+
+-spec hash_include(string() | binary(), string()) -> include_hash().
+hash_include(File, Code) when is_binary(File) ->
+    hash_include(binary_to_list(File), Code);
+hash_include(File, Code) when is_list(File) ->
+    {filename:basename(File), crypto:hash(sha256, Code)}.

src/aeso_pretty.erl

@@ -153,13 +153,21 @@ decl({type_decl, _, T, Vars}) -> typedecl(alias_t, T, Vars);
 decl({type_def, _, T, Vars, Def}) ->
     Kind = element(1, Def),
     equals(typedecl(Kind, T, Vars), typedef(Def));
-decl({fun_decl, _, F, T}) ->
+decl({fun_decl, Ann, F, T}) ->
-    hsep(text("function"), typed(name(F), T));
+    Fun = case aeso_syntax:get_ann(entrypoint, Ann, false) of
+            true  -> text("entrypoint");
+            false -> text("function")
+          end,
+    hsep(Fun, typed(name(F), T));
 decl(D = {letfun, Attrs, _, _, _, _}) ->
-    Mod = fun({Mod, true}) when Mod == private; Mod == internal; Mod == public; Mod == stateful ->
+    Mod = fun({Mod, true}) when Mod == private; Mod == stateful ->
                             text(atom_to_list(Mod));
              (_) -> empty() end,
-    hsep(lists:map(Mod, Attrs) ++ [letdecl("function", D)]);
+    Fun = case aeso_syntax:get_ann(entrypoint, Attrs, false) of
+              true  -> "entrypoint";
+              false -> "function"
+          end,
+    hsep(lists:map(Mod, Attrs) ++ [letdecl(Fun, D)]);
 decl(D = {letval, _, _, _, _}) -> letdecl("let", D).
 
 -spec expr(aeso_syntax:expr(), options()) -> doc().
@@ -214,7 +222,7 @@ typedef({variant_t, Constructors}) ->
 
 -spec constructor_t(aeso_syntax:constructor_t()) -> doc().
 constructor_t({constr_t, _, C, []}) -> name(C);
-constructor_t({constr_t, _, C, Args}) -> beside(name(C), tuple_type(Args)).
+constructor_t({constr_t, _, C, Args}) -> beside(name(C), args_type(Args)).
 
 -spec field_t(aeso_syntax:field_t()) -> doc().
 field_t({field_t, _, Name, Type}) ->
@@ -226,13 +234,16 @@ type(Type, Options) ->
 
 -spec type(aeso_syntax:type()) -> doc().
 type({fun_t, _, Named, Args, Ret}) ->
+    follow(hsep(args_type(Named ++ Args), text("=>")), type(Ret));
+type({type_sig, _, Named, Args, Ret}) ->
     follow(hsep(tuple_type(Named ++ Args), text("=>")), type(Ret));
 type({app_t, _, Type, []}) ->
     type(Type);
 type({app_t, _, Type, Args}) ->
-    beside(type(Type), tuple_type(Args));
+    beside(type(Type), args_type(Args));
 type({tuple_t, _, Args}) ->
     tuple_type(Args);
+type({bytes_t, _, any}) -> text("bytes(_)");
 type({bytes_t, _, Len}) ->
     text(lists:concat(["bytes(", Len, ")"]));
 type({named_arg_t, _, Name, Type, _Default}) ->
@@ -247,10 +258,20 @@ type(T = {con, _, _})  -> name(T);
 type(T = {qcon, _, _}) -> name(T);
 type(T = {tvar, _, _}) -> name(T).
 
--spec tuple_type([aeso_syntax:type()]) -> doc().
+-spec args_type([aeso_syntax:type()]) -> doc().
-tuple_type(Args) ->
+args_type(Args) ->
     tuple(lists:map(fun type/1, Args)).
 
+-spec tuple_type([aeso_syntax:type()]) -> doc().
+tuple_type([]) ->
+    text("unit");
+tuple_type(Factors) ->
+    beside(
+      [ text("(")
+      , par(punctuate(text(" *"), lists:map(fun type/1, Factors)), 0)
+      , text(")")
+      ]).
+
 -spec arg_expr(aeso_syntax:arg_expr()) -> doc().
 arg_expr({named_arg, _, Name, E}) ->
     follow(hsep(expr(Name), text("=")), expr(E));
@@ -329,6 +350,7 @@ expr_p(_, {Type, _, Bin})
          Type == oracle_pubkey;
          Type == oracle_query_id ->
     text(binary_to_list(aeser_api_encoder:encode(Type, Bin)));
+expr_p(_, {string, _, <<>>}) -> text("\"\"");
 expr_p(_, {string, _, S}) -> term(binary_to_list(S));
 expr_p(_, {char, _, C}) ->
     case C of
@@ -361,6 +383,7 @@ stmt_p({else, Else}) ->
 -spec bin_prec(aeso_syntax:bin_op()) -> {integer(), integer(), integer()}.
 bin_prec('..')   -> {  0,   0,   0};  %% Always printed inside '[ ]'
 bin_prec('=')    -> {  0,   0,   0};  %% Always printed inside '[ ]'
+bin_prec('@')    -> {  0,   0,   0};  %% Only in error messages
 bin_prec('||')   -> {200, 300, 200};
 bin_prec('&&')   -> {300, 400, 300};
 bin_prec('<')    -> {400, 500, 500};

src/aeso_scan.erl

@@ -37,7 +37,7 @@ lexer() ->
         , {"[^/*]+|[/*]", skip()} ],
 
     Keywords = ["contract", "include", "let", "switch", "type", "record", "datatype", "if", "elif", "else", "function",
-                "stateful", "true", "false", "mod", "public", "private", "indexed", "internal", "namespace"],
+                "stateful", "payable", "true", "false", "mod", "public", "entrypoint", "private", "indexed", "namespace"],
     KW = string:join(Keywords, "|"),
 
     Rules =

src/aeso_stdlib.erl

@@ -0,0 +1,434 @@
+%%%-------------------------------------------------------------------
+%%% @author Radosław Rowicki
+%%% @copyright (C) 2019, Aeternity Anstalt
+%%% @doc
+%%%     Standard library for Sophia
+%%% @end
+%%% Created : 6 July 2019
+%%%
+%%%-------------------------------------------------------------------
+
+-module(aeso_stdlib).
+
+-export([stdlib/0, stdlib_list/0, dependencies/1]).
+
+stdlib() ->
+    maps:from_list(stdlib_list()).
+
+stdlib_list() ->
+    [ {<<"List.aes">>, std_list()}
+    , {<<"Func.aes">>, std_func()}
+    , {<<"Option.aes">>, std_option()}
+    , {<<"Pair.aes">>, std_pair()}
+    , {<<"Triple.aes">>, std_triple()}
+    ].
+
+dependencies(Q) ->
+    case Q of
+        <<"Option.aes">> ->
+            [<<"List.aes">>];
+        _ -> []
+    end.
+
+std_func() ->
+"
+namespace Func =
+
+  function id(x : 'a) : 'a = x
+
+  function const(x : 'a) : 'b => 'a = (y) => x
+
+  function flip(f : ('a, 'b) => 'c) : ('b, 'a) => 'c = (b, a) => f(a, b)
+
+  function comp(f : 'b => 'c, g : 'a => 'b) : 'a => 'c = (x) => f(g(x))
+
+  function pipe(f : 'a => 'b, g : 'b => 'c) : 'a => 'c = (x) => g(f(x))
+
+  function rapply(x : 'a, f : 'a => 'b) : 'b = f(x)
+
+  /* The Z combinator - replacement for local and anonymous recursion.
+   */
+  function recur(f : ('arg => 'res, 'arg) => 'res) : 'arg => 'res =
+    (x) => f(recur(f), x)
+
+  function iter(n : int, f : 'a => 'a) : 'a => 'a = iter_(n, f, (x) => x)
+  private function iter_(n : int, f : 'a => 'a, acc : 'a => 'a) : 'a => 'a =
+    if(n == 0) acc
+    elif(n == 1) comp(f, acc)
+    else iter_(n / 2, comp(f, f), if(n mod 2 == 0) acc else comp(f, acc))
+
+  function curry2(f : ('a, 'b) => 'c) : 'a => ('b => 'c) =
+    (x) => (y) => f(x, y)
+  function curry3(f : ('a, 'b, 'c) => 'd) : 'a => ('b => ('c => 'd)) =
+    (x) => (y) => (z) => f(x, y, z)
+
+  function uncurry2(f : 'a => ('b => 'c)) : ('a, 'b) => 'c =
+    (x, y) => f(x)(y)
+  function uncurry3(f : 'a => ('b => ('c => 'd))) : ('a, 'b, 'c) => 'd =
+    (x, y, z) => f(x)(y)(z)
+
+  function tuplify2(f : ('a, 'b) => 'c) : (('a * 'b)) => 'c =
+    (t) => switch(t)
+      (x, y) => f(x, y)
+  function tuplify3(f : ('a, 'b, 'c) => 'd) : 'a * 'b * 'c => 'd =
+    (t) => switch(t)
+      (x, y, z) => f(x, y, z)
+
+  function untuplify2(f : 'a * 'b => 'c) : ('a, 'b) => 'c =
+    (x, y) => f((x, y))
+  function untuplify3(f : 'a * 'b * 'c => 'd) : ('a, 'b, 'c) => 'd =
+    (x, y, z) => f((x, y, z))
+".
+
+std_list() ->"
+namespace List =
+
+  function is_empty(l : list('a)) : bool = switch(l)
+    [] => true
+    _  => false
+
+  function first(l : list('a)) : option('a) = switch(l)
+    []   => None
+    h::_ => Some(h)
+
+  function tail(l : list('a)) : option(list('a)) = switch(l)
+    []   => None
+    _::t => Some(t)
+
+  function last(l : list('a)) : option('a) = switch(l)
+    []  => None
+    [x] => Some(x)
+    _::t => last(t)
+
+  function find(p : 'a => bool, l : list('a)) : option('a) = switch(l)
+    []   => None
+    h::t => if(p(h)) Some(h) else find(p, t)
+
+  function find_all(p : 'a => bool, l : list('a)) : list('a) = find_all_(p, l, [])
+  private function find_all_(p : 'a => bool, l : list('a), acc : list('a)) : list('a) = switch(l)
+    []   => reverse(acc)
+    h::t => find_all_(p, t, if(p(h)) h::acc else acc)
+
+  function find_indices(p : 'a => bool, l : list('a)) : list(int) = find_indices_(p, l, 0, [])
+  private function find_indices_( p : 'a => bool
+                                , l : list('a)
+                                , n : int
+                                , acc : list(int)
+                                ) : list(int) = switch(l)
+    []   => reverse(acc)
+    h::t => find_indices_(p, t, n+1, if(p(h)) n::acc else acc)
+
+  function nth(n : int, l : list('a)) : option('a) = switch(l)
+    []   => None
+    h::t => if(n == 0) Some(h) else nth(n-1, t)
+
+  /* Unsafe version of `nth` */
+  function get(n : int, l : list('a)) : 'a = switch(l)
+    [] => abort(\"Out of index get\")
+    h::t => if(n == 0) h else get(n-1, t)
+
+
+  function length(l : list('a)) : int = length_(l, 0)
+  private function length_(l : list('a), acc : int) : int = switch(l)
+    []   => acc
+    _::t => length_(t, acc + 1)
+
+
+  /* Unsafe. Replaces `n`th element of `l` with `e`. Crashes on over/underflow */
+  function replace_at(n : int, e : 'a, l : list('a)) : list('a) =
+    if(n<0) abort(\"insert_at underflow\") else replace_at_(n, e, l, [])
+  private function replace_at_(n : int, e : 'a, l : list('a), acc : list('a)) : list('a) =
+   switch(l)
+     []   => abort(\"replace_at overflow\")
+     h::t => if (n == 0) reverse(e::acc) ++ t
+             else replace_at_(n-1, e, t, h::acc)
+
+  /* Unsafe. Adds `e` to `l` to be its `n`th element. Crashes on over/underflow */
+  function insert_at(n : int, e : 'a, l : list('a)) : list('a) =
+    if(n<0) abort(\"insert_at underflow\") else insert_at_(n, e, l, [])
+  private function insert_at_(n : int, e : 'a, l : list('a), acc : list('a)) : list('a) =
+   if (n == 0) reverse(e::acc) ++ l
+   else switch(l)
+     []   => abort(\"insert_at overflow\")
+     h::t => insert_at_(n-1, e, t, h::acc)
+
+  function insert_by(f : (('a, 'a) => bool), x : 'a, l : list('a)) : list('a) =
+    switch(l)
+      []        => [x]
+      (e :: l') =>
+        if(f(x, e))
+          e :: insert_by(f, x, l')
+        else
+          x :: l
+
+  function foldr(cons : ('a, 'b) => 'b, nil : 'b, l : list('a)) : 'b = switch(l)
+    []   => nil
+    h::t => cons(h, foldr(cons, nil, t))
+
+  function foldl(rcons : ('b, 'a) => 'b, acc : 'b, l : list('a)) : 'b = switch(l)
+    []   => acc
+    h::t => foldl(rcons, rcons(acc, h), t)
+
+  function foreach(f : 'a => unit, l : list('a)) : unit =
+    switch(l)
+     []   => ()
+     e :: l' =>
+       f(e)
+       foreach(f, l')
+
+
+  function reverse(l : list('a)) : list('a) = foldl((lst, el) => el :: lst, [], l)
+
+
+  function map(f : 'a => 'b, l : list('a)) : list('b) = map_(f, l, [])
+  private function map_(f : 'a => 'b, l : list('a), acc : list('b)) : list('b) = switch(l)
+    []   => reverse(acc)
+    h::t => map_(f, t, f(h)::acc)
+
+  function flat_map(f : 'a => list('b), l : list('a)) : list('b) = flat_map_(f, l, [])
+  private function flat_map_(f : 'a => list('b), l : list('a), acc : list('b)) : list('b) = switch(l)
+    []   => reverse(acc)
+    h::t => flat_map_(f, t, reverse(f(h)) ++ acc)
+
+  function filter(p : 'a => bool, l : list('a)) : list('a) = filter_(p, l, [])
+  private function filter_(p : 'a => bool, l : list('a), acc : list('a)) : list('a) = switch(l)
+    []   => reverse(acc)
+    h::t => filter_(p, t, if(p(h)) h::acc else acc)
+
+  /* Take `n` first elements */
+  function take(n : int, l : list('a)) : list('a) =
+    if(n < 0) abort(\"Take negative number of elements\") else take_(n, l, [])
+  private function take_(n : int, l : list('a), acc : list('a)) : list('a) =
+    if(n == 0) reverse(acc)
+    else switch(l)
+      []   => reverse(acc)
+      h::t => take_(n-1, t, h::acc)
+
+  /* Drop `n` first elements */
+  function drop(n : int, l : list('a)) : list('a) =
+   if(n < 0) abort(\"Drop negative number of elements\")
+   elif (n == 0) l
+   else switch(l)
+      []   => []
+      h::t => drop(n-1, t)
+
+  /* Get the longest prefix of a list in which every element matches predicate `p` */
+  function take_while(p : 'a => bool, l : list('a)) : list('a) = take_while_(p, l, [])
+  private function take_while_(p : 'a => bool, l : list('a), acc : list('a)) : list('a) = switch(l)
+    []   => reverse(acc)
+    h::t => if(p(h)) take_while_(p, t, h::acc) else reverse(acc)
+
+  /* Drop elements from `l` until `p` holds */
+  function drop_while(p : 'a => bool, l : list('a)) : list('a) = switch(l)
+    []   => []
+    h::t => if(p(h)) drop_while(p, t) else l
+
+  /* Splits list into two lists of elements that respectively match and don't match predicate `p` */
+  function partition(p : 'a => bool, l : list('a)) : (list('a) * list('a)) = partition_(p, l, [], [])
+  private function partition_( p : 'a => bool
+                             , l : list('a)
+                             , acc_t : list('a)
+                             , acc_f : list('a)
+                             ) : (list('a) * list('a)) = switch(l)
+    []   => (reverse(acc_t), reverse(acc_f))
+    h::t => if(p(h)) partition_(p, t, h::acc_t, acc_f) else partition_(p, t, acc_t, h::acc_f)
+
+
+  function concats(ll : list(list('a))) : list('a) = foldr((l1, l2) => l1 ++ l2, [], ll)
+
+  function all(p : 'a => bool, l : list('a)) : bool = switch(l)
+    []   => true
+    h::t => if(p(h)) all(p, t) else false
+
+  function any(p : 'a => bool, l : list('a)) : bool = switch(l)
+    []   => 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)
+
+
+  /* Zips two list by applying bimapping function on respective elements. Drops longer tail. */
+  function zip_with(f : ('a, 'b) => 'c, l1 : list('a), l2 : list('b)) : list('c) = zip_with_(f, l1, l2, [])
+  private function zip_with_( f : ('a, 'b) => 'c
+                            , l1 : list('a)
+                            , l2 : list('b)
+                            , acc : list('c)
+                            ) : list('c) = switch ((l1, l2))
+    (h1::t1, h2::t2) => zip_with_(f, t1, t2, f(h1, h2)::acc)
+    _ => reverse(acc)
+
+  /* Zips two lists into list of pairs. Drops longer tail. */
+  function zip(l1 : list('a), l2 : list('b)) : list('a * 'b) = zip_with((a, b) => (a, b), l1, l2)
+
+  function unzip(l : list('a * 'b)) : list('a) * list('b) = unzip_(l, [], [])
+  private function unzip_( l     : list('a * 'b)
+                         , acc_l : list('a)
+                         , acc_r : list('b)
+                         ) : (list('a) * list('b)) = switch(l)
+    []               => (reverse(acc_l), reverse(acc_r))
+    (left, right)::t => unzip_(t, left::acc_l, right::acc_r)
+
+
+  // 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)
+
+
+  function intersperse(delim : 'a, l : list('a)) : list('a) = intersperse_(delim, l, [])
+  private function intersperse_(delim : 'a, l : list('a), acc : list('a)) : list('a) = switch(l)
+    []   => reverse(acc)
+    [e]  => reverse(e::acc)
+    h::t => intersperse_(delim, t, delim::h::acc)
+
+
+  function enumerate(l : list('a)) : list(int * 'a) = enumerate_(l, 0, [])
+  private function enumerate_(l : list('a), n : int, acc : list(int * 'a)) : list(int * 'a) = switch(l)
+    []   => reverse(acc)
+    h::t => enumerate_(t, n + 1, (n, h)::acc)
+
+".
+
+std_option() -> "
+namespace Option =
+
+  function is_none(o : option('a)) : bool = switch(o)
+    None => true
+    Some(_) => false
+
+  function is_some(o : option('a)) : bool = switch(o)
+    None => false
+    Some(_) => true
+
+
+  function match(n : 'b, s : 'a => 'b, o : option('a)) : 'b = switch(o)
+    None => n
+    Some(x) => s(x)
+
+  function default(def : 'a, o : option('a)) : 'a = match(def, (x) => x, o)
+
+  function force(o : option('a)) : 'a = default(abort(\"Forced None value\"), o)
+
+  function on_elem(f : 'a => unit, o : option('a)) : unit = match((), f, o)
+
+
+  function map(f : 'a => 'b, o : option('a)) : option('b) = switch(o)
+    None => None
+    Some(x) => Some(f(x))
+
+  function map2(f : ('a, 'b) => 'c
+               , o1 : option('a)
+               , o2 : option('b)
+               ) : option('c) = switch((o1, o2))
+    (Some(x1), Some(x2)) => Some(f(x1, x2))
+    _ => None
+
+  function map3( f : ('a, 'b, 'c) => 'd
+               , o1 : option('a)
+               , o2 : option('b)
+               , o3 : option('c)
+               ) : option('d) = switch((o1, o2, o3))
+    (Some(x1), Some(x2), Some(x3)) => Some(f(x1, x2, x3))
+    _ => None
+
+  function app_over(f : option ('a => 'b), o : option('a)) : option('b) = switch((f, o))
+    (Some(ff), Some(xx)) => Some(ff(xx))
+    _ => None
+
+  function flat_map(f : 'a => option('b), o : option('a)) : option('b) = switch(o)
+    None => None
+    Some(x) => f(x)
+
+
+  function to_list(o : option('a)) : list('a) = switch(o)
+    None => []
+    Some(x) => [x]
+
+  function filter_options(l : list(option('a))) : list('a) = filter_options_(l, [])
+  private function filter_options_(l : list (option('a)), acc : list('a)) : list('a) = switch(l)
+    []         => List.reverse(acc)
+    None::t    => filter_options_(t, acc)
+    Some(x)::t => filter_options_(t, x::acc)
+
+  function seq_options(l : list (option('a))) : option (list('a)) = seq_options_(l, [])
+  private function seq_options_(l : list (option('a)), acc : list('a)) : option(list('a)) = switch(l)
+    []         => Some(List.reverse(acc))
+    None::t    => None
+    Some(x)::t => seq_options_(t, x::acc)
+
+
+  function choose(o1 : option('a), o2 : option('a)) : option('a) =
+    if(is_some(o1)) o1 else o2
+
+  function choose_first(l : list(option('a))) : option('a) = switch(l)
+    [] => None
+    None::t    => choose_first(t)
+    Some(x)::_ => Some(x)
+".
+
+std_pair() -> "
+namespace Pair =
+
+  function fst(t : ('a * 'b)) : 'a = switch(t)
+    (x, _) => x
+
+  function snd(t : ('a * 'b)) : 'b = switch(t)
+    (_, y) => y
+
+
+  function map1(f : 'a => 'c, t : ('a * 'b)) : ('c * 'b) = switch(t)
+    (x, y) => (f(x), y)
+
+  function map2(f : 'b => 'c, t : ('a * 'b)) : ('a * 'c) = switch(t)
+    (x, y) => (x, f(y))
+
+  function bimap(f : 'a => 'c, g : 'b => 'd, t : ('a * 'b)) : ('c * 'd) = switch(t)
+    (x, y) => (f(x), g(y))
+
+
+  function swap(t : ('a * 'b)) : ('b * 'a) = switch(t)
+    (x, y) => (y, x)
+".
+
+std_triple() -> "
+namespace Triple =
+
+  function fst(t : ('a * 'b * 'c)) : 'a = switch(t)
+    (x, _, _) => x
+
+  function snd(t : ('a * 'b * 'c)) : 'b = switch(t)
+    (_, y, _) => y
+
+  function thd(t : ('a * 'b * 'c)) : 'c = switch(t)
+    (_, _, z) => z
+
+
+  function map1(f : 'a => 'm, t : ('a * 'b * 'c)) : ('m * 'b * 'c) = switch(t)
+    (x, y, z) => (f(x), y, z)
+
+  function map2(f : 'b => 'm, t : ('a * 'b * 'c)) : ('a * 'm * 'c) = switch(t)
+    (x, y, z) => (x, f(y), z)
+
+  function map3(f : 'c => 'm, t : ('a * 'b * 'c)) : ('a * 'b * 'm) = switch(t)
+    (x, y, z) => (x, y, f(z))
+
+  function trimap( f : 'a => 'x
+                 , g : 'b => 'y
+                 , h : 'c => 'z
+                 , t : ('a * 'b * 'c)
+                 ) : ('x * 'y * 'z) = switch(t)
+    (x, y, z) => (f(x), g(y), h(z))
+
+
+  function swap(t : ('a * 'b * 'c)) : ('c * 'b * 'a) = switch(t)
+    (x, y, z) => (z, y, x)
+
+  function rotr(t : ('a * 'b * 'c)) : ('c * 'a * 'b) = switch(t)
+    (x, y, z) => (z, x, y)
+
+  function rotl(t : ('a * 'b * 'c)) : ('b * 'c * 'a) = switch(t)
+    (x, y, z) => (y, z, x)
+".

src/aeso_syntax.erl

@@ -59,7 +59,7 @@
 -type type() :: {fun_t, ann(), [named_arg_t()], [type()], type()}
               | {app_t, ann(), type(), [type()]}
               | {tuple_t, ann(), [type()]}
-              | {bytes_t, ann(), integer()}
+              | {bytes_t, ann(), integer() | any}
               | id()  | qid()
               | con() | qcon()  %% contracts
               | tvar().
@@ -69,11 +69,11 @@
 -type constant()
     :: {int, ann(), integer()}
      | {bool, ann(), true | false}
-     | {hash, ann(), binary()}
+     | {bytes, ann(), binary()}
-     | {account_pubkey, binary()}
+     | {account_pubkey, ann(), binary()}
-     | {contract_pubkey, binary()}
+     | {contract_pubkey, ann(), binary()}
-     | {oracle_pubkey, binary()}
+     | {oracle_pubkey, ann(), binary()}
-     | {oracle_query_id, binary()}
+     | {oracle_query_id, ann(), binary()}
      | {string, ann(), binary()}
      | {char, ann(), integer()}.
 
@@ -92,6 +92,7 @@
      | {proj, ann(), expr(), id()}
      | {tuple, ann(), [expr()]}
      | {list, ann(), [expr()]}
+     | {list_comp, ann(), expr(), [comprehension_exp()]}
      | {typed, ann(), expr(), type()}
      | {record, ann(), [field(expr())]}
      | {record, ann(), expr(), [field(expr())]} %% record update
@@ -104,6 +105,10 @@
      | id() | qid() | con() | qcon()
      | constant().
 
+-type comprehension_exp() :: [{ comprehension_bind, ann(), id(), expr()}
+                             | {comprehension_if, expr()}
+                             | letbind()].
+
 -type arg_expr() :: expr() | {named_arg, ann(), id(), expr()}.
 
 %% When lvalue is a projection this is sugar for accessing fields in nested
@@ -148,4 +153,3 @@ get_ann(Key, Node, Default) ->
 qualify({con, Ann, N}, X)             -> qualify({qcon, Ann, [N]}, X);
 qualify({qcon, _, NS}, {con, Ann, C}) -> {qcon, Ann, NS ++ [C]};
 qualify({qcon, _, NS}, {id, Ann, X})  -> {qid, Ann, NS ++ [X]}.
-

src/aeso_syntax_utils.erl

@@ -6,7 +6,7 @@
 %%%-------------------------------------------------------------------
 -module(aeso_syntax_utils).
 
--export([used_ids/1, used_types/1, used/1]).
+-export([used_ids/1, used_types/2, used/1]).
 
 -record(alg, {zero, plus, scoped}).
 
@@ -71,6 +71,15 @@ fold(Alg = #alg{zero = Zero, plus = Plus, scoped = Scoped}, Fun, K, X) ->
             {proj, _, E, _}        -> Expr(E);
             {tuple, _, As}         -> Expr(As);
             {list, _, As}          -> Expr(As);
+            {list_comp, _, Y, []}  -> Expr(Y);
+            {list_comp, A, Y, [{comprehension_bind, I, E}|R]} ->
+                Plus(Expr(E), Scoped(BindExpr(I), Expr({list_comp, A, Y, R})));
+            {list_comp, A, Y, [{comprehension_if, E}|R]} ->
+                Plus(Expr(E), Expr({list_comp, A, Y, R}));
+            {list_comp, A, Y, [D = {letval, _, F, _, _} | R]} ->
+                Plus(Decl(D), Scoped(BindExpr(F), Expr({list_comp, A, Y, R})));
+            {list_comp, A, Y, [D = {letfun, _, F, _, _, _} | R]} ->
+                Plus(Decl(D), Scoped(BindExpr(F), Expr({list_comp, A, Y, R})));
             {typed, _, E, T}       -> Plus(Expr(E), Type(T));
             {record, _, Fs}        -> Expr(Fs);
             {record, _, E, Fs}     -> Expr([E | Fs]);
@@ -100,8 +109,12 @@ fold(Alg = #alg{zero = Zero, plus = Plus, scoped = Scoped}, Fun, K, X) ->
 used_ids(E) ->
     [ X || {{term, [X]}, _} <- used(E) ].
 
-used_types(T) ->
+used_types([Top] = _CurrentNS, T) ->
-    [ X || {{type, [X]}, _} <- used(T) ].
+    F = fun({{type, [X]}, _}) -> [X];
+           ({{type, [Top1, X]}, _}) when Top1 == Top -> [X];
+           (_) -> []
+        end,
+    lists:flatmap(F, used(T)).
 
 -type entity() :: {term, [string()]}
                 | {type, [string()]}

src/aeso_vm_decode.erl

@@ -0,0 +1,113 @@
+%%%-------------------------------------------------------------------
+%%% @copyright (C) 2017, Aeternity Anstalt
+%%% @doc Decoding aevm and fate data to AST
+%%%
+%%% @end
+%%%-------------------------------------------------------------------
+
+-module(aeso_vm_decode).
+
+-export([ from_aevm/3, 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"},     N) -> <<N1:256/signed>> = <<N:256>>, {int, [], N1};
+from_aevm(word, {id, _, "bits"},    N) -> error({todo, 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(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};
+from_fate({app_t, _, {id, _, "oracle_query"}, _}, ?FATE_ORACLE_Q(Bin)) -> {oracle_query_id, [], Bin};
+from_fate({con, _, _Name},  ?FATE_CONTRACT(Bin)) -> {contract_pubkey, [], Bin};
+from_fate({bytes_t, _, N},  ?FATE_BYTES(Bin)) when byte_size(Bin) == N -> {bytes, [], Bin};
+from_fate({id, _, "bits"},  ?FATE_BITS(Bin)) -> error({todo, bits, Bin});
+from_fate({id, _, "int"},     N) when is_integer(N) -> {int, [], N};
+from_fate({id, _, "bool"},    B) when is_boolean(B) -> {bool, [], B};
+from_fate({id, _, "string"}, S) when is_binary(S) -> {string, [], S};
+from_fate({app_t, _, {id, _, "list"}, [Type]}, List) when is_list(List) ->
+    {list, [], [from_fate(Type, X) || X <- List]};
+from_fate({app_t, _, {id, _, "option"}, [Type]}, Val) ->
+    case Val of
+        {variant, [0, 1], 0, {}}  -> {con, [], "None"};
+        {variant, [0, 1], 1, {X}} -> {app, [], {con, [], "Some"}, [from_fate(Type, X)]}
+    end;
+from_fate({tuple_t, _, []}, ?FATE_UNIT) ->
+     {tuple, [], []};
+from_fate({tuple_t, _, Types}, ?FATE_TUPLE(Val))
+        when length(Types) == tuple_size(Val) ->
+    {tuple, [], [from_fate(Type, X)
+                 || {Type, X} <- lists:zip(Types, tuple_to_list(Val))]};
+from_fate({record_t, Fields}, ?FATE_TUPLE(Val))
+        when length(Fields) == tuple_size(Val) ->
+    {record, [], [ {field, [], [{proj, [], FName}], from_fate(FType, X)}
+                   || {{field_t, _, FName, FType}, X} <- lists:zip(Fields, tuple_to_list(Val)) ]};
+from_fate({app_t, _, {id, _, "map"}, [KeyType, ValType]}, Map)
+        when is_map(Map) ->
+    {map, [], [ {from_fate(KeyType, Key),
+                 from_fate(ValType, Val)}
+                || {Key, Val} <- maps:to_list(Map) ]};
+from_fate({variant_t, Cons}, {variant, Ar, Tag, Args})
+        when length(Cons) > Tag ->
+    ConType = lists:nth(Tag + 1, Cons),
+    Arity = lists:nth(Tag + 1, Ar),
+    case tuple_to_list(Args) of
+        ArgList when length(ArgList) == Arity ->
+            from_fate(ConType, ArgList);
+        _ -> throw(cannot_translate_to_sophia)
+    end;
+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(_Type, _Data) ->
+    throw(cannot_translate_to_sophia).

src/aesophia.app.src

@@ -1,6 +1,6 @@
 {application, aesophia,
  [{description, "Contract Language for aeternity"},
-  {vsn, "3.0.0"},
+  {vsn, "4.0.0-rc1"},
   {registered, []},
   {applications,
    [kernel,
@@ -8,7 +8,8 @@
     jsx,
     syntax_tools,
     getopt,
-    aebytecode
+    aebytecode,
+    eblake2
    ]},
   {env,[]},
   {modules, []},

test/aeso_abi_tests.erl

@@ -1,7 +1,7 @@
 -module(aeso_abi_tests).
 
 -include_lib("eunit/include/eunit.hrl").
--compile(export_all).
+-compile([export_all, nowarn_export_all]).
 
 -define(SANDBOX(Code), sandbox(fun() -> Code end)).
 -define(DUMMY_HASH_WORD, 16#123).
@@ -62,10 +62,11 @@ encode_decode_sophia_test() ->
                                 Other -> Other
                               end end,
     ok = Check("int", "42"),
+    ok = Check("int", "-42"),
     ok = Check("bool", "true"),
     ok = Check("bool", "false"),
     ok = Check("string", "\"Hello\""),
-    ok = Check("(string, list(int), option(bool))",
+    ok = Check("string * list(int) * option(bool)",
                "(\"Hello\", [1, 2, 3], Some(true))"),
     ok = Check("variant", "Blue({[\"x\"] = 1})"),
     ok = Check("r", "{x = (\"foo\", 0), y = Red}"),
@@ -75,15 +76,15 @@ encode_decode_sophia_string(SophiaType, String) ->
     io:format("String ~p~n", [String]),
     Code = [ "contract MakeCall =\n"
            , "  type arg_type = ", SophiaType, "\n"
-           , "  type an_alias('a) = (string, 'a)\n"
+           , "  type an_alias('a) = string * 'a\n"
            , "  record r = {x : an_alias(int), y : variant}\n"
            , "  datatype variant = Red | Blue(map(string, int))\n"
-           , "  function foo : arg_type => arg_type\n" ],
+           , "  entrypoint foo : arg_type => arg_type\n" ],
-    case aeso_compiler:check_call(lists:flatten(Code), "foo", [String], []) of
+    case aeso_compiler:check_call(lists:flatten(Code), "foo", [String], [no_implicit_stdlib]) of
         {ok, _, {[Type], _}, [Arg]} ->
             io:format("Type ~p~n", [Type]),
             Data = encode(Arg),
-            case aeso_compiler:to_sophia_value(Code, "foo", ok, Data) of
+            case aeso_compiler:to_sophia_value(Code, "foo", ok, Data, [no_implicit_stdlib]) of
                 {ok, Sophia} ->
                     lists:flatten(io_lib:format("~s", [prettypr:format(aeso_pretty:expr(Sophia))]));
                 {error, Err} ->
@@ -119,16 +120,14 @@ calldata_init_test() ->
 
 calldata_indent_test() ->
     Test = fun(Extra) ->
-            encode_decode_calldata_(
+            Code = parameterized_contract(Extra, "foo", ["int"]),
-                parameterized_contract(Extra, "foo", ["int"]),
+            encode_decode_calldata_(Code, "foo", ["42"], word)
-                "foo", ["42"], word)
            end,
-    Test("  stateful function bla() = ()"),
+    Test("  stateful entrypoint bla() = ()"),
     Test("  type x = int"),
-    Test("  private function bla : int => int"),
+    Test("  stateful entrypoint bla(x : int) =\n"
-    Test("  public stateful function bla(x : int) =\n"
          "    x + 1"),
-    Test("  stateful private function bla(x : int) : int =\n"
+    Test("  stateful entrypoint bla(x : int) : int =\n"
          "    x + 1"),
     ok.
 
@@ -138,32 +137,32 @@ parameterized_contract(FunName, Types) ->
 parameterized_contract(ExtraCode, FunName, Types) ->
     lists:flatten(
         ["contract Remote =\n"
-         "  function bla : () => ()\n\n"
+         "  entrypoint bla : () => unit\n\n"
          "contract Dummy =\n",
          ExtraCode, "\n",
-         "  type an_alias('a) = (string, 'a)\n"
+         "  type an_alias('a) = string * 'a\n"
          "  record r = {x : an_alias(int), y : variant}\n"
          "  datatype variant = Red | Blue(map(string, int))\n"
-         "  function ", FunName, " : (", string:join(Types, ", "), ") => int\n" ]).
+         "  entrypoint ", FunName, " : (", string:join(Types, ", "), ") => int\n" ]).
 
 oracle_test() ->
     Contract =
         "contract OracleTest =\n"
-        "  function question(o, q : oracle_query(list(string), option(int))) =\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]} =
         aeso_compiler:check_call(Contract, "question", ["ok_111111111111111111111111111111ZrdqRz9",
-                                                        "oq_1111111111111111111111111111113AFEFpt5"], []),
+                                                        "oq_1111111111111111111111111111113AFEFpt5"], [no_implicit_stdlib]),
 
     ok.
 
 permissive_literals_fail_test() ->
     Contract =
         "contract OracleTest =\n"
-        "  stateful function haxx(o : oracle(list(string), option(int))) =\n"
+        "  stateful entrypoint haxx(o : oracle(list(string), option(int))) =\n"
         "    Chain.spend(o, 1000000)\n",
         {error, <<"Type errors\nCannot unify", _/binary>>} =
-            aeso_compiler:check_call(Contract, "haxx", ["#123"], []),
+            aeso_compiler:check_call(Contract, "haxx", ["#123"], [no_implicit_stdlib]),
     ok.
 
 encode_decode_calldata(FunName, Types, Args) ->
@@ -174,14 +173,16 @@ encode_decode_calldata(FunName, Types, Args, RetType) ->
     encode_decode_calldata_(Code, FunName, Args, RetType).
 
 encode_decode_calldata_(Code, FunName, Args, RetVMType) ->
-    {ok, Calldata, CalldataType, RetVMType1} = aeso_compiler:create_calldata(Code, FunName, Args),
+    {ok, Calldata} = aeso_compiler:create_calldata(Code, FunName, Args, [no_implicit_stdlib]),
-    ?assertEqual(RetVMType1, RetVMType),
+    {ok, _, {ArgTypes, RetType}, _} = aeso_compiler:check_call(Code, FunName, Args, [{backend, aevm}, no_implicit_stdlib]),
+    ?assertEqual(RetType, RetVMType),
+    CalldataType = {tuple, [word, {tuple, ArgTypes}]},
     {ok, {_Hash, ArgTuple}} = aeb_heap:from_binary(CalldataType, Calldata),
     case FunName of
         "init" ->
             ok;
         _ ->
-            {ok, _ArgTypes, ValueASTs} = aeso_compiler:decode_calldata(Code, FunName, Calldata),
+            {ok, _ArgTypes, ValueASTs} = aeso_compiler:decode_calldata(Code, FunName, Calldata, [no_implicit_stdlib]),
             Values = [ prettypr:format(aeso_pretty:expr(V)) || V <- ValueASTs ],
             ?assertMatch({X, X}, {Args, Values})
     end,

test/aeso_aci_tests.erl

@@ -2,75 +2,125 @@
 
 -include_lib("eunit/include/eunit.hrl").
 
-
+simple_aci_test_() ->
-do_test() ->
+    [{"Test contract " ++ integer_to_list(N),
-    test_contract(1),
+      fun() -> test_contract(N) end}
-    test_contract(2),
+     || N <- [1, 2, 3]].
-    test_contract(3).
 
 test_contract(N) ->
     {Contract,MapACI,DecACI} = test_cases(N),
-    {ok,JSON} = aeso_aci:encode(Contract),
+    {ok,JSON} = aeso_aci:contract_interface(json, Contract, [no_implicit_stdlib]),
-    ?assertEqual(MapACI, jsx:decode(JSON, [return_maps])),
+    ?assertEqual([MapACI], JSON),
-    ?assertEqual(DecACI, aeso_aci:decode(JSON)).
+    ?assertEqual({ok, DecACI}, aeso_aci:render_aci_json(JSON)).
 
 test_cases(1) ->
-    Contract = <<"contract C =\n"
+    Contract = <<"payable contract C =\n"
-		 "  function a(i : int) = i+1\n">>,
+		 "  payable stateful entrypoint a(i : int) = i+1\n">>,
-    MapACI = #{<<"contract">> =>
+    MapACI = #{contract =>
-		   #{<<"name">> => <<"C">>,
+		   #{name => <<"C">>,
-		     <<"type_defs">> => [],
+		     type_defs => [],
-		     <<"functions">> =>
+                     payable => true,
-			 [#{<<"name">> => <<"a">>,
+		     functions =>
-			    <<"arguments">> => 
+			 [#{name => <<"a">>,
-				[#{<<"name">> => <<"i">>,
+			    arguments =>
-				   <<"type">> => [<<"int">>]}],
+				[#{name => <<"i">>,
-			    <<"returns">> => <<"int">>,
+				   type => <<"int">>}],
-			    <<"stateful">> => false}]}},
+			    returns => <<"int">>,
-    DecACI = <<"contract C =\n"
+			    stateful => true,
-	       "  function a : (int) => int\n">>,
+                            payable  => true}]}},
+    DecACI = <<"payable contract C =\n"
+	       "  payable entrypoint a : (int) => int\n">>,
     {Contract,MapACI,DecACI};
 
 test_cases(2) ->
     Contract = <<"contract C =\n"
 		 "  type allan = int\n"
-		 "  function a(i : allan) = i+1\n">>,
+		 "  entrypoint a(i : allan) = i+1\n">>,
-    MapACI = #{<<"contract">> =>
+    MapACI = #{contract =>
-                       #{<<"name">> => <<"C">>,
+                       #{name => <<"C">>, payable => false,
-                         <<"type_defs">> =>
+                         type_defs =>
-                             [#{<<"name">> => <<"allan">>,
+                             [#{name => <<"allan">>,
-                                <<"typedef">> => <<"int">>,
+                                typedef => <<"int">>,
-                                <<"vars">> => []}],
+                                vars => []}],
-			 <<"functions">> =>
+			 functions =>
-                             [#{<<"arguments">> =>
+                             [#{arguments =>
-                                    [#{<<"name">> => <<"i">>,
+                                    [#{name => <<"i">>,
-                                       <<"type">> => [<<"int">>]}],
+                                       type => <<"C.allan">>}],
-                                <<"name">> => <<"a">>,
+                                name => <<"a">>,
-                                <<"returns">> => <<"int">>,
+                                returns => <<"int">>,
-                                <<"stateful">> => false}]}},
+                                stateful => false,
+                                payable  => false}]}},
     DecACI = <<"contract C =\n"
-	       "  function a : (int) => int\n">>,
+               "  type allan = int\n"
+               "  entrypoint a : (C.allan) => int\n">>,
     {Contract,MapACI,DecACI};
 test_cases(3) ->
     Contract = <<"contract C =\n"
+                 "  type state = unit\n"
+                 "  datatype event = SingleEventDefined\n"
 		 "  datatype bert('a) = Bin('a)\n"
-		 "  function a(i : bert(string)) = 1\n">>,
+		 "  entrypoint a(i : bert(string)) = 1\n">>,
-    MapACI = #{<<"contract">> =>
+    MapACI = #{contract =>
-		   #{<<"functions">> =>
+		   #{functions =>
-			 [#{<<"arguments">> =>
+			 [#{arguments =>
-				[#{<<"name">> => <<"i">>,
+				[#{name => <<"i">>,
-				   <<"type">> =>
+				   type =>
-				       [#{<<"C.bert">> => [<<"string">>]}]}],
+				       #{<<"C.bert">> => [<<"string">>]}}],
-			    <<"name">> => <<"a">>,<<"returns">> => <<"int">>,
+			    name => <<"a">>,returns => <<"int">>,
-			    <<"stateful">> => false}],
+			    stateful => false, payable  => false}],
-		     <<"name">> => <<"C">>,
+		     name => <<"C">>, payable => false,
-		     <<"type_defs">> =>
+                     event => #{variant => [#{<<"SingleEventDefined">> => []}]},
-			 [#{<<"name">> => <<"bert">>,
+                     state => <<"unit">>,
-			    <<"typedef">> =>
+		     type_defs =>
-				#{<<"variant">> =>
+			 [#{name => <<"bert">>,
+			    typedef =>
+				#{variant =>
 				      [#{<<"Bin">> => [<<"'a">>]}]},
-			    <<"vars">> => [#{<<"name">> => <<"'a">>}]}]}},
+			    vars => [#{name => <<"'a">>}]}]}},
     DecACI = <<"contract C =\n"
+               "  type state = unit\n"
+               "  datatype event = SingleEventDefined\n"
 	       "  datatype bert('a) = Bin('a)\n"
-	       "  function a : (C.bert(string)) => int\n">>,
+	       "  entrypoint a : (C.bert(string)) => int\n">>,
     {Contract,MapACI,DecACI}.
+
+%% Rounttrip
+aci_test_() ->
+    [{"Testing ACI generation for " ++ ContractName,
+      fun() -> aci_test_contract(ContractName) end}
+     || ContractName <- all_contracts()].
+
+all_contracts() -> [C || C <- aeso_compiler_tests:compilable_contracts()
+                             , not aeso_compiler_tests:wants_stdlib(C)].
+
+aci_test_contract(Name) ->
+    String = aeso_test_utils:read_contract(Name),
+    Opts   = [{include, {file_system, [aeso_test_utils:contract_path()]}}],
+    {ok, JSON} = aeso_aci:contract_interface(json, String, Opts),
+
+    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.
+
+check_stub(Stub, Options) ->
+    case aeso_parser:string(binary_to_list(Stub), Options) of
+        {ok, Ast} ->
+            try
+                %% io:format("AST: ~120p\n", [Ast]),
+                aeso_ast_infer_types:infer(Ast, [])
+            catch _:{type_errors, TE} ->
+                io:format("Type error:\n~s\n", [TE]),
+                error(TE);
+                  _:R ->
+                io:format("Error: ~p\n", [R]),
+                error(R)
+            end;
+        {error, E} ->
+            io:format("Error: ~p\n", [E]),
+            error({parse_error, E})
+    end.
+

test/aeso_calldata_tests.erl

@@ -0,0 +1,133 @@
+%%% -*- erlang-indent-level:4; indent-tabs-mode: nil -*-
+%%%-------------------------------------------------------------------
+%%% @copyright (C) 2019, Aeternity Anstalt
+%%% @doc Test Sophia language compiler.
+%%%
+%%% @end
+%%%-------------------------------------------------------------------
+
+-module(aeso_calldata_tests).
+
+-compile([export_all, nowarn_export_all]).
+
+-include_lib("eunit/include/eunit.hrl").
+
+%%  Very simply test compile the given contracts. Only basic checks
+%%  are made on the output, just that it is a binary which indicates
+%%  that the compilation worked.
+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}]
+                                    ++ [no_implicit_stdlib || not aeso_compiler_tests:wants_stdlib(ContractName)]);
+                  false -> undefined
+              end,
+           FateExprs =
+              case not lists:member(ContractName, not_yet_compilable(fate)) of
+                  true -> ast_exprs(ContractString, Fun, Args, [{backend, fate}]
+                                    ++ [no_implicit_stdlib || not aeso_compiler_tests:wants_stdlib(ContractName)]);
+                  false -> undefined
+              end,
+           case FateExprs == undefined orelse AevmExprs == undefined of
+               true -> ok;
+               false ->
+                   ?assertEqual(FateExprs, AevmExprs)
+           end
+        end} || {ContractName, Fun, Args} <- compilable_contracts()].
+
+calldata_aci_test_() ->
+     [ {"Testing " ++ ContractName ++ " contract calling " ++ Fun,
+        fun() ->
+           ContractString       = aeso_test_utils:read_contract(ContractName),
+           {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}]
+                                    ++ [no_implicit_stdlib || not aeso_compiler_tests:wants_stdlib(ContractName)]);
+                  false -> undefined
+              end,
+           FateExprs =
+              case not lists:member(ContractName, not_yet_compilable(fate)) of
+                  true -> ast_exprs(ContractACI, Fun, Args, [{backend, fate}]
+                                    ++ [no_implicit_stdlib || not aeso_compiler_tests:wants_stdlib(ContractName)]);
+                  false -> undefined
+              end,
+           case FateExprs == undefined orelse AevmExprs == undefined of
+               true -> ok;
+               false ->
+                   ?assertEqual(FateExprs, AevmExprs)
+           end
+        end} || {ContractName, Fun, Args} <- compilable_contracts()].
+
+
+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)),
+    ?assert(is_list(Exprs)),
+    Exprs.
+
+check_errors(Expect, ErrorString) ->
+    %% This removes the final single \n as well.
+    Actual = binary:split(<<ErrorString/binary,$\n>>, <<"\n\n">>, [global,trim]),
+    case {Expect -- Actual, Actual -- Expect} of
+        {[], Extra}   -> ?assertMatch({unexpected, []}, {unexpected, Extra});
+        {Missing, []} -> ?assertMatch({missing, []}, {missing, Missing});
+        {Missing, Extra} -> ?assertEqual(Missing, Extra)
+    end.
+
+%% compilable_contracts() -> [ContractName].
+%%  The currently compilable contracts.
+
+compilable_contracts() ->
+    [
+     {"identity", "init", []},
+     {"maps", "init", []},
+     {"funargs", "menot", ["false"]},
+     {"funargs", "append", ["[\"false\", \" is\", \" not\", \" true\"]"]},
+     %% TODO {"funargs", "bitsum", ["Bits.all"]},
+     {"funargs", "read", ["{label = \"question 1\", result = 4}"]},
+     {"funargs", "sjutton", ["#0011012003100011012003100011012003"]},
+     {"funargs", "sextiosju", ["#01020304050607080910111213141516171819202122232425262728293031323334353637383940"
+                               "414243444546474849505152535455565758596061626364656667"]},
+     {"funargs", "trettiotva", ["#0102030405060708091011121314151617181920212223242526272829303132"]},
+     {"funargs", "find_oracle", ["ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5"]},
+     {"funargs", "find_query", ["oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY"]},
+     {"funargs", "traffic_light", ["Green"]},
+     {"funargs", "traffic_light", ["Pantone(12)"]},
+     {"funargs", "tuples", ["()"]},
+     %% TODO {"funargs", "due", ["FixedTTL(1020)"]},
+     {"variant_types", "init", []},
+     {"basic_auth", "init", []},
+     {"address_literals", "init", []},
+     {"bytes_equality", "init", []},
+     {"address_chain", "init", []},
+     {"counter", "init",
+      ["-3334353637383940202122232425262728293031323334353637"]},
+     {"dutch_auction", "init",
+      ["ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt", "200000", "1000"]},
+     {"maps", "fromlist_i",
+      ["[(1, {x = 1, y = 2}), (2, {x = 3, y = 4}), (3, {x = 4, y = 4})]"]},
+     {"maps", "get_i", ["1", "{}"]},
+     {"maps", "get_i", ["1", "{[1] = {x = 3, y = 4}}"]},
+     {"maps", "get_i", ["1", "{[1] = {x = 3, y = 4}, [2] = {x = 4, y = 5}}"]},
+     {"maps", "get_i", ["1", "{[1] = {x = 3, y = 4}, [2] = {x = 4, y = 5}, [3] = {x = 5, y = 6}}"]},
+     {"strings", "str_concat", ["\"test\"","\"me\""]},
+     {"complex_types", "filter_some", ["[Some(11), Some(12), None]"]},
+     {"complex_types", "init", ["ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ"]},
+     {"__call" "init", []},
+     {"bitcoin_auth", "authorize", ["1", "#0102030405060708090a0b0c0d0e0f101718192021222324252627282930313233343536373839401a1b1c1d1e1f20212223242526272829303132333435363738"]},
+     {"bitcoin_auth", "to_sign", ["#0102030405060708090a0b0c0d0e0f1017181920212223242526272829303132", "2"]},
+     {"stub", "foo", ["42"]},
+     {"stub", "foo", ["-42"]},
+     {"payable", "foo", ["42"]}
+    ].
+
+not_yet_compilable(fate) ->
+    [];
+not_yet_compilable(aevm) ->
+    [].

test/aeso_compiler_tests.erl

@@ -16,20 +16,25 @@
 %%  are made on the output, just that it is a binary which indicates
 %%  that the compilation worked.
 simple_compile_test_() ->
-     [ {"Testing the " ++ ContractName ++ " contract",
+     [ {"Testing the " ++ ContractName ++ " contract with the " ++ atom_to_list(Backend) ++ " backend",
         fun() ->
-            case compile(ContractName) of
+            case compile(Backend, ContractName) of
                 #{byte_code := ByteCode,
                   contract_source := _,
-                  type_info := _} -> ?assertMatch(Code when is_binary(Code), ByteCode);
+                  type_info := _} when Backend == aevm ->
+                    ?assertMatch(Code when is_binary(Code), ByteCode);
+                #{fate_code := Code} when Backend == fate ->
+                    Code1 = aeb_fate_code:deserialize(aeb_fate_code:serialize(Code)),
+                    ?assertMatch({X, X}, {Code1, Code});
                 ErrBin ->
                     io:format("\n~s", [ErrBin]),
                     error(ErrBin)
             end
-        end} || ContractName <- compilable_contracts() ] ++
+        end} || ContractName <- compilable_contracts(), Backend <- [aevm, fate],
+                not lists:member(ContractName, not_yet_compilable(Backend))] ++
      [ {"Testing error messages of " ++ ContractName,
         fun() ->
-            case compile(ContractName) of
+            case compile(aevm, ContractName) of
                 <<"Type errors\n", ErrorString/binary>> ->
                     check_errors(lists:sort(ExpectedErrors), ErrorString);
                 <<"Parse errors\n", ErrorString/binary>> ->
@@ -44,19 +49,21 @@ simple_compile_test_() ->
                     {ok, Bin} = file:read_file(filename:join([aeso_test_utils:contract_path(), File])),
                     {File, Bin}
                   end || File <- ["included.aes", "../contracts/included2.aes"] ]),
-            #{byte_code := Code1} = compile("include", [{include, {explicit_files, FileSystem}}]),
+            #{byte_code := Code1} = compile(aevm, "include", [{include, {explicit_files, FileSystem}}]),
-            #{byte_code := Code2} = compile("include"),
+            #{byte_code := Code2} = compile(aevm, "include"),
             ?assertMatch(true, Code1 == Code2)
         end} ] ++
-     [ {"Testing deadcode elimination",
+     [ {"Testing deadcode elimination for " ++ atom_to_list(Backend),
         fun() ->
-            #{ byte_code := NoDeadCode } = compile("nodeadcode"),
+            #{ byte_code := NoDeadCode } = compile(Backend, "nodeadcode"),
-            #{ byte_code := DeadCode   } = compile("deadcode"),
+            #{ byte_code := DeadCode   } = compile(Backend, "deadcode"),
             SizeNoDeadCode = byte_size(NoDeadCode),
             SizeDeadCode   = byte_size(DeadCode),
-            ?assertMatch({_, _, true}, {SizeDeadCode, SizeNoDeadCode, SizeDeadCode + 40 < SizeNoDeadCode}),
+            Delta          = if Backend == aevm -> 40;
+                                Backend == fate -> 20 end,
+            ?assertMatch({_, _, true}, {SizeDeadCode, SizeNoDeadCode, SizeDeadCode + Delta < SizeNoDeadCode}),
             ok
-        end} ].
+        end} || Backend <- [aevm, fate] ].
 
 check_errors(Expect, ErrorString) ->
     %% This removes the final single \n as well.
@@ -67,12 +74,14 @@ check_errors(Expect, ErrorString) ->
         {Missing, Extra} -> ?assertEqual(Missing, Extra)
     end.
 
-compile(Name) ->
+compile(Backend, Name) ->
-    compile(Name, [{include, {file_system, [aeso_test_utils:contract_path()]}}]).
+    compile(Backend, Name,
+            [{include, {file_system, [aeso_test_utils:contract_path()]}}]
+            ++ [no_implicit_stdlib || not wants_stdlib(Name)]).
 
-compile(Name, Options) ->
+compile(Backend, Name, Options) ->
     String = aeso_test_utils:read_contract(Name),
-    case aeso_compiler:from_string(String, [{src_file, Name} | Options]) of
+    case aeso_compiler:from_string(String, [{src_file, Name}, {backend, Backend} | Options]) of
         {ok, Map}            -> Map;
         {error, ErrorString} -> ErrorString
     end.
@@ -109,9 +118,22 @@ compilable_contracts() ->
      "bitcoin_auth",
      "address_literals",
      "bytes_equality",
-     "address_chain"
+     "address_chain",
+     "namespace_bug",
+     "bytes_to_x",
+     "aens",
+     "tuple_match",
+     "cyclic_include",
+     "stdlib_include",
+     "double_include",
+     "manual_stdlib_include",
+     "list_comp",
+     "payable"
     ].
 
+not_yet_compilable(fate) -> [];
+not_yet_compilable(aevm) -> [].
+
 %% Contracts that should produce type errors
 
 failing_contracts() ->
@@ -119,6 +141,9 @@ failing_contracts() ->
        [<<"Duplicate definitions of abort at\n"
           "  - (builtin location)\n"
           "  - line 14, column 3">>,
+        <<"Duplicate definitions of require at\n"
+          "  - (builtin location)\n"
+          "  - line 15, column 3">>,
         <<"Duplicate definitions of double_def at\n"
           "  - line 10, column 3\n"
           "  - line 11, column 3">>,
@@ -130,12 +155,12 @@ failing_contracts() ->
           "  - line 8, column 3">>,
         <<"Duplicate definitions of put at\n"
           "  - (builtin location)\n"
-          "  - line 15, column 3">>,
+          "  - line 16, column 3">>,
         <<"Duplicate definitions of state at\n"
           "  - (builtin location)\n"
-          "  - line 16, column 3">>]}
+          "  - line 17, column 3">>]}
     , {"type_errors",
-       [<<"Unbound variable zz at line 17, column 21">>,
+       [<<"Unbound variable zz at line 17, column 23">>,
         <<"Cannot unify int\n"
           "         and list(int)\n"
           "when checking the application at line 26, column 9 of\n"
@@ -146,18 +171,18 @@ failing_contracts() ->
         <<"Cannot unify string\n"
           "         and int\n"
           "when checking the assignment of the field\n"
-          "  x : map(string, string) (at line 9, column 46)\n"
+          "  x : map(string, string) (at line 9, column 48)\n"
           "to the old value __x and the new value\n"
           "  __x {[\"foo\"] @ x = x + 1} : map(string, int)">>,
         <<"Cannot unify int\n"
           "         and string\n"
-          "when checking the type of the expression at line 34, column 45\n"
+          "when checking the type of the expression at line 34, column 47\n"
           "  1 : int\n"
           "against the expected type\n"
           "  string">>,
         <<"Cannot unify string\n"
           "         and int\n"
-          "when checking the type of the expression at line 34, column 50\n"
+          "when checking the type of the expression at line 34, column 52\n"
           "  \"bla\" : string\n"
           "against the expected type\n"
           "  int">>,
@@ -169,7 +194,7 @@ failing_contracts() ->
           "  int">>,
         <<"Cannot unify string\n"
           "         and int\n"
-          "when checking the type of the expression at line 11, column 56\n"
+          "when checking the type of the expression at line 11, column 58\n"
           "  \"foo\" : string\n"
           "against the expected type\n"
           "  int">>,
@@ -179,52 +204,51 @@ failing_contracts() ->
           "  - w : int (at line 38, column 13)\n"
           "  - z : string (at line 39, column 10)">>,
         <<"Not a record type: string\n"
-          "arising from the projection of the field y (at line 22, column 38)">>,
+          "arising from the projection of the field y (at line 22, column 40)">>,
         <<"Not a record type: string\n"
-          "arising from an assignment of the field y (at line 21, column 42)">>,
+          "arising from an assignment of the field y (at line 21, column 44)">>,
         <<"Not a record type: string\n"
-          "arising from an assignment of the field y (at line 20, column 38)">>,
+          "arising from an assignment of the field y (at line 20, column 40)">>,
         <<"Not a record type: string\n"
-          "arising from an assignment of the field y (at line 19, column 35)">>,
+          "arising from an assignment of the field y (at line 19, column 37)">>,
-        <<"Ambiguous record type with field y (at line 13, column 25) could be one of\n"
+        <<"Ambiguous record type with field y (at line 13, column 27) could be one of\n"
           "  - r (at line 4, column 10)\n"
           "  - r' (at line 5, column 10)">>,
         <<"Repeated name x in pattern\n"
           "  x :: x (at line 26, column 7)">>,
-        <<"Repeated argument x to function repeated_arg (at line 44, column 12).">>,
+        <<"Repeated argument x to function repeated_arg (at line 44, column 14).">>,
-        <<"Repeated argument y to function repeated_arg (at line 44, column 12).">>,
+        <<"Repeated argument y to function repeated_arg (at line 44, column 14).">>,
-        <<"No record type with fields y, z (at line 14, column 22)">>,
+        <<"No record type with fields y, z (at line 14, column 24)">>,
-        <<"The field z is missing when constructing an element of type r2 (at line 15, column 24)">>,
+        <<"The field z is missing when constructing an element of type r2 (at line 15, column 26)">>,
-        <<"Record type r2 does not have field y (at line 15, column 22)">>]}
+        <<"Record type r2 does not have field y (at line 15, column 24)">>,
+        <<"Let binding at line 47, column 5 must be followed by an expression">>,
+        <<"Let binding at line 50, column 5 must be followed by an expression">>,
+        <<"Let binding at line 54, column 5 must be followed by an expression">>,
+        <<"Let binding at line 58, column 5 must be followed by an expression">>]}
     , {"init_type_error",
        [<<"Cannot unify string\n"
           "         and map(int, int)\n"
           "when checking that 'init' returns a value of type 'state' at line 7, column 3">>]}
     , {"missing_state_type",
        [<<"Cannot unify string\n"
-          "         and ()\n"
+          "         and unit\n"
           "when checking that 'init' returns a value of type 'state' at line 5, column 3">>]}
     , {"missing_fields_in_record_expression",
-       [<<"The field x is missing when constructing an element of type r('a) (at line 7, column 40)">>,
+       [<<"The field x is missing when constructing an element of type r('a) (at line 7, column 42)">>,
-        <<"The field y is missing when constructing an element of type r(int) (at line 8, column 40)">>,
+        <<"The field y is missing when constructing an element of type r(int) (at line 8, column 42)">>,
-        <<"The fields y, z are missing when constructing an element of type r('1) (at line 6, column 40)">>]}
+        <<"The fields y, z are missing when constructing an element of type r('a) (at line 6, column 42)">>]}
     , {"namespace_clash",
        [<<"The contract Call (at line 4, column 10) has the same name as a namespace at (builtin location)">>]}
     , {"bad_events",
-        [<<"The payload type int (at line 10, column 30) should be string">>,
+        [<<"The indexed type string (at line 9, column 25) is not a word type">>,
-         <<"The payload type alias_address (at line 12, column 30) equals address but it should be string">>,
+         <<"The indexed type alias_string (at line 10, column 25) equals string which is not a word type">>]}
-         <<"The indexed type string (at line 9, column 25) is not a word type">>,
-         <<"The indexed type alias_string (at line 11, column 25) equals string which is not a word type">>]}
     , {"bad_events2",
         [<<"The event constructor BadEvent1 (at line 9, column 7) has too many non-indexed values (max 1)">>,
-         <<"The event constructor BadEvent2 (at line 10, column 7) has too many indexed values (max 3)">>,
+         <<"The event constructor BadEvent2 (at line 10, column 7) has too many indexed values (max 3)">>]}
-         <<"The event constructor BadEvent3 (at line 11, column 7) has too many non-indexed values (max 1)">>,
-         <<"The payload type address (at line 11, column 17) should be string">>,
-         <<"The payload type int (at line 11, column 26) should be string">>]}
     , {"type_clash",
         [<<"Cannot unify int\n"
            "         and string\n"
-           "when checking the record projection at line 12, column 40\n"
+           "when checking the record projection at line 12, column 42\n"
            "  r.foo : (gas : int, value : int) => Remote.themap\n"
            "against the expected type\n"
            "  (gas : int, value : int) => map(string, int)">>]}
@@ -247,46 +271,46 @@ failing_contracts() ->
            "  ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ\n"
            "has the type\n"
            "  address">>,
-         <<"Cannot unify oracle_query('1, '2)\n"
+         <<"Cannot unify oracle_query('a, 'b)\n"
            "         and Remote\n"
            "when checking the type of the expression at line 25, column 5\n"
            "  oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY :\n"
-           "    oracle_query('1, '2)\n"
+           "    oracle_query('a, 'b)\n"
            "against the expected type\n"
            "  Remote">>,
-         <<"Cannot unify oracle_query('3, '4)\n"
+         <<"Cannot unify oracle_query('c, 'd)\n"
            "         and bytes(32)\n"
            "when checking the type of the expression at line 23, column 5\n"
            "  oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY :\n"
-           "    oracle_query('3, '4)\n"
+           "    oracle_query('c, 'd)\n"
            "against the expected type\n"
            "  bytes(32)">>,
-         <<"Cannot unify oracle_query('5, '6)\n"
+         <<"Cannot unify oracle_query('e, 'f)\n"
            "         and oracle(int, bool)\n"
            "when checking the type of the expression at line 21, column 5\n"
            "  oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY :\n"
-           "    oracle_query('5, '6)\n"
+           "    oracle_query('e, 'f)\n"
            "against the expected type\n"
            "  oracle(int, bool)">>,
-         <<"Cannot unify oracle('7, '8)\n"
+         <<"Cannot unify oracle('g, 'h)\n"
            "         and Remote\n"
            "when checking the type of the expression at line 18, column 5\n"
            "  ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5 :\n"
-           "    oracle('7, '8)\n"
+           "    oracle('g, 'h)\n"
            "against the expected type\n"
            "  Remote">>,
-         <<"Cannot unify oracle('9, '10)\n"
+         <<"Cannot unify oracle('i, 'j)\n"
            "         and bytes(32)\n"
            "when checking the type of the expression at line 16, column 5\n"
            "  ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5 :\n"
-           "    oracle('9, '10)\n"
+           "    oracle('i, 'j)\n"
            "against the expected type\n"
            "  bytes(32)">>,
-         <<"Cannot unify oracle('11, '12)\n"
+         <<"Cannot unify oracle('k, 'l)\n"
            "         and oracle_query(int, bool)\n"
            "when checking the type of the expression at line 14, column 5\n"
            "  ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5 :\n"
-           "    oracle('11, '12)\n"
+           "    oracle('k, 'l)\n"
            "against the expected type\n"
            "  oracle_query(int, bool)">>,
          <<"Cannot unify address\n"
@@ -308,25 +332,55 @@ failing_contracts() ->
            "against the expected type\n"
            "  bytes(32)">>]}
     , {"stateful",
-       [<<"Cannot reference stateful function Chain.spend (at line 13, column 33)\nin the definition of non-stateful function fail1.">>,
+       [<<"Cannot reference stateful function Chain.spend (at line 13, column 35)\nin the definition of non-stateful function fail1.">>,
-        <<"Cannot reference stateful function local_spend (at line 14, column 33)\nin the definition of non-stateful function fail2.">>,
+        <<"Cannot reference stateful function local_spend (at line 14, column 35)\nin the definition of non-stateful function fail2.">>,
         <<"Cannot reference stateful function Chain.spend (at line 16, column 15)\nin the definition of non-stateful function fail3.">>,
         <<"Cannot reference stateful function Chain.spend (at line 20, column 31)\nin the definition of non-stateful function fail4.">>,
-        <<"Cannot reference stateful function Chain.spend (at line 35, column 53)\nin the definition of non-stateful function fail5.">>,
+        <<"Cannot reference stateful function Chain.spend (at line 35, column 47)\nin the definition of non-stateful function fail5.">>,
-        <<"Cannot pass non-zero value argument 1000 (at line 48, column 55)\nin the definition of non-stateful function fail6.">>,
+        <<"Cannot pass non-zero value argument 1000 (at line 48, column 57)\nin the definition of non-stateful function fail6.">>,
-        <<"Cannot pass non-zero value argument 1000 (at line 49, column 54)\nin the definition of non-stateful function fail7.">>,
+        <<"Cannot pass non-zero value argument 1000 (at line 49, column 56)\nin the definition of non-stateful function fail7.">>,
         <<"Cannot pass non-zero value argument 1000 (at line 52, column 17)\nin the definition of non-stateful function fail8.">>]}
     , {"bad_init_state_access",
        [<<"The init function should return the initial state as its result and cannot write the state,\n"
           "but it calls\n"
           "  - set_state (at line 11, column 5), which calls\n"
-          "  - roundabout (at line 8, column 36), which calls\n"
+          "  - roundabout (at line 8, column 38), which calls\n"
-          "  - put (at line 7, column 37)">>,
+          "  - put (at line 7, column 39)">>,
         <<"The init function should return the initial state as its result and cannot read the state,\n"
           "but it calls\n"
           "  - new_state (at line 12, column 5), which calls\n"
-          "  - state (at line 5, column 27)">>,
+          "  - state (at line 5, column 29)">>,
         <<"The init function should return the initial state as its result and cannot read the state,\n"
           "but it calls\n"
           "  - state (at line 13, column 13)">>]}
+    , {"field_parse_error",
+       [<<"line 6, column 1: In field_parse_error at 5:26:\n"
+          "Cannot use nested fields or keys in record construction: p.x\n">>]}
+    , {"modifier_checks",
+       [<<"The function all_the_things (at line 11, column 3) cannot be both public and private.">>,
+        <<"Namespaces cannot contain entrypoints (at line 3, column 3). Use 'function' instead.">>,
+        <<"The contract Remote (at line 5, column 10) has no entrypoints. Since Sophia version 3.2, public\ncontract functions must be declared with the 'entrypoint' keyword instead of\n'function'.">>,
+        <<"The entrypoint wha (at line 12, column 3) cannot be private. Use 'function' instead.">>,
+        <<"Use 'entrypoint' for declaration of foo (at line 6, column 3):\n  entrypoint foo : () => unit">>,
+        <<"Use 'entrypoint' instead of 'function' for public function foo (at line 10, column 3):\n  entrypoint foo() = ()">>,
+        <<"Use 'entrypoint' instead of 'function' for public function foo (at line 6, column 3):\n  entrypoint foo : () => unit">>]}
+    , {"list_comp_not_a_list",
+      [<<"Cannot unify int\n         and list('a)\nwhen checking rvalue of list comprehension binding at line 2, column 36\n  1 : int\nagainst type \n  list('a)">>
+      ]}
+    , {"list_comp_if_not_bool",
+      [<<"Cannot unify int\n         and bool\nwhen checking the type of the expression at line 2, column 44\n  3 : int\nagainst the expected type\n  bool">>
+      ]}
+    , {"list_comp_bad_shadow",
+      [<<"Cannot unify int\n         and string\nwhen checking the type of the pattern at line 2, column 53\n  x : int\nagainst the expected type\n  string">>
+      ]}
     ].
+
+wants_stdlib(Name) ->
+    lists:member
+      (Name,
+       [ "stdlib_include",
+         "list_comp",
+         "list_comp_not_a_list",
+         "list_comp_if_not_bool",
+         "list_comp_bad_shadow"
+       ]).

test/aeso_parser_tests.erl

@@ -15,7 +15,7 @@ simple_contracts_test_() ->
             ?assertMatch(
                 [{contract, _, {con, _, "Identity"},
                     [{letfun, _, {id, _, "id"}, [{arg, _, {id, _, "x"}, {id, _, "_"}}], {id, _, "_"},
-                        {id, _, "x"}}]}], parse_string(Text)),
+                        {id, _, "x"}}]}], parse_string(Text, [no_implicit_stdlib])),
             ok
        end},
       {"Operator precedence test.",
@@ -62,7 +62,7 @@ simple_contracts_test_() ->
      %% Parse tests of example contracts
      [ {lists:concat(["Parse the ", Contract, " contract."]),
         fun() -> roundtrip_contract(Contract) end}
-        || Contract <- [counter, voting, all_syntax, '05_greeter', aeproof, multi_sig, simple_storage, withdrawal, fundme, dutch_auction] ]
+        || Contract <- [counter, voting, all_syntax, '05_greeter', aeproof, multi_sig, simple_storage, fundme, dutch_auction] ]
     }.
 
 parse_contract(Name) ->
@@ -71,21 +71,23 @@ parse_contract(Name) ->
 roundtrip_contract(Name) ->
     round_trip(aeso_test_utils:read_contract(Name)).
 
-parse_string(Text) ->
+parse_string(Text) -> parse_string(Text, []).
-    case aeso_parser:string(Text) of
+
+parse_string(Text, Opts) ->
+    case aeso_parser:string(Text, Opts) of
         {ok, Contract} -> Contract;
         Err -> error(Err)
     end.
 
 parse_expr(Text) ->
     [{letval, _, _, _, Expr}] =
-        parse_string("let _ = " ++ Text),
+        parse_string("let _ = " ++ Text, [no_implicit_stdlib]),
     Expr.
 
 round_trip(Text) ->
-    Contract  = parse_string(Text),
+    Contract  = parse_string(Text, [no_implicit_stdlib]),
     Text1     = prettypr:format(aeso_pretty:decls(Contract)),
-    Contract1 = parse_string(Text1),
+    Contract1 = parse_string(Text1, [no_implicit_stdlib]),
     NoSrcLoc  = remove_line_numbers(Contract),
     NoSrcLoc1 = remove_line_numbers(Contract1),
     ?assertMatch(NoSrcLoc, diff(NoSrcLoc, NoSrcLoc1)).

test/contracts/__call.aes

@@ -0,0 +1,5 @@
+
+contract Identity =
+  function main (x:int) = x
+
+  function __call() = 12

test/contracts/abort_test.aes

@@ -8,7 +8,7 @@ contract AbortTest =
     { value = v }
 
   // Aborting
-  public function do_abort(v : int, s : string) : () =
+  public function do_abort(v : int, s : string) : unit =
     put_value(v)
     revert_abort(s)
 

test/contracts/abort_test_int.aes

@@ -1,9 +1,9 @@
 contract Interface =
-  function do_abort : (int, string) => ()
+  function do_abort : (int, string) => unit
   function get_value : () => int
-  function put_value : (int) => ()
+  function put_value : (int) => unit
   function get_values : () => list(int)
-  function put_values : (int) => ()
+  function put_values : (int) => unit
 
 contract AbortTestInt =
 

test/contracts/address_chain.aes

@@ -1,33 +1,36 @@
 contract Remote =
-  function main : (int) => ()
+  entrypoint main : (int) => unit
 
 contract AddrChain =
   type o_type = oracle(string, map(string, int))
   type oq_type = oracle_query(string, map(string, int))
 
-  function is_o(a : address) =
+  entrypoint is_o(a : address) =
     Address.is_oracle(a)
 
-  function is_c(a : address) =
+  entrypoint is_c(a : address) =
     Address.is_contract(a)
 
-//   function get_o(a : address) : option(o_type) =
+//   entrypoint get_o(a : address) : option(o_type) =
 //     Address.get_oracle(a)
 
-//   function get_c(a : address) : option(Remote) =
+//   entrypoint get_c(a : address) : option(Remote) =
 //     Address.get_contract(a)
 
-  function check_o(o : o_type) =
+  entrypoint check_o(o : o_type) =
     Oracle.check(o)
 
-  function check_oq(o : o_type, oq : oq_type) =
+  entrypoint check_oq(o : o_type, oq : oq_type) =
     Oracle.check_query(o, oq)
 
-//   function h_to_i(h : hash) : int =
+//   entrypoint h_to_i(h : hash) : int =
 //     Hash.to_int(h)
 
-//   function a_to_i(a : address) : int =
+//   entrypoint a_to_i(a : address) : int =
 //     Address.to_int(a) mod 10 ^ 16
 
-  function c_creator() : address =
+  entrypoint c_creator() : address =
     Contract.creator
+
+  entrypoint is_payable(a : address) : bool =
+    Address.is_payable(a)

test/contracts/address_literals.aes

@@ -1,14 +1,14 @@
 
 contract Remote =
-  function foo : () => ()
+  entrypoint foo : () => unit
 
 contract AddressLiterals =
-  function addr() : address =
+  entrypoint addr() : address =
     ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt
-  function oracle() : oracle(int, bool) =
+  entrypoint oracle() : oracle(int, bool) =
     ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5
-  function query() : oracle_query(int, bool) =
+  entrypoint query() : oracle_query(int, bool) =
     oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY
-  function contr() : Remote =
+  entrypoint contr() : Remote =
     ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ
 

test/contracts/aens.aes

@@ -3,53 +3,53 @@ contract AENSTest =
 
   // Name resolution
 
-  function resolve_word(name : string, key : string) : option(address) =
+  stateful entrypoint resolve_word(name : string, key : string) : option(address) =
     AENS.resolve(name, key)
 
-  function resolve_string(name : string, key : string) : option(string) =
+  stateful entrypoint resolve_string(name : string, key : string) : option(string) =
     AENS.resolve(name, key)
 
   // Transactions
 
-  function preclaim(addr  : address,          // Claim on behalf of this account (can be Contract.address)
+  stateful entrypoint preclaim(addr  : address,     // Claim on behalf of this account (can be Contract.address)
-                    chash : hash) : () =      // Commitment hash
+                             chash : hash) : unit = // Commitment hash
     AENS.preclaim(addr, chash)
 
-  function signedPreclaim(addr  : address,          // Claim on behalf of this account (can be Contract.address)
+  stateful entrypoint signedPreclaim(addr  : address, // Claim on behalf of this account (can be Contract.address)
-                          chash : hash,             // Commitment hash
+                                   chash : hash,             // Commitment hash
-                          sign  : signature) : () = // Signed by addr (if not Contract.address)
+                                   sign  : signature) : unit = // Signed by addr (if not Contract.address)
     AENS.preclaim(addr, chash, signature = sign)
 
-  function claim(addr : address,
+  stateful entrypoint claim(addr : address,
-                 name : string,
+                          name : string,
-                 salt : int) : () =
+                          salt : int) : unit =
     AENS.claim(addr, name, salt)
 
-  function signedClaim(addr : address,
+  stateful entrypoint signedClaim(addr : address,
-                       name : string,
+                                name : string,
-                       salt : int,
+                                salt : int,
-                       sign : signature) : () =
+                                sign : signature) : unit =
     AENS.claim(addr, name, salt, signature = sign)
 
   // TODO: update() -- how to handle pointers?
 
-  function transfer(owner     : address,
+  stateful entrypoint transfer(owner     : address,
-                    new_owner : address,
+                             new_owner : address,
-                    name_hash : hash) : () =
+                             name      : string) : unit =
-    AENS.transfer(owner, new_owner, name_hash)
+    AENS.transfer(owner, new_owner, name)
 
-  function signedTransfer(owner     : address,
+  stateful entrypoint signedTransfer(owner     : address,
-                          new_owner : address,
+                                     new_owner : address,
-                          name_hash : hash,
+                                     name      : string,
-                          sign      : signature) : () =
+                                     sign      : signature) : unit =
-    AENS.transfer(owner, new_owner, name_hash, signature = sign)
+    AENS.transfer(owner, new_owner, name, signature = sign)
 
-  function revoke(owner     : address,
+  stateful entrypoint revoke(owner     : address,
-                  name_hash : hash) : () =
+                           name      : string) : unit =
-    AENS.revoke(owner, name_hash)
+    AENS.revoke(owner, name)
 
-  function signedRevoke(owner     : address,
+  stateful entrypoint signedRevoke(owner     : address,
-                        name_hash : hash,
+                                   name      : string,
-                        sign      : signature) : () =
+                                   sign      : signature) : unit =
-    AENS.revoke(owner, name_hash, signature = sign)
+    AENS.revoke(owner, name, signature = sign)
 

test/contracts/aeproof.aes

@@ -104,10 +104,10 @@ contract AEProof =
                      proofsByOwner : map(address, array(uint)) }
 
     function notarize(document:string, comment:string, ipfsHash:hash) =
-        let _ = require(aetoken.balanceOf(caller()) > 0)
+        let _ = require(aetoken.balanceOf(caller()) > 0, "false")
         let proofHash: uint = calculateHash(document)
         let proof : proof = Map.get_(proofHash, state().proofs)
-        let _ = require(proof.owner == #0)
+        let _ = require(proof.owner == #0, "false")
         let proof' : proof = proof { owner = caller()
                                    , timestamp = block().timestamp
                                    , proofBlock = block().height
@@ -124,12 +124,12 @@ contract AEProof =
     function getProof(document) : proof =
         let calcHash = calculateHash(document)
         let proof = Map.get_(calcHash, state().proofs)
-        let _ = require(proof.owner != #0)
+        let _ = require(proof.owner != #0, "false")
         proof
 
     function getProofByHash(hash: uint) : proof =
         let proof = Map.get_(hash, state().proofs)
-        let _ = require(proof.owner != #0)
+        let _ = require(proof.owner != #0, "false")
         proof
 
 
@@ -141,5 +141,3 @@ contract AEProof =
     function getProofsByOwner(owner: address): array(uint) =
         Map.get(owner, state())
 
-    function require(x : bool) : unit = if(x) () else abort("false")
-

test/contracts/all_syntax.aes

@@ -24,7 +24,7 @@ contract AllSyntax =
         if(valWithType(Map.empty) == None)
           print(42 mod 10 * 5 / 3)
 
-  function funWithType(x : int, y) : (int, list(int)) = (x, 0 :: [y] ++ [])
+  function funWithType(x : int, y) : int * list(int) = (x, 0 :: [y] ++ [])
   function funNoType() =
     let foo = (x, y : bool) =>
                 if (! (y && x =< 0x0b || true)) [x]

test/contracts/bad_address_literals.aes

@@ -1,33 +1,33 @@
 
 contract Remote =
-  function foo : () => ()
+  entrypoint foo : () => unit
 
 contract AddressLiterals =
-  function addr1() : bytes(32) =
+  entrypoint addr1() : bytes(32) =
     ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt
-  function addr2() : Remote =
+  entrypoint addr2() : Remote =
     ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt
-  function addr3() : oracle(int, bool) =
+  entrypoint addr3() : oracle(int, bool) =
     ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt
 
-  function oracle1() : oracle_query(int, bool) =
+  entrypoint oracle1() : oracle_query(int, bool) =
     ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5
-  function oracle2() : bytes(32) =
+  entrypoint oracle2() : bytes(32) =
     ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5
-  function oracle3() : Remote =
+  entrypoint oracle3() : Remote =
     ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5
 
-  function query1() : oracle(int, bool) =
+  entrypoint query1() : oracle(int, bool) =
     oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY
-  function query2() : bytes(32) =
+  entrypoint query2() : bytes(32) =
     oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY
-  function query3() : Remote =
+  entrypoint query3() : Remote =
     oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY
 
-  function contr1() : address =
+  entrypoint contr1() : address =
     ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ
-  function contr2() : oracle(int, bool) =
+  entrypoint contr2() : oracle(int, bool) =
     ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ
-  function contr3() : bytes(32) =
+  entrypoint contr3() : bytes(32) =
     ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ
 

test/contracts/bad_events.aes

@@ -6,20 +6,18 @@ contract Events =
   datatype event =
       Event1(indexed alias_int, indexed int, string)
     | Event2(alias_string, indexed alias_address)
-    | BadEvent1(indexed string, string)
+    | BadEvent1(indexed string)
-    | BadEvent2(indexed int, int)
+    | BadEvent2(indexed alias_string)
-    | BadEvent3(indexed alias_string, string)
-    | BadEvent4(indexed int, alias_address)
 
-  function f1(x : int, y : string) =
+  entrypoint f1(x : int, y : string) =
     Chain.event(Event1(x, x+1, y))
 
-  function f2(s : string) =
+  entrypoint f2(s : string) =
     Chain.event(Event2(s, Call.caller))
 
-  function f3(x : int) =
+  entrypoint f3(x : int) =
     Chain.event(Event1(x, x + 2, Int.to_str(x + 7)))
 
-  function i2s(i : int) = Int.to_str(i)
+  entrypoint i2s(i : int) = Int.to_str(i)
-  function a2s(a : address) = Address.to_str(a)
+  entrypoint a2s(a : address) = Address.to_str(a)
 

test/contracts/bad_events2.aes

@@ -8,17 +8,16 @@ contract Events =
     | Event2(alias_string, indexed alias_address)
     | BadEvent1(string, string)
     | BadEvent2(indexed int, indexed int, indexed int, indexed address)
-    | BadEvent3(address, int)
 
-  function f1(x : int, y : string) =
+  entrypoint f1(x : int, y : string) =
     Chain.event(Event1(x, x+1, y))
 
-  function f2(s : string) =
+  entrypoint f2(s : string) =
     Chain.event(Event2(s, Call.caller))
 
-  function f3(x : int) =
+  entrypoint f3(x : int) =
     Chain.event(Event1(x, x + 2, Int.to_str(x + 7)))
 
-  function i2s(i : int) = Int.to_str(i)
+  entrypoint i2s(i : int) = Int.to_str(i)
-  function a2s(a : address) = Address.to_str(a)
+  entrypoint a2s(a : address) = Address.to_str(a)
 

test/contracts/bad_include_and_ns.aes

@@ -3,4 +3,4 @@ contract Bad =
   namespace Foo =
     function foo() = 42
 
-  function foo() = 43
+  entrypoint foo() = 43

test/contracts/bad_init_state_access.aes

@@ -2,12 +2,12 @@ contract BadInit =
 
   type state = int
 
-  function new_state(n) = state + n
+  entrypoint new_state(n) = state + n
 
-  stateful function roundabout(n) = put(n)
+  stateful entrypoint roundabout(n) = put(n)
-  stateful function set_state(n) = roundabout(n)
+  stateful entrypoint set_state(n) = roundabout(n)
 
-  stateful function init() =
+  stateful entrypoint init() =
     set_state(4)
     new_state(0)
     state + state

test/contracts/basic_auth.aes

@@ -2,18 +2,16 @@
 contract BasicAuth =
   record state = { nonce : int, owner : address }
 
-  function init() = { nonce = 1, owner = Call.caller }
+  entrypoint init() = { nonce = 1, owner = Call.caller }
 
-  stateful function authorize(n : int, s : signature) : bool =
+  stateful entrypoint authorize(n : int, s : signature) : bool =
     require(n >= state.nonce, "Nonce too low")
     require(n =< state.nonce, "Nonce too high")
     put(state{ nonce = n + 1 })
     switch(Auth.tx_hash)
       None          => abort("Not in Auth context")
-      Some(tx_hash) => Crypto.ecverify(to_sign(tx_hash, n), state.owner, s)
+      Some(tx_hash) => Crypto.verify_sig(to_sign(tx_hash, n), state.owner, s)
 
-  function to_sign(h : hash, n : int) =
+  entrypoint to_sign(h : hash, n : int) =
     Crypto.blake2b((h, n))
 
-  private function require(b : bool, err : string) =
-    if(!b) abort(err)

test/contracts/bitcoin_auth.aes

@@ -1,9 +1,9 @@
 contract BitcoinAuth =
-  record state = { nonce : int, owner : bytes(64) }
+  record state = { nonce : int, owner : bytes(20) }
 
-  function init(owner' : bytes(64)) = { nonce = 1, owner = owner' }
+  entrypoint init(owner' : bytes(20)) = { nonce = 1, owner = owner' }
 
-  stateful function authorize(n : int, s : signature) : bool =
+  stateful entrypoint authorize(n : int, s : bytes(65)) : bool =
     require(n >= state.nonce, "Nonce too low")
     require(n =< state.nonce, "Nonce too high")
     put(state{ nonce = n + 1 })
@@ -11,8 +11,6 @@ contract BitcoinAuth =
       None          => abort("Not in Auth context")
       Some(tx_hash) => Crypto.ecverify_secp256k1(to_sign(tx_hash, n), state.owner, s)
 
-  function to_sign(h : hash, n : int) : hash =
+  entrypoint to_sign(h : hash, n : int) : hash =
     Crypto.blake2b((h, n))
 
-  private function require(b : bool, err : string) =
-    if(!b) abort(err)

test/contracts/builtin_bug.aes

@@ -5,8 +5,8 @@ contract BuiltinBug =
 
   record state = {proofs : map(address, list(string))}
 
-  public function init() = {proofs = {}}
+  entrypoint init() = {proofs = {}}
 
-  public stateful function createProof(hash : string) =
+  stateful entrypoint createProof(hash : string) =
     put( state{ proofs[Call.caller] = hash :: state.proofs[Call.caller] } )
 

test/contracts/builtin_map_get_bug.aes

@@ -1,12 +1,8 @@
 contract TestContract =
-  record state = { 
+  record state = {_allowed : map(address, map(address, int))}
-    _allowed          : map(address, map(address, int))}
 
-  public stateful function init() = {
+  entrypoint init() = {_allowed = {}}
-    _allowed = {}}
-
-  public stateful function approve(spender: address, value: int) : bool = 
 
+  stateful entrypoint approve(spender: address, value: int) : bool =
     put(state{_allowed[Call.caller][spender] = value})
-
     true

test/contracts/bytes_equality.aes

@@ -1,18 +1,18 @@
 
 contract BytesEquality =
 
-  function eq16(a : bytes(16), b) = a == b
+  entrypoint eq16(a : bytes(16), b) = a == b
-  function ne16(a : bytes(16), b) = a != b
+  entrypoint ne16(a : bytes(16), b) = a != b
 
-  function eq32(a : bytes(32), b) = a == b
+  entrypoint eq32(a : bytes(32), b) = a == b
-  function ne32(a : bytes(32), b) = a != b
+  entrypoint ne32(a : bytes(32), b) = a != b
 
-  function eq47(a : bytes(47), b) = a == b
+  entrypoint eq47(a : bytes(47), b) = a == b
-  function ne47(a : bytes(47), b) = a != b
+  entrypoint ne47(a : bytes(47), b) = a != b
 
-  function eq64(a : bytes(64), b) = a == b
+  entrypoint eq64(a : bytes(64), b) = a == b
-  function ne64(a : bytes(64), b) = a != b
+  entrypoint ne64(a : bytes(64), b) = a != b
 
-  function eq65(a : bytes(65), b) = a == b
+  entrypoint eq65(a : bytes(65), b) = a == b
-  function ne65(a : bytes(65), b) = a != b
+  entrypoint ne65(a : bytes(65), b) = a != b
 

test/contracts/bytes_to_x.aes

@@ -0,0 +1,8 @@
+
+contract BytesToX =
+
+  entrypoint to_int(b : bytes(42)) : int = Bytes.to_int(b)
+  entrypoint to_str(b : bytes(12)) : string =
+    String.concat(Bytes.to_str(b), Bytes.to_str(#ffff))
+  entrypoint to_str_big(b : bytes(65)) : string =
+    Bytes.to_str(b)

test/contracts/complex_types.aes

@@ -1,78 +1,78 @@
 
 contract Remote =
-  function up_to       : (int)               => list(int)
+  entrypoint up_to       : (int)               => list(int)
-  function sum         : (list(int))         => int
+  entrypoint sum         : (list(int))         => int
-  function some_string : ()                  => string
+  entrypoint some_string : ()                  => string
-  function pair        : (int, string)       => (int, string)
+  entrypoint pair        : (int, string)       => int * string
-  function squares     : (int)               => list((int, int))
+  entrypoint squares     : (int)               => list(int * int)
-  function filter_some : (list(option(int))) => list(int)
+  entrypoint filter_some : (list(option(int))) => list(int)
-  function all_some    : (list(option(int))) => option(list(int))
+  entrypoint all_some    : (list(option(int))) => option(list(int))
 
 contract ComplexTypes =
 
   record state = { worker : Remote }
 
-  function init(worker) = {worker = worker}
+  entrypoint init(worker) = {worker = worker}
 
-  function sum_acc(xs, n) =
+  entrypoint sum_acc(xs, n) =
     switch(xs)
       []      => n
       x :: xs => sum_acc(xs, x + n)
 
   // Sum a list of integers
-  function sum(xs : list(int)) =
+  entrypoint sum(xs : list(int)) =
     sum_acc(xs, 0)
 
-  function up_to_acc(n, xs) =
+  entrypoint up_to_acc(n, xs) =
     switch(n)
       0 => xs
       _ => up_to_acc(n - 1, n :: xs)
 
-  function up_to(n) = up_to_acc(n, [])
+  entrypoint up_to(n) = up_to_acc(n, [])
 
   record answer('a) = {label : string, result : 'a}
 
-  function remote_triangle(worker, n) : answer(int) =
+  entrypoint remote_triangle(worker, n) : answer(int) =
     let xs = worker.up_to(gas = 100000, n)
     let t  = worker.sum(xs)
     { label = "answer:", result = t }
 
-  function remote_list(n) : list(int) =
+  entrypoint remote_list(n) : list(int) =
     state.worker.up_to(n)
 
-  function some_string() = "string"
+  entrypoint some_string() = "string"
 
-  function remote_string() : string =
+  entrypoint remote_string() : string =
     state.worker.some_string()
 
-  function pair(x : int, y : string) = (x, y)
+  entrypoint pair(x : int, y : string) = (x, y)
 
-  function remote_pair(n : int, s : string) : (int, string) =
+  entrypoint remote_pair(n : int, s : string) : int * string =
     state.worker.pair(gas = 10000, n, s)
 
-  function map(f, xs) =
+  entrypoint map(f, xs) =
     switch(xs)
       []      => []
       x :: xs => f(x) :: map(f, xs)
 
-  function squares(n) =
+  entrypoint squares(n) =
     map((i) => (i, i * i), up_to(n))
 
-  function remote_squares(n) : list((int, int)) =
+  entrypoint remote_squares(n) : list(int * int) =
     state.worker.squares(n)
 
   // option types
 
-  function filter_some(xs : list(option(int))) : list(int) =
+  entrypoint filter_some(xs : list(option(int))) : list(int) =
     switch(xs)
       []            => []
       None    :: ys => filter_some(ys)
       Some(x) :: ys => x :: filter_some(ys)
 
-  function remote_filter_some(xs : list(option(int))) : list(int) =
+  entrypoint remote_filter_some(xs : list(option(int))) : list(int) =
     state.worker.filter_some(xs)
 
-  function all_some(xs : list(option(int))) : option(list(int)) =
+  entrypoint all_some(xs : list(option(int))) : option(list(int)) =
     switch(xs)
       []         => Some([])
       None :: ys => None
@@ -81,6 +81,6 @@ contract ComplexTypes =
           Some(xs) => Some(x :: xs)
           None     => None
 
-  function remote_all_some(xs : list(option(int))) : option(list(int)) =
+  entrypoint remote_all_some(xs : list(option(int))) : option(list(int)) =
     state.worker.all_some(gas = 10000, xs)
 

test/contracts/counter.aes

@@ -3,7 +3,7 @@ contract Counter =
 
   record state = { value : int }
 
-  function init(val) = { value = val }
+  entrypoint init(val) = { value = val }
-  function get()     = state.value
+  entrypoint get()     = state.value
-  stateful function tick()    = put(state{ value = state.value + 1 })
+  stateful entrypoint tick()    = put(state{ value = state.value + 1 })
 

test/contracts/cyclic_include.aes

@@ -0,0 +1,4 @@
+include "cyclic_include_forth.aes"
+
+contract CI =
+  entrypoint ci() = Back.back() + Forth.forth()

test/contracts/cyclic_include_back.aes

@@ -0,0 +1,4 @@
+include "cyclic_include_forth.aes"
+
+namespace Back =
+  function back() = 2

test/contracts/cyclic_include_forth.aes

@@ -0,0 +1,4 @@
+include "cyclic_include_back.aes"
+
+namespace Forth =
+  function forth() = 3

test/contracts/deadcode.aes

@@ -1,5 +1,5 @@
 
-namespace List =
+namespace MyList =
 
   function map1(f : 'a => 'b, xs : list('a)) =
     switch(xs)
@@ -13,9 +13,9 @@ namespace List =
 
 contract Deadcode =
 
-  function inc1(xs : list(int)) : list(int) =
+  entrypoint inc1(xs : list(int)) : list(int) =
-    List.map1((x) => x + 1, xs)
+    MyList.map1((x) => x + 1, xs)
 
-  function inc2(xs : list(int)) : list(int) =
+  entrypoint inc2(xs : list(int)) : list(int) =
-    List.map1((x) => x + 1, xs)
+    MyList.map1((x) => x + 1, xs)
 

test/contracts/double_include.aes

@@ -0,0 +1,7 @@
+include "included.aes"
+include "../contracts/included.aes"
+
+contract Include =
+  entrypoint foo() =
+    Included.foo()
+

test/contracts/dutch_auction.aes

@@ -10,16 +10,13 @@ contract DutchAuction =
                    sold         : bool }
 
   // Add to work around current lack of predefined functions
-  private stateful function spend(to, amount) =
+  stateful function spend(to, amount) =
     let total = Contract.balance
     Chain.spend(to, amount)
     total - amount
 
-  private function require(b : bool, err : string) =
-    if(!b) abort(err)
-
   // TTL set by user on posting contract, typically (start - end ) div dec
-  public function init(beneficiary, start, decrease) : state =
+  entrypoint init(beneficiary, start, decrease) : state =
     require(start > 0 && decrease > 0, "bad args")
     { start_amount = start,
       start_height = Chain.block_height,
@@ -30,7 +27,7 @@ contract DutchAuction =
   // -- API
 
   // We are the buyer... interesting case to buy for someone else and keep 10%
-  public stateful function bid() =
+  stateful entrypoint bid() =
     require( !(state.sold), "sold")
     let cost =
       state.start_amount - (Chain.block_height - state.start_height) * state.dec

test/contracts/environment.aes

@@ -1,69 +1,69 @@
 
 // Testing primitives for accessing the block chain environment
 contract Interface =
-  function contract_address : () => address
+  entrypoint contract_address : () => address
-  function call_origin      : () => address
+  entrypoint call_origin      : () => address
-  function call_caller      : () => address
+  entrypoint call_caller      : () => address
-  function call_value       : () => int
+  entrypoint call_value       : () => int
 
 contract Environment =
 
   record state = {remote : Interface}
 
-  function init(remote) = {remote = remote}
+  entrypoint init(remote) = {remote = remote}
 
-  stateful function set_remote(remote) = put({remote = remote})
+  stateful entrypoint set_remote(remote) = put({remote = remote})
 
   // -- Information about the this contract ---
 
   // Address
-  function contract_address() : address = Contract.address
+  entrypoint contract_address() : address = Contract.address
-  function nested_address(who) : address =
+  entrypoint nested_address(who) : address =
     who.contract_address(gas = 1000)
 
   // Balance
-  function contract_balance() : int = Contract.balance
+  entrypoint contract_balance() : int = Contract.balance
 
   // -- Information about the current call ---
 
   // Origin
-  function call_origin()   : address = Call.origin
+  entrypoint call_origin()   : address = Call.origin
-  function nested_origin() : address =
+  entrypoint nested_origin() : address =
     state.remote.call_origin()
 
   // Caller
-  function call_caller() : address = Call.caller
+  entrypoint call_caller() : address = Call.caller
-  function nested_caller() : address =
+  entrypoint nested_caller() : address =
     state.remote.call_caller()
 
   // Value
-  function call_value() : int = Call.value
+  entrypoint call_value() : int = Call.value
-  stateful function nested_value(value : int) : int =
+  stateful entrypoint nested_value(value : int) : int =
     state.remote.call_value(value = value / 2)
 
   // Gas price
-  function call_gas_price() : int = Call.gas_price
+  entrypoint call_gas_price() : int = Call.gas_price
 
   // -- Information about the chain ---
 
   // Account balances
-  function get_balance(acct : address) : int = Chain.balance(acct)
+  entrypoint get_balance(acct : address) : int = Chain.balance(acct)
 
   // Block hash
-  function block_hash(height : int) : int = Chain.block_hash(height)
+  entrypoint block_hash(height : int) : option(hash) = Chain.block_hash(height)
 
   // Coinbase
-  function coinbase() : address = Chain.coinbase
+  entrypoint coinbase() : address = Chain.coinbase
 
   // Block timestamp
-  function timestamp() : int = Chain.timestamp
+  entrypoint timestamp() : int = Chain.timestamp
 
   // Block height
-  function block_height() : int = Chain.block_height
+  entrypoint block_height() : int = Chain.block_height
 
   // Difficulty
-  function difficulty() : int = Chain.difficulty
+  entrypoint difficulty() : int = Chain.difficulty
 
   // Gas limit
-  function gas_limit() : int = Chain.gas_limit
+  entrypoint gas_limit() : int = Chain.gas_limit
 

test/contracts/erc20_token.aes

@@ -77,9 +77,6 @@ contract ERC20Token =
     put( state{approval_log = e :: state.approval_log })
     e
 
-  private function require(b : bool, err : string) =
-    if(!b) abort(err)
-
   private function sub(_a : int, _b : int) : int =
     require(_b =< _a, "Error")
     _a - _b

test/contracts/events.aes

@@ -1,22 +1,40 @@
+contract Remote =
+  entrypoint dummy : () => unit
+
 contract Events =
-  type alias_int = int
-  type alias_address = address
-  type alias_string = string
 
-  datatype event =
+  // Valid index types
-      Event1(indexed alias_int, indexed int, string)
+  type ix1 = int
-    | Event2(alias_string, indexed alias_address)
+  type ix2 = bool
-    // | BadEvent1(indexed string, string)
+  type ix3 = bits
-    // | BadEvent2(indexed int, int)
+  type ix4 = bytes(12)
+  type ix5 = hash // bytes(32)
+  type ix6 = address
+  type ix7 = Remote
+  type ix8 = oracle(int, int)
+  type ix9 = oracle_query(int, int)
 
-  function f1(x : int, y : string) =
+  // Valid payload types
-    Chain.event(Event1(x, x+1, y))
+  type data1 = string
+  type data2 = signature  // bytes(64)
+  type data3 = bytes(65)
 
-  function f2(s : string) =
+  datatype event
-    Chain.event(Event2(s, Call.caller))
+    = Nodata0
+    | Nodata1(ix1)
+    | Nodata2(ix2, ix3)
+    | Nodata3(ix4, ix5, ix6)
+    | Data0(data1)
+    | Data1(data2, ix7)
+    | Data2(ix8, data3, ix9)
+    | Data3(ix1, ix2, ix5, data1)
 
-  function f3(x : int) =
+  entrypoint nodata0()                   = Chain.event(Nodata0)
-    Chain.event(Event1(x, x + 2, Int.to_str(x + 7)))
+  entrypoint nodata1(ix1)                = Chain.event(Nodata1(ix1))
+  entrypoint nodata2(ix2, ix3)           = Chain.event(Nodata2(ix2, ix3))
+  entrypoint nodata3(ix4, ix5, ix6)      = Chain.event(Nodata3(ix4, ix5, ix6))
+  entrypoint data0(data1)                = Chain.event(Data0(data1))
+  entrypoint data1(data2, ix7)           = Chain.event(Data1(data2, ix7))
+  entrypoint data2(ix8, data3, ix9)      = Chain.event(Data2(ix8, data3, ix9))
+  entrypoint data3(ix1, ix2, ix5, data1) = Chain.event(Data3(ix1, ix2, ix5, data1))
 
-  function i2s(i : int) = Int.to_str(i)
-  function a2s(a : address) = Address.to_str(a)

test/contracts/factorial.aes

@@ -1,17 +1,17 @@
 // An implementation of the factorial function where each recursive
 // call is to another contract. Not the cheapest way to compute factorial.
 contract FactorialServer =
-  function fac : (int) => int
+  entrypoint fac : (int) => int
 
 contract Factorial =
 
   record state = {worker : FactorialServer}
 
-  function init(worker) = {worker = worker}
+  entrypoint init(worker) = {worker = worker}
 
-  stateful function set_worker(worker) = put(state{worker = worker})
+  stateful entrypoint set_worker(worker) = put(state{worker = worker})
 
-  function fac(x : int) : int =
+  entrypoint fac(x : int) : int =
     if(x == 0) 1
     else x * state.worker.fac(x - 1)
 

test/contracts/field_parse_error.aes

@@ -0,0 +1,5 @@
+
+contract Fail =
+  record pt = {x : int, y : int}
+  record r  = {p : pt}
+  function fail() = {p.x = 0, p.y = 0}

test/contracts/funargs.aes

@@ -0,0 +1,47 @@
+
+contract FunctionArguments =
+
+  entrypoint sum(n : int, m: int) =
+    n + m
+
+  entrypoint append(xs : list(string)) =
+     switch(xs)
+      []      => ""
+      y :: ys => String.concat(y, append(ys))
+
+  entrypoint menot(b) =
+    !b
+
+  entrypoint bitsum(b : bits) =
+    Bits.sum(b)
+
+  record answer('a) = {label : string, result : 'a}
+
+  entrypoint read(a : answer(int)) =
+     a.result
+
+  entrypoint sjutton(b : bytes(17)) =
+     b
+
+  entrypoint sextiosju(b : bytes(67)) =
+     b
+
+  entrypoint trettiotva(b : bytes(32)) =
+     b
+
+  entrypoint find_oracle(o : oracle(int, bool)) =
+     true
+
+  entrypoint find_query(q : oracle_query(int, bool)) =
+     true
+
+  datatype colour() = Green | Yellow | Red | Pantone(int)
+
+  entrypoint traffic_light(c : colour) =
+     Red
+
+  entrypoint tuples(t : unit) =
+     t
+
+  entrypoint due(t : Chain.ttl) =
+     true

test/contracts/functions.aes

@@ -1,15 +1,15 @@
 contract Functions =
-  private function curry(f : ('a, 'b) => 'c) =
+  function curry(f : ('a, 'b) => 'c) =
     (x) => (y) => f(x, y)
-  private function map(f : 'a => 'b, xs : list('a)) =
+  function map(f : 'a => 'b, xs : list('a)) =
     switch(xs)
       [] => []
       x :: xs => f(x) :: map(f, xs)
-  private function map'() = map
+  function map'() = map
-  private function plus(x, y) = x + y
+  function plus(x, y) = x + y
-  function test1(xs : list(int)) = map(curry(plus)(5), xs)
+  entrypoint test1(xs : list(int)) = map(curry(plus)(5), xs)
-  function test2(xs : list(int)) = map'()(((x) => (y) => ((x, y) => x + y)(x, y))(100), xs)
+  entrypoint test2(xs : list(int)) = map'()(((x) => (y) => ((x, y) => x + y)(x, y))(100), xs)
-  function test3(xs : list(int)) =
+  entrypoint test3(xs : list(int)) =
     let m(f, xs) = map(f, xs)
     m((x) => x + 1, xs)
 

test/contracts/fundme.aes

@@ -12,23 +12,20 @@ contract FundMe =
                    deadline      : int,
                    goal          : int }
 
-  private function require(b : bool, err : string) =
+  stateful function spend(args : spend_args) =
-    if(!b) abort(err)
-
-  private stateful function spend(args : spend_args) =
     Chain.spend(args.recipient, args.amount)
 
-  public function init(beneficiary, deadline, goal) : state =
+  entrypoint init(beneficiary, deadline, goal) : state =
     { contributions = {},
       beneficiary   = beneficiary,
       deadline      = deadline,
       total         = 0,
       goal          = goal }
 
-  private function is_contributor(addr) =
+  function is_contributor(addr) =
     Map.member(addr, state.contributions)
 
-  public stateful function contribute() =
+  stateful entrypoint contribute() =
     if(Chain.block_height >= state.deadline)
       spend({ recipient = Call.caller, amount = Call.value }) // Refund money
       false
@@ -39,7 +36,7 @@ contract FundMe =
                  total @ tot = tot + Call.value })
       true
 
-  public stateful function withdraw() =
+  stateful entrypoint withdraw() =
     if(Chain.block_height < state.deadline)
       abort("Cannot withdraw before deadline")
     if(Call.caller == state.beneficiary)
@@ -49,13 +46,13 @@ contract FundMe =
     else
       abort("Not a contributor or beneficiary")
 
-  private stateful function withdraw_beneficiary() =
+  stateful function withdraw_beneficiary() =
     require(state.total >= state.goal, "Project was not funded")
     spend({recipient = state.beneficiary,
            amount    = Contract.balance })
     put(state{ beneficiary = ak_11111111111111111111111111111111273Yts })
 
-  private stateful function withdraw_contributor() =
+  stateful function withdraw_contributor() =
     if(state.total >= state.goal)
       abort("Project was funded")
     let to = Call.caller

test/contracts/identity.aes

@@ -1,3 +1,3 @@
 
 contract Identity =
-  function main (x:int) = x
+  entrypoint main (x:int) = x

test/contracts/include.aes

@@ -2,8 +2,8 @@ include "included.aes"
 include "../contracts/included2.aes"
 
 contract Include =
-  function foo() =
+  entrypoint foo() =
     Included.foo() < Included2a.bar()
 
-  function bar() =
+  entrypoint bar() =
     Included2b.foo() > Included.foo()

test/contracts/init_type_error.aes

@@ -3,6 +3,6 @@ contract InitTypeError =
 
   type state = map(int, int)
 
-  // Check that the compiler catches ill-typed init function
+  // Check that the compiler catches ill-typed init entrypoint
-  function init() = "not the right type!"
+  entrypoint init() = "not the right type!"
 

test/contracts/list_comp.aes

@@ -0,0 +1,23 @@
+contract ListComp =
+
+    entrypoint sample1() = [1,2,3]
+    entrypoint sample2() = [4,5]
+
+    entrypoint l1() = [x | x <- sample1()]
+    entrypoint l1_true() = [1,2,3]
+
+    entrypoint l2() = [x + y | x <- sample1(), y <- sample2()]
+    entrypoint l2_true() = [5,6,6,7,7,8]
+
+    entrypoint l3() = [x ++ y | x <- [[":)"] | x <- [1,2]]
+                              , y <- [[":("]]]  
+    entrypoint l3_true() = [[":)", ":("], [":)", ":("]]
+
+    entrypoint l4() = [(a, b, c) | let is_pit(a, b, c) = a*a + b*b == c*c
+                                 , let base = [1,2,3,4,5,6,7,8,9,10]
+                                 , a <- base
+                                 , b <- base, if (b >= a)
+                                 , c <- base, if (c >= b)
+                                 , if (is_pit(a, b, c))
+                                 ]
+    entrypoint l4_true() = [(3, 4, 5), (6, 8, 10)]

test/contracts/list_comp_bad_shadow.aes

@@ -0,0 +1,2 @@
+contract BadComp =
+  entrypoint failing() = [x + 1 | x <- [1,2,3], let x = "XD"]

test/contracts/list_comp_if_not_bool.aes

@@ -0,0 +1,2 @@
+contract BadComp =
+  entrypoint failing() = [x | x <- [], if (3)] 

test/contracts/list_comp_not_a_list.aes

@@ -0,0 +1,2 @@
+contract ListCompBad =
+  entrypoint failing() = [x | x <- 1]

test/contracts/manual_stdlib_include.aes

@@ -0,0 +1,7 @@
+// This contract should be compiled with no_implicit_stdlib option.
+// It should include Lists.aes implicitly however, because Option.aes depends on it.
+include "Option.aes"
+
+contract Test =
+  entrypoint i_should_build() =
+    List.is_empty(Option.to_list(None))

test/contracts/maps.aes

@@ -4,97 +4,97 @@ contract Maps =
   record state = { map_i : map(int, pt),
                    map_s : map(string, pt) }
 
-  function init() = { map_i = {}, map_s = {} }
+  entrypoint init() = { map_i = {}, map_s = {} }
 
-  function get_state() = state
+  entrypoint get_state() = state
 
   // {[k] = v}
-  function map_i() =
+  entrypoint map_i() =
     { [1] = {x = 1, y = 2},
       [2] = {x = 3, y = 4},
       [3] = {x = 5, y = 6} }
-  function map_s() =
+  entrypoint map_s() =
     { ["one"]   = {x = 1, y = 2},
       ["two"]   = {x = 3, y = 4},
       ["three"] = {x = 5, y = 6} }
-  stateful function map_state_i() = put(state{ map_i = map_i() })
+  stateful entrypoint map_state_i() = put(state{ map_i = map_i() })
-  stateful function map_state_s() = put(state{ map_s = map_s() })
+  stateful entrypoint map_state_s() = put(state{ map_s = map_s() })
 
   // m[k]
-  function get_i(k, m : map(int,    pt)) = m[k]
+  entrypoint get_i(k, m : map(int,    pt)) = m[k]
-  function get_s(k, m : map(string, pt)) = m[k]
+  entrypoint get_s(k, m : map(string, pt)) = m[k]
-  function get_state_i(k) = get_i(k, state.map_i)
+  entrypoint get_state_i(k) = get_i(k, state.map_i)
-  function get_state_s(k) = get_s(k, state.map_s)
+  entrypoint get_state_s(k) = get_s(k, state.map_s)
 
   // m[k = v]
-  function get_def_i(k, v, m : map(int,    pt)) = m[k = v]
+  entrypoint get_def_i(k, v, m : map(int,    pt)) = m[k = v]
-  function get_def_s(k, v, m : map(string, pt)) = m[k = v]
+  entrypoint get_def_s(k, v, m : map(string, pt)) = m[k = v]
-  function get_def_state_i(k, v) = get_def_i(k, v, state.map_i)
+  entrypoint get_def_state_i(k, v) = get_def_i(k, v, state.map_i)
-  function get_def_state_s(k, v) = get_def_s(k, v, state.map_s)
+  entrypoint get_def_state_s(k, v) = get_def_s(k, v, state.map_s)
 
   // m{[k] = v}
-  function set_i(k, p, m : map(int,    pt)) = m{ [k] = p }
+  entrypoint set_i(k, p, m : map(int,    pt)) = m{ [k] = p }
-  function set_s(k, p, m : map(string, pt)) = m{ [k] = p }
+  entrypoint set_s(k, p, m : map(string, pt)) = m{ [k] = p }
-  stateful function set_state_i(k, p) = put(state{ map_i = set_i(k, p, state.map_i) })
+  stateful entrypoint set_state_i(k, p) = put(state{ map_i = set_i(k, p, state.map_i) })
-  stateful function set_state_s(k, p) = put(state{ map_s = set_s(k, p, state.map_s) })
+  stateful entrypoint set_state_s(k, p) = put(state{ map_s = set_s(k, p, state.map_s) })
 
   // m{f[k].x = v}
-  function setx_i(k, x, m : map(int,    pt)) = m{ [k].x = x }
+  entrypoint setx_i(k, x, m : map(int,    pt)) = m{ [k].x = x }
-  function setx_s(k, x, m : map(string, pt)) = m{ [k].x = x }
+  entrypoint setx_s(k, x, m : map(string, pt)) = m{ [k].x = x }
-  stateful function setx_state_i(k, x) = put(state{ map_i[k].x = x })
+  stateful entrypoint setx_state_i(k, x) = put(state{ map_i[k].x = x })
-  stateful function setx_state_s(k, x) = put(state{ map_s[k].x = x })
+  stateful entrypoint setx_state_s(k, x) = put(state{ map_s[k].x = x })
 
   // m{[k] @ x = v }
-  function addx_i(k, d, m : map(int,    pt)) = m{ [k].x @ x = x + d }
+  entrypoint addx_i(k, d, m : map(int,    pt)) = m{ [k].x @ x = x + d }
-  function addx_s(k, d, m : map(string, pt)) = m{ [k].x @ x = x + d }
+  entrypoint addx_s(k, d, m : map(string, pt)) = m{ [k].x @ x = x + d }
-  stateful function addx_state_i(k, d) = put(state{ map_i[k].x @ x = x + d })
+  stateful entrypoint addx_state_i(k, d) = put(state{ map_i[k].x @ x = x + d })
-  stateful function addx_state_s(k, d) = put(state{ map_s[k].x @ x = x + d })
+  stateful entrypoint addx_state_s(k, d) = put(state{ map_s[k].x @ x = x + d })
 
   // m{[k = def] @ x = v }
-  function addx_def_i(k, v, d, m : map(int,    pt)) = m{ [k = v].x @ x = x + d }
+  entrypoint addx_def_i(k, v, d, m : map(int,    pt)) = m{ [k = v].x @ x = x + d }
-  function addx_def_s(k, v, d, m : map(string, pt)) = m{ [k = v].x @ x = x + d }
+  entrypoint addx_def_s(k, v, d, m : map(string, pt)) = m{ [k = v].x @ x = x + d }
 
   // Map.member
-  function member_i(k, m : map(int,    pt)) = Map.member(k, m)
+  entrypoint member_i(k, m : map(int,    pt)) = Map.member(k, m)
-  function member_s(k, m : map(string, pt)) = Map.member(k, m)
+  entrypoint member_s(k, m : map(string, pt)) = Map.member(k, m)
-  function member_state_i(k) = member_i(k, state.map_i)
+  entrypoint member_state_i(k) = member_i(k, state.map_i)
-  function member_state_s(k) = member_s(k, state.map_s)
+  entrypoint member_state_s(k) = member_s(k, state.map_s)
 
   // Map.lookup
-  function lookup_i(k, m : map(int,    pt)) = Map.lookup(k, m)
+  entrypoint lookup_i(k, m : map(int,    pt)) = Map.lookup(k, m)
-  function lookup_s(k, m : map(string, pt)) = Map.lookup(k, m)
+  entrypoint lookup_s(k, m : map(string, pt)) = Map.lookup(k, m)
-  function lookup_state_i(k) = lookup_i(k, state.map_i)
+  entrypoint lookup_state_i(k) = lookup_i(k, state.map_i)
-  function lookup_state_s(k) = lookup_s(k, state.map_s)
+  entrypoint lookup_state_s(k) = lookup_s(k, state.map_s)
 
   // Map.lookup_default
-  function lookup_def_i(k, m : map(int,    pt), def : pt) =
+  entrypoint lookup_def_i(k, m : map(int,    pt), def : pt) =
     Map.lookup_default(k, m, def)
-  function lookup_def_s(k, m : map(string, pt), def : pt) =
+  entrypoint lookup_def_s(k, m : map(string, pt), def : pt) =
     Map.lookup_default(k, m, def)
-  function lookup_def_state_i(k, def) = lookup_def_i(k, state.map_i, def)
+  entrypoint lookup_def_state_i(k, def) = lookup_def_i(k, state.map_i, def)
-  function lookup_def_state_s(k, def) = lookup_def_s(k, state.map_s, def)
+  entrypoint lookup_def_state_s(k, def) = lookup_def_s(k, state.map_s, def)
 
   // Map.delete
-  function delete_i(k, m : map(int,    pt)) = Map.delete(k, m)
+  entrypoint delete_i(k, m : map(int,    pt)) = Map.delete(k, m)
-  function delete_s(k, m : map(string, pt)) = Map.delete(k, m)
+  entrypoint delete_s(k, m : map(string, pt)) = Map.delete(k, m)
-  stateful function delete_state_i(k) = put(state{ map_i = delete_i(k, state.map_i) })
+  stateful entrypoint delete_state_i(k) = put(state{ map_i = delete_i(k, state.map_i) })
-  stateful function delete_state_s(k) = put(state{ map_s = delete_s(k, state.map_s) })
+  stateful entrypoint delete_state_s(k) = put(state{ map_s = delete_s(k, state.map_s) })
 
   // Map.size
-  function size_i(m : map(int,    pt)) = Map.size(m)
+  entrypoint size_i(m : map(int,    pt)) = Map.size(m)
-  function size_s(m : map(string, pt)) = Map.size(m)
+  entrypoint size_s(m : map(string, pt)) = Map.size(m)
-  function size_state_i() = size_i(state.map_i)
+  entrypoint size_state_i() = size_i(state.map_i)
-  function size_state_s() = size_s(state.map_s)
+  entrypoint size_state_s() = size_s(state.map_s)
 
   // Map.to_list
-  function tolist_i(m : map(int,    pt)) = Map.to_list(m)
+  entrypoint tolist_i(m : map(int,    pt)) = Map.to_list(m)
-  function tolist_s(m : map(string, pt)) = Map.to_list(m)
+  entrypoint tolist_s(m : map(string, pt)) = Map.to_list(m)
-  function tolist_state_i() = tolist_i(state.map_i)
+  entrypoint tolist_state_i() = tolist_i(state.map_i)
-  function tolist_state_s() = tolist_s(state.map_s)
+  entrypoint tolist_state_s() = tolist_s(state.map_s)
 
   // Map.from_list
-  function fromlist_i(xs : list((int,    pt))) = Map.from_list(xs)
+  entrypoint fromlist_i(xs : list(int    * pt)) = Map.from_list(xs)
-  function fromlist_s(xs : list((string, pt))) = Map.from_list(xs)
+  entrypoint fromlist_s(xs : list(string * pt)) = Map.from_list(xs)
-  stateful function fromlist_state_i(xs) = put(state{ map_i = fromlist_i(xs) })
+  stateful entrypoint fromlist_state_i(xs) = put(state{ map_i = fromlist_i(xs) })
-  stateful function fromlist_state_s(xs) = put(state{ map_s = fromlist_s(xs) })
+  stateful entrypoint fromlist_state_s(xs) = put(state{ map_s = fromlist_s(xs) })
 

test/contracts/missing_fields_in_record_expression.aes

@@ -3,6 +3,6 @@ contract MissingFieldsInRecordExpr =
   record r('a) = {x : int, y : string, z : 'a}
   type alias('a) = r('a)
 
-  function fail1()               = { x = 0 }
+  entrypoint fail1()               = { x = 0 }
-  function fail2(z : 'a) : r('a) = { y = "string", z = z }
+  entrypoint fail2(z : 'a) : r('a) = { y = "string", z = z }
-  function fail3() : alias(int)  = { x = 0, z = 1 }
+  entrypoint fail3() : alias(int)  = { x = 0, z = 1 }

test/contracts/missing_state_type.aes

@@ -2,5 +2,5 @@
 contract MissingStateType =
 
   // Check that we get a type error also for implicit state
-  function init() = "should be ()"
+  entrypoint init() = "should be ()"
 

test/contracts/modifier_checks.aes

@@ -0,0 +1,12 @@
+
+namespace Lib =
+  entrypoint foo() = ()
+
+contract Remote =
+  public function foo : () => unit
+  function bla() = ()
+
+contract Contract =
+  public function foo() = ()
+  public private stateful function all_the_things() = ()
+  private entrypoint wha() = ()

test/contracts/multi_sig.aes

@@ -28,8 +28,8 @@ contract MultiSig =
       let n = length(owners) + 1
       { nRequired  = nRequired,
         nOwners    = n,
-        owners     = Map.from_list(List.zip([1..n], caller() :: owners)),
+        owners     = Map.from_list(MyList.zip([1..n], caller() :: owners)),
-        ownerIndex = Map.from_list(List.zip(caller() :: owners, [1..n])) }
+        ownerIndex = Map.from_list(MyList.zip(caller() :: owners, [1..n])) }
 
     function lookup(map, key) =
       switch(Map.get(key, map))

test/contracts/name_clash.aes

@@ -1,16 +1,17 @@
 
 contract NameClash =
 
-  function double_proto : () => int
+  entrypoint double_proto : () => int
-  function double_proto : () => int
+  entrypoint double_proto : () => int
 
-  function proto_and_def : int => int
+  entrypoint proto_and_def : int => int
-  function proto_and_def(n) = n + 1
+  entrypoint proto_and_def(n) = n + 1
 
-  function double_def(x) = x
+  entrypoint double_def(x) = x
-  function double_def(y) = 0
+  entrypoint double_def(y) = 0
 
-  // abort, put and state are builtin
+  // abort, require, put and state are builtin
-  function abort() : int = 0
+  entrypoint abort() : int = 0
-  function put(x) = x
+  entrypoint require(b, err) = if(b) abort(err)
-  function state(x, y) = x + y
+  entrypoint put(x) = x
+  entrypoint state(x, y) = x + y

test/contracts/namespace_bug.aes

@@ -0,0 +1,18 @@
+
+namespace Foo =
+
+  record bla = {x : int, y : bool}
+
+  function bar() : Foo.bla = {x = 17, y = true}
+
+contract Bug =
+
+  // Crashed the type checker
+  entrypoint foo() = Foo.bar()
+
+  // Also crashed the type checker
+  type t = Foo.bla
+
+  entrypoint test() =
+    let x : t = Foo.bar()
+    x

test/contracts/namespace_clash.aes

@@ -2,4 +2,4 @@
 // You can't shadow existing contracts or namespaces.
 
 contract Call =
-  function whatever() = ()
+  entrypoint whatever() = ()

test/contracts/nodeadcode.aes

@@ -1,5 +1,5 @@
 
-namespace List =
+namespace MyList =
 
   function map1(f : 'a => 'b, xs : list('a)) =
     switch(xs)
@@ -13,9 +13,9 @@ namespace List =
 
 contract Deadcode =
 
-  function inc1(xs : list(int)) : list(int) =
+  entrypoint inc1(xs : list(int)) : list(int) =
-    List.map1((x) => x + 1, xs)
+    MyList.map1((x) => x + 1, xs)
 
-  function inc2(xs : list(int)) : list(int) =
+  entrypoint inc2(xs : list(int)) : list(int) =
-    List.map2((x) => x + 1, xs)
+    MyList.map2((x) => x + 1, xs)
 

test/contracts/oracles.aes

@@ -9,31 +9,31 @@ contract Oracles =
   type oracle_id = oracle(query_t, answer_t)
   type query_id  = oracle_query(query_t, answer_t)
 
-  stateful function registerOracle(acct : address,
+  stateful entrypoint registerOracle(acct : address,
                           qfee : fee,
                           ttl  : ttl) : oracle_id =
      Oracle.register(acct, qfee, ttl)
 
-  stateful function registerIntIntOracle(acct : address,
+  stateful entrypoint registerIntIntOracle(acct : address,
                                 qfee : fee,
                                 ttl  : ttl) : oracle(int, int) =
      Oracle.register(acct, qfee, ttl)
 
-  stateful function registerStringStringOracle(acct : address,
+  stateful entrypoint registerStringStringOracle(acct : address,
                                       qfee : fee,
                                       ttl  : ttl) : oracle(string, string) =
      Oracle.register(acct, qfee, ttl)
 
-  stateful function signedRegisterOracle(acct : address,
+  stateful entrypoint signedRegisterOracle(acct : address,
                                 sign : signature,
                                 qfee : fee,
                                 ttl  : ttl) : oracle_id =
      Oracle.register(acct, qfee, ttl, signature = sign)
 
-  function queryFee(o : oracle_id) : fee =
+  entrypoint queryFee(o : oracle_id) : fee =
     Oracle.query_fee(o)
 
-  stateful function createQuery(o    : oracle_id,
+  stateful entrypoint createQuery(o    : oracle_id,
                        q    : query_t,
                        qfee : fee,
                        qttl : ttl,
@@ -42,7 +42,7 @@ contract Oracles =
     Oracle.query(o, q, qfee, qttl, rttl)
 
   // Do not use in production!
-  stateful function unsafeCreateQuery(o    : oracle_id,
+  stateful entrypoint unsafeCreateQuery(o    : oracle_id,
                        q    : query_t,
                        qfee : fee,
                        qttl : ttl,
@@ -50,7 +50,7 @@ contract Oracles =
     Oracle.query(o, q, qfee, qttl, rttl)
 
   // Do not use in production!
-  stateful function unsafeCreateQueryThenErr(o    : oracle_id,
+  stateful entrypoint unsafeCreateQueryThenErr(o    : oracle_id,
                        q    : query_t,
                        qfee : fee,
                        qttl : ttl,
@@ -59,54 +59,52 @@ contract Oracles =
     require(qfee >= 100000000000000000, "causing a late error")
     res
 
-  stateful function extendOracle(o    : oracle_id,
+  stateful entrypoint extendOracle(o    : oracle_id,
-                        ttl  : ttl) : () =
+                        ttl  : ttl) : unit =
     Oracle.extend(o, ttl)
 
-  stateful function signedExtendOracle(o    : oracle_id,
+  stateful entrypoint signedExtendOracle(o    : oracle_id,
                               sign : signature,   // Signed oracle address
-                              ttl  : ttl) : () =
+                              ttl  : ttl) : unit =
     Oracle.extend(o, signature = sign, ttl)
 
-  stateful function respond(o    : oracle_id,
+  stateful entrypoint respond(o    : oracle_id,
                    q    : query_id,
-                   r    : answer_t) : () =
+                   r    : answer_t) : unit =
     Oracle.respond(o, q, r)
 
-  stateful function signedRespond(o    : oracle_id,
+  stateful entrypoint signedRespond(o    : oracle_id,
                          q    : query_id,
                          sign : signature,
-                         r    : answer_t) : () =
+                         r    : answer_t) : unit =
     Oracle.respond(o, q, signature = sign, r)
 
-  function getQuestion(o : oracle_id,
+  entrypoint getQuestion(o : oracle_id,
                        q : query_id) : query_t =
     Oracle.get_question(o, q)
 
-  function hasAnswer(o : oracle_id,
+  entrypoint hasAnswer(o : oracle_id,
                      q : query_id) =
     switch(Oracle.get_answer(o, q))
       None    => false
       Some(_) => true
 
-  function getAnswer(o : oracle_id,
+  entrypoint getAnswer(o : oracle_id,
                      q : query_id) : option(answer_t) =
     Oracle.get_answer(o, q)
 
   datatype complexQuestion = Why(int) | How(string)
   datatype complexAnswer   = NoAnswer | Answer(complexQuestion, string, int)
 
-  stateful function complexOracle(question) =
+  stateful entrypoint complexOracle(question) =
     let o = Oracle.register(Contract.address, 0, FixedTTL(1000)) : oracle(complexQuestion, complexAnswer)
     let q = Oracle.query(o, question, 0, RelativeTTL(100), RelativeTTL(100))
     Oracle.respond(o, q, Answer(question, "magic", 1337))
     Oracle.get_answer(o, q)
 
-  stateful function signedComplexOracle(question, sig) =
+  stateful entrypoint signedComplexOracle(question, sig) =
     let o = Oracle.register(signature = sig, Contract.address, 0, FixedTTL(1000)) : oracle(complexQuestion, complexAnswer)
     let q = Oracle.query(o, question, 0, RelativeTTL(100), RelativeTTL(100))
     Oracle.respond(o, q, Answer(question, "magic", 1337), signature = sig)
     Oracle.get_answer(o, q)
 
-  private function require(b : bool, err : string) =
-    if(!b) abort(err)

test/contracts/oracles_gas.aes

@@ -20,5 +20,3 @@ contract OraclesGas =
     Oracle.respond(o, q, answer)
     ()
 
-  private function require(b : bool, err : string) =
-    if(!b) abort(err)

test/contracts/oracles_no_vm.aes

@@ -21,7 +21,7 @@ contract Oracles =
   function respond(o    : oracle_id,
                    q    : query_id,
                    sign : signature,
-                   r    : answer_t) : () =
+                   r    : answer_t) : unit =
     Oracle.respond(o, q, signature = sign, r)
 
 
@@ -33,5 +33,3 @@ contract Oracles =
                      q : query_id) : option(answer_t) =
     Oracle.get_answer(o, q)
 
-  private function require(b : bool, err : string) =
-    if(!b) abort(err)

test/contracts/payable.aes

@@ -0,0 +1,3 @@
+payable contract Test =
+  payable entrypoint foo(x : int) = ()
+  function bar() = 42

test/contracts/reason/voting.re

@@ -47,7 +47,7 @@ module Voting : Voting = {
   let init(proposalNames: args): state =
     { chairPerson: caller(),
       voters:      AddrMap.empty,
-      proposals:   List.map((name) => {name: name, voteCount: 0}, proposalNames)
+      proposals:   MyList.map((name) => {name: name, voteCount: 0}, proposalNames)
     };
 
   /* Boilerplate */
@@ -73,7 +73,7 @@ module Voting : Voting = {
   };
 
   let addVote(candidate, weight) = {
-    let proposal = List.nth(state().proposals, candidate);
+    let proposal = MyList.nth(state().proposals, candidate);
     proposal.voteCount = proposal.voteCount + weight;
   };
 
@@ -121,6 +121,6 @@ module Voting : Voting = {
 
   /* const */
   let currentTally() =
-    List.map((p) => (p.name, p.voteCount), state().proposals);
+    MyList.map((p) => (p.name, p.voteCount), state().proposals);
 
 }

test/contracts/reason/voting_test.re

@@ -13,7 +13,7 @@ open Voting;
 
 let print_tally() = {
   let tally = call(other, () => currentTally());
-  List.map(((name, count)) => Printf.printf("%s: %d\n", name, count), tally);
+  MyList.map(((name, count)) => Printf.printf("%s: %d\n", name, count), tally);
   let winner = call(other, () => winnerName());
   Printf.printf("Winner: %s\n", winner);
 };

test/contracts/remote_call.aes

@@ -1,27 +1,27 @@
 
 contract Remote1 =
-  function main : (int) => int
+  entrypoint main : (int) => int
 
 contract Remote2 =
-  function call : (Remote1, int) => int
+  entrypoint call : (Remote1, int) => int
 
 contract Remote3 =
-  function get : () => int
+  entrypoint get : () => int
-  function tick : () => ()
+  entrypoint tick : () => unit
 
 contract RemoteCall =
 
-    stateful function call(r : Remote1, x : int) : int =
+    stateful entrypoint call(r : Remote1, x : int) : int =
         r.main(gas = 10000, value = 10, x)
 
-    function staged_call(r1 : Remote1, r2 : Remote2, x : int) =
+    entrypoint staged_call(r1 : Remote1, r2 : Remote2, x : int) =
         r2.call(r1, x)
 
-    function increment(r3 : Remote3) =
+    entrypoint increment(r3 : Remote3) =
         r3.tick()
 
-    function get(r3 : Remote3) =
+    entrypoint get(r3 : Remote3) =
         r3.get()
 
-    function plus(x, y) = x + y
+    entrypoint plus(x, y) = x + y
 

test/contracts/simple.aes

@@ -1,3 +1,4 @@
 
 contract Simple =
   type t = int => int
+  entrypoint dummy() = ()

test/contracts/simple_storage.aes

@@ -6,11 +6,11 @@
    contract SimpleStorage {
        uint storedData
 
-       function set(uint x) {
+       entrypoint set(uint x) {
            storedData = x
        }
 
-       function get() constant returns (uint) {
+       entrypoint get() constant returns (uint) {
            return storedData
        }
    }
@@ -20,9 +20,9 @@ contract SimpleStorage =
 
   record state = { data : int }
 
-  function init(value : int) : state = { data = value }
+  entrypoint init(value : int) : state = { data = value }
 
-  function get() : int = state.data
+  entrypoint get() : int = state.data
 
-  stateful function set(value : int) =
+  stateful entrypoint set(value : int) =
       put(state{data = value})

test/contracts/spend_test.aes

@@ -1,26 +1,26 @@
 
 contract SpendContract =
-  function withdraw : (int) => int
+  entrypoint withdraw : (int) => int
 
 contract SpendTest =
 
-  stateful function spend(to, amount) =
+  stateful entrypoint spend(to, amount) =
     let total = Contract.balance
     Chain.spend(to, amount)
     total - amount
 
-  stateful function withdraw(amount) : int =
+  stateful entrypoint withdraw(amount) : int =
     spend(Call.caller, amount)
 
-  stateful function withdraw_from(account, amount) =
+  stateful entrypoint withdraw_from(account, amount) =
     account.withdraw(amount)
     withdraw(amount)
 
-  stateful function spend_from(from, to, amount) =
+  stateful entrypoint spend_from(from, to, amount) =
     from.withdraw(amount)
     Chain.spend(to, amount)
     Chain.balance(to)
 
-  function get_balance() = Contract.balance
+  entrypoint get_balance() = Contract.balance
-  function get_balance_of(a) = Chain.balance(a)
+  entrypoint get_balance_of(a) = Chain.balance(a)
 

test/contracts/stack.aes

@@ -6,24 +6,24 @@ contract Stack =
   record state = { stack : stack(string),
                    size  : int }
 
-  function init(ss : list(string)) = { stack = ss, size = length(ss) }
+  entrypoint init(ss : list(string)) = { stack = ss, size = length(ss) }
 
-  private function length(xs) =
+  function length(xs) =
     switch(xs)
       [] => 0
       _ :: xs => length(xs) + 1
 
-  stateful function pop() : string =
+  stateful entrypoint pop() : string =
     switch(state.stack)
       s :: ss =>
         put(state{ stack = ss, size = state.size - 1 })
         s
 
-  stateful function push(s) =
+  stateful entrypoint push(s) =
     put(state{ stack = s :: state.stack, size = state.size + 1 })
     state.size
 
-  function all() = state.stack
+  entrypoint all() = state.stack
 
-  function size() = state.size
+  entrypoint size() = state.size
 

test/contracts/state_handling.aes

@@ -1,70 +1,70 @@
 contract Remote =
   record rstate = { i : int, s : string, m : map(int, int) }
 
-  function look_at : (rstate) => ()
+  entrypoint look_at : (rstate) => unit
-  function return_s : (bool) => string
+  entrypoint return_s : (bool) => string
-  function return_m : (bool) => map(int, int)
+  entrypoint return_m : (bool) => map(int, int)
-  function get : (rstate) => rstate
+  entrypoint get : (rstate) => rstate
-  function get_i : (rstate) => int
+  entrypoint get_i : (rstate) => int
-  function get_s : (rstate) => string
+  entrypoint get_s : (rstate) => string
-  function get_m : (rstate) => map(int, int)
+  entrypoint get_m : (rstate) => map(int, int)
 
-  function fun_update_i  : (rstate, int)           => rstate
+  entrypoint fun_update_i  : (rstate, int)           => rstate
-  function fun_update_s  : (rstate, string)        => rstate
+  entrypoint fun_update_s  : (rstate, string)        => rstate
-  function fun_update_m  : (rstate, map(int, int)) => rstate
+  entrypoint fun_update_m  : (rstate, map(int, int)) => rstate
-  function fun_update_mk : (rstate, int, int)      => rstate
+  entrypoint fun_update_mk : (rstate, int, int)      => rstate
 
 contract StateHandling =
 
   type state = Remote.rstate
 
-  function init(r : Remote, i : int) =
+  entrypoint init(r : Remote, i : int) =
     let state0 = { i = 0, s = "undefined", m = {} }
     r.fun_update_i(state0, i)
 
-  function read() = state
+  entrypoint read() = state
-  function read_i() = state.i
+  entrypoint read_i() = state.i
-  function read_s() = state.s
+  entrypoint read_s() = state.s
-  function read_m() = state.m
+  entrypoint read_m() = state.m
 
-  stateful function update(new_state : state) = put(new_state)
+  stateful entrypoint update(new_state : state) = put(new_state)
-  stateful function update_i(new_i) = put(state{ i = new_i })
+  stateful entrypoint update_i(new_i) = put(state{ i = new_i })
-  stateful function update_s(new_s) = put(state{ s = new_s })
+  stateful entrypoint update_s(new_s) = put(state{ s = new_s })
-  stateful function update_m(new_m) = put(state{ m = new_m })
+  stateful entrypoint update_m(new_m) = put(state{ m = new_m })
 
-  function pass_it(r : Remote) = r.look_at(state)
+  entrypoint pass_it(r : Remote) = r.look_at(state)
-  stateful function nop(r : Remote) = put(state{ i = state.i })
+  stateful entrypoint nop(r : Remote) = put(state{ i = state.i })
-  function return_it_s(r : Remote, big : bool) =
+  entrypoint return_it_s(r : Remote, big : bool) =
     let x = r.return_s(big)
     String.length(x)
-  function return_it_m(r : Remote, big : bool) =
+  entrypoint return_it_m(r : Remote, big : bool) =
     let x = r.return_m(big)
     Map.size(x)
 
-  function pass(r : Remote) = r.get(state)
+  entrypoint pass(r : Remote) = r.get(state)
-  function pass_i(r : Remote) = r.get_i(state)
+  entrypoint pass_i(r : Remote) = r.get_i(state)
-  function pass_s(r : Remote) = r.get_s(state)
+  entrypoint pass_s(r : Remote) = r.get_s(state)
-  function pass_m(r : Remote) = r.get_m(state)
+  entrypoint pass_m(r : Remote) = r.get_m(state)
 
-  function pass_update_i(r : Remote, i) = r.fun_update_i(state, i)
+  entrypoint pass_update_i(r : Remote, i) = r.fun_update_i(state, i)
-  function pass_update_s(r : Remote, s) = r.fun_update_s(state, s)
+  entrypoint pass_update_s(r : Remote, s) = r.fun_update_s(state, s)
-  function pass_update_m(r : Remote, m) = r.fun_update_m(state, m)
+  entrypoint pass_update_m(r : Remote, m) = r.fun_update_m(state, m)
 
-  stateful function remote_update_i (r : Remote, i)    = put(r.fun_update_i(state, i))
+  stateful entrypoint remote_update_i (r : Remote, i)    = put(r.fun_update_i(state, i))
-  stateful function remote_update_s (r : Remote, s)    = put(r.fun_update_s(state, s))
+  stateful entrypoint remote_update_s (r : Remote, s)    = put(r.fun_update_s(state, s))
-  stateful function remote_update_m (r : Remote, m)    = put(r.fun_update_m(state, m))
+  stateful entrypoint remote_update_m (r : Remote, m)    = put(r.fun_update_m(state, m))
-  stateful function remote_update_mk(r : Remote, k, v) = put(r.fun_update_mk(state, k, v))
+  stateful entrypoint remote_update_mk(r : Remote, k, v) = put(r.fun_update_mk(state, k, v))
 
   // remote called
-  function look_at(s : state) = ()
+  entrypoint look_at(s : state) = ()
 
-  function get(s : state) = s
+  entrypoint get(s : state) = s
-  function get_i(s : state) = s.i
+  entrypoint get_i(s : state) = s.i
-  function get_s(s : state) = s.s
+  entrypoint get_s(s : state) = s.s
-  function get_m(s : state) = s.m
+  entrypoint get_m(s : state) = s.m
 
-  function fun_update_i(st, ni) = st{ i = ni }
+  entrypoint fun_update_i(st, ni) = st{ i = ni }
-  function fun_update_s(st, ns) = st{ s = ns }
+  entrypoint fun_update_s(st, ns) = st{ s = ns }
-  function fun_update_m(st, nm) = st{ m = nm }
+  entrypoint fun_update_m(st, nm) = st{ m = nm }
-  function fun_update_mk(st, k, v) = st{ m = st.m{[k] = v} }
+  entrypoint fun_update_mk(st, k, v) = st{ m = st.m{[k] = v} }
 

test/contracts/stateful.aes

@@ -1,18 +1,18 @@
 
 contract Remote =
-  stateful function remote_spend : (address, int) => ()
+  stateful entrypoint remote_spend : (address, int) => unit
-  function remote_pure : int => int
+  entrypoint remote_pure : int => int
 
 contract Stateful =
 
-  private function pure(x) = x + 1
+  function pure(x) = x + 1
-  private stateful function local_spend(a) =
+  stateful function local_spend(a) =
     Chain.spend(a, 1000)
 
   // Non-stateful functions cannot mention stateful functions
-  function fail1(a : address) = Chain.spend(a, 1000)
+  entrypoint fail1(a : address) = Chain.spend(a, 1000)
-  function fail2(a : address) = local_spend(a)
+  entrypoint fail2(a : address) = local_spend(a)
-  function fail3(a : address) =
+  entrypoint fail3(a : address) =
     let foo = Chain.spend
     foo(a, 1000)
 
@@ -20,35 +20,35 @@ contract Stateful =
   private function fail4(a) = Chain.spend(a, 1000)
 
   // If annotated, stateful functions are allowed
-  stateful function ok1(a : address) = Chain.spend(a, 1000)
+  stateful entrypoint ok1(a : address) = Chain.spend(a, 1000)
 
   // And pure functions are always allowed
-  stateful function ok2(a : address) = pure(5)
+  stateful entrypoint ok2(a : address) = pure(5)
-  stateful function ok3(a : address) =
+  stateful entrypoint ok3(a : address) =
     let foo = pure
     foo(5)
 
   // No error here (fail4 is annotated as not stateful)
-  function ok4(a : address) = fail4(a)
+  entrypoint ok4(a : address) = fail4(a)
 
   // Lamdbas are checked at the construction site
-  private function fail5() : address => () = (a) => Chain.spend(a, 1000)
+  function fail5() : address => unit = (a) => Chain.spend(a, 1000)
 
   // .. so you can pass a stateful lambda to a non-stateful higher-order
   // function:
-  private function apply(f : 'a => 'b, x) = f(x)
+  function apply(f : 'a => 'b, x) = f(x)
-  stateful function ok5(a : address) =
+  stateful entrypoint ok5(a : address) =
     apply((val) => Chain.spend(a, val), 1000)
 
   // It doesn't matter if remote calls are stateful or not
-  function ok6(r : Remote) = r.remote_spend(Contract.address, 1000)
+  entrypoint ok6(r : Remote) = r.remote_spend(Contract.address, 1000)
-  function ok7(r : Remote) = r.remote_pure(5)
+  entrypoint ok7(r : Remote) = r.remote_pure(5)
 
   // But you can't send any tokens if not stateful
-  function fail6(r : Remote) = r.remote_spend(value = 1000, Contract.address, 1000)
+  entrypoint fail6(r : Remote) = r.remote_spend(value = 1000, Contract.address, 1000)
-  function fail7(r : Remote) = r.remote_pure(value = 1000, 5)
+  entrypoint fail7(r : Remote) = r.remote_pure(value = 1000, 5)
-  function fail8(r : Remote) =
+  entrypoint fail8(r : Remote) =
     let foo = r.remote_pure
     foo(value = 1000, 5)
-  function ok8(r : Remote) = r.remote_spend(Contract.address, 1000, value = 0)
+  entrypoint ok8(r : Remote) = r.remote_spend(Contract.address, 1000, value = 0)
 

test/contracts/stdlib_include.aes

@@ -0,0 +1,3 @@
+contract StdInc =
+  entrypoint test() = List.map((x) => Func.id(x), [1,2,3,4])
+

test/contracts/strings.aes

@@ -1,4 +1,4 @@
 contract Strings =
-    function str_len(s) = String.length(s)
+    entrypoint str_len(s) = String.length(s)
-    function str_concat(s1, s2) = String.concat(s1, s2)
+    entrypoint str_concat(s1, s2) = String.concat(s1, s2)
 

test/contracts/stub.aes

@@ -0,0 +1,2 @@
+contract Stub =
+  entrypoint foo : (int) => int

test/contracts/test.aes

@@ -91,10 +91,10 @@ contract Identity =
   // }
   // let id(x) = x
   // let main(xs) = map(double,xs)
-  function z(f,x) = x
+  entrypoint z(f,x) = x
-  private function s(n) = (f,x)=>f(n(f,x))
+  function s(n) = (f,x)=>f(n(f,x))
-  private function add(m,n) = (f,x)=>m(f,n(f,x))
+  function add(m,n) = (f,x)=>m(f,n(f,x))
-  function main(_) =
+  entrypoint main(_) =
     let three=s(s(s(z)))
     add(three,three)
        (((i)=>i+1),0)

test/contracts/tuple_match.aes

@@ -0,0 +1,36 @@
+contract TuplesMatch =
+
+  entrypoint tuplify3() = (t) => switch(t)
+    (x, y, z) => 3
+
+  entrypoint fst(p : int * string) =
+    switch(p)
+      (x, y) => x
+  entrypoint fst'(p : int * string) =
+    switch(p)
+      (x, _) => x
+  entrypoint snd(p : int * string) =
+    switch(p)
+      (x, y) => y
+  entrypoint snd'(p : int * string) =
+    switch(p)
+      (_, y) => y
+  entrypoint sum(p) =
+    switch(p)
+      (x, y) => x + y
+  entrypoint swap(p : int * string) =
+    switch(p)
+      (x, y) => (y, x)
+  entrypoint id(p : int * int * string) =
+    switch(p)
+      (x, y, z) => (x, y, z)
+  entrypoint nest(p : (int * int) * string) =
+    switch(p)
+      (xy, z) => switch(xy) (x, y) => (x, y, z)
+  entrypoint deep(p : (int * int) * (int * int)) =
+    switch(p)
+      ((x, y), (z, w)) => (x, y, z, w)
+  entrypoint deep_sum(p : (int * int) * (int * int)) =
+    switch(p)
+      ((x, y), (z, w)) => x + y + z + w
+

test/contracts/type_clash.aes

@@ -2,12 +2,12 @@
 contract Remote =
 
   type themap = map(int, string)
-  function foo : () => themap
+  entrypoint foo : () => themap
 
 contract Main =
 
   type themap = map(string, int)
 
   // Should fail
-  function foo(r : Remote) : themap = r.foo()
+  entrypoint foo(r : Remote) : themap = r.foo()
 

test/contracts/type_errors.aes

@@ -6,39 +6,54 @@ contract Test =
   record r2 = { z : int, w : int }
   record r3 = { x : int, z : int }
 
-  function set_x(r : r, z) = r{ x["foo"] @ x = x + 1 }
+  entrypoint set_x(r : r, z) = r{ x["foo"] @ x = x + 1 }
 
-  function bla(m : map(string, int)) = { [0] = "bla", ["foo"] = "" }
+  entrypoint bla(m : map(string, int)) = { [0] = "bla", ["foo"] = "" }
 
-  function foo(r) = r { y = 0 }
+  entrypoint foo(r) = r { y = 0 }
-  function bar() = { y = "foo", z = 0 }
+  entrypoint bar() = { y = "foo", z = 0 }
-  function baz() = { y = "foo", w = 0 }
+  entrypoint baz() = { y = "foo", w = 0 }
 
-  function foo1() = zz
+  entrypoint foo1() = zz
 
-  function test1() : string = { y = 0 }
+  entrypoint test1() : string = { y = 0 }
-  function test2(x : string) = x { y = 0 }
+  entrypoint test2(x : string) = x { y = 0 }
-  function test3(x : string) = x { y @ y = y + 1 }
+  entrypoint test3(x : string) = x { y @ y = y + 1 }
-  function test4(x : string) : int = x.y
+  entrypoint test4(x : string) : int = x.y
 
-  function test5(xs) =
+  entrypoint test5(xs) =
     switch(xs)
       x :: x => x
       [] => 0
 
-  function case_pat(xs) =
+  entrypoint case_pat(xs) =
     switch(xs)
       [] => 0
       x :: xs => "x"
 
-  function foo2(m : map(string, int)) = m{ [1] = "bla" }
+  entrypoint foo2(m : map(string, int)) = m{ [1] = "bla" }
 
-  function bad_if(x, y : int, w : int, z : string) =
+  entrypoint bad_if(x, y : int, w : int, z : string) =
     if(x) y
     elif(x) w
     else z
 
-  function type_error(r, x) =
+  entrypoint type_error(r, x) =
     set_x(set_x(x, r), x)
 
-  function repeated_arg(x : int, y, x : string, y : bool) : string = x
+  entrypoint repeated_arg(x : int, y, x : string, y : bool) : string = x
+
+  entrypoint missing1() =
+    let x = 0
+
+  entrypoint missing_fun1() =
+    let f(x) = x
+
+  entrypoint missing2() =
+    let x = 0
+    let y = 0
+
+  entrypoint missing_fun2() =
+    let f() = 0
+    let g() = f()
+