Add bytes type and values

and remove hash and signature

include/aeb_fate_data.hrl

@@ -7,8 +7,7 @@
 -define(FATE_MAP_T,       #{ fate_type() => fate_type() }).
 -define(FATE_STRING_T,    binary()).
 -define(FATE_ADDRESS_T,   {address, <<_:256>>}).
--define(FATE_HASH_T,      {hash, binary()}).
+-define(FATE_BYTES_T(N),  {bytes, binary()}).
--define(FATE_SIGNATURE_T, {signature, binary()}).
 -define(FATE_CONTRACT_T,  {contract, <<_:256>>}).
 -define(FATE_ORACLE_T,    {oracle, <<_:256>>}).
 -define(FATE_ORACLE_Q_T,  {oracle_query, <<_:256>>}).
@@ -25,8 +24,8 @@
 -define(IS_FATE_MAP(X),     (is_map(X))).
 -define(IS_FATE_TUPLE(X),   (is_tuple(X) andalso (tuple == element(1, X) andalso is_tuple(element(2, X))))).
 -define(IS_FATE_ADDRESS(X), (is_tuple(X) andalso (address == element(1, X) andalso is_binary(element(2, X))))).
--define(IS_FATE_HASH(X),    (is_tuple(X) andalso (hash == element(1, X) andalso is_binary(element(2, X))))).
+-define(IS_FATE_BYTES(X),   (is_tuple(X) andalso (bytes == element(1, X) andalso is_binary(element(2, X))))).
--define(IS_FATE_SIGNATURE(X), (is_tuple(X) andalso (signature == element(1, X) andalso is_binary(element(2, X))))).
+-define(IS_FATE_BYTES(N, X), (?IS_FATE_BYTES(X) andalso byte_size(element(2, X)) == (N))).
 -define(IS_FATE_CONTRACT(X), (is_tuple(X) andalso (contract == element(1, X) andalso is_binary(element(2, X))))).
 -define(IS_FATE_ORACLE(X), (is_tuple(X) andalso (oracle == element(1, X) andalso is_binary(element(2, X))))).
 -define(IS_FATE_ORACLE_Q(X), (is_tuple(X) andalso (oracle_query == element(1, X) andalso is_binary(element(2, X))))).
@@ -46,8 +45,7 @@
 -define(FATE_UNIT,         {tuple, {}}).
 -define(FATE_TUPLE(T),     {tuple, T}).
 -define(FATE_ADDRESS(A),   {address, A}).
--define(FATE_HASH(X),      {hash, X}).
+-define(FATE_BYTES(X),     {bytes, X}).
--define(FATE_SIGNATURE(S), {signature, S}).
 -define(FATE_CONTRACT(X),  {contract, X}).
 -define(FATE_ORACLE(X),    {oracle, X}).
 -define(FATE_ORACLE_Q(X),  {oracle_query, X}).
@@ -62,8 +60,7 @@
 -define(FATE_TUPLE_ELEMENTS(X), (tuple_to_list(element(2, X)))).
 -define(FATE_STRING_VALUE(X), (X)).
 -define(FATE_ADDRESS_VALUE(X), (element(2, X))).
--define(FATE_HASH_VALUE(X), (element(2, X))).
+-define(FATE_BYTES_VALUE(X), (element(2, X))).
--define(FATE_SIGNATURE_VALUE(X), (element(2, X))).
 -define(FATE_CONTRACT_VALUE(X), (element(2, X))).
 -define(FATE_ORACLE_VALUE(X), (element(2, X))).
 -define(FATE_NAME_VALUE(X), (element(2, X))).

src/aeb_fate_asm.erl

@@ -282,15 +282,10 @@ to_bytecode([{object,_line, {channel, Value}}|Rest],
     to_bytecode(Rest, Address, Env,
                 [{immediate, aeb_fate_data:make_contract(Value)}|Code],
                 Opts);
-to_bytecode([{hash,_line, Value}|Rest],
+to_bytecode([{bytes,_line, Value}|Rest],
             Address, Env, Code, Opts) ->
     to_bytecode(Rest, Address, Env,
-                [{immediate, aeb_fate_data:make_hash(Value)}|Code],
+                [{immediate, aeb_fate_data:make_bytes(Value)}|Code],
-                Opts);
-to_bytecode([{signature,_line, {signature, Value}}|Rest],
-            Address, Env, Code, Opts) ->
-    to_bytecode(Rest, Address, Env,
-                [{immediate, aeb_fate_data:make_signature(Value)}|Code],
                 Opts);
 to_bytecode([{id,_line, ID}|Rest], Address, Env, Code, Opts) ->
     {Env2, Id} = insert_symbol(list_to_binary(ID), Env),

src/aeb_fate_asm_scan.template

@@ -17,8 +17,7 @@ BASE64   = [A-Za-z0-9+/=]
 INT      = {DIGIT}+
 HEX      = 0x{HEXDIGIT}+
 OBJECT   = @[a-z][a-z]_{BASE58}+
-HASH     = #{BASE64}+
+BYTES    = #{BASE64}+
-SIG      = \$sg_{BASE58}+
 WS       = [\000-\s]
 ID       = {LOWER}[a-zA-Z0-9_]*
 STRING   = "[^"]*"
@@ -36,10 +35,8 @@ false          : {token, {boolean, TokenLine, false}}.
 
 FUNCTION       : {token, {function, TokenLine, 'FUNCTION' }}.
 
-{HASH} :
+{BYTES} :
- {token, {hash, TokenLine, parse_hash(TokenChars)}}.
+ {token, {bytes, TokenLine, parse_hash(TokenChars)}}.
-{SIG} :
- {token, {signature, TokenLine, parse_object(TokenChars)}}.
 {OBJECT} :
  {token, {object, TokenLine, parse_object(TokenChars)}}.
 {ID} :

src/aeb_fate_data.erl

@@ -12,12 +12,12 @@
 -type fate_map()       :: ?FATE_MAP_T.
 -type fate_string()    :: ?FATE_STRING_T.
 -type fate_address()   :: ?FATE_ADDRESS_T.
--type fate_hash()      :: ?FATE_HASH_T.
+-type fate_hash()      :: ?FATE_BYTES_T(32).
+-type fate_signature() :: ?FATE_BYTES_T(64).
 -type fate_contract()  :: ?FATE_CONTRACT_T.
 -type fate_oracle()    :: ?FATE_ORACLE_T.
 -type fate_name()      :: ?FATE_NAME_T.
 -type fate_channel()   :: ?FATE_CHANNEL_T.
--type fate_signature() :: ?FATE_SIGNATURE_T.
 -type fate_variant()   :: ?FATE_VARIANT_T.
 -type fate_tuple()     :: ?FATE_TUPLE_T.
 -type fate_bits()      :: ?FATE_BITS_T.
@@ -87,6 +87,7 @@
         , make_string/1
         , make_map/1
         , make_address/1
+        , make_bytes/1
         , make_hash/1
         , make_signature/1
         , make_contract/1
@@ -113,8 +114,9 @@ make_unit() ->         ?FATE_UNIT.
 make_tuple(T) ->       ?FATE_TUPLE(T).
 make_map(M) ->         ?MAKE_FATE_MAP(M).
 make_address(X) ->     ?FATE_ADDRESS(X).
-make_hash(X) ->        ?FATE_HASH(X).
+make_bytes(X) ->       ?FATE_BYTES(X).
-make_signature(X) ->   ?FATE_SIGNATURE(X).
+make_hash(X) ->        make_bytes(X).
+make_signature(X) ->   make_bytes(X).
 make_contract(X) ->    ?FATE_CONTRACT(X).
 make_oracle(X) ->      ?FATE_ORACLE(X).
 make_oracle_query(X) -> ?FATE_ORACLE_Q(X).
@@ -168,11 +170,9 @@ format(?FATE_VARIANT(Arities, Tag, T)) ->
      " |)"];
 format(M) when ?IS_FATE_MAP(M) ->
     ["{ ", format_kvs(maps:to_list(?FATE_MAP_VALUE(M))), " }"];
-format(?FATE_HASH(X))       -> ["#", base64:encode(X)];
+format(?FATE_BYTES(X))      -> ["#", base64:encode(X)];
 format(?FATE_ADDRESS(X))    ->
     ["@", aeser_api_encoder:encode(account_pubkey, X)];
-format(?FATE_SIGNATURE(X))  ->
-    ["$", aeser_api_encoder:encode(signature, X)];
 format(?FATE_CONTRACT(X))   ->
     ["@", aeser_api_encoder:encode(contract_pubkey, X)];
 format(?FATE_ORACLE(X))     ->
@@ -218,8 +218,8 @@ ordinal(T) when ?IS_FATE_CHANNEL(T)   -> 3;
 ordinal(T) when ?IS_FATE_CONTRACT(T)  -> 4;
 ordinal(T) when ?IS_FATE_NAME(T)      -> 5;
 ordinal(T) when ?IS_FATE_ORACLE(T)    -> 6;
-ordinal(T) when ?IS_FATE_HASH(T)      -> 7;
+ordinal(T) when ?IS_FATE_BYTES(T)     -> 7;
-ordinal(T) when ?IS_FATE_SIGNATURE(T) -> 8;
+%%                                       8;
 ordinal(T) when ?IS_FATE_BITS(T)      -> 9;
 ordinal(T) when ?IS_FATE_STRING(T)    -> 10;
 ordinal(T) when ?IS_FATE_TUPLE(T)     -> 11;

src/aeb_fate_encoding.erl

@@ -73,7 +73,7 @@
 -define(TYPE_MAP     , 2#01100111). %% 0110 0111 | Type | Type
 -define(TYPE_STRING  , 2#01110111). %% 0111 0111 - string typedef
 -define(TYPE_VARIANT , 2#10000111). %% 1000 0111 | [Arities] | [Type]
-                                    %% 1001 0111
+-define(TYPE_BYTES   , 2#10010111). %% 1001 0111 - Bytes typedef
                                     %% 1010 0111
                                     %% 1011 0111
                                     %% 1100 0111
@@ -108,13 +108,12 @@
 
 %% Object types
 -define(OTYPE_ADDRESS,   0).
--define(OTYPE_HASH,      1).
+-define(OTYPE_BYTES,     1).
--define(OTYPE_SIGNATURE, 2).
+-define(OTYPE_CONTRACT,  2).
--define(OTYPE_CONTRACT,  3).
+-define(OTYPE_ORACLE,    3).
--define(OTYPE_ORACLE,    4).
+-define(OTYPE_ORACLE_Q,  4).
--define(OTYPE_ORACLE_Q,  5).
+-define(OTYPE_NAME,      5).
--define(OTYPE_NAME,      6).
+-define(OTYPE_CHANNEL,   6).
--define(OTYPE_CHANNEL,   7).
 
 -define(IS_TYPE_TAG(X), (X =:= ?TYPE_INTEGER orelse
                          X =:= ?TYPE_BOOLEAN orelse
@@ -153,12 +152,10 @@ serialize(String) when ?IS_FATE_STRING(String),
     <<?LONG_STRING,
       (serialize_integer(?FATE_STRING_SIZE(String) - ?SHORT_STRING_SIZE))/binary
      , Bytes/binary>>;
+serialize(?FATE_BYTES(Bytes)) when is_binary(Bytes) ->
+    <<?OBJECT, ?OTYPE_BYTES, (serialize(?FATE_STRING(Bytes)))/binary>>;
 serialize(?FATE_ADDRESS(Address)) when is_binary(Address) ->
     <<?OBJECT, ?OTYPE_ADDRESS, (aeser_rlp:encode(Address))/binary>>;
-serialize(?FATE_HASH(Address)) when is_binary(Address) ->
-    <<?OBJECT, ?OTYPE_HASH, (aeser_rlp:encode(Address))/binary>>;
-serialize(?FATE_SIGNATURE(Address)) when is_binary(Address) ->
-    <<?OBJECT, ?OTYPE_SIGNATURE, (aeser_rlp:encode(Address))/binary>>;
 serialize(?FATE_CONTRACT(Address)) when is_binary(Address) ->
     <<?OBJECT, ?OTYPE_CONTRACT, (aeser_rlp:encode(Address))/binary>>;
 serialize(?FATE_ORACLE(Address)) when is_binary(Address) ->
@@ -233,9 +230,9 @@ serialize_type({tuple, Ts}) ->
         N when N =< 255 ->
             [?TYPE_TUPLE, N | [serialize_type(T) || T <- Ts]]
     end;
+serialize_type({bytes, N}) when 0 =< N ->
+    [?TYPE_BYTES | binary_to_list(serialize_integer(N))];
 serialize_type(address)     -> [?TYPE_OBJECT, ?OTYPE_ADDRESS];
-serialize_type(hash)        -> [?TYPE_OBJECT, ?OTYPE_HASH];
-serialize_type(signature)   -> [?TYPE_OBJECT, ?OTYPE_SIGNATURE];
 serialize_type(contract)    -> [?TYPE_OBJECT, ?OTYPE_CONTRACT];
 serialize_type(oracle)      -> [?TYPE_OBJECT, ?OTYPE_ORACLE];
 serialize_type(oracle_query)-> [?TYPE_OBJECT, ?OTYPE_ORACLE_Q];
@@ -263,11 +260,13 @@ deserialize_type(<<?TYPE_LIST, Rest/binary>>) ->
 deserialize_type(<<?TYPE_TUPLE, N, Rest/binary>>) ->
     {Ts, Rest2} = deserialize_types(N, Rest, []),
     {{tuple, Ts}, Rest2};
+deserialize_type(<<?TYPE_BYTES, Rest/binary>>) ->
+    {N, Rest2} = deserialize_one(Rest),
+    true       = is_integer(N) andalso N >= 0,
+    {{bytes, N}, Rest2};
 deserialize_type(<<?TYPE_OBJECT, ObjectType, Rest/binary>>) ->
     case ObjectType of
         ?OTYPE_ADDRESS   -> {address, Rest};
-        ?OTYPE_HASH      -> {hash, Rest};
-        ?OTYPE_SIGNATURE -> {signature, Rest};
         ?OTYPE_CONTRACT  -> {contract, Rest};
         ?OTYPE_ORACLE    -> {oracle, Rest};
         ?OTYPE_ORACLE_Q  -> {oracle_query, Rest};
@@ -382,13 +381,15 @@ deserialize2(<<S:6, ?SHORT_STRING:2, Rest/binary>>) ->
     String = binary:part(Rest, 0, S),
     Rest2 = binary:part(Rest, byte_size(Rest), - (byte_size(Rest) - S)),
     {?MAKE_FATE_STRING(String), Rest2};
+deserialize2(<<?OBJECT, ?OTYPE_BYTES, Rest/binary>>) ->
+    {String, Rest2} = deserialize_one(Rest),
+    true = ?IS_FATE_STRING(String),
+    {?FATE_BYTES(?FATE_STRING_VALUE(String)), Rest2};
 deserialize2(<<?OBJECT, ObjectType, Rest/binary>>) ->
     {A, Rest2} = aeser_rlp:decode_one(Rest),
     Val =
         case ObjectType of
             ?OTYPE_ADDRESS   -> ?FATE_ADDRESS(A);
-            ?OTYPE_HASH      -> ?FATE_HASH(A);
-            ?OTYPE_SIGNATURE -> ?FATE_SIGNATURE(A);
             ?OTYPE_CONTRACT  -> ?FATE_CONTRACT(A);
             ?OTYPE_ORACLE    -> ?FATE_ORACLE(A);
             ?OTYPE_ORACLE_Q  -> ?FATE_ORACLE_Q(A);