Merge pull request #104 from permaweb/feat/multi-attestations

impl: multisignature messages and hashpath/cache reorg

Author: samcamwilliams

erlang_ls.config

@@ -6,18 +6,11 @@ diagnostics:
 apps_dirs:
   - "src"
   - "src/*"
-deps_dirs:
-  - "_build/default/lib/b64fast"
-  - "_build/default/lib/cowboy"
-  - "_build/default/lib/gun"
-  - "_build/default/lib/jiffy"
 include_dirs:
   - "src/include"
 include_dirs:
   - "src"
   - "src/include"
-  - "_build/default/lib/"
-  - "_build/default/lib/*/include"
 lenses:
   enabled:
     - ct-run-test

src/ar_bundles.erl

@@ -5,7 +5,6 @@
 -export([new_item/4, sign_item/2, verify_item/1]).
 -export([encode_tags/1, decode_tags/1]).
 -export([serialize/1, serialize/2, deserialize/1, deserialize/2]).
--export([item_to_json_struct/1, json_struct_to_item/1]).
 -export([data_item_signature_data/1]).
 -export([normalize/1]).
 -export([print/1, format/1, format/2]).
@@ -385,7 +384,7 @@ serialize(RawTX, binary) ->
     >>;
 serialize(TX, json) ->
     true = enforce_valid_tx(TX),
-    jiffy:encode(item_to_json_struct(TX)).
+    jiffy:encode(hb_message:convert(TX, <<"ans104@1.0">>, #{})).
 
 %% @doc Take an item and ensure that it is of valid form. Useful for ensuring
 %% that a message is viable for serialization/deserialization before execution.
@@ -680,11 +679,8 @@ deserialize(Binary, binary) ->
 %end;
 deserialize(Bin, json) ->
     try
-        normalize(
-            maybe_unbundle(
-                json_struct_to_item(element(1, jiffy:decode(Bin)))
-            )
-        )
+        Map = jiffy:decode(Bin, [return_maps]),
+        hb_message:convert(Map, <<"ans104@1.0">>, #{})
     catch
         _:_:_Stack ->
             {error, invalid_item}
@@ -781,91 +777,6 @@ decode_bundle_header(0, ItemsBin, Header) ->
 decode_bundle_header(Count, <<Size:256/integer, ID:32/binary, Rest/binary>>, Header) ->
     decode_bundle_header(Count - 1, Rest, [{ID, Size} | Header]).
 
-item_to_json_struct(
-    #tx{
-        id = ID,
-        last_tx = Last,
-        owner = Owner,
-        tags = Tags,
-        target = Target,
-        data = Data,
-        signature = Sig
-    }
-) ->
-    % Set "From" if From-Process is Tag or set with "Owner" address
-    ?event({invoked_item_to_json_struct, {tags, Tags}, {owner, Owner}, {data, Data}}),
-    From =
-        case lists:filter(fun({Name, _}) -> Name =:= <<"From-Process">> end, Tags) of
-            [{_, FromProcess}] -> FromProcess;
-            [] -> hb_util:encode(ar_wallet:to_address(Owner))
-        end,
-    Fields = [
-        {<<"Id">>, hb_util:encode(ID)},
-        % NOTE: In Arweave TXs, these are called "last_tx"
-        {<<"Anchor">>, hb_util:encode(Last)},
-        % NOTE: When sent to ao "Owner" is the wallet address
-        {<<"Owner">>, hb_util:encode(ar_wallet:to_address(Owner))},
-        {<<"From">>, From},
-        {<<"Tags">>,
-            lists:map(
-                fun({Name, Value}) ->
-                    {
-                        [
-                            {name, maybe_list_to_binary(Name)},
-                            {value, maybe_list_to_binary(Value)}
-                        ]
-                    }
-                end,
-                Tags
-            )},
-        {<<"Target">>, hb_util:encode(Target)},
-        {<<"Data">>, Data},
-        {<<"Signature">>, hb_util:encode(Sig)}
-    ],
-    {Fields}.
-
-maybe_list_to_binary(List) when is_list(List) ->
-    list_to_binary(List);
-maybe_list_to_binary(Bin) ->
-    Bin.
-
-json_struct_to_item(Map) when is_map(Map) ->
-    deserialize(jiffy:encode(Map), json);
-json_struct_to_item({TXStruct}) ->
-    json_struct_to_item(TXStruct);
-json_struct_to_item(RawTXStruct) ->
-    TXStruct = [{string:lowercase(FieldName), Value} || {FieldName, Value} <- RawTXStruct],
-    Tags =
-        case hb_util:find_value(<<"tags">>, TXStruct) of
-            undefined ->
-                [];
-            Xs ->
-                Xs
-        end,
-    TXID = hb_util:decode(hb_util:find_value(<<"id">>, TXStruct, hb_util:encode(?DEFAULT_ID))),
-    #tx{
-        format = ans104,
-        id = TXID,
-        last_tx = hb_util:decode(hb_util:find_value(<<"anchor">>, TXStruct, <<>>)),
-        owner = hb_util:decode(
-            hb_util:find_value(<<"owner">>, TXStruct, hb_util:encode(?DEFAULT_OWNER))
-        ),
-        tags =
-            lists:map(
-                fun({KeyVals}) ->
-                    {_, Name} = lists:keyfind(<<"name">>, 1, KeyVals),
-                    {_, Value} = lists:keyfind(<<"value">>, 1, KeyVals),
-                    {Name, Value}
-                end,
-                Tags
-            ),
-        target = hb_util:decode(hb_util:find_value(<<"target">>, TXStruct, <<>>)),
-        data = hb_util:find_value(<<"data">>, TXStruct, <<>>),
-        signature = hb_util:decode(
-            hb_util:find_value(<<"signature">>, TXStruct, hb_util:encode(?DEFAULT_SIG))
-        )
-    }.
-
 %% @doc Decode the signature from a binary format. Only RSA 4096 is currently supported.
 %% Note: the signature type '1' corresponds to RSA 4096 - but it is is written in
 %% little-endian format which is why we match on `<<1, 0>>'.

src/ar_http.erl

@@ -195,7 +195,7 @@ handle_info({gun_error, PID, Reason},
 					ok
 			end,
 			gun:shutdown(PID),
-			?event(debug, {connection_error, {reason, Reason}}),
+			?event({connection_error, {reason, Reason}}),
 			{noreply, State#state{ status_by_pid = StatusByPID2, pid_by_peer = PIDByPeer2 }}
 	end;
 
@@ -309,7 +309,7 @@ parse_peer(Peer, Opts) ->
         [Host, Port] ->
             {binary_to_list(Host), parse_port(Port)};
         [Host] ->
-            {binary_to_list(Host), hb_opts:get(http_port, 443, Opts)}
+            {binary_to_list(Host), hb_opts:get(port, 443, Opts)}
     end.
 
 parse_port(Port) ->

src/hb_codec_tx.erl src/dev_codec_ans104.erlsrc/hb_codec_tx.erl renamed to src/dev_codec_ans104.erl

@@ -1,7 +1,7 @@
 %%% @doc Codec for managing transformations from `ar_bundles`-style Arweave TX
 %%% records to and from TABMs.
--module(hb_codec_tx).
--export([to/1, from/1]).
+-module(dev_codec_ans104).
+-export([to/1, from/1, attest/3, verify/3]).
 -include("include/hb.hrl").
 
 %% The size at which a value should be made into a body item, instead of a
@@ -11,7 +11,6 @@
 -define(TX_KEYS,
     [
         <<"id">>,
-        <<"unsigned_id">>,
         <<"last_tx">>,
         <<"owner">>,
         <<"target">>,
@@ -26,6 +25,48 @@
     ]
 ).
 
+%% @doc Sign a message using the `priv_wallet` key in the options.
+attest(Msg, _Req, Opts) ->
+    Signed = ar_bundles:sign_item(
+        to(Msg),
+        Wallet = hb_opts:get(priv_wallet, no_viable_wallet, Opts)
+    ),
+    ID = Signed#tx.id,
+    Owner = Signed#tx.owner,
+    Sig = Signed#tx.signature,
+    Address = hb_util:human_id(ar_wallet:to_address(Wallet)),
+    % Gather the prior attestations.
+    PriorAttestations = maps:get(<<"attestations">>, Msg, #{}),
+    Attestation =
+        #{
+            <<"attestation-device">> => <<"ans104@1.0">>,
+            <<"id">> => ID,
+            <<"owner">> => Owner,
+            <<"signature">> => Sig
+        },
+    AttestationWithHP =
+        case Msg of
+            #{ <<"hashpath">> := Hashpath } ->
+                Attestation#{ <<"hashpath">> => Hashpath };
+            _ -> Attestation
+        end,
+    MsgWithoutHP = maps:without([<<"hashpath">>], Msg),
+    {ok,
+        MsgWithoutHP#{
+            <<"attestations">> =>
+                PriorAttestations#{
+                    Address => AttestationWithHP
+                }
+        }
+    }.
+
+%% @doc Verify an ANS-104 attestation.
+verify(Msg, _Req, _Opts) ->
+    MsgWithoutAttestations = maps:without([<<"attestations">>], Msg),
+    TX = to(MsgWithoutAttestations),
+    Res = ar_bundles:verify_item(TX),
+    {ok, Res}.
+
 %% @doc Convert a #tx record into a message map recursively.
 from(Binary) when is_binary(Binary) -> Binary;
 from(TX) when is_record(TX, tx) ->

src/hb_codec_flat.erl src/dev_codec_flat.erlsrc/hb_codec_flat.erl renamed to src/dev_codec_flat.erl

@@ -1,10 +1,15 @@
-%%% A codec for turning TABMs into/from flat Erlang maps that have (potentially
-%%% multi-layer) paths as their keys, and a normal TABM binary as their value.
--module(hb_codec_flat).
--export([from/1, to/1]).
+%%% @doc A codec for turning TABMs into/from flat Erlang maps that have 
+%%% (potentially multi-layer) paths as their keys, and a normal TABM binary as 
+%%% their value.
+-module(dev_codec_flat).
+-export([from/1, to/1, attest/3, verify/3]).
 -include_lib("eunit/include/eunit.hrl").
 -include("include/hb.hrl").
 
+%%% Route signature functions to the `dev_codec_httpsig' module
+attest(Msg, Req, Opts) -> dev_codec_httpsig:attest(Msg, Req, Opts).
+verify(Msg, Req, Opts) -> dev_codec_httpsig:verify(Msg, Req, Opts).
+
 %% @doc Convert a flat map to a TABM.
 from(Bin) when is_binary(Bin) -> Bin;
 from(Map) when is_map(Map) ->
@@ -54,14 +59,14 @@ to(Map) when is_map(Map) ->
 simple_conversion_test() ->
     Flat = #{[<<"a">>] => <<"value">>},
     Nested = #{<<"a">> => <<"value">>},
-    ?assert(hb_message:match(Nested, hb_codec_flat:from(Flat))),
-    ?assert(hb_message:match(Flat, hb_codec_flat:to(Nested))).
+    ?assert(hb_message:match(Nested, dev_codec_flat:from(Flat))),
+    ?assert(hb_message:match(Flat, dev_codec_flat:to(Nested))).
 
 nested_conversion_test() ->
     Flat = #{<<"a/b">> => <<"value">>},
     Nested = #{<<"a">> => #{<<"b">> => <<"value">>}},
-    Unflattened = hb_codec_flat:from(Flat),
-    Flattened = hb_codec_flat:to(Nested),
+    Unflattened = dev_codec_flat:from(Flat),
+    Flattened = dev_codec_flat:to(Nested),
     ?assert(hb_message:match(Nested, Unflattened)),
     ?assert(hb_message:match(Flat, Flattened)).
 
@@ -78,22 +83,22 @@ multiple_paths_test() ->
         },
         <<"a">> => <<"3">>
     },
-    ?assert(hb_message:match(Nested, hb_codec_flat:from(Flat))),
-    ?assert(hb_message:match(Flat, hb_codec_flat:to(Nested))).
+    ?assert(hb_message:match(Nested, dev_codec_flat:from(Flat))),
+    ?assert(hb_message:match(Flat, dev_codec_flat:to(Nested))).
 
 binary_passthrough_test() ->
     Bin = <<"raw binary">>,
-    ?assertEqual(Bin, hb_codec_flat:from(Bin)),
-    ?assertEqual(Bin, hb_codec_flat:to(Bin)).
+    ?assertEqual(Bin, dev_codec_flat:from(Bin)),
+    ?assertEqual(Bin, dev_codec_flat:to(Bin)).
 
 deep_nesting_test() ->
     Flat = #{<<"a/b/c/d">> => <<"deep">>},
     Nested = #{<<"a">> => #{<<"b">> => #{<<"c">> => #{<<"d">> => <<"deep">>}}}},
-    Unflattened = hb_codec_flat:from(Flat),
-    Flattened = hb_codec_flat:to(Nested),
+    Unflattened = dev_codec_flat:from(Flat),
+    Flattened = dev_codec_flat:to(Nested),
     ?assert(hb_message:match(Nested, Unflattened)),
     ?assert(hb_message:match(Flat, Flattened)).
 
 empty_map_test() ->
-    ?assertEqual(#{}, hb_codec_flat:from(#{})),
-    ?assertEqual(#{}, hb_codec_flat:to(#{})).
+    ?assertEqual(#{}, dev_codec_flat:from(#{})),
+    ?assertEqual(#{}, dev_codec_flat:to(#{})).