Remove old type references, update naming, add license notices (#43)

Removed the oracle type references and updated the dependency list to point to git.qpq.swiss.

Reviewed-on: #43
Co-authored-by: Craig Everett <zxq9@zxq9.com>
Co-committed-by: Craig Everett <zxq9@zxq9.com>

test/gmser_api_encoder_tests.erl

@@ -0,0 +1,138 @@
+%%%-------------------------------------------------------------------
+%%% @copyright (C) 2025, QPQ AG
+%%% @copyright (C) 2018, Aeternity Anstalt
+%%%-------------------------------------------------------------------
+
+-module(gmser_api_encoder_tests).
+
+-include_lib("eunit/include/eunit.hrl").
+
+-define(TEST_MODULE, gmser_api_encoder).
+-define(TYPES, [ {key_block_hash    , 32}
+               , {micro_block_hash  , 32}
+               , {block_tx_hash     , 32}
+               , {block_state_hash  , 32}
+               , {channel           , 32}
+               , {contract_pubkey   , 32}
+               , {transaction       , not_applicable}
+               , {tx_hash           , 32}
+               , {account_pubkey    , 32}
+               , {signature         , 64}
+               , {name              , not_applicable}
+               , {native_token      , 32}
+               , {commitment        , 32}
+               , {peer_pubkey       , 32}
+               , {state             , 32}
+               , {poi               , not_applicable}]).
+
+encode_decode_test_() ->
+    [{"Byte sizes are correct",
+      fun() ->
+          lists:foreach(
+              fun({Type, ByteSize}) ->
+                  {_Type, _, ByteSize} = {Type, ByteSize,
+                                          ?TEST_MODULE:byte_size_for_type(Type)}
+              end,
+              ?TYPES)
+      end
+     },
+     {"Serialize/deserialize known types",
+      fun() ->
+          lists:foreach(
+              fun({Type, Size0}) ->
+                    ByteSize =
+                        case Size0 of
+                            not_applicable -> 42;
+                            _ when is_integer(Size0) -> Size0
+                        end,
+                    Key = <<42:ByteSize/unit:8>>,
+                    EncodedKey = ?TEST_MODULE:encode(Type, Key),
+                    {Type, Key} = ?TEST_MODULE:decode(EncodedKey),
+                    {ok, Key} = ?TEST_MODULE:safe_decode(Type, EncodedKey)
+              end,
+              ?TYPES)
+      end
+     },
+     {"Key size check works",
+      fun() ->
+          lists:foreach(
+              fun({_Type, not_applicable}) -> ok;
+                 ({Type, ByteSize}) ->
+                    CheckIlligalSize =
+                        fun(S) ->
+                            Key = <<42:S/unit:8>>,
+                            EncodedKey = ?TEST_MODULE:encode(Type, Key),
+                            {error, invalid_encoding} = ?TEST_MODULE:safe_decode(Type, EncodedKey)
+                        end,
+                    CheckIlligalSize(0),
+                    CheckIlligalSize(ByteSize - 1),
+                    CheckIlligalSize(ByteSize + 1)
+              end,
+              ?TYPES)
+      end
+     },
+     {"Missing prefix",
+      fun() ->
+          lists:foreach(
+              fun({Type, Size0}) ->
+                    ByteSize =
+                        case Size0 of
+                            not_applicable -> 42;
+                            _ when is_integer(Size0) -> Size0
+                        end,
+                    Key = <<42:ByteSize/unit:8>>,
+                    EncodedKey = ?TEST_MODULE:encode(Type, Key),
+                    <<_PartOfPrefix:1/unit:8, RestOfKey/binary>> = EncodedKey,
+                    {error, invalid_encoding} = ?TEST_MODULE:safe_decode(Type, RestOfKey),
+
+                    <<_PrefixWithoutDelimiter:2/unit:8, RestOfKey1/binary>> = EncodedKey,
+                    {error, invalid_encoding} = ?TEST_MODULE:safe_decode(Type, RestOfKey1),
+
+                    <<_WholePrefix:3/unit:8, RestOfKey2/binary>> = EncodedKey,
+                    {error, invalid_encoding} = ?TEST_MODULE:safe_decode(Type, RestOfKey2)
+              end,
+              ?TYPES)
+      end
+     },
+     {"Piece of encoded key",
+      fun() ->
+          lists:foreach(
+              fun({Type, Size0}) ->
+                    ByteSize =
+                        case Size0 of
+                            not_applicable -> 42;
+                            _ when is_integer(Size0) -> Size0
+                        end,
+                    Key = <<42:ByteSize/unit:8>>,
+                    EncodedKey = ?TEST_MODULE:encode(Type, Key),
+                    HalfKeySize = byte_size(EncodedKey) div 2,
+                    <<HalfKey:HalfKeySize/unit:8, RestOfKey/binary>> = EncodedKey,
+                    {error, invalid_encoding} = ?TEST_MODULE:safe_decode(Type, HalfKey),
+                    {error, invalid_encoding} = ?TEST_MODULE:safe_decode(Type, RestOfKey)
+              end,
+              ?TYPES)
+      end
+     },
+     {"Encode/decode binary with only zeros",
+      fun() ->
+          Bins = [<<0:Size/unit:8>> || Size <- lists:seq(1,64)],
+          lists:foreach(
+            fun(Bin) ->
+                lists:foreach(
+                  fun({Type, S}) ->
+                      case S =:= byte_size(Bin) orelse S =:= not_applicable of
+                        true ->
+                          Encoded = ?TEST_MODULE:encode(Type, Bin),
+                          {ok, Decoded} = ?TEST_MODULE:safe_decode(Type, Encoded),
+                          ?assertEqual(Decoded, Bin);
+                        false ->
+                          ok
+                      end,
+                      Encoded1 = base58:binary_to_base58(Bin),
+                      Decoded1 = base58:base58_to_binary(Encoded1),
+                      ?assertEqual(Bin, Decoded1)
+                  end, ?TYPES)
+            end,
+            Bins)
+      end}
+     ].