Factor handling of different ACI typedef cases

A lot of this complexity was a consequence of trying to avoid redundant
extraction of the namespace's/contract's name, so on the other hand
letting it be redundant made all of the complexity kind of evaporate.
Add to that that we're now building a little deep list and then
flattening it, and this logic was able to get really neat in a way that
I couldn't work out a year ago.

src/hz.erl

@@ -657,13 +657,13 @@ dry_run_map(Map) ->
 
 %% @doc
 %% Decode the "cb_XXXX" string that came out of a tx_info or dry_run, to
-%% the Erlang representation of FATE objects used by aeb_fate_encoding. See
+%% the Erlang representation of FATE objects used by gmb_fate_encoding. See
 %% decode_bytearray/2 for an alternative that provides simpler outputs based on
 %% information provided by an AACI.
 
 decode_bytearray_fate(EncodedStr) ->
     Encoded = unicode:characters_to_binary(EncodedStr),
-    {contract_bytearray, Binary} = aeser_api_encoder:decode(Encoded),
+    {contract_bytearray, Binary} = gmser_api_encoder:decode(Encoded),
     case Binary of
         <<>> -> {ok, none};
         <<"Out of gas">> -> {error, out_of_gas};
@@ -671,7 +671,7 @@ decode_bytearray_fate(EncodedStr) ->
             % FIXME there may be other errors that are encoded directly into
             % the byte array. We could try and catch to at least return
             % *something* for cases that we don't already detect.
-            Object = aeb_fate_encoding:deserialize(Binary),
+            Object = gmb_fate_encoding:deserialize(Binary),
             {ok, Object}
     end.
 
@@ -953,7 +953,7 @@ contract_create(CreatorID, Path, InitArgs) ->
 %%  </li>
 %%  <li>
 %%   <b>GasPrice:</b>
-%%   This is a factor that is used calculate a value in aettos (the smallest unit of
+%%   This is a factor that is used calculate a value in pucks (the smallest unit of
 %%   Gajumaru's currency value) for the gas consumed. In times of high contention
 %%   in the mempool increasing the gas price increases the value of mining a given
 %%   transaction, thus making miners more likely to prioritize the high value ones.
@@ -1059,14 +1059,14 @@ contract_create3(CreatorID, Nonce, Amount, TTL, Gas, GasPrice, Compiled, InitArg
 contract_create4(CreatorID, Nonce, Amount, TTL, Gas, GasPrice, Compiled, CallData) ->
     PK = unicode:characters_to_binary(CreatorID),
     try
-        {account_pubkey, OwnerID} = aeser_api_encoder:decode(PK),
+        {account_pubkey, OwnerID} = gmser_api_encoder:decode(PK),
         contract_create5(OwnerID, Nonce, Amount, TTL, Gas, GasPrice, Compiled, CallData)
     catch
         Error:Reason -> {Error, Reason}
     end.
 
 contract_create5(OwnerID, Nonce, Amount, TTL, Gas, GasPrice, Compiled, CallData) ->
-    Code = aeser_contract_code:serialize(Compiled),
+    Code = gmser_contract_code:serialize(Compiled),
     Source = maps:get(contract_source, Compiled, <<>>),
     VM = 1,
     ABI = 1,
@@ -1074,7 +1074,7 @@ contract_create5(OwnerID, Nonce, Amount, TTL, Gas, GasPrice, Compiled, CallData)
     ContractCreateVersion = 1,
     Type = contract_create_tx,
     Fields =
-        [{owner_id,   aeser_id:create(account, OwnerID)},
+        [{owner_id,   gmser_id:create(account, OwnerID)},
          {nonce,      Nonce},
          {code,       Code},
          {source,     Source},
@@ -1097,9 +1097,9 @@ contract_create5(OwnerID, Nonce, Amount, TTL, Gas, GasPrice, Compiled, CallData)
          {gas_price,  int},
          {gas,        int},
          {call_data,  binary}],
-    TXB = aeser_chain_objects:serialize(Type, ContractCreateVersion, Template, Fields),
+    TXB = gmser_chain_objects:serialize(Type, ContractCreateVersion, Template, Fields),
     try
-        {ok, aeser_api_encoder:encode(transaction, TXB)}
+        {ok, gmser_api_encoder:encode(transaction, TXB)}
     catch
         error:Reason -> {error, Reason}
     end.
@@ -1272,7 +1272,7 @@ contract_call(CallerID, Gas, AACI, ConID, Fun, Args) ->
 %%  </li>
 %%  <li>
 %%   <b>GasPrice:</b>
-%%   This is a factor that is used calculate a value in aettos (the smallest unit of
+%%   This is a factor that is used calculate a value in pucks (the smallest unit of
 %%   Gajumaru's currency value) for the gas consumed. In times of high contention
 %%   in the mempool increasing the gas price increases the value of mining a given
 %%   transaction, thus making miners more likely to prioritize the high value ones.
@@ -1330,7 +1330,7 @@ contract_call(CallerID, Nonce, Gas, GP, Amount, TTL, AACI, ConID, Fun, Args) ->
 contract_call2(CallerID, Nonce, Gas, GasPrice, Amount, TTL, ConID, CallData) ->
     CallerBin = unicode:characters_to_binary(CallerID),
     try
-        {account_pubkey, PK}  = aeser_api_encoder:decode(CallerBin),
+        {account_pubkey, PK}  = gmser_api_encoder:decode(CallerBin),
         contract_call3(PK, Nonce, Gas, GasPrice, Amount, TTL, ConID, CallData)
     catch
         Error:Reason -> {Error, Reason}
@@ -1339,7 +1339,7 @@ contract_call2(CallerID, Nonce, Gas, GasPrice, Amount, TTL, ConID, CallData) ->
 contract_call3(PK, Nonce, Gas, GasPrice, Amount, TTL, ConID, CallData) ->
     ConBin = unicode:characters_to_binary(ConID),
     try
-        {contract_pubkey, CK} = aeser_api_encoder:decode(ConBin),
+        {contract_pubkey, CK} = gmser_api_encoder:decode(ConBin),
         contract_call4(PK, Nonce, Gas, GasPrice, Amount, TTL, CK, CallData)
     catch
         Error:Reason -> {Error, Reason}
@@ -1350,9 +1350,9 @@ contract_call4(PK, Nonce, Gas, GasPrice, Amount, TTL, CK, CallData) ->
     CallVersion = 1,
     Type = contract_call_tx,
     Fields =
-        [{caller_id,   aeser_id:create(account, PK)},
+        [{caller_id,   gmser_id:create(account, PK)},
          {nonce,       Nonce},
-         {contract_id, aeser_id:create(contract, CK)},
+         {contract_id, gmser_id:create(contract, CK)},
          {abi_version, ABI},
          {ttl,         TTL},
          {amount,      Amount},
@@ -1369,9 +1369,9 @@ contract_call4(PK, Nonce, Gas, GasPrice, Amount, TTL, CK, CallData) ->
          {gas_price,   int},
          {gas,         int},
          {call_data,   binary}],
-    TXB = aeser_chain_objects:serialize(Type, CallVersion, Template, Fields),
+    TXB = gmser_chain_objects:serialize(Type, CallVersion, Template, Fields),
     try
-        {ok, aeser_api_encoder:encode(transaction, TXB)}
+        {ok, gmser_api_encoder:encode(transaction, TXB)}
     catch
         error:Reason -> {error, Reason}
     end.
@@ -1386,105 +1386,106 @@ contract_call4(PK, Nonce, Gas, GasPrice, Amount, TTL, CK, CallData) ->
 %% of calldata
 
 prepare_contract(File) ->
-    case aeso_compiler:file(File, [{aci, json}]) of
+    case gmso_compiler:file(File, [{aci, json}]) of
         {ok, #{aci := ACI}} -> {ok, prepare_aaci(ACI)};
         Error               -> Error
     end.
 
 prepare_aaci(ACI) ->
-    Types = lists:foldl(fun prepare_namespace_types/2, #{}, ACI),
+    % We want to take the types represented by the ACI, things like N1.T(N2.T),
+    % and dereference them down to concrete types like
+    % {tuple, [integer, string]}. Our type dereferencing algorithms
+    % shouldn't act directly on the JSON-based structures that the compiler
+    % gives us, though, though, so before we do the analysis, we should strip
+    % the ACI down to a list of 'opaque' type defintions and function specs.
+    {Name, OpaqueSpecs, TypeDefs} = convert_aci_types(ACI),
 
+    % Now that we have the opaque types, we can dereference the function specs
+    % down to the concrete types they actually represent. We annotate each
+    % subexpression of this concrete type with other info too, in case it helps
+    % make error messages easier to understand.
+    Specs = annotate_function_specs(OpaqueSpecs, TypeDefs, #{}),
+
+    {aaci, Name, Specs, TypeDefs}.
+
+convert_aci_types(ACI) ->
+    % Find the main contract, so we can get the specifications of its
+    % entrypoints.
     [{NameBin, SpecDefs}] =
         [{N, F}
          || #{contract := #{kind      := contract_main,
                             functions := F,
                             name      := N}} <- ACI],
     Name = binary_to_list(NameBin),
-    Specs = simplify_specs(SpecDefs, #{}, Types),
-    {aaci, Name, Specs, Types}.
+    % Turn these specifications into opaque types that we can reason about.
+    Specs = lists:map(fun convert_function_spec/1, SpecDefs),
 
-prepare_namespace_types(#{namespace := NS}, Types) ->
-    prepare_namespace_types2(NS, false, Types);
-prepare_namespace_types(#{contract := NS}, Types) ->
-    prepare_namespace_types2(NS, true, Types).
+    % These specifications can reference other type definitions from the main
+    % contract and any other namespaces, so extract these types and convert
+    % them too.
+    TypeDefTree = lists:map(fun convert_namespace_typedefs/1, ACI),
+    % The tree structure of the ACI naturally leads to a tree of opaque types,
+    % but we want a map, so flatten it out before we continue.
+    TypeDefMap = collect_opaque_types(TypeDefTree, #{}),
 
-prepare_namespace_types2(NS, IsContract, Types) ->
-    TypeDefs = maps:get(typedefs, NS),
-    NameBin = maps:get(name, NS),
+    % This is all the information we actually need from the ACI, the rest is
+    % just pre-compute and acceleration.
+    {Name, Specs, TypeDefMap}.
+
+convert_function_spec(#{name := NameBin, arguments := Args, returns := Result}) ->
     Name = binary_to_list(NameBin),
-    Types2 = case IsContract of
-                 true ->
-                     maps:put(Name, {[], contract}, Types);
-                 false ->
-                     Types
-             end,
-    Types3 = case maps:find(state, NS) of
-                 {ok, StateDefACI} ->
-                     StateDefOpaque = opaque_type([], StateDefACI),
-                     maps:put(Name ++ ".state", {[], StateDefOpaque}, Types2);
-                 error ->
-                     Types2
-             end,
-    simplify_typedefs(TypeDefs, Types3, Name ++ ".").
+    ArgTypes = lists:map(fun convert_arg/1, Args),
+    ResultType = opaque_type([], Result),
+    {Name, ArgTypes, ResultType}.
 
-simplify_typedefs([], Types, _NamePrefix) ->
-    Types;
-simplify_typedefs([Next | Rest], Types, NamePrefix) ->
-    #{name := NameBin, vars := ParamDefs, typedef := T} = Next,
-    Name = NamePrefix ++ binary_to_list(NameBin),
-    Params = [binary_to_list(Param) || #{name := Param} <- ParamDefs],
-    Type = opaque_type(Params, T),
-    NewTypes = maps:put(Name, {Params, Type}, Types),
-    simplify_typedefs(Rest, NewTypes, NamePrefix).
-
-simplify_specs([], Specs, _Types) ->
-    Specs;
-simplify_specs([Next | Rest], Specs, Types) ->
-    #{name := NameBin, arguments := ArgDefs, returns := ResultDef} = Next,
+convert_arg(#{name := NameBin, type := TypeDef}) ->
     Name = binary_to_list(NameBin),
-    ArgTypes = [simplify_args(Arg, Types) || Arg <- ArgDefs],
-    {ok, ResultType} = type(ResultDef, Types),
-    NewSpecs = maps:put(Name, {ArgTypes, ResultType}, Specs),
-    simplify_specs(Rest, NewSpecs, Types).
-
-simplify_args(#{name := NameBin, type := TypeDef}, Types) ->
-    Name = binary_to_list(NameBin),
-    % FIXME We should make this error more informative, and continue
-    % propogating it up, so that the user can provide their own ACI and find
-    % out whether it worked or not. At that point ACI -> AACI could almost be a
-    % module or package of its own.
-    {ok, Type} = type(TypeDef, Types),
+    {ok, Type} = opaque_type([], TypeDef),
     {Name, Type}.
 
-% Type preparation has two goals. First, we need a data structure that can be
-% traversed quickly, to take sophia-esque erlang expressions and turn them into
-% fate-esque erlang expressions that aebytecode can serialize. Second, we need
-% partially substituted names, so that error messages can be generated for why
-% "foobar" is not valid as the third field of a `bazquux`, because the third
-% field is supposed to be `option(integer)`, not `string`.
-%
-% To achieve this we need three representations of each type expression, which
-% together form an 'annotated type'. First, we need the fully opaque name,
-% "bazquux", then we need the normalized name, which is an opaque name with the
-% bare-minimum substitution needed to make the outer-most type-constructor an
-% identifiable built-in, ADT, or record type, and then we need the flattened
-% type, which is the raw {variant, [{Name, Fields}, ...]} or
-% {record, [{Name, Type}]} expression that can be used in actual Sophia->FATE
-% coercion. The type sub-expressions in these flattened types will each be
-% fully annotated as well, i.e. they will each contain *all three* of the above
-% representations, so that coercion of subexpressions remains fast AND
-% informative.
-%
-% In a lot of cases the opaque type given will already be normalized, in which
-% case either the normalized field or the non-normalized field of an annotated
-% type can simple be the atom `already_normalized`, which means error messages
-% can simply render the normalized type expression and know that the error will
-% make sense.
+convert_namespace_typedefs(#{namespace := NS}) ->
+    Name = namespace_name(NS),
+    convert_typedefs(NS, Name);
+convert_namespace_typedefs(#{contract := NS}) ->
+    Name = namespace_name(NS),
+    ImplicitTypes = convert_implicit_types(NS, Name),
+    ExplicitTypes = convert_typedefs(NS, Name),
+    [ImplicitTypes, ExplicitTypes].
 
-type(T, Types) ->
-    O = opaque_type([], T),
-    flatten_opaque_type(O, Types).
+namespace_name(#{name := NameBin}) ->
+    binary_to_list(NameBin).
 
+convert_implicit_types(#{state := StateDefACI}, Name) ->
+    StateDefOpaque = opaque_type([], StateDefACI),
+    [{Name, [], contract},
+     {Name ++ ".state", [], StateDefOpaque}];
+convert_implicit_types(_, Name) ->
+    [{Name, [], contract}].
+
+convert_typedefs(#{typedefs := TypeDefs}, Name) ->
+    convert_typedefs_loop(TypeDefs, Name ++ ".", []).
+
+% Take a namespace that has already had a period appended, and use that as a
+% prefix to convert and annotate a list of types.
+convert_typedefs_loop([], _NamePrefix, Converted) ->
+    Converted;
+convert_typedefs_loop([Next | Rest], NamePrefix, Converted) ->
+    #{name := NameBin, vars := ParamDefs, typedef := DefACI} = Next,
+    Name = NamePrefix ++ binary_to_list(NameBin),
+    Params = [binary_to_list(Param) || #{name := Param} <- ParamDefs],
+    Def = opaque_type(Params, DefACI),
+    convert_typedefs_loop(Rest, NamePrefix, [Converted, {Name, Params, Def}]).
+
+collect_opaque_types([], Types) ->
+    Types;
+collect_opaque_types([L | R], Types) ->
+    NewTypes = collect_opaque_types(L, Types),
+    collect_opaque_types(R, NewTypes);
+collect_opaque_types({Name, Params, Def}, Types) ->
+    maps:put(Name, {Params, Def}, Types).
+
+% Convert an ACI type defintion/spec into the 'opaque type' representation that
+% our dereferencing algorithms can reason about.
 opaque_type(Params, NameBin) when is_binary(NameBin) ->
     Name = opaque_type_name(NameBin),
     case not is_atom(Name) and lists:member(Name, Params) of
@@ -1508,7 +1509,7 @@ opaque_type(Params, Pair) when is_map(Pair) ->
     [{Name, TypeArgs}] = maps:to_list(Pair),
     {opaque_type_name(Name), [opaque_type(Params, Arg) || Arg <- TypeArgs]}.
 
-% atoms for builtins, lists for user defined types
+% atoms for builtins, strings (lists) for user-defined types
 opaque_type_name(<<"int">>)      -> integer;
 opaque_type_name(<<"address">>)  -> address;
 opaque_type_name(<<"contract">>) -> contract;
@@ -1519,16 +1520,49 @@ opaque_type_name(<<"map">>)      -> map;
 opaque_type_name(<<"string">>)   -> string;
 opaque_type_name(Name)           -> binary_to_list(Name).
 
-flatten_opaque_type(T, Types) ->
+% Type preparation has two goals. First, we need a data structure that can be
+% traversed quickly, to take sophia-esque erlang expressions and turn them into
+% fate-esque erlang expressions that gmbytecode can serialize. Second, we need
+% partially substituted names, so that error messages can be generated for why
+% "foobar" is not valid as the third field of a `bazquux`, because the third
+% field is supposed to be `option(integer)`, not `string`.
+%
+% To achieve this we need three representations of each type expression, which
+% together form an 'annotated type'. First, we need the fully opaque name,
+% "bazquux", then we need the normalized name, which is an opaque name with the
+% bare-minimum substitution needed to make the outer-most type-constructor an
+% identifiable built-in, ADT, or record type, and then we need the dereferenced
+% type, which is the raw {variant, [{Name, Fields}, ...]} or
+% {record, [{Name, Type}]} expression that can be used in actual Sophia->FATE
+% coercion. The type sub-expressions in these dereferenced types will each be
+% fully annotated as well, i.e. they will each contain *all three* of the above
+% representations, so that coercion of subexpressions remains fast and
+% informative.
+%
+% In a lot of cases the opaque type given will already be normalized, in which
+% case either the normalized field or the non-normalized field of an annotated
+% type can simple be the atom `already_normalized`, which means error messages
+% can simply render the normalized type expression and know that the error will
+% make sense.
+
+annotate_function_specs([], _Types, Specs) ->
+    Specs;
+annotate_function_specs([{Name, ArgsOpaque, ResultOpaque} | Rest], Types, Specs) ->
+    {ok, Args} = annotate_types(ArgsOpaque, Types, []),
+    {ok, Result} = annotate_type(ResultOpaque, Types),
+    NewSpecs = maps:put(Name, {Args, Result}, Specs),
+    annotate_function_specs(Rest, Types, NewSpecs).
+
+annotate_type(T, Types) ->
     case normalize_opaque_type(T, Types) of
         {ok, AlreadyNormalized, NOpaque, NExpanded} ->
-            flatten_opaque_type2(T, AlreadyNormalized, NOpaque, NExpanded, Types);
+            annotate_type2(T, AlreadyNormalized, NOpaque, NExpanded, Types);
         Error ->
             Error
     end.
 
-flatten_opaque_type2(T, AlreadyNormalized, NOpaque, NExpanded, Types) ->
-    case flatten_normalized_type(NExpanded, Types) of
+annotate_type2(T, AlreadyNormalized, NOpaque, NExpanded, Types) ->
+    case annotate_type_subexpressions(NExpanded, Types) of
         {ok, Flat} ->
             case AlreadyNormalized of
                 true -> {ok, {T, already_normalized, Flat}};
@@ -1538,48 +1572,48 @@ flatten_opaque_type2(T, AlreadyNormalized, NOpaque, NExpanded, Types) ->
             Error
     end.
 
-flatten_opaque_types([T | Rest], Types, Acc) ->
-    case flatten_opaque_type(T, Types) of
-        {ok, Type} -> flatten_opaque_types(Rest, Types, [Type | Acc]);
+annotate_types([T | Rest], Types, Acc) ->
+    case annotate_type(T, Types) of
+        {ok, Type} -> annotate_types(Rest, Types, [Type | Acc]);
         Error      -> Error
     end;
-flatten_opaque_types([], _Types, Acc) ->
+annotate_types([], _Types, Acc) ->
     {ok, lists:reverse(Acc)}.
 
-flatten_opaque_bindings([{Name, T} | Rest], Types, Acc) ->
-    case flatten_opaque_type(T, Types) of
-        {ok, Type} -> flatten_opaque_bindings(Rest, Types, [{Name, Type} | Acc]);
-        Error      -> Error
-    end;
-flatten_opaque_bindings([], _Types, Acc) ->
-    {ok, lists:reverse(Acc)}.
-
-flatten_opaque_variants([{Name, Elems} | Rest], Types, Acc) ->
-    case flatten_opaque_types(Elems, Types, []) of
-        {ok, ElemsFlat} -> flatten_opaque_variants(Rest, Types, [{Name, ElemsFlat} | Acc]);
-        Error           -> Error
-    end;
-flatten_opaque_variants([], _Types, Acc) ->
-    {ok, lists:reverse(Acc)}.
-
-flatten_normalized_type(PrimitiveType, _Types) when is_atom(PrimitiveType) ->
+annotate_type_subexpressions(PrimitiveType, _Types) when is_atom(PrimitiveType) ->
     {ok, PrimitiveType};
-flatten_normalized_type({variant, VariantsOpaque}, Types) ->
-    case flatten_opaque_variants(VariantsOpaque, Types, []) of
+annotate_type_subexpressions({variant, VariantsOpaque}, Types) ->
+    case annotate_variants(VariantsOpaque, Types, []) of
         {ok, Variants} -> {ok, {variant, Variants}};
         Error          -> Error
     end;
-flatten_normalized_type({record, FieldsOpaque}, Types) ->
-    case flatten_opaque_bindings(FieldsOpaque, Types, []) of
+annotate_type_subexpressions({record, FieldsOpaque}, Types) ->
+    case annotate_bindings(FieldsOpaque, Types, []) of
         {ok, Fields} -> {ok, {record, Fields}};
         Error        -> Error
     end;
-flatten_normalized_type({T, ElemsOpaque}, Types) ->
-    case flatten_opaque_types(ElemsOpaque, Types, []) of
+annotate_type_subexpressions({T, ElemsOpaque}, Types) ->
+    case annotate_types(ElemsOpaque, Types, []) of
         {ok, Elems} -> {ok, {T, Elems}};
         Error       -> Error
     end.
 
+annotate_bindings([{Name, T} | Rest], Types, Acc) ->
+    case annotate_type(T, Types) of
+        {ok, Type} -> annotate_bindings(Rest, Types, [{Name, Type} | Acc]);
+        Error      -> Error
+    end;
+annotate_bindings([], _Types, Acc) ->
+    {ok, lists:reverse(Acc)}.
+
+annotate_variants([{Name, Elems} | Rest], Types, Acc) ->
+    case annotate_types(Elems, Types, []) of
+        {ok, ElemsFlat} -> annotate_variants(Rest, Types, [{Name, ElemsFlat} | Acc]);
+        Error           -> Error
+    end;
+annotate_variants([], _Types, Acc) ->
+    {ok, lists:reverse(Acc)}.
+
 normalize_opaque_type(T, Types) ->
     case type_is_expanded(T) of
         false -> normalize_opaque_type(T, Types, true);
@@ -1740,7 +1774,7 @@ coerce({O, N, integer},  S, to_fate) when is_list(S) ->
     end;
 coerce({O, N, address},  S, to_fate) ->
     try
-        case aeser_api_encoder:decode(unicode:characters_to_binary(S)) of
+        case gmser_api_encoder:decode(unicode:characters_to_binary(S)) of
             {account_pubkey, Key} -> {ok, {address, Key}};
             _                     -> single_error({invalid, O, N, S})
         end
@@ -1748,11 +1782,11 @@ coerce({O, N, address},  S, to_fate) ->
         error:_ -> single_error({invalid, O, N, S})
     end;
 coerce({_, _, address}, {address, Bin}, from_fate) ->
-    Address = aeser_api_encoder:encode(account_pubkey, Bin),
+    Address = gmser_api_encoder:encode(account_pubkey, Bin),
     {ok, unicode:characters_to_list(Address)};
 coerce({O, N, contract}, S, to_fate) ->
     try
-        case aeser_api_encoder:decode(unicode:characters_to_binary(S)) of
+        case gmser_api_encoder:decode(unicode:characters_to_binary(S)) of
             {contract_pubkey, Key} -> {ok, {contract, Key}};
             _                      -> single_error({invalid, O, N, S})
         end
@@ -1760,7 +1794,7 @@ coerce({O, N, contract}, S, to_fate) ->
         error:_ -> single_error({invalid, O, N, S})
     end;
 coerce({_, _, contract}, {contract, Bin}, from_fate) ->
-    Address = aeser_api_encoder:encode(contract_pubkey, Bin),
+    Address = gmser_api_encoder:encode(contract_pubkey, Bin),
     {ok, unicode:characters_to_list(Address)};
 coerce({_, _, boolean}, true, _) ->
     {ok, true};
@@ -2027,8 +2061,7 @@ aaci_lookup_spec({aaci, _, FunDefs, _}, Fun) ->
 %% @doc
 %% This function always returns 1,000,000,000 in the current version.
 %%
-%% This is the minimum gas price returned by aec_tx_pool:minimum_miner_gas_price(),
-%% (the default set in aeternity_config_schema.json).
+%% This is the minimum gas price returned by aec_tx_pool:minimum_miner_gas_price()
 %%
 %% Surely there can be some more nuance to this, but until a "gas station" type
 %% market/chain survey service exists we will use this naive value as a default
@@ -2062,7 +2095,7 @@ encode_call_data({aaci, _ContractName, FunDefs, _TypeDefs}, Fun, Args) ->
 
 encode_call_data2(ArgDef, Fun, Args) ->
     case coerce_bindings(ArgDef, Args, to_fate) of
-        {ok, Coerced} -> aeb_fate_abi:create_calldata(Fun, Coerced);
+        {ok, Coerced} -> gmb_fate_abi:create_calldata(Fun, Coerced);
         Errors -> Errors
     end.
 
@@ -2082,7 +2115,7 @@ encode_call_data2(ArgDef, Fun, Args) ->
 %% check failed before verification was able to pass or fail (bad key encoding or similar).
 
 verify_signature(Sig, Message, PubKey) ->
-    case aeser_api_encoder:decode(PubKey) of
+    case gmser_api_encoder:decode(PubKey) of
         {account_pubkey, PK} -> verify_signature2(Sig, Message, PK);
         Other                -> {error, {bad_key, Other}}
     end.
@@ -2091,20 +2124,11 @@ verify_signature2(Sig, Message, PK) ->
     % Gajumaru signatures require messages to be salted and hashed, then
     % the hash is what gets signed in order to protect
     % the user from accidentally signing a transaction disguised as a message.
-    %
-    % Salt the message then hash with blake2b. See:
-    % 1. Erlang Blake2 blake2b/2 function:
-    %    https://gitlab.com/ioecs/eblake2/blob/60a079f00d72d1bfcc25de8e6996d28f912db3fd/src/eblake2.erl#L23-L25
-    % 2. SDK salting step:
-    %    https://gitlab.com/ioecs/aepp-sdk-js/blob/370f1e30064ad0239ba59931908d9aba0a2e86b6/src/utils/crypto.ts#L171-L175
-    % 3. SDK hashing:
-    %    https://gitlab.com/ioecs/aepp-sdk-js/blob/370f1e30064ad0239ba59931908d9aba0a2e86b6/src/utils/crypto.ts#L83-L85
     Prefix = <<"Gajumaru Signed Message:\n">>,
     {ok, PSize} = vencode(byte_size(Prefix)),
     {ok, MSize} = vencode(byte_size(Message)),
     Smashed = iolist_to_binary([PSize, Prefix, MSize, Message]),
     {ok, Hashed} = eblake2:blake2b(32, Smashed),
-%   Signature = <<(binary_to_integer(Sig, 16)):(64 * 8)>>,
     Signature = base64:decode(Sig),
     Result = ecu_eddsa:sign_verify_detached(Signature, Hashed, PK),
     {ok, Result}.
@@ -2194,11 +2218,11 @@ try_coerce(Type, Sophia, Fate) ->
     ok.
 
 coerce_int_test() ->
-    {ok, Type} = flatten_opaque_type(integer, #{}),
+    {ok, Type} = annotate_type(integer, #{}),
     try_coerce(Type, 123, 123).
 
 coerce_address_test() ->
-    {ok, Type} = flatten_opaque_type(address, #{}),
+    {ok, Type} = annotate_type(address, #{}),
     try_coerce(Type,
                "ak_2FTnrGfV8qsfHpaSEHpBrziioCpwwzLqSevHqfxQY3PaAAdARx",
                {address, <<164,136,155,90,124,22,40,206,255,76,213,56,238,123,
@@ -2206,7 +2230,7 @@ coerce_address_test() ->
                            210,39,214>>}).
 
 coerce_contract_test() ->
-    {ok, Type} = flatten_opaque_type(contract, #{}),
+    {ok, Type} = annotate_type(contract, #{}),
     try_coerce(Type,
                "ct_2FTnrGfV8qsfHpaSEHpBrziioCpwwzLqSevHqfxQY3PaAAdARx",
                {contract, <<164,136,155,90,124,22,40,206,255,76,213,56,238,123,
@@ -2214,35 +2238,35 @@ coerce_contract_test() ->
                             210,39,214>>}).
 
 coerce_bool_test() ->
-    {ok, Type} = flatten_opaque_type(boolean, #{}),
+    {ok, Type} = annotate_type(boolean, #{}),
     try_coerce(Type, true, true),
     try_coerce(Type, false, false).
 
 coerce_string_test() ->
-    {ok, Type} = flatten_opaque_type(string, #{}),
+    {ok, Type} = annotate_type(string, #{}),
     try_coerce(Type, "hello world", <<"hello world">>).
 
 coerce_list_test() ->
-    {ok, Type} = flatten_opaque_type({list, [string]}, #{}),
+    {ok, Type} = annotate_type({list, [string]}, #{}),
     try_coerce(Type, ["hello world", [65, 32, 65]], [<<"hello world">>, <<65, 32, 65>>]).
 
 coerce_map_test() ->
-    {ok, Type} = flatten_opaque_type({map, [string, {list, [integer]}]}, #{}),
+    {ok, Type} = annotate_type({map, [string, {list, [integer]}]}, #{}),
     try_coerce(Type, #{"a" => "a", "b" => "b"}, #{<<"a">> => "a", <<"b">> => "b"}).
 
 coerce_tuple_test() ->
-    {ok, Type} = flatten_opaque_type({tuple, [integer, string]}, #{}),
+    {ok, Type} = annotate_type({tuple, [integer, string]}, #{}),
     try_coerce(Type, {123, "456"}, {tuple, {123, <<"456">>}}).
 
 coerce_variant_test() ->
-    {ok, Type} = flatten_opaque_type({variant, [{"A", [integer]},
+    {ok, Type} = annotate_type({variant, [{"A", [integer]},
                                                 {"B", [integer, integer]}]},
                                      #{}),
     try_coerce(Type, {"A", 123}, {variant, [1, 2], 0, {123}}),
     try_coerce(Type, {"B", 456, 789}, {variant, [1, 2], 1, {456, 789}}).
 
 coerce_record_test() ->
-    {ok, Type} = flatten_opaque_type({record, [{"a", integer}, {"b", integer}]}, #{}),
+    {ok, Type} = annotate_type({record, [{"a", integer}, {"b", integer}]}, #{}),
     try_coerce(Type, #{"a" => 123, "b" => 456}, {tuple, {123, 456}}).
 
 

src/hz_fetcher.erl

@@ -6,8 +6,6 @@
 
 -export([connect/4, slowly_connect/4]).
 
--include("$zx_include/zx_logger.hrl").
-
 
 connect(Node = {Host, Port}, Request, From, Timeout) ->
     Timer = erlang:send_after(Timeout, self(), timeout),
@@ -236,3 +234,10 @@ url({Node, Port}, Path) when is_list(Node) ->
     ["https://", Node, ":", integer_to_list(Port), Path];
 url({Node, Port}, Path) when is_tuple(Node) ->
     ["https://", inet:ntoa(Node), ":", integer_to_list(Port), Path].
+
+
+
+log(Level, Format, Args) ->
+    Raw = io_lib:format("~w ~w: " ++ Format, [?MODULE, self() | Args]),
+    Entry = unicode:characters_to_list(Raw),
+    logger:log(Level, Entry).

src/hz_man.erl

@@ -29,8 +29,6 @@
 -export([init/1, handle_call/3, handle_cast/2, handle_info/2,
          code_change/3, terminate/2]).
 
-%% TODO: Make logging more flexible
--include("$zx_include/zx_logger.hrl").
 
 
 %%% Type and Record Definitions
@@ -197,7 +195,7 @@ handle_info({'DOWN', Mon, process, PID, Info}, State) ->
     NewState = handle_down(PID, Mon, Info, State),
     {noreply, NewState};
 handle_info(Unexpected, State) ->
-    ok = log("Unexpected info: ~tp~n", [Unexpected]),
+    ok = log(warning, "Unexpected info: ~tp~n", [Unexpected]),
     {noreply, State}.
 
 
@@ -287,3 +285,11 @@ do_request(Request,
 do_request(Request, From, State = #s{chain_nodes = {[], Used}}) ->
     Fresh = lists:reverse(Used),
     do_request(Request, From, State#s{chain_nodes = {Fresh, []}}).
+
+
+
+
+log(Level, Format, Args) ->
+    Raw = io_lib:format("~w ~w: " ++ Format, [?MODULE, self() | Args]),
+    Entry = unicode:characters_to_list(Raw),
+    logger:log(Level, Entry).