From 4e76c10a5da6a992cc186886cab53b765249475c Mon Sep 17 00:00:00 2001
From: pasta <pasta@dashboost.org>
Date: Mon, 3 Aug 2026 09:58:40 -0500
Subject: [PATCH 1/3] fix: update masternode rate limit on failed governance
 trigger path

AddGovernanceObjectInternal emplaced a trigger into mapObjects, attempted AddTrigger, and on failure returned early before MasternodeRateUpdate. MasternodeRateCheck treats a missing rate-buffer entry as allow, so a masternode that never lands a successful trigger was never rate-limited at all, defeating precisely the limiter meant to stop it. Each rejected trigger still cost a BLS verification and left a mapErasedGovernanceObjects entry retained for roughly 60 days on mainnet.

Advance the rate buffer on the failure path too. Relay scheduling is extracted so a trigger just marked deleted is not added to the additional-relay set; that part is a self-correction for a regression this change would otherwise introduce, not a pre-existing bug.
---
 src/Makefile.test.include                     |   1 +
 src/governance/governance.cpp                 |  33 ++-
 src/governance/governance.h                   |   5 +
 .../governance_failed_trigger_rate_tests.cpp  | 196 ++++++++++++++++++
 4 files changed, 226 insertions(+), 9 deletions(-)
 create mode 100644 src/test/governance_failed_trigger_rate_tests.cpp

diff --git a/src/Makefile.test.include b/src/Makefile.test.include
index faaee5aa1913..048aa2a61838 100644
--- a/src/Makefile.test.include
+++ b/src/Makefile.test.include
@@ -120,6 +120,7 @@ BITCOIN_TESTS =\
   test/flatfile_tests.cpp \
   test/fs_tests.cpp \
   test/getarg_tests.cpp \
+  test/governance_failed_trigger_rate_tests.cpp \
   test/governance_inv_tests.cpp \
   test/governance_superblock_tests.cpp \
   test/governance_validators_tests.cpp \
diff --git a/src/governance/governance.cpp b/src/governance/governance.cpp
index d87fef40fac5..483b85301c86 100644
--- a/src/governance/governance.cpp
+++ b/src/governance/governance.cpp
@@ -344,18 +344,25 @@ void CGovernanceManager::AddGovernanceObjectInternal(CGovernanceObject& insert_o
     LogPrint(BCLog::GOBJECT, "CGovernanceManager::AddGovernanceObject -- Before trigger block, GetDataAsPlainString = %s, nObjectType = %d\n",
                 Assert(govobj)->GetDataAsPlainString(), std23::to_underlying(govobj->GetObjectType()));
 
+    // Count the attempt against the per-masternode rate buffer before any early
+    // return. Failed AddTrigger paths used to skip this, so a single operator
+    // key could flood mapObjects with unparseable triggers.
+    MasternodeRateUpdate(*govobj);
+
     if (govobj->GetObjectType() == GovernanceObject::TRIGGER && !m_superblocks.AddTrigger(govobj, nCachedBlockHeight)) {
         LogPrint(BCLog::GOBJECT, "CGovernanceManager::AddGovernanceObject -- undo adding invalid trigger object: hash = %s\n", nHash.ToString());
         govobj->PrepareDeletion(GetTime<std::chrono::seconds>().count());
         return;
     }
 
+    // Only objects we keep may be announced. Scheduling this before the AddTrigger
+    // check would make us re-announce, and serve on GETDATA, a trigger we just
+    // undid and marked for deletion.
+    ScheduleAdditionalRelay(*govobj);
+
     LogPrint(BCLog::GOBJECT, "CGovernanceManager::AddGovernanceObject -- %s new, received from peer %s\n", strHash, peer_str);
     RelayObject(*govobj);
 
-    // Update the rate buffer
-    MasternodeRateUpdate(*govobj);
-
     m_mn_sync.BumpAssetLastTime("CGovernanceManager::AddGovernanceObject");
 
     // WE MIGHT HAVE PENDING/ORPHAN VOTES FOR THIS OBJECT
@@ -701,15 +708,23 @@ void CGovernanceManager::MasternodeRateUpdate(const CGovernanceObject& govobj)
         it = mapLastMasternodeObject.insert(txout_m_t::value_type(masternodeOutpoint, last_object_rec(true))).first;
     }
 
-    int64_t nTimestamp = govobj.GetCreationTime();
-    it->second.triggerBuffer.AddTimestamp(nTimestamp);
+    it->second.triggerBuffer.AddTimestamp(govobj.GetCreationTime());
+    it->second.fStatusOK = true;
+}
+
+void CGovernanceManager::ScheduleAdditionalRelay(const CGovernanceObject& govobj)
+{
+    AssertLockHeld(cs_store);
 
-    if (nTimestamp > GetTime() + count_seconds(MAX_TIME_FUTURE_DEVIATION) - count_seconds(RELIABLE_PROPAGATION_TIME)) {
-        // schedule additional relay for the object
+    if (govobj.GetObjectType() != GovernanceObject::TRIGGER) return;
+
+    // An object created this close to the future-deviation limit is still too new for
+    // peers with a lagging clock to accept, so re-announce it once it has aged past
+    // RELIABLE_PROPAGATION_TIME (see CheckPostponedObjects).
+    if (govobj.GetCreationTime() >
+        GetTime() + count_seconds(MAX_TIME_FUTURE_DEVIATION) - count_seconds(RELIABLE_PROPAGATION_TIME)) {
         setAdditionalRelayObjects.insert(govobj.GetHash());
     }
-
-    it->second.fStatusOK = true;
 }
 
 bool CGovernanceManager::MasternodeRateCheck(const CGovernanceObject& govobj, bool fUpdateFailStatus)
diff --git a/src/governance/governance.h b/src/governance/governance.h
index cca00d8cdb60..280f62f67394 100644
--- a/src/governance/governance.h
+++ b/src/governance/governance.h
@@ -403,6 +403,11 @@ class CGovernanceManager : public GovernanceStore
     void MasternodeRateUpdate(const CGovernanceObject& govobj)
         EXCLUSIVE_LOCKS_REQUIRED(cs_store);
 
+    /** Queue a deferred re-announcement for a trigger that is too new to propagate
+     *  reliably yet. Only call this for objects we are keeping. */
+    void ScheduleAdditionalRelay(const CGovernanceObject& govobj)
+        EXCLUSIVE_LOCKS_REQUIRED(cs_store);
+
     bool MasternodeRateCheck(const CGovernanceObject& govobj, bool fUpdateFailStatus, bool fForce, bool& fRateCheckBypassed)
         EXCLUSIVE_LOCKS_REQUIRED(cs_store);
 
diff --git a/src/test/governance_failed_trigger_rate_tests.cpp b/src/test/governance_failed_trigger_rate_tests.cpp
new file mode 100644
index 000000000000..8293362bae91
--- /dev/null
+++ b/src/test/governance_failed_trigger_rate_tests.cpp
@@ -0,0 +1,196 @@
+// Copyright (c) 2026 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <test/util/masternode.h>
+#include <test/util/setup_common.h>
+
+#include <bls/bls.h>
+#include <chainparams.h>
+#include <evo/chainhelper.h>
+#include <evo/deterministicmns.h>
+#include <governance/governance.h>
+#include <governance/object.h>
+#include <masternode/sync.h>
+#include <netfulfilledman.h>
+#include <script/standard.h>
+#include <util/std23.h>
+#include <util/strencodings.h>
+#include <util/time.h>
+#include <validation.h>
+
+#include <boost/test/unit_test.hpp>
+
+#include <algorithm>
+#include <string>
+#include <vector>
+
+// Fixture: a chain with DIP3 active, one registered masternode whose operator BLS
+// key we hold, a governance manager wired the way production init does, and
+// CMasternodeSync driven to FINISHED (MasternodeRateCheck is a no-op until then).
+//
+// The DIP3 activation height is pushed to 109 so TestChainSetup's fixed-checkpoint
+// assert still succeeds while the early coinbases are mature.
+struct FailedTriggerRateSetup : public TestChainSetup {
+    COutPoint mn_outpoint;
+    CBLSSecretKey operator_key;
+
+    FailedTriggerRateSetup() :
+        TestChainSetup(/*num_blocks=*/107, CBaseChainParams::REGTEST, {"-dip3params=109:500"})
+    {
+        auto& chainman = *Assert(m_node.chainman.get());
+        auto& dmnman = *Assert(m_node.dmnman);
+        const CScript coinbase_pk = GetScriptForRawPubKey(coinbaseKey.GetPubKey());
+
+        // Activate DIP3 (fixture tip is one block before activation height 109).
+        // Enforcement is independent of activation; ProRegTx only needs activation.
+        CreateAndProcessBlock({}, coinbase_pk);
+        BOOST_REQUIRE_EQUAL(WITH_LOCK(::cs_main, return chainman.ActiveChain().Height()), 108);
+
+        auto utxos = BuildSimpleUtxoMap(m_coinbase_txns);
+        CKey owner_key;
+        auto proreg_tx = CreateProRegTx(chainman, utxos, /*port=*/1, GenerateRandomAddress(), coinbaseKey, owner_key,
+                                        operator_key);
+        CreateAndProcessBlock({proreg_tx}, coinbase_pk);
+        dmnman.UpdatedBlockTip(WITH_LOCK(::cs_main, return chainman.ActiveChain().Tip()));
+
+        mn_outpoint = COutPoint{proreg_tx.GetHash(), 0};
+        const auto dmn = dmnman.GetListAtChainTip().GetMNByCollateral(mn_outpoint);
+        BOOST_REQUIRE(dmn);
+        BOOST_REQUIRE(dmn->pdmnState->pubKeyOperator.Get() == operator_key.GetPublicKey());
+
+        BOOST_REQUIRE(m_node.mn_metaman);
+        BOOST_REQUIRE(m_node.mn_sync);
+        BOOST_REQUIRE(m_node.chain_helper);
+        BOOST_REQUIRE(m_node.chain_helper->superblocks);
+        m_node.govman = std::make_unique<CGovernanceManager>(*m_node.mn_metaman, *m_node.chainman,
+                                                             *m_node.chain_helper->superblocks, *m_node.dmnman,
+                                                             *m_node.mn_sync);
+        BOOST_REQUIRE(m_node.govman->LoadCache(/*load_cache=*/false));
+
+        // Advance BLOCKCHAIN -> GOVERNANCE -> FINISHED. SyncFinished requires a
+        // loaded netfulfilledman.
+        BOOST_REQUIRE(m_node.netfulfilledman);
+        BOOST_REQUIRE(m_node.netfulfilledman->LoadCache(/*load_cache=*/false));
+        m_node.mn_sync->SwitchToNextAsset();
+        m_node.mn_sync->SwitchToNextAsset();
+        BOOST_REQUIRE(m_node.mn_sync->IsSynced());
+    }
+
+    ~FailedTriggerRateSetup()
+    {
+        // chain_helper (owner of the SuperblockManager govman clears in its dtor)
+        // must outlive govman -- see PrepareShutdown in init.cpp.
+        m_node.govman.reset();
+    }
+
+    // Malformed trigger JSON: type=TRIGGER so LoadData/IsValidLocally accept it, but
+    // SuperblockManager::AddTrigger fails while constructing CSuperblock (missing
+    // event_block_height / payment fields). That is the failed-trigger path.
+    CGovernanceObject MakeFailedTrigger(int64_t creation_time, int salt) const
+    {
+        const std::string data = strprintf(R"({"type":2,"salt":%d})", salt);
+        CGovernanceObject govobj{uint256{}, /*revision=*/1, creation_time, uint256{}, HexStr(data)};
+        BOOST_REQUIRE_EQUAL(std23::to_underlying(govobj.GetObjectType()),
+                            std23::to_underlying(GovernanceObject::TRIGGER));
+        govobj.SetMasternodeOutpoint(mn_outpoint);
+        const CBLSSignature sig = operator_key.Sign(govobj.GetSignatureHash(), /*specificLegacyScheme=*/false);
+        BOOST_REQUIRE(sig.IsValid());
+        govobj.SetSignature(sig.ToByteVector(/*specificLegacyScheme=*/false));
+        return govobj;
+    }
+};
+
+BOOST_FIXTURE_TEST_SUITE(governance_failed_trigger_rate_tests, FailedTriggerRateSetup)
+
+// Regression: AddGovernanceObjectInternal used to return early on
+// AddTrigger failure without calling MasternodeRateUpdate. Because
+// MasternodeRateCheck short-circuits when mapLastMasternodeObject has no entry,
+// a single operator key could flood mapObjects with unparseable triggers.
+// After the fix, failed triggers still advance the per-masternode rate buffer
+// so the flood is throttled.
+BOOST_AUTO_TEST_CASE(failed_trigger_path_advances_masternode_rate_limit)
+{
+    // Deterministic clock inside the allowed rate-check timestamp window.
+    SetMockTime(1'700'000'000s);
+    const int64_t base_time = GetTime<std::chrono::seconds>().count();
+
+    // Submit more failed triggers than RATE_BUFFER_SIZE from the same MN.
+    // Pre-fix the rate buffer never fills, so every object lands in mapObjects.
+    // Post-fix the buffer fills and further submissions are rate-rejected.
+    constexpr int flood_count = 12;
+    int objects_seen = 0;
+    for (int i = 0; i < flood_count; ++i) {
+        CGovernanceObject govobj = MakeFailedTrigger(base_time + i, /*salt=*/i);
+        const uint256 hash = govobj.GetHash();
+        // Unique per-object: salt + time vary both the data and the creation time.
+        BOOST_REQUIRE(!m_node.govman->HaveObjectForHash(hash));
+
+        LOCK(::cs_main);
+        // ProcessObject returns true for both accepted and rate-rejected objects
+        // (rate rejection is not a peer-misbehaviour event).
+        BOOST_CHECK(m_node.govman->ProcessObject(/*peer_str=*/"test-peer", hash, govobj));
+
+        if (m_node.govman->HaveObjectForHash(hash)) {
+            ++objects_seen;
+            // Failed triggers are accepted into mapObjects then marked for deletion.
+            const auto stored = m_node.govman->FindGovernanceObject(hash);
+            BOOST_REQUIRE(stored);
+            BOOST_CHECK(stored->IsSetCachedDelete());
+        }
+    }
+
+    // With the rate buffer size of 5, a fixed limiter records the first five
+    // failed attempts and rejects the rest before insertion. Without the fix
+    // every object is inserted (objects_seen == flood_count).
+    BOOST_CHECK_LT(objects_seen, flood_count);
+    BOOST_CHECK_LE(objects_seen, RATE_BUFFER_SIZE + 1);
+
+    const UniValue stats = m_node.govman->ToJson();
+    BOOST_CHECK_LT(stats["objects_total"].getInt<int>(), flood_count);
+    BOOST_CHECK_EQUAL(stats["objects_total"].getInt<int>(), objects_seen);
+
+    // A trigger we undid must never be announced to peers.
+    BOOST_CHECK(m_node.govman->FetchRelayInventory().empty());
+}
+
+// A failed trigger must not be scheduled for the deferred "additional relay"
+// pass. That bookkeeping (setAdditionalRelayObjects) fires for creation times
+// close to MAX_TIME_FUTURE_DEVIATION, and used to live inside
+// MasternodeRateUpdate() -- so counting the failed attempt against the rate
+// buffer would otherwise make the node re-announce, and serve on GETDATA, an
+// object it had just rejected and marked for deletion. One signature-valid
+// message would then fan out to every peer, which in turn re-announce it.
+BOOST_AUTO_TEST_CASE(failed_trigger_is_not_scheduled_for_additional_relay)
+{
+    SetMockTime(1'700'000'000s);
+    const int64_t now = GetTime<std::chrono::seconds>().count();
+
+    // Inside (now + MAX_TIME_FUTURE_DEVIATION - RELIABLE_PROPAGATION_TIME,
+    // now + MAX_TIME_FUTURE_DEVIATION], i.e. accepted by MasternodeRateCheck but
+    // "too new to propagate reliably", which is what arms the additional relay.
+    const int64_t near_future = now + 3550;
+    CGovernanceObject govobj = MakeFailedTrigger(near_future, /*salt=*/0);
+    const uint256 hash = govobj.GetHash();
+
+    WITH_LOCK(::cs_main, BOOST_CHECK(m_node.govman->ProcessObject(/*peer_str=*/"test-peer", hash, govobj)));
+
+    // The object is stored (AddTrigger failure happens after insertion) but is
+    // immediately marked for deletion, so it is not syncable...
+    BOOST_REQUIRE(m_node.govman->HaveObjectForHash(hash));
+    BOOST_CHECK(!m_node.govman->HaveSyncableObjectForHash(hash));
+    // ...and nothing was queued for relay on the accept path either.
+    BOOST_CHECK(m_node.govman->FetchRelayInventory().empty());
+
+    // Move past RELIABLE_PROPAGATION_TIME so the deferred relay would be "ready",
+    // then run the pass. UpdatedBlockTip -> CheckPostponedObjects drains
+    // setAdditionalRelayObjects.
+    SetMockTime(std::chrono::seconds{now + 120});
+    m_node.govman->UpdatedBlockTip(WITH_LOCK(::cs_main, return m_node.chainman->ActiveChain().Tip()));
+
+    const auto invs = m_node.govman->FetchRelayInventory();
+    BOOST_CHECK(std::ranges::none_of(invs, [&](const CInv& inv) { return inv.hash == hash; }));
+    BOOST_CHECK(invs.empty());
+}
+
+BOOST_AUTO_TEST_SUITE_END()

From a03a5e6889349e5f3f0002922de6095b5b9e1fbc Mon Sep 17 00:00:00 2001
From: pasta <pasta@dashboost.org>
Date: Tue, 4 Aug 2026 08:46:53 -0500
Subject: [PATCH 2/3] test: rework failed-trigger rate coverage from review

Move the failed-trigger rate regressions into governance_inv_tests.cpp,
use SetMockTime(0s), and rename ScheduleAdditionalRelay to
ScheduleTriggerRelay since it only applies to triggers.
---
 src/Makefile.test.include                     |   1 -
 src/governance/governance.cpp                 |   6 +-
 src/governance/governance.h                   |   4 +-
 .../governance_failed_trigger_rate_tests.cpp  | 196 ------------------
 src/test/governance_inv_tests.cpp             | 181 ++++++++++++++++
 5 files changed, 186 insertions(+), 202 deletions(-)
 delete mode 100644 src/test/governance_failed_trigger_rate_tests.cpp

diff --git a/src/Makefile.test.include b/src/Makefile.test.include
index 048aa2a61838..faaee5aa1913 100644
--- a/src/Makefile.test.include
+++ b/src/Makefile.test.include
@@ -120,7 +120,6 @@ BITCOIN_TESTS =\
   test/flatfile_tests.cpp \
   test/fs_tests.cpp \
   test/getarg_tests.cpp \
-  test/governance_failed_trigger_rate_tests.cpp \
   test/governance_inv_tests.cpp \
   test/governance_superblock_tests.cpp \
   test/governance_validators_tests.cpp \
diff --git a/src/governance/governance.cpp b/src/governance/governance.cpp
index 483b85301c86..23a480b8d579 100644
--- a/src/governance/governance.cpp
+++ b/src/governance/governance.cpp
@@ -358,7 +358,7 @@ void CGovernanceManager::AddGovernanceObjectInternal(CGovernanceObject& insert_o
     // Only objects we keep may be announced. Scheduling this before the AddTrigger
     // check would make us re-announce, and serve on GETDATA, a trigger we just
     // undid and marked for deletion.
-    ScheduleAdditionalRelay(*govobj);
+    ScheduleTriggerRelay(*govobj);
 
     LogPrint(BCLog::GOBJECT, "CGovernanceManager::AddGovernanceObject -- %s new, received from peer %s\n", strHash, peer_str);
     RelayObject(*govobj);
@@ -712,13 +712,13 @@ void CGovernanceManager::MasternodeRateUpdate(const CGovernanceObject& govobj)
     it->second.fStatusOK = true;
 }
 
-void CGovernanceManager::ScheduleAdditionalRelay(const CGovernanceObject& govobj)
+void CGovernanceManager::ScheduleTriggerRelay(const CGovernanceObject& govobj)
 {
     AssertLockHeld(cs_store);
 
     if (govobj.GetObjectType() != GovernanceObject::TRIGGER) return;
 
-    // An object created this close to the future-deviation limit is still too new for
+    // A trigger created this close to the future-deviation limit is still too new for
     // peers with a lagging clock to accept, so re-announce it once it has aged past
     // RELIABLE_PROPAGATION_TIME (see CheckPostponedObjects).
     if (govobj.GetCreationTime() >
diff --git a/src/governance/governance.h b/src/governance/governance.h
index 280f62f67394..c062919e0c4f 100644
--- a/src/governance/governance.h
+++ b/src/governance/governance.h
@@ -404,8 +404,8 @@ class CGovernanceManager : public GovernanceStore
         EXCLUSIVE_LOCKS_REQUIRED(cs_store);
 
     /** Queue a deferred re-announcement for a trigger that is too new to propagate
-     *  reliably yet. Only call this for objects we are keeping. */
-    void ScheduleAdditionalRelay(const CGovernanceObject& govobj)
+     *  reliably yet. Only call this for triggers we are keeping. */
+    void ScheduleTriggerRelay(const CGovernanceObject& govobj)
         EXCLUSIVE_LOCKS_REQUIRED(cs_store);
 
     bool MasternodeRateCheck(const CGovernanceObject& govobj, bool fUpdateFailStatus, bool fForce, bool& fRateCheckBypassed)
diff --git a/src/test/governance_failed_trigger_rate_tests.cpp b/src/test/governance_failed_trigger_rate_tests.cpp
deleted file mode 100644
index 8293362bae91..000000000000
--- a/src/test/governance_failed_trigger_rate_tests.cpp
+++ /dev/null
@@ -1,196 +0,0 @@
-// Copyright (c) 2026 The Dash Core developers
-// Distributed under the MIT software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#include <test/util/masternode.h>
-#include <test/util/setup_common.h>
-
-#include <bls/bls.h>
-#include <chainparams.h>
-#include <evo/chainhelper.h>
-#include <evo/deterministicmns.h>
-#include <governance/governance.h>
-#include <governance/object.h>
-#include <masternode/sync.h>
-#include <netfulfilledman.h>
-#include <script/standard.h>
-#include <util/std23.h>
-#include <util/strencodings.h>
-#include <util/time.h>
-#include <validation.h>
-
-#include <boost/test/unit_test.hpp>
-
-#include <algorithm>
-#include <string>
-#include <vector>
-
-// Fixture: a chain with DIP3 active, one registered masternode whose operator BLS
-// key we hold, a governance manager wired the way production init does, and
-// CMasternodeSync driven to FINISHED (MasternodeRateCheck is a no-op until then).
-//
-// The DIP3 activation height is pushed to 109 so TestChainSetup's fixed-checkpoint
-// assert still succeeds while the early coinbases are mature.
-struct FailedTriggerRateSetup : public TestChainSetup {
-    COutPoint mn_outpoint;
-    CBLSSecretKey operator_key;
-
-    FailedTriggerRateSetup() :
-        TestChainSetup(/*num_blocks=*/107, CBaseChainParams::REGTEST, {"-dip3params=109:500"})
-    {
-        auto& chainman = *Assert(m_node.chainman.get());
-        auto& dmnman = *Assert(m_node.dmnman);
-        const CScript coinbase_pk = GetScriptForRawPubKey(coinbaseKey.GetPubKey());
-
-        // Activate DIP3 (fixture tip is one block before activation height 109).
-        // Enforcement is independent of activation; ProRegTx only needs activation.
-        CreateAndProcessBlock({}, coinbase_pk);
-        BOOST_REQUIRE_EQUAL(WITH_LOCK(::cs_main, return chainman.ActiveChain().Height()), 108);
-
-        auto utxos = BuildSimpleUtxoMap(m_coinbase_txns);
-        CKey owner_key;
-        auto proreg_tx = CreateProRegTx(chainman, utxos, /*port=*/1, GenerateRandomAddress(), coinbaseKey, owner_key,
-                                        operator_key);
-        CreateAndProcessBlock({proreg_tx}, coinbase_pk);
-        dmnman.UpdatedBlockTip(WITH_LOCK(::cs_main, return chainman.ActiveChain().Tip()));
-
-        mn_outpoint = COutPoint{proreg_tx.GetHash(), 0};
-        const auto dmn = dmnman.GetListAtChainTip().GetMNByCollateral(mn_outpoint);
-        BOOST_REQUIRE(dmn);
-        BOOST_REQUIRE(dmn->pdmnState->pubKeyOperator.Get() == operator_key.GetPublicKey());
-
-        BOOST_REQUIRE(m_node.mn_metaman);
-        BOOST_REQUIRE(m_node.mn_sync);
-        BOOST_REQUIRE(m_node.chain_helper);
-        BOOST_REQUIRE(m_node.chain_helper->superblocks);
-        m_node.govman = std::make_unique<CGovernanceManager>(*m_node.mn_metaman, *m_node.chainman,
-                                                             *m_node.chain_helper->superblocks, *m_node.dmnman,
-                                                             *m_node.mn_sync);
-        BOOST_REQUIRE(m_node.govman->LoadCache(/*load_cache=*/false));
-
-        // Advance BLOCKCHAIN -> GOVERNANCE -> FINISHED. SyncFinished requires a
-        // loaded netfulfilledman.
-        BOOST_REQUIRE(m_node.netfulfilledman);
-        BOOST_REQUIRE(m_node.netfulfilledman->LoadCache(/*load_cache=*/false));
-        m_node.mn_sync->SwitchToNextAsset();
-        m_node.mn_sync->SwitchToNextAsset();
-        BOOST_REQUIRE(m_node.mn_sync->IsSynced());
-    }
-
-    ~FailedTriggerRateSetup()
-    {
-        // chain_helper (owner of the SuperblockManager govman clears in its dtor)
-        // must outlive govman -- see PrepareShutdown in init.cpp.
-        m_node.govman.reset();
-    }
-
-    // Malformed trigger JSON: type=TRIGGER so LoadData/IsValidLocally accept it, but
-    // SuperblockManager::AddTrigger fails while constructing CSuperblock (missing
-    // event_block_height / payment fields). That is the failed-trigger path.
-    CGovernanceObject MakeFailedTrigger(int64_t creation_time, int salt) const
-    {
-        const std::string data = strprintf(R"({"type":2,"salt":%d})", salt);
-        CGovernanceObject govobj{uint256{}, /*revision=*/1, creation_time, uint256{}, HexStr(data)};
-        BOOST_REQUIRE_EQUAL(std23::to_underlying(govobj.GetObjectType()),
-                            std23::to_underlying(GovernanceObject::TRIGGER));
-        govobj.SetMasternodeOutpoint(mn_outpoint);
-        const CBLSSignature sig = operator_key.Sign(govobj.GetSignatureHash(), /*specificLegacyScheme=*/false);
-        BOOST_REQUIRE(sig.IsValid());
-        govobj.SetSignature(sig.ToByteVector(/*specificLegacyScheme=*/false));
-        return govobj;
-    }
-};
-
-BOOST_FIXTURE_TEST_SUITE(governance_failed_trigger_rate_tests, FailedTriggerRateSetup)
-
-// Regression: AddGovernanceObjectInternal used to return early on
-// AddTrigger failure without calling MasternodeRateUpdate. Because
-// MasternodeRateCheck short-circuits when mapLastMasternodeObject has no entry,
-// a single operator key could flood mapObjects with unparseable triggers.
-// After the fix, failed triggers still advance the per-masternode rate buffer
-// so the flood is throttled.
-BOOST_AUTO_TEST_CASE(failed_trigger_path_advances_masternode_rate_limit)
-{
-    // Deterministic clock inside the allowed rate-check timestamp window.
-    SetMockTime(1'700'000'000s);
-    const int64_t base_time = GetTime<std::chrono::seconds>().count();
-
-    // Submit more failed triggers than RATE_BUFFER_SIZE from the same MN.
-    // Pre-fix the rate buffer never fills, so every object lands in mapObjects.
-    // Post-fix the buffer fills and further submissions are rate-rejected.
-    constexpr int flood_count = 12;
-    int objects_seen = 0;
-    for (int i = 0; i < flood_count; ++i) {
-        CGovernanceObject govobj = MakeFailedTrigger(base_time + i, /*salt=*/i);
-        const uint256 hash = govobj.GetHash();
-        // Unique per-object: salt + time vary both the data and the creation time.
-        BOOST_REQUIRE(!m_node.govman->HaveObjectForHash(hash));
-
-        LOCK(::cs_main);
-        // ProcessObject returns true for both accepted and rate-rejected objects
-        // (rate rejection is not a peer-misbehaviour event).
-        BOOST_CHECK(m_node.govman->ProcessObject(/*peer_str=*/"test-peer", hash, govobj));
-
-        if (m_node.govman->HaveObjectForHash(hash)) {
-            ++objects_seen;
-            // Failed triggers are accepted into mapObjects then marked for deletion.
-            const auto stored = m_node.govman->FindGovernanceObject(hash);
-            BOOST_REQUIRE(stored);
-            BOOST_CHECK(stored->IsSetCachedDelete());
-        }
-    }
-
-    // With the rate buffer size of 5, a fixed limiter records the first five
-    // failed attempts and rejects the rest before insertion. Without the fix
-    // every object is inserted (objects_seen == flood_count).
-    BOOST_CHECK_LT(objects_seen, flood_count);
-    BOOST_CHECK_LE(objects_seen, RATE_BUFFER_SIZE + 1);
-
-    const UniValue stats = m_node.govman->ToJson();
-    BOOST_CHECK_LT(stats["objects_total"].getInt<int>(), flood_count);
-    BOOST_CHECK_EQUAL(stats["objects_total"].getInt<int>(), objects_seen);
-
-    // A trigger we undid must never be announced to peers.
-    BOOST_CHECK(m_node.govman->FetchRelayInventory().empty());
-}
-
-// A failed trigger must not be scheduled for the deferred "additional relay"
-// pass. That bookkeeping (setAdditionalRelayObjects) fires for creation times
-// close to MAX_TIME_FUTURE_DEVIATION, and used to live inside
-// MasternodeRateUpdate() -- so counting the failed attempt against the rate
-// buffer would otherwise make the node re-announce, and serve on GETDATA, an
-// object it had just rejected and marked for deletion. One signature-valid
-// message would then fan out to every peer, which in turn re-announce it.
-BOOST_AUTO_TEST_CASE(failed_trigger_is_not_scheduled_for_additional_relay)
-{
-    SetMockTime(1'700'000'000s);
-    const int64_t now = GetTime<std::chrono::seconds>().count();
-
-    // Inside (now + MAX_TIME_FUTURE_DEVIATION - RELIABLE_PROPAGATION_TIME,
-    // now + MAX_TIME_FUTURE_DEVIATION], i.e. accepted by MasternodeRateCheck but
-    // "too new to propagate reliably", which is what arms the additional relay.
-    const int64_t near_future = now + 3550;
-    CGovernanceObject govobj = MakeFailedTrigger(near_future, /*salt=*/0);
-    const uint256 hash = govobj.GetHash();
-
-    WITH_LOCK(::cs_main, BOOST_CHECK(m_node.govman->ProcessObject(/*peer_str=*/"test-peer", hash, govobj)));
-
-    // The object is stored (AddTrigger failure happens after insertion) but is
-    // immediately marked for deletion, so it is not syncable...
-    BOOST_REQUIRE(m_node.govman->HaveObjectForHash(hash));
-    BOOST_CHECK(!m_node.govman->HaveSyncableObjectForHash(hash));
-    // ...and nothing was queued for relay on the accept path either.
-    BOOST_CHECK(m_node.govman->FetchRelayInventory().empty());
-
-    // Move past RELIABLE_PROPAGATION_TIME so the deferred relay would be "ready",
-    // then run the pass. UpdatedBlockTip -> CheckPostponedObjects drains
-    // setAdditionalRelayObjects.
-    SetMockTime(std::chrono::seconds{now + 120});
-    m_node.govman->UpdatedBlockTip(WITH_LOCK(::cs_main, return m_node.chainman->ActiveChain().Tip()));
-
-    const auto invs = m_node.govman->FetchRelayInventory();
-    BOOST_CHECK(std::ranges::none_of(invs, [&](const CInv& inv) { return inv.hash == hash; }));
-    BOOST_CHECK(invs.empty());
-}
-
-BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/governance_inv_tests.cpp b/src/test/governance_inv_tests.cpp
index 93e63e9ac33f..29ab53c2a236 100644
--- a/src/test/governance_inv_tests.cpp
+++ b/src/test/governance_inv_tests.cpp
@@ -2,8 +2,11 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <bls/bls.h>
+#include <chainparams.h>
 #include <common/bloom.h>
 #include <evo/chainhelper.h>
+#include <evo/deterministicmns.h>
 #include <governance/governance.h>
 #include <governance/net_governance.h>
 #include <governance/object.h>
@@ -13,21 +16,27 @@
 #include <netfulfilledman.h>
 #include <node/connection_types.h>
 #include <protocol.h>
+#include <script/standard.h>
 #include <streams.h>
 #include <uint256.h>
+#include <util/std23.h>
 #include <util/strencodings.h>
 #include <util/time.h>
+#include <validation.h>
 #include <version.h>
 
+#include <test/util/masternode.h>
 #include <test/util/net.h>
 #include <test/util/setup_common.h>
 #include <test/util/validation.h>
 
 #include <boost/test/unit_test.hpp>
 
+#include <algorithm>
 #include <atomic>
 #include <chrono>
 #include <memory>
+#include <string>
 #include <vector>
 
 using namespace std::chrono_literals;
@@ -472,3 +481,175 @@ BOOST_AUTO_TEST_CASE(governance_vote_authorization_survives_unsynced_drop)
 }
 
 BOOST_AUTO_TEST_SUITE_END()
+
+
+// Fixture for failed-trigger rate-limit regressions: DIP3-active chain, one
+// registered masternode whose operator BLS key we hold, governance wired as in
+// production init, and CMasternodeSync driven to FINISHED (MasternodeRateCheck is
+// a no-op until then).
+//
+// The DIP3 activation height is pushed to 109 so TestChainSetup's fixed-checkpoint
+// assert still succeeds while the early coinbases are mature.
+struct FailedTriggerRateSetup : public TestChainSetup {
+    COutPoint mn_outpoint;
+    CBLSSecretKey operator_key;
+
+    FailedTriggerRateSetup() :
+        TestChainSetup(/*num_blocks=*/107, CBaseChainParams::REGTEST, {"-dip3params=109:500"})
+    {
+        auto& chainman = *Assert(m_node.chainman.get());
+        auto& dmnman = *Assert(m_node.dmnman);
+        const CScript coinbase_pk = GetScriptForRawPubKey(coinbaseKey.GetPubKey());
+
+        // Activate DIP3 (fixture tip is one block before activation height 109).
+        // Enforcement is independent of activation; ProRegTx only needs activation.
+        CreateAndProcessBlock({}, coinbase_pk);
+        BOOST_REQUIRE_EQUAL(WITH_LOCK(::cs_main, return chainman.ActiveChain().Height()), 108);
+
+        auto utxos = BuildSimpleUtxoMap(m_coinbase_txns);
+        CKey owner_key;
+        auto proreg_tx = CreateProRegTx(chainman, utxos, /*port=*/1, GenerateRandomAddress(), coinbaseKey, owner_key,
+                                        operator_key);
+        CreateAndProcessBlock({proreg_tx}, coinbase_pk);
+        dmnman.UpdatedBlockTip(WITH_LOCK(::cs_main, return chainman.ActiveChain().Tip()));
+
+        mn_outpoint = COutPoint{proreg_tx.GetHash(), 0};
+        const auto dmn = dmnman.GetListAtChainTip().GetMNByCollateral(mn_outpoint);
+        BOOST_REQUIRE(dmn);
+        BOOST_REQUIRE(dmn->pdmnState->pubKeyOperator.Get() == operator_key.GetPublicKey());
+
+        BOOST_REQUIRE(m_node.mn_metaman);
+        BOOST_REQUIRE(m_node.mn_sync);
+        BOOST_REQUIRE(m_node.chain_helper);
+        BOOST_REQUIRE(m_node.chain_helper->superblocks);
+        m_node.govman = std::make_unique<CGovernanceManager>(*m_node.mn_metaman, *m_node.chainman,
+                                                             *m_node.chain_helper->superblocks, *m_node.dmnman,
+                                                             *m_node.mn_sync);
+        BOOST_REQUIRE(m_node.govman->LoadCache(/*load_cache=*/false));
+
+        // Advance BLOCKCHAIN -> GOVERNANCE -> FINISHED. SyncFinished requires a
+        // loaded netfulfilledman.
+        BOOST_REQUIRE(m_node.netfulfilledman);
+        BOOST_REQUIRE(m_node.netfulfilledman->LoadCache(/*load_cache=*/false));
+        m_node.mn_sync->SwitchToNextAsset();
+        m_node.mn_sync->SwitchToNextAsset();
+        BOOST_REQUIRE(m_node.mn_sync->IsSynced());
+    }
+
+    ~FailedTriggerRateSetup()
+    {
+        // chain_helper (owner of the SuperblockManager govman clears in its dtor)
+        // must outlive govman -- see PrepareShutdown in init.cpp.
+        m_node.govman.reset();
+    }
+
+    // Malformed trigger JSON: type=TRIGGER so LoadData/IsValidLocally accept it, but
+    // SuperblockManager::AddTrigger fails while constructing CSuperblock (missing
+    // event_block_height / payment fields). That is the failed-trigger path.
+    CGovernanceObject MakeFailedTrigger(int64_t creation_time, int salt) const
+    {
+        const std::string data = strprintf(R"({"type":2,"salt":%d})", salt);
+        CGovernanceObject govobj{uint256{}, /*revision=*/1, creation_time, uint256{}, HexStr(data)};
+        BOOST_REQUIRE_EQUAL(std23::to_underlying(govobj.GetObjectType()),
+                            std23::to_underlying(GovernanceObject::TRIGGER));
+        govobj.SetMasternodeOutpoint(mn_outpoint);
+        const CBLSSignature sig = operator_key.Sign(govobj.GetSignatureHash(), /*specificLegacyScheme=*/false);
+        BOOST_REQUIRE(sig.IsValid());
+        govobj.SetSignature(sig.ToByteVector(/*specificLegacyScheme=*/false));
+        return govobj;
+    }
+};
+
+BOOST_FIXTURE_TEST_SUITE(governance_failed_trigger_rate_tests, FailedTriggerRateSetup)
+
+// Regression: AddGovernanceObjectInternal used to return early on
+// AddTrigger failure without calling MasternodeRateUpdate. Because
+// MasternodeRateCheck short-circuits when mapLastMasternodeObject has no entry,
+// a single operator key could flood mapObjects with unparseable triggers.
+// After the fix, failed triggers still advance the per-masternode rate buffer
+// so the flood is throttled.
+BOOST_AUTO_TEST_CASE(failed_trigger_path_advances_masternode_rate_limit)
+{
+    // Deterministic clock inside the allowed rate-check timestamp window.
+    SetMockTime(0s);
+    const int64_t base_time = GetTime<std::chrono::seconds>().count();
+
+    // Submit more failed triggers than RATE_BUFFER_SIZE from the same MN.
+    // Pre-fix the rate buffer never fills, so every object lands in mapObjects.
+    // Post-fix the buffer fills and further submissions are rate-rejected.
+    constexpr int flood_count = 12;
+    int objects_seen = 0;
+    for (int i = 0; i < flood_count; ++i) {
+        CGovernanceObject govobj = MakeFailedTrigger(base_time + i, /*salt=*/i);
+        const uint256 hash = govobj.GetHash();
+        // Unique per-object: salt + time vary both the data and the creation time.
+        BOOST_REQUIRE(!m_node.govman->HaveObjectForHash(hash));
+
+        LOCK(::cs_main);
+        // ProcessObject returns true for both accepted and rate-rejected objects
+        // (rate rejection is not a peer-misbehaviour event).
+        BOOST_CHECK(m_node.govman->ProcessObject(/*peer_str=*/"test-peer", hash, govobj));
+
+        if (m_node.govman->HaveObjectForHash(hash)) {
+            ++objects_seen;
+            // Failed triggers are accepted into mapObjects then marked for deletion.
+            const auto stored = m_node.govman->FindGovernanceObject(hash);
+            BOOST_REQUIRE(stored);
+            BOOST_CHECK(stored->IsSetCachedDelete());
+        }
+    }
+
+    // With the rate buffer size of 5, a fixed limiter records the first five
+    // failed attempts and rejects the rest before insertion. Without the fix
+    // every object is inserted (objects_seen == flood_count).
+    BOOST_CHECK_LT(objects_seen, flood_count);
+    BOOST_CHECK_LE(objects_seen, RATE_BUFFER_SIZE + 1);
+
+    const UniValue stats = m_node.govman->ToJson();
+    BOOST_CHECK_LT(stats["objects_total"].getInt<int>(), flood_count);
+    BOOST_CHECK_EQUAL(stats["objects_total"].getInt<int>(), objects_seen);
+
+    // A trigger we undid must never be announced to peers.
+    BOOST_CHECK(m_node.govman->FetchRelayInventory().empty());
+}
+
+// A failed trigger must not be scheduled for the deferred trigger-relay pass.
+// That bookkeeping (setAdditionalRelayObjects) fires for creation times close
+// to MAX_TIME_FUTURE_DEVIATION, and used to live inside MasternodeRateUpdate()
+// -- so counting the failed attempt against the rate buffer would otherwise
+// make the node re-announce, and serve on GETDATA, an object it had just
+// rejected and marked for deletion. One signature-valid message would then fan
+// out to every peer, which in turn re-announce it.
+BOOST_AUTO_TEST_CASE(failed_trigger_is_not_scheduled_for_additional_relay)
+{
+    SetMockTime(0s);
+    const int64_t now = GetTime<std::chrono::seconds>().count();
+
+    // Inside (now + MAX_TIME_FUTURE_DEVIATION - RELIABLE_PROPAGATION_TIME,
+    // now + MAX_TIME_FUTURE_DEVIATION], i.e. accepted by MasternodeRateCheck but
+    // "too new to propagate reliably", which is what arms the trigger relay.
+    const int64_t near_future = now + 3550;
+    CGovernanceObject govobj = MakeFailedTrigger(near_future, /*salt=*/0);
+    const uint256 hash = govobj.GetHash();
+
+    WITH_LOCK(::cs_main, BOOST_CHECK(m_node.govman->ProcessObject(/*peer_str=*/"test-peer", hash, govobj)));
+
+    // The object is stored (AddTrigger failure happens after insertion) but is
+    // immediately marked for deletion, so it is not syncable...
+    BOOST_REQUIRE(m_node.govman->HaveObjectForHash(hash));
+    BOOST_CHECK(!m_node.govman->HaveSyncableObjectForHash(hash));
+    // ...and nothing was queued for relay on the accept path either.
+    BOOST_CHECK(m_node.govman->FetchRelayInventory().empty());
+
+    // Move past RELIABLE_PROPAGATION_TIME so the deferred relay would be "ready",
+    // then run the pass. UpdatedBlockTip -> CheckPostponedObjects drains
+    // setAdditionalRelayObjects.
+    SetMockTime(std::chrono::seconds{now + 120});
+    m_node.govman->UpdatedBlockTip(WITH_LOCK(::cs_main, return m_node.chainman->ActiveChain().Tip()));
+
+    const auto invs = m_node.govman->FetchRelayInventory();
+    BOOST_CHECK(std::ranges::none_of(invs, [&](const CInv& inv) { return inv.hash == hash; }));
+    BOOST_CHECK(invs.empty());
+}
+
+BOOST_AUTO_TEST_SUITE_END()

From 5b4cc0f9d1d7f44fbcfd75b4ad68eb12b65005f5 Mon Sep 17 00:00:00 2001
From: pasta <pasta@dashboost.org>
Date: Tue, 4 Aug 2026 09:02:09 -0500
Subject: [PATCH 3/3] test: use one governance_inv_tests fixture and suite

Fold the failed-trigger rate regressions into the single
governance_inv_tests suite. GovernanceInvSetup now owns the DIP3 /
ProRegTx path used by those cases and also covers the INV/vote tests.
---
 src/test/governance_inv_tests.cpp | 191 +++++++++++-------------------
 1 file changed, 69 insertions(+), 122 deletions(-)

diff --git a/src/test/governance_inv_tests.cpp b/src/test/governance_inv_tests.cpp
index 29ab53c2a236..c2e104572441 100644
--- a/src/test/governance_inv_tests.cpp
+++ b/src/test/governance_inv_tests.cpp
@@ -28,7 +28,6 @@
 #include <test/util/masternode.h>
 #include <test/util/net.h>
 #include <test/util/setup_common.h>
-#include <test/util/validation.h>
 
 #include <boost/test/unit_test.hpp>
 
@@ -42,32 +41,67 @@
 using namespace std::chrono_literals;
 
 namespace {
-struct GovernanceInvSetup : public TestingSetup {
-    GovernanceInvSetup() : TestingSetup{CBaseChainParams::MAIN}
+// Unified governance unit-test fixture. The DIP3 / ProRegTx path is required for
+// signed-trigger rate regressions, and it also satisfies the lighter INV/vote
+// authorization tests (govman + NetGovernance handler + mn_sync).
+//
+// DIP3 activation is pushed to 109 so TestChainSetup's fixed-checkpoint assert
+// still succeeds while the early coinbases are mature.
+struct GovernanceInvSetup : public TestChainSetup {
+    COutPoint mn_outpoint;
+    CBLSSecretKey operator_key;
+
+    GovernanceInvSetup() :
+        TestChainSetup(/*num_blocks=*/107, CBaseChainParams::REGTEST, {"-dip3params=109:500"})
     {
-        // ConfirmInventoryRequest and the NetGovernance object/vote handlers
-        // short-circuit on !IsBlockchainSynced().
-        BOOST_REQUIRE(m_node.mn_sync);
-        m_node.mn_sync->SwitchToNextAsset();
-        BOOST_REQUIRE(m_node.mn_sync->IsBlockchainSynced());
+        auto& chainman = *Assert(m_node.chainman.get());
+        auto& dmnman = *Assert(m_node.dmnman);
+        const CScript coinbase_pk = GetScriptForRawPubKey(coinbaseKey.GetPubKey());
+
+        // Activate DIP3 (fixture tip is one block before activation height 109).
+        // Enforcement is independent of activation; ProRegTx only needs activation.
+        CreateAndProcessBlock({}, coinbase_pk);
+        BOOST_REQUIRE_EQUAL(WITH_LOCK(::cs_main, return chainman.ActiveChain().Height()), 108);
+
+        auto utxos = BuildSimpleUtxoMap(m_coinbase_txns);
+        CKey owner_key;
+        auto proreg_tx = CreateProRegTx(chainman, utxos, /*port=*/1, GenerateRandomAddress(), coinbaseKey, owner_key,
+                                        operator_key);
+        CreateAndProcessBlock({proreg_tx}, coinbase_pk);
+        dmnman.UpdatedBlockTip(WITH_LOCK(::cs_main, return chainman.ActiveChain().Tip()));
+
+        mn_outpoint = COutPoint{proreg_tx.GetHash(), 0};
+        const auto dmn = dmnman.GetListAtChainTip().GetMNByCollateral(mn_outpoint);
+        BOOST_REQUIRE(dmn);
+        BOOST_REQUIRE(dmn->pdmnState->pubKeyOperator.Get() == operator_key.GetPublicKey());
 
         BOOST_REQUIRE(m_node.mn_metaman);
         // Note: mn_metaman is left unloaded. No test here reaches
         // CGovernanceObject::ProcessVote, which asserts metaman.IsValid() -- a vote whose
         // parent object exists would, and would need it loaded first.
-        m_node.govman = std::make_unique<CGovernanceManager>(*m_node.mn_metaman, *m_node.chainman, *m_node.chain_helper->superblocks, *m_node.dmnman, *m_node.mn_sync);
+        BOOST_REQUIRE(m_node.mn_sync);
+        BOOST_REQUIRE(m_node.chain_helper);
+        BOOST_REQUIRE(m_node.chain_helper->superblocks);
+        m_node.govman = std::make_unique<CGovernanceManager>(*m_node.mn_metaman, *m_node.chainman,
+                                                             *m_node.chain_helper->superblocks, *m_node.dmnman,
+                                                             *m_node.mn_sync);
         // Match runtime preconditions: NetGovernance::AlreadyHave claims we
         // already have the inv when governance isn't loaded (e.g.
         // -disablegovernance), so ConfirmInventoryRequest would never run.
         BOOST_REQUIRE(m_node.govman->LoadCache(/*load_cache=*/false));
 
         BOOST_REQUIRE(m_node.netfulfilledman);
-        // Loaded here for the later test that advances GOVERNANCE -> FINISHED;
-        // the sync notifier asserts netfulfilledman.IsValid().
+        // Loaded before advancing sync: SyncFinished asserts netfulfilledman.IsValid().
         BOOST_REQUIRE(m_node.netfulfilledman->LoadCache(/*load_cache=*/false));
         BOOST_REQUIRE(m_node.connman);
         BOOST_REQUIRE(m_node.peerman);
 
+        // Advance BLOCKCHAIN -> GOVERNANCE -> FINISHED. Rate checks are a no-op until
+        // IsSynced(); INV/vote tests also tolerate a fully-synced start state.
+        m_node.mn_sync->SwitchToNextAsset();
+        m_node.mn_sync->SwitchToNextAsset();
+        BOOST_REQUIRE(m_node.mn_sync->IsSynced());
+
         // Intentional unit-test boundary: TestingSetup does not run the
         // init.cpp/AppInit startup path that registers the Dash-specific
         // handlers, so the INV branch in PeerManagerImpl::AlreadyHave would not
@@ -79,17 +113,33 @@ struct GovernanceInvSetup : public TestingSetup {
             m_node.peerman.get(), *m_node.govman, *m_node.mn_sync,
             *m_node.netfulfilledman, *m_node.connman));
 
-        // Anchor the clock so the object and vote timestamps the tests build
-        // from GetTime() are deterministic. Nothing advances it.
-        SetMockTime(1'700'000'000s);
+        // Deterministic clock for object/vote timestamps and rate-check windows.
+        SetMockTime(0s);
     }
-    ~GovernanceInvSetup() {
-        // govman holds a reference to chain_helper->superblocks, so it must be reset before chain_helper (matches PrepareShutdown
-        // ordering in init.cpp).
+
+    ~GovernanceInvSetup()
+    {
+        // govman holds a reference to chain_helper->superblocks, so it must be reset
+        // before chain_helper (matches PrepareShutdown ordering in init.cpp).
         m_node.peerman->RemoveHandlers();
         m_node.govman.reset();
     }
 
+    // Malformed trigger JSON: type=TRIGGER so LoadData/IsValidLocally accept it, but
+    // SuperblockManager::AddTrigger fails while constructing CSuperblock (missing
+    // event_block_height / payment fields). That is the failed-trigger path.
+    CGovernanceObject MakeFailedTrigger(int64_t creation_time, int salt) const
+    {
+        const std::string data = strprintf(R"({"type":2,"salt":%d})", salt);
+        CGovernanceObject govobj{uint256{}, /*revision=*/1, creation_time, uint256{}, HexStr(data)};
+        BOOST_REQUIRE_EQUAL(std23::to_underlying(govobj.GetObjectType()),
+                            std23::to_underlying(GovernanceObject::TRIGGER));
+        govobj.SetMasternodeOutpoint(mn_outpoint);
+        const CBLSSignature sig = operator_key.Sign(govobj.GetSignatureHash(), /*specificLegacyScheme=*/false);
+        BOOST_REQUIRE(sig.IsValid());
+        govobj.SetSignature(sig.ToByteVector(/*specificLegacyScheme=*/false));
+        return govobj;
+    }
 };
 
 size_t CountQueuedMessages(const CNode& peer, const std::string& msg_type)
@@ -196,8 +246,7 @@ BOOST_AUTO_TEST_CASE(per_object_vote_sync_is_fulfilled_request_limited)
     LOCK(NetEventsInterface::g_msgproc_mutex);
 
     // NetGovernance::ProcessMessage ignores MNGOVERNANCESYNC until sync is
-    // fully finished; advance from GOVERNANCE to FINISHED.
-    m_node.mn_sync->SwitchToNextAsset();
+    // fully finished; the fixture already advances to FINISHED.
     BOOST_REQUIRE(m_node.mn_sync->IsSynced());
 
     auto peer{MakeGovernanceInvPeer(/*id=*/1)};
@@ -331,10 +380,6 @@ BOOST_AUTO_TEST_CASE(governance_objects_require_peer_announcement_or_request)
 {
     LOCK(NetEventsInterface::g_msgproc_mutex);
 
-    TestChainState& chainstate =
-        *static_cast<TestChainState*>(&m_node.chainman->ActiveChainstate());
-    chainstate.JumpOutOfIbd();
-
     NetGovernance net_gov(m_node.peerman.get(), *m_node.govman, *m_node.mn_sync,
                           *m_node.netfulfilledman, *m_node.connman);
 
@@ -382,17 +427,12 @@ BOOST_AUTO_TEST_CASE(governance_objects_require_peer_announcement_or_request)
     m_node.peerman->FinalizeNode(*announcing_peer);
     m_node.peerman->FinalizeNode(*second_announcing_peer);
     m_node.peerman->FinalizeNode(*unsolicited_peer);
-    chainstate.ResetIbd();
 }
 
 BOOST_AUTO_TEST_CASE(governance_votes_require_peer_announcement_or_request)
 {
     LOCK(NetEventsInterface::g_msgproc_mutex);
 
-    TestChainState& chainstate =
-        *static_cast<TestChainState*>(&m_node.chainman->ActiveChainstate());
-    chainstate.JumpOutOfIbd();
-
     NetGovernance net_gov(m_node.peerman.get(), *m_node.govman, *m_node.mn_sync,
                           *m_node.netfulfilledman, *m_node.connman);
 
@@ -433,7 +473,6 @@ BOOST_AUTO_TEST_CASE(governance_votes_require_peer_announcement_or_request)
     m_node.peerman->FinalizeNode(*announcing_peer);
     m_node.peerman->FinalizeNode(*second_announcing_peer);
     m_node.peerman->FinalizeNode(*unsolicited_peer);
-    chainstate.ResetIbd();
 }
 
 // A message received while not blockchain-synced is dropped, but the per-peer authorization must
@@ -442,10 +481,6 @@ BOOST_AUTO_TEST_CASE(governance_vote_authorization_survives_unsynced_drop)
 {
     LOCK(NetEventsInterface::g_msgproc_mutex);
 
-    TestChainState& chainstate =
-        *static_cast<TestChainState*>(&m_node.chainman->ActiveChainstate());
-    chainstate.JumpOutOfIbd();
-
     NetGovernance net_gov(m_node.peerman.get(), *m_node.govman, *m_node.mn_sync,
                           *m_node.netfulfilledman, *m_node.connman);
 
@@ -477,97 +512,8 @@ BOOST_AUTO_TEST_CASE(governance_vote_authorization_survives_unsynced_drop)
     BOOST_CHECK_EQUAL(CountQueuedMessages(*peer, NetMsgType::MNGOVERNANCESYNC), 1U);
 
     m_node.peerman->FinalizeNode(*peer);
-    chainstate.ResetIbd();
 }
 
-BOOST_AUTO_TEST_SUITE_END()
-
-
-// Fixture for failed-trigger rate-limit regressions: DIP3-active chain, one
-// registered masternode whose operator BLS key we hold, governance wired as in
-// production init, and CMasternodeSync driven to FINISHED (MasternodeRateCheck is
-// a no-op until then).
-//
-// The DIP3 activation height is pushed to 109 so TestChainSetup's fixed-checkpoint
-// assert still succeeds while the early coinbases are mature.
-struct FailedTriggerRateSetup : public TestChainSetup {
-    COutPoint mn_outpoint;
-    CBLSSecretKey operator_key;
-
-    FailedTriggerRateSetup() :
-        TestChainSetup(/*num_blocks=*/107, CBaseChainParams::REGTEST, {"-dip3params=109:500"})
-    {
-        auto& chainman = *Assert(m_node.chainman.get());
-        auto& dmnman = *Assert(m_node.dmnman);
-        const CScript coinbase_pk = GetScriptForRawPubKey(coinbaseKey.GetPubKey());
-
-        // Activate DIP3 (fixture tip is one block before activation height 109).
-        // Enforcement is independent of activation; ProRegTx only needs activation.
-        CreateAndProcessBlock({}, coinbase_pk);
-        BOOST_REQUIRE_EQUAL(WITH_LOCK(::cs_main, return chainman.ActiveChain().Height()), 108);
-
-        auto utxos = BuildSimpleUtxoMap(m_coinbase_txns);
-        CKey owner_key;
-        auto proreg_tx = CreateProRegTx(chainman, utxos, /*port=*/1, GenerateRandomAddress(), coinbaseKey, owner_key,
-                                        operator_key);
-        CreateAndProcessBlock({proreg_tx}, coinbase_pk);
-        dmnman.UpdatedBlockTip(WITH_LOCK(::cs_main, return chainman.ActiveChain().Tip()));
-
-        mn_outpoint = COutPoint{proreg_tx.GetHash(), 0};
-        const auto dmn = dmnman.GetListAtChainTip().GetMNByCollateral(mn_outpoint);
-        BOOST_REQUIRE(dmn);
-        BOOST_REQUIRE(dmn->pdmnState->pubKeyOperator.Get() == operator_key.GetPublicKey());
-
-        BOOST_REQUIRE(m_node.mn_metaman);
-        BOOST_REQUIRE(m_node.mn_sync);
-        BOOST_REQUIRE(m_node.chain_helper);
-        BOOST_REQUIRE(m_node.chain_helper->superblocks);
-        m_node.govman = std::make_unique<CGovernanceManager>(*m_node.mn_metaman, *m_node.chainman,
-                                                             *m_node.chain_helper->superblocks, *m_node.dmnman,
-                                                             *m_node.mn_sync);
-        BOOST_REQUIRE(m_node.govman->LoadCache(/*load_cache=*/false));
-
-        // Advance BLOCKCHAIN -> GOVERNANCE -> FINISHED. SyncFinished requires a
-        // loaded netfulfilledman.
-        BOOST_REQUIRE(m_node.netfulfilledman);
-        BOOST_REQUIRE(m_node.netfulfilledman->LoadCache(/*load_cache=*/false));
-        m_node.mn_sync->SwitchToNextAsset();
-        m_node.mn_sync->SwitchToNextAsset();
-        BOOST_REQUIRE(m_node.mn_sync->IsSynced());
-    }
-
-    ~FailedTriggerRateSetup()
-    {
-        // chain_helper (owner of the SuperblockManager govman clears in its dtor)
-        // must outlive govman -- see PrepareShutdown in init.cpp.
-        m_node.govman.reset();
-    }
-
-    // Malformed trigger JSON: type=TRIGGER so LoadData/IsValidLocally accept it, but
-    // SuperblockManager::AddTrigger fails while constructing CSuperblock (missing
-    // event_block_height / payment fields). That is the failed-trigger path.
-    CGovernanceObject MakeFailedTrigger(int64_t creation_time, int salt) const
-    {
-        const std::string data = strprintf(R"({"type":2,"salt":%d})", salt);
-        CGovernanceObject govobj{uint256{}, /*revision=*/1, creation_time, uint256{}, HexStr(data)};
-        BOOST_REQUIRE_EQUAL(std23::to_underlying(govobj.GetObjectType()),
-                            std23::to_underlying(GovernanceObject::TRIGGER));
-        govobj.SetMasternodeOutpoint(mn_outpoint);
-        const CBLSSignature sig = operator_key.Sign(govobj.GetSignatureHash(), /*specificLegacyScheme=*/false);
-        BOOST_REQUIRE(sig.IsValid());
-        govobj.SetSignature(sig.ToByteVector(/*specificLegacyScheme=*/false));
-        return govobj;
-    }
-};
-
-BOOST_FIXTURE_TEST_SUITE(governance_failed_trigger_rate_tests, FailedTriggerRateSetup)
-
-// Regression: AddGovernanceObjectInternal used to return early on
-// AddTrigger failure without calling MasternodeRateUpdate. Because
-// MasternodeRateCheck short-circuits when mapLastMasternodeObject has no entry,
-// a single operator key could flood mapObjects with unparseable triggers.
-// After the fix, failed triggers still advance the per-masternode rate buffer
-// so the flood is throttled.
 BOOST_AUTO_TEST_CASE(failed_trigger_path_advances_masternode_rate_limit)
 {
     // Deterministic clock inside the allowed rate-check timestamp window.
@@ -652,4 +598,5 @@ BOOST_AUTO_TEST_CASE(failed_trigger_is_not_scheduled_for_additional_relay)
     BOOST_CHECK(invs.empty());
 }
 
+
 BOOST_AUTO_TEST_SUITE_END()