net: Add block undo data messages

Author: rustaceanrob

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,10 @@ bool AppInitParameterInteraction(const ArgsManager& args)
         g_local_services = ServiceFlags(g_local_services | NODE_COMPACT_FILTERS);
     }
 
+    if (args.GetBoolArg("-peerblockinputs"), DEFAULT_PEERBLOCKUNDO) {
+        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>
@@ -2370,6 +2371,22 @@ void PeerManagerImpl::ProcessGetBlockData(CNode& pfrom, Peer& peer, const CInv&
         block_pos = pindex->GetBlockPos();
     }
 
+    if (inv.IsMsgBlockUndo()) {
+        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;
+        }
+        CBlockUndo block_undo{};
+        if (m_chainman.m_blockman.ReadBlockUndo(block_undo, *pindex)) {
+            auto hash = pindex->GetBlockHash();
+            NetworkBlockUndo undo{hash, block_undo};
+            MakeAndPushMessage(pfrom, NetMsgType::BLOCKUNDO, undo);
+        } else {
+            LogError("Cannot load block undo from disk, %s\n", pfrom.DisconnectMsg(fLogIPs));
+        }
+    }
+
     std::shared_ptr<const CBlock> pblock;
     if (a_recent_block && a_recent_block->GetHash() == inv.hash) {
         pblock = a_recent_block;

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

@@ -69,6 +69,7 @@ std::string CInv::GetMessageType() const
     case MSG_BLOCK:          return cmd.append(NetMsgType::BLOCK);
     case MSG_FILTERED_BLOCK: return cmd.append(NetMsgType::MERKLEBLOCK);
     case MSG_CMPCT_BLOCK:    return cmd.append(NetMsgType::CMPCTBLOCK);
+    case MSG_BLOCK_UNDO:     return cmd.append(NetMsgType::BLOCKUNDO);
     default:
         throw std::out_of_range(strprintf("CInv::GetMessageType(): type=%d unknown type", type));
     }
@@ -99,6 +100,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{"getblockundo"};
+
+inline constexpr const char* BLOCKUNDO{"blockundo"};
 /**
  * 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),
 };
 
 /**
@@ -484,6 +491,7 @@ enum GetDataMsg : uint32_t {
     MSG_CMPCT_BLOCK = 4,                              //!< Defined in BIP152
     MSG_WITNESS_BLOCK = MSG_BLOCK | MSG_WITNESS_FLAG, //!< Defined in BIP144
     MSG_WITNESS_TX = MSG_TX | MSG_WITNESS_FLAG,       //!< Defined in BIP144
+    MSG_BLOCK_UNDO = 6,
     // MSG_FILTERED_WITNESS_BLOCK is defined in BIP144 as reserved for future
     // use and remains unused.
     // MSG_FILTERED_WITNESS_BLOCK = MSG_FILTERED_BLOCK | MSG_WITNESS_FLAG,
@@ -510,6 +518,7 @@ class CInv
     bool IsMsgFilteredBlk() const { return type == MSG_FILTERED_BLOCK; }
     bool IsMsgCmpctBlk() const { return type == MSG_CMPCT_BLOCK; }
     bool IsMsgWitnessBlk() const { return type == MSG_WITNESS_BLOCK; }
+    bool IsMsgBlockUndo() const { return type == MSG_BLOCK_UNDO; }
 
     // Combined-message helper methods
     bool IsGenTxMsg() const

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

src/test/undo_tests.cpp

@@ -0,0 +1,111 @@
+// Copyright (c) 2025-present The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+#include <arith_uint256.h>
+#include <coins.h>
+#include <consensus/amount.h>
+#include <key.h>
+#include <primitives/transaction.h>
+#include <pubkey.h>
+#include <random.h>
+#include <script/script.h>
+#include <serialize.h>
+#include <streams.h>
+#include <test/util/setup_common.h>
+#include <undo.h>
+
+#include <boost/test/unit_test.hpp>
+
+namespace {
+CAmount amt_1{111};
+CAmount amt_2{4321};
+CAmount amt_3{12345};
+CAmount amt_4{94949};
+CAmount amt_5{5222322};
+CAmount amt_6{34112};
+int height_1{3};
+int height_2{424002};
+int height_3{2244002};
+int height_4{983999};
+int height_5{2455};
+int height_6{20};
+} // namespace
+
+BOOST_FIXTURE_TEST_SUITE(undo_tests, BasicTestingSetup)
+
+BOOST_AUTO_TEST_CASE(network_undo_serialization)
+{
+    // case one
+    CPubKey key_1 = GenerateRandomKey().GetPubKey();
+    CScript script_1 = CScript() << OP_DUP << OP_HASH160 << ToByteVector(key_1.GetID()) << OP_EQUALVERIFY << OP_CHECKSIG;
+    Coin coin_1{
+        CTxOut{amt_1, script_1},
+        height_1,
+        false,
+    };
+    // case two
+    CScript redeem{};
+    CScript script_2 = CScript() << OP_HASH160 << ToByteVector(CScriptID(redeem)) << OP_EQUAL;
+    Coin coin_2{
+        CTxOut{amt_2, script_2},
+        height_2,
+        false,
+    };
+    // case three
+    CKey key_2 = GenerateRandomKey();
+    CScript script_3 = CScript() << ToByteVector(key_2.GetPubKey()) << OP_CHECKSIG;
+    Coin coin_3{
+        CTxOut{amt_3, script_3},
+        height_3,
+        false,
+    };
+    // case four
+    CKey key_3 = GenerateRandomKey(/*compressed=*/false);
+    CScript script_4 = CScript() << ToByteVector(key_3.GetPubKey()) << OP_CHECKSIG;
+    Coin coin_4{
+        CTxOut{amt_4, script_4},
+        height_4,
+        false,
+    };
+    CKey key_4 = GenerateRandomKey();
+    XOnlyPubKey x_only{key_4.GetPubKey()};
+    CScript script_5 = CScript() << OP_1 << 0x20 << ToByteVector(x_only);
+    Coin coin_5{
+        CTxOut{amt_5, script_5},
+        height_5,
+        false,
+    };
+    CPubKey key_5 = GenerateRandomKey().GetPubKey();
+    CScript script_6 = CScript() << OP_DUP << OP_HASH160 << ToByteVector(key_5.GetID()) << OP_EQUALVERIFY << OP_CHECKSIG;
+    Coin coin_6{
+        CTxOut{amt_6, script_6},
+        height_6,
+        true,
+    };
+
+    CTxUndo undo_1{std::vector{coin_1, coin_2}};
+    CTxUndo undo_2{std::vector{coin_3, coin_4}};
+    CTxUndo undo_3{std::vector{coin_5, coin_6}};
+    CBlockUndo undo{std::vector{undo_1, undo_2, undo_3}};
+    uint256 block_hash{GetRandHash()};
+    NetworkBlockUndo want{block_hash, undo};
+    BOOST_CHECK(want.m_coins.size() > 0);
+    DataStream undo_byte_stream{};
+    Serialize(undo_byte_stream, want);
+    BOOST_CHECK(undo_byte_stream.size() > 0);
+    NetworkBlockUndo got;
+    Unserialize(undo_byte_stream, got);
+    BOOST_CHECK_EQUAL(want.m_coins.size(), got.m_coins.size());
+    for (size_t i = 0; i < want.m_coins.size(); ++i) {
+        const auto& coin_1 = want.m_coins[i];
+        const auto& coin_2 = got.m_coins[i];
+        BOOST_CHECK_EQUAL(coin_1.fCoinBase, coin_2.fCoinBase);
+        BOOST_CHECK_EQUAL(coin_1.nHeight, coin_2.nHeight);
+        BOOST_CHECK_EQUAL(coin_1.out.nValue, coin_2.out.nValue);
+        const auto sct_1{coin_1.out.scriptPubKey};
+        const auto sct_2{coin_2.out.scriptPubKey};
+        BOOST_CHECK(sct_1 == sct_2);
+    }
+}
+
+BOOST_AUTO_TEST_SUITE_END();

src/undo.h

@@ -11,6 +11,7 @@
 #include <consensus/consensus.h>
 #include <primitives/transaction.h>
 #include <serialize.h>
+#include <uint256.h>
 
 /** Formatter for undo information for a CTxIn
  *
@@ -48,6 +49,26 @@ struct TxInUndoFormatter
     }
 };
 
+struct NetworkCoinFormatter
+{
+    template<typename Stream>
+    void Ser(Stream& s, const Coin& coin) {
+        ::Serialize(s, coin.nHeight * uint32_t{2} + coin.fCoinBase);
+        ::Serialize(s, coin.out.nValue);
+        ::Serialize(s, Using<ScriptCompression>(coin.out.scriptPubKey));
+    }
+
+    template<typename Stream>
+    void Unser(Stream& s, Coin& coin) {
+        uint32_t n_code = 0x00;
+        ::Unserialize(s, n_code);
+        coin.nHeight = n_code >> 1;
+        coin.fCoinBase = n_code & 1;
+        ::Unserialize(s, coin.out.nValue);
+        ::Unserialize(s, Using<ScriptCompression>(coin.out.scriptPubKey));
+    }
+};
+
 /** Undo information for a CTransaction */
 class CTxUndo
 {
@@ -67,4 +88,32 @@ class CBlockUndo
     SERIALIZE_METHODS(CBlockUndo, obj) { READWRITE(obj.vtxundo); }
 };
 
+class NetworkBlockUndo
+{
+public:
+    std::vector<Coin> m_coins;
+    uint256 m_hash;
+
+    NetworkBlockUndo(): m_coins{}, m_hash{} {};
+
+    NetworkBlockUndo(uint256 hash, CBlockUndo& undo): m_hash{hash} {
+        for (const auto& tx_undo : undo.vtxundo) {
+            for (const auto& coin : tx_undo.vprevout) {
+                m_coins.push_back(coin);
+            }
+        }
+    }
+
+    template <typename Stream>
+    void Serialize(Stream& s) const {
+        ::Serialize(s, m_hash);
+        ::Serialize(s, Using<VectorFormatter<NetworkCoinFormatter>>(m_coins));
+    }
+
+    template <typename Stream>
+    void Unserialize(Stream& s) {
+        ::Unserialize(s, m_hash);
+        ::Unserialize(s, Using<VectorFormatter<NetworkCoinFormatter>>(m_coins));
+    }
+};
 #endif // BITCOIN_UNDO_H