Rename tx_block to tx_header, sort/dedup address.

Author: evoskuil

include/bitcoin/node/protocols/protocol_explore.hpp

@@ -19,6 +19,7 @@
 #ifndef LIBBITCOIN_NODE_PROTOCOLS_PROTOCOL_EXPLORE_HPP
 #define LIBBITCOIN_NODE_PROTOCOLS_PROTOCOL_EXPLORE_HPP
 
+#include <atomic>
 #include <memory>
 #include <optional>
 #include <bitcoin/node/define.hpp>
@@ -95,7 +96,7 @@ class BCN_API protocol_explore
     bool handle_get_tx(const code& ec, interface::tx,
         uint8_t version, uint8_t media, const system::hash_cptr& hash,
         bool witness) NOEXCEPT;
-    bool handle_get_tx_block(const code& ec, interface::tx_block,
+    bool handle_get_tx_header(const code& ec, interface::tx_header,
         uint8_t version, uint8_t media,
         const system::hash_cptr& hash) NOEXCEPT;
     bool handle_get_tx_fee(const code& ec, interface::tx_fee,
@@ -152,6 +153,7 @@ class BCN_API protocol_explore
         const std::optional<system::hash_cptr>& hash) NOEXCEPT;
 
     dispatcher dispatcher_{};
+    std::atomic_bool stopping_{};
 };
 
 } // namespace node

src/parse/target.cpp

@@ -199,8 +199,8 @@ code parse_target(request_t& out, const std::string_view& path) NOEXCEPT
         else
         {
             const auto component = segments[segment++];
-            if (component == "block")
-                method = "tx_block";
+            if (component == "header")
+                method = "tx_header";
             else if (component == "fee")
                 method = "tx_fee";
             else

src/protocols/protocol_explore.cpp

@@ -21,6 +21,7 @@
 #include <algorithm>
 #include <optional>
 #include <ranges>
+#include <set>
 #include <utility>
 #include <bitcoin/node/define.hpp>
 #include <bitcoin/node/parse/parse.hpp>
@@ -40,6 +41,27 @@ using namespace network::messages::peer;
 using namespace std::placeholders;
 using namespace boost::json;
 
+using point_set = std::set<chain::point>;
+using outpoint_set = std::set<chain::outpoint>;
+
+DEFINE_JSON_TO_TAG(point_set)
+{
+    point_set out{};
+    for (const auto& point : value.as_array())
+        out.insert(value_to<chain::point>(point));
+
+    return out;
+}
+
+DEFINE_JSON_TO_TAG(outpoint_set)
+{
+    outpoint_set out{};
+    for (const auto& outpoint : value.as_array())
+        out.insert(value_to<chain::outpoint>(outpoint));
+
+    return out;
+}
+
 // Avoiding namespace conflict.
 using object_type = network::rpc::object_t;
 
@@ -70,7 +92,7 @@ void protocol_explore::start() NOEXCEPT
     SUBSCRIBE_EXPLORE(handle_get_block_tx, _1, _2, _3, _4, _5, _6, _7, _8);
 
     SUBSCRIBE_EXPLORE(handle_get_tx, _1, _2, _3, _4, _5, _6);
-    SUBSCRIBE_EXPLORE(handle_get_tx_block, _1, _2, _3, _4, _5);
+    SUBSCRIBE_EXPLORE(handle_get_tx_header, _1, _2, _3, _4, _5);
     SUBSCRIBE_EXPLORE(handle_get_tx_fee, _1, _2, _3, _4, _5);
 
     SUBSCRIBE_EXPLORE(handle_get_inputs, _1, _2, _3, _4, _5, _6);
@@ -94,6 +116,7 @@ void protocol_explore::start() NOEXCEPT
 void protocol_explore::stopping(const code& ec) NOEXCEPT
 {
     BC_ASSERT(stranded());
+    stopping_.store(true);
     dispatcher_.stop(ec);
     protocol_html::stopping(ec);
 }
@@ -532,37 +555,40 @@ bool protocol_explore::handle_get_tx(const code& ec, interface::tx, uint8_t,
     return true;
 }
 
-bool protocol_explore::handle_get_tx_block(const code& ec, interface::tx_block,
+bool protocol_explore::handle_get_tx_header(const code& ec, interface::tx_header,
     uint8_t, uint8_t media, const hash_cptr& hash) NOEXCEPT
 {
     if (stopped(ec))
         return false;
 
     const auto& query = archive();
-    const auto block = query.to_confirmed_block(*hash);
-    if (block.is_terminal())
+    const auto link = query.to_confirmed_block(*hash);
+    if (link.is_terminal())
     {
         send_not_found();
         return true;
     }
 
-    const auto key = query.get_header_key(block);
-    if (key == null_hash)
+    const auto header = query.get_header(link);
+    if (!header)
     {
         send_internal_server_error(database::error::integrity);
         return true;
     }
 
+    constexpr auto size = chain::header::serialized_size();
     switch (media)
     {
         case data:
-            send_chunk(to_chunk(key));
+            send_chunk(to_bin(*header, size));
             return true;
         case text:
-            send_text(encode_base16(key));
+            send_text(to_hex(*header, size));
             return true;
         case json:
-            send_json(value_from(encode_hash(key)), two * hash_size);
+            auto model = value_from(header);
+            inject(model, {}, link);
+            send_json(std::move(model), two * size);
             return true;
     }
 
@@ -893,12 +919,9 @@ bool protocol_explore::handle_get_output_spenders(const code& ec,
         return true;
     }
 
-    // TODO: dedup and lexical sort.
-    chain::points out(points.size());
-    std::ranges::transform(points, out.begin(), [&](const auto& link) NOEXCEPT
-    {
-        return query.get_spender(link);
-    });
+    point_set out{};
+    for (const auto& point: points)
+        out.insert(query.get_spender(point));
 
     const auto size = out.size() * chain::point::serialized_size();
     switch (media)
@@ -931,8 +954,10 @@ bool protocol_explore::handle_get_address(const code& ec, interface::address,
         return true;
     }
 
+    // TODO: post queries to thread (both stopping() and this are stranded).
+
     database::output_links outputs{};
-    if (!query.to_address_outputs(outputs, *hash))
+    if (!query.to_address_outputs(stopping_, outputs, *hash))
     {
         send_internal_server_error(database::error::integrity);
         return true;
@@ -944,14 +969,11 @@ bool protocol_explore::handle_get_address(const code& ec, interface::address,
         return true;
     }
 
-    // TODO: dedup and lexical sort.
-    chain::points out(outputs.size());
-    std::ranges::transform(outputs, out.begin(), [&](const auto& link) NOEXCEPT
-    {
-        return query.get_spent(link);
-    });
+    outpoint_set out{};
+    for (const auto& output: outputs)
+        out.insert(query.get_spent(output));
 
-    const auto size = out.size() * chain::point::serialized_size();
+    const auto size = out.size() * chain::outpoint::serialized_size();
     switch (media)
     {
         case data:

test/parse/target.cpp

@@ -424,15 +424,15 @@ BOOST_AUTO_TEST_CASE(parse__parse_target__tx_invalid_component__invalid_componen
     BOOST_REQUIRE_EQUAL(parse_target(out, path), node::error::invalid_component);
 }
 
-// tx_block
+// tx_header
 
-BOOST_AUTO_TEST_CASE(parse__parse_target__tx_block_valid__expected)
+BOOST_AUTO_TEST_CASE(parse__parse_target__tx_header_valid__expected)
 {
-    const std::string path = "/v42/tx/0000000000000000000000000000000000000000000000000000000000000042/block";
+    const std::string path = "/v42/tx/0000000000000000000000000000000000000000000000000000000000000042/header";
 
     request_t request{};
     BOOST_REQUIRE(!parse_target(request, path));
-    BOOST_REQUIRE_EQUAL(request.method, "tx_block");
+    BOOST_REQUIRE_EQUAL(request.method, "tx_header");
     BOOST_REQUIRE(request.params.has_value());
 
     const auto& params = request.params.value();
@@ -452,16 +452,16 @@ BOOST_AUTO_TEST_CASE(parse__parse_target__tx_block_valid__expected)
     BOOST_REQUIRE_EQUAL(to_uintx(*hash_cptr), uint256_t{ 0x42 });
 }
 
-BOOST_AUTO_TEST_CASE(parse__parse_target__tx_block_invalid_component__invalid_component)
+BOOST_AUTO_TEST_CASE(parse__parse_target__tx_header_invalid_component__invalid_component)
 {
     const std::string path = "/v3/tx/0000000000000000000000000000000000000000000000000000000000000000/invalid";
     request_t out{};
     BOOST_REQUIRE_EQUAL(parse_target(out, path), node::error::invalid_component);
 }
 
-BOOST_AUTO_TEST_CASE(parse__parse_target__tx_block_extra_segment__extra_segment)
+BOOST_AUTO_TEST_CASE(parse__parse_target__tx_header_extra_segment__extra_segment)
 {
-    const std::string path = "/v3/tx/0000000000000000000000000000000000000000000000000000000000000000/block/extra";
+    const std::string path = "/v3/tx/0000000000000000000000000000000000000000000000000000000000000000/header/extra";
     request_t out{};
     BOOST_REQUIRE_EQUAL(parse_target(out, path), node::error::extra_segment);
 }