BIP ???: Serve block undo data

Author: rustaceanrob

src/compressor.h

@@ -95,6 +95,162 @@ struct ScriptCompression
     }
 };
 
+enum class ReconstructableScriptType: unsigned char {
+    Unknown = 0x00,
+    P2pkh = 0x01,
+    P2pkEven = 0x02,
+    P2pkOdd = 0x03,
+    P2pkUncompressed = 0x04,
+    P2sh = 0x06,
+    P2wsh = 0x07,
+    P2wpkh = 0x08,
+    P2tr = 0x09,
+};
+
+template <typename Stream>
+void Serialize(Stream& s, ReconstructableScriptType type)
+{
+    ::Serialize(s, static_cast<uint8_t>(type));
+}
+
+struct ReconstructableScript {
+    template<typename Stream>
+    void Ser(Stream& s, const CScript& script)
+    {
+        if (script.IsPayToTaproot()) {
+            ::Serialize(s, ReconstructableScriptType::P2tr);
+            ::Serialize(s, MakeByteSpan(script).subspan(2, 32));
+            return;
+        }
+        if (script.IsPayToWitnessScriptHash()) {
+            ::Serialize(s, ReconstructableScriptType::P2wsh);
+            ::Serialize(s, MakeByteSpan(script).subspan(2, 32));
+            return;
+        }
+        if (script.size() == 22 && script[0] == OP_0 && script[1] == 20) {
+            ::Serialize(s, ReconstructableScriptType::P2wpkh);
+            ::Serialize(s, MakeByteSpan(script).subspan(2, 20));
+            return;
+        }
+        if (script.IsPayToScriptHash()) {
+            ::Serialize(s, ReconstructableScriptType::P2sh);
+            ::Serialize(s, MakeByteSpan(script).subspan(2, 20));
+            return;
+        }
+        if  (script.size() == 25 && script[0] == OP_DUP && script[1] == OP_HASH160
+                            && script[2] == 20 && script[23] == OP_EQUALVERIFY
+                            && script[24] == OP_CHECKSIG) {
+            ::Serialize(s, ReconstructableScriptType::P2pkh);
+            ::Serialize(s, MakeByteSpan(script).subspan(3, 20));
+            return;
+        }
+        if (script.size() == 35 && script[0] == 33 && script[34] == OP_CHECKSIG) {
+            if (script[1] == 0x02) {
+                ::Serialize(s, ReconstructableScriptType::P2pkEven);
+                ::Serialize(s, MakeByteSpan(script).subspan(2, 32));
+                return;
+            }
+            if (script[1] == 0x03) {
+                ::Serialize(s, ReconstructableScriptType::P2pkOdd);
+                ::Serialize(s, MakeByteSpan(script).subspan(2, 32));
+                return;
+            }
+        }
+        if (script.size() == 67 && script[0] == 65 && script[66] == OP_CHECKSIG && script[1] == 0x04) {
+            ::Serialize(s, ReconstructableScriptType::P2pkUncompressed);
+            ::Serialize(s, MakeByteSpan(script).subspan(2, 64));
+            return;
+        }
+        ::Serialize(s, ReconstructableScriptType::Unknown);
+        ::Serialize(s, script);
+    }
+
+    template<typename Stream>
+    void Unser(Stream& s, CScript& script)
+    {
+        unsigned char type;
+        ::Unserialize(s, type);
+        ReconstructableScriptType s_type{type};
+        switch (s_type) {
+            case ReconstructableScriptType::P2tr: {
+                std::array<unsigned char, 32> x_only;
+                ::Unserialize(s, std::span{x_only});
+                script.resize(34);
+                script[0] = OP_1;
+                script[1] = 32;
+                memcpy(&script[2], x_only.data(), 32);
+                break;
+            }
+            case ReconstructableScriptType::P2wsh: {
+                uint256 hash;
+                ::Unserialize(s, hash);
+                script.resize(34);
+                script[0] = OP_0;
+                script[1] = 32;
+                memcpy(&script[2], hash.data(), 32);
+                break;
+            }
+            case ReconstructableScriptType::P2wpkh: {
+                uint160 hash;
+                ::Unserialize(s, hash);
+                script.resize(22);
+                script[0] = OP_0;
+                script[1] = 20;
+                memcpy(&script[2], hash.data(), 20);
+                break;
+            }
+            case ReconstructableScriptType::P2sh: {
+                uint160 hash;
+                ::Unserialize(s, hash);
+                script.resize(23);
+                script[0] = OP_HASH160;
+                script[1] = 20;
+                memcpy(&script[2], hash.data(), 20);
+                script[22] = OP_EQUAL;
+                break;
+            }
+            case ReconstructableScriptType::P2pkh: {
+                uint160 hash;
+                ::Unserialize(s, hash);
+                script.resize(25);
+                script[0] = OP_DUP;
+                script[1] = OP_HASH160;
+                script[2] = 20;
+                memcpy(&script[3], hash.data(), 20);
+                script[23] = OP_EQUALVERIFY;
+                script[24] = OP_CHECKSIG;
+                break;
+            }
+            case ReconstructableScriptType::P2pkEven:
+            case ReconstructableScriptType::P2pkOdd: {
+                std::array<unsigned char, 32> xcoord;
+                ::Unserialize(s, std::span{xcoord});
+                script.resize(35);
+                script[0] = 33;
+                script[1] = type;
+                memcpy(&script[2], xcoord.data(), 32);
+                script[34] = OP_CHECKSIG;
+                break;
+            }
+            case ReconstructableScriptType::P2pkUncompressed: {
+                std::array<unsigned char, 64> public_key;
+                ::Unserialize(s, std::span{public_key});
+                script.resize(67);
+                script[0] = 65;
+                script[1] = 0x04;
+                memcpy(&script[2], public_key.data(), 64);
+                script[66] = OP_CHECKSIG;
+                break;
+            }
+            case ReconstructableScriptType::Unknown: {
+                ::Unserialize(s, script);
+                break;
+            }
+            default: break;
+        }
+    }
+};
+
 struct AmountCompression
 {
     template<typename Stream, typename I> void Ser(Stream& s, I val)

src/init.cpp

@@ -557,6 +557,7 @@ void SetupServerArgs(ArgsManager& argsman, bool can_listen_ipc)
     argsman.AddArg("-v2transport", strprintf("Support v2 transport (default: %u)", DEFAULT_V2_TRANSPORT), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg("-peerbloomfilters", strprintf("Support filtering of blocks and transaction with bloom filters (default: %u)", DEFAULT_PEERBLOOMFILTERS), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg("-peerblockfilters", strprintf("Serve compact block filters to peers per BIP 157 (default: %u)", DEFAULT_PEERBLOCKFILTERS), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
+    argsman.AddArg("-peerblockinputs", strprintf("Serve historical inputs to blocks (default: %u)", DEFAULT_PEERBLOCKUNDO), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg("-txreconciliation", strprintf("Enable transaction reconciliations per BIP 330 (default: %d)", DEFAULT_TXRECONCILIATION_ENABLE), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::CONNECTION);
     argsman.AddArg("-port=<port>", strprintf("Listen for connections on <port> (default: %u, testnet3: %u, testnet4: %u, signet: %u, regtest: %u). Not relevant for I2P (see doc/i2p.md). If set to a value x, the default onion listening port will be set to x+1.", defaultChainParams->GetDefaultPort(), testnetChainParams->GetDefaultPort(), testnet4ChainParams->GetDefaultPort(), signetChainParams->GetDefaultPort(), regtestChainParams->GetDefaultPort()), ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY, OptionsCategory::CONNECTION);
     const std::string proxy_doc_for_value =
@@ -984,6 +985,13 @@ bool AppInitParameterInteraction(const ArgsManager& args)
         g_local_services = ServiceFlags(g_local_services | NODE_COMPACT_FILTERS);
     }
 
+    if (args.GetBoolArg("-peerblockinputs", DEFAULT_PEERBLOCKUNDO)) {
+        if (args.GetIntArg("-prune", 0)) {
+            return InitError(_("Prune mode is incompatible with serving block inputs."));
+        }
+        g_local_services = ServiceFlags(g_local_services | NODE_BLOCK_UNDO);
+    }
+
     if (args.GetIntArg("-prune", 0)) {
         if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX))
             return InitError(_("Prune mode is incompatible with -txindex."));

src/net_processing.cpp

@@ -56,6 +56,7 @@
 #include <tinyformat.h>
 #include <txmempool.h>
 #include <uint256.h>
+#include <undo.h>
 #include <util/check.h>
 #include <util/strencodings.h>
 #include <util/time.h>
@@ -1076,6 +1077,8 @@ class PeerManagerImpl final : public PeerManager
      */
     void ProcessGetCFCheckPt(CNode& node, Peer& peer, DataStream& vRecv);
 
+    void ProcessGetBlockUndo(CNode& node, Peer& peer, DataStream& vRecv);
+
     /** Checks if address relay is permitted with peer. If needed, initializes
      * the m_addr_known bloom filter and sets m_addr_relay_enabled to true.
      *
@@ -3394,6 +3397,48 @@ void PeerManagerImpl::ProcessGetCFCheckPt(CNode& node, Peer& peer, DataStream& v
               headers);
 }
 
+void PeerManagerImpl::ProcessGetBlockUndo(CNode& pfrom, Peer& peer, DataStream& vRecv)
+{
+    uint256 blockhash;
+    vRecv >> blockhash;
+    uint32_t cutoff;
+    vRecv >> cutoff;
+    if ((peer.m_our_services & NODE_BLOCK_UNDO) != NODE_BLOCK_UNDO) {
+        LogDebug(BCLog::NET, "ignoring unsupported block undo request, %s\n", pfrom.DisconnectMsg(fLogIPs));
+        pfrom.fDisconnect = true;
+        return;
+    }
+    CBlockIndex* pindex{nullptr};
+    {
+        LOCK(cs_main);
+        pindex = m_chainman.m_blockman.LookupBlockIndex(blockhash);
+        if (!pindex) {
+            return;
+        }
+        if (!BlockRequestAllowed(pindex)) {
+            LogDebug(BCLog::NET, "%s: ignoring request from peer=%i for old block that isn't in the main chain\n", __func__, pfrom.GetId());
+            return;
+        }
+        // disconnect node in case we have reached the outbound limit for serving historical blocks
+        if (m_connman.OutboundTargetReached(true) &&
+            (((m_chainman.m_best_header != nullptr) && (m_chainman.m_best_header->GetBlockTime() - pindex->GetBlockTime() > HISTORICAL_BLOCK_AGE))) &&
+            !pfrom.HasPermission(NetPermissionFlags::Download) // nodes with the download permission may exceed target
+        ) {
+            LogDebug(BCLog::NET, "historical block serving limit reached, %s\n", pfrom.DisconnectMsg(fLogIPs));
+            pfrom.fDisconnect = true;
+            return;
+        }
+    }
+    CBlockUndo block_undo{};
+    if (m_chainman.m_blockman.ReadBlockUndo(block_undo, *pindex)) {
+        auto hash = pindex->GetBlockHash();
+        NetworkBlockUndo undo{hash, block_undo, cutoff};
+        MakeAndPushMessage(pfrom, NetMsgType::BLOCKUNDO, undo);
+    } else {
+        LogError("Cannot load block undo from disk, %s\n", pfrom.DisconnectMsg(fLogIPs));
+    }
+}
+
 void PeerManagerImpl::ProcessBlock(CNode& node, const std::shared_ptr<const CBlock>& block, bool force_processing, bool min_pow_checked)
 {
     bool new_block{false};
@@ -5120,6 +5165,10 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
         return;
     }
 
+    if (msg_type == NetMsgType::GETBLOCKUNDO) {
+        ProcessGetBlockUndo(pfrom, *peer, vRecv);
+    }
+
     if (msg_type == NetMsgType::NOTFOUND) {
         std::vector<CInv> vInv;
         vRecv >> vInv;

src/net_processing.h

@@ -42,6 +42,7 @@ static constexpr bool DEFAULT_TXRECONCILIATION_ENABLE{false};
 static const uint32_t DEFAULT_BLOCK_RECONSTRUCTION_EXTRA_TXN{100};
 static const bool DEFAULT_PEERBLOOMFILTERS = false;
 static const bool DEFAULT_PEERBLOCKFILTERS = false;
+static const bool DEFAULT_PEERBLOCKUNDO = false;
 /** Maximum number of outstanding CMPCTBLOCK requests for the same block. */
 static const unsigned int MAX_CMPCTBLOCKS_INFLIGHT_PER_BLOCK = 3;
 /** Number of headers sent in one getheaders result. We rely on the assumption that if a peer sends

src/protocol.cpp

@@ -99,6 +99,7 @@ static std::string serviceFlagToStr(size_t bit)
     case NODE_COMPACT_FILTERS: return "COMPACT_FILTERS";
     case NODE_NETWORK_LIMITED: return "NETWORK_LIMITED";
     case NODE_P2P_V2:          return "P2P_V2";
+    case NODE_BLOCK_UNDO:      return "BLOCK_UNDO";
     // Not using default, so we get warned when a case is missing
     }
 

src/protocol.h

@@ -216,6 +216,10 @@ inline constexpr const char* GETBLOCKTXN{"getblocktxn"};
  * @since protocol version 70014 as described by BIP 152
  */
 inline constexpr const char* BLOCKTXN{"blocktxn"};
+
+inline constexpr const char* GETBLOCKUNDO{"getbundo"};
+
+inline constexpr const char* BLOCKUNDO{"bundo"};
 /**
  * getcfilters requests compact filters for a range of blocks.
  * Only available with service bit NODE_COMPACT_FILTERS as described by
@@ -303,6 +307,8 @@ inline const std::array ALL_NET_MESSAGE_TYPES{std::to_array<std::string>({
     NetMsgType::CFCHECKPT,
     NetMsgType::WTXIDRELAY,
     NetMsgType::SENDTXRCNCL,
+    NetMsgType::BLOCKUNDO,
+    NetMsgType::GETBLOCKUNDO,
 })};
 
 /** nServices flags */
@@ -336,6 +342,7 @@ enum ServiceFlags : uint64_t {
     // collisions and other cases where nodes may be advertising a service they
     // do not actually support. Other service bits should be allocated via the
     // BIP process.
+    NODE_BLOCK_UNDO = (1 << 21),
 };
 
 /**

src/test/CMakeLists.txt

@@ -120,6 +120,7 @@ add_executable(test_bitcoin
   txvalidation_tests.cpp
   txvalidationcache_tests.cpp
   uint256_tests.cpp
+  undo_tests.cpp
   util_check_tests.cpp
   util_expected_tests.cpp
   util_string_tests.cpp