Add federated block-signing server implementation

src/federation.cpp

@@ -11,6 +11,7 @@
 #include <miner.h>
 #include <netaddress.h>
 #include <netbase.h>
+#include <netmessagemaker.h>
 #include <net.h>
 #include <node/context.h>
 #include <pow.h>
@@ -237,12 +238,57 @@ static bool ReadFederationOpts() {
     return !errors;
 }
 
+//! A record of which nodes have identified themselves as block-signing peers,
+//! and their associated public keys.
+static std::map<NodeId, CPubKey> g_fednode_conn;
+
 //! The current block proposal, which is announced by the leader at the
 //! beginning of their round.
 static CBlock g_block_proposal;
 //! A collection of valid signatures for the proposed block of the current round.
 static std::map<CPubKey, std::vector<unsigned char>> g_block_sigs;
 
+// Our peer-to-peer messages all transmitted as NetMsgType::BLOCKSIGN messages
+// on the wire.  We differentiate the type of message for our own purposes with
+// a sub-message command, a single byte value at the beginning of the message
+// payload.
+namespace BlockSignMsgType {
+const unsigned char VER      = 0;
+const unsigned char VERACK   = 1;
+} // namespace BlockSignMsgType
+
+// Checks if the specified peer is in the whitelist, and if so sends it a VER
+// message.
+static void HandshakePeer(CNode* pnode) {
+    LOCK(cs_block_signer);
+
+    if (g_fednode_conn.count(pnode->GetId())) {
+        // Already handshaked
+        return;
+    }
+
+    bool match = false;
+    for (const auto& subnet : g_whitelist) {
+        if (subnet.Match(pnode->addr)) {
+            match = true;
+            break;
+        }
+    }
+
+    if (match) {
+        g_context->connman->PushMessage(pnode, CNetMsgMaker(pnode->GetCommonVersion()).Make(
+            NetMsgType::BLOCKSIGN,
+            BlockSignMsgType::VER,
+            g_our_block_signing_key));
+    }
+}
+
+// Checks if the connection manager has connected to any new nodes since we were
+// last called, and attempts a handshake if these nodes are in the whitelist.
+static void HandshakeNewConnections() {
+    g_context->connman->ForEachNode(HandshakePeer);
+}
+
 static bool GenerateBlockProposal()
 {
     const CChainParams& params = Params();
@@ -411,6 +457,11 @@ void ThreadBlockSigner(NodeContext& node)
     // Make node context accessible everywhere from within this file.
     g_context = &node;
 
+    if (!g_context->connman) {
+        LogPrint(BCLog::FEDERATION, "Error: peer-to-peer functionality missing or disabled.  Unable to start block signer.\n");
+        return;
+    }
+
     // Parse the various federation and block signing configuration
     // options and initialize the global variable state accordingly.
     if (!ReadFederationOpts()) {
@@ -428,6 +479,8 @@ void ThreadBlockSigner(NodeContext& node)
             std::chrono::steady_clock::now().time_since_epoch()));
 
     while (true) {
+        HandshakeNewConnections();
+
         // Sleep this thread until the start of the next block interval.
         nextblocktime += std::chrono::minutes{1};
         if (!g_thread_interrupt.sleep_until(nextblocktime)) {
@@ -467,4 +520,65 @@ void ThreadBlockSigner(NodeContext& node)
     }
 }
 
+void HandleBlockSignMessage(CNode& from, CDataStream& msg, std::chrono::microseconds time_received, const std::atomic<bool>& interrupt_msg_proc)
+{
+    unsigned char code;
+    msg >> code;
+
+    switch (code) {
+        case BlockSignMsgType::VER:
+        case BlockSignMsgType::VERACK:
+        {
+            LOCK(cs_block_signer);
+
+            CPubKey other;
+            msg >> other;
+            if (!other.IsFullyValid()) {
+                LogPrint(BCLog::FEDERATION, "Received blocksign::VER%s message with invalid/malformed public key.  Ignoring.\n", (code == BlockSignMsgType::VERACK) ? "ACK" : "");
+                break;
+            }
+            if (std::find(g_block_signing_keys.begin(), g_block_signing_keys.end(), other) == g_block_signing_keys.end()) {
+                std::string pkstr(HexStr(CDataStream(SER_NETWORK, CLIENT_VERSION) << other), 2);
+                LogPrint(BCLog::FEDERATION, "Received blocksign::VER%s message with unrecognized public key %s.  Ignoring.\n", (code == BlockSignMsgType::VERACK) ? "ACK" : "", pkstr);
+                break;
+            }
+            if (!g_block_signers.count(other)) {
+                std::string pkstr(HexStr(CDataStream(SER_NETWORK, CLIENT_VERSION) << other), 2);
+                LogPrint(BCLog::FEDERATION, "Received blocksign::VER%s message with known public key, but cannot find record for peer: %s.  Ignoring.  Are you missing a a '-blocksignnode=%s:<ip:port>' configuration parameter?\n", (code == BlockSignMsgType::VERACK) ? "ACK" : "", pkstr, pkstr);
+                break;
+            }
+
+            g_fednode_conn[from.GetId()] = other;
+            g_block_signers[other].m_nodes.insert(from.GetId());
+
+            if (code == BlockSignMsgType::VERACK) {
+                break;
+            }
+
+            // FIXME: Don't duplicate HandshakePeer
+            bool match = false;
+            for (const auto& subnet : g_whitelist) {
+                if (subnet.Match(from.addr)) {
+                    match = true;
+                    break;
+                }
+            }
+
+            if (!match) {
+                break;
+            }
+
+            g_context->connman->PushMessage(&from, CNetMsgMaker(from.GetCommonVersion()).Make(
+                NetMsgType::BLOCKSIGN,
+                BlockSignMsgType::VERACK,
+                g_our_block_signing_key));
+        }
+        break;
+
+        default:
+            LogPrint(BCLog::FEDERATION, "Received an unrecognized blocksign message (code=%d) from peer=%d.  Ignoring.\n", code, from.GetId());
+        break;
+    }
+}
+
 // End of File

src/federation.h

@@ -5,7 +5,13 @@
 #ifndef BITCOIN_FEDERATION_H
 #define BITCOIN_FEDERATION_H
 
+#include <net.h>
 #include <node/context.h>
+#include <streams.h>
+
+#include <atomic>
+#include <chrono>
+#include <cstdint>
 
 /** Run an instance of the block-signing protocol manager. */
 void ThreadBlockSigner(NodeContext &node);
@@ -15,6 +21,10 @@ void ThreadBlockSigner(NodeContext &node);
 // routine.  This should be investigated and removed if possible.
 void InterruptBlockSignerThread();
 
+/** Called by the code in net_processing.cpp, handles a BLOCKSIGN message from a
+ ** federation peer. */
+void HandleBlockSignMessage(CNode& from, CDataStream& msg, std::chrono::microseconds time_received, const std::atomic<bool>& interrupt_msg_proc);
+
 #endif // BITCOIN_FEDERATION_H
 
 // End of File

src/net_processing.cpp

@@ -11,6 +11,7 @@
 #include <blockfilter.h>
 #include <chainparams.h>
 #include <consensus/validation.h>
+#include <federation.h>
 #include <hash.h>
 #include <index/blockfilterindex.h>
 #include <merkleblock.h>
@@ -3750,6 +3751,11 @@ void PeerManager::ProcessMessage(CNode& pfrom, const std::string& msg_type, CDat
         return;
     }
 
+    if (msg_type == NetMsgType::BLOCKSIGN) {
+        HandleBlockSignMessage(pfrom, vRecv, time_received, interruptMsgProc);
+        return;
+    }
+
     // Ignore unknown commands for extensibility
     LogPrint(BCLog::NET, "Unknown command \"%s\" from peer=%d\n", SanitizeString(msg_type), pfrom.GetId());
     return;

src/protocol.cpp

@@ -38,6 +38,7 @@ const char *SENDCMPCT="sendcmpct";
 const char *CMPCTBLOCK="cmpctblock";
 const char *GETBLOCKTXN="getblocktxn";
 const char *BLOCKTXN="blocktxn";
+const char *BLOCKSIGN="blocksign";
 const char *GETCFILTERS="getcfilters";
 const char *CFILTER="cfilter";
 const char *GETCFHEADERS="getcfheaders";

src/protocol.h

@@ -218,6 +218,9 @@ extern const char* GETBLOCKTXN;
  * @since protocol version 70014 as described by BIP 152
  */
 extern const char* BLOCKTXN;
+/**
+ */
+extern const char *BLOCKSIGN;
 /**
  * getcfilters requests compact filters for a range of blocks.
  * Only available with service bit NODE_COMPACT_FILTERS as described by