dash(s8-p2p.2): Legacy/Actual/NodeBridge sharechain-p2p dispatch layer + 12-handler KATs (#656)

Author: frstrtr

src/impl/dash/CMakeLists.txt

@@ -35,3 +35,25 @@ target_include_directories(dash_rpc PRIVATE
     ${CMAKE_SOURCE_DIR}/src/btclibs
     ${CMAKE_SOURCE_DIR}/include)
 target_link_libraries(dash_rpc PRIVATE core nlohmann_json::nlohmann_json ${Boost_LIBRARIES})
+
+# S8 sharechain-p2p dispatch layer (slice S8-p2p.2). Mirrors the dgb pool OBJECT
+# lib (src/impl/dgb/CMakeLists.txt add_library(dgb OBJECT ...)): compiles the
+# Legacy/Actual established-peer protocol handlers so the 12-message dispatch
+# surface is a real compiled TU. node.cpp (the NodeImpl reception/think TU) is
+# slice .4 and does NOT exist yet, so this OBJECT lib is intentionally NOT linked
+# into any executable here -- processing_shares()/handle_get_share() are declared
+# in node.hpp and their definitions are link-deferred to slice .4. Object-compile
+# only; SAFE-ADDITIVE (no existing target links `dash`, so ltc/btc/doge/dgb build
+# + ctest surfaces are untouched). Per-coin isolation held: src/impl/dash only.
+add_library(dash OBJECT
+    node.hpp
+    peer.hpp
+    messages.hpp
+    share.hpp
+    protocol_actual.cpp protocol_legacy.cpp
+)
+target_include_directories(dash PRIVATE
+    ${CMAKE_SOURCE_DIR}/src
+    ${CMAKE_SOURCE_DIR}/src/btclibs
+    ${CMAKE_SOURCE_DIR}/include)
+target_link_libraries(dash core pool sharechain c2pool_storage dash_x11 btclibs nlohmann_json::nlohmann_json ${Boost_LIBRARIES} ${SECP256K1_LIBRARIES})

src/impl/dash/node.hpp

@@ -25,13 +25,15 @@
 #include "coin/transaction.hpp"
 
 #include <pool/node.hpp>
+#include <pool/protocol.hpp>
 #include <core/reply_matcher.hpp>
 #include <c2pool/storage/sharechain_storage.hpp>
 
 #include <boost/asio/thread_pool.hpp>
 #include <boost/asio/steady_timer.hpp>
 
 #include <atomic>
+#include <functional>
 #include <map>
 #include <memory>
 #include <mutex>
@@ -97,6 +99,14 @@ class NodeImpl : public pool::BaseNode<dash::Config, dash::ShareChain, dash::Pee
     // daemon. Reception-slice protocol handlers look up tx hashes here.
     std::map<uint256, coin::Transaction> m_known_txs;
 
+    // Wire-message parser used by the Legacy/Actual dispatch protocols to turn
+    // a RawMessage into a typed message variant. Mirrors dgb::NodeImpl::m_handler.
+    dash::Handler m_handler;
+
+    // Callback fired when a bestblock message is received from a peer; wired by
+    // the work layer (slice .4) to trigger a work refresh. Mirrors dgb.
+    std::function<void(const uint256&)> m_on_bestblock;
+
     // Thread pool for parallel share_init_verify (X11 CPU work). Keeps the
     // expensive crypto off the io_context thread.
     boost::asio::thread_pool m_verify_pool{4};
@@ -309,6 +319,27 @@ class NodeImpl : public pool::BaseNode<dash::Config, dash::ShareChain, dash::Pee
                    : pool::PeerConnectionType::legacy;
     }
 
+    // ── Reception-slice (B) dispatch surface ───────────────────
+    // Declarations consumed by the Legacy/Actual protocol handlers
+    // (protocol_legacy.cpp / protocol_actual.cpp). The bodies of
+    // processing_shares() and handle_get_share() live in the node.cpp
+    // translation unit (slice .4) and are intentionally link-deferred here;
+    // the dispatch layer object-compiles against these declarations.
+    void processing_shares(HandleSharesData& data, NetService addr);
+    std::vector<dash::ShareType> handle_get_share(std::vector<uint256> hashes,
+        uint64_t parents, std::vector<uint256> stops, NetService peer_addr);
+
+    // Completes a pending async share request when a sharereply arrives.
+    // Inline (mirrors dgb) so the reply-matcher plumbing needs no node.cpp.
+    void got_share_reply(uint256 id, dash::ShareReplyData shares)
+    {
+        try { m_share_getter.got_response(id, shares); }
+        catch (const std::invalid_argument&) { /* request already timed out */ }
+    }
+
+    // Register a callback fired when a bestblock message is received from a peer.
+    void set_on_bestblock(std::function<void(const uint256&)> fn) { m_on_bestblock = std::move(fn); }
+
     // ── Tracker accessors ───────────────────────────────────────────────
 
     /// Direct tracker access — compute-thread-only (already holds the exclusive
@@ -379,4 +410,53 @@ class NodeImpl : public pool::BaseNode<dash::Config, dash::ShareChain, dash::Pee
     }
 };
 
+// ── Sharechain-p2p dispatch layer (slice S8-p2p.2) ──────────────────
+// Namespace-only port of the dgb reference (src/impl/dgb/node.hpp:647). The
+// version-handshake reception rides NodeImpl::handle_version above; the two
+// established-peer protocols below dispatch the 12 post-handshake messages.
+// Both Legacy and Actual register the identical handler set; the divergence
+// between them lives in the handler BODIES (protocol_legacy.cpp vs
+// protocol_actual.cpp), byte-parity with dgb. handle_message() bodies + the
+// 12 HANDLER() bodies are defined in those two .cpp translation units.
+
+class Legacy : public pool::Protocol<NodeImpl>
+{
+public:
+    void handle_message(std::unique_ptr<RawMessage> rmsg, NodeImpl::peer_ptr peer) override;
+
+    ADD_HANDLER(addrs, dash::message_addrs);
+    ADD_HANDLER(addrme, dash::message_addrme);
+    ADD_HANDLER(ping, dash::message_ping);
+    ADD_HANDLER(getaddrs, dash::message_getaddrs);
+    ADD_HANDLER(shares, dash::message_shares);
+    ADD_HANDLER(sharereq, dash::message_sharereq);
+    ADD_HANDLER(sharereply, dash::message_sharereply);
+    ADD_HANDLER(bestblock, dash::message_bestblock);
+    ADD_HANDLER(have_tx, dash::message_have_tx);
+    ADD_HANDLER(losing_tx, dash::message_losing_tx);
+    ADD_HANDLER(remember_tx, dash::message_remember_tx);
+    ADD_HANDLER(forget_tx, dash::message_forget_tx);
+};
+
+class Actual : public pool::Protocol<NodeImpl>
+{
+public:
+    void handle_message(std::unique_ptr<RawMessage> rmsg, NodeImpl::peer_ptr peer) override;
+
+    ADD_HANDLER(addrs, dash::message_addrs);
+    ADD_HANDLER(addrme, dash::message_addrme);
+    ADD_HANDLER(ping, dash::message_ping);
+    ADD_HANDLER(getaddrs, dash::message_getaddrs);
+    ADD_HANDLER(shares, dash::message_shares);
+    ADD_HANDLER(sharereq, dash::message_sharereq);
+    ADD_HANDLER(sharereply, dash::message_sharereply);
+    ADD_HANDLER(bestblock, dash::message_bestblock);
+    ADD_HANDLER(have_tx, dash::message_have_tx);
+    ADD_HANDLER(losing_tx, dash::message_losing_tx);
+    ADD_HANDLER(remember_tx, dash::message_remember_tx);
+    ADD_HANDLER(forget_tx, dash::message_forget_tx);
+};
+
+using Node = pool::NodeBridge<NodeImpl, Legacy, Actual>;
+
 } // namespace dash