deploymentinfo: report signalling

Author: ajtowns

src/rpc/blockchain.cpp

@@ -1497,6 +1497,24 @@ static void SoftForkDescPushBack(const CBlockIndex* blockindex, UniValue& softfo
         case ThresholdState::LOCKED_IN:
         case ThresholdState::ACTIVE:
             bip9.pushKV("signal_abandon", strprintf("%08x", consensusParams.vDeployments[id].signal_abandon));
+
+            // Report observed signalling
+            {
+                UniValue signals(UniValue::VARR);
+                for (const auto& signal_info : g_versionbitscache.GetSignalInfo(blockindex, consensusParams, id)) {
+                    UniValue s(UniValue::VOBJ);
+                    if (signal_info.bip_version == -1) {
+                        // don't report self-activation signals if already active
+                        if (signal_info.activate && current_state == ThresholdState::ACTIVE) continue;
+                    } else {
+                        s.pushKV("bip_version", signal_info.bip_version);
+                    }
+                    s.pushKV("height", signal_info.height);
+                    s.pushKV("action", (signal_info.activate ? "activate" : "abandon"));
+                    signals.push_back(s);
+                }
+                bip9.pushKV("signals", signals);
+            }
             break;
         case ThresholdState::DEACTIVATING:
         case ThresholdState::ABANDONED:

src/test/fuzz/versionbits.cpp

@@ -13,11 +13,17 @@
 #include <test/fuzz/fuzz.h>
 #include <test/fuzz/util.h>
 
+#include <algorithm>
 #include <cstdint>
 #include <limits>
 #include <memory>
 #include <vector>
 
+bool operator==(const SignalInfo& a, const SignalInfo& b)
+{
+    return a.height == b.height && a.bip_version == b.bip_version && a.activate == b.activate;
+}
+
 namespace {
 class TestConditionChecker : public AbstractThresholdConditionChecker
 {
@@ -165,6 +171,18 @@ FUZZ_TARGET_INIT(versionbits, initialize)
     // Now that we have chosen time and versions, setup to mine blocks
     Blocks blocks(block_start_time, interval);
 
+    const auto siginfo_nosignal = [&]() -> std::optional<SignalInfo> {
+        int bip, bip_ver;
+        if (checker.BIP(bip, bip_ver)) {
+            if ((ver_nosignal & 0xFFFFFF00l) == (ver_activate & 0xFFFFFF00l)) {
+                return SignalInfo{.height = 0, .bip_version = static_cast<uint8_t>(ver_nosignal & 0xFF), .activate = true};
+            } else if ((ver_nosignal & 0xFFFFFF00l) == (ver_abandon & 0xFFFFFF00l)) {
+                return SignalInfo{.height = 0, .bip_version = static_cast<uint8_t>(ver_nosignal & 0xFF), .activate = false};
+            }
+        }
+        return std::nullopt;
+    }();
+
     /* Strategy:
      *  * we mine n*period blocks, with zero/one of
      *    those blocks signalling activation, and zero/one of
@@ -207,8 +225,13 @@ FUZZ_TARGET_INIT(versionbits, initialize)
     bool sig_abandon = false;
     int next_active = 0;
     int next_abandon = 0;
+
+    std::vector<SignalInfo> exp_siginfo = checker.GetSignalInfo(nullptr); // dummy
+    assert(exp_siginfo.empty());
+
     for (int b = 1; b <= period; ++b) {
         CBlockIndex* current_block = blocks.tip();
+        const int next_height = (current_block != nullptr ? current_block->nHeight + 1 : 0);
 
         if (current_block != nullptr) {
             // state and since don't change within the period
@@ -221,14 +244,24 @@ FUZZ_TARGET_INIT(versionbits, initialize)
         while (b > next_abandon) next_abandon += 1 + fuzzed_data_provider.ConsumeIntegral<uint8_t>();
         while (b > next_active) next_active += 1 + fuzzed_data_provider.ConsumeIntegral<uint8_t>();
         if (b == next_abandon) {
+            exp_siginfo.push_back({.height = next_height, .bip_version=-1, .activate=false});
             blocks.mine_block(ver_abandon);
             sig_abandon = true;
         } else if (b == next_active) {
+            exp_siginfo.push_back({.height = next_height, .bip_version=-1, .activate=true});
             blocks.mine_block(ver_activate);
             sig_active = true;
         } else {
+            if (siginfo_nosignal) {
+                exp_siginfo.push_back(*siginfo_nosignal);
+                exp_siginfo.back().height = next_height;
+            }
             blocks.mine_block(ver_nosignal);
         }
+
+        const std::vector<SignalInfo> siginfo = checker.GetSignalInfo(blocks.tip());
+        assert(siginfo.size() == exp_siginfo.size());
+        assert(std::equal(siginfo.begin(), siginfo.end(), exp_siginfo.rbegin(), exp_siginfo.rend()));
     }
 
     // grab the final block and the state it's left us in

src/versionbits.cpp

@@ -174,6 +174,42 @@ int AbstractThresholdConditionChecker::GetStateSinceHeightFor(const CBlockIndex*
     return pindexPrev->nHeight + 1;
 }
 
+std::vector<SignalInfo> AbstractThresholdConditionChecker::GetSignalInfo(const CBlockIndex* pindex) const
+{
+    std::vector<SignalInfo> result;
+
+    int bip = 0, bip_version = 0;
+    const bool check_other_versions = BIP(bip, bip_version);
+
+    const int32_t activate = ActivateVersion();
+    const int32_t abandon = AbandonVersion();
+    const int period = Period();
+
+    while (pindex != nullptr) {
+        if (pindex->nVersion == activate) {
+            result.push_back({ .height = pindex->nHeight, .bip_version = -1, .activate = true });
+        } else if (pindex->nVersion == abandon) {
+            result.push_back({ .height = pindex->nHeight, .bip_version = -1, .activate = false });
+        } else if (check_other_versions) {
+            if ((pindex->nVersion & 0x00FFFF00l) == (bip << 8)) {
+                SignalInfo s;
+                s.height = pindex->nHeight;
+                s.bip_version = static_cast<uint8_t>(pindex->nVersion & 0xFF);
+                if ((pindex->nVersion & 0xFF000000l) == VERSIONBITS_TOP_ACTIVE) {
+                    s.activate = true;
+                    result.push_back(s);
+                } else if ((pindex->nVersion & 0xFF000000l) == VERSIONBITS_TOP_ABANDON) {
+                    s.activate = false;
+                    result.push_back(s);
+                }
+            }
+        }
+        if (pindex->nHeight % period == 0) break;
+        pindex = pindex->pprev;
+    }
+    return result;
+}
+
 namespace
 {
 /**
@@ -209,6 +245,11 @@ int VersionBitsCache::StateSinceHeight(const CBlockIndex* pindexPrev, const Cons
     return VersionBitsConditionChecker(params, pos).GetStateSinceHeightFor(pindexPrev, m_caches[pos]);
 }
 
+std::vector<SignalInfo> VersionBitsCache::GetSignalInfo(const CBlockIndex* pindex, const Consensus::Params& params, Consensus::DeploymentPos pos) const
+{
+    return VersionBitsConditionChecker(params, pos).GetSignalInfo(pindex);
+}
+
 int32_t VersionBitsCache::ComputeBlockVersion(const CBlockIndex* pindexPrev, const Consensus::Params& params)
 {
     int32_t nVersion = VERSIONBITS_TOP_BITS;

src/versionbits.h

@@ -36,6 +36,13 @@ enum class ThresholdState {
 // will either be nullptr or a block with (height + 1) % Period() == 0.
 typedef std::map<const CBlockIndex*, ThresholdState> ThresholdConditionCache;
 
+struct SignalInfo
+{
+    int height;
+    int bip_version; // -1 = this version
+    bool activate; // true = activate, false = abandon
+};
+
 /**
  * Abstract class that implements BIP9-style threshold logic, and caches results.
  */
@@ -56,6 +63,9 @@ class AbstractThresholdConditionChecker {
 
     /** Report bip number and version, based on nVersion signalling standard */
     bool BIP(int& bip, int& version) const;
+
+    /** Returns signalling information */
+    std::vector<SignalInfo> GetSignalInfo(const CBlockIndex* pindex) const;
 };
 
 /** BIP 9 allows multiple softforks to be deployed in parallel. We cache
@@ -80,6 +90,9 @@ class VersionBitsCache
     /** Report bip number and version, based on nVersion signalling standard */
     bool BIP(int& bip, int& bip_version, const Consensus::Params& params, Consensus::DeploymentPos pos) const;
 
+    /** Returns signalling information */
+    std::vector<SignalInfo> GetSignalInfo(const CBlockIndex* pindex, const Consensus::Params& params, Consensus::DeploymentPos pos) const;
+
     void Clear();
 };
 

test/functional/rpc_blockchain.py

@@ -204,6 +204,7 @@ def check_signalling_deploymentinfo_result(self, gdi_result, height, blockhash):
                     'since': 144,
                     'signal_activate': "30000000",
                     'signal_abandon': "50000000",
+                    'signals': [],
                 },
                 'active': False
             },