Bump gmserialization to v1.2.0

.gitignore

@@ -19,6 +19,7 @@ rebar3.crashdump
 *.erl~
 *.aes~
 aesophia
+sophia
 .qcci
 current_counterexample.eqc
 test/contracts/test.aes

rebar.config

@@ -2,7 +2,8 @@
 
 {erl_opts, [debug_info]}.
 
-{deps, [ {aebytecode, {git, "https://github.com/aeternity/aebytecode.git", {tag, "v3.4.1"}}}
+{deps, [ {gmbytecode, {git, "https://git.qpq.swiss/QPQ-AG/gmbytecode.git",
+                       {ref, "691b9742bf7e4aa6a4e8e209397916be5abe1763"}}}
        , {eblake2, "1.0.0"}
        , {jsx, {git, "https://github.com/talentdeficit/jsx.git", {tag, "2.8.0"}}}
        ]}.
@@ -13,8 +14,8 @@
             {base_plt_apps, [erts, kernel, stdlib, crypto, mnesia]}
            ]}.
 
-{relx, [{release, {aesophia, "8.0.1"},
+{relx, [{release, {sophia, "8.0.1"},
-         [aesophia, aebytecode]},
+         [sophia, gmbytecode]},
 
         {dev_mode, true},
         {include_erts, false},

rebar.lock

@@ -1,22 +1,22 @@
 {"1.2.0",
-[{<<"aebytecode">>,
+[{<<"base58">>,
-  {git,"https://github.com/aeternity/aebytecode.git",
+  {git,"https://git.qpq.swiss/QPQ-AG/erl-base58.git",
-       {ref,"6bd6f82c70d800950ea1a2c70c364a4181ff5291"}},
+       {ref,"e6aa62eeae3d4388311401f06e4b939bf4e94b9c"}},
-  0},
- {<<"aeserialization">>,
-  {git,"https://github.com/aeternity/aeserialization.git",
-       {ref,"b26e6d105424748ba1c27917267b7cff07f37802"}},
-  1},
- {<<"base58">>,
-  {git,"https://github.com/aeternity/erl-base58.git",
-       {ref,"60a335668a60328a29f9731b67c4a0e9e3d50ab6"}},
   2},
  {<<"eblake2">>,{pkg,<<"eblake2">>,<<"1.0.0">>},0},
  {<<"enacl">>,
-  {git,"https://github.com/aeternity/enacl.git",
+  {git,"https://git.qpq.swiss/QPQ-AG/enacl.git",
        {ref,"4eb7ec70084ba7c87b1af8797c4c4e90c84f95a2"}},
   2},
  {<<"getopt">>,{pkg,<<"getopt">>,<<"1.0.1">>},1},
+ {<<"gmbytecode">>,
+  {git,"https://git.qpq.swiss/QPQ-AG/gmbytecode.git",
+       {ref,"691b9742bf7e4aa6a4e8e209397916be5abe1763"}},
+  0},
+ {<<"gmserialization">>,
+  {git,"https://git.qpq.swiss/QPQ-AG/gmserialization.git",
+       {ref,"ac64e01b0f675c1a34c70a827062f381920742db"}},
+  1},
  {<<"jsx">>,
   {git,"https://github.com/talentdeficit/jsx.git",
        {ref,"3074d4865b3385a050badf7828ad31490d860df5"}},

src/aeso_ast_to_fcode.erl

@@ -784,14 +784,14 @@ expr_to_fcode(Env, _, {app, _, Fun = {typed, Ann, FunE, {fun_t, _, NamedArgsT, A
                 _ ->
                     %% Here we little cheat on the typechecker, but this inconsistency
                     %% is to be solved in `aeso_fcode_to_fate:type_to_scode/1`
-                    FInitArgsT = aeb_fate_data:make_typerep([type_to_fcode(Env, T) || T <- ArgsT]),
+                    FInitArgsT = gmb_fate_data:make_typerep([type_to_fcode(Env, T) || T <- ArgsT]),
                     builtin_to_fcode(state_layout(Env), FAnn, chain_clone, [{lit, FAnn, FInitArgsT}|FArgs])
             end;
         {builtin_u, FAnn, chain_create, _Ar} ->
             case {ArgsT, Type} of
                 {var_args, _} -> fcode_error({var_args_not_set, FunE});
                 {_, {con, _, Contract}} ->
-                    FInitArgsT = aeb_fate_data:make_typerep([type_to_fcode(Env, T) || T <- ArgsT]),
+                    FInitArgsT = gmb_fate_data:make_typerep([type_to_fcode(Env, T) || T <- ArgsT]),
                     builtin_to_fcode(state_layout(Env), FAnn, chain_create, [{lit, FAnn, {contract_code, Contract}}, {lit, FAnn, FInitArgsT}|FArgs]);
                 {_, _} -> fcode_error({not_a_contract_type, Type})
             end;

src/aeso_compiler.erl

@@ -27,7 +27,7 @@
         , validate_byte_code/3
         ]).
 
--include_lib("aebytecode/include/aeb_opcodes.hrl").
+-include_lib("gmbytecode/include/gmb_opcodes.hrl").
 -include("aeso_utils.hrl").
 
 
@@ -52,15 +52,15 @@
 
 -spec version() -> {ok, binary()} | {error, term()}.
 version() ->
-    case lists:keyfind(aesophia, 1, application:loaded_applications()) of
+    case lists:keyfind(sophia, 1, application:loaded_applications()) of
         false ->
-            case application:load(aesophia) of
+            case application:load(sophia) of
                 ok ->
-                    case application:get_key(aesophia, vsn) of
+                    case application:get_key(sophia, vsn) of
                         {ok, VsnString} ->
                             {ok, list_to_binary(VsnString)};
                         undefined ->
-                            {error, failed_to_load_aesophia}
+                            {error, failed_to_load_sophia}
                     end;
                 Err = {error, _} ->
                     Err
@@ -124,14 +124,14 @@ from_string1(ContractString, Options) ->
     SavedFreshNames = maps:get(saved_fresh_names, FCodeEnv, #{}),
     FateCode = aeso_fcode_to_fate:compile(ChildContracts, FCode, SavedFreshNames, Options),
     pp_assembler(FateCode, Options),
-    ByteCode = aeb_fate_code:serialize(FateCode, []),
+    ByteCode = gmb_fate_code:serialize(FateCode, []),
     {ok, Version} = version(),
     Res = #{byte_code => ByteCode,
             compiler_version => Version,
             contract_source => ContractString,
             type_info => [],
             fate_code => FateCode,
-            abi_version => aeb_fate_abi:abi_version(),
+            abi_version => gmb_fate_abi:abi_version(),
             payable => maps:get(payable, FCode),
             warnings => Warnings
            },
@@ -203,7 +203,7 @@ add_extra_call(Contract0, Call, Options) ->
         , ast := Ast} = string_to_code(Contract0, Options),
         FateCode = aeso_fcode_to_fate:compile(ChildContracts, OrgFcode, #{}, []),
         %% collect all hashes and compute the first name without hash collision to
-        SymbolHashes = maps:keys(aeb_fate_code:symbols(FateCode)),
+        SymbolHashes = maps:keys(gmb_fate_code:symbols(FateCode)),
         CallName = first_none_match(?CALL_NAME, SymbolHashes,
                                     lists:seq($1, $9) ++ lists:seq($A, $Z) ++ lists:seq($a, $z)),
         Contract = insert_call_function(Ast, Contract0, CallName, Call),
@@ -220,7 +220,7 @@ encode_value(Contract0, Type, Value, Options) ->
     case add_extra_call(Contract0, {value, Type, Value}, Options) of
         {ok, CallName, Code} ->
             Body = get_call_body(CallName, Code),
-            {ok, aeb_fate_encoding:serialize(aeso_fcode_to_fate:term_to_fate(Body))};
+            {ok, gmb_fate_encoding:serialize(aeso_fcode_to_fate:term_to_fate(Body))};
         Err = {error, _} ->
             Err
     end.
@@ -243,7 +243,7 @@ decode_value(Contract0, Type, FateValue, Options) ->
 first_none_match(_CallName, _Hashes, []) ->
     error(unable_to_find_unique_call_name);
 first_none_match(CallName, Hashes, [Char|Chars]) ->
-    case not lists:member(aeb_fate_code:symbol_identifier(list_to_binary(CallName)), Hashes) of
+    case not lists:member(gmb_fate_code:symbol_identifier(list_to_binary(CallName)), Hashes) of
         true ->
             CallName;
         false ->
@@ -303,7 +303,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) ->
-    try aeso_vm_decode:from_fate({id, [], "string"}, aeb_fate_encoding:deserialize(Data)) of
+    try aeso_vm_decode:from_fate({id, [], "string"}, gmb_fate_encoding:deserialize(Data)) of
         Err ->
             {ok, {app, [], {id, [], "abort"}, [Err]}}
     catch _:_ ->
@@ -328,11 +328,11 @@ to_sophia_value(ContractString, FunName, ok, Data, Options0) ->
 
 fate_data_to_sophia_value(Type, UnfoldedType, FateData) ->
     try
-        {ok, aeso_vm_decode:from_fate(UnfoldedType, aeb_fate_encoding:deserialize(FateData))}
+        {ok, aeso_vm_decode:from_fate(UnfoldedType, gmb_fate_encoding:deserialize(FateData))}
     catch throw:cannot_translate_to_sophia ->
             Type1 = prettypr:format(aeso_pretty:type(Type)),
             Msg = io_lib:format("Cannot translate FATE value ~p\n  of Sophia type ~s",
-                                [aeb_fate_encoding:deserialize(FateData), Type1]),
+                                [gmb_fate_encoding:deserialize(FateData), Type1]),
             {error, [aeso_errors:new(data_error, Msg)]};
           _:_ ->
             Type1 = prettypr:format(aeso_pretty:type(Type)),
@@ -350,7 +350,7 @@ create_calldata(Code, Fun, Args, Options0) ->
     Options = [no_code | Options0],
     case check_call(Code, Fun, Args, Options) of
         {ok, FunName, FateArgs} ->
-            aeb_fate_abi:create_calldata(FunName, FateArgs);
+            gmb_fate_abi:create_calldata(FunName, FateArgs);
         {error, _} = Err -> Err
     end.
 
@@ -377,7 +377,7 @@ decode_calldata(ContractString, FunName, Calldata, Options0) ->
                                                                   [ unfold_record_types
                                                                   , unfold_variant_types
                                                                   , not_unfold_system_alias_types]),
-        case aeb_fate_abi:decode_calldata(FunName, Calldata) of
+        case gmb_fate_abi:decode_calldata(FunName, Calldata) of
             {ok, FateArgs} ->
                 try
                     {tuple_t, [], ArgTypes1} = Type,
@@ -424,7 +424,7 @@ pp_sophia_code(C, Opts)->  pp(C, Opts, pp_sophia_code, fun(Code) ->
 pp_ast(C, Opts)      ->  pp(C, Opts, pp_ast, fun aeso_ast:pp/1).
 pp_typed_ast(C, Opts)->  pp(C, Opts, pp_typed_ast, fun aeso_ast:pp_typed/1).
 
-pp_assembler(C, Opts) ->  pp(C, Opts, pp_assembler, fun(Asm) -> io:format("~s", [aeb_fate_asm:pp(Asm)]) end).
+pp_assembler(C, Opts) ->  pp(C, Opts, pp_assembler, fun(Asm) -> io:format("~s", [gmb_fate_asm:pp(Asm)]) end).
 
 pp(Code, Options, Option, PPFun) ->
     case proplists:lookup(Option, Options) of
@@ -442,14 +442,14 @@ pp(Code, Options, Option, PPFun) ->
 validate_byte_code(#{ byte_code := ByteCode, payable := Payable }, Source, Options) ->
     Fail = fun(Err) -> {error, [aeso_errors:new(data_error, Err)]} end,
     try
-        FCode1 = ?protect(deserialize, aeb_fate_code:strip_init_function(aeb_fate_code:deserialize(ByteCode))),
+        FCode1 = ?protect(deserialize, gmb_fate_code:strip_init_function(gmb_fate_code:deserialize(ByteCode))),
         {FCode2, SrcPayable} =
             ?protect(compile,
                      begin
                          {ok, #{ byte_code := SrcByteCode, payable := SrcPayable }} =
                              from_string1(Source, Options),
-                         FCode = aeb_fate_code:deserialize(SrcByteCode),
+                         FCode = gmb_fate_code:deserialize(SrcByteCode),
-                         {aeb_fate_code:strip_init_function(FCode), SrcPayable}
+                         {gmb_fate_code:strip_init_function(FCode), SrcPayable}
                      end),
         case compare_fate_code(FCode1, FCode2) of
             ok when SrcPayable /= Payable ->
@@ -465,10 +465,10 @@ validate_byte_code(#{ byte_code := ByteCode, payable := Payable }, Source, Optio
     end.
 
 compare_fate_code(FCode1, FCode2) ->
-    Funs1 = aeb_fate_code:functions(FCode1),
+    Funs1 = gmb_fate_code:functions(FCode1),
-    Funs2 = aeb_fate_code:functions(FCode2),
+    Funs2 = gmb_fate_code:functions(FCode2),
-    Syms1 = aeb_fate_code:symbols(FCode1),
+    Syms1 = gmb_fate_code:symbols(FCode1),
-    Syms2 = aeb_fate_code:symbols(FCode2),
+    Syms2 = gmb_fate_code:symbols(FCode2),
     FunHashes1 = maps:keys(Funs1),
     FunHashes2 = maps:keys(Funs2),
     case FunHashes1 == FunHashes2 of

src/aeso_fcode_to_fate.erl

@@ -23,7 +23,7 @@
                 | loop
                 | tuple() | atom().    %% FATE instruction
 
--type arg() :: tuple(). %% Not exported: aeb_fate_ops:fate_arg().
+-type arg() :: tuple(). %% Not exported: gmb_fate_ops:fate_arg().
 
 %% Annotated scode
 -type scode_a()  :: [sinstr_a()].
@@ -87,14 +87,14 @@ compile(ChildContracts, FCode, SavedFreshNames, Options) ->
     SFuns  = functions_to_scode(ChildContracts, ContractName, Functions, SavedFreshNames, Options),
     SFuns1 = optimize_scode(SFuns, Options),
     FateCode = to_basic_blocks(SFuns1),
-    ?debug(compile, Options, "~s\n", [aeb_fate_asm:pp(FateCode)]),
+    ?debug(compile, Options, "~s\n", [gmb_fate_asm:pp(FateCode)]),
     case proplists:get_value(include_child_contract_symbols, Options, false) of
         false -> FateCode;
         true  -> add_child_symbols(ChildContracts, FateCode)
     end.
 
 make_function_id(X) ->
-    aeb_fate_code:symbol_identifier(make_function_name(X)).
+    gmb_fate_code:symbol_identifier(make_function_name(X)).
 
 make_function_name(event)              -> <<"Chain.event">>;
 make_function_name({entrypoint, Name}) -> Name;
@@ -103,7 +103,7 @@ make_function_name({local_fun, Xs})    -> list_to_binary("." ++ string:join(Xs,
 add_child_symbols(ChildContracts, FateCode) ->
     Funs = lists:flatten([ maps:keys(ChildFuns) || {_, #{functions := ChildFuns}} <- maps:to_list(ChildContracts) ]),
     Symbols = maps:from_list([ {make_function_id(FName), make_function_name(FName)} || FName <- Funs ]),
-    aeb_fate_code:update_symbols(FateCode, Symbols).
+    gmb_fate_code:update_symbols(FateCode, Symbols).
 
 functions_to_scode(ChildContracts, ContractName, Functions, SavedFreshNames, Options) ->
     FunNames = maps:keys(Functions),
@@ -212,14 +212,14 @@ serialize_contract_code(Env, C) ->
             SavedFreshNames = Env#env.saved_fresh_names,
             FCode = maps:get(C, Env#env.child_contracts),
             FateCode = compile(Env#env.child_contracts, FCode, SavedFreshNames, Options),
-            ByteCode = aeb_fate_code:serialize(FateCode, []),
+            ByteCode = gmb_fate_code:serialize(FateCode, []),
             {ok, Version} = aeso_compiler:version(),
             OriginalSourceCode = proplists:get_value(original_src, Options, ""),
             Code = #{byte_code => ByteCode,
                      compiler_version => Version,
                      source_hash => crypto:hash(sha256, OriginalSourceCode ++ [0] ++ C),
                      type_info => [],
-                     abi_version => aeb_fate_abi:abi_version(),
+                     abi_version => gmb_fate_abi:abi_version(),
                      payable => maps:get(payable, FCode)
                    },
             Serialized = aeser_contract_code:serialize(Code),
@@ -230,17 +230,17 @@ serialize_contract_code(Env, C) ->
 
 lit_to_fate(Env, L) ->
     case L of
-        {int, N}             -> aeb_fate_data:make_integer(N);
+        {int, N}             -> gmb_fate_data:make_integer(N);
-        {string, S}          -> aeb_fate_data:make_string(S);
+        {string, S}          -> gmb_fate_data:make_string(S);
-        {bytes, B}           -> aeb_fate_data:make_bytes(B);
+        {bytes, B}           -> gmb_fate_data:make_bytes(B);
-        {bool, B}            -> aeb_fate_data:make_boolean(B);
+        {bool, B}            -> gmb_fate_data:make_boolean(B);
-        {account_pubkey, K}  -> aeb_fate_data:make_address(K);
+        {account_pubkey, K}  -> gmb_fate_data:make_address(K);
-        {signature, S}       -> aeb_fate_data:make_bytes(S);
+        {signature, S}       -> gmb_fate_data:make_bytes(S);
-        {contract_pubkey, K} -> aeb_fate_data:make_contract(K);
+        {contract_pubkey, K} -> gmb_fate_data:make_contract(K);
-        {oracle_pubkey, K}   -> aeb_fate_data:make_oracle(K);
+        {oracle_pubkey, K}   -> gmb_fate_data:make_oracle(K);
-        {oracle_query_id, H} -> aeb_fate_data:make_oracle_query(H);
+        {oracle_query_id, H} -> gmb_fate_data:make_oracle_query(H);
-        {contract_code, C}   -> aeb_fate_data:make_contract_bytearray(serialize_contract_code(Env, C));
+        {contract_code, C}   -> gmb_fate_data:make_contract_bytearray(serialize_contract_code(Env, C));
-        {typerep, T}         -> aeb_fate_data:make_typerep(type_to_scode(T))
+        {typerep, T}         -> gmb_fate_data:make_typerep(type_to_scode(T))
      end.
 
 term_to_fate(E) -> term_to_fate(#env{}, #{}, E).
@@ -250,21 +250,21 @@ term_to_fate(GlobEnv, _Env, {lit, _, L}) ->
     lit_to_fate(GlobEnv, L);
 %% negative literals are parsed as 0 - N
 term_to_fate(_GlobEnv, _Env, {op, _, '-', [{lit, _, {int, 0}}, {lit, _, {int, N}}]}) ->
-    aeb_fate_data:make_integer(-N);
+    gmb_fate_data:make_integer(-N);
 term_to_fate(_GlobEnv, _Env, {nil, _}) ->
-    aeb_fate_data:make_list([]);
+    gmb_fate_data:make_list([]);
 term_to_fate(GlobEnv, Env, {op, _, '::', [Hd, Tl]}) ->
     %% The Tl will translate into a list, because FATE lists are just lists
     [term_to_fate(GlobEnv, Env, Hd) | term_to_fate(GlobEnv, Env, Tl)];
 term_to_fate(GlobEnv, Env, {tuple, _, As}) ->
-    aeb_fate_data:make_tuple(list_to_tuple([ term_to_fate(GlobEnv, Env, A) || A<-As]));
+    gmb_fate_data:make_tuple(list_to_tuple([ term_to_fate(GlobEnv, Env, A) || A<-As]));
 term_to_fate(GlobEnv, Env, {con, _, Ar, I, As}) ->
     FateAs = [ term_to_fate(GlobEnv, Env, A) || A <- As ],
-    aeb_fate_data:make_variant(Ar, I, list_to_tuple(FateAs));
+    gmb_fate_data:make_variant(Ar, I, list_to_tuple(FateAs));
 term_to_fate(_GlobEnv, _Env, {builtin, _, bits_all, []}) ->
-    aeb_fate_data:make_bits(-1);
+    gmb_fate_data:make_bits(-1);
 term_to_fate(_GlobEnv, _Env, {builtin, _, bits_none, []}) ->
-    aeb_fate_data:make_bits(0);
+    gmb_fate_data:make_bits(0);
 term_to_fate(GlobEnv, _Env, {op, _, bits_set, [B, I]}) ->
     {bits, N} = term_to_fate(GlobEnv, B),
     J         = term_to_fate(GlobEnv, I),
@@ -282,7 +282,7 @@ term_to_fate(_GlobEnv, Env, {var, _, X}) ->
         V         -> V
     end;
 term_to_fate(_GlobEnv, _Env, {builtin, _, map_empty, []}) ->
-    aeb_fate_data:make_map(#{});
+    gmb_fate_data:make_map(#{});
 term_to_fate(GlobEnv, Env, {op, _, map_set, [M, K, V]}) ->
     Map = term_to_fate(GlobEnv, Env, M),
     Map#{term_to_fate(GlobEnv, Env, K) => term_to_fate(GlobEnv, Env, V)};
@@ -304,7 +304,7 @@ to_scode1(Env, {lit, Ann, L}) ->
     [ dbg_loc(Env, Ann), push(?i(lit_to_fate(Env, L))) ];
 
 to_scode1(Env, {nil, Ann}) ->
-    [ dbg_loc(Env, Ann), aeb_fate_ops:nil(?a) ];
+    [ dbg_loc(Env, Ann), gmb_fate_ops:nil(?a) ];
 
 to_scode1(Env, {var, Ann, X}) ->
     [ dbg_loc(Env, Ann), push(lookup_var(Env, X)) ];
@@ -313,7 +313,7 @@ to_scode1(Env, {con, Ann, Ar, I, As}) ->
     N = length(As),
     [ dbg_loc(Env, Ann),
       [to_scode(notail(Env), A) || A <- As],
-      aeb_fate_ops:variant(?a, ?i(Ar), ?i(I), ?i(N)) ];
+      gmb_fate_ops:variant(?a, ?i(Ar), ?i(I), ?i(N)) ];
 
 to_scode1(Env, {tuple, Ann, As}) ->
     N = length(As),
@@ -324,13 +324,13 @@ to_scode1(Env, {tuple, Ann, As}) ->
 to_scode1(Env, {proj, Ann, E, I}) ->
     [ dbg_loc(Env, Ann),
       to_scode(notail(Env), E),
-      aeb_fate_ops:element_op(?a, ?i(I), ?a) ];
+      gmb_fate_ops:element_op(?a, ?i(I), ?a) ];
 
 to_scode1(Env, {set_proj, Ann, R, I, E}) ->
     [ dbg_loc(Env, Ann),
       to_scode(notail(Env), E),
       to_scode(notail(Env), R),
-      aeb_fate_ops:setelement(?a, ?i(I), ?a, ?a) ];
+      gmb_fate_ops:setelement(?a, ?i(I), ?a, ?a) ];
 
 to_scode1(Env, {op, Ann, Op, Args}) ->
     [ dbg_loc(Env, Ann) | call_to_scode(Env, op_to_scode(Op), Args) ];
@@ -341,7 +341,7 @@ to_scode1(Env, {'let', Ann, X, {var, _, Y}, Body}) ->
 to_scode1(Env, {'let', Ann, X, Expr, Body}) ->
     {I, Env1} = bind_local(X, Env),
     SCode = [ to_scode(notail(Env), Expr),
-              aeb_fate_ops:store({var, I}, {stack, 0}),
+              gmb_fate_ops:store({var, I}, {stack, 0}),
               to_scode(Env1, Body) ],
     [ dbg_loc(Env, Ann) | dbg_scoped_vars(Env1, [X], SCode) ];
 
@@ -355,18 +355,18 @@ to_scode1(Env = #env{ current_function = Fun, tailpos = true, debug_info = false
                         {I, Env2} = bind_local("_", Env1),
                         ArgCode   = to_scode(notail(Env2), Arg),
                         Acc1 = [Acc, ArgCode,
-                                aeb_fate_ops:store({var, I}, ?a)],
+                                gmb_fate_ops:store({var, I}, ?a)],
                         {[I | Is], Acc1, Env2}
                     end, {[], [], Env}, Args),
     [ dbg_loc(Env, Ann),
       Code,
-      [ aeb_fate_ops:store({arg, I}, {var, J})
+      [ gmb_fate_ops:store({arg, I}, {var, J})
         || {I, J} <- lists:zip(lists:seq(0, length(Vars) - 1),
                                lists:reverse(Vars)) ],
       loop ];
 to_scode1(Env, {def, Ann, Fun, Args}) ->
     FName = make_function_id(Fun),
-    Lbl   = aeb_fate_data:make_string(FName),
+    Lbl   = gmb_fate_data:make_string(FName),
     [ dbg_loc(Env, Ann) | call_to_scode(Env, local_call(Env, ?i(Lbl)), Args) ];
 to_scode1(Env, {funcall, Ann, Fun, Args}) ->
     [ dbg_loc(Env, Ann) | call_to_scode(Env, [to_scode(Env, Fun), local_call(Env, ?a)], Args) ];
@@ -377,23 +377,23 @@ to_scode1(Env, {builtin, Ann, B, Args}) ->
 to_scode1(Env, {remote, Ann, ArgsT, RetT, Ct, Fun, [Gas, Value, Protected | Args]}) ->
     Lbl = make_function_id(Fun),
     {ArgTypes, RetType0} = typesig_to_scode([{"_", T} || T <- ArgsT], RetT),
-    ArgType = ?i(aeb_fate_data:make_typerep({tuple, ArgTypes})),
+    ArgType = ?i(gmb_fate_data:make_typerep({tuple, ArgTypes})),
-    RetType = ?i(aeb_fate_data:make_typerep(RetType0)),
+    RetType = ?i(gmb_fate_data:make_typerep(RetType0)),
     SCode = case Protected of
         {lit, _, {bool, false}} ->
             case Gas of
                 {builtin, _, call_gas_left, _} ->
-                    Call = aeb_fate_ops:call_r(?a, Lbl, ArgType, RetType, ?a),
+                    Call = gmb_fate_ops:call_r(?a, Lbl, ArgType, RetType, ?a),
                     call_to_scode(Env, Call, [Ct, Value | Args]);
                 _ ->
-                    Call = aeb_fate_ops:call_gr(?a, Lbl, ArgType, RetType, ?a, ?a),
+                    Call = gmb_fate_ops:call_gr(?a, Lbl, ArgType, RetType, ?a, ?a),
                     call_to_scode(Env, Call, [Ct, Value, Gas | Args])
             end;
         {lit, _, {bool, true}} ->
-            Call = aeb_fate_ops:call_pgr(?a, Lbl, ArgType, RetType, ?a, ?a, ?i(true)),
+            Call = gmb_fate_ops:call_pgr(?a, Lbl, ArgType, RetType, ?a, ?a, ?i(true)),
             call_to_scode(Env, Call, [Ct, Value, Gas | Args]);
         _ ->
-            Call = aeb_fate_ops:call_pgr(?a, Lbl, ArgType, RetType, ?a, ?a, ?a),
+            Call = gmb_fate_ops:call_pgr(?a, Lbl, ArgType, RetType, ?a, ?a, ?a),
             call_to_scode(Env, Call, [Ct, Value, Gas, Protected | Args])
     end,
     [ dbg_loc(Env, Ann) | SCode ];
@@ -409,8 +409,8 @@ to_scode1(Env, {closure, Ann, Fun, FVs}) ->
 to_scode1(Env, {switch, Ann, Case}) ->
     [ dbg_loc(Env, Ann) | split_to_scode(Env, Case) ].
 
-local_call( Env = #env{debug_info = false}, Fun) when Env#env.tailpos -> aeb_fate_ops:call_t(Fun);
+local_call( Env = #env{debug_info = false}, Fun) when Env#env.tailpos -> gmb_fate_ops:call_t(Fun);
-local_call(_Env, Fun)                                                 -> aeb_fate_ops:call(Fun).
+local_call(_Env, Fun)                                                 -> gmb_fate_ops:call(Fun).
 
 split_to_scode(Env, {nosplit, Renames, Expr}) ->
     [switch_body, dbg_scoped_vars(Env, Renames, to_scode(Env, Expr))];
@@ -448,13 +448,13 @@ split_to_scode(Env, {split, {list, _}, X, Alts}) ->
                      [{'case', {'::', Y, Z}, S} | _] ->
                          {I, Env1} = bind_local(Y, Env),
                          {J, Env2} = bind_local(Z, Env1),
-                         [aeb_fate_ops:hd({var, I}, Arg),
+                         [gmb_fate_ops:hd({var, I}, Arg),
-                          aeb_fate_ops:tl({var, J}, Arg),
+                          gmb_fate_ops:tl({var, J}, Arg),
                           split_to_scode(Env2, S)]
                  end
              end,
     SAlts = [GetAlt('::'), GetAlt(nil)],
-    [aeb_fate_ops:is_nil(?a, Arg),
+    [gmb_fate_ops:is_nil(?a, Arg),
      {switch, ?a, boolean, SAlts, Def}];
 split_to_scode(Env, {split, Type, X, Alts}) when Type == integer; Type == string ->
     {Def, Alts1} = catchall_to_scode(Env, X, Alts),
@@ -488,9 +488,9 @@ literal_split_to_scode(Env, Type, Arg, [{'case', Lit, Body} | Alts], Def) when T
         end,
     SLit = case Lit of
                {int, N} -> N;
-               {string, S} -> aeb_fate_data:make_string(S)
+               {string, S} -> gmb_fate_data:make_string(S)
            end,
-    [aeb_fate_ops:eq(?a, Arg, ?i(SLit)),
+    [gmb_fate_ops:eq(?a, Arg, ?i(SLit)),
      {switch, ?a, boolean, [False, True], Def}].
 
 catchall_to_scode(Env, X, Alts) -> catchall_to_scode(Env, X, Alts, []).
@@ -504,10 +504,10 @@ catchall_to_scode(_, _, [], Acc) -> {missing, lists:reverse(Acc)}.
 
 %% Tuple is in the accumulator. Arguments are the variable names.
 match_tuple(Env, Arg, Xs) ->
-    match_tuple(Env, 0, fun aeb_fate_ops:element_op/3, Arg, Xs).
+    match_tuple(Env, 0, fun gmb_fate_ops:element_op/3, Arg, Xs).
 
 match_variant(Env, Arg, Xs) ->
-    Elem = fun(Dst, I, Val) -> aeb_fate_ops:variant_element(Dst, Val, I) end,
+    Elem = fun(Dst, I, Val) -> gmb_fate_ops:variant_element(Dst, Val, I) end,
     match_tuple(Env, 0, Elem, Arg, Xs).
 
 match_tuple(Env, I, Elem, Arg, ["_" | Xs]) ->
@@ -526,239 +526,239 @@ call_to_scode(Env, CallCode, Args) ->
      CallCode].
 
 builtin_to_scode(Env, chain_event, Args) ->
-    call_to_scode(Env, [erlang:apply(aeb_fate_ops, log, lists:duplicate(length(Args), ?a)),
+    call_to_scode(Env, [erlang:apply(gmb_fate_ops, log, lists:duplicate(length(Args), ?a)),
                         tuple(0)], Args);
 builtin_to_scode(_Env, map_empty, []) ->
-    [aeb_fate_ops:map_empty(?a)];
+    [gmb_fate_ops:map_empty(?a)];
 builtin_to_scode(_Env, bits_none, []) ->
-    [aeb_fate_ops:bits_none(?a)];
+    [gmb_fate_ops:bits_none(?a)];
 builtin_to_scode(_Env, bits_all, []) ->
-    [aeb_fate_ops:bits_all(?a)];
+    [gmb_fate_ops:bits_all(?a)];
 builtin_to_scode(Env, bytes_to_int, [_] = Args) ->
-    call_to_scode(Env, aeb_fate_ops:bytes_to_int(?a, ?a), Args);
+    call_to_scode(Env, gmb_fate_ops:bytes_to_int(?a, ?a), Args);
 builtin_to_scode(Env, bytes_to_str, [_] = Args) ->
-    call_to_scode(Env, aeb_fate_ops:bytes_to_str(?a, ?a), Args);
+    call_to_scode(Env, gmb_fate_ops:bytes_to_str(?a, ?a), Args);
 builtin_to_scode(Env, bytes_concat, [_, _] = Args) ->
-    call_to_scode(Env, aeb_fate_ops:bytes_concat(?a, ?a, ?a), Args);
+    call_to_scode(Env, gmb_fate_ops:bytes_concat(?a, ?a, ?a), Args);
 builtin_to_scode(Env, bytes_split, [_, _] = Args) ->
-    call_to_scode(Env, aeb_fate_ops:bytes_split(?a, ?a, ?a), Args);
+    call_to_scode(Env, gmb_fate_ops:bytes_split(?a, ?a, ?a), Args);
 builtin_to_scode(Env, bytes_split_any, [_, _] = Args) ->
-    call_to_scode(Env, aeb_fate_ops:bytes_split_any(?a, ?a, ?a), Args);
+    call_to_scode(Env, gmb_fate_ops:bytes_split_any(?a, ?a, ?a), Args);
 builtin_to_scode(Env, bytes_to_fixed_size, [_, _] = Args) ->
-    call_to_scode(Env, aeb_fate_ops:bytes_to_fixed_size(?a, ?a, ?a), Args);
+    call_to_scode(Env, gmb_fate_ops:bytes_to_fixed_size(?a, ?a, ?a), Args);
 builtin_to_scode(Env, bytes_to_any_size, [A]) ->
     [to_scode(Env, A)]; %% no_op!
 builtin_to_scode(Env, bytes_size, [_] = Args) ->
-    call_to_scode(Env, aeb_fate_ops:bytes_size(?a, ?a), Args);
+    call_to_scode(Env, gmb_fate_ops:bytes_size(?a, ?a), Args);
 builtin_to_scode(Env, abort, [_] = Args) ->
-    call_to_scode(Env, aeb_fate_ops:abort(?a), Args);
+    call_to_scode(Env, gmb_fate_ops:abort(?a), Args);
 builtin_to_scode(Env, exit, [_] = Args) ->
-    call_to_scode(Env, aeb_fate_ops:exit(?a), Args);
+    call_to_scode(Env, gmb_fate_ops:exit(?a), Args);
 builtin_to_scode(Env, chain_spend, [_, _] = Args) ->
-    call_to_scode(Env, [aeb_fate_ops:spend(?a, ?a),
+    call_to_scode(Env, [gmb_fate_ops:spend(?a, ?a),
                         tuple(0)], Args);
 builtin_to_scode(Env, chain_balance, [_] = Args) ->
-    call_to_scode(Env, aeb_fate_ops:balance_other(?a, ?a), Args);
+    call_to_scode(Env, gmb_fate_ops:balance_other(?a, ?a), Args);
 builtin_to_scode(Env, chain_block_hash, [_] = Args) ->
-    call_to_scode(Env, aeb_fate_ops:blockhash(?a, ?a), Args);
+    call_to_scode(Env, gmb_fate_ops:blockhash(?a, ?a), Args);
 builtin_to_scode(_Env, chain_coinbase, []) ->
-    [aeb_fate_ops:beneficiary(?a)];
+    [gmb_fate_ops:beneficiary(?a)];
 builtin_to_scode(_Env, chain_timestamp, []) ->
-    [aeb_fate_ops:timestamp(?a)];
+    [gmb_fate_ops:timestamp(?a)];
 builtin_to_scode(_Env, chain_block_height, []) ->
-    [aeb_fate_ops:generation(?a)];
+    [gmb_fate_ops:generation(?a)];
 builtin_to_scode(_Env, chain_difficulty, []) ->
-    [aeb_fate_ops:difficulty(?a)];
+    [gmb_fate_ops:difficulty(?a)];
 builtin_to_scode(_Env, chain_gas_limit, []) ->
-    [aeb_fate_ops:gaslimit(?a)];
+    [gmb_fate_ops:gaslimit(?a)];
 builtin_to_scode(_Env, chain_network_id, []) ->
-    [aeb_fate_ops:network_id(?a)];
+    [gmb_fate_ops:network_id(?a)];
 builtin_to_scode(_Env, contract_balance, []) ->
-    [aeb_fate_ops:balance(?a)];
+    [gmb_fate_ops:balance(?a)];
 builtin_to_scode(_Env, contract_address, []) ->
-    [aeb_fate_ops:address(?a)];
+    [gmb_fate_ops:address(?a)];
 builtin_to_scode(_Env, contract_creator, []) ->
-    [aeb_fate_ops:contract_creator(?a)];
+    [gmb_fate_ops:contract_creator(?a)];
 builtin_to_scode(_Env, call_origin, []) ->
-    [aeb_fate_ops:origin(?a)];
+    [gmb_fate_ops:origin(?a)];
 builtin_to_scode(_Env, call_caller, []) ->
-    [aeb_fate_ops:caller(?a)];
+    [gmb_fate_ops:caller(?a)];
 builtin_to_scode(_Env, call_value, []) ->
-    [aeb_fate_ops:call_value(?a)];
+    [gmb_fate_ops:call_value(?a)];
 builtin_to_scode(_Env, call_gas_price, []) ->
-    [aeb_fate_ops:gasprice(?a)];
+    [gmb_fate_ops:gasprice(?a)];
 builtin_to_scode(_Env, call_fee, []) ->
-    [aeb_fate_ops:fee(?a)];
+    [gmb_fate_ops:fee(?a)];
 builtin_to_scode(_Env, call_gas_left, []) ->
-    [aeb_fate_ops:gas(?a)];
+    [gmb_fate_ops:gas(?a)];
 builtin_to_scode(Env, oracle_register, [_Sign,_Account,_QFee,_TTL,_QType,_RType] = Args) ->
-    call_to_scode(Env, aeb_fate_ops:oracle_register(?a, ?a, ?a, ?a, ?a, ?a, ?a), Args);
+    call_to_scode(Env, gmb_fate_ops:oracle_register(?a, ?a, ?a, ?a, ?a, ?a, ?a), Args);
 builtin_to_scode(Env, oracle_expiry, [_Oracle] = Args) ->
-    call_to_scode(Env, aeb_fate_ops:oracle_expiry(?a, ?a), Args);
+    call_to_scode(Env, gmb_fate_ops:oracle_expiry(?a, ?a), Args);
 builtin_to_scode(Env, oracle_query_fee, [_Oracle] = Args) ->
-    call_to_scode(Env, aeb_fate_ops:oracle_query_fee(?a, ?a), Args);
+    call_to_scode(Env, gmb_fate_ops:oracle_query_fee(?a, ?a), Args);
 builtin_to_scode(Env, oracle_query, [_Oracle, _Question, _QFee, _QTTL, _RTTL, _QType, _RType] = Args) ->
-    call_to_scode(Env, aeb_fate_ops:oracle_query(?a, ?a, ?a, ?a, ?a, ?a, ?a, ?a), Args);
+    call_to_scode(Env, gmb_fate_ops:oracle_query(?a, ?a, ?a, ?a, ?a, ?a, ?a, ?a), Args);
 builtin_to_scode(Env, oracle_get_question, [_Oracle, _QueryId, _QType, _RType] = Args) ->
-    call_to_scode(Env, aeb_fate_ops:oracle_get_question(?a, ?a, ?a, ?a, ?a), Args);
+    call_to_scode(Env, gmb_fate_ops:oracle_get_question(?a, ?a, ?a, ?a, ?a), Args);
 builtin_to_scode(Env, oracle_respond, [_Sign, _Oracle, _QueryId, _Response, _QType, _RType] = Args) ->
-    call_to_scode(Env, [aeb_fate_ops:oracle_respond(?a, ?a, ?a, ?a, ?a, ?a),
+    call_to_scode(Env, [gmb_fate_ops:oracle_respond(?a, ?a, ?a, ?a, ?a, ?a),
                         tuple(0)], Args);
 builtin_to_scode(Env, oracle_extend, [_Sign, _Oracle, _TTL] = Args) ->
-    call_to_scode(Env, [aeb_fate_ops:oracle_extend(?a, ?a, ?a),
+    call_to_scode(Env, [gmb_fate_ops:oracle_extend(?a, ?a, ?a),
                         tuple(0)], Args);
 builtin_to_scode(Env, oracle_get_answer, [_Oracle, _QueryId, _QType, _RType] = Args) ->
-    call_to_scode(Env, aeb_fate_ops:oracle_get_answer(?a, ?a, ?a, ?a, ?a), Args);
+    call_to_scode(Env, gmb_fate_ops:oracle_get_answer(?a, ?a, ?a, ?a, ?a), Args);
 builtin_to_scode(Env, oracle_check, [_Oracle, _QType, _RType] = Args) ->
-    call_to_scode(Env, aeb_fate_ops:oracle_check(?a, ?a, ?a, ?a), Args);
+    call_to_scode(Env, gmb_fate_ops:oracle_check(?a, ?a, ?a, ?a), Args);
 builtin_to_scode(Env, oracle_check_query, [_Oracle, _Query, _QType, _RType] = Args) ->
-    call_to_scode(Env, aeb_fate_ops:oracle_check_query(?a, ?a, ?a, ?a, ?a), Args);
+    call_to_scode(Env, gmb_fate_ops:oracle_check_query(?a, ?a, ?a, ?a, ?a), Args);
 builtin_to_scode(Env, address_is_oracle, [_] = Args) ->
-    call_to_scode(Env, aeb_fate_ops:is_oracle(?a, ?a), Args);
+    call_to_scode(Env, gmb_fate_ops:is_oracle(?a, ?a), Args);
 builtin_to_scode(Env, address_is_contract, [_] = Args) ->
-    call_to_scode(Env, aeb_fate_ops:is_contract(?a, ?a), Args);
+    call_to_scode(Env, gmb_fate_ops:is_contract(?a, ?a), Args);
 builtin_to_scode(Env, address_is_payable, [_] = Args) ->
-    call_to_scode(Env, aeb_fate_ops:is_payable(?a, ?a), Args);
+    call_to_scode(Env, gmb_fate_ops:is_payable(?a, ?a), Args);
 builtin_to_scode(Env, aens_resolve, [_Name, _Key, _Type] = Args) ->
-    call_to_scode(Env, aeb_fate_ops:aens_resolve(?a, ?a, ?a, ?a), Args);
+    call_to_scode(Env, gmb_fate_ops:aens_resolve(?a, ?a, ?a, ?a), Args);
 builtin_to_scode(Env, aens_preclaim, [_Sign, _Account, _Hash] = Args) ->
-    call_to_scode(Env, [aeb_fate_ops:aens_preclaim(?a, ?a, ?a),
+    call_to_scode(Env, [gmb_fate_ops:aens_preclaim(?a, ?a, ?a),
                         tuple(0)], Args);
 builtin_to_scode(Env, aens_claim, [_Sign, _Account, _NameString, _Salt, _NameFee] = Args) ->
-    call_to_scode(Env, [aeb_fate_ops:aens_claim(?a, ?a, ?a, ?a, ?a),
+    call_to_scode(Env, [gmb_fate_ops:aens_claim(?a, ?a, ?a, ?a, ?a),
                         tuple(0)], Args);
 builtin_to_scode(Env, aens_transfer, [_Sign, _From, _To, _Name] = Args) ->
-    call_to_scode(Env, [aeb_fate_ops:aens_transfer(?a, ?a, ?a, ?a),
+    call_to_scode(Env, [gmb_fate_ops:aens_transfer(?a, ?a, ?a, ?a),
                         tuple(0)], Args);
 builtin_to_scode(Env, aens_revoke, [_Sign, _Account, _Name] = Args) ->
-    call_to_scode(Env, [aeb_fate_ops:aens_revoke(?a, ?a, ?a),
+    call_to_scode(Env, [gmb_fate_ops:aens_revoke(?a, ?a, ?a),
                         tuple(0)], Args);
 builtin_to_scode(Env, aens_update, [_Sign, _Account, _NameString, _TTL, _ClientTTL, _Pointers] = Args) ->
-    call_to_scode(Env, [aeb_fate_ops:aens_update(?a, ?a, ?a, ?a, ?a, ?a),
+    call_to_scode(Env, [gmb_fate_ops:aens_update(?a, ?a, ?a, ?a, ?a, ?a),
                         tuple(0)], Args);
 builtin_to_scode(Env, aens_lookup, [_Name] = Args) ->
-    call_to_scode(Env, aeb_fate_ops:aens_lookup(?a, ?a), Args);
+    call_to_scode(Env, gmb_fate_ops:aens_lookup(?a, ?a), Args);
 builtin_to_scode(_Env, auth_tx_hash, []) ->
-    [aeb_fate_ops:auth_tx_hash(?a)];
+    [gmb_fate_ops:auth_tx_hash(?a)];
 builtin_to_scode(_Env, auth_tx, []) ->
-    [aeb_fate_ops:auth_tx(?a)];
+    [gmb_fate_ops:auth_tx(?a)];
 builtin_to_scode(Env, chain_bytecode_hash, [_Addr] = Args) ->
-    call_to_scode(Env, aeb_fate_ops:bytecode_hash(?a, ?a), Args);
+    call_to_scode(Env, gmb_fate_ops:bytecode_hash(?a, ?a), Args);
 builtin_to_scode(Env, chain_clone,
                  [InitArgsT, GasCap, Value, Prot, Contract | InitArgs]) ->
     case GasCap of
         {builtin, _, call_gas_left, _} ->
-            call_to_scode(Env, aeb_fate_ops:clone(?a, ?a, ?a, ?a),
+            call_to_scode(Env, gmb_fate_ops:clone(?a, ?a, ?a, ?a),
                           [Contract, InitArgsT, Value, Prot | InitArgs]
                          );
         _ ->
-            call_to_scode(Env, aeb_fate_ops:clone_g(?a, ?a, ?a, ?a, ?a),
+            call_to_scode(Env, gmb_fate_ops:clone_g(?a, ?a, ?a, ?a, ?a),
                           [Contract, InitArgsT, Value, GasCap, Prot | InitArgs]
                          )
     end;
 
 builtin_to_scode(Env, chain_create,
                  [ Code, InitArgsT, Value | InitArgs]) ->
-    call_to_scode(Env, aeb_fate_ops:create(?a, ?a, ?a),
+    call_to_scode(Env, gmb_fate_ops:create(?a, ?a, ?a),
                   [Code, InitArgsT, Value | InitArgs]
                  ).
 
 %% -- Operators --
 
-op_to_scode('+')               -> aeb_fate_ops:add(?a, ?a, ?a);
+op_to_scode('+')               -> gmb_fate_ops:add(?a, ?a, ?a);
-op_to_scode('-')               -> aeb_fate_ops:sub(?a, ?a, ?a);
+op_to_scode('-')               -> gmb_fate_ops:sub(?a, ?a, ?a);
-op_to_scode('*')               -> aeb_fate_ops:mul(?a, ?a, ?a);
+op_to_scode('*')               -> gmb_fate_ops:mul(?a, ?a, ?a);
-op_to_scode('/')               -> aeb_fate_ops:divide(?a, ?a, ?a);
+op_to_scode('/')               -> gmb_fate_ops:divide(?a, ?a, ?a);
-op_to_scode(mod)               -> aeb_fate_ops:modulo(?a, ?a, ?a);
+op_to_scode(mod)               -> gmb_fate_ops:modulo(?a, ?a, ?a);
-op_to_scode('^')               -> aeb_fate_ops:pow(?a, ?a, ?a);
+op_to_scode('^')               -> gmb_fate_ops:pow(?a, ?a, ?a);
-op_to_scode('++')              -> aeb_fate_ops:append(?a, ?a, ?a);
+op_to_scode('++')              -> gmb_fate_ops:append(?a, ?a, ?a);
-op_to_scode('::')              -> aeb_fate_ops:cons(?a, ?a, ?a);
+op_to_scode('::')              -> gmb_fate_ops:cons(?a, ?a, ?a);
-op_to_scode('<')               -> aeb_fate_ops:lt(?a, ?a, ?a);
+op_to_scode('<')               -> gmb_fate_ops:lt(?a, ?a, ?a);
-op_to_scode('>')               -> aeb_fate_ops:gt(?a, ?a, ?a);
+op_to_scode('>')               -> gmb_fate_ops:gt(?a, ?a, ?a);
-op_to_scode('=<')              -> aeb_fate_ops:elt(?a, ?a, ?a);
+op_to_scode('=<')              -> gmb_fate_ops:elt(?a, ?a, ?a);
-op_to_scode('>=')              -> aeb_fate_ops:egt(?a, ?a, ?a);
+op_to_scode('>=')              -> gmb_fate_ops:egt(?a, ?a, ?a);
-op_to_scode('==')              -> aeb_fate_ops:eq(?a, ?a, ?a);
+op_to_scode('==')              -> gmb_fate_ops:eq(?a, ?a, ?a);
-op_to_scode('!=')              -> aeb_fate_ops:neq(?a, ?a, ?a);
+op_to_scode('!=')              -> gmb_fate_ops:neq(?a, ?a, ?a);
-op_to_scode('!')               -> aeb_fate_ops:not_op(?a, ?a);
+op_to_scode('!')               -> gmb_fate_ops:not_op(?a, ?a);
-op_to_scode('bnot')            -> aeb_fate_ops:bin_not(?a, ?a);
+op_to_scode('bnot')            -> gmb_fate_ops:bin_not(?a, ?a);
-op_to_scode('band')            -> aeb_fate_ops:bin_and(?a, ?a, ?a);
+op_to_scode('band')            -> gmb_fate_ops:bin_and(?a, ?a, ?a);
-op_to_scode('bor')             -> aeb_fate_ops:bin_or(?a, ?a, ?a);
+op_to_scode('bor')             -> gmb_fate_ops:bin_or(?a, ?a, ?a);
-op_to_scode('bxor')            -> aeb_fate_ops:bin_xor(?a, ?a, ?a);
+op_to_scode('bxor')            -> gmb_fate_ops:bin_xor(?a, ?a, ?a);
-op_to_scode('<<')              -> aeb_fate_ops:bin_sl(?a, ?a, ?a);
+op_to_scode('<<')              -> gmb_fate_ops:bin_sl(?a, ?a, ?a);
-op_to_scode('>>')              -> aeb_fate_ops:bin_sr(?a, ?a, ?a);
+op_to_scode('>>')              -> gmb_fate_ops:bin_sr(?a, ?a, ?a);
-op_to_scode(map_get)           -> aeb_fate_ops:map_lookup(?a, ?a, ?a);
+op_to_scode(map_get)           -> gmb_fate_ops:map_lookup(?a, ?a, ?a);
-op_to_scode(map_get_d)         -> aeb_fate_ops:map_lookup(?a, ?a, ?a, ?a);
+op_to_scode(map_get_d)         -> gmb_fate_ops:map_lookup(?a, ?a, ?a, ?a);
-op_to_scode(map_set)           -> aeb_fate_ops:map_update(?a, ?a, ?a, ?a);
+op_to_scode(map_set)           -> gmb_fate_ops:map_update(?a, ?a, ?a, ?a);
-op_to_scode(map_from_list)     -> aeb_fate_ops:map_from_list(?a, ?a);
+op_to_scode(map_from_list)     -> gmb_fate_ops:map_from_list(?a, ?a);
-op_to_scode(map_to_list)       -> aeb_fate_ops:map_to_list(?a, ?a);
+op_to_scode(map_to_list)       -> gmb_fate_ops:map_to_list(?a, ?a);
-op_to_scode(map_delete)        -> aeb_fate_ops:map_delete(?a, ?a, ?a);
+op_to_scode(map_delete)        -> gmb_fate_ops:map_delete(?a, ?a, ?a);
-op_to_scode(map_member)        -> aeb_fate_ops:map_member(?a, ?a, ?a);
+op_to_scode(map_member)        -> gmb_fate_ops:map_member(?a, ?a, ?a);
-op_to_scode(map_size)          -> aeb_fate_ops:map_size_(?a, ?a);
+op_to_scode(map_size)          -> gmb_fate_ops:map_size_(?a, ?a);
-op_to_scode(stringinternal_length)    -> aeb_fate_ops:str_length(?a, ?a);
+op_to_scode(stringinternal_length)    -> gmb_fate_ops:str_length(?a, ?a);
-op_to_scode(stringinternal_concat)    -> aeb_fate_ops:str_join(?a, ?a, ?a);
+op_to_scode(stringinternal_concat)    -> gmb_fate_ops:str_join(?a, ?a, ?a);
-op_to_scode(stringinternal_to_bytes)  -> aeb_fate_ops:str_to_bytes(?a, ?a);
+op_to_scode(stringinternal_to_bytes)  -> gmb_fate_ops:str_to_bytes(?a, ?a);
-op_to_scode(stringinternal_to_list)   -> aeb_fate_ops:str_to_list(?a, ?a);
+op_to_scode(stringinternal_to_list)   -> gmb_fate_ops:str_to_list(?a, ?a);
-op_to_scode(stringinternal_from_list) -> aeb_fate_ops:str_from_list(?a, ?a);
+op_to_scode(stringinternal_from_list) -> gmb_fate_ops:str_from_list(?a, ?a);
-op_to_scode(stringinternal_to_lower)  -> aeb_fate_ops:str_to_lower(?a, ?a);
+op_to_scode(stringinternal_to_lower)  -> gmb_fate_ops:str_to_lower(?a, ?a);
-op_to_scode(stringinternal_to_upper)  -> aeb_fate_ops:str_to_upper(?a, ?a);
+op_to_scode(stringinternal_to_upper)  -> gmb_fate_ops:str_to_upper(?a, ?a);
-op_to_scode(char_to_int)       -> aeb_fate_ops:char_to_int(?a, ?a);
+op_to_scode(char_to_int)       -> gmb_fate_ops:char_to_int(?a, ?a);
-op_to_scode(char_from_int)     -> aeb_fate_ops:char_from_int(?a, ?a);
+op_to_scode(char_from_int)     -> gmb_fate_ops:char_from_int(?a, ?a);
-op_to_scode(bits_set)          -> aeb_fate_ops:bits_set(?a, ?a, ?a);
+op_to_scode(bits_set)          -> gmb_fate_ops:bits_set(?a, ?a, ?a);
-op_to_scode(bits_clear)        -> aeb_fate_ops:bits_clear(?a, ?a, ?a);
+op_to_scode(bits_clear)        -> gmb_fate_ops:bits_clear(?a, ?a, ?a);
-op_to_scode(bits_test)         -> aeb_fate_ops:bits_test(?a, ?a, ?a);
+op_to_scode(bits_test)         -> gmb_fate_ops:bits_test(?a, ?a, ?a);
-op_to_scode(bits_sum)          -> aeb_fate_ops:bits_sum(?a, ?a);
+op_to_scode(bits_sum)          -> gmb_fate_ops:bits_sum(?a, ?a);
-op_to_scode(bits_intersection) -> aeb_fate_ops:bits_and(?a, ?a, ?a);
+op_to_scode(bits_intersection) -> gmb_fate_ops:bits_and(?a, ?a, ?a);
-op_to_scode(bits_union)        -> aeb_fate_ops:bits_or(?a, ?a, ?a);
+op_to_scode(bits_union)        -> gmb_fate_ops:bits_or(?a, ?a, ?a);
-op_to_scode(bits_difference)   -> aeb_fate_ops:bits_diff(?a, ?a, ?a);
+op_to_scode(bits_difference)   -> gmb_fate_ops:bits_diff(?a, ?a, ?a);
-op_to_scode(address_to_str)    -> aeb_fate_ops:addr_to_str(?a, ?a);
+op_to_scode(address_to_str)    -> gmb_fate_ops:addr_to_str(?a, ?a);
-op_to_scode(address_to_bytes)  -> aeb_fate_ops:addr_to_bytes(?a, ?a);
+op_to_scode(address_to_bytes)  -> gmb_fate_ops:addr_to_bytes(?a, ?a);
-op_to_scode(int_to_str)        -> aeb_fate_ops:int_to_str(?a, ?a);
+op_to_scode(int_to_str)        -> gmb_fate_ops:int_to_str(?a, ?a);
-op_to_scode(int_to_bytes)      -> aeb_fate_ops:int_to_bytes(?a, ?a, ?a);
+op_to_scode(int_to_bytes)      -> gmb_fate_ops:int_to_bytes(?a, ?a, ?a);
-op_to_scode(int_mulmod)        -> aeb_fate_ops:mulmod(?a, ?a, ?a, ?a);
+op_to_scode(int_mulmod)        -> gmb_fate_ops:mulmod(?a, ?a, ?a, ?a);
-op_to_scode(contract_to_address)         -> aeb_fate_ops:contract_to_address(?a, ?a);
+op_to_scode(contract_to_address)         -> gmb_fate_ops:contract_to_address(?a, ?a);
-op_to_scode(address_to_contract)         -> aeb_fate_ops:address_to_contract(?a, ?a);
+op_to_scode(address_to_contract)         -> gmb_fate_ops:address_to_contract(?a, ?a);
-op_to_scode(crypto_verify_sig)           -> aeb_fate_ops:verify_sig(?a, ?a, ?a, ?a);
+op_to_scode(crypto_verify_sig)           -> gmb_fate_ops:verify_sig(?a, ?a, ?a, ?a);
-op_to_scode(crypto_verify_sig_secp256k1) -> aeb_fate_ops:verify_sig_secp256k1(?a, ?a, ?a, ?a);
+op_to_scode(crypto_verify_sig_secp256k1) -> gmb_fate_ops:verify_sig_secp256k1(?a, ?a, ?a, ?a);
-op_to_scode(crypto_ecverify_secp256k1)   -> aeb_fate_ops:ecverify_secp256k1(?a, ?a, ?a, ?a);
+op_to_scode(crypto_ecverify_secp256k1)   -> gmb_fate_ops:ecverify_secp256k1(?a, ?a, ?a, ?a);
-op_to_scode(crypto_ecrecover_secp256k1)  -> aeb_fate_ops:ecrecover_secp256k1(?a, ?a, ?a);
+op_to_scode(crypto_ecrecover_secp256k1)  -> gmb_fate_ops:ecrecover_secp256k1(?a, ?a, ?a);
-op_to_scode(crypto_sha3)                 -> aeb_fate_ops:sha3(?a, ?a);
+op_to_scode(crypto_sha3)                 -> gmb_fate_ops:sha3(?a, ?a);
-op_to_scode(crypto_sha256)               -> aeb_fate_ops:sha256(?a, ?a);
+op_to_scode(crypto_sha256)               -> gmb_fate_ops:sha256(?a, ?a);
-op_to_scode(crypto_blake2b)              -> aeb_fate_ops:blake2b(?a, ?a);
+op_to_scode(crypto_blake2b)              -> gmb_fate_ops:blake2b(?a, ?a);
-op_to_scode(crypto_poseidon)             -> aeb_fate_ops:poseidon(?a, ?a, ?a);
+op_to_scode(crypto_poseidon)             -> gmb_fate_ops:poseidon(?a, ?a, ?a);
-op_to_scode(stringinternal_sha3)         -> aeb_fate_ops:sha3(?a, ?a);
+op_to_scode(stringinternal_sha3)         -> gmb_fate_ops:sha3(?a, ?a);
-op_to_scode(stringinternal_sha256)       -> aeb_fate_ops:sha256(?a, ?a);
+op_to_scode(stringinternal_sha256)       -> gmb_fate_ops:sha256(?a, ?a);
-op_to_scode(stringinternal_blake2b)      -> aeb_fate_ops:blake2b(?a, ?a);
+op_to_scode(stringinternal_blake2b)      -> gmb_fate_ops:blake2b(?a, ?a);
-op_to_scode(mcl_bls12_381_g1_neg)        -> aeb_fate_ops:bls12_381_g1_neg(?a, ?a);
+op_to_scode(mcl_bls12_381_g1_neg)        -> gmb_fate_ops:bls12_381_g1_neg(?a, ?a);
-op_to_scode(mcl_bls12_381_g1_norm)       -> aeb_fate_ops:bls12_381_g1_norm(?a, ?a);
+op_to_scode(mcl_bls12_381_g1_norm)       -> gmb_fate_ops:bls12_381_g1_norm(?a, ?a);
-op_to_scode(mcl_bls12_381_g1_valid)      -> aeb_fate_ops:bls12_381_g1_valid(?a, ?a);
+op_to_scode(mcl_bls12_381_g1_valid)      -> gmb_fate_ops:bls12_381_g1_valid(?a, ?a);
-op_to_scode(mcl_bls12_381_g1_is_zero)    -> aeb_fate_ops:bls12_381_g1_is_zero(?a, ?a);
+op_to_scode(mcl_bls12_381_g1_is_zero)    -> gmb_fate_ops:bls12_381_g1_is_zero(?a, ?a);
-op_to_scode(mcl_bls12_381_g1_add)        -> aeb_fate_ops:bls12_381_g1_add(?a, ?a, ?a);
+op_to_scode(mcl_bls12_381_g1_add)        -> gmb_fate_ops:bls12_381_g1_add(?a, ?a, ?a);
-op_to_scode(mcl_bls12_381_g1_mul)        -> aeb_fate_ops:bls12_381_g1_mul(?a, ?a, ?a);
+op_to_scode(mcl_bls12_381_g1_mul)        -> gmb_fate_ops:bls12_381_g1_mul(?a, ?a, ?a);
-op_to_scode(mcl_bls12_381_g2_neg)        -> aeb_fate_ops:bls12_381_g2_neg(?a, ?a);
+op_to_scode(mcl_bls12_381_g2_neg)        -> gmb_fate_ops:bls12_381_g2_neg(?a, ?a);
-op_to_scode(mcl_bls12_381_g2_norm)       -> aeb_fate_ops:bls12_381_g2_norm(?a, ?a);
+op_to_scode(mcl_bls12_381_g2_norm)       -> gmb_fate_ops:bls12_381_g2_norm(?a, ?a);
-op_to_scode(mcl_bls12_381_g2_valid)      -> aeb_fate_ops:bls12_381_g2_valid(?a, ?a);
+op_to_scode(mcl_bls12_381_g2_valid)      -> gmb_fate_ops:bls12_381_g2_valid(?a, ?a);
-op_to_scode(mcl_bls12_381_g2_is_zero)    -> aeb_fate_ops:bls12_381_g2_is_zero(?a, ?a);
+op_to_scode(mcl_bls12_381_g2_is_zero)    -> gmb_fate_ops:bls12_381_g2_is_zero(?a, ?a);
-op_to_scode(mcl_bls12_381_g2_add)        -> aeb_fate_ops:bls12_381_g2_add(?a, ?a, ?a);
+op_to_scode(mcl_bls12_381_g2_add)        -> gmb_fate_ops:bls12_381_g2_add(?a, ?a, ?a);
-op_to_scode(mcl_bls12_381_g2_mul)        -> aeb_fate_ops:bls12_381_g2_mul(?a, ?a, ?a);
+op_to_scode(mcl_bls12_381_g2_mul)        -> gmb_fate_ops:bls12_381_g2_mul(?a, ?a, ?a);
-op_to_scode(mcl_bls12_381_gt_inv)        -> aeb_fate_ops:bls12_381_gt_inv(?a, ?a);
+op_to_scode(mcl_bls12_381_gt_inv)        -> gmb_fate_ops:bls12_381_gt_inv(?a, ?a);
-op_to_scode(mcl_bls12_381_gt_add)        -> aeb_fate_ops:bls12_381_gt_add(?a, ?a, ?a);
+op_to_scode(mcl_bls12_381_gt_add)        -> gmb_fate_ops:bls12_381_gt_add(?a, ?a, ?a);
-op_to_scode(mcl_bls12_381_gt_mul)        -> aeb_fate_ops:bls12_381_gt_mul(?a, ?a, ?a);
+op_to_scode(mcl_bls12_381_gt_mul)        -> gmb_fate_ops:bls12_381_gt_mul(?a, ?a, ?a);
-op_to_scode(mcl_bls12_381_gt_pow)        -> aeb_fate_ops:bls12_381_gt_pow(?a, ?a, ?a);
+op_to_scode(mcl_bls12_381_gt_pow)        -> gmb_fate_ops:bls12_381_gt_pow(?a, ?a, ?a);
-op_to_scode(mcl_bls12_381_gt_is_one)     -> aeb_fate_ops:bls12_381_gt_is_one(?a, ?a);
+op_to_scode(mcl_bls12_381_gt_is_one)     -> gmb_fate_ops:bls12_381_gt_is_one(?a, ?a);
-op_to_scode(mcl_bls12_381_pairing)       -> aeb_fate_ops:bls12_381_pairing(?a, ?a, ?a);
+op_to_scode(mcl_bls12_381_pairing)       -> gmb_fate_ops:bls12_381_pairing(?a, ?a, ?a);
-op_to_scode(mcl_bls12_381_miller_loop)   -> aeb_fate_ops:bls12_381_miller_loop(?a, ?a, ?a);
+op_to_scode(mcl_bls12_381_miller_loop)   -> gmb_fate_ops:bls12_381_miller_loop(?a, ?a, ?a);
-op_to_scode(mcl_bls12_381_final_exp)     -> aeb_fate_ops:bls12_381_final_exp(?a, ?a);
+op_to_scode(mcl_bls12_381_final_exp)     -> gmb_fate_ops:bls12_381_final_exp(?a, ?a);
-op_to_scode(mcl_bls12_381_int_to_fr)     -> aeb_fate_ops:bls12_381_int_to_fr(?a, ?a);
+op_to_scode(mcl_bls12_381_int_to_fr)     -> gmb_fate_ops:bls12_381_int_to_fr(?a, ?a);
-op_to_scode(mcl_bls12_381_int_to_fp)     -> aeb_fate_ops:bls12_381_int_to_fp(?a, ?a);
+op_to_scode(mcl_bls12_381_int_to_fp)     -> gmb_fate_ops:bls12_381_int_to_fp(?a, ?a);
-op_to_scode(mcl_bls12_381_fr_to_int)     -> aeb_fate_ops:bls12_381_fr_to_int(?a, ?a);
+op_to_scode(mcl_bls12_381_fr_to_int)     -> gmb_fate_ops:bls12_381_fr_to_int(?a, ?a);
-op_to_scode(mcl_bls12_381_fp_to_int)     -> aeb_fate_ops:bls12_381_fp_to_int(?a, ?a).
+op_to_scode(mcl_bls12_381_fp_to_int)     -> gmb_fate_ops:bls12_381_fp_to_int(?a, ?a).
 
 %% PUSH and STORE ?a are the same, so we use STORE to make optimizations
 %% easier, and specialize to PUSH (which is cheaper) at the end.
 push(A) -> {'STORE', ?a, A}.
 
 tuple(0) -> push(?i({tuple, {}}));
-tuple(N) -> aeb_fate_ops:tuple(?a, N).
+tuple(N) -> gmb_fate_ops:tuple(?a, N).
 
 %% -- Debug info functions --
 
@@ -825,8 +825,8 @@ dbg_undef(Undef, SCode) when is_tuple(SCode); is_atom(SCode) ->
             true  -> tuple_to_list(SCode);
             false -> [SCode]
         end,
-    Op = aeb_fate_opcodes:m_to_op(Mnemonic),
+    Op = gmb_fate_opcodes:m_to_op(Mnemonic),
-    case aeb_fate_opcodes:end_bb(Op) of
+    case gmb_fate_opcodes:end_bb(Op) of
         true  -> [Undef, SCode];
         false -> [SCode, Undef]
     end.
@@ -898,7 +898,7 @@ pp_ann(_, []) -> [].
 pp_op(switch_body) -> "SWITCH-BODY";
 pp_op(loop) -> "LOOP";
 pp_op(I)    ->
-    aeb_fate_pp:format_op(I, #{}).
+    gmb_fate_pp:format_op(I, #{}).
 
 pp_arg(?i(I))    -> io_lib:format("~w", [I]);
 pp_arg({arg, N}) -> io_lib:format("arg~p", [N]);
@@ -1668,14 +1668,14 @@ unannotate(Code) when is_list(Code) ->
 unannotate({i, _Ann, I}) -> [I].
 
 %% Desugar and specialize
-desugar({'ADD', ?a, ?i(1), ?a}) -> [aeb_fate_ops:inc()];
+desugar({'ADD', ?a, ?i(1), ?a}) -> [gmb_fate_ops:inc()];
-desugar({'ADD', A,  ?i(1), A})  -> [aeb_fate_ops:inc(desugar_arg(A))];
+desugar({'ADD', A,  ?i(1), A})  -> [gmb_fate_ops:inc(desugar_arg(A))];
-desugar({'ADD', ?a, ?a, ?i(1)}) -> [aeb_fate_ops:inc()];
+desugar({'ADD', ?a, ?a, ?i(1)}) -> [gmb_fate_ops:inc()];
-desugar({'ADD', A,  A,  ?i(1)}) -> [aeb_fate_ops:inc(desugar_arg(A))];
+desugar({'ADD', A,  A,  ?i(1)}) -> [gmb_fate_ops:inc(desugar_arg(A))];
-desugar({'SUB', ?a, ?a, ?i(1)}) -> [aeb_fate_ops:dec()];
+desugar({'SUB', ?a, ?a, ?i(1)}) -> [gmb_fate_ops:dec()];
-desugar({'SUB', A, A, ?i(1)})   -> [aeb_fate_ops:dec(desugar_arg(A))];
+desugar({'SUB', A, A, ?i(1)})   -> [gmb_fate_ops:dec(desugar_arg(A))];
-desugar({'STORE', ?a, A})       -> [aeb_fate_ops:push(desugar_arg(A))];
+desugar({'STORE', ?a, A})       -> [gmb_fate_ops:push(desugar_arg(A))];
-desugar({'STORE', R, ?a})       -> [aeb_fate_ops:pop(desugar_arg(R))];
+desugar({'STORE', R, ?a})       -> [gmb_fate_ops:pop(desugar_arg(R))];
 desugar({switch, Arg, Type, Alts, Def}) ->
     [{switch, desugar_arg(Arg), Type, [desugar(A) || A <- Alts], desugar(Def)}];
 desugar(missing) -> missing;
@@ -1695,11 +1695,11 @@ desugar_arg(A) -> A.
 %%  Constructing basic blocks
 
 to_basic_blocks(Funs) ->
-    to_basic_blocks(maps:to_list(Funs), aeb_fate_code:new()).
+    to_basic_blocks(maps:to_list(Funs), gmb_fate_code:new()).
 
 to_basic_blocks([{Name, {Attrs, Sig, Code}}|Left], Acc) ->
-    BB = bb(Name, Code ++ [aeb_fate_ops:return()]),
+    BB = bb(Name, Code ++ [gmb_fate_ops:return()]),
-    to_basic_blocks(Left, aeb_fate_code:insert_fun(Name, Attrs, Sig, BB, Acc));
+    to_basic_blocks(Left, gmb_fate_code:insert_fun(Name, Attrs, Sig, BB, Acc));
 to_basic_blocks([], Acc) ->
     Acc.
 
@@ -1770,7 +1770,7 @@ block(Blk = #blk{code     = [{switch, Arg, Type, Alts, Default} | Code],
     {DefRef, DefBlk} =
         case Default of
             missing when Catchall == none ->
-                FreshBlk([aeb_fate_ops:abort(?i(<<"Incomplete patterns">>))], none);
+                FreshBlk([gmb_fate_ops:abort(?i(<<"Incomplete patterns">>))], none);
             missing -> {Catchall, []};
             _       -> FreshBlk(Default ++ [{jump, RestRef}], Catchall)
                        %% ^ fall-through to the outer catchall
@@ -1945,14 +1945,14 @@ split_calls(Ref, [I | Code], Acc, Blocks) ->
 
 set_labels(Labels, {Ref, Code}) when is_reference(Ref) ->
     {maps:get(Ref, Labels), [ set_labels(Labels, I) || I <- Code ]};
-set_labels(_Labels, loop)              -> aeb_fate_ops:jump(0);
+set_labels(_Labels, loop)              -> gmb_fate_ops:jump(0);
-set_labels(Labels, {jump, Ref})        -> aeb_fate_ops:jump(maps:get(Ref, Labels));
+set_labels(Labels, {jump, Ref})        -> gmb_fate_ops:jump(maps:get(Ref, Labels));
-set_labels(Labels, {jumpif, Arg, Ref}) -> aeb_fate_ops:jumpif(Arg, maps:get(Ref, Labels));
+set_labels(Labels, {jumpif, Arg, Ref}) -> gmb_fate_ops:jumpif(Arg, maps:get(Ref, Labels));
 set_labels(Labels, {switch, Arg, Refs}) ->
     case [ maps:get(Ref, Labels) || Ref <- Refs ] of
-        [R1, R2]     -> aeb_fate_ops:switch(Arg, R1, R2);
+        [R1, R2]     -> gmb_fate_ops:switch(Arg, R1, R2);
-        [R1, R2, R3] -> aeb_fate_ops:switch(Arg, R1, R2, R3);
+        [R1, R2, R3] -> gmb_fate_ops:switch(Arg, R1, R2, R3);
-        Rs           -> aeb_fate_ops:switch(Arg, Rs)
+        Rs           -> gmb_fate_ops:switch(Arg, Rs)
     end;
 set_labels(_, I) -> I.
 

src/aeso_parser.erl

@@ -748,7 +748,7 @@ read_file(File, Opts) ->
                 Escript        = escript:script_name(),
                 {ok, Sections} = escript:extract(Escript, []),
                 Archive        = proplists:get_value(archive, Sections),
-                FileName       = binary_to_list(filename:join([aesophia, priv, stdlib, File])),
+                FileName       = binary_to_list(filename:join([sophia, priv, stdlib, File])),
                 case zip:extract(Archive, [{file_list, [FileName]}, memory]) of
                     {ok, [{_, Src}]} -> {ok, escript, Src};
                     _                -> {error, not_found}

src/aeso_stdlib.erl

@@ -13,5 +13,5 @@
 -export([stdlib_include_path/0]).
 
 stdlib_include_path() ->
-    filename:join([code:priv_dir(aesophia), "stdlib"]).
+    filename:join([code:priv_dir(sophia), "stdlib"]).
 

src/aeso_vm_decode.erl

@@ -8,9 +8,9 @@
 
 -export([ from_fate/2 ]).
 
--include_lib("aebytecode/include/aeb_fate_data.hrl").
+-include_lib("gmbytecode/include/gmb_fate_data.hrl").
 
--spec from_fate(aeso_syntax:type(), aeb_fate_data:fate_type()) -> aeso_syntax:expr().
+-spec from_fate(aeso_syntax:type(), gmb_fate_data:fate_type()) -> aeso_syntax:expr().
 from_fate({id, _, "address"}, ?FATE_ADDRESS(Bin)) -> {account_pubkey, [], Bin};
 from_fate({id, _, "signature"}, ?FATE_BYTES(Bin)) -> {signature, [], Bin};
 from_fate({id, _, "hash"}, ?FATE_BYTES(Bin)) -> {bytes, [], Bin};

src/sophia.app.src

@@ -1,4 +1,4 @@
-{application, aesophia,
+{application, sophia,
  [{description, "Compiler for Aeternity Sophia language"},
   {vsn, "8.0.1"},
   {registered, []},
@@ -7,7 +7,7 @@
     stdlib,
     jsx,
     syntax_tools,
-    aebytecode,
+    gmbytecode,
     eblake2
    ]},
   {env,[]},

test/aeso_abi_tests.erl

@@ -65,9 +65,9 @@ to_sophia_value_mcl_bls12_381_test() ->
 
     Opts = [{backend, fate}],
 
-    CallValue32 = aeb_fate_encoding:serialize({bytes, <<20:256>>}),
+    CallValue32 = gmb_fate_encoding:serialize({bytes, <<20:256>>}),
-    CallValue48 = aeb_fate_encoding:serialize({bytes, <<55:384>>}),
+    CallValue48 = gmb_fate_encoding:serialize({bytes, <<55:384>>}),
-    CallValueTp = aeb_fate_encoding:serialize({tuple, {{bytes, <<15:256>>}, {bytes, <<160:256>>}, {bytes, <<1234:256>>}}}),
+    CallValueTp = gmb_fate_encoding:serialize({tuple, {{bytes, <<15:256>>}, {bytes, <<160:256>>}, {bytes, <<1234:256>>}}}),
 
     {ok,     _} = aeso_compiler:to_sophia_value(Code, "test_bls12_381_fp", ok, CallValue32, Opts),
     {error,  _} = aeso_compiler:to_sophia_value(Code, "test_bls12_381_fp", ok, CallValue48, Opts),
@@ -227,7 +227,7 @@ encode_decode_calldata_(Code, FunName, Args) ->
         "init" ->
             [];
         _ ->
-            {ok, FateArgs} = aeb_fate_abi:decode_calldata(FunName, Calldata),
+            {ok, FateArgs} = gmb_fate_abi:decode_calldata(FunName, Calldata),
             FateArgs
     end.
 
@@ -236,7 +236,7 @@ encode_decode(D) ->
     D.
 
 encode(D) ->
-    aeb_fate_encoding:serialize(D).
+    gmb_fate_encoding:serialize(D).
 
 decode(B) ->
-    aeb_fate_encoding:deserialize(B).
+    gmb_fate_encoding:deserialize(B).

test/aeso_compiler_tests.erl

@@ -28,7 +28,7 @@ simple_compile_test_() ->
        fun() ->
            case compile(ContractName) of
                #{fate_code := Code} ->
-                   Code1 = aeb_fate_code:deserialize(aeb_fate_code:serialize(Code)),
+                   Code1 = gmb_fate_code:deserialize(gmb_fate_code:serialize(Code)),
                    ?assertMatch({X, X}, {Code1, Code});
                Error -> io:format("\n\n~p\n\n", [Error]), print_and_throw(Error)
            end
@@ -84,7 +84,7 @@ stdlib_test_() ->
           Options = [{src_file, File}],
           case aeso_compiler:from_string(String, Options) of
               {ok, #{fate_code := Code}} ->
-                  Code1 = aeb_fate_code:deserialize(aeb_fate_code:serialize(Code)),
+                  Code1 = gmb_fate_code:deserialize(gmb_fate_code:serialize(Code)),
                   ?assertMatch({X, X}, {Code1, Code});
               {error, Error} -> io:format("\n\n~p\n\n", [Error]), print_and_throw(Error)
           end
@@ -1345,7 +1345,7 @@ validation_fails() ->
 validate(Contract1, Contract2) ->
     case compile(Contract1) of
         ByteCode = #{ fate_code := FCode } ->
-            FCode1   = aeb_fate_code:serialize(aeb_fate_code:strip_init_function(FCode)),
+            FCode1   = gmb_fate_code:serialize(gmb_fate_code:strip_init_function(FCode)),
             Source   = aeso_test_utils:read_contract(Contract2),
             aeso_compiler:validate_byte_code(
               ByteCode#{ byte_code := FCode1 }, Source,

test/aeso_test_utils.erl

@@ -11,7 +11,7 @@
 -export([read_contract/1, contract_path/0]).
 
 contract_path() ->
-    filename:join(code:lib_dir(aesophia, test), "contracts").
+    filename:join(code:lib_dir(sophia, test), "contracts").
 
 %% Read a contract file from the test/contracts directory.
 -spec read_contract(string() | atom()) -> string().