Test Auth.tx_hash compilation

CHANGELOG.md

@@ -1,40 +0,0 @@
-# Changelog
-All notable changes to this project will be documented in this file.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
-and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-
-## [Unreleased]
-### Added
-### Changed
-### Removed
-
-## [2.1.0] - 2019-04-11
-### Added
-- Stubs (not yet wired up) for compilation to FATE
-- Add functions specific for Calldata decoding
-- Support for `Auth.tx_hash`, not available in AEVM until Fortuna release
-
-### Changed
-- Improvements to the ACI generator
-
-## [2.0.0] - 2019-03-11
-### Added
-- Add `Crypto.ecverify` to the compiler.
-- Add `Crypto.sha3`, `Crypto.blake2`, `Crypto.sha256`, `String.blake2` and
-  `String.sha256` to the compiler.
-- Add the `bits` type for working with bit fields in Sophia.
-- Add Namespaces to Sophia in order to simplify using library contracts, etc.
-- Add a missig type check on the `init` function - detects programmer errors earlier.
-- Add the ACI (Aeternity Contract Interface) generator.
-
-### Changed
-- Use native bit shift operations in builtin functions, reducing gas cost.
-- Improve type checking of `record` fields - generates more understandable error messages.
-- Improved, more coherent, error messages.
-- Simplify calldata creation - instead of passing a compiled contract, simply
-  pass a (stubbed) contract string.
-
-[Unreleased]: https://github.com/aeternity/aesophia/compare/v2.1.0...HEAD
-[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/RELEASE-NOTES-2.0.0.md

@@ -0,0 +1,16 @@
+# About this release
+
+This is the `aesophia` compiler version 2.0.0. The main changes compared to version 1.2.0 are:
+
+* Add `Crypto.ecverify` to the compiler.
+* Add `Crypto.sha3`, `Crypto.blake2`, `Crypto.sha256`, `String.blake2` and
+  `String.sha256` to the compiler.
+* Add the `bits` type for working with bit fields in Sophia.
+* Use native bit shift operations in builtin functions, reducing gas cost.
+* Add Namespaces to Sophia in order to simplify using library contracts, etc.
+* Simplify calldata creation - instead of passing a compiled contract, simply
+  pass a (stubbed) contract string.
+* Add a missig type check on the `init` function - detects programmer errors earlier.
+* Improve type checking of `record` fields - generates more understandable error messages.
+* Improved, more coherent, error messages.
+* Add the ACI (Aeternity Contract Interface) generator.

docs/aeso_aci.md

@@ -31,48 +31,23 @@ generates the following JSON structure representing the contract interface:
 {
   "contract": {
     "name": "Answers",
-    "state": {
-      "record": [
-        {
-          "name": "a",
-          "type": {
-            "map": {
-              "key": "string",
-              "value": "int"
-            }
-          }
-        }
-      ]
-    },
     "type_defs": [
+      {
+        "name": "state",
+        "vars": [],
+        "typedef": "{a : map(string,int)}"
+      },
       {
         "name": "answers",
         "vars": [],
-        "typedef": {
-          "map": {
-            "key": "string",
-            "value": "int"
-          }
-        }
+        "typedef": "map(string,int)"
       }
     ],
     "functions": [
       {
         "name": "init",
         "arguments": [],
-        "returns": {
-          "record": [
-            {
-              "name": "a",
-              "type": {
-                "map": {
-                  "key": "string",
-                  "value": "int"
-                }
-              }
-            }
-          ]
-        },
+        "type": "{a : map(string,int)}",
         "stateful": true
       },
       {
@@ -87,12 +62,7 @@ generates the following JSON structure representing the contract interface:
             "type": "int"
           }
         ],
-        "returns": {
-          "map": {
-            "key": "string",
-            "value": "int"
-          }
-        },
+        "type": "map(string,int)",
         "stateful": false
       }
     ]
@@ -104,7 +74,7 @@ When that encoding is decoded the following include definition is generated:
 
 ```
 contract Answers =
-  function new_answer : (string, int) => map(string, int)
+  function new_answer : (string, int) => map(string,int)
 ```
 
 ### Types
@@ -115,7 +85,7 @@ json_string() = binary()
 
 ### Exports
 
-#### encode_contract(ContractString) -> {ok,JSONstring} | {error,ErrorString}
+#### encode(ContractString) -> {ok,JSONstring} | {error,ErrorString}
 
 Types
 
@@ -124,21 +94,9 @@ ConstractString = contract_string()
 JSONstring = json_string()
 ```
 
-This is equivalent to `aeso_aci:encode_contract(ConstractString, [])`.
-
-#### encode_contract(ContractString, Options) -> {ok,JSONstring} | {error,ErrorString}
-
-Types
-
-``` erlang
-ConstractString = contract_string()
-Options = [option()]
-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.
 
-#### decode_contract(JSONstring) -> ConstractString.
+#### decode(JSONstring) -> ConstractString.
 
 Types
 
@@ -149,67 +107,23 @@ 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.
 
-#### encode_type(TypeAST) -> JSONstring.
-
-Types
-
-``` erlang
-JSONstring = json_string()
-```
-
-Generate the JSON encoding of a type from the AST of the type.
-
-#### encode_arg(ArgAST) -> JSONstring.
-
-Types
-
-``` erlang
-JSONstring = json_string()
-```
-
-Generate the JSON encoding of a function argument from the AST of the argument.
-
-#### encode_stmt(StmtAST) -> JSONstring.
-
-Types
-
-``` erlang
-JSONstring = json_string()
-```
-
-Generate the JSON encoding of a statement from the AST of the statement.
-
-#### encode_expr(ExprAST) -> JSONstring.
-
-Types
-
-``` erlang
-JSONstring = json_string()
-```
-
-Generate the JSON encoding of an expression from the AST of the expression.
-
-### Notes
-
-The deprecated functions `aseo_aci:encode/2` and `aeso_aci:decode/1` are still available but should not be used.
-
 ### 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.
 
 ``` erlang
 1> {ok,Contract} = file:read_file("aci_test.aes").
-{ok,<<"contract Answers =\n\n  record state = { a : answers }\n  type answers() = map(string, int)\n\n  stateful functio"...>>}
-2> {ok,Encoding} = aeso_aci:encode_contract(Contract).
-{ok,<<"{\"contract\":{\"name\":\"Answers\",\"state\":{\"record\":[{\"name\":\"a\",\"type\":{\"map\":{\"key\":\"string\",\"value\":\"int\"}}}]"...>>}
+{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).
+<<"{\"contract\":{\"name\":\"Answers\",\"type_defs\":[{\"name\":\"state\",\"vars\":[],\"typedef\":\"{a : map(string,int)}\"},{\"name\":\"ans"...>>
 3> file:write_file("aci_test.aci", Encoding).
 ok
-4> Decoded = aeso_aci:decode_contract(Encoding).
-<<"contract Answers =\n  function new_answer : (string, int) => map(string, int)\n">>
+4> Decoded = aeso_aci:decode(Encoding).
+<<"contract Answers =\n  function new_answer : (string, int) => map(string,int)\n">>
 5> file:write_file("aci_test.include", Decoded).
 ok
 6> jsx:prettify(Encoding).
-<<"{\n  \"contract\": {\n    \"name\": \"Answers\",\n    \"state\": {\n      \"record\": [\n        {\n          \"name\": \"a\",\n         "...>>
+<<"{\n  \"contract\": {\n    \"name\": \"Answers\",\n    \"type_defs\": [\n      {\n        \"name\": \"state\",\n        \"vars\": [],\n   "...>>
 ```
 
 The final call to `jsx:prettify(Encoding)` returns the encoding in a

include/aeso_heap.hrl

@@ -0,0 +1,15 @@
+
+-record(pmap, {key_t  :: aeso_sophia:type(),
+               val_t  :: aeso_sophia:type(),
+               parent :: none | non_neg_integer(),
+               size   = 0 :: non_neg_integer(),
+               data   :: #{aeso_heap:binary_value() => aeso_heap:binary_value() | tombstone}
+                       | stored}).
+
+-record(maps, { maps    = #{} :: #{ non_neg_integer() => #pmap{} }
+              , next_id = 0   :: non_neg_integer() }).
+
+-record(heap, { maps   :: #maps{},
+                offset :: aeso_heap:offset(),
+                heap   :: binary() | #{non_neg_integer() => non_neg_integer()} }).
+

rebar.config

@@ -3,7 +3,7 @@
 {erl_opts, [debug_info]}.
 
 {deps, [ {aebytecode, {git, "https://github.com/aeternity/aebytecode.git",
-                            {ref, "e8253b0"}}}
+                            {ref, "9041423"}}}
        , {getopt, "1.0.1"}
        , {jsx, {git, "https://github.com/talentdeficit/jsx.git",
                      {tag, "2.8.0"}}}
@@ -30,7 +30,7 @@
             {base_plt_apps, [erts, kernel, stdlib, crypto, mnesia]}
            ]}.
 
-{relx, [{release, {aesophia, "2.1.0"},
+{relx, [{release, {aesophia, "2.0.0"},
          [aesophia, aebytecode, getopt]},
 
         {dev_mode, true},

rebar.lock

@@ -1,7 +1,7 @@
 {"1.1.0",
 [{<<"aebytecode">>,
   {git,"https://github.com/aeternity/aebytecode.git",
-       {ref,"e8253b09709f1595d8bd6a1756a0ce93185c6518"}},
+       {ref,"9041423906247a7267a5a94530307b19c4490e8c"}},
   0},
  {<<"aeserialization">>,
   {git,"https://github.com/aeternity/aeserialization.git",

src/aeso_abi.erl

@@ -0,0 +1,209 @@
+%%%-------------------------------------------------------------------
+%%% @copyright (C) 2017, Aeternity Anstalt
+%%% @doc
+%%%     Encode and decode data and function calls according to
+%%%     Sophia-AEVM-ABI.
+%%% @end
+%%% Created : 25 Jan 2018
+%%%
+%%%-------------------------------------------------------------------
+-module(aeso_abi).
+-define(HASH_SIZE, 32).
+
+-export([ old_create_calldata/3
+        , create_calldata/4
+        , check_calldata/2
+        , function_type_info/3
+        , function_type_hash/3
+        , arg_typerep_from_function/2
+        , type_hash_from_function_name/2
+        , typereps_from_type_hash/2
+        , function_name_from_type_hash/2
+        , get_function_hash_from_calldata/1
+        ]).
+
+-type hash() :: <<_:256>>. %% 256 = ?HASH_SIZE * 8.
+-type function_name() :: binary(). %% String
+-type typerep() :: aeso_sophia:type().
+-type function_type_info() :: { FunctionHash :: hash()
+                              , FunctionName :: function_name()
+                              , ArgType      :: binary() %% binary typerep
+                              , OutType      :: binary() %% binary typerep
+                              }.
+-type type_info() :: [function_type_info()].
+
+%%%===================================================================
+%%% API
+%%%===================================================================
+
+%%%===================================================================
+%%% Handle calldata
+
+create_calldata(FunName, Args, ArgTypes0, RetType) ->
+    ArgTypes = {tuple, ArgTypes0},
+    <<TypeHashInt:?HASH_SIZE/unit:8>> =
+        function_type_hash(list_to_binary(FunName), ArgTypes, RetType),
+    Data = aeso_heap:to_binary({TypeHashInt, list_to_tuple(Args)}),
+    {ok, Data, {tuple, [word, ArgTypes]}, RetType}.
+
+get_type_info_and_hash(#{type_info := TypeInfo}, FunName) ->
+    FunBin = list_to_binary(FunName),
+    case type_hash_from_function_name(FunBin, TypeInfo) of
+        {ok, <<TypeHashInt:?HASH_SIZE/unit:8>>} -> {ok, TypeInfo, TypeHashInt};
+        {ok, _}                   -> {error, bad_type_hash};
+        {error, _} = Err          -> Err
+    end.
+
+-spec check_calldata(binary(), type_info()) ->
+                        {'ok', typerep(), typerep()} | {'error', atom()}.
+check_calldata(CallData, TypeInfo) ->
+    %% The first element of the CallData should be the function name
+    case get_function_hash_from_calldata(CallData) of
+        {ok, Hash} ->
+            case typereps_from_type_hash(Hash, TypeInfo) of
+                {ok, ArgType, OutType} ->
+                    try aeso_heap:from_binary({tuple, [word, ArgType]}, CallData) of
+                        {ok, _Something} ->
+                            {ok, {tuple, [word, ArgType]}, OutType};
+                        {error, _} ->
+                            {error, bad_call_data}
+                    catch
+                        _T:_E ->
+                            {error, bad_call_data}
+                    end;
+                {error, _} ->
+                    {error, unknown_function}
+            end;
+        {error, _What} ->
+            {error, bad_call_data}
+    end.
+
+-spec get_function_hash_from_calldata(CallData::binary()) ->
+                                             {ok, binary()} | {error, term()}.
+get_function_hash_from_calldata(CallData) ->
+    case aeso_heap:from_binary({tuple, [word]}, CallData) of
+        {ok, {HashInt}} -> {ok, <<HashInt:?HASH_SIZE/unit:8>>};
+        {error, _} = Error -> Error
+    end.
+
+%%%===================================================================
+%%% Handle type info from contract meta data
+
+-spec function_type_info(function_name(), [typerep()], typerep()) ->
+                            function_type_info().
+function_type_info(Name, ArgTypes, OutType) ->
+    ArgType = {tuple, ArgTypes},
+    { function_type_hash(Name, ArgType, OutType)
+    , Name
+    , aeso_heap:to_binary(ArgType)
+    , aeso_heap:to_binary(OutType)
+    }.
+
+-spec function_type_hash(function_name(), typerep(), typerep()) -> hash().
+function_type_hash(Name, ArgType, OutType) when is_binary(Name) ->
+    Bin =  iolist_to_binary([ Name
+                            , aeso_heap:to_binary(ArgType)
+                            , aeso_heap:to_binary(OutType)
+                            ]),
+    %% Calculate a 256 bit digest BLAKE2b hash value of a binary
+    {ok, Hash} = eblake2:blake2b(?HASH_SIZE, Bin),
+    Hash.
+
+-spec arg_typerep_from_function(function_name(), type_info()) ->
+           {'ok', typerep()} | {'error', 'bad_type_data' | 'unknown_function'}.
+arg_typerep_from_function(Function, TypeInfo) ->
+    case lists:keyfind(Function, 2, TypeInfo) of
+        {_TypeHash, Function, ArgTypeBin,_OutTypeBin} ->
+            case aeso_heap:from_binary(typerep, ArgTypeBin) of
+                {ok, ArgType} -> {ok, ArgType};
+                {error,_} -> {error, bad_type_data}
+            end;
+        false ->
+            {error, unknown_function}
+    end.
+
+-spec typereps_from_type_hash(hash(), type_info()) ->
+           {'ok', typerep(), typerep()} | {'error', 'bad_type_data' | 'unknown_function'}.
+typereps_from_type_hash(TypeHash, TypeInfo) ->
+    case lists:keyfind(TypeHash, 1, TypeInfo) of
+        {TypeHash,_Function, ArgTypeBin, OutTypeBin} ->
+            case {aeso_heap:from_binary(typerep, ArgTypeBin),
+                  aeso_heap:from_binary(typerep, OutTypeBin)} of
+                {{ok, ArgType}, {ok, OutType}} -> {ok, ArgType, OutType};
+                {_, _} -> {error, bad_type_data}
+            end;
+        false ->
+            {error, unknown_function}
+    end.
+
+-spec function_name_from_type_hash(hash(), type_info()) ->
+                                          {'ok', function_name()}
+                                        | {'error', 'unknown_function'}.
+function_name_from_type_hash(TypeHash, TypeInfo) ->
+    case lists:keyfind(TypeHash, 1, TypeInfo) of
+        {TypeHash, Function,_ArgTypeBin,_OutTypeBin} ->
+            {ok, Function};
+        false ->
+            {error, unknown_function}
+    end.
+
+-spec type_hash_from_function_name(function_name(), type_info()) ->
+                                          {'ok', hash()}
+                                        | {'error', 'unknown_function'}.
+type_hash_from_function_name(Name, TypeInfo) ->
+    case lists:keyfind(Name, 2, TypeInfo) of
+        {TypeHash, Name,_ArgTypeBin,_OutTypeBin} ->
+            {ok, TypeHash};
+        false ->
+            {error, unknown_function}
+    end.
+
+%% -- Old calldata creation. Kept for backwards compatibility. ---------------
+
+old_create_calldata(Contract, Function, Argument) when is_map(Contract) ->
+    case aeso_constants:string(Argument) of
+        {ok, {tuple, _, _} = Tuple} ->
+            old_encode_call(Contract, Function, Tuple);
+        {ok, {unit, _} = Tuple} ->
+            old_encode_call(Contract, Function, Tuple);
+        {ok, ParsedArgument} ->
+            %% The Sophia compiler does not parse a singleton tuple (42) as a tuple,
+            %% Wrap it in a tuple.
+            old_encode_call(Contract, Function, {tuple, [], [ParsedArgument]});
+        {error, _} ->
+            {error, argument_syntax_error}
+    end.
+
+%% Call takes one arument.
+%% Use a tuple to pass multiple arguments.
+old_encode_call(Contract, Function, ArgumentAst) ->
+    Argument = old_ast_to_erlang(ArgumentAst),
+    case get_type_info_and_hash(Contract, Function) of
+        {ok, TypeInfo, TypeHashInt} ->
+            Data = aeso_heap:to_binary({TypeHashInt, Argument}),
+            case check_calldata(Data, TypeInfo) of
+                {ok, CallDataType, OutType} ->
+                    {ok, Data, CallDataType, OutType};
+                {error, _} = Err ->
+                    Err
+            end;
+        {error, _} = Err -> Err
+    end.
+
+old_ast_to_erlang({int, _, N}) -> N;
+old_ast_to_erlang({hash, _, <<N:?HASH_SIZE/unit:8>>}) -> N;
+old_ast_to_erlang({hash, _, <<Hi:256, Lo:256>>}) -> {Hi, Lo};    %% signature
+old_ast_to_erlang({bool, _, true}) -> 1;
+old_ast_to_erlang({bool, _, false}) -> 0;
+old_ast_to_erlang({string, _, Bin}) -> Bin;
+old_ast_to_erlang({unit, _}) -> {};
+old_ast_to_erlang({con, _, "None"}) -> none;
+old_ast_to_erlang({app, _, {con, _, "Some"}, [A]}) -> {some, old_ast_to_erlang(A)};
+old_ast_to_erlang({tuple, _, Elems}) ->
+    list_to_tuple(lists:map(fun old_ast_to_erlang/1, Elems));
+old_ast_to_erlang({list, _, Elems}) ->
+    lists:map(fun old_ast_to_erlang/1, Elems);
+old_ast_to_erlang({map, _, Elems}) ->
+    maps:from_list([ {old_ast_to_erlang(element(1, Elem)), old_ast_to_erlang(element(2, Elem))}
+                        || Elem <- Elems ]).
+

src/aeso_aci.erl

@@ -1,35 +1,26 @@
 %%%-------------------------------------------------------------------
 %%% @author Robert Virding
-%%% @copyright (C) 2019, Aeternity Anstalt
+%%% @copyright (C) 2017, Aeternity Anstalt
 %%% @doc
 %%%     ACI interface
 %%% @end
-%%% Created : 12 Jan 2019
+%%% Created : 12 Dec 2017
 %%%-------------------------------------------------------------------
 
 -module(aeso_aci).
 
-%% Old deprecated interface.
 -export([encode/1,encode/2,decode/1]).
 
--export([encode_contract/1,encode_contract/2,decode_contract/1]).
--export([encode_func/1,encode_type/1,encode_arg/1,
-         encode_stmt/1,encode_expr/1]).
-
 %% Define records for the various typed syntactic forms. These make
-%% the code easier but don't seem to exist elsewhere. Unfortunately
-%% sometimes the same typename is used with different fields.
+%% the code easier but don't seem to exist elsewhere.
 
-%% Top-level
 -record(contract, {ann,con,decls}).
 %% -record(namespace, {ann,con,decls}).
 -record(letfun, {ann,id,args,type,body}).
 -record(type_def, {ann,id,vars,typedef}).
 
-%% Types
 -record(app_t, {ann,id,fields}).
 -record(tuple_t, {ann,args}).
--record(bytes_t, {ann,len}).
 -record(record_t, {fields}).
 -record(field_t, {ann,id,type}).
 -record(alias_t, {type}).
@@ -37,7 +28,6 @@
 -record(constr_t, {ann,con,args}).
 -record(fun_t, {ann,named,args,type}).
 
-%% Tokens
 -record(arg, {ann,id,type}).
 -record(id, {ann,name}).
 -record(con, {ann,name}).
@@ -45,62 +35,33 @@
 -record(qcon, {ann,names}).
 -record(tvar, {ann,name}).
 
-%% Statements
--record(block, {ann,body}).
--record('if', {ann,test,then,else}).            %Both statement and expression
--record(letval, {ann,pat,type,exp}).
--record(switch, {ann,arg,cases}).
--record('case', {ann,pat,body}).
-
-%% Expressions
--record(bool, {ann,bool}).
--record(int, {ann,value}).
--record(string, {ann,bin}).
--record(bytes, {ann,bin}).
--record(tuple, {ann,args}).
--record(list, {ann,args}).
--record(record, {ann,fields}).                  %Create a record
--record(field, {ann,name,value}).               %A record field
--record(proj, {ann,value}).                     %?
--record(map, {ann,fields}).                     %Create a map
--record(map_get, {ann,field}).
--record(lam, {ann,args,body}).
--record(app, {ann,func,args}).
--record(typed, {ann,expr,type}).
-
-%% The old deprecated interface.
-
-encode(C) -> encode_contract(C).
-encode(C, Os) -> encode_contract(C, Os).
-decode(J) -> decode_contract(J).
-
-%% encode_contract(ContractString) -> {ok,JSON} | {error,String}.
-%% encode_contract(ContractString, Options) -> {ok,JSON} | {error,String}.
+%% encode(ContractString) -> {ok,JSON} | {error,String}.
+%% encode(ContractString, Options) -> {ok,JSON} | {error,String}.
 %%  Build a JSON structure with lists and tuples, not maps, as this
 %%  allows us to order the fields in the contructed JSON string.
 
-encode_contract(ContractString) -> 
-    encode_contract(ContractString, []).
-encode_contract(ContractString, Options) when is_binary(ContractString) ->
-    encode_contract(binary_to_list(ContractString), Options);
-encode_contract(ContractString, Options) ->
+encode(ContractString) -> encode(ContractString, []).
+
+encode(ContractString, Options) when is_binary(ContractString) ->
+    encode(binary_to_list(ContractString), Options);
+encode(ContractString, Options) ->
     try
         Ast = parse(ContractString, Options),
-        %% io:format("Ast\n~p\n", [Ast]),
+        %%io:format("~p\n", [Ast]),
         %% aeso_ast:pp(Ast),
         TypedAst = aeso_ast_infer_types:infer(Ast, Options),
-        %% io:format("Typed ast\n~p\n", [TypedAst]),
+        %% io:format("~p\n", [TypedAst]),
         %% aeso_ast:pp_typed(TypedAst),
         %% We find and look at the last contract.
         Contract = lists:last(TypedAst),
         Cname = contract_name(Contract),
-        Tdefs = do_encode_contract_typedefs(sort_decls(contract_types(Contract))),
-        Fdefs = [ do_encode_func(F) || F <- sort_decls(contract_funcs(Contract)),
+        Tdefs = [ encode_typedef(T) ||
+                    T <- sort_decls(contract_types(Contract)) ],
+        Fdefs = [ encode_func(F) || F <- sort_decls(contract_funcs(Contract)),
                                     not is_private_func(F) ],
-        Jmap = [{<<"contract">>,
-                 [{<<"name">>, do_encode_name(Cname)}] ++
-                     Tdefs ++
-                     [{<<"functions">>, Fdefs}]}],
+        Jmap = [{<<"contract">>, [{<<"name">>, list_to_binary(Cname)},
+                                  {<<"type_defs">>, Tdefs},
+                                  {<<"functions">>, Fdefs}]}],
         %% io:format("~p\n", [Jmap]),
         {ok,jsx:encode(Jmap)}
     catch
@@ -119,376 +80,122 @@ join_errors(Prefix, Errors, Pfun) ->
     Ess = [ Pfun(E) || E <- Errors ],
     list_to_binary(string:join([Prefix|Ess], "\n")).
 
-%% do_encode_contract_typedefs(TypeDefs) -> [JSON].
-%%  Return a list of typedefs and state and event if they occur.
-
-do_encode_contract_typedefs(Tdefs) ->
-    Fun = fun(T, {Ts,Ss,Es}) ->
-                  %% Only one state and event.
-                  case typedef_name(T) of
-                      "state" -> {Ts,[do_encode_state_typedef(T)],Es};
-                      "event" -> {Ts,Ss,[do_encode_event_typedef(T)]};
-                      _Name  -> {Ts ++ [do_encode_typedef(T)],Ss,Es}
-                  end
-          end,
-    {Ts,Ss,Es} = lists:foldl(Fun, {[],[],[]}, Tdefs),
-    Ss ++ [{<<"type_defs">>, Ts}] ++ Es.
-
-%% do_encode_state_typedef(StateTdef) -> JSON.
-%% do_encode_event_typedef(EventTdef) -> JSON.
-
-do_encode_state_typedef(State) ->
-    Def = typedef_def(State),
-    {<<"state">>,do_encode_alias(Def)}.
-
-do_encode_event_typedef(State) ->
-    Def = typedef_def(State),
-    {<<"event">>,do_encode_alias(Def)}.
-
-%% encode_func(TypedAST) -> JSON.
-%%  Encode a function AST into a JSON structure.
-
-encode_func(AST) ->
-    jsx:encode(do_encode_func(AST)).
-
-%% do_encode_func(Function) -> JSONmap
-%%  Encode a function definition. Currently we are only interested in
-%%  the interface and type.
-
-do_encode_func(Fdef) ->
+encode_func(Fdef) ->
     Name = function_name(Fdef),
     Args = function_args(Fdef),
     Type = function_type(Fdef),
-    [{<<"name">>, do_encode_name(Name)},
-     {<<"arguments">>, do_encode_args(Args)},
-     {<<"returns">>, do_encode_type(Type)},
+    [{<<"name">>, list_to_binary(Name)},
+     {<<"arguments">>, encode_args(Args)},
+     {<<"type">>, list_to_binary(encode_type(Type))},
      {<<"stateful">>, is_stateful_func(Fdef)}].
 
-%% encode_arg(TypedAST) -> JSON.
-%%  Encode an argument AST into a JSON structure.
+encode_args(Args) ->
+    [ encode_arg(A) || A <- Args ].
 
-encode_arg(AST) ->
-    jsx:encode(do_encode_arg(AST)).
+encode_arg(#arg{id=Id,type=T}) ->
+    [{<<"name">>,list_to_binary(encode_type(Id))},
+     {<<"type">>,list_to_binary(encode_type(T))}].
 
-%% do_encode_args(ArgASTs) -> [JSONmap].
-%% do_encode_arg(ArgAST) -> JSONmap.
+encode_types(Types) ->
+    [ encode_type(T) || T <- Types ].
 
-do_encode_args(Args) ->
-    [ do_encode_arg(A) || A <- Args ].
+encode_type(#tvar{name=N}) -> N;
+encode_type(#id{name=N}) -> N;
+encode_type(#con{name=N}) -> N;
+encode_type(#qid{names=Ns}) ->
+    lists:join(".", Ns);
+encode_type(#qcon{names=Ns}) ->
+    lists:join(".", Ns);                        %?
+encode_type(#tuple_t{args=As}) ->
+    Eas = encode_types(As),
+    [$(,lists:join(",", Eas),$)];
+encode_type(#record_t{fields=Fs}) ->
+    Efs = encode_types(Fs),
+    [${,lists:join(",", Efs),$}];
+encode_type(#app_t{id=Id,fields=Fs}) ->
+    Name = encode_type(Id),
+    Efs = encode_types(Fs),
+    [Name,"(",lists:join(",", Efs),")"];
+encode_type(#field_t{id=Id,type=T}) ->
+    [encode_type(Id)," : ",encode_type(T)];
+encode_type(#variant_t{cons=Cs}) ->
+    Ecs = encode_types(Cs),
+    lists:join(" | ", Ecs);
+encode_type(#constr_t{con=C,args=As}) ->
+    Ec = encode_type(C),
+    Eas = encode_types(As),
+    [Ec,$(,lists:join(", ", Eas),$)];
+encode_type(#fun_t{args=As,type=T}) ->
+    Eas = encode_types(As),
+    Et = encode_type(T),
+    [$(,lists:join(", ", Eas),") => ",Et].
 
-do_encode_arg(#arg{id=Id,type=T}) ->
-    [{<<"name">>,do_encode_type(Id)},
-     {<<"type">>,do_encode_type(T)}].
-
-%% encode_type(TypedAST) -> JSON.
-%%  Encode a type AST into a JSON structure.
-
-encode_type(AST) ->
-    jsx:encode(do_encode_type(AST)).
-
-%% do_encode_types([TypeAST]) -> [JSONmap].
-%% do_encode_type(TypeAST) -> JsonMap.
-
-do_encode_types(Types) ->
-    [ do_encode_type(T) || T <- Types ].
-
-do_encode_type(#tvar{name=N}) -> do_encode_name(N);
-do_encode_type(#id{name=N}) -> do_encode_name(N);
-do_encode_type(#con{name=N}) -> do_encode_name(N);
-do_encode_type(#qid{names=Ns}) ->
-    do_encode_name(lists:join(".", Ns));
-do_encode_type(#qcon{names=Ns}) ->
-    do_encode_name(lists:join(".", Ns));        %?
-do_encode_type(#tuple_t{args=As}) ->
-    Eas = do_encode_types(As),
-    [{<<"tuple">>,Eas}];
-do_encode_type(#bytes_t{len=Len}) ->
-    {<<"bytes">>,Len};
-do_encode_type(#record_t{fields=Fs}) ->
-    Efs = do_encode_type_rec_fields(Fs),
-    [{<<"record">>,Efs}];
-%% Special case lists and maps as they are built-in types.
-do_encode_type(#app_t{id=#id{name="list"},fields=[F]}) ->
-    Ef = do_encode_type(F),
-    [{<<"list">>,Ef}];
-do_encode_type(#app_t{id=#id{name="map"},fields=Fs}) ->
-    Ef = do_encode_type_mapo_field(Fs),
-    [{<<"map">>,Ef}];
-%% Other applications.
-do_encode_type(#app_t{id=Id,fields=Fs}) ->
-    Name = do_encode_type(Id),
-    Efs = do_encode_types(Fs),
-    [{Name,Efs}];
-do_encode_type(#variant_t{cons=Cs}) ->
-    Ecs = do_encode_types(Cs),
-    [{<<"variant">>,Ecs}];
-do_encode_type(#constr_t{con=C,args=As}) ->
-    Ec = do_encode_type(C),
-    Eas = do_encode_types(As),
-    [{Ec,Eas}];
-do_encode_type(#fun_t{args=As,type=T}) ->
-    Eas = do_encode_types(As),
-    Et = do_encode_type(T),
-    [{<<"function">>,[{<<"arguments">>,Eas},{<<"returns">>,Et}]}].
-
-do_encode_name(Name) ->
-    list_to_binary(Name).
-
-%% do_encode_type_rec_fields(Fields) -> [JSONmap].
-%% do_encode_type_rec_field(Field) -> JSONmap.
-%%  Encode a record field type.
-
-do_encode_type_rec_fields(Fs) ->
-    [ do_encode_type_rec_field(F) || F <- Fs ].
-
-do_encode_type_rec_field(#field_t{id=Id,type=T}) ->
-    [{<<"name">>,do_encode_type(Id)},
-     {<<"type">>,do_encode_type(T)}].
-
-%% do_encode_type_mapo_field(Field) -> JSONmap.
-%%  Two fields for one map type.
-
-do_encode_type_mapo_field([K,V]) ->
-    [{<<"key">>,do_encode_type(K)},
-     {<<"value">>,do_encode_type(V)}].
-
-%% do_encode_typedef(TypeDefAST) -> JSON.
-
-do_encode_typedef(Type) ->
+encode_typedef(Type) ->
     Name = typedef_name(Type),
     Vars = typedef_vars(Type),
     Def = typedef_def(Type),
-    [{<<"name">>, do_encode_name(Name)},
-     {<<"vars">>, do_encode_tvars(Vars)},
-     {<<"typedef">>, do_encode_alias(Def)}].
+    [{<<"name">>, list_to_binary(Name)},
+     {<<"vars">>, encode_tvars(Vars)},
+     {<<"typedef">>, list_to_binary(encode_alias(Def))}].
 
-do_encode_tvars(Vars) ->
-    [ do_encode_tvar(V) || V <- Vars ].
+encode_tvars(Vars) ->
+    [ encode_tvar(V) || V <- Vars ].
 
-do_encode_tvar(#tvar{name=N}) ->
-    [{<<"name">>, do_encode_name(N)}].
+encode_tvar(#tvar{name=N}) ->
+    [{<<"name">>, list_to_binary(N)}].
 
-do_encode_alias(#alias_t{type=T}) ->
-    do_encode_type(T);
-do_encode_alias(A) -> do_encode_type(A).
+encode_alias(#alias_t{type=T}) ->
+    encode_type(T);
+encode_alias(A) -> encode_type(A).
 
-%% encode_stmt(StmtAST) -> JSON.
-%%  Encode a statement AST into a JSON structure.
-
-encode_stmt(AST) ->
-    jsx:encode(do_encode_stmt(AST)).
-
-%% do_encode_stmt(StmtAST) -> JSONmap.
-
-do_encode_stmt(#typed{expr=E}) ->               %Ignore the type
-    do_encode_stmt(E);
-do_encode_stmt(#block{body=Body}) ->
-    Eblock = [ do_encode_stmt(B) || B <- Body ],
-    [{<<"block">>,Eblock}];
-do_encode_stmt(#'if'{test=Test,then=Then,else=Else}) ->
-    %% This is both a statement and en expression.
-    Etest = do_encode_expr(Test),
-    Ethen = do_encode_stmt(Then),
-    Eelse = do_encode_stmt(Else),
-    [{<<"if">>,[{<<"test">>,Etest},{<<"then">>,Ethen},{<<"else">>,Eelse}]}];
-do_encode_stmt(#letval{pat=Pat,exp=Exp}) ->
-    Epat = do_encode_expr(Pat),
-    Eexp = do_encode_expr(Exp),
-    [{<<"let">>,[{<<"pattern">>,Epat},{<<"expression">>,Eexp}]}];
-do_encode_stmt(#switch{arg=Arg,cases=Cases}) ->
-    Earg = do_encode_expr(Arg),
-    Ecases = [ do_encode_stmt_case(Case) || Case <- Cases ],
-    [{<<"switch">>,[{<<"arg">>,Earg},{<<"cases">>,Ecases}]}];
-do_encode_stmt(E) ->
-    do_encode_expr(E).
-
-do_encode_stmt_case(#'case'{pat=Pat,body=Body}) ->
-    Epat = do_encode_expr(Pat),                 %Patterns are expessions
-    Ebody = do_encode_stmt(Body),
-    [{<<"pattern">>,Epat},{<<"body">>,Ebody}].
-
-%% encode_expr(ExprAST) -> JSON.
-%%  Encode an expression AST into a JSON structure.
-
-encode_expr(AST) ->
-    jsx:encode(do_encode_expr(AST)).
-
-%% do_encode_exprs(ExprASTs) -> [JSONmap].
-%% do_encode_expr(ExprAST) -> JSONmap.
-
-do_encode_exprs(Es) ->
-    [ do_encode_expr(E) || E <- Es ].
-
-do_encode_expr(#typed{expr=E}) ->               %Ignore the type
-    do_encode_expr(E);
-do_encode_expr(#id{name=N}) -> do_encode_name(N);
-do_encode_expr(#con{name=N}) -> do_encode_name(N);
-do_encode_expr(#qid{names=Ns}) ->
-    do_encode_name(lists:join(".", Ns));
-do_encode_expr(#qcon{names=Ns}) ->
-    do_encode_name(lists:join(".", Ns));        %?
-do_encode_expr(#bool{bool=B}) -> B;
-do_encode_expr(#int{value=V}) -> V;
-do_encode_expr(#string{bin=B}) ->
-    [{<<"string">>,B}];
-do_encode_expr(#bytes{bin=B}) -> B;
-do_encode_expr(#tuple{args=As}) ->
-    Eas = do_encode_exprs(As),
-    [{<<"tuple">>,Eas}];
-do_encode_expr(#list{args=As}) ->
-    Eas = do_encode_exprs(As),
-    [{<<"list">>,Eas}];
-do_encode_expr(#record{fields=Fs}) ->           %Create a record
-    Efs = do_encode_expr_rec_fields(Fs),
-    [{<<"create_record">>,Efs}];
-do_encode_expr({record,_Ann,Rec,Fs}) ->         %Update a record
-    Erec = do_encode_expr(Rec),
-    Efs = do_encode_expr_rec_fields(Fs),
-    [{<<"update_record">>,[Erec,Efs]}];
-do_encode_expr(#lam{args=As,body=B}) ->
-    Eas = do_encode_args(As),
-    Eb = do_encode_stmt(B),
-    [{<<"function">>,[{<<"arguments">>,Eas},{<<"body">>,Eb}]}];
-do_encode_expr(#map{fields=Fs}) ->              %Create a map
-    Efs = do_encode_expr_map_fields(Fs),
-    [{<<"create_map">>,Efs}];
-do_encode_expr({map,_Ann,Map,Fs}) ->            %Update a map
-    Emap = do_encode_expr(Map),
-    Efs = do_encode_expr_map_fields(Fs),
-    [{<<"update_map">>,[Emap,Efs]}];
-do_encode_expr(#map_get{field=F}) ->
-    do_encode_expr(F);
-do_encode_expr(#proj{value=V}) ->
-    do_encode_expr(V);
-do_encode_expr(#app{func=F,args=As}) ->
-    Ef = do_encode_expr(F),
-    Eas = do_encode_exprs(As),
-    [{<<"apply">>,[{<<"function">>,Ef},
-                   {<<"arguments">>,Eas}]}];
-do_encode_expr(#'if'{test=Test,then=Then,else=Else}) ->
-    %% This is both a statement and en expression.
-    Etest = do_encode_expr(Test),
-    Ethen = do_encode_expr(Then),
-    Eelse = do_encode_expr(Else),
-    [{<<"if">>,[{<<"test">>,Etest},{<<"then">>,Ethen},{<<"else">>,Eelse}]}];
-do_encode_expr({Op,_Ann}) ->
-    list_to_binary(atom_to_list(Op)).
-
-%% do_encode_expr_rec_fields(Fields) -> [JSON].
-%% do_encode_expr_rec_field(Field) -> JSON.
-%%  Encode a record field expression.
-
-do_encode_expr_rec_fields(Fs) ->
-    [ do_encode_expr_rec_field(F) || F <- Fs ].
-
-do_encode_expr_rec_field(#field{name=[N],value=V}) ->
-    [{<<"name">>,do_encode_expr(N)},
-     {<<"value">>,do_encode_expr(V)}].
-
-%% do_encode_expr_map_fields(Fields) -> [JSON].
-%% do_encode_expr_map_field(Field) -> JSON.
-%%  Encode a map field expression.
-
-do_encode_expr_map_fields(Fs) ->
-    [ do_encode_expr_map_field(F) || F <- Fs ].
-
-do_encode_expr_map_field({K,V}) ->
-    [{<<"key">>,do_encode_expr(K)},
-     {<<"value">>,do_encode_expr(V)}];
-do_encode_expr_map_field(#field{name=[K],value=V}) ->
-    [{<<"key">>,do_encode_expr(K)},
-     {<<"value">>,do_encode_expr(V)}].
-
-%% decode_contract(JSON) -> ContractString.
+%% decode(JSON) -> ContractString.
 %%  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_contract(Json) ->
+decode(Json) ->
     Map = jsx:decode(Json, [return_maps]),
     %% io:format("~p\n", [Map]),
     #{<<"contract">> := C} = Map,
-    #{<<"name">> := Name, <<"type_defs">> := Ts, <<"functions">> := Fs} = C,
-    CS = ["contract"," ",io_lib:format("~s", [Name])," =\n",
-          do_decode_tdefs(Ts),
-          do_decode_funcs(Fs)],
-    list_to_binary(CS).
+    list_to_binary(decode_contract(C)).
 
-do_decode_funcs(Fs) -> [ do_decode_func(F) || F <- Fs ].
+decode_contract(#{<<"name">> := Name,
+                  <<"type_defs">> := _Ts,
+                  <<"functions">> := Fs}) ->
+    ["contract"," ",io_lib:format("~s", [Name])," =\n",
+     [],                                        %Don't include types yet.
+     %% decode_tdefs(Ts),
+     decode_funcs(Fs)].
 
-do_decode_func(#{<<"name">> := <<"init">>}) -> [];
-do_decode_func(#{<<"name">> := Name,<<"arguments">> := As,<<"returns">> := T}) ->
+decode_funcs(Fs) -> [ decode_func(F) || F <- Fs ].
+
+decode_func(#{<<"name">> := <<"init">>}) -> [];
+decode_func(#{<<"name">> := Name,<<"arguments">> := As,<<"type">> := T}) ->
     ["  function"," ",io_lib:format("~s", [Name])," : ",
-     do_decode_args(As)," => ",do_decode_type(T),$\n].
+     decode_args(As)," => ",decode_type(T),$\n].
 
-do_decode_args(As) ->
-    Das = [ do_decode_arg(A) || A <- As ],
+decode_type(T) -> io_lib:format("~s", [T]).
+
+decode_args(As) ->
+    Das = [ decode_arg(A) || A <- As ],
     [$(,lists:join(", ", Das),$)].
 
-do_decode_arg(#{<<"type">> := T}) -> do_decode_type(T).
-
-do_decode_types(Ets) ->
-    [ do_decode_type(Et) || Et <- Ets ].
-
-do_decode_type(#{<<"tuple">> := Ets}) ->
-    Ts = do_decode_types(Ets),
-    [$(,lists:join(", ", Ts),$)];
-do_decode_type(#{<<"record">> := Efs}) ->
-    Fs = do_decode_type_rec_fields(Efs),
-    [${,lists:join(", ", Fs),$}];
-do_decode_type(#{<<"list">> := Et}) ->
-    T = do_decode_type(Et),
-    ["list",$(,T,$)];
-do_decode_type(#{<<"map">> := Et}) ->
-    T = do_decode_type_map(Et),
-    ["map",$(,T,$)];
-do_decode_type(#{<<"variant">> := Ets}) ->
-    Ts = do_decode_types(Ets),
-    lists:join(" | ", Ts);
-do_decode_type(Econs) when is_map(Econs) ->     %General constructor
-    %% io:format("~p\n", [Econs]),
-    [{Ec,Ets}] = maps:to_list(Econs),
-    C = do_decode_name(Ec),
-    Ts = do_decode_types(Ets),
-    [C,$(,lists:join(", ", Ts),$)];
-do_decode_type(T) ->                            %Just raw names.
-    do_decode_name(T).
-
-do_decode_name(En) ->
-    binary_to_list(En).
-
-do_decode_type_rec_fields(Efs) ->
-    [ do_decode_type_rec_field(Ef) || Ef <- Efs ].
-
-do_decode_type_rec_field(#{<<"name">> := En,<<"type">> := Et}) ->
-    Name = do_decode_name(En),
-    Type = do_decode_type(Et),
-    [Name," : ",Type].
-
-do_decode_type_map(#{<<"key">> := Ek,<<"value">> := Ev}) ->
-    Key = do_decode_type(Ek),
-    Value = do_decode_type(Ev),
-    [Key,", ",Value].
-
-%% do_decode_tdefs(Json) -> [TypeString].
-%%  Here we are only interested in the type definitions and ignore the
-%%  aliases. We find them as they always have variants.
-
-do_decode_tdefs(Ts) -> [ do_decode_tdef(T) ||
-                        #{<<"typedef">> := #{<<"variant">> := _}} = T <- Ts
-                    ].
-
-do_decode_tdef(#{<<"name">> := Name,<<"vars">> := Vs,<<"typedef">> := T}) ->
-    ["  datatype"," ",do_decode_name(Name),do_decode_tvars(Vs),
-     " = ",do_decode_type(T),$\n].
-
-do_decode_tvars([]) -> [];                      %No tvars, no parentheses
-do_decode_tvars(Vs) ->
-    Dvs = [ do_decode_tvar(V) || V <- Vs ],
-    [$(,lists:join(", ", Dvs),$)].
-
-do_decode_tvar(#{<<"name">> := N}) -> io_lib:format("~s", [N]).
+decode_arg(#{<<"type">> := T}) -> decode_type(T).
 
+%% To keep dialyzer happy and quiet.
+%% decode_tdefs(Ts) -> [ decode_tdef(T) || T <- Ts ].
+%%
+%% decode_tdef(#{<<"name">> := Name,<<"vars">> := Vs,<<"typedef">> := T}) ->
+%%     ["  type"," ",io_lib:format("~s", [Name]),decode_tvars(Vs),
+%%      " = ",decode_type(T),$\n].
+%%
+%% 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]).
+%%
 %% #contract{Ann, Con, [Declarations]}.
 
 contract_name(#contract{con=#con{name=N}}) -> N.
@@ -535,9 +242,6 @@ 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
@@ -560,7 +264,7 @@ parse(Text, Options) ->
     end.
 
 parse_error(Pos, ErrorString) ->
-    %% io:format("Error ~p ~p\n", [Pos,ErrorString]),
+    io:format("Error ~p ~p\n", [Pos,ErrorString]),
     Error = io_lib:format("~s: ~s", [pos_error(Pos), ErrorString]),
     error({parse_errors, [Error]}).
 

src/aeso_ast_infer_types.erl

@@ -56,12 +56,7 @@
     , fields   :: [aeso_syntax:id()]
     , context  :: why_record() }).
 
--record(is_contract_constraint,
-    { contract_t :: utype(),
-      context    :: aeso_syntax:expr()  %% The address literal
-    }).
-
--type field_constraint() :: #field_constraint{} | #record_create_constraint{} | #is_contract_constraint{}.
+-type field_constraint() :: #field_constraint{} | #record_create_constraint{}.
 
 -record(field_info,
     { ann      :: aeso_syntax:ann()
@@ -346,7 +341,6 @@ global_env() ->
     Address = {id, Ann, "address"},
     Hash    = {id, Ann, "hash"},
     Bits    = {id, Ann, "bits"},
-    Bytes   = fun(Len) -> {bytes_t, Ann, Len} end,
     Oracle  = fun(Q, R) -> {app_t, Ann, {id, Ann, "oracle"}, [Q, R]} end,
     Query   = fun(Q, R) -> {app_t, Ann, {id, Ann, "oracle_query"}, [Q, R]} end,
     Unit    = {tuple_t, Ann, []},
@@ -379,9 +373,7 @@ global_env() ->
                      {"abort", Fun1(String, A)}])
         , types = MkDefs(
                     [{"int", 0}, {"bool", 0}, {"string", 0}, {"address", 0},
-                     {"hash", {[], {alias_t, Bytes(32)}}},
-                     {"signature", {[], {alias_t, Bytes(64)}}},
-                     {"bits", 0},
+                     {"hash", 0}, {"signature", 0}, {"bits", 0},
                      {"option", 1}, {"list", 1}, {"map", 2},
                      {"oracle", 2}, {"oracle_query", 2}
                      ]) },
@@ -447,7 +439,6 @@ global_env() ->
     CryptoScope = #scope
         { funs = MkDefs(
                      [{"ecverify", Fun([Hash, Address, SignId], Bool)},
-                      {"ecverify_secp256k1", Fun([Hash, Bytes(64), Bytes(64)], Bool)},
                       {"sha3",     Fun1(A, Hash)},
                       {"sha256",   Fun1(A, Hash)},
                       {"blake2b",  Fun1(A, Hash)}]) },
@@ -506,7 +497,7 @@ map_t(As, K, V) -> {app_t, As, {id, As, "map"}, [K, V]}.
 infer(Contracts) ->
     infer(Contracts, []).
 
--type option() :: return_env.
+-type option() :: permissive_address_literals | return_env.
 
 -spec init_env(list(option())) -> env().
 init_env(_Options) -> global_env().
@@ -684,9 +675,6 @@ check_type(Env, X = {Tag, _, _}, Arity) when Tag == con; Tag == qcon; Tag == id;
 check_type(Env, Type = {tuple_t, Ann, Types}, Arity) ->
     ensure_base_type(Type, Arity),
     {tuple_t, Ann, [ check_type(Env, T, 0) || T <- Types ]};
-check_type(_Env, Type = {bytes_t, _Ann, _Len}, Arity) ->
-    ensure_base_type(Type, Arity),
-    Type;
 check_type(Env, {app_t, Ann, Type, Types}, Arity) ->
     Types1 = [ check_type(Env, T, 0) || T <- Types ],
     Type1  = check_type(Env, Type, Arity + length(Types)),
@@ -910,29 +898,20 @@ infer_expr(_Env, Body={int, As, _}) ->
     {typed, As, Body, {id, As, "int"}};
 infer_expr(_Env, Body={string, As, _}) ->
     {typed, As, Body, {id, As, "string"}};
-infer_expr(_Env, Body={bytes, As, Bin}) ->
-    {typed, As, Body, {bytes_t, As, byte_size(Bin)}};
-infer_expr(_Env, Body={account_pubkey, As, _}) ->
-    {typed, As, Body, {id, As, "address"}};
-infer_expr(_Env, Body={oracle_pubkey, As, _}) ->
-    Q = fresh_uvar(As),
-    R = fresh_uvar(As),
-    {typed, As, Body, {app_t, As, {id, As, "oracle"}, [Q, R]}};
-infer_expr(_Env, Body={oracle_query_id, As, _}) ->
-    Q = fresh_uvar(As),
-    R = fresh_uvar(As),
-    {typed, As, Body, {app_t, As, {id, As, "oracle_query"}, [Q, R]}};
-infer_expr(_Env, Body={contract_pubkey, As, _}) ->
-    Con = fresh_uvar(As),
-    constrain([#is_contract_constraint{ contract_t = Con,
-                                        context    = Body }]),
-    {typed, As, Body, Con};
+infer_expr(_Env, Body={hash, As, Hash}) ->
+    case byte_size(Hash) of
+        32 -> {typed, As, Body, {id, As, "address"}};
+        64 -> {typed, As, Body, {id, As, "signature"}}
+    end;
 infer_expr(_Env, Body={id, As, "_"}) ->
     {typed, As, Body, fresh_uvar(As)};
-infer_expr(Env, Id = {Tag, As, _}) when Tag == id; Tag == qid ->
+infer_expr(Env, Id = {id, As, _}) ->
     {QName, Type} = lookup_name(Env, As, Id),
     {typed, As, QName, Type};
-infer_expr(Env, Id = {Tag, As, _}) when Tag == con; Tag == qcon ->
+infer_expr(Env, Id = {qid, As, _}) ->
+    {QName, Type} = lookup_name(Env, As, Id),
+    {typed, As, QName, Type};
+infer_expr(Env, Id = {con, As, _}) ->
     {QName, Type} = lookup_name(Env, As, Id, [freshen]),
     {typed, As, QName, Type};
 infer_expr(Env, {unit, As}) ->
@@ -1369,16 +1348,6 @@ check_record_create_constraints(Env, [C | Cs]) ->
     end,
     check_record_create_constraints(Env, Cs).
 
-check_is_contract_constraints(_Env, []) -> ok;
-check_is_contract_constraints(Env, [C | Cs]) ->
-    #is_contract_constraint{ contract_t = Type, context = Lit } = C,
-    Type1 = unfold_types_in_type(Env, instantiate(Type)),
-    case lookup_type(Env, record_type_name(Type1)) of
-        {_, {_Ann, {[], {contract_t, _}}}} -> ok;
-        _ -> type_error({not_a_contract_type, Type1, Lit})
-    end,
-    check_is_contract_constraints(Env, Cs).
-
 -spec solve_field_constraints(env(), [field_constraint()]) -> ok.
 solve_field_constraints(Env, Constraints) ->
     %% First look for record fields that appear in only one type definition
@@ -1477,12 +1446,9 @@ solve_known_record_types(Env, Constraints) ->
     DerefConstraints--SolvedConstraints.
 
 destroy_and_report_unsolved_field_constraints(Env) ->
-    {FieldCs, OtherCs} =
+    {FieldCs, CreateCs} =
         lists:partition(fun(#field_constraint{}) -> true; (_) -> false end,
                         get_field_constraints()),
-    {CreateCs, ContractCs} =
-        lists:partition(fun(#record_create_constraint{}) -> true; (_) -> false end,
-                        OtherCs),
     Unknown  = solve_known_record_types(Env, FieldCs),
     if Unknown == [] -> ok;
        true ->
@@ -1492,7 +1458,6 @@ destroy_and_report_unsolved_field_constraints(Env) ->
             end
     end,
     check_record_create_constraints(Env, CreateCs),
-    check_is_contract_constraints(Env, ContractCs),
     destroy_field_constraints(),
     ok.
 
@@ -1618,8 +1583,6 @@ unfold_types_in_type(Env, {field_t, Attr, Name, Type}, Options) ->
     {field_t, Attr, Name, unfold_types_in_type(Env, Type, Options)};
 unfold_types_in_type(Env, {constr_t, Ann, Con, Types}, Options) ->
     {constr_t, Ann, Con, unfold_types_in_type(Env, Types, Options)};
-unfold_types_in_type(Env, {named_arg_t, Ann, Con, Types, Default}, Options) ->
-    {named_arg_t, Ann, Con, unfold_types_in_type(Env, Types, Options), Default};
 unfold_types_in_type(Env, T, Options) when is_tuple(T) ->
     list_to_tuple(unfold_types_in_type(Env, tuple_to_list(T), Options));
 unfold_types_in_type(Env, [H|T], Options) ->
@@ -1675,8 +1638,6 @@ unify1(_Env, {qid, _, Name}, {qid, _, Name}, _When) ->
     true;
 unify1(_Env, {qcon, _, Name}, {qcon, _, Name}, _When) ->
     true;
-unify1(_Env, {bytes_t, _, Len}, {bytes_t, _, Len}, _When) ->
-    true;
 unify1(Env, {fun_t, _, Named1, Args1, Result1}, {fun_t, _, Named2, Args2, Result2}, When) ->
     unify(Env, Named1, Named2, When) andalso
     unify(Env, Args1, Args2, When) andalso unify(Env, Result1, Result2, When);
@@ -1694,8 +1655,26 @@ unify1(Env, {app_t, _, T, []}, B, When) ->
 unify1(Env, A, {app_t, _, T, []}, When) ->
     unify(Env, A, T, When);
 unify1(_Env, A, B, When) ->
-    cannot_unify(A, B, When),
-    false.
+    Ok =
+        case get_option(permissive_address_literals, false) of
+            true ->
+                Kind = fun({qcon, _, _})       -> con;
+                          ({con, _, _})        -> con;
+                          ({id, _, "address"}) -> addr;
+                          ({id, _, "hash"})    -> hash;
+                          ({app_t, _, {id, _, "oracle"}, _})       -> oracle;
+                          ({app_t, _, {id, _, "oracle_query"}, _}) -> query;
+                          (_)                  -> other end,
+                %% If permissive_address_literals we allow unifying adresses
+                %% with contract types or oracles/oracle queries
+                case lists:usort([Kind(A), Kind(B)]) of
+                    [addr, K] -> K /= other;
+                    _ -> false
+                end;
+            false -> false
+        end,
+    [ cannot_unify(A, B, When) || not Ok ],
+    Ok.
 
 dereference(T = {uvar, _, R}) ->
     case ets_lookup(type_vars, R) of
@@ -1724,7 +1703,6 @@ occurs_check1(_, {con, _, _}) -> false;
 occurs_check1(_, {qid, _, _}) -> false;
 occurs_check1(_, {qcon, _, _}) -> false;
 occurs_check1(_, {tvar, _, _}) -> false;
-occurs_check1(_, {bytes_t, _, _}) -> false;
 occurs_check1(R, {fun_t, _, Named, Args, Res}) ->
     occurs_check(R, [Res, Named | Args]);
 occurs_check1(R, {app_t, _, T, Ts}) ->
@@ -1841,11 +1819,6 @@ pp_error({undefined_field, Id}) ->
     io_lib:format("Unbound field ~s at ~s\n", [pp(Id), pp_loc(Id)]);
 pp_error({not_a_record_type, Type, Why}) ->
     io_lib:format("~s\n~s\n", [pp_type("Not a record type: ", Type), pp_why_record(Why)]);
-pp_error({not_a_contract_type, Type, Lit}) ->
-    io_lib:format("The type ~s is not a contract type\n"
-                  "when checking that the contract literal at ~s\n~s\n"
-                  "has the type\n~s\n",
-                  [pp_type("", Type), pp_loc(Lit), pp_expr("  ", Lit), pp_type("  ", Type)]);
 pp_error({non_linear_pattern, Pattern, Nonlinear}) ->
     Plural = [ $s || length(Nonlinear) > 1 ],
     io_lib:format("Repeated name~s ~s in pattern\n~s (at ~s)\n",
@@ -2070,8 +2043,6 @@ pp({qid, _, Name}) ->
     string:join(Name, ".");
 pp({con, _, Name}) ->
     Name;
-pp({qcon, _, Name}) ->
-    string:join(Name, ".");
 pp({uvar, _, Ref}) ->
     %% Show some unique representation
     ["?u" | integer_to_list(erlang:phash2(Ref, 16384)) ];
@@ -2079,8 +2050,6 @@ pp({tvar, _, Name}) ->
     Name;
 pp({tuple_t, _, Cpts}) ->
     ["(", pp(Cpts), ")"];
-pp({bytes_t, _, Len}) ->
-    ["bytes(", integer_to_list(Len), ")"];
 pp({app_t, _, T, []}) ->
     pp(T);
 pp({app_t, _, Type, Args}) ->

src/aeso_ast_to_icode.erl

@@ -346,11 +346,6 @@ ast_body(?qid_app(["Crypto", "ecverify"], [Msg, PK, Sig], _, _), Icode) ->
               [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) ->
-    prim_call(?PRIM_CALL_CRYPTO_ECVERIFY_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", "sha3"], [Term], [Type], _), Icode) ->
     generic_hash_primop(?PRIM_CALL_CRYPTO_SHA3, Term, Type, Icode);
 ast_body(?qid_app(["Crypto", "sha256"], [Term], [Type], _), Icode) ->
@@ -421,19 +416,16 @@ ast_body({bool, _, Bool}, _Icode) ->        %BOOL as ints
     #integer{value = Value};
 ast_body({int, _, Value}, _Icode) ->
     #integer{value = Value};
-ast_body({bytes, _, Bin}, _Icode) ->
-    case aeb_memory:binary_to_words(Bin) of
-        [Word] -> #integer{value = Word};
-        Words  -> #tuple{cpts = [#integer{value = W} || W <- Words]}
-    end;
-ast_body({Key, _, Bin}, _Icode) when Key == account_pubkey;
-                                     Key == contract_pubkey;
-                                     Key == oracle_pubkey;
-                                     Key == oracle_query_id ->
-    <<Value:32/unit:8>> = Bin,
+ast_body({hash, _, Hash}, _Icode) ->
+    case Hash of
+        <<Value:32/unit:8>> ->              %% address
             #integer{value = Value};
+        <<Hi:32/unit:8, Lo:32/unit:8>> ->   %% signature
+            #tuple{cpts = [#integer{value = Hi},
+                           #integer{value = Lo}]}
+    end;
 ast_body({string,_,Bin}, _Icode) ->
-    Cpts = [size(Bin) | aeb_memory:binary_to_words(Bin)],
+    Cpts = [size(Bin) | aeso_memory:binary_to_words(Bin)],
     #tuple{cpts = [#integer{value=X} || X <- Cpts]};
 ast_body({tuple,_,Args}, Icode) ->
     #tuple{cpts = [ast_body(A, Icode) || A <- Args]};
@@ -457,7 +449,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>> = aeso_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{
@@ -658,7 +650,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>> = aeso_abi:function_type_hash(PrimBin, ArgType, OutType),
                 TH;
             false ->
                 0
@@ -687,7 +679,7 @@ make_type_def(Args, Def, Icode = #{ type_vars := TypeEnv }) ->
         ast_typerep(Def, Icode#{ type_vars := maps:merge(TypeEnv, TypeEnv1) })
     end.
 
--spec ast_typerep(aeso_syntax:type()) -> aeb_aevm_data:type().
+-spec ast_typerep(aeso_syntax:type()) -> aeso_sophia:type().
 ast_typerep(Type) -> ast_typerep(Type, aeso_icode:new([])).
 
 ast_typerep({id, _, Name}, Icode) ->
@@ -696,8 +688,6 @@ ast_typerep({qid, _, Name}, Icode) ->
     lookup_type_id(Name, [], Icode);
 ast_typerep({con, _, _}, _) ->
     word;   %% Contract type
-ast_typerep({bytes_t, _, Len}, _) ->
-    {bytes, Len};
 ast_typerep({app_t, _, {id, _, Name}, Args}, Icode) ->
     ArgReps = [ ast_typerep(Arg, Icode) || Arg <- Args ],
     lookup_type_id(Name, ArgReps, Icode);
@@ -725,8 +715,8 @@ ast_typerep({variant_t, Cons}, Icode) ->
 ttl_t(Icode) ->
     ast_typerep({qid, [], ["Chain", "ttl"]}, Icode).
 
-sign_t() -> bytes_t(64).
-bytes_t(Len) -> {bytes, Len}.
+sign_t() ->
+    {tuple, [word, word]}.
 
 get_signature_arg(Args0) ->
     NamedArgs = [Arg || Arg = {named_arg, _, _, _} <- Args0],
@@ -760,8 +750,6 @@ type_value({list, A}) ->
 type_value({tuple, As}) ->
     #tuple{ cpts = [#integer{ value = ?TYPEREP_TUPLE_TAG },
                     #list{ elems = [ type_value(A) || A <- As ] }] };
-type_value({bytes, Len}) ->
-    #tuple{ cpts = [#integer{ value = ?TYPEREP_BYTES_TAG }, #integer{ value = Len }] };
 type_value({variant, Cs}) ->
     #tuple{ cpts = [#integer{ value = ?TYPEREP_VARIANT_TAG },
                     #list{ elems = [ #list{ elems = [ type_value(A) || A <- As ] } || As <- Cs ] }] };

src/aeso_builtins.erl

@@ -94,7 +94,7 @@ 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)],
+    Cpts = [size(BinStr) | aeso_memory:binary_to_words(BinStr)],
     #tuple{ cpts = [ #integer{value = X} || X <- Cpts ] }.
 
 check_event_type(Icode) ->

src/aeso_compiler.erl

@@ -104,12 +104,13 @@ from_string(ContractString, Options) ->
         %% General programming errors in the compiler just signal error.
     end.
 
--spec string_to_icode(string(), [option()]) -> map().
-string_to_icode(ContractString, Options) ->
+-spec string_to_icode(string(), [option() | permissive_address_literals]) -> map().
+string_to_icode(ContractString, Options0) ->
+    {InferOptions, Options} = lists:partition(fun(Opt) -> Opt == permissive_address_literals end, Options0),
     Ast = parse(ContractString, Options),
     pp_sophia_code(Ast, Options),
     pp_ast(Ast, Options),
-    {TypeEnv, TypedAst} = aeso_ast_infer_types:infer(Ast, [return_env]),
+    {TypeEnv, TypedAst} = aeso_ast_infer_types:infer(Ast, [return_env | InferOptions]),
     pp_typed_ast(TypedAst, Options),
     Icode = ast_to_icode(TypedAst, Options),
     pp_icode(Icode, Options),
@@ -150,11 +151,11 @@ check_call(Source, FunName, Args, Options) ->
 
 check_call(ContractString0, FunName, Args, Options, PatchFun) ->
     try
-        %% First check the contract without the __call function
+        %% First check the contract without the __call function and no permissive literals
         #{} = string_to_icode(ContractString0, Options),
         ContractString = insert_call_function(ContractString0, FunName, Args, Options),
         #{typed_ast := TypedAst,
-          icode     := Icode} = string_to_icode(ContractString, Options),
+          icode     := Icode} = string_to_icode(ContractString, [permissive_address_literals | Options]),
         {ok, {FunName, {fun_t, _, _, ArgTypes, RetType}}} = get_call_type(TypedAst),
         ArgVMTypes = [ aeso_ast_to_icode:ast_typerep(T, Icode) || T <- ArgTypes ],
         RetVMType  = case RetType of
@@ -207,7 +208,7 @@ last_contract_indent(Decls) ->
         _                     -> 0
     end.
 
--spec to_sophia_value(string(), string(), ok | error | revert, aeb_aevm_data:data()) ->
+-spec to_sophia_value(string(), string(), ok | error | revert, aeso_sophia:data()) ->
         {ok, aeso_syntax:expr()} | {error, term()}.
 to_sophia_value(ContractString, Fun, ResType, Data) ->
     to_sophia_value(ContractString, Fun, ResType, Data, []).
@@ -217,7 +218,7 @@ to_sophia_value(ContractString, Fun, ResType, Data) ->
 to_sophia_value(_, _, error, Err, _Options) ->
     {ok, {app, [], {id, [], "error"}, [{string, [], Err}]}};
 to_sophia_value(_, _, revert, Data, _Options) ->
-    case aeb_heap:from_binary(string, Data) of
+    case aeso_heap:from_binary(string, Data) of
         {ok, Err} -> {ok, {app, [], {id, [], "abort"}, [{string, [], Err}]}};
         {error, _} = Err -> Err
     end;
@@ -229,7 +230,7 @@ to_sophia_value(ContractString, FunName, ok, Data, 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 aeso_heap:from_binary(VmType, Data) of
             {ok, VmValue} ->
                 try
                     {ok, translate_vm_value(VmType, Type, VmValue)}
@@ -256,21 +257,19 @@ to_sophia_value(ContractString, FunName, ok, Data, Options) ->
                                 fun (E) -> io_lib:format("~p", [E]) end)}
     end.
 
-address_literal(Type, N) -> {Type, [], <<N:256>>}.
+address_literal(N) -> {hash, [], <<N:256>>}.  % TODO
 
 %% 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);
+-spec translate_vm_value(aeso_sophia:type(), aeso_syntax:type(), aeso_sophia:data()) -> aeso_syntax:expr().
+translate_vm_value(word,   {id, _, "address"},                     N) -> address_literal(N);
+translate_vm_value(word,   {app_t, _, {id, _, "oracle"}, _},       N) -> address_literal(N);
+translate_vm_value(word,   {app_t, _, {id, _, "oracle_query"}, _}, N) -> address_literal(N);
+translate_vm_value(word,   {id, _, "hash"},    N) -> {hash, [], <<N:256>>};
 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({bytes, Len}, {bytes_t, _, Len}, Val) when Len =< 32 ->
-    {bytes, [], <<Val:Len/unit:8>>};
-translate_vm_value({bytes, Len}, {bytes_t, _, Len}, Val) ->
-    {bytes, [], binary:part(<< <<W:32/unit:8>> || W <- tuple_to_list(Val) >>, 0, Len)};
+translate_vm_value({tuple, [word, word]}, {id, _, "signature"}, {tuple, [Hi, Lo]}) ->
+    {hash, [], <<Hi:256, Lo:256>>};
 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]};
@@ -314,12 +313,12 @@ 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()}
+                             {ok, binary(), aeso_sophia:type(), aeso_sophia:type()}
                              | {error, term()}.
 create_calldata(Code, Fun, Args) ->
     case check_call(Code, Fun, Args, []) of
         {ok, FunName, {ArgTypes, RetType}, VMArgs} ->
-            aeb_abi:create_calldata(FunName, VMArgs, ArgTypes, RetType);
+            aeso_abi:create_calldata(FunName, VMArgs, ArgTypes, RetType);
         {error, _} = Err -> Err
     end.
 
@@ -337,7 +336,7 @@ decode_calldata(ContractString, FunName, Calldata) ->
         Type0         = {tuple_t, [], ArgTypes},
         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({tuple, [word, VmType]}, Calldata) of
+        case aeso_heap:from_binary({tuple, [word, VmType]}, Calldata) of
             {ok, {_, VmValue}} ->
                 try
                     {tuple, [], Values} = translate_vm_value(VmType, Type, VmValue),
@@ -398,15 +397,11 @@ get_decode_type(FunName, [_ | Contracts]) ->
     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().
+%% consumed by aeso_heap:to_binary().
 icode_to_term(word, {integer, N}) -> N;
 icode_to_term(string, {tuple, [{integer, Len} | Words]}) ->
     <<Str:Len/binary, _/binary>> = << <<W:256>> || {integer, W} <- Words >>,
     Str;
-icode_to_term({bytes, Len}, {integer, Value}) when Len =< 32 ->
-    Value;
-icode_to_term({bytes, Len}, {tuple, Words}) when Len > 32->
-    list_to_tuple([W || {integer, W} <- Words]);
 icode_to_term({list, T}, {list, Vs}) ->
     [ icode_to_term(T, V) || V <- Vs ];
 icode_to_term({tuple, Ts}, {tuple, Vs}) ->
@@ -450,7 +445,7 @@ 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)),
+    TypeInfo = [aeso_abi:function_type_info(list_to_binary(lists:last(Name)),
                                             ArgTypesOnly(Args), TypeRep)
                 || {Name, Attrs, Args,_Body, TypeRep} <- Functions,
                    not is_tuple(Name),

src/aeso_heap.erl

@@ -0,0 +1,301 @@
+-module(aeso_heap).
+
+-export([ to_binary/1
+        , to_binary/2
+        , from_heap/3
+        , from_binary/2
+        , from_binary/3
+        , maps_with_next_id/1
+        , set_next_id/2
+        , heap_fragment/3
+        , heap_value/3
+        , heap_value/4
+        , heap_value_pointer/1
+        , heap_value_maps/1
+        , heap_value_offset/1
+        , heap_value_heap/1
+        , heap_fragment_maps/1
+        , heap_fragment_offset/1
+        , heap_fragment_heap/1
+        ]).
+
+-export_type([binary_value/0, heap_value/0, offset/0, heap_fragment/0]).
+
+-include("aeso_icode.hrl").
+-include_lib("aesophia/include/aeso_heap.hrl").
+
+-type word()            :: non_neg_integer().
+-type pointer()         :: word().
+-opaque heap_fragment() :: #heap{}.
+-type offset()          :: non_neg_integer().
+-type binary_value()    :: binary().
+-type heap_value()      :: {pointer(), heap_fragment()}.
+
+
+-spec maps_with_next_id(heap_fragment()) -> #maps{}.
+%% Create just a maps value, don't keep rest of Heap
+maps_with_next_id(#heap{maps = #maps{next_id = N}}) ->
+    #maps{ next_id = N }.
+
+-spec set_next_id(heap_fragment(), non_neg_integer()) -> heap_fragment().
+set_next_id(Heap, N) -> 
+    Heap#heap{ maps = Heap#heap.maps#maps{ next_id = N } }.
+
+%% -- data type heap_fragment
+
+-spec heap_fragment(binary() | #{non_neg_integer() => non_neg_integer()}) -> heap_fragment().
+heap_fragment(Heap) ->
+    heap_fragment(#maps{ next_id = 0 }, 0, Heap).
+
+-spec heap_fragment(#maps{}, offset(), 
+                    binary() | #{non_neg_integer() => non_neg_integer()}) -> heap_fragment().
+heap_fragment(Maps, Offset, Heap) ->
+    #heap{maps = Maps, offset = Offset, heap = Heap}.
+
+-spec heap_fragment_maps(heap_fragment()) -> #maps{}.
+heap_fragment_maps(#heap{maps = Maps}) ->
+    Maps.
+
+-spec heap_fragment_offset(heap_fragment()) -> offset().
+heap_fragment_offset(#heap{offset = Offs}) ->
+    Offs.
+
+-spec heap_fragment_heap(heap_fragment()) -> binary() | #{non_neg_integer() => non_neg_integer()}.
+heap_fragment_heap(#heap{heap = Heap}) ->
+    Heap.
+
+
+%% -- data type heap_value
+
+-spec heap_value(#maps{}, pointer(), 
+                 binary() | #{non_neg_integer() => non_neg_integer()}) -> heap_value().
+heap_value(Maps, Ptr, Heap) ->
+    heap_value(Maps, Ptr, Heap, 0).
+
+-spec heap_value(#maps{}, pointer(), 
+                 binary() | #{non_neg_integer() => non_neg_integer()}, offset()) -> heap_value().
+heap_value(Maps, Ptr, Heap, Offs) ->
+    {Ptr, heap_fragment(Maps, Offs, Heap)}.
+
+-spec heap_value_pointer(heap_value()) -> pointer().
+heap_value_pointer({Ptr, _}) -> Ptr.
+
+-spec heap_value_maps(heap_value()) -> #maps{}.
+heap_value_maps({_, Heap}) -> Heap#heap.maps.
+
+-spec heap_value_offset(heap_value()) -> offset().
+heap_value_offset({_, Heap}) -> Heap#heap.offset.
+
+-spec heap_value_heap(heap_value()) -> 
+                             binary() | #{non_neg_integer() => non_neg_integer()}.
+heap_value_heap({_, Heap}) -> Heap#heap.heap.
+    
+%% -- Value to binary --------------------------------------------------------
+
+-spec to_binary(aeso_sophia:data()) -> aeso_sophia:heap().
+%% Encode the data as a heap where the first word is the value (for unboxed
+%% types) or a pointer to the value (for boxed types).
+to_binary(Data) ->
+    to_binary(Data, 0).
+
+to_binary(Data, BaseAddress) ->
+    {Address, Memory} = to_binary1(Data, BaseAddress + 32),
+    R = <<Address:256, Memory/binary>>,
+    R.
+
+
+%% Allocate the data in memory, from the given address.  Return a pair
+%% of memory contents from that address and the value representing the
+%% data.
+to_binary1(Data,_Address) when is_integer(Data) ->
+    {Data,<<>>};
+to_binary1(Data, Address) when is_binary(Data) ->
+    %% a string
+    Words = aeso_memory:binary_to_words(Data),
+    {Address,<<(size(Data)):256, << <<W:256>> || W <- Words>>/binary>>};
+to_binary1(none, Address)            -> to_binary1({variant, 0, []}, Address);
+to_binary1({some, Value}, Address)   -> to_binary1({variant, 1, [Value]}, Address);
+to_binary1(word, Address)            -> to_binary1({?TYPEREP_WORD_TAG}, Address);
+to_binary1(string, Address)          -> to_binary1({?TYPEREP_STRING_TAG}, Address);
+to_binary1(typerep, Address)         -> to_binary1({?TYPEREP_TYPEREP_TAG}, Address);
+to_binary1(function, Address)        -> to_binary1({?TYPEREP_FUN_TAG}, Address);
+to_binary1({list, T}, Address)       -> to_binary1({?TYPEREP_LIST_TAG, T}, Address);
+to_binary1({option, T}, Address)     -> to_binary1({variant, [[], [T]]}, Address);
+to_binary1({tuple, Ts}, Address)     -> to_binary1({?TYPEREP_TUPLE_TAG, Ts}, Address);
+to_binary1({variant, Cons}, Address) -> to_binary1({?TYPEREP_VARIANT_TAG, Cons}, Address);
+to_binary1({map, K, V}, Address)     -> to_binary1({?TYPEREP_MAP_TAG, K, V}, Address);
+to_binary1({variant, Tag, Args}, Address) ->
+    to_binary1(list_to_tuple([Tag | Args]), Address);
+to_binary1(Map, Address) when is_map(Map) ->
+    Size = maps:size(Map),
+    %% Sort according to binary ordering
+    KVs = lists:sort([ {to_binary(K), to_binary(V)} || {K, V} <- maps:to_list(Map) ]),
+    {Address, <<Size:256, << <<(byte_size(K)):256, K/binary,
+                               (byte_size(V)):256, V/binary>> || {K, V} <- KVs >>/binary >>};
+to_binary1({}, _Address) ->
+    {0, <<>>};
+to_binary1(Data, Address) when is_tuple(Data) ->
+    {Elems,Memory} = to_binaries(tuple_to_list(Data),Address+32*size(Data)),
+    ElemsBin = << <<W:256>> || W <- Elems>>,
+    {Address,<< ElemsBin/binary, Memory/binary >>};
+to_binary1([],_Address) ->
+    <<Nil:256>> = <<(-1):256>>,
+    {Nil,<<>>};
+to_binary1([H|T],Address) ->
+    to_binary1({H,T},Address).
+
+
+to_binaries([],_Address) ->
+    {[],<<>>};
+to_binaries([H|T],Address) ->
+    {HRep,HMem} = to_binary1(H,Address),
+    {TRep,TMem} = to_binaries(T,Address+size(HMem)),
+    {[HRep|TRep],<<HMem/binary, TMem/binary>>}.
+
+%% Interpret a return value (a binary) using a type rep.
+
+-spec from_heap(Type :: ?Type(), Heap :: binary(), Ptr :: integer()) ->
+        {ok, term()} | {error, term()}.
+from_heap(Type, Heap, Ptr) ->
+    try {ok, from_binary(#{}, Type, Heap, Ptr)}
+    catch _:Err ->
+        %% io:format("** Error: from_heap failed with ~p\n  ~p\n", [Err, erlang:get_stacktrace()]),
+        {error, Err}
+    end.
+
+%% Base address is the address of the first word of the given heap.
+-spec from_binary(T :: ?Type(),
+                  Heap :: binary(),
+                  BaseAddr :: non_neg_integer()) ->
+        {ok, term()} | {error, term()}.
+from_binary(T, Heap = <<V:256, _/binary>>, BaseAddr) ->
+    from_heap(T, <<0:BaseAddr/unit:8, Heap/binary>>, V);
+from_binary(_, Bin, _BaseAddr) ->
+    {error, {binary_too_short, Bin}}.
+
+-spec from_binary(?Type(), binary()) -> {ok, term()} | {error, term()}.
+from_binary(T, Heap) ->
+    from_binary(T, Heap, 0).
+
+from_binary(_, word, _, V) ->
+    V;
+from_binary(_, signed_word, _, V) ->
+    <<N:256/signed>> = <<V:256>>,
+    N;
+from_binary(_, bool, _, V) ->
+    case V of
+        0 -> false;
+        1 -> true
+    end;
+from_binary(_, string, Heap, V) ->
+    StringSize = heap_word(Heap,V),
+    BitAddr = 8*(V+32),
+    <<_:BitAddr,Bytes:StringSize/binary,_/binary>> = Heap,
+    Bytes;
+from_binary(_, {tuple, []}, _, _) ->
+    {};
+from_binary(Visited, {tuple,Cpts}, Heap, V) ->
+    check_circular_refs(Visited, V),
+    NewVisited = Visited#{V => true},
+    ElementNums = lists:seq(0, length(Cpts)-1),
+    TypesAndPointers = lists:zip(Cpts, ElementNums),
+    ElementAddress = fun(Index) -> V + 32 * Index end,
+    Element = fun(Index) ->
+                      heap_word(Heap, ElementAddress(Index))
+              end,
+    Convert = fun(Type, Index) ->
+                from_binary(NewVisited, Type, Heap, Element(Index))
+              end,
+    Elements = [Convert(T, I) || {T,I} <- TypesAndPointers],
+    list_to_tuple(Elements);
+from_binary(Visited, {list, Elem}, Heap, V) ->
+    <<Nil:256>> = <<(-1):256>>,
+    if V==Nil ->
+          [];
+       true ->
+          {H,T} = from_binary(Visited, {tuple,[Elem,{list,Elem}]},Heap,V),
+          [H|T]
+    end;
+from_binary(Visited, {option, A}, Heap, V) ->
+    from_binary(Visited, {variant_t, [{none, []}, {some, [A]}]}, Heap, V);
+from_binary(Visited, {variant, Cons}, Heap, V) ->
+    Tag      = heap_word(Heap, V),
+    Args     = lists:nth(Tag + 1, Cons),
+    Visited1 = Visited#{V => true},
+    {variant, Tag, tuple_to_list(from_binary(Visited1, {tuple, Args}, Heap, V + 32))};
+from_binary(Visited, {variant_t, TCons}, Heap, V) ->   %% Tagged variants
+    {Tags, Cons} = lists:unzip(TCons),
+    {variant, I, Args} = from_binary(Visited, {variant, Cons}, Heap, V),
+    Tag = lists:nth(I + 1, Tags),
+    case Args of
+        []  -> Tag;
+        _   -> list_to_tuple([Tag | Args])
+    end;
+from_binary(_Visited, {map, A, B}, Heap, Ptr) ->
+    %% FORMAT: [Size] [KeySize] Key [ValSize] Val .. [KeySize] Key [ValSize] Val
+    Size = heap_word(Heap, Ptr),
+    map_binary_to_value(A, B, Size, Heap, Ptr + 32);
+from_binary(Visited, typerep, Heap, V) ->
+    check_circular_refs(Visited, V),
+    Tag = heap_word(Heap, V),
+    Arg1 = fun(T, I) -> from_binary(Visited#{V => true}, T, Heap, heap_word(Heap, V + 32 * I)) end,
+    Arg  = fun(T) -> Arg1(T, 1) end,
+    case Tag of
+        ?TYPEREP_WORD_TAG    -> word;
+        ?TYPEREP_STRING_TAG  -> string;
+        ?TYPEREP_TYPEREP_TAG -> typerep;
+        ?TYPEREP_LIST_TAG    -> {list,    Arg(typerep)};
+        ?TYPEREP_TUPLE_TAG   -> {tuple,   Arg({list, typerep})};
+        ?TYPEREP_VARIANT_TAG -> {variant, Arg({list, {list, typerep}})};
+        ?TYPEREP_MAP_TAG     -> {map,     Arg(typerep), Arg1(typerep, 2)};
+        ?TYPEREP_FUN_TAG     -> function
+    end.
+
+map_binary_to_value(KeyType, ValType, N, Bin, Ptr) ->
+    %% Avoid looping on bogus sizes
+    MaxN = byte_size(Bin) div 64,
+    Heap = heap_fragment(Bin),
+    map_from_binary({value, KeyType, ValType}, min(N, MaxN), Heap, Ptr, #{}).
+
+map_from_binary(_, 0, _, _, Map) -> Map;
+map_from_binary({value, KeyType, ValType} = Output, I, Heap, Ptr, Map) ->
+    KeySize = get_word(Heap, Ptr),
+    KeyPtr  = Ptr + 32,
+    KeyBin  = get_chunk(Heap, KeyPtr, KeySize),
+    ValSize = get_word(Heap, KeyPtr + KeySize),
+    ValPtr  = KeyPtr + KeySize + 32,
+    ValBin  = get_chunk(Heap, ValPtr, ValSize),
+    %% Keys and values are self contained binaries
+    {ok, Key} = from_binary(KeyType, KeyBin),
+    {ok, Val} = from_binary(ValType, ValBin),
+    map_from_binary(Output, I - 1, Heap, ValPtr + ValSize,  Map#{Key => Val}).
+
+check_circular_refs(Visited, V) ->
+    case maps:is_key(V, Visited) of
+        true ->  exit(circular_references);
+        false -> ok
+    end.
+
+heap_word(Heap, Addr) when is_binary(Heap) ->
+    BitSize = 8*Addr,
+    <<_:BitSize,W:256,_/binary>> = Heap,
+    W;
+heap_word(Heap, Addr) when is_map(Heap) ->
+    0 = Addr rem 32, %% Check that it's word aligned.
+    maps:get(Addr, Heap, 0).
+
+get_word(#heap{offset = Offs, heap = Mem}, Addr) when Addr >= Offs ->
+    get_word(Mem, Addr - Offs);
+get_word(Mem, Addr) when is_binary(Mem) ->
+    <<_:Addr/unit:8, Word:256, _/binary>> = Mem,
+    Word.
+
+get_chunk(#heap{offset = Offs, heap = Mem}, Addr, Bytes) when Addr >= Offs ->
+    get_chunk(Mem, Addr - Offs, Bytes);
+get_chunk(Mem, Addr, Bytes) when is_binary(Mem) ->
+    <<_:Addr/unit:8, Chunk:Bytes/binary, _/binary>> = Mem,
+    Chunk.
+
+
+
+

src/aeso_icode.erl

@@ -25,14 +25,14 @@
 
 -include("aeso_icode.hrl").
 
--type type_def() :: fun(([aeb_aevm_data:type()]) -> aeb_aevm_data:type()).
+-type type_def() :: fun(([aeso_sophia:type()]) -> aeso_sophia:type()).
 
 -type bindings() :: any().
 -type fun_dec() :: { string()
                    , [modifier()]
                    , arg_list()
                    , expr()
-                   , aeb_aevm_data:type()}.
+                   , aeso_sophia:type()}.
 
 -type modifier() :: private | stateful.
 
@@ -42,10 +42,10 @@
                   , functions => [fun_dec()]
                   , namespace => aeso_syntax:con() | aeso_syntax:qcon()
                   , env => [bindings()]
-                  , state_type => aeb_aevm_data:type()
-                  , event_type => aeb_aevm_data:type()
+                  , state_type => aeso_sophia:type()
+                  , event_type => aeso_sophia:type()
                   , types => #{ type_name() => type_def() }
-                  , type_vars => #{ string() => aeb_aevm_data:type() }
+                  , type_vars => #{ string() => aeso_sophia:type() }
                   , constructors => #{ [string()] => integer() }  %% name to tag
                   , options => [any()]
                   }.

src/aeso_icode.hrl

@@ -1,5 +1,14 @@
 
--include_lib("aebytecode/include/aeb_typerep_def.hrl").
+-define(Type(), aeso_sophia:type()).
+
+-define(TYPEREP_WORD_TAG,   0).
+-define(TYPEREP_STRING_TAG, 1).
+-define(TYPEREP_LIST_TAG,   2).
+-define(TYPEREP_TUPLE_TAG,  3).
+-define(TYPEREP_VARIANT_TAG, 4).
+-define(TYPEREP_TYPEREP_TAG, 5).
+-define(TYPEREP_MAP_TAG,     6).
+-define(TYPEREP_FUN_TAG,     7).
 
 -record(arg, {name::string(), type::?Type()}).
 

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>> = aeso_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_memory.erl

@@ -0,0 +1,19 @@
+%%%-------------------------------------------------------------------
+%%% @copyright (C) 2018, Aeternity Anstalt
+%%% @doc
+%%%      Memory speifics that compiler and VM need to agree upon
+%%% @end
+%%% Created : 19 Dec 2018
+%%%-------------------------------------------------------------------
+
+-module(aeso_memory).
+
+-export([binary_to_words/1]).
+
+binary_to_words(<<>>) ->
+    [];
+binary_to_words(<<N:256,Bin/binary>>) ->
+    [N|binary_to_words(Bin)];
+binary_to_words(Bin) ->
+    binary_to_words(<<Bin/binary,0>>).
+

src/aeso_parser.erl

@@ -136,15 +136,11 @@ type200() ->
 type300() -> type400().
 
 type400() ->
-    choice(
-    [?RULE(typeAtom(), optional(type_args()),
+    ?RULE(typeAtom(), optional(type_args()),
           case _2 of
             none       -> _1;
             {ok, Args} -> {app_t, get_ann(_1), _1, Args}
-          end),
-     ?RULE(id("bytes"), parens(token(int)),
-           {bytes_t, get_ann(_1), element(3, _2)})
-    ]).
+          end).
 
 typeAtom() ->
     ?LAZY_P(choice(
@@ -207,8 +203,8 @@ exprAtom() ->
     ?LAZY_P(begin
         Expr = ?LAZY_P(expr()),
         choice(
-        [ id_or_addr(), con(), token(qid), token(qcon)
-        , token(bytes), token(string), token(char)
+        [ id(), con(), token(qid), token(qcon)
+        , token(hash), token(string), token(char)
         , token(int)
         , ?RULE(token(hex), set_ann(format, hex, setelement(1, _1, int)))
         , {bool, keyword(true), true}
@@ -330,26 +326,6 @@ token(Tag) ->
         {Tok, {Line, Col}, Val} -> {Tok, pos_ann(Line, Col), Val}
     end).
 
-id(Id) ->
-    ?LET_P({id, A, X} = Y, id(),
-           if X == Id -> Y;
-              true    -> fail({A, "expected 'bytes'"})
-           end).
-
-id_or_addr() ->
-    ?RULE(id(), parse_addr_literal(_1)).
-
-parse_addr_literal(Id = {id, Ann, Name}) ->
-    case lists:member(lists:sublist(Name, 3), ["ak_", "ok_", "oq_", "ct_"]) of
-        false -> Id;
-        true  ->
-            try aeser_api_encoder:decode(list_to_binary(Name)) of
-                {Type, Bin} -> {Type, Ann, Bin}
-            catch _:_ ->
-                Id
-            end
-    end.
-
 %% -- Helpers ----------------------------------------------------------------
 
 keyword(K) -> ann(tok(K)).
@@ -481,7 +457,7 @@ parse_pattern(E = {id, _, _})     -> E;
 parse_pattern(E = {unit, _})      -> E;
 parse_pattern(E = {int, _, _})    -> E;
 parse_pattern(E = {bool, _, _})   -> E;
-parse_pattern(E = {bytes, _, _})  -> E;
+parse_pattern(E = {hash, _, _})   -> E;
 parse_pattern(E = {string, _, _}) -> E;
 parse_pattern(E = {char, _, _})   -> E;
 parse_pattern(E) -> bad_expr_err("Not a valid pattern", E).

src/aeso_pretty.erl

@@ -236,8 +236,6 @@ type({app_t, _, Type, Args}) ->
     beside(type(Type), tuple_type(Args));
 type({tuple_t, _, Args}) ->
     tuple_type(Args);
-type({bytes_t, _, Len}) ->
-    text(lists:concat(["bytes(", Len, ")"]));
 type({named_arg_t, _, Name, Type, _Default}) ->
     %% Drop the default value
     %% follow(hsep(typed(name(Name), Type), text("=")), expr(Default));
@@ -321,17 +319,8 @@ expr_p(_, E = {int, _, N}) ->
            end,
     text(S);
 expr_p(_, {bool, _, B}) -> text(atom_to_list(B));
-expr_p(_, {bytes, _, Bin}) ->
-    Digits = byte_size(Bin),
-    <<N:Digits/unit:8>> = Bin,
-    text(lists:flatten(io_lib:format("#~*.16.0b", [Digits*2, N])));
+expr_p(_, {hash, _, <<N:256>>}) -> text("#" ++ integer_to_list(N, 16));
 expr_p(_, {hash, _, <<N:512>>}) -> text("#" ++ integer_to_list(N, 16));
-expr_p(_, {Type, _, Bin})
-    when Type == account_pubkey;
-         Type == contract_pubkey;
-         Type == oracle_pubkey;
-         Type == oracle_query_id ->
-    text(binary_to_list(aeser_api_encoder:encode(Type, Bin)));
 expr_p(_, {unit, _}) -> text("()");
 expr_p(_, {string, _, S}) -> term(binary_to_list(S));
 expr_p(_, {char, _, C}) ->

src/aeso_scan.erl

@@ -20,7 +20,7 @@ lexer() ->
     CON      = [UPPER, "[a-zA-Z0-9_]*"],
     INT      = [DIGIT, "+"],
     HEX      = ["0x", HEXDIGIT, "+"],
-    BYTES    = ["#", HEXDIGIT, "+"],
+    HASH     = ["#", HEXDIGIT, "+"],
     WS       = "[\\000-\\ ]+",
     ID       = [LOWER, "[a-zA-Z0-9_']*"],
     TVAR     = ["'", ID],
@@ -54,7 +54,7 @@ lexer() ->
         , {STRING, token(string, fun parse_string/1)}
         , {HEX,    token(hex,    fun parse_hex/1)}
         , {INT,    token(int,    fun list_to_integer/1)}
-        , {BYTES,  token(bytes,  fun parse_bytes/1)}
+        , {HASH,   token(hash,   fun parse_hash/1)}
 
           %% Identifiers (qualified first!)
         , {QID,   token(qid,  fun(S) -> string:tokens(S, ".") end)}
@@ -117,8 +117,10 @@ unescape([C | Chars], Acc) ->
 
 parse_hex("0x" ++ Chars) -> list_to_integer(Chars, 16).
 
-parse_bytes("#" ++ Chars) ->
+parse_hash("#" ++ Chars) ->
     N = list_to_integer(Chars, 16),
-    Digits = (length(Chars) + 1) div 2,
-    <<N:Digits/unit:8>>.
+    case length(Chars) > 64 of  %% 64 hex digits = 32 bytes
+        true  -> <<N:64/unit:8>>;   %% signature
+        false -> <<N:32/unit:8>>    %% address
+    end.
 

src/aeso_sophia.erl

@@ -0,0 +1,30 @@
+-module(aeso_sophia).
+
+-export_type([data/0,
+              type/0,
+              heap/0]).
+
+-type type() :: word | signed_word | string | typerep | function
+              | {list,   type()}
+              | {option, type()}
+              | {tuple, [type()]}
+              | {variant, [[type()]]}.
+
+
+-type data() :: none
+              | {some,   data()}
+              | {option, data()}
+              | word
+              | string
+              | {list,   data()}
+              | {tuple, [data()]}
+              | {variant, integer(), [data()]}
+              | integer()
+              | binary()
+              | [data()]
+              | {}
+              | {data()}
+              | {data(), data()}.
+
+-type heap() :: binary().
+

src/aeso_syntax.erl

@@ -60,7 +60,6 @@
 -type type() :: {fun_t, ann(), [named_arg_t()], [type()], type()}
               | {app_t, ann(), type(), [type()]}
               | {tuple_t, ann(), [type()]}
-              | {bytes_t, ann(), integer()}
               | id()  | qid()
               | con() | qcon()  %% contracts
               | tvar().
@@ -71,10 +70,6 @@
     :: {int, ann(), integer()}
      | {bool, ann(), true | false}
      | {hash, ann(), binary()}
-     | {account_pubkey, binary()}
-     | {contract_pubkey, binary()}
-     | {oracle_pubkey, binary()}
-     | {oracle_query_id, binary()}
      | {unit, ann()}
      | {string, ann(), binary()}
      | {char, ann(), integer()}.

src/aesophia.app.src

@@ -1,6 +1,6 @@
 {application, aesophia,
  [{description, "Contract Language for aeternity"},
-  {vsn, "2.1.0"},
+  {vsn, "2.0.0"},
   {registered, []},
   {applications,
    [kernel,

test/aeso_abi_tests.erl

@@ -4,9 +4,6 @@
 -compile(export_all).
 
 -define(SANDBOX(Code), sandbox(fun() -> Code end)).
--define(DUMMY_HASH_WORD, 16#123).
--define(DUMMY_HASH, <<0:30/unit:8, 127, 119>>). %% 16#123
--define(DUMMY_HASH_LIT, "#0000000000000000000000000000000000000000000000000000000000000123").
 
 sandbox(Code) ->
     Parent = self(),
@@ -22,8 +19,8 @@ sandbox(Code) ->
 
 malicious_from_binary_test() ->
     CircularList = from_words([32, 1, 32]), %% Xs = 1 :: Xs
-    {ok, {error, circular_references}}   = ?SANDBOX(aeb_heap:from_binary({list, word}, CircularList)),
-    {ok, {error, {binary_too_short, _}}} = ?SANDBOX(aeb_heap:from_binary(word, <<1, 2, 3, 4>>)),
+    {ok, {error, circular_references}}   = ?SANDBOX(aeso_heap:from_binary({list, word}, CircularList)),
+    {ok, {error, {binary_too_short, _}}} = ?SANDBOX(aeso_heap:from_binary(word, <<1, 2, 3, 4>>)),
     ok.
 
 from_words(Ws) ->
@@ -100,15 +97,7 @@ calldata_test() ->
     Map = #{ <<"a">> => 4 },
     [{variant, 1, [Map]}, {{<<"b">>, 5}, {variant, 0, []}}] =
         encode_decode_calldata("foo", ["variant", "r"], ["Blue({[\"a\"] = 4})", "{x = (\"b\", 5), y = Red}"]),
-    [?DUMMY_HASH_WORD, 16#456] = encode_decode_calldata("foo", ["bytes(32)", "address"],
-                                                        [?DUMMY_HASH_LIT, "ak_1111111111111111111111111111113AFEFpt5"]),
-    [?DUMMY_HASH_WORD, ?DUMMY_HASH_WORD] =
-        encode_decode_calldata("foo", ["bytes(32)", "hash"], [?DUMMY_HASH_LIT, ?DUMMY_HASH_LIT]),
-
-    [119, {0, 0}] = encode_decode_calldata("foo", ["int", "signature"], ["119", [$# | lists:duplicate(128, $0)]]),
-
-    [16#456] = encode_decode_calldata("foo", ["Remote"], ["ct_1111111111111111111111111111113AFEFpt5"]),
-
+    [16#123, 16#456] = encode_decode_calldata("foo", ["hash", "address"], ["#123", "#456"]),
     ok.
 
 calldata_init_test() ->
@@ -137,9 +126,7 @@ parameterized_contract(FunName, Types) ->
 
 parameterized_contract(ExtraCode, FunName, Types) ->
     lists:flatten(
-        ["contract Remote =\n"
-         "  function bla : () => ()\n\n"
-         "contract Dummy =\n",
+        ["contract Dummy =\n",
          ExtraCode, "\n",
          "  type an_alias('a) = (string, 'a)\n"
          "  record r = {x : an_alias(int), y : variant}\n"
@@ -152,9 +139,7 @@ oracle_test() ->
         "  function 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"], []),
-
+        aeso_compiler:check_call(Contract, "question", ["#123", "#456"], []),
     ok.
 
 permissive_literals_fail_test() ->
@@ -176,7 +161,7 @@ encode_decode_calldata(FunName, Types, Args, RetType) ->
 encode_decode_calldata_(Code, FunName, Args, RetVMType) ->
     {ok, Calldata, CalldataType, RetVMType1} = aeso_compiler:create_calldata(Code, FunName, Args),
     ?assertEqual(RetVMType1, RetVMType),
-    {ok, {_Hash, ArgTuple}} = aeb_heap:from_binary(CalldataType, Calldata),
+    {ok, {_Hash, ArgTuple}} = aeso_heap:from_binary(CalldataType, Calldata),
     case FunName of
         "init" ->
             ok;
@@ -192,8 +177,8 @@ encode_decode(T, D) ->
     D.
 
 encode(D) ->
-    aeb_heap:to_binary(D).
+    aeso_heap:to_binary(D).
 
 decode(T,B) ->
-    {ok, D} = aeb_heap:from_binary(T, B),
+    {ok, D} = aeso_heap:from_binary(T, B),
     D.

test/aeso_aci_tests.erl

@@ -5,72 +5,41 @@
 
 do_test() ->
     test_contract(1),
-    test_contract(2),
-    test_contract(3).
+    test_contract(2).
 
 test_contract(N) ->
-    {Contract,MapACI,DecACI} = test_cases(N),
-    {ok,JSON} = aeso_aci:encode(Contract),
-    ?assertEqual(MapACI, jsx:decode(JSON, [return_maps])),
-    ?assertEqual(DecACI, aeso_aci:decode(JSON)).
+    {Contract,DecACI} = test_cases(N),
+    {ok,Enc} = aeso_aci:encode(Contract),
+    ?assertEqual(DecACI, jsx:decode(Enc)).
 
 test_cases(1) ->
     Contract = <<"contract C =\n"
 		 "  function a(i : int) = i+1\n">>,
-    MapACI = #{<<"contract">> =>
-		   #{<<"name">> => <<"C">>,
-		     <<"type_defs">> => [],
-		     <<"functions">> =>
-			 [#{<<"name">> => <<"a">>,
-			    <<"arguments">> => 
-				[#{<<"name">> => <<"i">>,
-				   <<"type">> => <<"int">>}],
-			    <<"returns">> => <<"int">>,
-			    <<"stateful">> => false}]}},
-    DecACI = <<"contract C =\n"
-	       "  function a : (int) => int\n">>,
-    {Contract,MapACI,DecACI};
+    DecodedACI = [{<<"contract">>,
+		   [{<<"name">>,<<"C">>},
+		    {<<"type_defs">>,[]},
+		    {<<"functions">>,
+		     [[{<<"name">>,<<"a">>},
+		       {<<"arguments">>,
+			[[{<<"name">>,<<"i">>},{<<"type">>,<<"int">>}]]},
+		       {<<"type">>,<<"int">>},
+		       {<<"stateful">>,false}]]}]}],
+    {Contract,DecodedACI};
 
 test_cases(2) ->
     Contract = <<"contract C =\n"
 		 "  type allan = int\n"
 		 "  function a(i : allan) = i+1\n">>,
-    MapACI = #{<<"contract">> =>
-                       #{<<"name">> => <<"C">>,
-                         <<"type_defs">> =>
-                             [#{<<"name">> => <<"allan">>,
-                                <<"typedef">> => <<"int">>,
-                                <<"vars">> => []}],
-			 <<"functions">> =>
-                             [#{<<"arguments">> =>
-                                    [#{<<"name">> => <<"i">>,
-                                       <<"type">> => <<"int">>}],
-                                <<"name">> => <<"a">>,
-                                <<"returns">> => <<"int">>,
-                                <<"stateful">> => false}]}},
-    DecACI = <<"contract C =\n"
-	       "  function a : (int) => int\n">>,
-    {Contract,MapACI,DecACI};
-test_cases(3) ->
-    Contract = <<"contract C =\n"
-		 "  datatype bert('a) = Bin('a)\n"
-		 "  function a(i : bert(string)) = 1\n">>,
-    MapACI = #{<<"contract">> =>
-		   #{<<"functions">> =>
-			 [#{<<"arguments">> =>
-				[#{<<"name">> => <<"i">>,
-				   <<"type">> =>
-				       #{<<"C.bert">> => [<<"string">>]}}],
-			    <<"name">> => <<"a">>,<<"returns">> => <<"int">>,
-			    <<"stateful">> => false}],
-		     <<"name">> => <<"C">>,
-		     <<"type_defs">> =>
-			 [#{<<"name">> => <<"bert">>,
-			    <<"typedef">> =>
-				#{<<"variant">> =>
-				      [#{<<"Bin">> => [<<"'a">>]}]},
-			    <<"vars">> => [#{<<"name">> => <<"'a">>}]}]}},
-    DecACI = <<"contract C =\n"
-	       "  datatype bert('a) = Bin('a)\n"
-	       "  function a : (C.bert(string)) => int\n">>,
-    {Contract,MapACI,DecACI}.
+    DecodedACI = [{<<"contract">>,
+		   [{<<"name">>,<<"C">>},
+		    {<<"type_defs">>,
+		     [[{<<"name">>,<<"allan">>},
+		       {<<"vars">>,[]},
+		       {<<"typedef">>,<<"int">>}]]},
+		    {<<"functions">>,
+		     [[{<<"name">>,<<"a">>},
+		       {<<"arguments">>,
+			[[{<<"name">>,<<"i">>},{<<"type">>,<<"int">>}]]},
+		       {<<"type">>,<<"int">>},
+		       {<<"stateful">>,false}]]}]}],
+    {Contract,DecodedACI}.

test/aeso_compiler_tests.erl

@@ -8,8 +8,6 @@
 
 -module(aeso_compiler_tests).
 
--compile([export_all, nowarn_export_all]).
-
 -include_lib("eunit/include/eunit.hrl").
 
 %%  Very simply test compile the given contracts. Only basic checks
@@ -18,14 +16,10 @@
 simple_compile_test_() ->
      [ {"Testing the " ++ ContractName ++ " contract",
         fun() ->
-            case compile(ContractName) of
             #{byte_code := ByteCode,
               contract_source := _,
-                  type_info := _} -> ?assertMatch(Code when is_binary(Code), ByteCode);
-                ErrBin ->
-                    io:format("\n~s", [ErrBin]),
-                    error(ErrBin)
-            end
+              type_info := _} = compile(ContractName),
+            ?assertMatch(Code when is_binary(Code), ByteCode)
         end} || ContractName <- compilable_contracts() ] ++
      [ {"Testing error messages of " ++ ContractName,
         fun() ->
@@ -104,9 +98,7 @@ compilable_contracts() ->
      "state_handling",
      "events",
      "include",
-     "basic_auth",
-     "bitcoin_auth",
-     "address_literals"
+     "basic_auth"
     ].
 
 %% Contracts that should produce type errors
@@ -226,80 +218,4 @@ failing_contracts() ->
     , {"bad_include_and_ns",
         [<<"Include of 'included.aes' at line 2, column 11\nnot allowed, include only allowed at top level.">>,
          <<"Nested namespace not allowed\nNamespace 'Foo' at line 3, column 13 not defined at top level.">>]}
-    , {"bad_address_literals",
-        [<<"The type bytes(32) is not a contract type\n"
-           "when checking that the contract literal at line 32, column 5\n"
-           "  ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ\n"
-           "has the type\n"
-           "  bytes(32)">>,
-         <<"The type oracle(int, bool) is not a contract type\n"
-           "when checking that the contract literal at line 30, column 5\n"
-           "  ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ\n"
-           "has the type\n"
-           "  oracle(int, bool)">>,
-         <<"The type address is not a contract type\n"
-           "when checking that the contract literal at line 28, column 5\n"
-           "  ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ\n"
-           "has the type\n"
-           "  address">>,
-         <<"Cannot unify oracle_query('1, '2)\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"
-           "against the expected type\n"
-           "  Remote">>,
-         <<"Cannot unify oracle_query('3, '4)\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"
-           "against the expected type\n"
-           "  bytes(32)">>,
-         <<"Cannot unify oracle_query('5, '6)\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"
-           "against the expected type\n"
-           "  oracle(int, bool)">>,
-         <<"Cannot unify oracle('7, '8)\n"
-           "         and Remote\n"
-           "when checking the type of the expression at line 18, column 5\n"
-           "  ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5 :\n"
-           "    oracle('7, '8)\n"
-           "against the expected type\n"
-           "  Remote">>,
-         <<"Cannot unify oracle('9, '10)\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"
-           "against the expected type\n"
-           "  bytes(32)">>,
-         <<"Cannot unify oracle('11, '12)\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"
-           "against the expected type\n"
-           "  oracle_query(int, bool)">>,
-         <<"Cannot unify address\n"
-           "         and oracle(int, bool)\n"
-           "when checking the type of the expression at line 11, column 5\n"
-           "  ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt : address\n"
-           "against the expected type\n"
-           "  oracle(int, bool)">>,
-         <<"Cannot unify address\n"
-           "         and Remote\n"
-           "when checking the type of the expression at line 9, column 5\n"
-           "  ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt : address\n"
-           "against the expected type\n"
-           "  Remote">>,
-         <<"Cannot unify address\n"
-           "         and bytes(32)\n"
-           "when checking the type of the expression at line 7, column 5\n"
-           "  ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt : address\n"
-           "against the expected type\n"
-           "  bytes(32)">>]}
     ].

test/aeso_scan_tests.erl

@@ -48,7 +48,7 @@ all_tokens() ->
     %% Literals
     [ Lit(true), Lit(false)
     , Tok(id, "foo"), Tok(id, "_"), Tok(con, "Foo")
-    , Tok(bytes, Hash)
+    , Tok(hash, Hash)
     , Tok(int, 1234567890), Tok(hex, 9876543210)
     , Tok(string, <<"bla\"\\\b\e\f\n\r\t\vbla">>)
     ].
@@ -78,7 +78,7 @@ show_token({param, _, P}) -> "@" ++ P;
 show_token({string, _, S}) -> fmt(binary_to_list(S));
 show_token({int, _, N}) -> fmt(N);
 show_token({hex, _, N}) -> fmt("0x~.16b", N);
-show_token({bytes, _, <<N:256>>}) -> fmt("#~64.16.0b", N);
+show_token({hash, _, <<N:256>>}) -> fmt("#~.16b", N);
 show_token({comment, _, S}) -> S;
 show_token({_, _, _}) -> "TODO".
 

test/contracts/address_literals.aes

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

test/contracts/bad_address_literals.aes

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

test/contracts/bitcoin_auth.aes

@@ -1,18 +0,0 @@
-contract BitcoinAuth =
-  record state = { nonce : int, owner : bytes(64) }
-
-  function init(owner' : bytes(64)) = { nonce = 1, owner = owner' }
-
-  function 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_secp256k1(to_sign(tx_hash, n), state.owner, s)
-
-  function to_sign(h : hash, n : int) : hash =
-    Crypto.blake2b((h, n))
-
-  private function require(b : bool, err : string) =
-    if(!b) abort(err)

test/contracts/fundme.aes

@@ -53,7 +53,7 @@ contract FundMe =
     require(state.total >= state.goal, "Project was not funded")
     spend({recipient = state.beneficiary,
            amount    = Contract.balance })
-    put(state{ beneficiary = ak_11111111111111111111111111111111273Yts })
+    put(state{ beneficiary = #0 })
 
   private stateful function withdraw_contributor() =
     if(state.total >= state.goal)