From ef1b4a70c20eda6ac5e544fe26f76a08255cff42 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Sat, 10 Jan 2026 20:34:24 +0530
Subject: [PATCH 01/16] refactor: rename `ToUnderlying()` to match C++23
 convention

We have a multitude of C++23 polyfills across the codebase and the
current naming convention makes it painful to switch to the standard
library when the time eventually comes.
---
 src/Makefile.am                   |  2 +-
 src/active/dkgsessionhandler.cpp  | 20 +++++++++---------
 src/active/quorums.cpp            |  8 ++++----
 src/addressindex.h                |  8 ++++----
 src/chainlock/chainlock.cpp       |  4 ++--
 src/chainparams.cpp               |  4 ++--
 src/evo/core_write.cpp            | 10 ++++-----
 src/evo/providertx.cpp            |  6 +++---
 src/evo/providertx.h              |  2 +-
 src/evo/simplifiedmns.cpp         | 10 +++++----
 src/evo/smldiff.cpp               |  2 +-
 src/governance/classes.cpp        |  7 ++++---
 src/governance/governance.cpp     |  6 +++---
 src/governance/object.cpp         |  4 ++--
 src/governance/validators.cpp     |  7 ++++---
 src/llmq/blockprocessor.cpp       | 34 +++++++++++++++----------------
 src/llmq/commitment.cpp           | 14 ++++++-------
 src/llmq/commitment.h             | 10 ++++-----
 src/llmq/core_write.cpp           |  6 +++---
 src/llmq/debug.cpp                | 14 ++++++-------
 src/llmq/dkgsession.cpp           | 10 ++++-----
 src/llmq/dkgsession.h             |  4 ++--
 src/llmq/dkgsessionmgr.cpp        | 21 ++++++++++---------
 src/llmq/observer/quorums.cpp     | 10 ++++-----
 src/llmq/options.cpp              |  4 ++--
 src/llmq/quorumsman.cpp           | 16 +++++++--------
 src/llmq/signing_shares.cpp       | 10 ++++-----
 src/llmq/utils.cpp                |  4 ++--
 src/net_processing.cpp            |  4 ++--
 src/qt/optionsdialog.cpp          |  4 ++--
 src/qt/rpcconsole.cpp             |  8 ++++----
 src/spentindex.h                  |  2 +-
 src/test/llmq_dkg_tests.cpp       |  4 ++--
 src/util/std23.h                  | 28 +++++++++++++++++++++++++
 src/util/underlying.h             | 14 -------------
 src/validation.cpp                |  2 +-
 src/zmq/zmqpublishnotifier.cpp    |  2 +-
 test/util/data/non-backported.txt |  1 +
 38 files changed, 173 insertions(+), 153 deletions(-)
 create mode 100644 src/util/std23.h
 delete mode 100644 src/util/underlying.h

diff --git a/src/Makefile.am b/src/Makefile.am
index 1c5fd1936399..7b4960beb3ce 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -412,9 +412,9 @@ BITCOIN_CORE_H = \
   util/ranges.h \
   util/readwritefile.h \
   util/result.h \
-  util/underlying.h \
   util/serfloat.h \
   util/settings.h \
+  util/std23.h \
   util/ranges_set.h \
   util/sock.h \
   util/string.h \
diff --git a/src/active/dkgsessionhandler.cpp b/src/active/dkgsessionhandler.cpp
index c0ed65b75402..ad795befc498 100644
--- a/src/active/dkgsessionhandler.cpp
+++ b/src/active/dkgsessionhandler.cpp
@@ -61,12 +61,12 @@ void ActiveDKGSessionHandler::UpdatedBlockTip(const CBlockIndex* pindexNew)
     bool fNewPhase = (quorumStageInt % params.dkgPhaseBlocks) == 0;
     int phaseInt = quorumStageInt / params.dkgPhaseBlocks + 1;
     QuorumPhase oldPhase = phase;
-    if (fNewPhase && phaseInt >= ToUnderlying(QuorumPhase::Initialized) && phaseInt <= ToUnderlying(QuorumPhase::Idle)) {
+    if (fNewPhase && phaseInt >= std23::to_underlying(QuorumPhase::Initialized) && phaseInt <= std23::to_underlying(QuorumPhase::Idle)) {
         phase = static_cast<QuorumPhase>(phaseInt);
     }
 
     LogPrint(BCLog::LLMQ_DKG, "ActiveDKGSessionHandler::%s -- %s qi[%d] currentHeight=%d, pQuorumBaseBlockIndex->nHeight=%d, oldPhase=%d, newPhase=%d\n", __func__,
-             params.name, quorumIndex, currentHeight, pQuorumBaseBlockIndex->nHeight, ToUnderlying(oldPhase), ToUnderlying(phase));
+             params.name, quorumIndex, currentHeight, pQuorumBaseBlockIndex->nHeight, std23::to_underlying(oldPhase), std23::to_underlying(phase));
 }
 
 void ActiveDKGSessionHandler::StartThread(CConnman& connman, PeerManager& peerman)
@@ -75,7 +75,7 @@ void ActiveDKGSessionHandler::StartThread(CConnman& connman, PeerManager& peerma
         throw std::runtime_error("Tried to start an already started ActiveDKGSessionHandler thread.");
     }
 
-    m_thread_name = strprintf("llmq-%d-%d", ToUnderlying(params.type), quorumIndex);
+    m_thread_name = strprintf("llmq-%d-%d", std23::to_underlying(params.type), quorumIndex);
     phaseHandlerThread = std::thread(&util::TraceThread, m_thread_name.c_str(),
                                      [this, &connman, &peerman] { PhaseHandlerThread(connman, peerman); });
 }
@@ -120,7 +120,7 @@ class AbortPhaseException : public std::exception {
 void ActiveDKGSessionHandler::WaitForNextPhase(std::optional<QuorumPhase> curPhase, QuorumPhase nextPhase,
                                                const uint256& expectedQuorumHash, const WhileWaitFunc& shouldNotWait) const
 {
-    LogPrint(BCLog::LLMQ_DKG, "ActiveDKGSessionHandler::%s -- %s qi[%d] - starting, curPhase=%d, nextPhase=%d\n", __func__, params.name, quorumIndex, curPhase.has_value() ? ToUnderlying(*curPhase) : -1, ToUnderlying(nextPhase));
+    LogPrint(BCLog::LLMQ_DKG, "ActiveDKGSessionHandler::%s -- %s qi[%d] - starting, curPhase=%d, nextPhase=%d\n", __func__, params.name, quorumIndex, curPhase.has_value() ? std23::to_underlying(*curPhase) : -1, std23::to_underlying(nextPhase));
 
     while (true) {
         if (stopRequested) {
@@ -136,7 +136,7 @@ void ActiveDKGSessionHandler::WaitForNextPhase(std::optional<QuorumPhase> curPha
             break;
         }
         if (curPhase.has_value() && _phase != curPhase) {
-            LogPrint(BCLog::LLMQ_DKG, "ActiveDKGSessionHandler::%s -- %s qi[%d] - aborting due unexpected phase change, _phase=%d, curPhase=%d\n", __func__, params.name, quorumIndex, ToUnderlying(_phase), curPhase.has_value() ? ToUnderlying(*curPhase) : -1);
+            LogPrint(BCLog::LLMQ_DKG, "ActiveDKGSessionHandler::%s -- %s qi[%d] - aborting due unexpected phase change, _phase=%d, curPhase=%d\n", __func__, params.name, quorumIndex, std23::to_underlying(_phase), curPhase.has_value() ? std23::to_underlying(*curPhase) : -1);
             throw AbortPhaseException();
         }
         if (!shouldNotWait()) {
@@ -144,7 +144,7 @@ void ActiveDKGSessionHandler::WaitForNextPhase(std::optional<QuorumPhase> curPha
         }
     }
 
-    LogPrint(BCLog::LLMQ_DKG, "ActiveDKGSessionHandler::%s -- %s qi[%d] - done, curPhase=%d, nextPhase=%d\n", __func__, params.name, quorumIndex, curPhase.has_value() ? ToUnderlying(*curPhase) : -1, ToUnderlying(nextPhase));
+    LogPrint(BCLog::LLMQ_DKG, "ActiveDKGSessionHandler::%s -- %s qi[%d] - done, curPhase=%d, nextPhase=%d\n", __func__, params.name, quorumIndex, curPhase.has_value() ? std23::to_underlying(*curPhase) : -1, std23::to_underlying(nextPhase));
 
     if (nextPhase == QuorumPhase::Initialized) {
         m_dkgdbgman.ResetLocalSessionStatus(params.type, quorumIndex);
@@ -206,7 +206,7 @@ void ActiveDKGSessionHandler::SleepBeforePhase(QuorumPhase curPhase, const uint2
     int heightTmp{currentHeight.load()};
     int heightStart{heightTmp};
 
-    LogPrint(BCLog::LLMQ_DKG, "ActiveDKGSessionHandler::%s -- %s qi[%d] - starting sleep for %d ms, curPhase=%d\n", __func__, params.name, quorumIndex, sleepTime, ToUnderlying(curPhase));
+    LogPrint(BCLog::LLMQ_DKG, "ActiveDKGSessionHandler::%s -- %s qi[%d] - starting sleep for %d ms, curPhase=%d\n", __func__, params.name, quorumIndex, sleepTime, std23::to_underlying(curPhase));
 
     while (TicksSinceEpoch<std::chrono::milliseconds>(SystemClock::now()) < endTime) {
         if (stopRequested) {
@@ -233,20 +233,20 @@ void ActiveDKGSessionHandler::SleepBeforePhase(QuorumPhase curPhase, const uint2
         }
     }
 
-    LogPrint(BCLog::LLMQ_DKG, "ActiveDKGSessionHandler::%s -- %s qi[%d] - done, curPhase=%d\n", __func__, params.name, quorumIndex, ToUnderlying(curPhase));
+    LogPrint(BCLog::LLMQ_DKG, "ActiveDKGSessionHandler::%s -- %s qi[%d] - done, curPhase=%d\n", __func__, params.name, quorumIndex, std23::to_underlying(curPhase));
 }
 
 void ActiveDKGSessionHandler::HandlePhase(QuorumPhase curPhase, QuorumPhase nextPhase,
                                           const uint256& expectedQuorumHash, double randomSleepFactor,
                                           const StartPhaseFunc& startPhaseFunc, const WhileWaitFunc& runWhileWaiting)
 {
-    LogPrint(BCLog::LLMQ_DKG, "ActiveDKGSessionHandler::%s -- %s qi[%d] - starting, curPhase=%d, nextPhase=%d\n", __func__, params.name, quorumIndex, ToUnderlying(curPhase), ToUnderlying(nextPhase));
+    LogPrint(BCLog::LLMQ_DKG, "ActiveDKGSessionHandler::%s -- %s qi[%d] - starting, curPhase=%d, nextPhase=%d\n", __func__, params.name, quorumIndex, std23::to_underlying(curPhase), std23::to_underlying(nextPhase));
 
     SleepBeforePhase(curPhase, expectedQuorumHash, randomSleepFactor, runWhileWaiting);
     startPhaseFunc();
     WaitForNextPhase(curPhase, nextPhase, expectedQuorumHash, runWhileWaiting);
 
-    LogPrint(BCLog::LLMQ_DKG, "ActiveDKGSessionHandler::%s -- %s qi[%d] - done, curPhase=%d, nextPhase=%d\n", __func__, params.name, quorumIndex, ToUnderlying(curPhase), ToUnderlying(nextPhase));
+    LogPrint(BCLog::LLMQ_DKG, "ActiveDKGSessionHandler::%s -- %s qi[%d] - done, curPhase=%d, nextPhase=%d\n", __func__, params.name, quorumIndex, std23::to_underlying(curPhase), std23::to_underlying(nextPhase));
 }
 
 // returns a set of NodeIds which sent invalid messages
diff --git a/src/active/quorums.cpp b/src/active/quorums.cpp
index 1885022d9c35..b293a99030c7 100644
--- a/src/active/quorums.cpp
+++ b/src/active/quorums.cpp
@@ -53,7 +53,7 @@ void QuorumParticipant::CheckQuorumConnections(const Consensus::LLMQParams& llmq
         if (utils::EnsureQuorumConnections(llmqParams, m_connman, m_sporkman, {m_dmnman, m_qsnapman, m_chainman, quorum->m_quorum_base_block_index},
                                            m_dmnman.GetListAtChainTip(), proTxHash, /*is_masternode=*/true, m_quorums_watch)) {
             if (deletableQuorums.erase(quorum->qc->quorumHash) > 0) {
-                LogPrint(BCLog::LLMQ, "QuorumParticipant::%s -- llmqType[%d] h[%d] keeping mn quorum connections for quorum: [%d:%s]\n", __func__, ToUnderlying(llmqParams.type), pindexNew->nHeight, quorum->m_quorum_base_block_index->nHeight, quorum->m_quorum_base_block_index->GetBlockHash().ToString());
+                LogPrint(BCLog::LLMQ, "QuorumParticipant::%s -- llmqType[%d] h[%d] keeping mn quorum connections for quorum: [%d:%s]\n", __func__, std23::to_underlying(llmqParams.type), pindexNew->nHeight, quorum->m_quorum_base_block_index->nHeight, quorum->m_quorum_base_block_index->GetBlockHash().ToString());
             }
         } else if (watchOtherISQuorums && !quorum->IsMember(proTxHash)) {
             Uint256HashSet connections;
@@ -63,12 +63,12 @@ void QuorumParticipant::CheckQuorumConnections(const Consensus::LLMQParams& llmq
             }
             if (!connections.empty()) {
                 if (!m_connman.HasMasternodeQuorumNodes(llmqParams.type, quorum->m_quorum_base_block_index->GetBlockHash())) {
-                    LogPrint(BCLog::LLMQ, "QuorumParticipant::%s -- llmqType[%d] h[%d] adding mn inter-quorum connections for quorum: [%d:%s]\n", __func__, ToUnderlying(llmqParams.type), pindexNew->nHeight, quorum->m_quorum_base_block_index->nHeight, quorum->m_quorum_base_block_index->GetBlockHash().ToString());
+                    LogPrint(BCLog::LLMQ, "QuorumParticipant::%s -- llmqType[%d] h[%d] adding mn inter-quorum connections for quorum: [%d:%s]\n", __func__, std23::to_underlying(llmqParams.type), pindexNew->nHeight, quorum->m_quorum_base_block_index->nHeight, quorum->m_quorum_base_block_index->GetBlockHash().ToString());
                     m_connman.SetMasternodeQuorumNodes(llmqParams.type, quorum->m_quorum_base_block_index->GetBlockHash(), connections);
                     m_connman.SetMasternodeQuorumRelayMembers(llmqParams.type, quorum->m_quorum_base_block_index->GetBlockHash(), connections);
                 }
                 if (deletableQuorums.erase(quorum->qc->quorumHash) > 0) {
-                    LogPrint(BCLog::LLMQ, "QuorumParticipant::%s -- llmqType[%d] h[%d] keeping mn inter-quorum connections for quorum: [%d:%s]\n", __func__, ToUnderlying(llmqParams.type), pindexNew->nHeight, quorum->m_quorum_base_block_index->nHeight, quorum->m_quorum_base_block_index->GetBlockHash().ToString());
+                    LogPrint(BCLog::LLMQ, "QuorumParticipant::%s -- llmqType[%d] h[%d] keeping mn inter-quorum connections for quorum: [%d:%s]\n", __func__, std23::to_underlying(llmqParams.type), pindexNew->nHeight, quorum->m_quorum_base_block_index->nHeight, quorum->m_quorum_base_block_index->GetBlockHash().ToString());
                 }
             }
         }
@@ -224,7 +224,7 @@ void QuorumParticipant::TriggerQuorumDataRecoveryThreads(gsl::not_null<const CBl
                     StartDataRecoveryThread(block_index, std::move(pQuorum), nDataMask);
                 } else {
                     LogPrint(BCLog::LLMQ, "QuorumParticipant::%s -- No data needed from (%d, %s) at height %d\n", __func__,
-                             ToUnderlying(pQuorum->qc->llmqType), pQuorum->qc->quorumHash.ToString(), block_index->nHeight);
+                             std23::to_underlying(pQuorum->qc->llmqType), pQuorum->qc->quorumHash.ToString(), block_index->nHeight);
                 }
             } else {
                 TryStartVvecSyncThread(block_index, std::move(pQuorum), fWeAreQuorumTypeMember);
diff --git a/src/addressindex.h b/src/addressindex.h
index 55dbc8284a58..6ef68d473d80 100644
--- a/src/addressindex.h
+++ b/src/addressindex.h
@@ -11,7 +11,7 @@
 #include <consensus/amount.h>
 #include <serialize.h>
 #include <uint256.h>
-#include <util/underlying.h>
+#include <util/std23.h>
 
 #include <chrono>
 #include <tuple>
@@ -122,7 +122,7 @@ struct CAddressIndexKey {
 
     template<typename Stream>
     void Serialize(Stream& s) const {
-        ser_writedata8(s, ToUnderlying(m_address_type));
+        ser_writedata8(s, std23::to_underlying(m_address_type));
         m_address_bytes.Serialize(s);
         // Heights are stored big-endian for key sorting in LevelDB
         ser_writedata32be(s, m_block_height);
@@ -169,7 +169,7 @@ struct CAddressIndexIteratorKey {
 
     template<typename Stream>
     void Serialize(Stream& s) const {
-        ser_writedata8(s, ToUnderlying(m_address_type));
+        ser_writedata8(s, std23::to_underlying(m_address_type));
         m_address_bytes.Serialize(s);
     }
 
@@ -207,7 +207,7 @@ struct CAddressIndexIteratorHeightKey {
 
     template<typename Stream>
     void Serialize(Stream& s) const {
-        ser_writedata8(s, ToUnderlying(m_address_type));
+        ser_writedata8(s, std23::to_underlying(m_address_type));
         m_address_bytes.Serialize(s);
         ser_writedata32be(s, m_block_height);
     }
diff --git a/src/chainlock/chainlock.cpp b/src/chainlock/chainlock.cpp
index bbfb3c9f83af..e5a62a43c54b 100644
--- a/src/chainlock/chainlock.cpp
+++ b/src/chainlock/chainlock.cpp
@@ -10,9 +10,9 @@
 #include <node/interface_ui.h>
 #include <scheduler.h>
 #include <txmempool.h>
+#include <util/std23.h>
 #include <util/thread.h>
 #include <util/time.h>
-#include <util/underlying.h>
 #include <validation.h>
 #include <validationinterface.h>
 
@@ -135,7 +135,7 @@ MessageProcessingResult CChainLocksHandler::ProcessNewChainLock(const NodeId fro
 
     if (const auto ret = VerifyChainLock(clsig); ret != VerifyRecSigStatus::Valid) {
         LogPrint(BCLog::CHAINLOCKS, "CChainLocksHandler::%s -- invalid CLSIG (%s), status=%d peer=%d\n", __func__,
-                 clsig.ToString(), ToUnderlying(ret), from);
+                 clsig.ToString(), std23::to_underlying(ret), from);
         if (from != -1) {
             return MisbehavingError{10};
         }
diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index bf6e74023579..df1eb452ad53 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -11,8 +11,8 @@
 #include <deploymentinfo.h>
 #include <llmq/params.h>
 #include <util/ranges.h>
+#include <util/std23.h>
 #include <util/system.h>
-#include <util/underlying.h>
 #include <versionbits.h>
 
 #include <arith_uint256.h>
@@ -1192,7 +1192,7 @@ void CRegTestParams::UpdateLLMQInstantSendDIP0024FromArgs(const ArgsManager& arg
     if (llmqType == Consensus::LLMQType::LLMQ_NONE) {
         throw std::runtime_error("Invalid LLMQ type specified for -llmqtestinstantsenddip0024.");
     }
-    LogPrintf("Setting llmqtestinstantsenddip0024 to %ld\n", ToUnderlying(llmqType));
+    LogPrintf("Setting llmqtestinstantsenddip0024 to %ld\n", std23::to_underlying(llmqType));
     UpdateLLMQDIP0024InstantSend(llmqType);
 }
 
diff --git a/src/evo/core_write.cpp b/src/evo/core_write.cpp
index b3e414d7c779..72b3cb0b32b8 100644
--- a/src/evo/core_write.cpp
+++ b/src/evo/core_write.cpp
@@ -13,11 +13,11 @@
 #include <evo/smldiff.h>
 #include <llmq/commitment.h>
 #include <rpc/evo_util.h>
+#include <util/std23.h>
 
 #include <core_io.h>
 #include <rpc/util.h>
 #include <util/check.h>
-#include <util/underlying.h>
 
 #include <univalue.h>
 
@@ -163,7 +163,7 @@ RPCResult CCbTx::GetJsonHelp(const std::string& key, bool optional)
 UniValue CCbTx::ToJson() const
 {
     UniValue ret(UniValue::VOBJ);
-    ret.pushKV("version", ToUnderlying(nVersion));
+    ret.pushKV("version", std23::to_underlying(nVersion));
     ret.pushKV("height", nHeight);
     ret.pushKV("merkleRootMNList", merkleRootMNList.ToString());
     if (nVersion >= CCbTx::Version::MERKLE_ROOT_QUORUMS) {
@@ -301,7 +301,7 @@ UniValue CProRegTx::ToJson() const
 {
     UniValue ret(UniValue::VOBJ);
     ret.pushKV("version", nVersion);
-    ret.pushKV("type", ToUnderlying(nType));
+    ret.pushKV("type", std23::to_underlying(nType));
     ret.pushKV("collateralHash", collateralOutpoint.hash.ToString());
     ret.pushKV("collateralIndex", collateralOutpoint.n);
     ret.pushKV("service", netInfo->GetPrimary().ToStringAddrPort());
@@ -391,7 +391,7 @@ UniValue CProUpServTx::ToJson() const
 {
     UniValue ret(UniValue::VOBJ);
     ret.pushKV("version", nVersion);
-    ret.pushKV("type", ToUnderlying(nType));
+    ret.pushKV("type", std23::to_underlying(nType));
     ret.pushKV("proTxHash", proTxHash.ToString());
     ret.pushKV("service", netInfo->GetPrimary().ToStringAddrPort());
     ret.pushKV("addresses", GetNetInfoWithLegacyFields(*this, nType));
@@ -524,7 +524,7 @@ UniValue CSimplifiedMNListEntry::ToJson(bool extended) const
 {
     UniValue obj(UniValue::VOBJ);
     obj.pushKV("nVersion", nVersion);
-    obj.pushKV("nType", ToUnderlying(nType));
+    obj.pushKV("nType", std23::to_underlying(nType));
     obj.pushKV("proRegTxHash", proRegTxHash.ToString());
     obj.pushKV("confirmedHash", confirmedHash.ToString());
     obj.pushKV("service", netInfo->GetPrimary().ToStringAddrPort());
diff --git a/src/evo/providertx.cpp b/src/evo/providertx.cpp
index 9f5d38a50a3e..bbdc009bb197 100644
--- a/src/evo/providertx.cpp
+++ b/src/evo/providertx.cpp
@@ -5,6 +5,7 @@
 #include <evo/providertx.h>
 
 #include <evo/dmn_types.h>
+#include <util/std23.h>
 
 #include <chainparams.h>
 #include <consensus/validation.h>
@@ -12,7 +13,6 @@
 #include <hash.h>
 #include <script/standard.h>
 #include <tinyformat.h>
-#include <util/underlying.h>
 #include <validation.h>
 
 namespace ProTxVersion {
@@ -154,7 +154,7 @@ std::string CProRegTx::ToString() const
 
     return strprintf("CProRegTx(nVersion=%d, nType=%d, collateralOutpoint=%s, netInfo=%s, nOperatorReward=%f, "
                      "ownerAddress=%s, pubKeyOperator=%s, votingAddress=%s, scriptPayout=%s, platformNodeID=%s%s)\n",
-                     nVersion, ToUnderlying(nType), collateralOutpoint.ToStringShort(), netInfo->ToString(),
+                     nVersion, std23::to_underlying(nType), collateralOutpoint.ToStringShort(), netInfo->ToString(),
                      (double)nOperatorReward / 100, EncodeDestination(PKHash(keyIDOwner)), pubKeyOperator.ToString(),
                      EncodeDestination(PKHash(keyIDVoting)), payee, platformNodeID.ToString(),
                      (nVersion >= ProTxVersion::ExtAddr
@@ -200,7 +200,7 @@ std::string CProUpServTx::ToString() const
 
     return strprintf("CProUpServTx(nVersion=%d, nType=%d, proTxHash=%s, netInfo=%s, operatorPayoutAddress=%s, "
                      "platformNodeID=%s%s)\n",
-                     nVersion, ToUnderlying(nType), proTxHash.ToString(), netInfo->ToString(), payee,
+                     nVersion, std23::to_underlying(nType), proTxHash.ToString(), netInfo->ToString(), payee,
                      platformNodeID.ToString(),
                      (nVersion >= ProTxVersion::ExtAddr
                           ? ""
diff --git a/src/evo/providertx.h b/src/evo/providertx.h
index 4642835dbb8b..dd85fa559b5d 100644
--- a/src/evo/providertx.h
+++ b/src/evo/providertx.h
@@ -10,12 +10,12 @@
 #include <evo/netinfo.h>
 #include <evo/specialtx.h>
 #include <primitives/transaction.h>
+#include <util/std23.h>
 
 #include <consensus/validation.h>
 #include <key_io.h>
 #include <netaddress.h>
 #include <pubkey.h>
-#include <util/underlying.h>
 
 #include <univalue.h>
 #include <gsl/pointers.h>
diff --git a/src/evo/simplifiedmns.cpp b/src/evo/simplifiedmns.cpp
index fcbc16d7587a..ea83cce79e44 100644
--- a/src/evo/simplifiedmns.cpp
+++ b/src/evo/simplifiedmns.cpp
@@ -4,18 +4,20 @@
 
 #include <evo/simplifiedmns.h>
 
+#include <evo/netinfo.h>
+#include <util/std23.h>
+
 #include <clientversion.h>
 #include <consensus/merkle.h>
-#include <evo/netinfo.h>
 #include <key_io.h>
 #include <logging.h>
 #include <serialize.h>
 #include <sync.h>
-#include <univalue.h>
 #include <util/time.h>
-#include <util/underlying.h>
 #include <version.h>
 
+#include <univalue.h>
+
 CSimplifiedMNListEntry::CSimplifiedMNListEntry(const uint256& proreg_tx_hash, const uint256& confirmed_hash,
                                                const std::shared_ptr<NetInfoInterface>& net_info,
                                                const CBLSLazyPublicKey& pubkey_operator, const CKeyID& keyid_voting,
@@ -59,7 +61,7 @@ std::string CSimplifiedMNListEntry::ToString() const
     return strprintf("CSimplifiedMNListEntry(nVersion=%d, nType=%d, proRegTxHash=%s, confirmedHash=%s, netInfo=%s, "
                      "pubKeyOperator=%s, votingAddress=%s, isValid=%d, payoutAddress=%s, operatorPayoutAddress=%s, "
                      "platformNodeID=%s%s)\n",
-                     nVersion, ToUnderlying(nType), proRegTxHash.ToString(), confirmedHash.ToString(),
+                     nVersion, std23::to_underlying(nType), proRegTxHash.ToString(), confirmedHash.ToString(),
                      netInfo->ToString(), pubKeyOperator.ToString(), EncodeDestination(PKHash(keyIDVoting)), isValid,
                      payoutAddress, operatorPayoutAddress, platformNodeID.ToString(),
                      (nVersion >= ProTxVersion::ExtAddr ? "" : strprintf(", platformHTTPPort=%d", platformHTTPPort)));
diff --git a/src/evo/smldiff.cpp b/src/evo/smldiff.cpp
index 823b24af1572..4edf461963a5 100644
--- a/src/evo/smldiff.cpp
+++ b/src/evo/smldiff.cpp
@@ -81,7 +81,7 @@ bool CSimplifiedMNListDiff::BuildQuorumChainlockInfo(const llmq::CQuorumManager&
         auto quorum = qman.GetQuorum(e.llmqType, e.quorumHash);
         if (!quorum) {
             LogPrintf("%s: ERROR! Unexpected missing quorum with llmqType=%d, quorumHash=%s\n", __func__,
-                      ToUnderlying(e.llmqType), e.quorumHash.ToString());
+                      std23::to_underlying(e.llmqType), e.quorumHash.ToString());
             return false;
         }
 
diff --git a/src/governance/classes.cpp b/src/governance/classes.cpp
index 405ebbc530c5..6e1bd943495e 100644
--- a/src/governance/classes.cpp
+++ b/src/governance/classes.cpp
@@ -4,13 +4,14 @@
 
 #include <governance/classes.h>
 
+#include <util/std23.h>
+
 #include <chainparams.h>
 #include <core_io.h>
 #include <key_io.h>
 #include <primitives/transaction.h>
 #include <script/standard.h>
 #include <util/strencodings.h>
-#include <util/underlying.h>
 #include <validation.h>
 
 #include <univalue.h>
@@ -75,7 +76,7 @@ CSuperblock::CSuperblock(const CGovernanceObject& govObj, uint256& nHash) :
     vecPayments()
 {
     LogPrint(BCLog::GOBJECT, "CSuperblock -- Constructor govobj: %s, nObjectType = %d\n", govObj.GetDataAsPlainString(),
-             ToUnderlying(govObj.GetObjectType()));
+             std23::to_underlying(govObj.GetObjectType()));
 
     if (govObj.GetObjectType() != GovernanceObject::TRIGGER) {
         throw std::runtime_error("CSuperblock: Governance Object not a trigger");
@@ -83,7 +84,7 @@ CSuperblock::CSuperblock(const CGovernanceObject& govObj, uint256& nHash) :
 
     UniValue obj = govObj.GetJSONObject();
 
-    if (obj["type"].getInt<int>() != ToUnderlying(GovernanceObject::TRIGGER)) {
+    if (obj["type"].getInt<int>() != std23::to_underlying(GovernanceObject::TRIGGER)) {
         throw std::runtime_error("CSuperblock: invalid data type");
     }
 
diff --git a/src/governance/governance.cpp b/src/governance/governance.cpp
index d64b63414939..190fe8b9dce5 100644
--- a/src/governance/governance.cpp
+++ b/src/governance/governance.cpp
@@ -284,7 +284,7 @@ void CGovernanceManager::AddGovernanceObjectInternal(CGovernanceObject& insert_o
     }
 
     LogPrint(BCLog::GOBJECT, "CGovernanceManager::AddGovernanceObject -- Adding object: hash = %s, type = %d\n", nHash.ToString(),
-             ToUnderlying(insert_obj.GetObjectType()));
+             std23::to_underlying(insert_obj.GetObjectType()));
 
     // INSERT INTO OUR GOVERNANCE OBJECT MEMORY
     // IF WE HAVE THIS OBJECT ALREADY, WE DON'T WANT ANOTHER COPY
@@ -299,7 +299,7 @@ void CGovernanceManager::AddGovernanceObjectInternal(CGovernanceObject& insert_o
 
     auto& [_, govobj] = *emplace_ret;
     LogPrint(BCLog::GOBJECT, "CGovernanceManager::AddGovernanceObject -- Before trigger block, GetDataAsPlainString = %s, nObjectType = %d\n",
-                Assert(govobj)->GetDataAsPlainString(), ToUnderlying(govobj->GetObjectType()));
+                Assert(govobj)->GetDataAsPlainString(), std23::to_underlying(govobj->GetObjectType()));
 
     if (govobj->GetObjectType() == GovernanceObject::TRIGGER && !AddNewTrigger(nHash)) {
         LogPrint(BCLog::GOBJECT, "CGovernanceManager::AddGovernanceObject -- undo adding invalid trigger object: hash = %s\n", nHash.ToString());
@@ -1289,7 +1289,7 @@ void CGovernanceManager::CleanAndRemoveTriggers()
             }
 
             LogPrint(BCLog::GOBJECT, "CGovernanceManager::%s -- superblock status = %d\n", __func__,
-                     ToUnderlying(pSuperblock->GetStatus()));
+                     std23::to_underlying(pSuperblock->GetStatus()));
             switch (pSuperblock->GetStatus()) {
             case SeenObjectStatus::ErrorInvalid:
             case SeenObjectStatus::Unknown:
diff --git a/src/governance/object.cpp b/src/governance/object.cpp
index 02804d532e4c..b1c1e8e4dad2 100644
--- a/src/governance/object.cpp
+++ b/src/governance/object.cpp
@@ -285,7 +285,7 @@ UniValue CGovernanceObject::GetStateJson(const ChainstateManager& chainman, cons
     ret.pushKV("DataString", GetDataAsPlainString());
     ret.pushKV("Hash", GetHash().ToString());
     ret.pushKV("CollateralHash", GetCollateralHash().ToString());
-    ret.pushKV("ObjectType", ToUnderlying(GetObjectType()));
+    ret.pushKV("ObjectType", std23::to_underlying(GetObjectType()));
     ret.pushKV("CreationTime", GetCreationTime());
     if (const COutPoint& outpoint = GetMasternodeOutpoint(); outpoint != COutPoint{}) {
         ret.pushKV("SigningMasternode", outpoint.ToStringShort());
@@ -427,7 +427,7 @@ bool CGovernanceObject::IsValidLocally(const CDeterministicMNList& tip_mn_list,
         return true;
     }
     default: {
-        strError = strprintf("Invalid object type %d", ToUnderlying(m_obj.type));
+        strError = strprintf("Invalid object type %d", std23::to_underlying(m_obj.type));
         return false;
     }
     }
diff --git a/src/governance/validators.cpp b/src/governance/validators.cpp
index bbe10d90439d..901378cf3c1d 100644
--- a/src/governance/validators.cpp
+++ b/src/governance/validators.cpp
@@ -3,13 +3,14 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <governance/common.h>
+
 #include <governance/validators.h>
+#include <util/std23.h>
 
 #include <key_io.h>
 #include <timedata.h>
 #include <tinyformat.h>
 #include <util/strencodings.h>
-#include <util/underlying.h>
 
 #include <algorithm>
 
@@ -78,8 +79,8 @@ bool CProposalValidator::ValidateType()
         return false;
     }
 
-    if (nType != ToUnderlying(GovernanceObject::PROPOSAL)) {
-        strErrorMessages += strprintf("type is not %d;", ToUnderlying(GovernanceObject::PROPOSAL));
+    if (nType != std23::to_underlying(GovernanceObject::PROPOSAL)) {
+        strErrorMessages += strprintf("type is not %d;", std23::to_underlying(GovernanceObject::PROPOSAL));
         return false;
     }
 
diff --git a/src/llmq/blockprocessor.cpp b/src/llmq/blockprocessor.cpp
index 86b9617ff004..b6191b9d8013 100644
--- a/src/llmq/blockprocessor.cpp
+++ b/src/llmq/blockprocessor.cpp
@@ -3,12 +3,13 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <llmq/blockprocessor.h>
-#include <llmq/commitment.h>
-#include <llmq/options.h>
-#include <llmq/utils.h>
 
 #include <evo/evodb.h>
 #include <evo/specialtx.h>
+#include <llmq/commitment.h>
+#include <llmq/options.h>
+#include <llmq/utils.h>
+#include <util/std23.h>
 
 #include <chain.h>
 #include <chainparams.h>
@@ -22,7 +23,6 @@
 #include <saltedhasher.h>
 #include <sync.h>
 #include <util/irange.h>
-#include <util/underlying.h>
 #include <validation.h>
 
 #include <map>
@@ -84,7 +84,7 @@ MessageProcessingResult CQuorumBlockProcessor::ProcessMessage(const CNode& peer,
     const auto& llmq_params_opt = Params().GetLLMQ(qc.llmqType);
     if (!llmq_params_opt.has_value()) {
         LogPrint(BCLog::LLMQ, "CQuorumBlockProcessor::%s -- invalid commitment type %d from peer=%d\n", __func__,
-                 ToUnderlying(qc.llmqType), peer.GetId());
+                 std23::to_underlying(qc.llmqType), peer.GetId());
         ret.m_error = MisbehavingError{100};
         return ret;
     }
@@ -125,7 +125,7 @@ MessageProcessingResult CQuorumBlockProcessor::ProcessMessage(const CNode& peer,
         }
         if (HasMinedCommitment(type, qc.quorumHash)) {
             LogPrint(BCLog::LLMQ, "CQuorumBlockProcessor::%s -- commitment for quorum hash[%s], type[%d], quorumIndex[%d] is already mined, peer=%d\n",
-                     __func__, qc.quorumHash.ToString(), ToUnderlying(type), qc.quorumIndex, peer.GetId());
+                     __func__, qc.quorumHash.ToString(), std23::to_underlying(type), qc.quorumIndex, peer.GetId());
             // NOTE: do not punish here
             return ret;
         }
@@ -148,13 +148,13 @@ MessageProcessingResult CQuorumBlockProcessor::ProcessMessage(const CNode& peer,
     if (!qc.Verify({m_dmnman, m_qsnapman, m_chainstate.m_chainman, pQuorumBaseBlockIndex}, /*checkSigs=*/true)) {
         LogPrint(BCLog::LLMQ, "CQuorumBlockProcessor::%s -- commitment for quorum %s:%d is not valid quorumIndex[%d] nversion[%d], peer=%d\n",
                  __func__, qc.quorumHash.ToString(),
-                 ToUnderlying(qc.llmqType), qc.quorumIndex, qc.nVersion, peer.GetId());
+                 std23::to_underlying(qc.llmqType), qc.quorumIndex, qc.nVersion, peer.GetId());
         ret.m_error = MisbehavingError{100};
         return ret;
     }
 
     LogPrint(BCLog::LLMQ, "CQuorumBlockProcessor::%s -- received commitment for quorum %s:%d, validMembers=%d, signers=%d, peer=%d\n", __func__,
-             qc.quorumHash.ToString(), ToUnderlying(qc.llmqType), qc.CountValidMembers(), qc.CountSigners(), peer.GetId());
+             qc.quorumHash.ToString(), std23::to_underlying(qc.llmqType), qc.CountValidMembers(), qc.CountSigners(), peer.GetId());
 
     if (auto inv_opt = AddMineableCommitment(qc)) {
         ret.m_inventory.emplace_back(inv_opt.value());
@@ -225,7 +225,7 @@ bool CQuorumBlockProcessor::ProcessBlock(const CBlock& block, gsl::not_null<cons
     }
     for (const auto& [_, qc] : qcs) {
         if (!ProcessCommitment(pindex->nHeight, blockHash, qc, state, fJustCheck)) {
-            LogPrintf("[ProcessBlock] failed h[%d] llmqType[%d] version[%d] quorumIndex[%d] quorumHash[%s]\n", pindex->nHeight, ToUnderlying(qc.llmqType), qc.nVersion, qc.quorumIndex, qc.quorumHash.ToString());
+            LogPrintf("[ProcessBlock] failed h[%d] llmqType[%d] version[%d] quorumIndex[%d] quorumHash[%s]\n", pindex->nHeight, std23::to_underlying(qc.llmqType), qc.nVersion, qc.quorumIndex, qc.quorumHash.ToString());
             return false;
         }
     }
@@ -271,7 +271,7 @@ bool CQuorumBlockProcessor::ProcessCommitment(int nHeight, const uint256& blockH
 
     const auto& llmq_params_opt = Params().GetLLMQ(qc.llmqType);
     if (!llmq_params_opt.has_value()) {
-        LogPrint(BCLog::LLMQ, "%s -- invalid commitment type %d\n", __func__, ToUnderlying(qc.llmqType));
+        LogPrint(BCLog::LLMQ, "%s -- invalid commitment type %d\n", __func__, std23::to_underlying(qc.llmqType));
         return false;
     }
     const auto& llmq_params = llmq_params_opt.value();
@@ -282,7 +282,7 @@ bool CQuorumBlockProcessor::ProcessCommitment(int nHeight, const uint256& blockH
              "%s -- processing commitment for block height=%d, type=%d, quorumIndex=%d, quorumHash=%s, signers=%s, "
              "validMembers=%d, quorumPublicKey=%s "
              "fJustCheck[%d] processing commitment from block.\n",
-             __func__, nHeight, ToUnderlying(qc.llmqType), qc.quorumIndex, quorumHash.ToString(), qc.CountSigners(),
+             __func__, nHeight, std23::to_underlying(qc.llmqType), qc.quorumIndex, quorumHash.ToString(), qc.CountSigners(),
              qc.CountValidMembers(), qc.quorumPublicKey.ToString(), fJustCheck);
 
     // skip `bad-qc-block` checks below when replaying blocks after the crash
@@ -294,7 +294,7 @@ bool CQuorumBlockProcessor::ProcessCommitment(int nHeight, const uint256& blockH
         LogPrint(BCLog::LLMQ, /* Continued */
                  "%s -- height=%d, type=%d, quorumIndex=%d, quorumHash=%s, signers=%s, validMembers=%d, "
                  "quorumPublicKey=%s quorumHash is null.\n",
-                 __func__, nHeight, ToUnderlying(qc.llmqType), qc.quorumIndex, quorumHash.ToString(), qc.CountSigners(),
+                 __func__, nHeight, std23::to_underlying(qc.llmqType), qc.quorumIndex, quorumHash.ToString(), qc.CountSigners(),
                  qc.CountValidMembers(), qc.quorumPublicKey.ToString());
         return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-qc-block");
     }
@@ -302,7 +302,7 @@ bool CQuorumBlockProcessor::ProcessCommitment(int nHeight, const uint256& blockH
         LogPrint(BCLog::LLMQ, /* Continued */
                  "%s -- height=%d, type=%d, quorumIndex=%d, quorumHash=%s, qc.quorumHash=%s signers=%s, "
                  "validMembers=%d, quorumPublicKey=%s non equal quorumHash.\n",
-                 __func__, nHeight, ToUnderlying(qc.llmqType), qc.quorumIndex, quorumHash.ToString(),
+                 __func__, nHeight, std23::to_underlying(qc.llmqType), qc.quorumIndex, quorumHash.ToString(),
                  qc.quorumHash.ToString(), qc.CountSigners(), qc.CountValidMembers(), qc.quorumPublicKey.ToString());
         return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-qc-block");
     }
@@ -312,7 +312,7 @@ bool CQuorumBlockProcessor::ProcessCommitment(int nHeight, const uint256& blockH
             LogPrint(BCLog::LLMQ, /* Continued */
                      "%s -- height=%d, type=%d, quorumIndex=%d, quorumHash=%s, signers=%s, validMembers=%dqc "
                      "verifynull failed.\n",
-                     __func__, nHeight, ToUnderlying(qc.llmqType), qc.quorumIndex, quorumHash.ToString(),
+                     __func__, nHeight, std23::to_underlying(qc.llmqType), qc.quorumIndex, quorumHash.ToString(),
                      qc.CountSigners(), qc.CountValidMembers());
             return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-qc-invalid-null");
         }
@@ -341,7 +341,7 @@ bool CQuorumBlockProcessor::ProcessCommitment(int nHeight, const uint256& blockH
         LogPrint(BCLog::LLMQ, /* Continued */
                  "%s -- height=%d, type=%d, quorumIndex=%d, quorumHash=%s, signers=%s, validMembers=%d, "
                  "quorumPublicKey=%s qc verify failed.\n",
-                 __func__, nHeight, ToUnderlying(qc.llmqType), qc.quorumIndex, quorumHash.ToString(), qc.CountSigners(),
+                 __func__, nHeight, std23::to_underlying(qc.llmqType), qc.quorumIndex, quorumHash.ToString(), qc.CountSigners(),
                  qc.CountValidMembers(), qc.quorumPublicKey.ToString());
         return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-qc-invalid");
     }
@@ -375,7 +375,7 @@ bool CQuorumBlockProcessor::ProcessCommitment(int nHeight, const uint256& blockH
     }
 
     LogPrint(BCLog::LLMQ, "%s -- processed commitment from block. type=%d, quorumIndex=%d, quorumHash=%s\n", __func__,
-             ToUnderlying(qc.llmqType), qc.quorumIndex, quorumHash.ToString());
+             std23::to_underlying(qc.llmqType), qc.quorumIndex, quorumHash.ToString());
 
     return true;
 }
@@ -492,7 +492,7 @@ uint256 CQuorumBlockProcessor::GetQuorumBlockHash(const Consensus::LLMQParams& l
 
     uint256 quorumBlockHash;
     if (!GetBlockHash(active_chain, quorumBlockHash, quorumStartHeight)) {
-        LogPrint(BCLog::LLMQ, "[GetQuorumBlockHash] llmqType[%d] h[%d] qi[%d] quorumStartHeight[%d] quorumHash[EMPTY]\n", ToUnderlying(llmqParams.type), nHeight, quorumIndex, quorumStartHeight);
+        LogPrint(BCLog::LLMQ, "[GetQuorumBlockHash] llmqType[%d] h[%d] qi[%d] quorumStartHeight[%d] quorumHash[EMPTY]\n", std23::to_underlying(llmqParams.type), nHeight, quorumIndex, quorumStartHeight);
         return {};
     }
 
diff --git a/src/llmq/commitment.cpp b/src/llmq/commitment.cpp
index 7ee08a9fbd5d..7bd0aa792fc3 100644
--- a/src/llmq/commitment.cpp
+++ b/src/llmq/commitment.cpp
@@ -6,15 +6,15 @@
 
 #include <evo/deterministicmns.h>
 #include <evo/specialtx.h>
+#include <llmq/options.h>
+#include <llmq/utils.h>
+#include <util/std23.h>
 
 #include <chainparams.h>
 #include <checkqueue.h>
 #include <consensus/validation.h>
 #include <deploymentstatus.h>
-#include <llmq/options.h>
-#include <llmq/utils.h>
 #include <logging.h>
-#include <util/underlying.h>
 #include <validation.h>
 
 namespace llmq
@@ -35,7 +35,7 @@ bool CFinalCommitment::VerifySignatureAsync(const llmq::UtilParameters& util_par
     const auto& llmq_params_opt = Params().GetLLMQ(llmqType);
     if (!llmq_params_opt.has_value()) {
         LogPrint(BCLog::LLMQ, "CFinalCommitment -- q[%s] invalid llmqType=%d\n", quorumHash.ToString(),
-                 ToUnderlying(llmqType));
+                 std23::to_underlying(llmqType));
         return false;
     }
     const auto& llmq_params = llmq_params_opt.value();
@@ -98,7 +98,7 @@ bool CFinalCommitment::Verify(const llmq::UtilParameters& util_params, bool chec
 {
     const auto& llmq_params_opt = Params().GetLLMQ(llmqType);
     if (!llmq_params_opt.has_value()) {
-        LogPrint(BCLog::LLMQ, "CFinalCommitment -- q[%s] invalid llmqType=%d\n", quorumHash.ToString(), ToUnderlying(llmqType));
+        LogPrint(BCLog::LLMQ, "CFinalCommitment -- q[%s] invalid llmqType=%d\n", quorumHash.ToString(), std23::to_underlying(llmqType));
         return false;
     }
     const auto& llmq_params = llmq_params_opt.value();
@@ -188,7 +188,7 @@ bool CFinalCommitment::VerifyNull() const
 {
     const auto& llmq_params_opt = Params().GetLLMQ(llmqType);
     if (!llmq_params_opt.has_value()) {
-        LogPrint(BCLog::LLMQ, "CFinalCommitment -- q[%s]invalid llmqType=%d\n", quorumHash.ToString(), ToUnderlying(llmqType));
+        LogPrint(BCLog::LLMQ, "CFinalCommitment -- q[%s]invalid llmqType=%d\n", quorumHash.ToString(), std23::to_underlying(llmqType));
         return false;
     }
 
@@ -226,7 +226,7 @@ bool CheckLLMQCommitment(const llmq::UtilParameters& util_params, const CTransac
     const auto& llmq_params_opt = Params().GetLLMQ(qcTx.commitment.llmqType);
     if (!llmq_params_opt.has_value()) {
         LogPrint(BCLog::LLMQ, "CFinalCommitment -- h[%d] GetLLMQ failed for llmqType[%d]\n",
-                 util_params.m_base_index->nHeight, ToUnderlying(qcTx.commitment.llmqType));
+                 util_params.m_base_index->nHeight, std23::to_underlying(qcTx.commitment.llmqType));
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-qc-commitment-type");
     }
 
diff --git a/src/llmq/commitment.h b/src/llmq/commitment.h
index 3a8337b62746..92df37fd56c9 100644
--- a/src/llmq/commitment.h
+++ b/src/llmq/commitment.h
@@ -5,14 +5,14 @@
 #ifndef BITCOIN_LLMQ_COMMITMENT_H
 #define BITCOIN_LLMQ_COMMITMENT_H
 
-#include <primitives/transaction.h>
-#include <util/irange.h>
-#include <util/strencodings.h>
-#include <util/underlying.h>
-
 #include <bls/bls.h>
 #include <llmq/params.h>
 #include <llmq/types.h>
+#include <util/irange.h>
+#include <util/std23.h>
+
+#include <primitives/transaction.h>
+#include <util/strencodings.h>
 
 #include <gsl/pointers.h>
 #include <univalue.h>
diff --git a/src/llmq/core_write.cpp b/src/llmq/core_write.cpp
index 89add66af10b..44db0a27e5be 100644
--- a/src/llmq/core_write.cpp
+++ b/src/llmq/core_write.cpp
@@ -117,7 +117,7 @@ UniValue CFinalCommitment::ToJson() const
 {
     UniValue obj(UniValue::VOBJ);
     obj.pushKV("version", nVersion);
-    obj.pushKV("llmqType", ToUnderlying(llmqType));
+    obj.pushKV("llmqType", std23::to_underlying(llmqType));
     obj.pushKV("quorumHash", quorumHash.ToString());
     obj.pushKV("quorumIndex", quorumIndex);
     obj.pushKV("signersCount", CountSigners());
@@ -242,7 +242,7 @@ UniValue CQuorumSnapshot::ToJson() const
         activeQ.push_back(h);
     }
     obj.pushKV("activeQuorumMembers", activeQ);
-    obj.pushKV("mnSkipListMode", ToUnderlying(mnSkipListMode));
+    obj.pushKV("mnSkipListMode", std23::to_underlying(mnSkipListMode));
     UniValue skipList(UniValue::VARR);
     for (const auto& h : mnSkipList) {
         // cppcheck-suppress useStlAlgorithm
@@ -268,7 +268,7 @@ RPCResult CRecoveredSig::GetJsonHelp(const std::string& key, bool optional)
 UniValue CRecoveredSig::ToJson() const
 {
     UniValue ret(UniValue::VOBJ);
-    ret.pushKV("llmqType", ToUnderlying(llmqType));
+    ret.pushKV("llmqType", std23::to_underlying(llmqType));
     ret.pushKV("quorumHash", quorumHash.ToString());
     ret.pushKV("id", id.ToString());
     ret.pushKV("msgHash", msgHash.ToString());
diff --git a/src/llmq/debug.cpp b/src/llmq/debug.cpp
index 5d48d36682d4..93a0a8d7c986 100644
--- a/src/llmq/debug.cpp
+++ b/src/llmq/debug.cpp
@@ -4,14 +4,14 @@
 
 #include <llmq/debug.h>
 
-#include <chainparams.h>
-#include <timedata.h>
-#include <validation.h>
-
 #include <evo/deterministicmns.h>
 #include <llmq/utils.h>
 #include <util/irange.h>
-#include <util/underlying.h>
+#include <util/std23.h>
+
+#include <chainparams.h>
+#include <timedata.h>
+#include <validation.h>
 
 namespace llmq
 {
@@ -32,10 +32,10 @@ UniValue CDKGDebugSessionStatus::ToJson(CDeterministicMNManager& dmnman, CQuorum
         }
     }
 
-    ret.pushKV("llmqType", ToUnderlying(llmqType));
+    ret.pushKV("llmqType", std23::to_underlying(llmqType));
     ret.pushKV("quorumHash", quorumHash.ToString());
     ret.pushKV("quorumHeight", quorumHeight);
-    ret.pushKV("phase", ToUnderlying(phase));
+    ret.pushKV("phase", std23::to_underlying(phase));
 
     ret.pushKV("sentContributions", statusBits.sentContributions);
     ret.pushKV("sentComplaint", statusBits.sentComplaint);
diff --git a/src/llmq/dkgsession.cpp b/src/llmq/dkgsession.cpp
index fba7e8b38d39..f2d86acbfab9 100644
--- a/src/llmq/dkgsession.cpp
+++ b/src/llmq/dkgsession.cpp
@@ -13,11 +13,11 @@
 #include <llmq/utils.h>
 #include <masternode/meta.h>
 #include <util/irange.h>
+#include <util/std23.h>
 
 #include <chainparams.h>
 #include <deploymentstatus.h>
 #include <logging.h>
-#include <util/underlying.h>
 #include <validation.h>
 
 #include <cxxtimer.hpp>
@@ -35,18 +35,18 @@ CDKGLogger::CDKGLogger(const CDKGSession& _quorumDkg, std::string_view _func, in
 {
 }
 
-static std::array<std::atomic<double>, ToUnderlying(DKGError::type::_COUNT)> simDkgErrorMap{};
+static std::array<std::atomic<double>, std23::to_underlying(DKGError::type::_COUNT)> simDkgErrorMap{};
 
 void SetSimulatedDKGErrorRate(DKGError::type type, double rate)
 {
     if (type >= DKGError::type::_COUNT) return;
-    simDkgErrorMap[ToUnderlying(type)] = rate;
+    simDkgErrorMap[std23::to_underlying(type)] = rate;
 }
 
 double GetSimulatedErrorRate(DKGError::type type)
 {
-    if (ToUnderlying(type) >= DKGError::type::_COUNT) return 0;
-    return simDkgErrorMap[ToUnderlying(type)];
+    if (std23::to_underlying(type) >= DKGError::type::_COUNT) return 0;
+    return simDkgErrorMap[std23::to_underlying(type)];
 }
 
 bool CDKGSession::ShouldSimulateError(DKGError::type type) const
diff --git a/src/llmq/dkgsession.h b/src/llmq/dkgsession.h
index 16b2e1416653..aad735618ec7 100644
--- a/src/llmq/dkgsession.h
+++ b/src/llmq/dkgsession.h
@@ -12,10 +12,10 @@
 #include <bls/bls_ies.h>
 #include <bls/bls_worker.h>
 #include <evo/types.h>
+#include <util/std23.h>
 
 #include <saltedhasher.h>
 #include <sync.h>
-#include <util/underlying.h>
 
 #include <optional>
 #include <unordered_set>
@@ -53,7 +53,7 @@ class CDKGContribution
     template<typename Stream>
     inline void SerializeWithoutSig(Stream& s) const
     {
-        s << ToUnderlying(llmqType);
+        s << std23::to_underlying(llmqType);
         s << quorumHash;
         s << proTxHash;
         s << *vvec;
diff --git a/src/llmq/dkgsessionmgr.cpp b/src/llmq/dkgsessionmgr.cpp
index 0c9a74f0570b..6bae171b84ed 100644
--- a/src/llmq/dkgsessionmgr.cpp
+++ b/src/llmq/dkgsessionmgr.cpp
@@ -3,19 +3,20 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <llmq/dkgsessionmgr.h>
+
+#include <bls/bls_ies.h>
+#include <evo/deterministicmns.h>
 #include <llmq/options.h>
 #include <llmq/params.h>
 #include <llmq/utils.h>
+#include <spork.h>
+#include <unordered_lru_cache.h>
+#include <util/irange.h>
+#include <util/std23.h>
 
-#include <bls/bls_ies.h>
 #include <chainparams.h>
 #include <dbwrapper.h>
 #include <deploymentstatus.h>
-#include <evo/deterministicmns.h>
-#include <spork.h>
-#include <unordered_lru_cache.h>
-#include <util/irange.h>
-#include <util/underlying.h>
 #include <validation.h>
 
 static bool IsQuorumDKGEnabled(const CSporkManager& sporkman)
@@ -117,7 +118,7 @@ MessageProcessingResult CDKGSessionManager::ProcessMessage(CNode& pfrom, bool is
 
     const auto& llmq_params_opt = Params().GetLLMQ(llmqType);
     if (!llmq_params_opt.has_value()) {
-        LogPrintf("CDKGSessionManager -- invalid llmqType [%d]\n", ToUnderlying(llmqType));
+        LogPrintf("CDKGSessionManager -- invalid llmqType [%d]\n", std23::to_underlying(llmqType));
         return MisbehavingError{100};
     }
     const auto& llmq_params = llmq_params_opt.value();
@@ -144,7 +145,7 @@ MessageProcessingResult CDKGSessionManager::ProcessMessage(CNode& pfrom, bool is
         }
 
         if (!m_chainman.IsQuorumTypeEnabled(llmqType, pQuorumBaseBlockIndex->pprev)) {
-            LogPrintf("CDKGSessionManager -- llmqType [%d] quorums aren't active\n", ToUnderlying(llmqType));
+            LogPrintf("CDKGSessionManager -- llmqType [%d] quorums aren't active\n", std23::to_underlying(llmqType));
             return MisbehavingError{100};
         }
 
@@ -294,7 +295,7 @@ bool CDKGSessionManager::GetVerifiedContributions(Consensus::LLMQType llmqType,
                 CDataStream s(SER_DISK, CLIENT_VERSION);
                 if (!db->ReadDataStream(std::make_tuple(DB_VVEC, llmqType, pQuorumBaseBlockIndex->GetBlockHash(), proTxHash), s)) {
                     LogPrint(BCLog::LLMQ, "%s -- this node does not have vvec for llmq=%d block=%s protx=%s\n",
-                             __func__, ToUnderlying(llmqType), pQuorumBaseBlockIndex->GetBlockHash().ToString(),
+                             __func__, std23::to_underlying(llmqType), pQuorumBaseBlockIndex->GetBlockHash().ToString(),
                              proTxHash.ToString());
                     return false;
                 }
@@ -376,7 +377,7 @@ void CDKGSessionManager::CleanupOldContributions() const
     const auto prefixes = {DB_VVEC, DB_SKCONTRIB, DB_ENC_CONTRIB};
 
     for (const auto& params : Params().GetConsensus().llmqs) {
-        LogPrint(BCLog::LLMQ, "CDKGSessionManager::%s -- looking for old entries for llmq type %d\n", __func__, ToUnderlying(params.type));
+        LogPrint(BCLog::LLMQ, "CDKGSessionManager::%s -- looking for old entries for llmq type %d\n", __func__, std23::to_underlying(params.type));
 
         CDBBatch batch(*db);
         size_t cnt_old{0}, cnt_all{0};
diff --git a/src/llmq/observer/quorums.cpp b/src/llmq/observer/quorums.cpp
index cd37b14f86d9..a9baad814f59 100644
--- a/src/llmq/observer/quorums.cpp
+++ b/src/llmq/observer/quorums.cpp
@@ -93,12 +93,12 @@ Uint256HashSet QuorumObserver::GetQuorumsToDelete(const Consensus::LLMQParams& l
                 connmanQuorumsToDelete.erase(curDkgBlock);
             }
         }
-        LogPrint(BCLog::LLMQ, "QuorumObserver::%s -- llmqType[%d] h[%d] keeping mn quorum connections for rotated quorums: [%s]\n", __func__, ToUnderlying(llmqParams.type), pindexNew->nHeight, ss.str());
+        LogPrint(BCLog::LLMQ, "QuorumObserver::%s -- llmqType[%d] h[%d] keeping mn quorum connections for rotated quorums: [%s]\n", __func__, std23::to_underlying(llmqParams.type), pindexNew->nHeight, ss.str());
     } else {
         int curDkgHeight = pindexNew->nHeight - (pindexNew->nHeight % llmqParams.dkgInterval);
         auto curDkgBlock = pindexNew->GetAncestor(curDkgHeight)->GetBlockHash();
         connmanQuorumsToDelete.erase(curDkgBlock);
-        LogPrint(BCLog::LLMQ, "QuorumObserver::%s -- llmqType[%d] h[%d] keeping mn quorum connections for quorum: [%d:%s]\n", __func__, ToUnderlying(llmqParams.type), pindexNew->nHeight, curDkgHeight, curDkgBlock.ToString());
+        LogPrint(BCLog::LLMQ, "QuorumObserver::%s -- llmqType[%d] h[%d] keeping mn quorum connections for quorum: [%d:%s]\n", __func__, std23::to_underlying(llmqParams.type), pindexNew->nHeight, curDkgHeight, curDkgBlock.ToString());
     }
 
     return connmanQuorumsToDelete;
@@ -114,7 +114,7 @@ void QuorumObserver::CheckQuorumConnections(const Consensus::LLMQParams& llmqPar
         if (utils::EnsureQuorumConnections(llmqParams, m_connman, m_sporkman, {m_dmnman, m_qsnapman, m_chainman, quorum->m_quorum_base_block_index},
                                            m_dmnman.GetListAtChainTip(), /*myProTxHash=*/uint256{}, /*is_masternode=*/false, /*quorums_watch=*/true)) {
             if (deletableQuorums.erase(quorum->qc->quorumHash) > 0) {
-                LogPrint(BCLog::LLMQ, "QuorumObserver::%s -- llmqType[%d] h[%d] keeping mn quorum connections for quorum: [%d:%s]\n", __func__, ToUnderlying(llmqParams.type), pindexNew->nHeight, quorum->m_quorum_base_block_index->nHeight, quorum->m_quorum_base_block_index->GetBlockHash().ToString());
+                LogPrint(BCLog::LLMQ, "QuorumObserver::%s -- llmqType[%d] h[%d] keeping mn quorum connections for quorum: [%d:%s]\n", __func__, std23::to_underlying(llmqParams.type), pindexNew->nHeight, quorum->m_quorum_base_block_index->nHeight, quorum->m_quorum_base_block_index->GetBlockHash().ToString());
             }
         }
     }
@@ -175,7 +175,7 @@ void QuorumObserver::DataRecoveryThread(gsl::not_null<const CBlockIndex*> block_
         auto printLog = [&](const std::string& strMessage) {
             const std::string strMember{pCurrentMemberHash == nullptr ? "nullptr" : pCurrentMemberHash->ToString()};
             LogPrint(BCLog::LLMQ, "QuorumObserver::DataRecoveryThread -- %s - for llmqType %d, quorumHash %s, nDataMask (%d/%d), pCurrentMemberHash %s, nTries %d\n",
-                strMessage, ToUnderlying(pQuorum->qc->llmqType), pQuorum->qc->quorumHash.ToString(), nDataMask, data_mask, strMember, nTries);
+                strMessage, std23::to_underlying(pQuorum->qc->llmqType), pQuorum->qc->quorumHash.ToString(), nDataMask, data_mask, strMember, nTries);
         };
         printLog("Start");
 
@@ -312,7 +312,7 @@ void QuorumObserver::TryStartVvecSyncThread(gsl::not_null<const CBlockIndex*> bl
         StartVvecSyncThread(block_index, std::move(pQuorum));
     } else {
         LogPrint(BCLog::LLMQ, "QuorumObserver::%s -- No data needed from (%d, %s) at height %d\n", __func__,
-                 ToUnderlying(pQuorum->qc->llmqType), pQuorum->qc->quorumHash.ToString(), block_index->nHeight);
+                 std23::to_underlying(pQuorum->qc->llmqType), pQuorum->qc->quorumHash.ToString(), block_index->nHeight);
     }
 }
 
diff --git a/src/llmq/options.cpp b/src/llmq/options.cpp
index 30d6f77b148f..d7a74bf5a3b4 100644
--- a/src/llmq/options.cpp
+++ b/src/llmq/options.cpp
@@ -5,13 +5,13 @@
 #include <llmq/options.h>
 
 #include <spork.h>
+#include <util/ranges.h>
+#include <util/std23.h>
 
 #include <chainparams.h>
 #include <consensus/params.h>
 #include <deploymentstatus.h>
-#include <util/ranges.h>
 #include <util/system.h>
-#include <util/underlying.h>
 #include <validation.h>
 
 #include <string>
diff --git a/src/llmq/quorumsman.cpp b/src/llmq/quorumsman.cpp
index ffcb90878fbf..ca376ef2512b 100644
--- a/src/llmq/quorumsman.cpp
+++ b/src/llmq/quorumsman.cpp
@@ -16,6 +16,7 @@
 #include <llmq/signhash.h>
 #include <llmq/utils.h>
 #include <util/irange.h>
+#include <util/std23.h>
 
 #include <chainparams.h>
 #include <dbwrapper.h>
@@ -23,7 +24,6 @@
 #include <netmessagemaker.h>
 #include <util/thread.h>
 #include <util/time.h>
-#include <util/underlying.h>
 #include <validation.h>
 
 #include <cxxtimer.hpp>
@@ -69,7 +69,7 @@ CQuorumPtr CQuorumManager::BuildQuorumFromCommitment(const Consensus::LLMQType l
 
     auto [qc, minedBlockHash] = quorumBlockProcessor.GetMinedCommitment(llmqType, quorumHash);
     if (minedBlockHash == uint256::ZERO) {
-        LogPrint(BCLog::LLMQ, "CQuorumManager::%s -- No mined commitment for llmqType[%d] nHeight[%d] quorumHash[%s]\n", __func__, ToUnderlying(llmqType), pQuorumBaseBlockIndex->nHeight, pQuorumBaseBlockIndex->GetBlockHash().ToString());
+        LogPrint(BCLog::LLMQ, "CQuorumManager::%s -- No mined commitment for llmqType[%d] nHeight[%d] quorumHash[%s]\n", __func__, std23::to_underlying(llmqType), pQuorumBaseBlockIndex->nHeight, pQuorumBaseBlockIndex->GetBlockHash().ToString());
         return nullptr;
     }
     assert(qc.quorumHash == pQuorumBaseBlockIndex->GetBlockHash());
@@ -95,7 +95,7 @@ CQuorumPtr CQuorumManager::BuildQuorumFromCommitment(const Consensus::LLMQType l
             WITH_LOCK(cs_db, quorum->WriteContributions(*db));
             hasValidVvec = true;
         } else {
-            LogPrint(BCLog::LLMQ, "CQuorumManager::%s -- llmqType[%d] quorumIndex[%d] quorum.ReadContributions and BuildQuorumContributions for quorumHash[%s] failed\n", __func__, ToUnderlying(llmqType), quorum->qc->quorumIndex, quorum->qc->quorumHash.ToString());
+            LogPrint(BCLog::LLMQ, "CQuorumManager::%s -- llmqType[%d] quorumIndex[%d] quorum.ReadContributions and BuildQuorumContributions for quorumHash[%s] failed\n", __func__, std23::to_underlying(llmqType), quorum->qc->quorumIndex, quorum->qc->quorumHash.ToString());
         }
     }
 
@@ -160,7 +160,7 @@ bool CQuorumManager::RequestQuorumData(CNode* pfrom, CConnman& connman, const CQ
     }
     const Consensus::LLMQType llmqType = quorum.qc->llmqType;
     if (!Params().GetLLMQ(llmqType).has_value()) {
-        LogPrint(BCLog::LLMQ, "CQuorumManager::%s -- Invalid llmqType: %d\n", __func__, ToUnderlying(llmqType));
+        LogPrint(BCLog::LLMQ, "CQuorumManager::%s -- Invalid llmqType: %d\n", __func__, std23::to_underlying(llmqType));
         return false;
     }
     const CBlockIndex* pindex{quorum.m_quorum_base_block_index};
@@ -182,7 +182,7 @@ bool CQuorumManager::RequestQuorumData(CNode* pfrom, CConnman& connman, const CQ
         }
     }
     LogPrint(BCLog::LLMQ, "CQuorumManager::%s -- sending QGETDATA quorumHash[%s] llmqType[%d] proRegTx[%s]\n", __func__, key.quorumHash.ToString(),
-             ToUnderlying(key.llmqType), key.proRegTx.ToString());
+             std23::to_underlying(key.llmqType), key.proRegTx.ToString());
 
     CNetMsgMaker msgMaker(pfrom->GetCommonVersion());
     connman.PushMessage(pfrom, msgMaker.Make(NetMsgType::QGETDATA, request));
@@ -284,7 +284,7 @@ std::vector<CQuorumCPtr> CQuorumManager::ScanQuorums(Consensus::LLMQType llmqTyp
         auto quorum = GetQuorum(llmqType, pQuorumBaseBlockIndex, populate_cache);
         if (!quorum) {
             LogPrintf("%s: ERROR! Unexpected missing quorum with llmqType=%d, blockHash=%s, populate_cache=%s\n",
-                      __func__, ToUnderlying(llmqType), pQuorumBaseBlockIndex->GetBlockHash().ToString(),
+                      __func__, std23::to_underlying(llmqType), pQuorumBaseBlockIndex->GetBlockHash().ToString(),
                       populate_cache ? "true" : "false");
             return {};
         }
@@ -583,7 +583,7 @@ void CQuorumManager::CacheWarmingThreadMain() const
 
         cxxtimer::Timer t(true);
         LogPrint(BCLog::LLMQ, "CQuorumManager::%s -- type=%d height=%d hash=%s start\n", __func__,
-                 ToUnderlying(pQuorum->params.type), pQuorum->m_quorum_base_block_index->nHeight,
+                 std23::to_underlying(pQuorum->params.type), pQuorum->m_quorum_base_block_index->nHeight,
                  pQuorum->m_quorum_base_block_index->GetBlockHash().ToString());
 
         // when then later some other thread tries to get keys, it will be much faster
@@ -597,7 +597,7 @@ void CQuorumManager::CacheWarmingThreadMain() const
         }
 
         LogPrint(BCLog::LLMQ, "CQuorumManager::%s -- type=%d height=%d hash=%s done. time=%d\n", __func__,
-                 ToUnderlying(pQuorum->params.type), pQuorum->m_quorum_base_block_index->nHeight,
+                 std23::to_underlying(pQuorum->params.type), pQuorum->m_quorum_base_block_index->nHeight,
                  pQuorum->m_quorum_base_block_index->GetBlockHash().ToString(), t.count());
     }
 }
diff --git a/src/llmq/signing_shares.cpp b/src/llmq/signing_shares.cpp
index 5892b6e51bc5..5ca4a4bfe3ac 100644
--- a/src/llmq/signing_shares.cpp
+++ b/src/llmq/signing_shares.cpp
@@ -14,7 +14,7 @@
 #include <llmq/signing.h>
 #include <spork.h>
 #include <util/irange.h>
-#include <util/underlying.h>
+#include <util/std23.h>
 
 #include <chainparams.h>
 #include <net_processing.h>
@@ -36,7 +36,7 @@ void CSigShare::UpdateKey()
 std::string CSigSesAnn::ToString() const
 {
     return strprintf("sessionId=%d, llmqType=%d, quorumHash=%s, id=%s, msgHash=%s",
-                     sessionId, ToUnderlying(getLlmqType()), getQuorumHash().ToString(), getId().ToString(), getMsgHash().ToString());
+                     sessionId, std23::to_underlying(getLlmqType()), getQuorumHash().ToString(), getId().ToString(), getMsgHash().ToString());
 }
 
 void CSigSharesInv::Merge(const CSigSharesInv& inv2)
@@ -662,7 +662,7 @@ bool CSigSharesManager::CollectPendingSigSharesToVerify(
             // nothing instead of reporting flawed data.
             if (!quorum) {
                 LogPrintf("%s: ERROR! Unexpected missing quorum with llmqType=%d, quorumHash=%s\n", __func__,
-                          ToUnderlying(llmqType), sigShare.getQuorumHash().ToString());
+                          std23::to_underlying(llmqType), sigShare.getQuorumHash().ToString());
                 return false;
             }
             retQuorums.try_emplace(k, quorum);
@@ -1762,7 +1762,7 @@ std::optional<CSigShare> CSigSharesManager::CreateSigShareForSingleMember(const
              "CSigSharesManager::%s -- created sigShare. signHash=%s, id=%s, msgHash=%s, llmqType=%d, quorum=%s, "
              "time=%s\n",
              __func__, signHash.ToString(), sigShare.getId().ToString(), sigShare.getMsgHash().ToString(),
-             ToUnderlying(quorum.params.type), quorum.qc->quorumHash.ToString(), t.count());
+             std23::to_underlying(quorum.params.type), quorum.qc->quorumHash.ToString(), t.count());
 
     return sigShare;
 }
@@ -1805,7 +1805,7 @@ std::optional<CSigShare> CSigSharesManager::CreateSigShare(const CQuorum& quorum
     sigShare.UpdateKey();
 
     LogPrint(BCLog::LLMQ_SIGS, "CSigSharesManager::%s -- created sigShare. signHash=%s, id=%s, msgHash=%s, llmqType=%d, quorum=%s, time=%s\n", __func__,
-              signHash.ToString(), sigShare.getId().ToString(), sigShare.getMsgHash().ToString(), ToUnderlying(quorum.params.type), quorum.qc->quorumHash.ToString(), t.count());
+              signHash.ToString(), sigShare.getId().ToString(), sigShare.getMsgHash().ToString(), std23::to_underlying(quorum.params.type), quorum.qc->quorumHash.ToString(), t.count());
 
     return sigShare;
 }
diff --git a/src/llmq/utils.cpp b/src/llmq/utils.cpp
index 71720b6a3ba1..ebb8165acbc0 100644
--- a/src/llmq/utils.cpp
+++ b/src/llmq/utils.cpp
@@ -17,8 +17,8 @@
 #include <deploymentstatus.h>
 #include <net.h>
 #include <random.h>
+#include <util/std23.h>
 #include <util/time.h>
-#include <util/underlying.h>
 #include <validation.h>
 
 #include <atomic>
@@ -468,7 +468,7 @@ std::vector<QuorumMembers> ComputeQuorumMembersByQuarterRotation(const Consensus
                                                                                llmq::WORK_DIFF_DEPTH);
     CDeterministicMNList allMns = util_params.m_dmnman.GetListForBlock(pWorkBlockIndex);
     LogPrint(BCLog::LLMQ, "ComputeQuorumMembersByQuarterRotation llmqType[%d] nHeight[%d] allMns[%d]\n",
-             ToUnderlying(llmqParams.type), util_params.m_base_index->nHeight, allMns.GetValidMNsCount());
+             std23::to_underlying(llmqParams.type), util_params.m_base_index->nHeight, allMns.GetValidMNsCount());
 
     PreviousQuorumQuarters previousQuarters(nQuorums);
     auto prev_cycles{previousQuarters.GetCycles()};
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index e5b83dc0f88f..ad1737ffb10f 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -34,10 +34,10 @@
 #include <txmempool.h>
 #include <txorphanage.h>
 #include <util/check.h>
+#include <util/std23.h>
 #include <util/strencodings.h>
 #include <util/system.h>
 #include <util/trace.h>
-#include <util/underlying.h>
 #include <validation.h>
 
 #include <active/context.h>
@@ -3670,7 +3670,7 @@ MessageProcessingResult PeerManagerImpl::ProcessPlatformBanMessage(NodeId node,
     Consensus::LLMQType llmq_type = Params().GetConsensus().llmqTypePlatform;
     auto quorum = m_llmq_ctx->qman->GetQuorum(llmq_type, ban_msg.m_quorum_hash);
     if (!quorum) {
-        LogPrintf("PLATFORMBAN -- hash: %s protx_hash: %s missing quorum_hash: %s llmq_type: %d\n", hash.ToString(), ban_msg.m_protx_hash.ToString(), ban_msg.m_quorum_hash.ToString(), ToUnderlying(llmq_type));
+        LogPrintf("PLATFORMBAN -- hash: %s protx_hash: %s missing quorum_hash: %s llmq_type: %d\n", hash.ToString(), ban_msg.m_protx_hash.ToString(), ban_msg.m_quorum_hash.ToString(), std23::to_underlying(llmq_type));
         ret.m_error = MisbehavingError{100};
         return ret;
     }
diff --git a/src/qt/optionsdialog.cpp b/src/qt/optionsdialog.cpp
index 034ae4f908ef..27f8ce62a25b 100644
--- a/src/qt/optionsdialog.cpp
+++ b/src/qt/optionsdialog.cpp
@@ -25,7 +25,7 @@
 #include <txdb.h> // for -dbcache defaults
 #include <util/strencodings.h>
 #include <util/system.h>
-#include <util/underlying.h>
+#include <util/std23.h>
 
 #include <chrono>
 
@@ -318,7 +318,7 @@ void OptionsDialog::setModel(OptionsModel *_model)
 
 void OptionsDialog::setCurrentTab(OptionsDialog::Tab tab)
 {
-    showPage(ToUnderlying(tab));
+    showPage(std23::to_underlying(tab));
 }
 
 void OptionsDialog::setMapper()
diff --git a/src/qt/rpcconsole.cpp b/src/qt/rpcconsole.cpp
index 7f8d46c0f9ad..ab501efa86ac 100644
--- a/src/qt/rpcconsole.cpp
+++ b/src/qt/rpcconsole.cpp
@@ -28,7 +28,7 @@
 #include <util/string.h>
 #include <util/system.h>
 #include <util/threadnames.h>
-#include <util/underlying.h>
+#include <util/std23.h>
 
 #include <univalue.h>
 
@@ -608,7 +608,7 @@ RPCConsole::RPCConsole(interfaces::Node& node, QWidget* parent, Qt::WindowFlags
     connect(pageButtons, QOverload<int>::of(&QButtonGroup::buttonClicked), this, &RPCConsole::showPage);
 #endif
 
-    showPage(ToUnderlying(TabTypes::INFO));
+    showPage(std23::to_underlying(TabTypes::INFO));
 
     reloadThemedWidgets();
 
@@ -1569,12 +1569,12 @@ void RPCConsole::showOrHideBanTableIfRequired()
 
 void RPCConsole::setTabFocus(enum TabTypes tabType)
 {
-    showPage(ToUnderlying(tabType));
+    showPage(std23::to_underlying(tabType));
 }
 
 QString RPCConsole::tabTitle(TabTypes tab_type) const
 {
-    return pageButtons->button(ToUnderlying(tab_type))->text();
+    return pageButtons->button(std23::to_underlying(tab_type))->text();
 }
 
 QKeySequence RPCConsole::tabShortcut(TabTypes tab_type) const
diff --git a/src/spentindex.h b/src/spentindex.h
index 5382a2b096d5..bc289173bb73 100644
--- a/src/spentindex.h
+++ b/src/spentindex.h
@@ -136,7 +136,7 @@ struct CAddressUnspentKey {
 
     template<typename Stream>
     void Serialize(Stream& s) const {
-        ser_writedata8(s, ToUnderlying(m_address_type));
+        ser_writedata8(s, std23::to_underlying(m_address_type));
         m_address_bytes.Serialize(s);
         m_tx_hash.Serialize(s);
         ser_writedata32(s, m_tx_index);
diff --git a/src/test/llmq_dkg_tests.cpp b/src/test/llmq_dkg_tests.cpp
index 9e57d63354d5..ee136df34f0e 100644
--- a/src/test/llmq_dkg_tests.cpp
+++ b/src/test/llmq_dkg_tests.cpp
@@ -4,7 +4,7 @@
 
 #include <llmq/dkgsession.h>
 #include <util/irange.h>
-#include <util/underlying.h>
+#include <util/std23.h>
 
 #include <boost/test/unit_test.hpp>
 
@@ -13,7 +13,7 @@ BOOST_AUTO_TEST_SUITE(llmq_dkg_tests)
 BOOST_AUTO_TEST_CASE(llmq_dkgerror)
 {
     using namespace llmq;
-    for (auto i : irange::range(ToUnderlying(llmq::DKGError::type::_COUNT))) {
+    for (auto i : irange::range(std23::to_underlying(llmq::DKGError::type::_COUNT))) {
         BOOST_REQUIRE(GetSimulatedErrorRate(llmq::DKGError::type(i)) == 0.0);
         SetSimulatedDKGErrorRate(llmq::DKGError::type(i), 1.0);
         BOOST_REQUIRE(GetSimulatedErrorRate(llmq::DKGError::type(i)) == 1.0);
diff --git a/src/util/std23.h b/src/util/std23.h
new file mode 100644
index 000000000000..ab23ef346935
--- /dev/null
+++ b/src/util/std23.h
@@ -0,0 +1,28 @@
+// Copyright (c) 2023 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_UTIL_STD23_H
+#define BITCOIN_UTIL_STD23_H
+
+#include <type_traits>
+#include <utility>
+
+namespace std23 {
+#if __cplusplus >= 202302L
+using std::to_underlying;
+#else
+/**
+ * @tparam E enumeration type, automatically deduced
+ * @param e the enumerated value to convert
+ * @return the underlying value in base type
+ */
+template <typename E>
+[[nodiscard]] inline constexpr std::underlying_type_t<E> to_underlying(E e) noexcept
+{
+    return static_cast<std::underlying_type_t<E>>(e);
+}
+#endif // __cplusplus >= 202302L
+} // namespace std23
+
+#endif // BITCOIN_UTIL_STD23_H
diff --git a/src/util/underlying.h b/src/util/underlying.h
deleted file mode 100644
index 55821bb742a8..000000000000
--- a/src/util/underlying.h
+++ /dev/null
@@ -1,14 +0,0 @@
-// Copyright (c) 2023 The Dash Core developers
-// Distributed under the MIT software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#ifndef BITCOIN_UTIL_UNDERLYING_H
-#define BITCOIN_UTIL_UNDERLYING_H
-#include <type_traits>
-
-template <typename E>
-[[nodiscard]] inline constexpr typename std::underlying_type<E>::type ToUnderlying(E e) noexcept {
-    return static_cast<typename std::underlying_type<E>::type>(e);
-}
-
-#endif // BITCOIN_UTIL_UNDERLYING_H
diff --git a/src/validation.cpp b/src/validation.cpp
index 95629b462cf1..70371ede114e 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -6059,7 +6059,7 @@ bool ChainstateManager::IsQuorumTypeEnabled(const Consensus::LLMQType llmqType,
         return pindexPrev->nHeight >= TESTNET_LLMQ_25_67_ACTIVATION_HEIGHT;
 
     default:
-        throw std::runtime_error(strprintf("%s: Unknown LLMQ type %d", __func__, ToUnderlying(llmqType)));
+        throw std::runtime_error(strprintf("%s: Unknown LLMQ type %d", __func__, std23::to_underlying(llmqType)));
     }
 
     // Something wrong with conditions above, they are not consistent
diff --git a/src/zmq/zmqpublishnotifier.cpp b/src/zmq/zmqpublishnotifier.cpp
index 83d43e474212..d174457dcdd3 100644
--- a/src/zmq/zmqpublishnotifier.cpp
+++ b/src/zmq/zmqpublishnotifier.cpp
@@ -464,7 +464,7 @@ bool CZMQPublishRawGovernanceVoteNotifier::NotifyGovernanceVote(const std::share
 bool CZMQPublishRawGovernanceObjectNotifier::NotifyGovernanceObject(const std::shared_ptr<const Governance::Object>& govobj)
 {
     uint256 nHash = govobj->GetHash();
-    LogPrint(BCLog::ZMQ, "Publish rawgovernanceobject %s with type %d to %s\n", nHash.ToString(), ToUnderlying(govobj->type), this->address);
+    LogPrint(BCLog::ZMQ, "Publish rawgovernanceobject %s with type %d to %s\n", nHash.ToString(), std23::to_underlying(govobj->type), this->address);
     CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
     ss << *govobj;
     return SendZmqMessage(MSG_RAWGOBJ, &(*ss.begin()), ss.size());
diff --git a/test/util/data/non-backported.txt b/test/util/data/non-backported.txt
index a33f92fa6a74..4c56e4b7d8e8 100644
--- a/test/util/data/non-backported.txt
+++ b/test/util/data/non-backported.txt
@@ -59,6 +59,7 @@ src/util/irange.h
 src/util/pointer.h
 src/util/ranges.h
 src/util/ranges_set.*
+src/util/std23.h
 src/util/wpipe.*
 src/wallet/bip39*
 src/wallet/coinjoin.*

From 1e1f91d4dac0d561be2b02350f942e3e1be32247 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Sat, 10 Jan 2026 20:36:21 +0530
Subject: [PATCH 02/16] refactor: move `enumerate` to C++23 polyfill, mirror
 namespace structure

---
 src/Makefile.am                              |  1 -
 src/evo/smldiff.cpp                          | 14 +++----
 src/test/block_reward_reallocation_tests.cpp | 20 +++++-----
 src/util/enumerate.h                         | 39 ------------------
 src/util/std23.h                             | 42 +++++++++++++++++++-
 test/util/data/non-backported.txt            |  1 -
 6 files changed, 58 insertions(+), 59 deletions(-)
 delete mode 100644 src/util/enumerate.h

diff --git a/src/Makefile.am b/src/Makefile.am
index 7b4960beb3ce..c28010aa5fff 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -392,7 +392,6 @@ BITCOIN_CORE_H = \
   util/bytevectorhash.h \
   util/check.h \
   util/edge.h \
-  util/enumerate.h \
   util/epochguard.h \
   util/error.h \
   util/fastrange.h \
diff --git a/src/evo/smldiff.cpp b/src/evo/smldiff.cpp
index 4edf461963a5..8e85c918b3ea 100644
--- a/src/evo/smldiff.cpp
+++ b/src/evo/smldiff.cpp
@@ -4,20 +4,20 @@
 
 #include <evo/smldiff.h>
 
-
-#include <chainparams.h>
-#include <consensus/merkle.h>
-#include <core_io.h>
-#include <deploymentstatus.h>
 #include <evo/deterministicmns.h>
 #include <evo/specialtx.h>
 #include <llmq/blockprocessor.h>
 #include <llmq/commitment.h>
 #include <llmq/quorumsman.h>
+#include <util/std23.h>
+
+#include <chainparams.h>
+#include <consensus/merkle.h>
+#include <core_io.h>
+#include <deploymentstatus.h>
 #include <node/blockstorage.h>
 #include <serialize.h>
 #include <univalue.h>
-#include <util/enumerate.h>
 #include <validation.h>
 
 using node::ReadBlockFromDisk;
@@ -74,7 +74,7 @@ bool CSimplifiedMNListDiff::BuildQuorumChainlockInfo(const llmq::CQuorumManager&
     // we want to load CbTxs once per block (heavy operation).
     std::multimap<const CBlockIndex*, uint16_t> workBaseBlockIndexMap;
 
-    for (const auto [idx, e] : enumerate(newQuorums)) {
+    for (const auto [idx, e] : std23::views::enumerate(newQuorums)) {
         // We assume that we have on hand, quorums that correspond to the hashes queried.
         // If we cannot find them, something must have gone wrong and we should cease trying
         // to build any further.
diff --git a/src/test/block_reward_reallocation_tests.cpp b/src/test/block_reward_reallocation_tests.cpp
index ffb7ced72a22..6eb8dfd2f777 100644
--- a/src/test/block_reward_reallocation_tests.cpp
+++ b/src/test/block_reward_reallocation_tests.cpp
@@ -5,6 +5,13 @@
 #include <test/util/setup_common.h>
 
 #include <bls/bls.h>
+#include <evo/deterministicmns.h>
+#include <evo/providertx.h>
+#include <evo/specialtx.h>
+#include <masternode/payments.h>
+#include <util/irange.h>
+#include <util/std23.h>
+
 #include <chainparams.h>
 #include <deploymentstatus.h>
 #include <node/miner.h>
@@ -15,13 +22,6 @@
 #include <script/standard.h>
 #include <validation.h>
 
-#include <evo/deterministicmns.h>
-#include <evo/providertx.h>
-#include <evo/specialtx.h>
-#include <masternode/payments.h>
-#include <util/enumerate.h>
-#include <util/irange.h>
-
 #include <boost/test/unit_test.hpp>
 
 #include <map>
@@ -45,8 +45,8 @@ struct TestChainBRRBeforeActivationSetup : public TestChainSetup
 static SimpleUTXOMap BuildSimpleUtxoMap(const std::vector<CTransactionRef>& txs)
 {
     SimpleUTXOMap utxos;
-    for (auto [i, tx] : enumerate(txs)) {
-        for (auto [j, output] : enumerate(tx->vout)) {
+    for (auto [i, tx] : std23::views::enumerate(txs)) {
+        for (auto [j, output] : std23::views::enumerate(tx->vout)) {
             utxos.try_emplace(COutPoint(tx->GetHash(), j), std::make_pair((int)i + 1, output.nValue));
         }
     }
@@ -100,7 +100,7 @@ static void SignTransaction(const CTxMemPool& mempool, CMutableTransaction& tx,
     FillableSigningProvider tempKeystore;
     tempKeystore.AddKeyPubKey(coinbaseKey, coinbaseKey.GetPubKey());
 
-    for (auto [i, input] : enumerate(tx.vin)) {
+    for (auto [i, input] : std23::views::enumerate(tx.vin)) {
         uint256 hashBlock;
         CTransactionRef txFrom = GetTransaction(/*block_index=*/nullptr, &mempool, input.prevout.hash,
                                                 Params().GetConsensus(), hashBlock);
diff --git a/src/util/enumerate.h b/src/util/enumerate.h
deleted file mode 100644
index c3ec0f00e518..000000000000
--- a/src/util/enumerate.h
+++ /dev/null
@@ -1,39 +0,0 @@
-// Copyright (c) 2022-2024 The Dash Core developers
-// Distributed under the MIT software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#ifndef BITCOIN_UTIL_ENUMERATE_H
-#define BITCOIN_UTIL_ENUMERATE_H
-
-#include <iterator>
-
-/**
- * similar to python's enumerate(iterable).
- * @tparam T type of iterable, automatically deduced
- * @tparam TIter begin of container
- * @param iterable an iterable object, can be a temporary
- * @return struct containing a size_t index, and it's element in iterable
- */
-template <typename T,
-          typename TIter = decltype(std::begin(std::declval<T>())),
-          typename = decltype(std::end(std::declval<T>()))>
-constexpr auto enumerate(T && iterable)
-{
-    struct iterator
-    {
-        size_t i;
-        TIter iter;
-        bool operator != (const iterator & other) const { return iter != other.iter; }
-        void operator ++ () { ++i; ++iter; }
-        auto operator * () const { return std::tie(i, *iter); }
-    };
-    struct iterable_wrapper
-    {
-        T iterable;
-        auto begin() { return iterator{ 0, std::begin(iterable) }; }
-        auto end() { return iterator{ 0, std::end(iterable) }; }
-    };
-    return iterable_wrapper{ std::forward<T>(iterable) };
-}
-
-#endif // BITCOIN_UTIL_ENUMERATE_H
diff --git a/src/util/std23.h b/src/util/std23.h
index ab23ef346935..39ba2f7c6ba6 100644
--- a/src/util/std23.h
+++ b/src/util/std23.h
@@ -1,10 +1,12 @@
-// Copyright (c) 2023 The Dash Core developers
+// Copyright (c) 2022-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.
 
 #ifndef BITCOIN_UTIL_STD23_H
 #define BITCOIN_UTIL_STD23_H
 
+#include <iterator>
+#include <ranges>
 #include <type_traits>
 #include <utility>
 
@@ -23,6 +25,44 @@ template <typename E>
     return static_cast<std::underlying_type_t<E>>(e);
 }
 #endif // __cplusplus >= 202302L
+namespace ranges {
+namespace views {
+#if __cplusplus >= 202302L
+using std::ranges::views::enumerate;
+#else
+/**
+ * @tparam T type of iterable, automatically deduced
+ * @tparam TIter begin of container
+ * @param iterable an iterable object, can be a temporary
+ * @return struct containing a size_t index, and it's element in iterable
+ */
+template <typename T,
+          typename TIter = decltype(std::begin(std::declval<T>())),
+          typename = decltype(std::end(std::declval<T>()))>
+inline constexpr auto enumerate(T && iterable)
+{
+    struct iterator
+    {
+        size_t i;
+        TIter iter;
+        bool operator != (const iterator & other) const { return iter != other.iter; }
+        void operator ++ () { ++i; ++iter; }
+        auto operator * () const { return std::tie(i, *iter); }
+    };
+    struct iterable_wrapper
+    {
+        T iterable;
+        auto begin() { return iterator{ 0, std::begin(iterable) }; }
+        auto end() { return iterator{ 0, std::end(iterable) }; }
+    };
+    return iterable_wrapper{ std::forward<T>(iterable) };
+}
+#endif // __cplusplus >= 202302L
+} // namespace views
+} // namespace ranges
+namespace views {
+using namespace std23::ranges::views;
+} // namespace views
 } // namespace std23
 
 #endif // BITCOIN_UTIL_STD23_H
diff --git a/test/util/data/non-backported.txt b/test/util/data/non-backported.txt
index 4c56e4b7d8e8..1cf8fc30f5ed 100644
--- a/test/util/data/non-backported.txt
+++ b/test/util/data/non-backported.txt
@@ -54,7 +54,6 @@ src/test/util/llmq_tests.h
 src/test/governance*.cpp
 src/unordered_lru_cache.h
 src/util/edge.*
-src/util/enumerate.h
 src/util/irange.h
 src/util/pointer.h
 src/util/ranges.h

From 1ad3c2ac688d03d43c87cf9d04edd2caf906c9b1 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Sun, 11 Jan 2026 12:08:13 +0530
Subject: [PATCH 03/16] refactor: distinguish between custom helpers and
 polyfills

`ranges` was the polyfill for C++20 `std::ranges` but we've mixed it
with our custom helper, `find_if_opt`, that should be in `util`.

Let's retire most use and keep it minimal.
---
 src/active/quorums.cpp        | 10 ++++++++--
 src/bls/bls.h                 |  8 +++-----
 src/bls/bls_worker.cpp        | 11 ++++-------
 src/chainparams.cpp           | 16 ++++++++--------
 src/coinjoin/client.cpp       | 25 +++++++++++++------------
 src/coinjoin/client.h         |  4 ++--
 src/coinjoin/coinjoin.cpp     | 13 +++++++------
 src/coinjoin/coinjoin.h       |  4 +++-
 src/coinjoin/common.h         |  8 ++++----
 src/coinjoin/server.cpp       | 23 +++++++++++------------
 src/evo/deterministicmns.cpp  | 21 +++++++++++----------
 src/evo/deterministicmns.h    |  8 +++++---
 src/governance/governance.cpp | 15 +++++++++------
 src/governance/signing.cpp    |  5 +++--
 src/instantsend/signing.cpp   | 19 +++++++++++--------
 src/llmq/dkgsession.cpp       |  6 ++++--
 src/llmq/options.cpp          |  8 +++++---
 src/llmq/quorums.cpp          |  5 ++---
 src/llmq/signing.cpp          |  3 ++-
 src/llmq/signing_shares.cpp   | 19 +++++++++----------
 src/llmq/utils.cpp            |  7 ++++---
 src/masternode/payments.cpp   | 13 +++++++------
 src/masternode/utils.cpp      | 11 ++++++-----
 src/spork.cpp                 | 14 ++++++++------
 src/util/ranges.h             |  6 ++----
 src/validation.cpp            |  1 +
 26 files changed, 152 insertions(+), 131 deletions(-)

diff --git a/src/active/quorums.cpp b/src/active/quorums.cpp
index b293a99030c7..1c0fd54aa763 100644
--- a/src/active/quorums.cpp
+++ b/src/active/quorums.cpp
@@ -24,6 +24,8 @@
 
 #include <cxxtimer.hpp>
 
+#include <ranges>
+
 namespace llmq {
 QuorumParticipant::QuorumParticipant(CBLSWorker& bls_worker, CConnman& connman, CDeterministicMNManager& dmnman,
                                      QuorumObserverParent& qman, CQuorumSnapshotManager& qsnapman,
@@ -47,7 +49,9 @@ void QuorumParticipant::CheckQuorumConnections(const Consensus::LLMQParams& llmq
 
     const uint256 proTxHash = m_mn_activeman.GetProTxHash();
     const bool watchOtherISQuorums = llmqParams.type == Params().GetConsensus().llmqTypeDIP0024InstantSend &&
-                                     ranges::any_of(lastQuorums, [&proTxHash](const auto& old_quorum){ return old_quorum->IsMember(proTxHash); });
+                                     std::ranges::any_of(lastQuorums, [&proTxHash](const auto& old_quorum) {
+                                         return old_quorum->IsMember(proTxHash);
+                                     });
 
     for (const auto& quorum : lastQuorums) {
         if (utils::EnsureQuorumConnections(llmqParams, m_connman, m_sporkman, {m_dmnman, m_qsnapman, m_chainman, quorum->m_quorum_base_block_index},
@@ -209,7 +213,9 @@ void QuorumParticipant::TriggerQuorumDataRecoveryThreads(gsl::not_null<const CBl
 
     for (const auto& params : Params().GetConsensus().llmqs) {
         auto vecQuorums = m_qman.ScanQuorums(params.type, block_index, params.keepOldConnections);
-        const bool fWeAreQuorumTypeMember = ranges::any_of(vecQuorums, [&proTxHash](const auto& pQuorum) { return pQuorum->IsValidMember(proTxHash); });
+        const bool fWeAreQuorumTypeMember = std::ranges::any_of(vecQuorums, [&proTxHash](const auto& pQuorum) {
+            return pQuorum->IsValidMember(proTxHash);
+        });
 
         for (auto& pQuorum : vecQuorums) {
             if (pQuorum->IsValidMember(proTxHash)) {
diff --git a/src/bls/bls.h b/src/bls/bls.h
index a99cec3114cf..5377f5dafa40 100644
--- a/src/bls/bls.h
+++ b/src/bls/bls.h
@@ -9,7 +9,6 @@
 #include <serialize.h>
 #include <uint256.h>
 #include <util/strencodings.h>
-#include <util/ranges.h>
 
 // bls-dash uses relic, which may define DEBUG and ERROR, which leads to many warnings in some build setups
 #undef ERROR
@@ -23,10 +22,9 @@
 #undef SEED
 
 #include <array>
-#include <mutex>
-#include <unistd.h>
-
 #include <atomic>
+#include <mutex>
+#include <ranges>
 
 namespace bls {
     extern std::atomic<bool> bls_legacy_scheme;
@@ -106,7 +104,7 @@ class CBLSWrapper
             return;
         }
 
-        if (ranges::all_of(vecBytes, [](uint8_t c) { return c == 0; })) {
+        if (std::ranges::all_of(vecBytes, [](uint8_t c) { return c == 0; })) {
             Reset();
         } else {
             try {
diff --git a/src/bls/bls_worker.cpp b/src/bls/bls_worker.cpp
index 44f15e46c22b..7d8d0bd6e492 100644
--- a/src/bls/bls_worker.cpp
+++ b/src/bls/bls_worker.cpp
@@ -5,10 +5,10 @@
 #include <bls/bls_worker.h>
 #include <hash.h>
 
-#include <util/ranges.h>
 #include <util/system.h>
 
 #include <memory>
+#include <ranges>
 #include <utility>
 
 template <typename T>
@@ -108,9 +108,7 @@ bool CBLSWorker::GenerateContributions(int quorumThreshold, Span<CBLSId> ids, BL
         };
         futures.emplace_back(workerPool.push(f));
     }
-    return ranges::all_of(futures, [](auto& f){
-        return f.get();
-    });
+    return std::ranges::all_of(futures, [](auto& f) { return f.get(); });
 }
 
 // aggregates a single vector of BLS objects in parallel
@@ -775,9 +773,8 @@ void CBLSWorker::AsyncVerifySig(const CBLSSignature& sig, const CBLSPublicKey& p
 
     std::unique_lock<std::mutex> l(sigVerifyMutex);
 
-    bool foundDuplicate = ranges::any_of(sigVerifyQueue, [&msgHash](const auto& job){
-        return job.msgHash == msgHash;
-    });
+    bool foundDuplicate = std::ranges::any_of(sigVerifyQueue,
+                                              [&msgHash](const auto& job) { return job.msgHash == msgHash; });
 
     if (foundDuplicate) {
         // batched/aggregated verification does not allow duplicate hashes, so we push what we currently have and start
diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index df1eb452ad53..cc4355e5ab9d 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -6,18 +6,18 @@
 
 #include <chainparams.h>
 
+#include <llmq/params.h>
+#include <util/std23.h>
+
+#include <arith_uint256.h>
 #include <chainparamsseeds.h>
 #include <consensus/merkle.h>
 #include <deploymentinfo.h>
-#include <llmq/params.h>
-#include <util/ranges.h>
-#include <util/std23.h>
 #include <util/system.h>
 #include <versionbits.h>
 
-#include <arith_uint256.h>
-
-#include <assert.h>
+#include <cassert>
+#include <ranges>
 
 static CBlock CreateGenesisBlock(const char* pszTimestamp, const CScript& genesisOutputScript, uint32_t nTime, uint32_t nNonce, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward)
 {
@@ -735,7 +735,7 @@ class CDevNetParams : public CChainParams {
      */
     void UpdateLLMQDevnetParameters(int size, int threshold)
     {
-        auto params = ranges::find_if(consensus.llmqs, [](const auto& llmq){ return llmq.type == Consensus::LLMQType::LLMQ_DEVNET;});
+        auto params = std::ranges::find_if(consensus.llmqs, [](const auto& llmq){ return llmq.type == Consensus::LLMQType::LLMQ_DEVNET;});
         assert(params != consensus.llmqs.end());
         params->size = size;
         params->minSize = threshold;
@@ -974,7 +974,7 @@ class CRegTestParams : public CChainParams {
      */
     void UpdateLLMQTestParameters(int size, int threshold, const Consensus::LLMQType llmqType)
     {
-        auto params = ranges::find_if(consensus.llmqs, [llmqType](const auto& llmq){ return llmq.type == llmqType;});
+        auto params = std::ranges::find_if(consensus.llmqs, [llmqType](const auto& llmq){ return llmq.type == llmqType;});
         assert(params != consensus.llmqs.end());
         params->size = size;
         params->minSize = threshold;
diff --git a/src/coinjoin/client.cpp b/src/coinjoin/client.cpp
index 8299cd9d86cb..2eae460eaeee 100644
--- a/src/coinjoin/client.cpp
+++ b/src/coinjoin/client.cpp
@@ -4,31 +4,33 @@
 
 #include <coinjoin/client.h>
 
-#include <chain.h>
-#include <chainparams.h>
 #include <coinjoin/options.h>
-#include <core_io.h>
 #include <evo/deterministicmns.h>
 #include <masternode/meta.h>
 #include <masternode/sync.h>
+#include <rpc/evo_util.h>
+#include <util/irange.h>
+#include <wallet/coinjoin.h>
+
+#include <chain.h>
+#include <chainparams.h>
+#include <core_io.h>
 #include <net.h>
 #include <netmessagemaker.h>
-#include <rpc/evo_util.h>
 #include <shutdown.h>
 #include <util/check.h>
-#include <util/irange.h>
 #include <util/moneystr.h>
-#include <util/ranges.h>
 #include <util/system.h>
 #include <util/translation.h>
 #include <version.h>
 #include <wallet/coincontrol.h>
-#include <wallet/coinjoin.h>
 #include <wallet/coinselection.h>
 #include <wallet/receive.h>
 #include <wallet/spend.h>
 
 #include <memory>
+#include <ranges>
+
 #include <univalue.h>
 
 using wallet::CCoinControl;
@@ -601,9 +603,8 @@ bool CCoinJoinClientSession::SignFinalTransaction(CNode& peer, CChainState& acti
     for (const auto &entry: vecEntries) {
         // Check that the final transaction has all our outputs
         for (const auto &txout: entry.vecTxOut) {
-            bool fFound = ranges::any_of(finalMutableTransaction.vout, [&txout](const auto& txoutFinal){
-                return txoutFinal == txout;
-            });
+            bool fFound = std::ranges::any_of(finalMutableTransaction.vout,
+                                              [&txout](const auto& txoutFinal) { return txoutFinal == txout; });
             if (!fFound) {
                 // Something went wrong and we'll refuse to sign. It's possible we'll be charged collateral. But that's
                 // better than signing if the transaction doesn't look like what we wanted.
@@ -1444,14 +1445,14 @@ bool CCoinJoinClientSession::MakeCollateralAmounts()
     });
 
     // First try to use only non-denominated funds
-    if (ranges::any_of(vecTally, [&](const auto& item) EXCLUSIVE_LOCKS_REQUIRED(m_wallet->cs_wallet) {
+    if (std::ranges::any_of(vecTally, [&](const auto& item) EXCLUSIVE_LOCKS_REQUIRED(m_wallet->cs_wallet) {
             return MakeCollateralAmounts(item, false);
         })) {
         return true;
     }
 
     // There should be at least some denominated funds we should be able to break in pieces to continue mixing
-    if (ranges::any_of(vecTally, [&](const auto& item) EXCLUSIVE_LOCKS_REQUIRED(m_wallet->cs_wallet) {
+    if (std::ranges::any_of(vecTally, [&](const auto& item) EXCLUSIVE_LOCKS_REQUIRED(m_wallet->cs_wallet) {
             return MakeCollateralAmounts(item, true);
         })) {
         return true;
diff --git a/src/coinjoin/client.h b/src/coinjoin/client.h
index 2b1933841c71..5ecf433010f1 100644
--- a/src/coinjoin/client.h
+++ b/src/coinjoin/client.h
@@ -12,12 +12,12 @@
 
 #include <net_types.h>
 #include <protocol.h>
-#include <util/ranges.h>
 #include <util/translation.h>
 
 #include <atomic>
 #include <deque>
 #include <memory>
+#include <ranges>
 #include <utility>
 
 class CCoinJoinClientManager;
@@ -105,7 +105,7 @@ class CoinJoinWalletManager {
     bool ForAnyCJClientMan(Callable&& func) EXCLUSIVE_LOCKS_REQUIRED(!cs_wallet_manager_map)
     {
         LOCK(cs_wallet_manager_map);
-        return ranges::any_of(m_wallet_manager_map, [&](auto& pair) { return func(pair.second); });
+        return std::ranges::any_of(m_wallet_manager_map, [&](auto& pair) { return func(pair.second); });
     };
 
 private:
diff --git a/src/coinjoin/coinjoin.cpp b/src/coinjoin/coinjoin.cpp
index 1d129d8521e6..9cfe75b585ae 100644
--- a/src/coinjoin/coinjoin.cpp
+++ b/src/coinjoin/coinjoin.cpp
@@ -4,6 +4,11 @@
 
 #include <coinjoin/coinjoin.h>
 
+#include <bls/bls.h>
+#include <chainlock/chainlock.h>
+#include <instantsend/instantsend.h>
+#include <masternode/sync.h>
+
 #include <chain.h>
 #include <chainparams.h>
 #include <txmempool.h>
@@ -13,11 +18,7 @@
 #include <validation.h>
 #include <tinyformat.h>
 
-#include <bls/bls.h>
-#include <chainlock/chainlock.h>
-#include <instantsend/instantsend.h>
-#include <masternode/sync.h>
-
+#include <ranges>
 #include <string>
 
 constexpr static CAmount DEFAULT_MAX_RAW_TX_FEE{COIN / 10};
@@ -104,7 +105,7 @@ bool CCoinJoinBroadcastTx::IsValidStructure() const
     if (tx->vin.size() > CoinJoin::GetMaxPoolParticipants() * COINJOIN_ENTRY_MAX_SIZE) {
         return false;
     }
-    return ranges::all_of(tx->vout, [] (const auto& txOut){
+    return std::ranges::all_of(tx->vout, [](const auto& txOut) {
         return CoinJoin::IsDenominatedAmount(txOut.nValue) && txOut.scriptPubKey.IsPayToPublicKeyHash();
     });
 }
diff --git a/src/coinjoin/coinjoin.h b/src/coinjoin/coinjoin.h
index 9a15be8b6c03..7a2159d73251 100644
--- a/src/coinjoin/coinjoin.h
+++ b/src/coinjoin/coinjoin.h
@@ -7,6 +7,8 @@
 
 #include <coinjoin/common.h>
 
+#include <util/ranges.h>
+
 #include <core_io.h>
 #include <netaddress.h>
 #include <primitives/block.h>
@@ -346,7 +348,7 @@ class CCoinJoinBaseManager
     std::optional<CCoinJoinQueue> GetQueueFromHash(const uint256& queueHash) EXCLUSIVE_LOCKS_REQUIRED(!cs_vecqueue)
     {
         LOCK(cs_vecqueue);
-        return ranges::find_if_opt(vecCoinJoinQueue, [&queueHash](const auto& q) { return q.GetHash() == queueHash; });
+        return util::find_if_opt(vecCoinJoinQueue, [&queueHash](const auto& q) { return q.GetHash() == queueHash; });
     }
 };
 
diff --git a/src/coinjoin/common.h b/src/coinjoin/common.h
index 7b7c939f1184..5b1fc7b76742 100644
--- a/src/coinjoin/common.h
+++ b/src/coinjoin/common.h
@@ -5,12 +5,13 @@
 #ifndef BITCOIN_COINJOIN_COMMON_H
 #define BITCOIN_COINJOIN_COMMON_H
 
+#include <util/ranges.h>
+
 #include <consensus/amount.h>
 #include <primitives/transaction.h>
 
 #include <array>
 #include <string>
-#include <util/ranges.h>
 
 /** Holds a mixing input
  */
@@ -117,9 +118,8 @@ constexpr bool IsCollateralAmount(CAmount nInputAmount)
 
 constexpr int CalculateAmountPriority(CAmount nInputAmount)
 {
-    if (auto optDenom = ranges::find_if_opt(GetStandardDenominations(), [&nInputAmount](const auto& denom) {
-        return nInputAmount == denom;
-    })) {
+    if (auto optDenom = util::find_if_opt(GetStandardDenominations(),
+                                          [&nInputAmount](const auto& denom) { return nInputAmount == denom; })) {
         return (float)COIN / *optDenom * 10000;
     }
     if (nInputAmount < COIN) {
diff --git a/src/coinjoin/server.cpp b/src/coinjoin/server.cpp
index c68e33224a56..86cb3ce01d5e 100644
--- a/src/coinjoin/server.cpp
+++ b/src/coinjoin/server.cpp
@@ -8,7 +8,6 @@
 #include <evo/deterministicmns.h>
 #include <masternode/meta.h>
 #include <masternode/sync.h>
-#include <util/ranges.h>
 
 #include <core_io.h>
 #include <net.h>
@@ -25,6 +24,8 @@
 
 #include <univalue.h>
 
+#include <ranges>
+
 CCoinJoinServer::CCoinJoinServer(PeerManagerInternal* peer_manager, ChainstateManager& chainman, CConnman& _connman,
                                  CDeterministicMNManager& dmnman, CDSTXManager& dstxman, CMasternodeMetaMan& mn_metaman,
                                  CTxMemPool& mempool, const CActiveMasternodeManager& mn_activeman,
@@ -91,8 +92,8 @@ void CCoinJoinServer::ProcessDSACCEPT(CNode& peer, CDataStream& vRecv)
 
             auto mnOutpoint = m_mn_activeman.GetOutPoint();
 
-            if (ranges::any_of(vecCoinJoinQueue,
-                               [&mnOutpoint](const auto& q){return q.masternodeOutpoint == mnOutpoint;})) {
+            if (std::ranges::any_of(vecCoinJoinQueue,
+                                    [&mnOutpoint](const auto& q) { return q.masternodeOutpoint == mnOutpoint; })) {
                 // refuse to create another queue this often
                 LogPrint(BCLog::COINJOIN, "DSACCEPT -- last dsq is still in queue, refuse to mix\n");
                 PushStatus(peer, STATUS_REJECTED, ERR_RECENT);
@@ -408,7 +409,7 @@ void CCoinJoinServer::ChargeFees() const
     if (nState == POOL_STATE_ACCEPTING_ENTRIES) {
         LOCK(cs_coinjoin);
         for (const auto& txCollateral : vecSessionCollaterals) {
-            bool fFound = ranges::any_of(vecEntries, [&txCollateral](const auto& entry){
+            bool fFound = std::ranges::any_of(vecEntries, [&txCollateral](const auto& entry) {
                 return *entry.txCollateral == *txCollateral;
             });
 
@@ -610,10 +611,8 @@ bool CCoinJoinServer::AddEntry(const CCoinJoinEntry& entry, PoolMessage& nMessag
         LogPrint(BCLog::COINJOIN, "CCoinJoinServer::%s -- txin=%s\n", __func__, txin.ToString());
         LOCK(cs_coinjoin);
         for (const auto& inner_entry : vecEntries) {
-            if (ranges::any_of(inner_entry.vecTxDSIn,
-                            [&txin](const auto& txdsin){
-                                    return txdsin.prevout == txin.prevout;
-                            })) {
+            if (std::ranges::any_of(inner_entry.vecTxDSIn,
+                                    [&txin](const auto& txdsin) { return txdsin.prevout == txin.prevout; })) {
                 LogPrint(BCLog::COINJOIN, "CCoinJoinServer::%s -- ERROR: already have this txin in entries\n", __func__);
                 nMessageIDRet = ERR_ALREADY_HAVE;
                 // Two peers sent the same input? Can't really say who is the malicious one here,
@@ -650,8 +649,8 @@ bool CCoinJoinServer::AddScriptSig(const CTxIn& txinNew)
 
     LOCK(cs_coinjoin);
     for (const auto& entry : vecEntries) {
-        if (ranges::any_of(entry.vecTxDSIn,
-                        [&txinNew](const auto& txdsin){ return txdsin.scriptSig == txinNew.scriptSig; })){
+        if (std::ranges::any_of(entry.vecTxDSIn,
+                                [&txinNew](const auto& txdsin) { return txdsin.scriptSig == txinNew.scriptSig; })) {
             LogPrint(BCLog::COINJOIN, "CCoinJoinServer::AddScriptSig -- already exists\n");
             return false;
         }
@@ -687,8 +686,8 @@ bool CCoinJoinServer::IsSignaturesComplete() const
     AssertLockNotHeld(cs_coinjoin);
     LOCK(cs_coinjoin);
 
-    return ranges::all_of(vecEntries, [](const auto& entry){
-        return ranges::all_of(entry.vecTxDSIn, [](const auto& txdsin){return txdsin.fHasSig;});
+    return std::ranges::all_of(vecEntries, [](const auto& entry) {
+        return std::ranges::all_of(entry.vecTxDSIn, [](const auto& txdsin) { return txdsin.fHasSig; });
     });
 }
 
diff --git a/src/evo/deterministicmns.cpp b/src/evo/deterministicmns.cpp
index aa97f67de072..a3e503c72afc 100644
--- a/src/evo/deterministicmns.cpp
+++ b/src/evo/deterministicmns.cpp
@@ -120,8 +120,9 @@ CDeterministicMNCPtr CDeterministicMNList::GetValidMN(const uint256& proTxHash)
 
 CDeterministicMNCPtr CDeterministicMNList::GetMNByOperatorKey(const CBLSPublicKey& pubKey) const
 {
-    const auto it = ranges::find_if(mnMap,
-                              [&pubKey](const auto& p){return p.second->pdmnState->pubKeyOperator.Get() == pubKey;});
+    const auto it = std::ranges::find_if(mnMap, [&pubKey](const auto& p) {
+        return p.second->pdmnState->pubKeyOperator.Get() == pubKey;
+    });
     if (it == mnMap.end()) {
         return nullptr;
     }
@@ -853,13 +854,13 @@ CDeterministicMNList CDeterministicMNManager::GetListForBlockInternal(gsl::not_n
             mnListsCache.emplace(snapshot_hash, snapshot);
         } else {
             // keep snapshots for yet alive quorums
-            if (ranges::any_of(Params().GetConsensus().llmqs,
-                               [&snapshot, this](const auto& params) EXCLUSIVE_LOCKS_REQUIRED(cs) {
-                                   AssertLockHeld(cs);
-                                   return (snapshot.GetHeight() % params.dkgInterval == 0) &&
-                                          (snapshot.GetHeight() + params.dkgInterval * (params.keepOldConnections + 1) >=
-                                           tipIndex->nHeight);
-                               })) {
+            if (std::ranges::any_of(Params().GetConsensus().llmqs, [&snapshot, this](
+                                                                       const auto& params) EXCLUSIVE_LOCKS_REQUIRED(cs) {
+                    AssertLockHeld(cs);
+                    return (snapshot.GetHeight() % params.dkgInterval == 0) &&
+                           (snapshot.GetHeight() + params.dkgInterval * (params.keepOldConnections + 1) >=
+                            tipIndex->nHeight);
+                })) {
                 mnListsCache.emplace(snapshot_hash, snapshot);
             }
         }
@@ -919,7 +920,7 @@ void CDeterministicMNManager::CleanupCache(int nHeight)
             // it's a snapshot for the tip, keep it
             continue;
         }
-        bool fQuorumCache = ranges::any_of(Params().GetConsensus().llmqs, [&nHeight, &p](const auto& params){
+        bool fQuorumCache = std::ranges::any_of(Params().GetConsensus().llmqs, [&nHeight, &p](const auto& params) {
             return (p.second.GetHeight() % params.dkgInterval == 0) &&
                    (p.second.GetHeight() + params.dkgInterval * (params.keepOldConnections + 1) >= nHeight);
         });
diff --git a/src/evo/deterministicmns.h b/src/evo/deterministicmns.h
index 1bdcf7343e96..8563076e9a9f 100644
--- a/src/evo/deterministicmns.h
+++ b/src/evo/deterministicmns.h
@@ -21,9 +21,11 @@
 #include <gsl/pointers.h>
 #include <immer/map.hpp>
 
+#include <algorithm>
 #include <atomic>
 #include <limits>
 #include <numeric>
+#include <ranges>
 #include <unordered_map>
 #include <utility>
 
@@ -262,17 +264,17 @@ class CDeterministicMNList
 
     [[nodiscard]] size_t GetValidMNsCount() const
     {
-        return ranges::count_if(mnMap, [](const auto& p) { return !p.second->pdmnState->IsBanned(); });
+        return std::ranges::count_if(mnMap, [](const auto& p) { return !p.second->pdmnState->IsBanned(); });
     }
 
     [[nodiscard]] size_t GetAllEvoCount() const
     {
-        return ranges::count_if(mnMap, [](const auto& p) { return p.second->nType == MnType::Evo; });
+        return std::ranges::count_if(mnMap, [](const auto& p) { return p.second->nType == MnType::Evo; });
     }
 
     [[nodiscard]] size_t GetValidEvoCount() const
     {
-        return ranges::count_if(mnMap, [](const auto& p) {
+        return std::ranges::count_if(mnMap, [](const auto& p) {
             return p.second->nType == MnType::Evo && !p.second->pdmnState->IsBanned();
         });
     }
diff --git a/src/governance/governance.cpp b/src/governance/governance.cpp
index 190fe8b9dce5..d3e725710944 100644
--- a/src/governance/governance.cpp
+++ b/src/governance/governance.cpp
@@ -4,10 +4,6 @@
 
 #include <governance/governance.h>
 
-#include <chain.h>
-#include <chainparams.h>
-#include <common/bloom.h>
-#include <deploymentstatus.h>
 #include <evo/deterministicmns.h>
 #include <flat-database.h>
 #include <governance/classes.h>
@@ -15,17 +11,24 @@
 #include <governance/validators.h>
 #include <masternode/meta.h>
 #include <masternode/sync.h>
+#include <spork.h>
+#include <util/std23.h>
+
+#include <chain.h>
+#include <chainparams.h>
+#include <common/bloom.h>
+#include <deploymentstatus.h>
 #include <netfulfilledman.h>
 #include <netmessagemaker.h>
 #include <protocol.h>
 #include <shutdown.h>
-#include <spork.h>
 #include <timedata.h>
-#include <util/ranges.h>
 #include <util/thread.h>
 #include <util/time.h>
 #include <validationinterface.h>
 
+#include <ranges>
+
 const std::string GovernanceStore::SERIALIZATION_VERSION_STRING = "CGovernanceManager-Version-16";
 
 namespace {
diff --git a/src/governance/signing.cpp b/src/governance/signing.cpp
index abc0777d6301..1aec5e818073 100644
--- a/src/governance/signing.cpp
+++ b/src/governance/signing.cpp
@@ -16,6 +16,7 @@
 #include <validation.h>
 
 #include <algorithm>
+#include <ranges>
 
 namespace {
 constexpr std::chrono::seconds GOVERNANCE_FUDGE_WINDOW{2h};
@@ -182,7 +183,7 @@ void GovernanceSigner::VoteGovernanceTriggers(const std::optional<const CGoverna
         if (vote_rec_t voteRecord; trigger_opt.value().GetCurrentMNVotes(m_mn_activeman.GetOutPoint(), voteRecord)) {
             const auto& strFunc = __func__;
             // Let's see if there is a VOTE_SIGNAL_FUNDING vote from us already
-            voted_already = ranges::any_of(voteRecord.mapInstances, [&](const auto& voteInstancePair) {
+            voted_already = std::ranges::any_of(voteRecord.mapInstances, [&](const auto& voteInstancePair) {
                 if (voteInstancePair.first == VOTE_SIGNAL_FUNDING) {
                     if (voteInstancePair.second.eOutcome == VOTE_OUTCOME_YES) {
                         votedFundingYesTriggerHash = gov_sb_hash;
@@ -236,7 +237,7 @@ void GovernanceSigner::VoteGovernanceTriggers(const std::optional<const CGoverna
         }
         if (vote_rec_t voteRecord; govobj->GetCurrentMNVotes(m_mn_activeman.GetOutPoint(), voteRecord)) {
             const auto& strFunc = __func__;
-            if (ranges::any_of(voteRecord.mapInstances, [&](const auto& voteInstancePair) {
+            if (std::ranges::any_of(voteRecord.mapInstances, [&](const auto& voteInstancePair) {
                     if (voteInstancePair.first == VOTE_SIGNAL_FUNDING) {
                         LogPrint(BCLog::GOBJECT, /* Continued */
                                  "%s -- Not voting NO-FUNDING for trigger:%s, we voted %s for it already\n", strFunc,
diff --git a/src/instantsend/signing.cpp b/src/instantsend/signing.cpp
index 783b5757ca22..05e506614a37 100644
--- a/src/instantsend/signing.cpp
+++ b/src/instantsend/signing.cpp
@@ -4,18 +4,20 @@
 
 #include <instantsend/signing.h>
 
+#include <chainlock/chainlock.h>
+#include <llmq/quorumsman.h>
+#include <llmq/signing_shares.h>
+#include <masternode/sync.h>
+#include <spork.h>
+#include <util/irange.h>
+
 #include <chain.h>
 #include <chainparams.h>
 #include <index/txindex.h>
 #include <logging.h>
-#include <util/irange.h>
 #include <validation.h>
 
-#include <chainlock/chainlock.h>
-#include <llmq/quorumsman.h>
-#include <llmq/signing_shares.h>
-#include <masternode/sync.h>
-#include <spork.h>
+#include <ranges>
 
 // Forward declaration to break dependency over node/transaction.h
 namespace node {
@@ -170,8 +172,9 @@ bool InstantSendSigner::CheckCanLock(const CTransaction& tx, bool printDebug, co
         return false;
     }
 
-    return ranges::all_of(tx.vin,
-                          [&](const auto& in) { return CheckCanLock(in.prevout, printDebug, tx.GetHash(), params); });
+    return std::ranges::all_of(tx.vin, [&](const auto& in) {
+        return CheckCanLock(in.prevout, printDebug, tx.GetHash(), params);
+    });
 }
 
 bool InstantSendSigner::CheckCanLock(const COutPoint& outpoint, bool printDebug, const uint256& txHash,
diff --git a/src/llmq/dkgsession.cpp b/src/llmq/dkgsession.cpp
index f2d86acbfab9..6d74f602f4a7 100644
--- a/src/llmq/dkgsession.cpp
+++ b/src/llmq/dkgsession.cpp
@@ -22,9 +22,11 @@
 
 #include <cxxtimer.hpp>
 
+#include <algorithm>
 #include <array>
 #include <atomic>
 #include <memory>
+#include <ranges>
 
 namespace llmq {
 CDKGLogger::CDKGLogger(const CDKGSession& _quorumDkg, std::string_view _func, int source_line) :
@@ -236,7 +238,7 @@ std::optional<CInv> CDKGSession::ReceiveMessage(const CDKGContribution& qc)
 
     receivedVvecs[member->idx] = qc.vvec;
 
-    int receivedCount = ranges::count_if(members, [](const auto& m){return !m->contributions.empty();});
+    int receivedCount = std::ranges::count_if(members, [](const auto& m) { return !m->contributions.empty(); });
 
     logger.Batch("received and relayed contribution. received=%d/%d, time=%d", receivedCount, members.size(), t1.count());
 
@@ -666,7 +668,7 @@ std::optional<CInv> CDKGSession::ReceiveMessage(const CDKGPrematureCommitment& q
         return true;
     });
 
-    int receivedCount = ranges::count_if(members, [](const auto& m){ return !m->prematureCommitments.empty(); });
+    int receivedCount = std::ranges::count_if(members, [](const auto& m) { return !m->prematureCommitments.empty(); });
 
     t1.stop();
 
diff --git a/src/llmq/options.cpp b/src/llmq/options.cpp
index d7a74bf5a3b4..d5c946a95752 100644
--- a/src/llmq/options.cpp
+++ b/src/llmq/options.cpp
@@ -14,8 +14,9 @@
 #include <util/system.h>
 #include <validation.h>
 
-#include <string>
+#include <ranges>
 #include <stdexcept>
+#include <string>
 
 namespace llmq
 {
@@ -71,8 +72,9 @@ QvvecSyncModeMap GetEnabledQuorumVvecSyncEntries(const ArgsManager& args)
             throw std::invalid_argument(strprintf("Invalid format in -llmq-qvvec-sync: %s", strEntry));
         }
 
-        if (auto optLLMQParams = ranges::find_if_opt(Params().GetConsensus().llmqs,
-                                                     [&strLLMQType](const auto& params){return params.name == strLLMQType;})) {
+        if (auto optLLMQParams = util::find_if_opt(Params().GetConsensus().llmqs, [&strLLMQType](const auto& params) {
+                return params.name == strLLMQType;
+            })) {
             llmqType = optLLMQParams->type;
         } else {
             throw std::invalid_argument(strprintf("Invalid llmqType in -llmq-qvvec-sync: %s", strEntry));
diff --git a/src/llmq/quorums.cpp b/src/llmq/quorums.cpp
index 51108903cd70..b0b657813702 100644
--- a/src/llmq/quorums.cpp
+++ b/src/llmq/quorums.cpp
@@ -10,6 +10,7 @@
 #include <dbwrapper.h>
 
 #include <memory>
+#include <ranges>
 
 namespace llmq {
 const std::string DB_QUORUM_SK_SHARE = "q_Qsk";
@@ -134,9 +135,7 @@ bool CQuorum::SetSecretKeyShare(const CBLSSecretKey& secretKeyShare, const uint2
 
 bool CQuorum::IsMember(const uint256& proTxHash) const
 {
-    return ranges::any_of(members, [&proTxHash](const auto& dmn){
-        return dmn->proTxHash == proTxHash;
-    });
+    return std::ranges::any_of(members, [&proTxHash](const auto& dmn) { return dmn->proTxHash == proTxHash; });
 }
 
 bool CQuorum::IsValidMember(const uint256& proTxHash) const
diff --git a/src/llmq/signing.cpp b/src/llmq/signing.cpp
index 0e12e31bf547..f470c1ba1705 100644
--- a/src/llmq/signing.cpp
+++ b/src/llmq/signing.cpp
@@ -15,6 +15,7 @@
 #include <util/system.h>
 
 #include <algorithm>
+#include <ranges>
 #include <unordered_map>
 #include <unordered_set>
 
@@ -608,7 +609,7 @@ bool IsQuorumActive(Consensus::LLMQType llmqType, const CQuorumManager& qman, co
     const auto& llmq_params_opt = Params().GetLLMQ(llmqType);
     assert(llmq_params_opt.has_value());
     auto quorums = qman.ScanQuorums(llmqType, llmq_params_opt->keepOldConnections);
-    return ranges::any_of(quorums, [&quorumHash](const auto& q){ return q->qc->quorumHash == quorumHash; });
+    return std::ranges::any_of(quorums, [&quorumHash](const auto& q) { return q->qc->quorumHash == quorumHash; });
 }
 
 } // namespace llmq
diff --git a/src/llmq/signing_shares.cpp b/src/llmq/signing_shares.cpp
index 5ca4a4bfe3ac..66cbb8e97ec2 100644
--- a/src/llmq/signing_shares.cpp
+++ b/src/llmq/signing_shares.cpp
@@ -25,6 +25,8 @@
 
 #include <cxxtimer.hpp>
 
+#include <ranges>
+
 namespace llmq
 {
 void CSigShare::UpdateKey()
@@ -280,8 +282,7 @@ void CSigSharesManager::ProcessMessage(const CNode& pfrom, const std::string& ms
             BanNode(pfrom.GetId());
             return;
         }
-        if (!ranges::all_of(msgs,
-                            [this, &pfrom](const auto& ann){ return ProcessMessageSigSesAnn(pfrom, ann); })) {
+        if (!std::ranges::all_of(msgs, [this, &pfrom](const auto& ann) { return ProcessMessageSigSesAnn(pfrom, ann); })) {
             BanNode(pfrom.GetId());
             return;
         }
@@ -293,8 +294,7 @@ void CSigSharesManager::ProcessMessage(const CNode& pfrom, const std::string& ms
             BanNode(pfrom.GetId());
             return;
         }
-        if (!ranges::all_of(msgs,
-                            [this, &pfrom](const auto& inv){ return ProcessMessageSigSharesInv(pfrom, inv); })) {
+        if (!std::ranges::all_of(msgs, [this, &pfrom](const auto& inv) { return ProcessMessageSigSharesInv(pfrom, inv); })) {
             BanNode(pfrom.GetId());
             return;
         }
@@ -306,8 +306,7 @@ void CSigSharesManager::ProcessMessage(const CNode& pfrom, const std::string& ms
             BanNode(pfrom.GetId());
             return;
         }
-        if (!ranges::all_of(msgs,
-                            [this, &pfrom](const auto& inv){ return ProcessMessageGetSigShares(pfrom, inv); })) {
+        if (!std::ranges::all_of(msgs, [this, &pfrom](const auto& inv) { return ProcessMessageGetSigShares(pfrom, inv); })) {
             BanNode(pfrom.GetId());
             return;
         }
@@ -323,8 +322,8 @@ void CSigSharesManager::ProcessMessage(const CNode& pfrom, const std::string& ms
             BanNode(pfrom.GetId());
             return;
         }
-        if (!ranges::all_of(msgs,
-                            [this, &pfrom](const auto& bs){ return ProcessMessageBatchedSigShares(pfrom, bs); })) {
+        if (!std::ranges::all_of(msgs,
+                                 [this, &pfrom](const auto& bs) { return ProcessMessageBatchedSigShares(pfrom, bs); })) {
             BanNode(pfrom.GetId());
             return;
         }
@@ -1273,8 +1272,8 @@ bool CSigSharesManager::SendMessages()
         assert(session);
         while (session->sendSessionId == UNINITIALIZED_SESSION_ID) {
             const uint32_t session_id{GetRand<uint32_t>()};
-            if (ranges::all_of(nodeState.sessions,
-                               [&session_id](const auto& s) { return s.second.sendSessionId != session_id; })) {
+            if (std::ranges::all_of(nodeState.sessions,
+                                    [&session_id](const auto& s) { return s.second.sendSessionId != session_id; })) {
                 // No session is using this id yet
                 session->sendSessionId = session_id;
                 sigSessionAnnouncements[nodeId].emplace_back(
diff --git a/src/llmq/utils.cpp b/src/llmq/utils.cpp
index ebb8165acbc0..c009ad3b995c 100644
--- a/src/llmq/utils.cpp
+++ b/src/llmq/utils.cpp
@@ -11,19 +11,19 @@
 #include <llmq/types.h>
 #include <masternode/meta.h>
 #include <util/irange.h>
-#include <util/ranges.h>
+#include <util/std23.h>
 
 #include <chainparams.h>
 #include <deploymentstatus.h>
 #include <net.h>
 #include <random.h>
-#include <util/std23.h>
 #include <util/time.h>
 #include <validation.h>
 
 #include <atomic>
 #include <map>
 #include <optional>
+#include <ranges>
 
 /**
  * Forward declarations
@@ -788,7 +788,8 @@ bool EnsureQuorumConnections(const Consensus::LLMQParams& llmqParams, CConnman&
         return false;
     }
 
-    bool isMember = ranges::find_if(members, [&](const auto& dmn) { return dmn->proTxHash == myProTxHash; }) != members.end();
+    bool isMember = std::ranges::find_if(members, [&](const auto& dmn) { return dmn->proTxHash == myProTxHash; }) !=
+                    members.end();
 
     if (!isMember && !quorums_watch) {
         return false;
diff --git a/src/masternode/payments.cpp b/src/masternode/payments.cpp
index 1c5b1d4be107..d97208f20740 100644
--- a/src/masternode/payments.cpp
+++ b/src/masternode/payments.cpp
@@ -4,22 +4,23 @@
 
 #include <masternode/payments.h>
 
-#include <chain.h>
-#include <consensus/amount.h>
-#include <deploymentstatus.h>
 #include <evo/deterministicmns.h>
 #include <governance/classes.h>
 #include <governance/governance.h>
+#include <masternode/sync.h>
+
+#include <chain.h>
+#include <consensus/amount.h>
+#include <deploymentstatus.h>
 #include <key_io.h>
 #include <logging.h>
-#include <masternode/sync.h>
 #include <primitives/block.h>
 #include <script/standard.h>
 #include <tinyformat.h>
-#include <util/ranges.h>
 #include <validation.h>
 
 #include <cassert>
+#include <ranges>
 #include <string>
 
 CAmount PlatformShare(const CAmount reward)
@@ -123,7 +124,7 @@ CAmount PlatformShare(const CAmount reward)
     }
 
     for (const auto& txout : voutMasternodePayments) {
-        bool found = ranges::any_of(txNew.vout, [&txout](const auto& txout2) {return txout == txout2;});
+        bool found = std::ranges::any_of(txNew.vout, [&txout](const auto& txout2) { return txout == txout2; });
         if (!found) {
             std::string str_payout;
             if (CTxDestination dest; ExtractDestination(txout.scriptPubKey, dest)) {
diff --git a/src/masternode/utils.cpp b/src/masternode/utils.cpp
index 4ed51031db27..b2c0bc90e07f 100644
--- a/src/masternode/utils.cpp
+++ b/src/masternode/utils.cpp
@@ -4,14 +4,15 @@
 
 #include <masternode/utils.h>
 
-#include <net.h>
-#include <shutdown.h>
-#include <util/ranges.h>
-
 #include <coinjoin/walletman.h>
 #include <evo/deterministicmns.h>
 #include <masternode/sync.h>
 
+#include <net.h>
+#include <shutdown.h>
+
+#include <algorithm>
+
 void CMasternodeUtils::DoMaintenance(CConnman& connman, CDeterministicMNManager& dmnman, const CMasternodeSync& mn_sync,
                                      CJWalletManager* const cj_walletman)
 {
@@ -67,7 +68,7 @@ void CMasternodeUtils::DoMaintenance(CConnman& connman, CDeterministicMNManager&
             }
         }
 
-        bool fFound = ranges::any_of(mixing_masternodes, [&pnode](const auto& dmn) {
+        bool fFound = std::ranges::any_of(mixing_masternodes, [&pnode](const auto& dmn) {
             return pnode->addr == dmn->pdmnState->netInfo->GetPrimary();
         });
         if (fFound) return; // do NOT disconnect mixing masternodes
diff --git a/src/spork.cpp b/src/spork.cpp
index 9842e44226f6..0d4fc7cabd5d 100644
--- a/src/spork.cpp
+++ b/src/spork.cpp
@@ -4,8 +4,10 @@
 
 #include <spork.h>
 
-#include <chainparams.h>
 #include <flat-database.h>
+#include <util/ranges.h>
+
+#include <chainparams.h>
 #include <key_io.h>
 #include <logging.h>
 #include <messagesigner.h>
@@ -15,10 +17,10 @@
 #include <script/standard.h>
 #include <timedata.h>
 #include <util/message.h> // for MESSAGE_MAGIC
-#include <util/ranges.h>
 #include <util/string.h>
 #include <validation.h>
 
+#include <ranges>
 #include <string>
 
 const std::string SporkStore::SERIALIZATION_VERSION_STRING = "CSporkManager-Version-2";
@@ -277,8 +279,8 @@ SporkValue CSporkManager::GetSporkValue(SporkId nSporkID) const
     }
 
 
-    if (auto optSpork = ranges::find_if_opt(sporkDefs,
-                                            [&nSporkID](const auto& sporkDef){return sporkDef.sporkId == nSporkID;})) {
+    if (auto optSpork = util::find_if_opt(sporkDefs,
+                                          [&nSporkID](const auto& sporkDef) { return sporkDef.sporkId == nSporkID; })) {
         return optSpork->defaultValue;
     } else {
         LogPrint(BCLog::SPORK, "CSporkManager::GetSporkValue -- Unknown Spork ID %d\n", nSporkID);
@@ -288,8 +290,8 @@ SporkValue CSporkManager::GetSporkValue(SporkId nSporkID) const
 
 SporkId CSporkManager::GetSporkIDByName(std::string_view strName)
 {
-    if (auto optSpork = ranges::find_if_opt(sporkDefs,
-                                            [&strName](const auto& sporkDef){return sporkDef.name == strName;})) {
+    if (auto optSpork = util::find_if_opt(sporkDefs,
+                                          [&strName](const auto& sporkDef) { return sporkDef.name == strName; })) {
         return optSpork->sporkId;
     }
 
diff --git a/src/util/ranges.h b/src/util/ranges.h
index 055745a20d6e..808a6a487261 100644
--- a/src/util/ranges.h
+++ b/src/util/ranges.h
@@ -8,9 +8,7 @@
 #include <optional>
 #include <ranges>
 
-namespace ranges {
-using namespace std::ranges;
-
+namespace util {
 template <typename X, typename Z>
 constexpr inline auto find_if_opt(const X& ds, const Z& fn)
 {
@@ -20,6 +18,6 @@ constexpr inline auto find_if_opt(const X& ds, const Z& fn)
     }
     return std::optional<std::decay_t<decltype(*it)>>{};
 }
-}
+} // namespace util
 
 #endif // BITCOIN_UTIL_RANGES_H
diff --git a/src/validation.cpp b/src/validation.cpp
index 70371ede114e..03a00a59eaa8 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -57,6 +57,7 @@
 #include <evo/specialtxman.h>
 #include <masternode/payments.h>
 #include <stats/client.h>
+#include <util/std23.h>
 
 #include <algorithm>
 #include <cassert>

From 75d5dc6a4553b675f35d8c7f2b5145fa92831562 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Sun, 11 Jan 2026 12:04:44 +0530
Subject: [PATCH 04/16] refactor: switch from `irange(min, max)` to
 `std::views::iota(min, max)`

We are only migrating this overload to `std::views::iota` because it is
assumed that min and max have the same underlying or compatible type,
the `irange(max)` overload causes type issues because `0` needs to be
statically cast, to keep it simple we will be introducing a small
wrapper but not extending it to this case where it is unnecessary.
---
 src/evo/deterministicmns.cpp | 3 ++-
 src/llmq/commitment.cpp      | 4 +++-
 src/llmq/dkgsession.cpp      | 2 +-
 3 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/evo/deterministicmns.cpp b/src/evo/deterministicmns.cpp
index a3e503c72afc..f5bc33a2655b 100644
--- a/src/evo/deterministicmns.cpp
+++ b/src/evo/deterministicmns.cpp
@@ -29,6 +29,7 @@
 #include <functional>
 #include <optional>
 #include <memory>
+#include <ranges>
 
 #include <univalue.h>
 
@@ -1466,7 +1467,7 @@ bool CDeterministicMNManager::MigrateLegacyDiffs(const CBlockIndex* const tip_in
     CDeterministicMNList snapshot;
 
     const auto start_height{Params().GetConsensus().DeploymentHeight(Consensus::DEPLOYMENT_DIP0003)};
-    for (auto current_height : irange::range(start_height, tip_index->nHeight + 1)) {
+    for (auto current_height : std::views::iota(start_height, tip_index->nHeight + 1)) {
         auto current_index = tip_index->GetAncestor(current_height);
         auto target_key{std::make_tuple(DB_LIST_DIFF_LEGACY, current_index->GetBlockHash())};
         pcursor->Seek(target_key);
diff --git a/src/llmq/commitment.cpp b/src/llmq/commitment.cpp
index 7bd0aa792fc3..e231e30861f4 100644
--- a/src/llmq/commitment.cpp
+++ b/src/llmq/commitment.cpp
@@ -17,6 +17,8 @@
 #include <logging.h>
 #include <validation.h>
 
+#include <ranges>
+
 namespace llmq
 {
 
@@ -161,7 +163,7 @@ bool CFinalCommitment::Verify(const llmq::UtilParameters& util_params, bool chec
         LogPrint(BCLog::LLMQ, "CFinalCommitment::%s mns[%d] validMembers[%s] signers[%s]\n", __func__, members.size(), ss.str(), ss2.str());
     }
 
-    for (const auto i : irange::range(members.size(), size_t(llmq_params.size))) {
+    for (const auto i : std::views::iota(members.size(), size_t(llmq_params.size))) {
         if (validMembers[i]) {
             LogPrint(BCLog::LLMQ, "CFinalCommitment -- q[%s] invalid validMembers bitset. bit %d should not be set\n", quorumHash.ToString(), i);
             return false;
diff --git a/src/llmq/dkgsession.cpp b/src/llmq/dkgsession.cpp
index 6d74f602f4a7..e956b0a076cb 100644
--- a/src/llmq/dkgsession.cpp
+++ b/src/llmq/dkgsession.cpp
@@ -578,7 +578,7 @@ bool CDKGSession::PreVerifyMessage(const CDKGPrematureCommitment& qc, bool& retB
         return false;
     }
 
-    for (const auto i : irange::range(members.size(), size_t(params.size))) {
+    for (const auto i : std::views::iota(members.size(), size_t(params.size))) {
         // cppcheck-suppress useStlAlgorithm
         if (qc.validMembers[i]) {
             retBan = true;

From 315893e0f389bc191aa6d53f3c3316fbbe5bc5d2 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Sun, 11 Jan 2026 12:06:54 +0530
Subject: [PATCH 05/16] refactor: replace `irange::range` with thin
 `std::views::iota` wrapper

---
 src/Makefile.am                              |  1 -
 src/active/dkgsession.cpp                    | 11 +--
 src/active/quorums.cpp                       |  5 +-
 src/bench/bls_dkg.cpp                        | 12 +--
 src/coinjoin/client.cpp                      |  8 +-
 src/evo/deterministicmns.cpp                 |  8 +-
 src/evo/specialtxman.cpp                     |  1 -
 src/instantsend/signing.cpp                  |  4 +-
 src/llmq/blockprocessor.cpp                  |  8 +-
 src/llmq/commitment.cpp                      |  7 +-
 src/llmq/commitment.h                        |  4 +-
 src/llmq/debug.cpp                           |  4 +-
 src/llmq/dkgsession.cpp                      |  8 +-
 src/llmq/dkgsessionmgr.cpp                   | 10 +--
 src/llmq/dkgsessionmgr.h                     |  4 +-
 src/llmq/observer/quorums.cpp                |  3 +-
 src/llmq/quorums.cpp                         |  7 +-
 src/llmq/quorumsman.cpp                      |  6 +-
 src/llmq/signing_shares.cpp                  | 12 +--
 src/llmq/snapshot.h                          | 13 +--
 src/llmq/utils.cpp                           | 20 ++---
 src/rpc/quorums.cpp                          |  3 +-
 src/rpc/rawtransaction.cpp                   | 12 +--
 src/test/block_reward_reallocation_tests.cpp | 16 ++--
 src/test/bls_tests.cpp                       |  9 +-
 src/test/llmq_dkg_tests.cpp                  |  6 +-
 src/util/irange.h                            | 89 --------------------
 src/util/ranges.h                            |  6 ++
 test/util/data/non-backported.txt            |  1 -
 29 files changed, 110 insertions(+), 188 deletions(-)
 delete mode 100644 src/util/irange.h

diff --git a/src/Makefile.am b/src/Makefile.am
index c28010aa5fff..f7cae4d1b627 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -399,7 +399,6 @@ BITCOIN_CORE_H = \
   util/golombrice.h \
   util/hasher.h \
   util/hash_type.h \
-  util/irange.h \
   util/asmap.h \
   util/getuniquepath.h \
   util/macros.h \
diff --git a/src/active/dkgsession.cpp b/src/active/dkgsession.cpp
index 15eb449ece7f..deea0a21be2a 100644
--- a/src/active/dkgsession.cpp
+++ b/src/active/dkgsession.cpp
@@ -12,6 +12,7 @@
 #include <llmq/options.h>
 #include <llmq/utils.h>
 #include <masternode/meta.h>
+#include <util/ranges.h>
 
 #include <chain.h>
 #include <deploymentstatus.h>
@@ -81,7 +82,7 @@ void ActiveDKGSession::SendContributions(CDKGPendingMessages& pendingMessages, P
     qc.contributions = std::make_shared<CBLSIESMultiRecipientObjects<CBLSSecretKey>>();
     qc.contributions->InitEncrypt(members.size());
 
-    for (const auto i : irange::range(members.size())) {
+    for (const auto i : util::irange(members.size())) {
         const auto& m = members[i];
         CBLSSecretKey skContrib = m_sk_contributions[i];
 
@@ -150,7 +151,7 @@ void ActiveDKGSession::VerifyPendingContributions()
         return;
     }
 
-    for (const auto i : irange::range(memberIndexes.size())) {
+    for (const auto i : util::irange(memberIndexes.size())) {
         if (!result[i]) {
             const auto& m = members[memberIndexes[i]];
             logger.Batch("invalid contribution from %s. will complain later", m->dmn->proTxHash.ToString());
@@ -267,7 +268,7 @@ void ActiveDKGSession::SendComplaint(CDKGPendingMessages& pendingMessages, PeerM
 
     int badCount = 0;
     int complaintCount = 0;
-    for (const auto i : irange::range(members.size())) {
+    for (const auto i : util::irange(members.size())) {
         const auto& m = members[i];
         if (m->bad || m->badConnection) {
             qc.badMembers[i] = true;
@@ -352,7 +353,7 @@ void ActiveDKGSession::SendJustification(CDKGPendingMessages& pendingMessages, P
     qj.proTxHash = myProTxHash;
     qj.contributions.reserve(forMembers.size());
 
-    for (const uint32_t i : irange::range(members.size())) {
+    for (const uint32_t i : util::irange(members.size())) {
         const auto& m = members[i];
         if (forMembers.count(m->dmn->proTxHash) == 0) {
             continue;
@@ -444,7 +445,7 @@ void ActiveDKGSession::SendCommitment(CDKGPendingMessages& pendingMessages, Peer
     qc.quorumHash = m_quorum_base_block_index->GetBlockHash();
     qc.proTxHash = myProTxHash;
 
-    for (const auto i : irange::range(members.size())) {
+    for (const auto i : util::irange(members.size())) {
         const auto& m = members[i];
         if (!m->bad) {
             qc.validMembers[i] = true;
diff --git a/src/active/quorums.cpp b/src/active/quorums.cpp
index 1c0fd54aa763..f528e139c0f2 100644
--- a/src/active/quorums.cpp
+++ b/src/active/quorums.cpp
@@ -14,6 +14,7 @@
 #include <llmq/quorums.h>
 #include <llmq/utils.h>
 #include <masternode/sync.h>
+#include <util/ranges.h>
 
 #include <chain.h>
 #include <chainparams.h>
@@ -100,7 +101,7 @@ size_t QuorumParticipant::GetQuorumRecoveryStartOffset(const CQuorum& quorum, gs
     size_t nIndex{0};
     {
         auto my_protx_hash = m_mn_activeman.GetProTxHash();
-        for (const auto i : irange::range(vecProTxHashes.size())) {
+        for (const auto i : util::irange(vecProTxHashes.size())) {
             // cppcheck-suppress useStlAlgorithm
             if (my_protx_hash == vecProTxHashes[i]) {
                 nIndex = i;
@@ -160,7 +161,7 @@ MessageProcessingResult QuorumParticipant::ProcessContribQDATA(CNode& pfrom, CDa
 
         std::vector<CBLSSecretKey> vecSecretKeys;
         vecSecretKeys.resize(vecEncrypted.size());
-        for (const auto i : irange::range(vecEncrypted.size())) {
+        for (const auto i : util::irange(vecEncrypted.size())) {
             if (!m_mn_activeman.Decrypt(vecEncrypted[i], memberIdx, vecSecretKeys[i], PROTOCOL_VERSION)) {
                 return MisbehavingError{10, "failed to decrypt"};
             }
diff --git a/src/bench/bls_dkg.cpp b/src/bench/bls_dkg.cpp
index 14e83810a100..be19cdb34978 100644
--- a/src/bench/bls_dkg.cpp
+++ b/src/bench/bls_dkg.cpp
@@ -3,9 +3,11 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <bench/bench.h>
+
 #include <bls/bls_worker.h>
+#include <util/ranges.h>
+
 #include <random.h>
-#include <util/irange.h>
 
 struct Member {
     CBLSId id;
@@ -45,7 +47,7 @@ class DKG
     void VerifyContributionShares(size_t whoAmI, const std::set<size_t>& invalidIndexes, bool aggregated)
     {
         auto result = blsWorker.VerifyContributionShares(members[whoAmI].id, receivedVvecs, receivedSkShares, aggregated);
-        for (const size_t i : irange::range(receivedVvecs.size())) {
+        for (const size_t i : util::irange(receivedVvecs.size())) {
             if (invalidIndexes.count(i)) {
                 assert(!result[i]);
             } else {
@@ -60,7 +62,7 @@ class DKG
         members.reserve(quorumSize);
         ids.reserve(quorumSize);
 
-        for (const int i : irange::range(quorumSize)) {
+        for (const int i : util::irange(quorumSize)) {
             uint256 id;
             WriteLE64(id.begin(), i + 1);
             members.push_back({CBLSId(id), {}, {}});
@@ -94,7 +96,7 @@ class DKG
             ReceiveShares(memberIdx);
 
             std::set<size_t> invalidIndexes;
-            for ([[maybe_unused]] const auto _ : irange::range(invalidCount)) {
+            for ([[maybe_unused]] const auto _ : util::irange(invalidCount)) {
                 size_t shareIdx = GetRand<size_t>(receivedSkShares.size());
                 receivedSkShares[shareIdx].MakeNewKey();
                 invalidIndexes.emplace(shareIdx);
@@ -117,7 +119,7 @@ static void BLSDKG_GenerateContributions(benchmark::Bench& bench, uint32_t epoch
         epoch_iters = 1;
         quorumSize = 1;
     }
-    for (const int i : irange::range(quorumSize)) {
+    for (const int i : util::irange(quorumSize)) {
         uint256 id;
         WriteLE64(id.begin(), i + 1);
         members.push_back({CBLSId(id), {}, {}});
diff --git a/src/coinjoin/client.cpp b/src/coinjoin/client.cpp
index 2eae460eaeee..38db0f3909ba 100644
--- a/src/coinjoin/client.cpp
+++ b/src/coinjoin/client.cpp
@@ -9,7 +9,7 @@
 #include <masternode/meta.h>
 #include <masternode/sync.h>
 #include <rpc/evo_util.h>
-#include <util/irange.h>
+#include <util/ranges.h>
 #include <wallet/coinjoin.h>
 
 #include <chain.h>
@@ -621,7 +621,7 @@ bool CCoinJoinClientSession::SignFinalTransaction(CNode& peer, CChainState& acti
             int nMyInputIndex = -1;
             CScript prevPubKey = CScript();
 
-            for (const auto i : irange::range(finalMutableTransaction.vin.size())) {
+            for (const auto i : util::irange(finalMutableTransaction.vin.size())) {
                 // cppcheck-suppress useStlAlgorithm
                 if (finalMutableTransaction.vin[i] == txdsin) {
                     nMyInputIndex = i;
@@ -1303,7 +1303,7 @@ bool CCoinJoinClientSession::SubmitDenominate(CConnman& connman)
 
     std::vector<std::pair<int, size_t> > vecInputsByRounds;
 
-    for (const auto i : irange::range(CCoinJoinClientOptions::GetRounds() + CCoinJoinClientOptions::GetRandomRounds())) {
+    for (const auto i : util::irange(CCoinJoinClientOptions::GetRounds() + CCoinJoinClientOptions::GetRandomRounds())) {
         if (PrepareDenominate(i, i, strError, vecTxDSIn, vecPSInOutPairsTmp, true)) {
             WalletCJLogPrint(m_wallet, "CCoinJoinClientSession::SubmitDenominate -- Running CoinJoin denominate for %d rounds, success\n", i);
             vecInputsByRounds.emplace_back(i, vecPSInOutPairsTmp.size());
@@ -1769,7 +1769,7 @@ bool CCoinJoinClientSession::CreateDenominated(CAmount nBalanceToDenominate, con
             WalletCJLogPrint(m_wallet, "CCoinJoinClientSession::%s -- 2 - nBalanceToDenominate: %f, nDenomValue: %f, denomsToCreateValue: %d, denomsToCreateBal: %d\n",
                                          __func__, (float) nBalanceToDenominate / COIN, (float) nDenomValue / COIN, denomsToCreateValue, denomsToCreateBal);
             auto it = mapDenomCount.find(nDenomValue);
-            for (const auto i : irange::range(denomsToCreate)) {
+            for (const auto i : util::irange(denomsToCreate)) {
                 // Never go above the cap unless it's the largest denom
                 if (nDenomValue != nLargestDenomValue && it->second >= CCoinJoinClientOptions::GetDenomsHardCap()) break;
 
diff --git a/src/evo/deterministicmns.cpp b/src/evo/deterministicmns.cpp
index f5bc33a2655b..5d63d4f9ae26 100644
--- a/src/evo/deterministicmns.cpp
+++ b/src/evo/deterministicmns.cpp
@@ -13,8 +13,8 @@
 #include <masternode/meta.h>
 #include <messagesigner.h>
 #include <stats/client.h>
-#include <util/irange.h>
 #include <util/pointer.h>
+#include <util/ranges.h>
 
 #include <chainparams.h>
 #include <coins.h>
@@ -244,7 +244,7 @@ std::vector<CDeterministicMNCPtr> CDeterministicMNList::GetProjectedMNPayees(gsl
                 // If the last payee is an EvoNode, we need to check its consecutive payments and pay him again if needed
                 if (dmn->nType == MnType::Evo && dmn->pdmnState->nConsecutivePayments < dmn_types::Evo.voting_weight) {
                     remaining_evo_payments = dmn_types::Evo.voting_weight - dmn->pdmnState->nConsecutivePayments;
-                    for ([[maybe_unused]] auto _ : irange::range(remaining_evo_payments)) {
+                    for ([[maybe_unused]] auto _ : util::irange(remaining_evo_payments)) {
                         result.emplace_back(dmn);
                         evo_to_be_skipped = dmn;
                     }
@@ -255,14 +255,14 @@ std::vector<CDeterministicMNCPtr> CDeterministicMNList::GetProjectedMNPayees(gsl
 
     ForEachMNShared(/*onlyValid=*/true, [&](const auto& dmn) {
         if (dmn == evo_to_be_skipped) return;
-        for ([[maybe_unused]] auto _ : irange::range(isMNRewardReallocation ? 1 : GetMnType(dmn->nType).voting_weight)) {
+        for ([[maybe_unused]] auto _ : util::irange(isMNRewardReallocation ? 1 : GetMnType(dmn->nType).voting_weight)) {
             result.emplace_back(dmn);
         }
     });
 
     if (evo_to_be_skipped != nullptr) {
         // if EvoNode is in the middle of payments, add entries for already paid ones to the end of the list
-        for ([[maybe_unused]] auto _ : irange::range(evo_to_be_skipped->pdmnState->nConsecutivePayments)) {
+        for ([[maybe_unused]] auto _ : util::irange(evo_to_be_skipped->pdmnState->nConsecutivePayments)) {
             result.emplace_back(evo_to_be_skipped);
         }
     }
diff --git a/src/evo/specialtxman.cpp b/src/evo/specialtxman.cpp
index 3cdb9e7e79d8..4c721b0f69bd 100644
--- a/src/evo/specialtxman.cpp
+++ b/src/evo/specialtxman.cpp
@@ -10,7 +10,6 @@
 #include <deploymentstatus.h>
 #include <hash.h>
 #include <primitives/block.h>
-#include <util/irange.h>
 #include <util/system.h>
 #include <validation.h>
 
diff --git a/src/instantsend/signing.cpp b/src/instantsend/signing.cpp
index 05e506614a37..e93007f01408 100644
--- a/src/instantsend/signing.cpp
+++ b/src/instantsend/signing.cpp
@@ -9,7 +9,7 @@
 #include <llmq/signing_shares.h>
 #include <masternode/sync.h>
 #include <spork.h>
-#include <util/irange.h>
+#include <util/ranges.h>
 
 #include <chain.h>
 #include <chainparams.h>
@@ -340,7 +340,7 @@ bool InstantSendSigner::TrySignInputLocks(const CTransaction& tx, bool fRetroact
     LogPrint(BCLog::INSTANTSEND, "%s -- txid=%s: trying to vote on %d inputs\n", __func__, tx.GetHash().ToString(),
              tx.vin.size());
 
-    for (const auto i : irange::range(tx.vin.size())) {
+    for (const auto i : util::irange(tx.vin.size())) {
         const auto& in = tx.vin[i];
         auto& id = ids[i];
         WITH_LOCK(cs_input_requests, inputRequestIds.emplace(id));
diff --git a/src/llmq/blockprocessor.cpp b/src/llmq/blockprocessor.cpp
index b6191b9d8013..984a7caf9e23 100644
--- a/src/llmq/blockprocessor.cpp
+++ b/src/llmq/blockprocessor.cpp
@@ -9,6 +9,7 @@
 #include <llmq/commitment.h>
 #include <llmq/options.h>
 #include <llmq/utils.h>
+#include <util/ranges.h>
 #include <util/std23.h>
 
 #include <chain.h>
@@ -22,7 +23,6 @@
 #include <primitives/transaction.h>
 #include <saltedhasher.h>
 #include <sync.h>
-#include <util/irange.h>
 #include <validation.h>
 
 #include <map>
@@ -475,7 +475,7 @@ size_t CQuorumBlockProcessor::GetNumCommitmentsRequired(const Consensus::LLMQPar
     size_t quorums_num = rotation_enabled ? llmqParams.signingActiveQuorumCount : 1;
     size_t ret{0};
 
-    for (const auto quorumIndex : irange::range(quorums_num)) {
+    for (const auto quorumIndex : util::irange(quorums_num)) {
         uint256 quorumHash = GetQuorumBlockHash(llmqParams, m_chainstate.m_chain, nHeight, quorumIndex);
         if (!quorumHash.IsNull() && !HasMinedCommitment(llmqParams.type, quorumHash)) ++ret;
     }
@@ -625,7 +625,7 @@ std::vector<const CBlockIndex*> CQuorumBlockProcessor::GetLastMinedCommitmentsPe
     assert(llmq_params_opt.has_value());
     std::vector<const CBlockIndex*> ret;
 
-    for (const auto quorumIndex : irange::range(llmq_params_opt->signingActiveQuorumCount)) {
+    for (const auto quorumIndex : util::irange(llmq_params_opt->signingActiveQuorumCount)) {
         std::optional<const CBlockIndex*> q = GetLastMinedCommitmentsByQuorumIndexUntilBlock(llmqType, pindex, quorumIndex, cycle);
         if (q.has_value()) {
             ret.emplace_back(q.value());
@@ -741,7 +741,7 @@ std::optional<std::vector<CFinalCommitment>> CQuorumBlockProcessor::GetMineableC
     size_t quorums_num = rotation_enabled ? llmqParams.signingActiveQuorumCount : 1;
 
     std::stringstream ss;
-    for (const auto quorumIndex : irange::range(quorums_num)) {
+    for (const auto quorumIndex : util::irange(quorums_num)) {
         CFinalCommitment cf;
 
         uint256 quorumHash = GetQuorumBlockHash(llmqParams, m_chainstate.m_chain, nHeight, quorumIndex);
diff --git a/src/llmq/commitment.cpp b/src/llmq/commitment.cpp
index e231e30861f4..41d5e6d01142 100644
--- a/src/llmq/commitment.cpp
+++ b/src/llmq/commitment.cpp
@@ -8,6 +8,7 @@
 #include <evo/specialtx.h>
 #include <llmq/options.h>
 #include <llmq/utils.h>
+#include <util/ranges.h>
 #include <util/std23.h>
 
 #include <chainparams.h>
@@ -60,7 +61,7 @@ bool CFinalCommitment::VerifySignatureAsync(const llmq::UtilParameters& util_par
         }
     } else {
         std::vector<CBLSPublicKey> memberPubKeys;
-        for (const auto i : irange::range(members.size())) {
+        for (const auto i : util::irange(members.size())) {
             if (!signers[i]) {
                 continue;
             }
@@ -156,7 +157,7 @@ bool CFinalCommitment::Verify(const llmq::UtilParameters& util_params, bool chec
     if (LogAcceptDebug(BCLog::LLMQ)) {
         std::stringstream ss;
         std::stringstream ss2;
-        for (const auto i: irange::range(llmq_params.size)) {
+        for (const auto i : util::irange(llmq_params.size)) {
             ss << "v[" << i << "]=" << validMembers[i];
             ss2 << "s[" << i << "]=" << signers[i];
         }
@@ -234,7 +235,7 @@ bool CheckLLMQCommitment(const llmq::UtilParameters& util_params, const CTransac
 
     if (LogAcceptDebug(BCLog::LLMQ)) {
         std::stringstream ss;
-        for (const auto i: irange::range(llmq_params_opt->size)) {
+        for (const auto i : util::irange(llmq_params_opt->size)) {
             ss << "v[" << i << "]=" << qcTx.commitment.validMembers[i];
         }
         LogPrint(BCLog::LLMQ, "CFinalCommitment -- %s llmqType[%d] validMembers[%s] signers[]\n", __func__,
diff --git a/src/llmq/commitment.h b/src/llmq/commitment.h
index 92df37fd56c9..d4da16f60b53 100644
--- a/src/llmq/commitment.h
+++ b/src/llmq/commitment.h
@@ -8,7 +8,7 @@
 #include <bls/bls.h>
 #include <llmq/params.h>
 #include <llmq/types.h>
-#include <util/irange.h>
+#include <util/ranges.h>
 #include <util/std23.h>
 
 #include <primitives/transaction.h>
@@ -137,7 +137,7 @@ class CFinalCommitment
     static std::string BitsVectorToHexStr(const std::vector<bool>& vBits)
     {
         std::vector<uint8_t> vBytes((vBits.size() + 7) / 8);
-        for (const auto i : irange::range(vBits.size())) {
+        for (const auto i : util::irange(vBits.size())) {
             vBytes[i / 8] |= vBits[i] << (i % 8);
         }
         return HexStr(vBytes);
diff --git a/src/llmq/debug.cpp b/src/llmq/debug.cpp
index 93a0a8d7c986..a91b78e6d75a 100644
--- a/src/llmq/debug.cpp
+++ b/src/llmq/debug.cpp
@@ -6,7 +6,7 @@
 
 #include <evo/deterministicmns.h>
 #include <llmq/utils.h>
-#include <util/irange.h>
+#include <util/ranges.h>
 #include <util/std23.h>
 
 #include <chainparams.h>
@@ -80,7 +80,7 @@ UniValue CDKGDebugSessionStatus::ToJson(CDeterministicMNManager& dmnman, CQuorum
         }
     };
 
-    for (const auto i : irange::range(members.size())) {
+    for (const auto i : util::irange(members.size())) {
         const auto& m = members[i];
         add(badMembers, i, m.statusBits.bad);
         add(weComplain, i, m.statusBits.weComplain);
diff --git a/src/llmq/dkgsession.cpp b/src/llmq/dkgsession.cpp
index e956b0a076cb..4c8f661e7866 100644
--- a/src/llmq/dkgsession.cpp
+++ b/src/llmq/dkgsession.cpp
@@ -12,7 +12,7 @@
 #include <llmq/options.h>
 #include <llmq/utils.h>
 #include <masternode/meta.h>
-#include <util/irange.h>
+#include <util/ranges.h>
 #include <util/std23.h>
 
 #include <chainparams.h>
@@ -95,14 +95,14 @@ bool CDKGSession::Init(const uint256& _myProTxHash, int _quorumIndex)
     receivedSkContributions.resize(members.size());
     vecEncryptedContributions.resize(members.size());
 
-    for (const auto i : irange::range(mns.size())) {
+    for (const auto i : util::irange(mns.size())) {
         members[i] = std::make_unique<CDKGMember>(mns[i], i);
         membersMap.emplace(members[i]->dmn->proTxHash, i);
         memberIds[i] = members[i]->id;
     }
 
     if (!_myProTxHash.IsNull()) {
-        for (const auto i : irange::range(members.size())) {
+        for (const auto i : util::irange(members.size())) {
             const auto& m = members[i];
             if (m->dmn->proTxHash == _myProTxHash) {
                 myIdx = i;
@@ -358,7 +358,7 @@ std::optional<CInv> CDKGSession::ReceiveMessage(const CDKGComplaint& qc)
     }
 
     int receivedCount = 0;
-    for (const auto i : irange::range(members.size())) {
+    for (const auto i : util::irange(members.size())) {
         const auto& m = members[i];
         if (qc.badMembers[i]) {
             logger.Batch("%s voted for %s to be bad", member->dmn->proTxHash.ToString(), m->dmn->proTxHash.ToString());
diff --git a/src/llmq/dkgsessionmgr.cpp b/src/llmq/dkgsessionmgr.cpp
index 6bae171b84ed..ed98ee9c23c9 100644
--- a/src/llmq/dkgsessionmgr.cpp
+++ b/src/llmq/dkgsessionmgr.cpp
@@ -11,7 +11,7 @@
 #include <llmq/utils.h>
 #include <spork.h>
 #include <unordered_lru_cache.h>
-#include <util/irange.h>
+#include <util/ranges.h>
 #include <util/std23.h>
 
 #include <chainparams.h>
@@ -286,7 +286,7 @@ bool CDKGSessionManager::GetVerifiedContributions(Consensus::LLMQType llmqType,
 
     // NOTE: the `cs_main` should not be locked under scope of `contributionsCacheCs`
     LOCK(contributionsCacheCs);
-    for (const auto i : irange::range(members.size())) {
+    for (const auto i : util::irange(members.size())) {
         if (validMembers[i]) {
             const uint256& proTxHash = members[i]->proTxHash;
             ContributionsCacheKey cacheKey = {llmqType, pQuorumBaseBlockIndex->GetBlockHash(), proTxHash};
@@ -302,7 +302,7 @@ bool CDKGSessionManager::GetVerifiedContributions(Consensus::LLMQType llmqType,
                 size_t vvec_size = ReadCompactSize(s);
                 CBLSPublicKey pubkey;
                 std::vector<CBLSPublicKey> qv;
-                for ([[maybe_unused]] size_t _ : irange::range(vvec_size)) {
+                for ([[maybe_unused]] size_t _ : util::irange(vvec_size)) {
                     s >> CBLSPublicKeyVersionWrapper(pubkey, false);
                     qv.emplace_back(pubkey);
                 }
@@ -330,7 +330,7 @@ bool CDKGSessionManager::GetEncryptedContributions(Consensus::LLMQType llmqType,
     vecRet.reserve(members.size());
 
     size_t nRequestedMemberIdx{std::numeric_limits<size_t>::max()};
-    for (const auto i : irange::range(members.size())) {
+    for (const auto i : util::irange(members.size())) {
         // cppcheck-suppress useStlAlgorithm
         if (members[i]->proTxHash == nProTxHash) {
             nRequestedMemberIdx = i;
@@ -342,7 +342,7 @@ bool CDKGSessionManager::GetEncryptedContributions(Consensus::LLMQType llmqType,
         return false;
     }
 
-    for (const auto i : irange::range(members.size())) {
+    for (const auto i : util::irange(members.size())) {
         if (validMembers[i]) {
             CBLSIESMultiRecipientObjects<CBLSSecretKey> encryptedContributions;
             if (!db->Read(std::make_tuple(DB_ENC_CONTRIB, llmqType, pQuorumBaseBlockIndex->GetBlockHash(), members[i]->proTxHash), encryptedContributions)) {
diff --git a/src/llmq/dkgsessionmgr.h b/src/llmq/dkgsessionmgr.h
index 56a13e7be285..4c92ad32e238 100644
--- a/src/llmq/dkgsessionmgr.h
+++ b/src/llmq/dkgsessionmgr.h
@@ -9,7 +9,7 @@
 #include <bls/bls_worker.h>
 #include <llmq/dkgsessionhandler.h>
 #include <msg_result.h>
-#include <util/irange.h>
+#include <util/ranges.h>
 
 #include <net_types.h>
 
@@ -105,7 +105,7 @@ class CDKGSessionManager
         const Consensus::Params& consensus_params = Params().GetConsensus();
         for (const auto& params : consensus_params.llmqs) {
             auto session_count = (params.useRotation) ? params.signingActiveQuorumCount : 1;
-            for (const auto i : irange::range(session_count)) {
+            for (const auto i : util::irange(session_count)) {
                 dkgSessionHandlers.emplace(SessionHandlerKey{params.type, i}, handler_fn(params, i));
             }
         }
diff --git a/src/llmq/observer/quorums.cpp b/src/llmq/observer/quorums.cpp
index a9baad814f59..ffb073d67005 100644
--- a/src/llmq/observer/quorums.cpp
+++ b/src/llmq/observer/quorums.cpp
@@ -12,6 +12,7 @@
 #include <masternode/sync.h>
 #include <msg_result.h>
 #include <unordered_lru_cache.h>
+#include <util/ranges.h>
 
 #include <chain.h>
 #include <chainparams.h>
@@ -85,7 +86,7 @@ Uint256HashSet QuorumObserver::GetQuorumsToDelete(const Consensus::LLMQParams& l
         int cycleIndexTipHeight = pindexNew->nHeight % llmqParams.dkgInterval;
         int cycleQuorumBaseHeight = pindexNew->nHeight - cycleIndexTipHeight;
         std::stringstream ss;
-        for (const auto quorumIndex : irange::range(llmqParams.signingActiveQuorumCount)) {
+        for (const auto quorumIndex : util::irange(llmqParams.signingActiveQuorumCount)) {
             if (quorumIndex <= cycleIndexTipHeight) {
                 int curDkgHeight = cycleQuorumBaseHeight + quorumIndex;
                 auto curDkgBlock = pindexNew->GetAncestor(curDkgHeight)->GetBlockHash();
diff --git a/src/llmq/quorums.cpp b/src/llmq/quorums.cpp
index b0b657813702..50f53ab00cac 100644
--- a/src/llmq/quorums.cpp
+++ b/src/llmq/quorums.cpp
@@ -6,6 +6,7 @@
 
 #include <evo/deterministicmns.h>
 #include <llmq/commitment.h>
+#include <util/ranges.h>
 
 #include <dbwrapper.h>
 
@@ -140,7 +141,7 @@ bool CQuorum::IsMember(const uint256& proTxHash) const
 
 bool CQuorum::IsValidMember(const uint256& proTxHash) const
 {
-    for (const auto i : irange::range(members.size())) {
+    for (const auto i : util::irange(members.size())) {
         // cppcheck-suppress useStlAlgorithm
         if (members[i]->proTxHash == proTxHash) {
             return qc->validMembers[i];
@@ -177,7 +178,7 @@ CBLSSecretKey CQuorum::GetSkShare() const
 
 int CQuorum::GetMemberIndex(const uint256& proTxHash) const
 {
-    for (const auto i : irange::range(members.size())) {
+    for (const auto i : util::irange(members.size())) {
         // cppcheck-suppress useStlAlgorithm
         if (members[i]->proTxHash == proTxHash) {
             return int(i);
@@ -216,7 +217,7 @@ bool CQuorum::ReadContributions(const CDBWrapper& db)
     size_t vvec_size = ReadCompactSize(s);
     CBLSPublicKey pubkey;
     std::vector<CBLSPublicKey> qv;
-    for ([[maybe_unused]] size_t _ : irange::range(vvec_size)) {
+    for ([[maybe_unused]] size_t _ : util::irange(vvec_size)) {
         s >> CBLSPublicKeyVersionWrapper(pubkey, false);
         qv.emplace_back(pubkey);
     }
diff --git a/src/llmq/quorumsman.cpp b/src/llmq/quorumsman.cpp
index ca376ef2512b..f3c66093fc99 100644
--- a/src/llmq/quorumsman.cpp
+++ b/src/llmq/quorumsman.cpp
@@ -15,7 +15,7 @@
 #include <llmq/params.h>
 #include <llmq/signhash.h>
 #include <llmq/utils.h>
-#include <util/irange.h>
+#include <util/ranges.h>
 #include <util/std23.h>
 
 #include <chainparams.h>
@@ -587,7 +587,7 @@ void CQuorumManager::CacheWarmingThreadMain() const
                  pQuorum->m_quorum_base_block_index->GetBlockHash().ToString());
 
         // when then later some other thread tries to get keys, it will be much faster
-        for (const auto i : irange::range(pQuorum->members.size())) {
+        for (const auto i : util::irange(pQuorum->members.size())) {
             if (m_cache_interrupt) {
                 break;
             }
@@ -723,7 +723,7 @@ CQuorumCPtr SelectQuorumForSigning(const Consensus::LLMQParams& llmq_params, con
 
         std::vector<std::pair<uint256, size_t>> scores;
         scores.reserve(quorums.size());
-        for (const auto i : irange::range(quorums.size())) {
+        for (const auto i : util::irange(quorums.size())) {
             CHashWriter h(SER_NETWORK, 0);
             h << llmq_params.type;
             h << quorums[i]->qc->quorumHash;
diff --git a/src/llmq/signing_shares.cpp b/src/llmq/signing_shares.cpp
index 66cbb8e97ec2..61c918223803 100644
--- a/src/llmq/signing_shares.cpp
+++ b/src/llmq/signing_shares.cpp
@@ -13,7 +13,7 @@
 #include <llmq/signhash.h>
 #include <llmq/signing.h>
 #include <spork.h>
-#include <util/irange.h>
+#include <util/ranges.h>
 #include <util/std23.h>
 
 #include <chainparams.h>
@@ -43,7 +43,7 @@ std::string CSigSesAnn::ToString() const
 
 void CSigSharesInv::Merge(const CSigSharesInv& inv2)
 {
-    for (const auto i : irange::range(inv.size())) {
+    for (const auto i : util::irange(inv.size())) {
         if (inv2.inv[i]) {
             inv[i] = inv2.inv[i];
         }
@@ -59,7 +59,7 @@ std::string CSigSharesInv::ToString() const
 {
     std::string str = "(";
     bool first = true;
-    for (const auto i : irange::range(inv.size())) {
+    for (const auto i : util::irange(inv.size())) {
         if (!inv[i]) {
             continue;
         }
@@ -1054,7 +1054,7 @@ void CSigSharesManager::CollectSigSharesToRequest(std::unordered_map<NodeId, Uin
                 continue;
             }
 
-            for (const auto i : irange::range(session.announced.inv.size())) {
+            for (const auto i : util::irange(session.announced.inv.size())) {
                 if (!session.announced.inv[i]) {
                     continue;
                 }
@@ -1127,7 +1127,7 @@ void CSigSharesManager::CollectSigSharesToSend(std::unordered_map<NodeId, Uint25
 
             CBatchedSigShares batchedSigShares;
 
-            for (const auto i : irange::range(session.requested.inv.size())) {
+            for (const auto i : util::irange(session.requested.inv.size())) {
                 if (!session.requested.inv[i]) {
                     continue;
                 }
@@ -1516,7 +1516,7 @@ void CSigSharesManager::Cleanup()
                 if (LogAcceptDebug(BCLog::LLMQ_SIGS)) {
                     if (const auto quorumIt = quorums.find(std::make_pair(oneSigShare.getLlmqType(), oneSigShare.getQuorumHash())); quorumIt != quorums.end()) {
                         const auto& quorum = quorumIt->second;
-                        for (const auto i : irange::range(quorum->members.size())) {
+                        for (const auto i : util::irange(quorum->members.size())) {
                             if (m->count((uint16_t)i) == 0) {
                                 const auto& dmn = quorum->members[i];
                                 strMissingMembers += strprintf("\n  %s", dmn->proTxHash.ToString());
diff --git a/src/llmq/snapshot.h b/src/llmq/snapshot.h
index d85758dd84df..1a63beeba1de 100644
--- a/src/llmq/snapshot.h
+++ b/src/llmq/snapshot.h
@@ -8,12 +8,13 @@
 #include <evo/smldiff.h>
 #include <llmq/commitment.h>
 #include <llmq/params.h>
+#include <unordered_lru_cache.h>
+#include <util/ranges.h>
+
 #include <saltedhasher.h>
 #include <serialize.h>
 #include <sync.h>
 #include <threadsafety.h>
-#include <unordered_lru_cache.h>
-#include <util/irange.h>
 
 #include <optional>
 
@@ -77,7 +78,7 @@ class CQuorumSnapshot
         size_t cnt = ReadCompactSize(s);
         ReadFixedBitSet(s, activeQuorumMembers, cnt);
         cnt = ReadCompactSize(s);
-        for ([[maybe_unused]] const auto _ : irange::range(cnt)) {
+        for ([[maybe_unused]] const auto _ : util::irange(cnt)) {
             int obj;
             s >> obj;
             mnSkipList.push_back(obj);
@@ -184,21 +185,21 @@ class CQuorumRotationInfo
         }
 
         size_t cnt = ReadCompactSize(s);
-        for ([[maybe_unused]] const auto _ : irange::range(cnt)) {
+        for ([[maybe_unused]] const auto _ : util::irange(cnt)) {
             CFinalCommitment qc;
             ::Unserialize(s, qc);
             lastCommitmentPerIndex.push_back(std::move(qc));
         }
 
         cnt = ReadCompactSize(s);
-        for ([[maybe_unused]] const auto _ : irange::range(cnt)) {
+        for ([[maybe_unused]] const auto _ : util::irange(cnt)) {
             CQuorumSnapshot snap;
             ::Unserialize(s, snap);
             quorumSnapshotList.push_back(std::move(snap));
         }
 
         cnt = ReadCompactSize(s);
-        for ([[maybe_unused]] const auto _ : irange::range(cnt)) {
+        for ([[maybe_unused]] const auto _ : util::irange(cnt)) {
             CSimplifiedMNListDiff mnlist;
             ::Unserialize(s, mnlist);
             mnListDiffList.push_back(std::move(mnlist));
diff --git a/src/llmq/utils.cpp b/src/llmq/utils.cpp
index c009ad3b995c..1e382fc169cc 100644
--- a/src/llmq/utils.cpp
+++ b/src/llmq/utils.cpp
@@ -10,7 +10,7 @@
 #include <llmq/snapshot.h>
 #include <llmq/types.h>
 #include <masternode/meta.h>
-#include <util/irange.h>
+#include <util/ranges.h>
 #include <util/std23.h>
 
 #include <chainparams.h>
@@ -236,7 +236,7 @@ std::vector<QuorumMembers> GetQuorumQuarterMembersBySnapshot(const Consensus::LL
     switch (snapshot.mnSkipListMode) {
     case SnapshotSkipMode::MODE_NO_SKIPPING: {
         auto itm = sortedCombinedMns.begin();
-        for (const size_t i : irange::range(numQuorums)) {
+        for (const size_t i : util::irange(numQuorums)) {
             while (quarterQuorumMembers[i].size() < quarterSize) {
                 quarterQuorumMembers[i].push_back(*itm);
                 itm++;
@@ -262,7 +262,7 @@ std::vector<QuorumMembers> GetQuorumQuarterMembersBySnapshot(const Consensus::LL
 
         int idx = 0;
         auto itsk = processesdSkipList.begin();
-        for (const size_t i : irange::range(numQuorums)) {
+        for (const size_t i : util::irange(numQuorums)) {
             while (quarterQuorumMembers[i].size() < quarterSize) {
                 if (itsk != processesdSkipList.end() && idx == *itsk) {
                     itsk++;
@@ -363,7 +363,7 @@ std::vector<QuorumMembers> BuildNewQuorumQuarterMembers(const Consensus::LLMQPar
                                                 Consensus::DEPLOYMENT_V19) ||
                           (util_params.m_chainman.GetParams().NetworkIDString() == CBaseChainParams::TESTNET);
 
-    for (const size_t idx : irange::range(nQuorums)) {
+    for (const size_t idx : util::irange(nQuorums)) {
         for (auto* prev_cycle : previousQuarters.GetCycles()) {
             for (const auto& mn : prev_cycle->m_members[idx]) {
                 if (skipRemovedMNs && !allMns.HasMN(mn->proTxHash)) {
@@ -407,7 +407,7 @@ std::vector<QuorumMembers> BuildNewQuorumQuarterMembers(const Consensus::LLMQPar
     std::vector<int> skipList;
     size_t firstSkippedIndex = 0;
     size_t idx{0};
-    for (const size_t i : irange::range(nQuorums)) {
+    for (const size_t i : util::irange(nQuorums)) {
         auto usedMNsCount = MnsUsedAtHIndexed[i].GetAllMNsCount();
         bool updated{false};
         size_t initial_loop_idx = idx;
@@ -495,7 +495,7 @@ std::vector<QuorumMembers> ComputeQuorumMembersByQuarterRotation(const Consensus
     // assert (!newQuarterMembers.empty());
 
     if (LogAcceptDebug(BCLog::LLMQ)) {
-        for (const size_t i : irange::range(nQuorums)) {
+        for (const size_t i : util::irange(nQuorums)) {
             std::stringstream ss;
             for (size_t idx = prev_cycles.size(); idx-- > 0;) {
                 ss << strprintf(" %dCmns[%s]", idx, ToString(prev_cycles[idx]->m_members[i]));
@@ -506,7 +506,7 @@ std::vector<QuorumMembers> ComputeQuorumMembersByQuarterRotation(const Consensus
     }
 
     std::vector<QuorumMembers> quorumMembers(nQuorums);
-    for (const size_t i : irange::range(nQuorums)) {
+    for (const size_t i : util::irange(nQuorums)) {
         // Move elements from previous quarters into quorumMembers
         for (auto* prev_cycle : prev_cycles | std::views::reverse) {
             std::move(prev_cycle->m_members[i].begin(), prev_cycle->m_members[i].end(),
@@ -632,7 +632,7 @@ QuorumMembers GetAllQuorumMembers(Consensus::LLMQType llmqType, const UtilParame
         quorumMembers = q[quorumIndex];
 
         LOCK(cs_indexed_members);
-        for (const size_t i : irange::range(q.size())) {
+        for (const size_t i : util::irange(q.size())) {
             mapIndexedQuorumMembers[llmqType].emplace(std::make_pair(pCycleQuorumBaseBlockIndex->GetBlockHash(), i),
                                                       std::move(q[i]));
         }
@@ -738,7 +738,7 @@ Uint256HashSet GetQuorumRelayMembers(const Consensus::LLMQParams& llmqParams, co
         return r;
     };
 
-    for (const auto i : irange::range(mns.size())) {
+    for (const auto i : util::irange(mns.size())) {
         const auto& dmn = mns[i];
         if (dmn->proTxHash == forMember) {
             auto r = calcOutbound(i, dmn->proTxHash);
@@ -768,7 +768,7 @@ std::set<size_t> CalcDeterministicWatchConnections(Consensus::LLMQType llmqType,
 
     std::set<size_t> result;
     uint256 rnd = qwatchConnectionSeed;
-    for ([[maybe_unused]] const auto _ : irange::range(connectionCount)) {
+    for ([[maybe_unused]] const auto _ : util::irange(connectionCount)) {
         rnd = ::SerializeHash(std::make_pair(rnd, std::make_pair(llmqType, pQuorumBaseBlockIndex->GetBlockHash())));
         result.emplace(rnd.GetUint64(0) % memberCount);
     }
diff --git a/src/rpc/quorums.cpp b/src/rpc/quorums.cpp
index f82ec32def8d..f50d723c0c8f 100644
--- a/src/rpc/quorums.cpp
+++ b/src/rpc/quorums.cpp
@@ -20,6 +20,7 @@
 #include <llmq/snapshot.h>
 #include <llmq/utils.h>
 #include <rpc/evo_util.h>
+#include <util/ranges.h>
 
 #include <chainparams.h>
 #include <deploymentstatus.h>
@@ -367,7 +368,7 @@ static RPCHelpMan quorum_dkgstatus()
         bool rotation_enabled = llmq::IsQuorumRotationEnabled(llmq_params, pindexTip);
         int quorums_num = rotation_enabled ? llmq_params.signingActiveQuorumCount : 1;
 
-        for (const int quorumIndex : irange::range(quorums_num)) {
+        for (const int quorumIndex : util::irange(quorums_num)) {
             UniValue obj(UniValue::VOBJ);
             obj.pushKV("llmqType", std::string(llmq_params.name));
             obj.pushKV("quorumIndex", quorumIndex);
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index 5db203c01832..0c37567b5e15 100644
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -57,7 +57,7 @@
 #include <llmq/commitment.h>
 #include <llmq/context.h>
 #include <rpc/index_util.h>
-#include <util/irange.h>
+#include <util/ranges.h>
 
 #include <cstdint>
 #include <numeric>
@@ -404,7 +404,7 @@ static RPCHelpMan getrawtransactionmulti() {
 
         const CBlockIndex* blockindex{blockhash.IsNull() ? nullptr : WITH_LOCK(::cs_main, return chainman.m_blockman.LookupBlockIndex(blockhash))};
         if (blockindex == nullptr && !blockhash.IsNull()) {
-            for (const auto idx : irange::range(txids.size())) {
+            for (const auto idx : util::irange(txids.size())) {
                 result.pushKV(txids[idx].get_str(), "None");
             }
             continue;
@@ -414,7 +414,7 @@ static RPCHelpMan getrawtransactionmulti() {
         if (count > 100) {
             throw JSONRPCError(RPC_INVALID_PARAMETER, "Up to 100 txids in total");
         }
-        for (const auto idx : irange::range(txids.size())) {
+        for (const auto idx : util::irange(txids.size())) {
             const std::string txid_str = txids[idx].get_str();
             const uint256 txid = ParseHashV(txid_str, "transaction id");
 
@@ -485,7 +485,7 @@ static RPCHelpMan getislocks()
     }
 
     const LLMQContext& llmq_ctx = EnsureLLMQContext(node);
-    for (const auto idx : irange::range(txids.size())) {
+    for (const auto idx : util::irange(txids.size())) {
         const uint256 txid(ParseHashV(txids[idx], "txid"));
 
         if (const instantsend::InstantSendLockPtr islock = llmq_ctx.isman->GetInstantSendLockByTxid(txid); islock != nullptr) {
@@ -562,7 +562,7 @@ static RPCHelpMan gettxchainlocks()
         g_txindex->BlockUntilSyncedToCurrentChain();
     }
 
-    for (const auto idx : irange::range(txids.size())) {
+    for (const auto idx : util::irange(txids.size())) {
         UniValue result(UniValue::VOBJ);
         const uint256 txid(ParseHashV(txids[idx], "txid"));
         if (txid == Params().GenesisBlock().hashMerkleRoot) {
@@ -693,7 +693,7 @@ static RPCHelpMan getassetunlockstatuses()
         }();
     }
 
-    for (const auto i : irange::range(str_indexes.size())) {
+    for (const auto i : util::irange(str_indexes.size())) {
         UniValue obj(UniValue::VOBJ);
         uint64_t index{};
         if (!ParseUInt64(str_indexes[i].get_str(), &index)) {
diff --git a/src/test/block_reward_reallocation_tests.cpp b/src/test/block_reward_reallocation_tests.cpp
index 6eb8dfd2f777..6ab54912fe2d 100644
--- a/src/test/block_reward_reallocation_tests.cpp
+++ b/src/test/block_reward_reallocation_tests.cpp
@@ -9,7 +9,7 @@
 #include <evo/providertx.h>
 #include <evo/specialtx.h>
 #include <masternode/payments.h>
-#include <util/irange.h>
+#include <util/ranges.h>
 #include <util/std23.h>
 
 #include <chainparams.h>
@@ -186,7 +186,7 @@ BOOST_FIXTURE_TEST_CASE(block_reward_reallocation, TestChainBRRBeforeActivationS
         // Creating blocks by different ways
         const auto pblocktemplate = BlockAssembler(m_node.chainman->ActiveChainstate(), m_node, m_node.mempool.get(), Params()).CreateNewBlock(coinbasePubKey);
     }
-    for ([[maybe_unused]] auto _ : irange::range(499)) {
+    for ([[maybe_unused]] auto _ : util::irange(499)) {
         CreateAndProcessBlock({}, coinbasePubKey);
         LOCK(cs_main);
         dmnman.UpdatedBlockTip(m_node.chainman->ActiveChain().Tip());
@@ -218,7 +218,7 @@ BOOST_FIXTURE_TEST_CASE(block_reward_reallocation, TestChainBRRBeforeActivationS
         BOOST_CHECK_EQUAL(pblocktemplate->voutMasternodePayments[0].nValue, masternode_payment);
     }
 
-    for ([[maybe_unused]] auto _ : irange::range(consensus_params.nSuperblockCycle - 1)) {
+    for ([[maybe_unused]] auto _ : util::irange(consensus_params.nSuperblockCycle - 1)) {
         CreateAndProcessBlock({}, coinbasePubKey);
     }
 
@@ -235,9 +235,9 @@ BOOST_FIXTURE_TEST_CASE(block_reward_reallocation, TestChainBRRBeforeActivationS
     }
 
     // Reallocation should kick-in with the superblock after 19 adjustments, 3 superblocks long each
-    for ([[maybe_unused]] auto i : irange::range(19)) {
-        for ([[maybe_unused]] auto j : irange::range(3)) {
-            for ([[maybe_unused]] auto k : irange::range(consensus_params.nSuperblockCycle)) {
+    for ([[maybe_unused]] auto i : util::irange(19)) {
+        for ([[maybe_unused]] auto j : util::irange(3)) {
+            for ([[maybe_unused]] auto k : util::irange(consensus_params.nSuperblockCycle)) {
                 CreateAndProcessBlock({}, coinbasePubKey);
             }
             LOCK(cs_main);
@@ -273,8 +273,8 @@ BOOST_FIXTURE_TEST_CASE(block_reward_reallocation, TestChainBRRBeforeActivationS
 
     // Reward split should stay ~75/25 after reallocation is done,
     // check 10 next superblocks
-    for ([[maybe_unused]] auto i : irange::range(10)) {
-        for ([[maybe_unused]] auto k : irange::range(consensus_params.nSuperblockCycle)) {
+    for ([[maybe_unused]] auto i : util::irange(10)) {
+        for ([[maybe_unused]] auto k : util::irange(consensus_params.nSuperblockCycle)) {
             CreateAndProcessBlock({}, coinbasePubKey);
         }
         LOCK(cs_main);
diff --git a/src/test/bls_tests.cpp b/src/test/bls_tests.cpp
index 008b245953c8..9c57f8a3e431 100644
--- a/src/test/bls_tests.cpp
+++ b/src/test/bls_tests.cpp
@@ -4,10 +4,11 @@
 
 #include <bls/bls.h>
 #include <bls/bls_batchverifier.h>
+#include <util/ranges.h>
+
 #include <clientversion.h>
 #include <random.h>
 #include <streams.h>
-#include <util/irange.h>
 #include <util/strencodings.h>
 
 #include <boost/test/unit_test.hpp>
@@ -374,7 +375,7 @@ void FuncThresholdSignature(const bool legacy_scheme)
 
     std::vector<CBLSSecretKey> v_threshold_sks;
     std::vector<CBLSPublicKey> v_threshold_pks;
-    for ([[maybe_unused]] const auto i : irange::range(m_threshold)) {
+    for ([[maybe_unused]] const auto i : util::irange(m_threshold)) {
         CBLSSecretKey sk;
         sk.MakeNewKey();
         v_threshold_sks.push_back(sk);
@@ -388,7 +389,7 @@ void FuncThresholdSignature(const bool legacy_scheme)
     std::vector<CBLSId> v_size_ids;
     std::vector<CBLSSecretKey> v_size_sk_shares;
     std::vector<CBLSPublicKey> v_size_pk_shares;
-    for ([[maybe_unused]] const auto m_shares : irange::range(m_size)) {
+    for ([[maybe_unused]] const auto m_shares : util::irange(m_size)) {
         v_size_ids.emplace_back(GetRandHash());
         CBLSSecretKey sk;
         BOOST_CHECK(sk.SecretKeyShare(v_threshold_sks, v_size_ids[m_shares]));
@@ -399,7 +400,7 @@ void FuncThresholdSignature(const bool legacy_scheme)
 
         std::vector<CBLSSignature> v_share_sigs;
         std::vector<CBLSId> v_share_ids;
-        for ([[maybe_unused]] const auto j : irange::range(m_shares)) {
+        for ([[maybe_unused]] const auto j : util::irange(m_shares)) {
             v_share_sigs.emplace_back(v_size_sk_shares[j].Sign(hash, legacy_scheme));
             BOOST_CHECK(v_share_sigs.back().VerifyInsecure(v_size_pk_shares[j], hash));
             v_share_ids.push_back(v_size_ids[j]);
diff --git a/src/test/llmq_dkg_tests.cpp b/src/test/llmq_dkg_tests.cpp
index ee136df34f0e..33ef378bc5c8 100644
--- a/src/test/llmq_dkg_tests.cpp
+++ b/src/test/llmq_dkg_tests.cpp
@@ -3,7 +3,7 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <llmq/dkgsession.h>
-#include <util/irange.h>
+#include <util/ranges.h>
 #include <util/std23.h>
 
 #include <boost/test/unit_test.hpp>
@@ -13,7 +13,7 @@ BOOST_AUTO_TEST_SUITE(llmq_dkg_tests)
 BOOST_AUTO_TEST_CASE(llmq_dkgerror)
 {
     using namespace llmq;
-    for (auto i : irange::range(std23::to_underlying(llmq::DKGError::type::_COUNT))) {
+    for (auto i : util::irange(std23::to_underlying(llmq::DKGError::type::_COUNT))) {
         BOOST_REQUIRE(GetSimulatedErrorRate(llmq::DKGError::type(i)) == 0.0);
         SetSimulatedDKGErrorRate(llmq::DKGError::type(i), 1.0);
         BOOST_REQUIRE(GetSimulatedErrorRate(llmq::DKGError::type(i)) == 1.0);
@@ -23,6 +23,4 @@ BOOST_AUTO_TEST_CASE(llmq_dkgerror)
     BOOST_REQUIRE(GetSimulatedErrorRate(llmq::DKGError::type::_COUNT) == 0.0);
 }
 
-
-
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/util/irange.h b/src/util/irange.h
deleted file mode 100644
index f450dd83dfd9..000000000000
--- a/src/util/irange.h
+++ /dev/null
@@ -1,89 +0,0 @@
-// Copyright (c) 2021-2022 The Dash Core developers
-// Distributed under the MIT software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-// Original implementation here: https://github.com/whoshuu/cpp_range/blob/cd6897e40176c3031ad1e4c8069d672b2e544996/include/range.h under MIT software license
-
-#ifndef BITCOIN_UTIL_IRANGE_H
-#define BITCOIN_UTIL_IRANGE_H
-
-#include <iterator>
-#include <stdexcept>
-
-namespace irange {
-namespace detail {
-
-template <typename T>
-class Range {
-    // T must be an integral type
-    static_assert(std::is_integral<T>());
-
-public:
-    Range(const T start, const T stop, const T step) : start_{start}, stop_{stop}, step_{step} {
-        if (step_ == 0) {
-            throw std::invalid_argument("Range step argument must not be zero");
-        } else {
-            if ((start_ > stop_ && step_ > 0) || (start_ < stop_ && step_ < 0)) {
-                throw std::invalid_argument("Range arguments must result in termination");
-            }
-        }
-    }
-
-    class iterator {
-    public:
-        typedef std::forward_iterator_tag iterator_category;
-        typedef T value_type;
-        typedef T& reference;
-        typedef T* pointer;
-
-        iterator(value_type value, value_type step, value_type boundary) : value_{value}, step_{step},
-                                                                           boundary_{boundary},
-                                                                           positive_step_(step_ > 0) {}
-        iterator operator++() { value_ += step_; return *this; }
-        reference operator*() { return value_; }
-        pointer operator->() { return &value_; }
-        bool operator==(const iterator& rhs) const { return positive_step_ ? (value_ >= rhs.value_ && value_ > boundary_)
-                                                                           : (value_ <= rhs.value_ && value_ < boundary_); }
-        bool operator!=(const iterator& rhs) const { return positive_step_ ? (value_ < rhs.value_ && value_ >= boundary_)
-                                                                           : (value_ > rhs.value_ && value_ <= boundary_); }
-
-    private:
-        value_type value_;
-        const T step_;
-        const T boundary_;
-        const bool positive_step_;
-    };
-
-    iterator begin() const {
-        return iterator(start_, step_, start_);
-    }
-
-    iterator end() const {
-        return iterator(stop_, step_, start_);
-    }
-
-private:
-    const T start_;
-    const T stop_;
-    const T step_;
-};
-
-} // namespace detail
-
-template <typename T>
-detail::Range<T> range(const T stop) {
-    return detail::Range<T>(T{0}, stop, T{1});
-}
-
-template <typename T>
-detail::Range<T> range(const T start, const T stop) {
-    return detail::Range<T>(start, stop, T{1});
-}
-
-template <typename T>
-detail::Range<T> range(const T start, const T stop, const T step) {
-    return detail::Range<T>(start, stop, step);
-}
-
-} // namespace irange
-
-#endif // BITCOIN_UTIL_IRANGE_H
diff --git a/src/util/ranges.h b/src/util/ranges.h
index 808a6a487261..bb745a251802 100644
--- a/src/util/ranges.h
+++ b/src/util/ranges.h
@@ -18,6 +18,12 @@ constexpr inline auto find_if_opt(const X& ds, const Z& fn)
     }
     return std::optional<std::decay_t<decltype(*it)>>{};
 }
+
+template <typename T>
+constexpr inline auto irange(const T& max)
+{
+    return std::views::iota(T{0}, max);
+}
 } // namespace util
 
 #endif // BITCOIN_UTIL_RANGES_H
diff --git a/test/util/data/non-backported.txt b/test/util/data/non-backported.txt
index 1cf8fc30f5ed..6ee62708bdf6 100644
--- a/test/util/data/non-backported.txt
+++ b/test/util/data/non-backported.txt
@@ -54,7 +54,6 @@ src/test/util/llmq_tests.h
 src/test/governance*.cpp
 src/unordered_lru_cache.h
 src/util/edge.*
-src/util/irange.h
 src/util/pointer.h
 src/util/ranges.h
 src/util/ranges_set.*

From ab5720f57da2c2e4343a9c97f83ecadf1242717e Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Sat, 10 Jan 2026 22:52:04 +0530
Subject: [PATCH 06/16] util: add polyfill for `std::ranges::contains`

---
 src/util/std23.h | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/src/util/std23.h b/src/util/std23.h
index 39ba2f7c6ba6..6252026bc71f 100644
--- a/src/util/std23.h
+++ b/src/util/std23.h
@@ -5,6 +5,8 @@
 #ifndef BITCOIN_UTIL_STD23_H
 #define BITCOIN_UTIL_STD23_H
 
+#include <algorithm>
+#include <functional>
 #include <iterator>
 #include <ranges>
 #include <type_traits>
@@ -26,6 +28,26 @@ template <typename E>
 }
 #endif // __cplusplus >= 202302L
 namespace ranges {
+#if __cplusplus >= 202302L
+using std::ranges::contains;
+#else
+/**
+ * @tparam R range type, automatically deduced
+ * @tparam T value type to search for, automatically deduced
+ * @tparam Proj projection type
+ * @param range the range to search in
+ * @param value the value to search for
+ * @param proj optional projection to apply to elements before comparison
+ * @return true if the range contains the value, false otherwise
+ */
+template <typename R, typename T, typename Proj = std::identity>
+inline constexpr bool contains(R&& range, const T& value, Proj proj = {})
+{
+    return std::ranges::any_of(std::forward<R>(range), [&value, &proj](auto&& elem) {
+        return std::invoke(proj, std::forward<decltype(elem)>(elem)) == value;
+    });
+}
+#endif // __cplusplus >= 202302L
 namespace views {
 #if __cplusplus >= 202302L
 using std::ranges::views::enumerate;

From dcf37c1f98d18bc2ca92bbee233f68b1aba36289 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Sat, 10 Jan 2026 19:45:29 +0530
Subject: [PATCH 07/16] refactor: use `std23::ranges::contains` in
 Dash-specific code

---
 src/active/dkgsession.cpp | 5 +++--
 src/evo/mnhftx.cpp        | 3 ++-
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/active/dkgsession.cpp b/src/active/dkgsession.cpp
index deea0a21be2a..65ee904dc0c1 100644
--- a/src/active/dkgsession.cpp
+++ b/src/active/dkgsession.cpp
@@ -13,6 +13,7 @@
 #include <llmq/utils.h>
 #include <masternode/meta.h>
 #include <util/ranges.h>
+#include <util/std23.h>
 
 #include <chain.h>
 #include <deploymentstatus.h>
@@ -355,7 +356,7 @@ void ActiveDKGSession::SendJustification(CDKGPendingMessages& pendingMessages, P
 
     for (const uint32_t i : util::irange(members.size())) {
         const auto& m = members[i];
-        if (forMembers.count(m->dmn->proTxHash) == 0) {
+        if (!std23::ranges::contains(forMembers, m->dmn->proTxHash)) {
             continue;
         }
         logger.Batch("justifying for %s", m->dmn->proTxHash.ToString());
@@ -560,7 +561,7 @@ std::vector<CFinalCommitment> ActiveDKGSession::FinalizeCommitments()
 
         for (const auto& p : prematureCommitments) {
             const auto& qc = p.second;
-            if (validCommitments.count(p.first) == 0) {
+            if (!std23::ranges::contains(validCommitments, p.first)) {
                 continue;
             }
 
diff --git a/src/evo/mnhftx.cpp b/src/evo/mnhftx.cpp
index 8f4fa535c4f1..0dc90f18d144 100644
--- a/src/evo/mnhftx.cpp
+++ b/src/evo/mnhftx.cpp
@@ -11,6 +11,7 @@
 #include <llmq/quorumsman.h>
 #include <llmq/signhash.h>
 #include <node/blockstorage.h>
+#include <util/std23.h>
 
 #include <chain.h>
 #include <chainparams.h>
@@ -191,7 +192,7 @@ static bool extractSignals(const ChainstateManager& chainman, const llmq::CQuoru
             return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-mnhf-tx-payload");
         }
         const uint8_t bit = opt_mnhfTx->signal.versionBit;
-        if (std::find(new_signals.begin(), new_signals.end(), bit) != new_signals.end()) {
+        if (std23::ranges::contains(new_signals, bit)) {
             return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-mnhf-duplicates-in-block");
         }
         new_signals.push_back(bit);

From 0e0919259d57799f1099708fb9b60e69faecab6b Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Sat, 10 Jan 2026 21:10:25 +0530
Subject: [PATCH 08/16] util: add polyfill for `std::ranges::fold_left`

---
 src/util/std23.h | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/src/util/std23.h b/src/util/std23.h
index 6252026bc71f..81ea19a34e52 100644
--- a/src/util/std23.h
+++ b/src/util/std23.h
@@ -8,6 +8,7 @@
 #include <algorithm>
 #include <functional>
 #include <iterator>
+#include <numeric>
 #include <ranges>
 #include <type_traits>
 #include <utility>
@@ -30,6 +31,7 @@ template <typename E>
 namespace ranges {
 #if __cplusplus >= 202302L
 using std::ranges::contains;
+using std::ranges::fold_left;
 #else
 /**
  * @tparam R range type, automatically deduced
@@ -47,6 +49,21 @@ inline constexpr bool contains(R&& range, const T& value, Proj proj = {})
         return std::invoke(proj, std::forward<decltype(elem)>(elem)) == value;
     });
 }
+
+/**
+ * @tparam R range type, automatically deduced
+ * @tparam T initial value type, automatically deduced
+ * @tparam F binary operation type, automatically deduced
+ * @param range the range to fold
+ * @param init the initial value
+ * @param f binary operation to apply
+ * @return the result of folding the range
+ */
+template <typename R, typename T, typename F>
+inline constexpr auto fold_left(R&& range, T init, F f)
+{
+    return std::accumulate(std::ranges::begin(range), std::ranges::end(range), std::move(init), std::move(f));
+}
 #endif // __cplusplus >= 202302L
 namespace views {
 #if __cplusplus >= 202302L

From 431ac0725db612bcf7fe4b7afd36f41da40a08d1 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Sat, 10 Jan 2026 21:10:38 +0530
Subject: [PATCH 09/16] refactor: use `std23::ranges::fold_left` in
 Dash-specific code

---
 src/evo/cbtx.cpp            | 12 +++++-------
 src/governance/classes.cpp  |  9 +--------
 src/llmq/signing_shares.cpp |  7 +++----
 src/llmq/signing_shares.h   |  8 +++-----
 4 files changed, 12 insertions(+), 24 deletions(-)

diff --git a/src/evo/cbtx.cpp b/src/evo/cbtx.cpp
index 47144774d187..4e1b7986ad6c 100644
--- a/src/evo/cbtx.cpp
+++ b/src/evo/cbtx.cpp
@@ -2,20 +2,22 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <consensus/validation.h>
 #include <evo/cbtx.h>
+
 #include <evo/specialtx.h>
 #include <llmq/blockprocessor.h>
 #include <llmq/commitment.h>
 #include <llmq/options.h>
 #include <llmq/quorumsman.h>
 #include <llmq/utils.h>
-#include <node/blockstorage.h>
+#include <util/std23.h>
 
 #include <chain.h>
 #include <chainparams.h>
 #include <consensus/merkle.h>
+#include <consensus/validation.h>
 #include <deploymentstatus.h>
+#include <node/blockstorage.h>
 
 using node::ReadBlockFromDisk;
 
@@ -109,11 +111,7 @@ auto CachedGetQcHashesQcIndexedHashes(const CBlockIndex* pindexPrev, const llmq:
 
 auto CalcHashCountFromQCHashes(const QcHashMap& qcHashes)
 {
-    size_t hash_count{0};
-    for (const auto& [_, vec_hashes] : qcHashes) {
-        hash_count += vec_hashes.size();
-    }
-    return hash_count;
+    return std23::ranges::fold_left(qcHashes, size_t{0}, [](size_t s, const auto& p) { return s + p.second.size(); });
 }
 
 bool CalcCbTxMerkleRootQuorums(const CBlock& block, const CBlockIndex* pindexPrev,
diff --git a/src/governance/classes.cpp b/src/governance/classes.cpp
index 6e1bd943495e..954473a600fe 100644
--- a/src/governance/classes.cpp
+++ b/src/governance/classes.cpp
@@ -233,14 +233,7 @@ bool CSuperblock::GetPayment(int nPaymentIndex, CGovernancePayment& paymentRet)
 
 CAmount CSuperblock::GetPaymentsTotalAmount()
 {
-    CAmount nPaymentsTotalAmount = 0;
-    int nPayments = CountPayments();
-
-    for (int i = 0; i < nPayments; i++) {
-        nPaymentsTotalAmount += vecPayments[i].nAmount;
-    }
-
-    return nPaymentsTotalAmount;
+    return std23::ranges::fold_left(vecPayments, CAmount{0}, [](CAmount s, const auto& p) { return s + p.nAmount; });
 }
 
 /**
diff --git a/src/llmq/signing_shares.cpp b/src/llmq/signing_shares.cpp
index 61c918223803..ffb52f00c463 100644
--- a/src/llmq/signing_shares.cpp
+++ b/src/llmq/signing_shares.cpp
@@ -313,10 +313,9 @@ void CSigSharesManager::ProcessMessage(const CNode& pfrom, const std::string& ms
     } else if (msg_type == NetMsgType::QBSIGSHARES) {
         std::vector<CBatchedSigShares> msgs;
         vRecv >> msgs;
-        size_t totalSigsCount = 0;
-        for (const auto& bs : msgs) {
-            totalSigsCount += bs.sigShares.size();
-        }
+        const size_t totalSigsCount = std23::ranges::fold_left(msgs, size_t{0}, [](size_t s, const auto& bs) {
+            return s + bs.sigShares.size();
+        });
         if (totalSigsCount > MAX_MSGS_TOTAL_BATCHED_SIGS) {
             LogPrint(BCLog::LLMQ_SIGS, "CSigSharesManager::%s -- too many sigs in QBSIGSHARES message. cnt=%d, max=%d, node=%d\n", __func__, msgs.size(), MAX_MSGS_TOTAL_BATCHED_SIGS, pfrom.GetId());
             BanNode(pfrom.GetId());
diff --git a/src/llmq/signing_shares.h b/src/llmq/signing_shares.h
index e6d91f7b25a2..dcad83f77e0e 100644
--- a/src/llmq/signing_shares.h
+++ b/src/llmq/signing_shares.h
@@ -11,6 +11,7 @@
 #include <llmq/signhash.h>
 #include <llmq/signing.h>
 #include <msg_result.h>
+#include <util/std23.h>
 
 #include <random.h>
 #include <saltedhasher.h>
@@ -231,11 +232,8 @@ class SigShareMap
 
     [[nodiscard]] size_t Size() const
     {
-        size_t s = 0;
-        for (auto& p : internalMap) {
-            s += p.second.size();
-        }
-        return s;
+        return std23::ranges::fold_left(internalMap, size_t{0},
+                                        [](size_t s, const auto& p) { return s + p.second.size(); });
     }
 
     [[nodiscard]] size_t CountForSignHash(const uint256& signHash) const

From f6c30f126cf24d00a42be63528b4e0301a47d79b Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Sun, 11 Jan 2026 12:07:10 +0530
Subject: [PATCH 10/16] refactor: merge `util/ranges.h` and `util/pointer.h` to
 `util/helpers.h`

---
 src/Makefile.am                              |  3 +-
 src/active/dkgsession.cpp                    |  2 +-
 src/active/quorums.cpp                       |  2 +-
 src/bench/bls_dkg.cpp                        |  2 +-
 src/coinjoin/client.cpp                      |  2 +-
 src/coinjoin/coinjoin.h                      |  5 +-
 src/coinjoin/common.h                        |  2 +-
 src/evo/deterministicmns.cpp                 |  3 +-
 src/evo/dmnstate.h                           |  2 +-
 src/evo/simplifiedmns.h                      |  2 +-
 src/instantsend/signing.cpp                  |  2 +-
 src/llmq/blockprocessor.cpp                  |  2 +-
 src/llmq/commitment.cpp                      |  2 +-
 src/llmq/commitment.h                        |  2 +-
 src/llmq/debug.cpp                           |  2 +-
 src/llmq/dkgsession.cpp                      |  2 +-
 src/llmq/dkgsessionmgr.cpp                   |  2 +-
 src/llmq/dkgsessionmgr.h                     |  2 +-
 src/llmq/observer/quorums.cpp                |  2 +-
 src/llmq/options.cpp                         |  2 +-
 src/llmq/quorums.cpp                         |  2 +-
 src/llmq/quorumsman.cpp                      |  2 +-
 src/llmq/signing_shares.cpp                  |  2 +-
 src/llmq/snapshot.h                          |  2 +-
 src/llmq/utils.cpp                           |  2 +-
 src/rpc/quorums.cpp                          |  2 +-
 src/rpc/rawtransaction.cpp                   |  2 +-
 src/spork.cpp                                |  2 +-
 src/test/block_reward_reallocation_tests.cpp |  2 +-
 src/test/bls_tests.cpp                       |  2 +-
 src/test/evo_netinfo_tests.cpp               |  5 +-
 src/test/llmq_dkg_tests.cpp                  |  2 +-
 src/util/helpers.h                           | 48 ++++++++++++++++++++
 src/util/pointer.h                           | 38 ----------------
 src/util/ranges.h                            | 29 ------------
 test/util/data/non-backported.txt            |  3 +-
 36 files changed, 85 insertions(+), 105 deletions(-)
 create mode 100644 src/util/helpers.h
 delete mode 100644 src/util/pointer.h
 delete mode 100644 src/util/ranges.h

diff --git a/src/Makefile.am b/src/Makefile.am
index f7cae4d1b627..d49bba590b53 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -399,6 +399,7 @@ BITCOIN_CORE_H = \
   util/golombrice.h \
   util/hasher.h \
   util/hash_type.h \
+  util/helpers.h \
   util/asmap.h \
   util/getuniquepath.h \
   util/macros.h \
@@ -406,8 +407,6 @@ BITCOIN_CORE_H = \
   util/moneystr.h \
   util/overflow.h \
   util/overloaded.h \
-  util/pointer.h \
-  util/ranges.h \
   util/readwritefile.h \
   util/result.h \
   util/serfloat.h \
diff --git a/src/active/dkgsession.cpp b/src/active/dkgsession.cpp
index 65ee904dc0c1..efcbfe46aef9 100644
--- a/src/active/dkgsession.cpp
+++ b/src/active/dkgsession.cpp
@@ -12,7 +12,7 @@
 #include <llmq/options.h>
 #include <llmq/utils.h>
 #include <masternode/meta.h>
-#include <util/ranges.h>
+#include <util/helpers.h>
 #include <util/std23.h>
 
 #include <chain.h>
diff --git a/src/active/quorums.cpp b/src/active/quorums.cpp
index f528e139c0f2..043d31fa0982 100644
--- a/src/active/quorums.cpp
+++ b/src/active/quorums.cpp
@@ -14,7 +14,7 @@
 #include <llmq/quorums.h>
 #include <llmq/utils.h>
 #include <masternode/sync.h>
-#include <util/ranges.h>
+#include <util/helpers.h>
 
 #include <chain.h>
 #include <chainparams.h>
diff --git a/src/bench/bls_dkg.cpp b/src/bench/bls_dkg.cpp
index be19cdb34978..dc157ca0ebd3 100644
--- a/src/bench/bls_dkg.cpp
+++ b/src/bench/bls_dkg.cpp
@@ -5,7 +5,7 @@
 #include <bench/bench.h>
 
 #include <bls/bls_worker.h>
-#include <util/ranges.h>
+#include <util/helpers.h>
 
 #include <random.h>
 
diff --git a/src/coinjoin/client.cpp b/src/coinjoin/client.cpp
index 38db0f3909ba..be6727cc41b1 100644
--- a/src/coinjoin/client.cpp
+++ b/src/coinjoin/client.cpp
@@ -9,7 +9,7 @@
 #include <masternode/meta.h>
 #include <masternode/sync.h>
 #include <rpc/evo_util.h>
-#include <util/ranges.h>
+#include <util/helpers.h>
 #include <wallet/coinjoin.h>
 
 #include <chain.h>
diff --git a/src/coinjoin/coinjoin.h b/src/coinjoin/coinjoin.h
index 7a2159d73251..0d190414de65 100644
--- a/src/coinjoin/coinjoin.h
+++ b/src/coinjoin/coinjoin.h
@@ -7,7 +7,7 @@
 
 #include <coinjoin/common.h>
 
-#include <util/ranges.h>
+#include <util/helpers.h>
 
 #include <core_io.h>
 #include <netaddress.h>
@@ -15,7 +15,6 @@
 #include <primitives/transaction.h>
 #include <sync.h>
 #include <timedata.h>
-#include <univalue.h>
 #include <util/translation.h>
 #include <version.h>
 
@@ -24,6 +23,8 @@
 #include <optional>
 #include <utility>
 
+#include <univalue.h>
+
 class CChainState;
 class CBLSPublicKey;
 class CBlockIndex;
diff --git a/src/coinjoin/common.h b/src/coinjoin/common.h
index 5b1fc7b76742..6c7abfba2266 100644
--- a/src/coinjoin/common.h
+++ b/src/coinjoin/common.h
@@ -5,7 +5,7 @@
 #ifndef BITCOIN_COINJOIN_COMMON_H
 #define BITCOIN_COINJOIN_COMMON_H
 
-#include <util/ranges.h>
+#include <util/helpers.h>
 
 #include <consensus/amount.h>
 #include <primitives/transaction.h>
diff --git a/src/evo/deterministicmns.cpp b/src/evo/deterministicmns.cpp
index 5d63d4f9ae26..494b0fa9326f 100644
--- a/src/evo/deterministicmns.cpp
+++ b/src/evo/deterministicmns.cpp
@@ -13,8 +13,7 @@
 #include <masternode/meta.h>
 #include <messagesigner.h>
 #include <stats/client.h>
-#include <util/pointer.h>
-#include <util/ranges.h>
+#include <util/helpers.h>
 
 #include <chainparams.h>
 #include <coins.h>
diff --git a/src/evo/dmnstate.h b/src/evo/dmnstate.h
index b2f93fad0ccd..cb1d3a12c8d0 100644
--- a/src/evo/dmnstate.h
+++ b/src/evo/dmnstate.h
@@ -11,7 +11,7 @@
 #include <netaddress.h>
 #include <pubkey.h>
 #include <script/script.h>
-#include <util/pointer.h>
+#include <util/helpers.h>
 
 #include <memory>
 #include <utility>
diff --git a/src/evo/simplifiedmns.h b/src/evo/simplifiedmns.h
index cbc1e9434fe4..457600db4b23 100644
--- a/src/evo/simplifiedmns.h
+++ b/src/evo/simplifiedmns.h
@@ -9,7 +9,7 @@
 #include <evo/dmn_types.h>
 #include <evo/netinfo.h>
 #include <evo/providertx.h>
-#include <util/pointer.h>
+#include <util/helpers.h>
 
 #include <merkleblock.h>
 #include <netaddress.h>
diff --git a/src/instantsend/signing.cpp b/src/instantsend/signing.cpp
index e93007f01408..c2d247827c4b 100644
--- a/src/instantsend/signing.cpp
+++ b/src/instantsend/signing.cpp
@@ -9,7 +9,7 @@
 #include <llmq/signing_shares.h>
 #include <masternode/sync.h>
 #include <spork.h>
-#include <util/ranges.h>
+#include <util/helpers.h>
 
 #include <chain.h>
 #include <chainparams.h>
diff --git a/src/llmq/blockprocessor.cpp b/src/llmq/blockprocessor.cpp
index 984a7caf9e23..ce7948e62132 100644
--- a/src/llmq/blockprocessor.cpp
+++ b/src/llmq/blockprocessor.cpp
@@ -9,7 +9,7 @@
 #include <llmq/commitment.h>
 #include <llmq/options.h>
 #include <llmq/utils.h>
-#include <util/ranges.h>
+#include <util/helpers.h>
 #include <util/std23.h>
 
 #include <chain.h>
diff --git a/src/llmq/commitment.cpp b/src/llmq/commitment.cpp
index 41d5e6d01142..b492df2e0c2d 100644
--- a/src/llmq/commitment.cpp
+++ b/src/llmq/commitment.cpp
@@ -8,7 +8,7 @@
 #include <evo/specialtx.h>
 #include <llmq/options.h>
 #include <llmq/utils.h>
-#include <util/ranges.h>
+#include <util/helpers.h>
 #include <util/std23.h>
 
 #include <chainparams.h>
diff --git a/src/llmq/commitment.h b/src/llmq/commitment.h
index d4da16f60b53..292db406c71f 100644
--- a/src/llmq/commitment.h
+++ b/src/llmq/commitment.h
@@ -8,7 +8,7 @@
 #include <bls/bls.h>
 #include <llmq/params.h>
 #include <llmq/types.h>
-#include <util/ranges.h>
+#include <util/helpers.h>
 #include <util/std23.h>
 
 #include <primitives/transaction.h>
diff --git a/src/llmq/debug.cpp b/src/llmq/debug.cpp
index a91b78e6d75a..0c5993d6c867 100644
--- a/src/llmq/debug.cpp
+++ b/src/llmq/debug.cpp
@@ -6,7 +6,7 @@
 
 #include <evo/deterministicmns.h>
 #include <llmq/utils.h>
-#include <util/ranges.h>
+#include <util/helpers.h>
 #include <util/std23.h>
 
 #include <chainparams.h>
diff --git a/src/llmq/dkgsession.cpp b/src/llmq/dkgsession.cpp
index 4c8f661e7866..6160e2c28cf2 100644
--- a/src/llmq/dkgsession.cpp
+++ b/src/llmq/dkgsession.cpp
@@ -12,7 +12,7 @@
 #include <llmq/options.h>
 #include <llmq/utils.h>
 #include <masternode/meta.h>
-#include <util/ranges.h>
+#include <util/helpers.h>
 #include <util/std23.h>
 
 #include <chainparams.h>
diff --git a/src/llmq/dkgsessionmgr.cpp b/src/llmq/dkgsessionmgr.cpp
index ed98ee9c23c9..76384c8e73ed 100644
--- a/src/llmq/dkgsessionmgr.cpp
+++ b/src/llmq/dkgsessionmgr.cpp
@@ -11,7 +11,7 @@
 #include <llmq/utils.h>
 #include <spork.h>
 #include <unordered_lru_cache.h>
-#include <util/ranges.h>
+#include <util/helpers.h>
 #include <util/std23.h>
 
 #include <chainparams.h>
diff --git a/src/llmq/dkgsessionmgr.h b/src/llmq/dkgsessionmgr.h
index 4c92ad32e238..23cf14491ddd 100644
--- a/src/llmq/dkgsessionmgr.h
+++ b/src/llmq/dkgsessionmgr.h
@@ -9,7 +9,7 @@
 #include <bls/bls_worker.h>
 #include <llmq/dkgsessionhandler.h>
 #include <msg_result.h>
-#include <util/ranges.h>
+#include <util/helpers.h>
 
 #include <net_types.h>
 
diff --git a/src/llmq/observer/quorums.cpp b/src/llmq/observer/quorums.cpp
index ffb073d67005..6f0b019a84cb 100644
--- a/src/llmq/observer/quorums.cpp
+++ b/src/llmq/observer/quorums.cpp
@@ -12,7 +12,7 @@
 #include <masternode/sync.h>
 #include <msg_result.h>
 #include <unordered_lru_cache.h>
-#include <util/ranges.h>
+#include <util/helpers.h>
 
 #include <chain.h>
 #include <chainparams.h>
diff --git a/src/llmq/options.cpp b/src/llmq/options.cpp
index d5c946a95752..2241bc13efdc 100644
--- a/src/llmq/options.cpp
+++ b/src/llmq/options.cpp
@@ -5,7 +5,7 @@
 #include <llmq/options.h>
 
 #include <spork.h>
-#include <util/ranges.h>
+#include <util/helpers.h>
 #include <util/std23.h>
 
 #include <chainparams.h>
diff --git a/src/llmq/quorums.cpp b/src/llmq/quorums.cpp
index 50f53ab00cac..0fb761ea18a7 100644
--- a/src/llmq/quorums.cpp
+++ b/src/llmq/quorums.cpp
@@ -6,7 +6,7 @@
 
 #include <evo/deterministicmns.h>
 #include <llmq/commitment.h>
-#include <util/ranges.h>
+#include <util/helpers.h>
 
 #include <dbwrapper.h>
 
diff --git a/src/llmq/quorumsman.cpp b/src/llmq/quorumsman.cpp
index f3c66093fc99..3802dafdfada 100644
--- a/src/llmq/quorumsman.cpp
+++ b/src/llmq/quorumsman.cpp
@@ -15,7 +15,7 @@
 #include <llmq/params.h>
 #include <llmq/signhash.h>
 #include <llmq/utils.h>
-#include <util/ranges.h>
+#include <util/helpers.h>
 #include <util/std23.h>
 
 #include <chainparams.h>
diff --git a/src/llmq/signing_shares.cpp b/src/llmq/signing_shares.cpp
index ffb52f00c463..2c174bcd6063 100644
--- a/src/llmq/signing_shares.cpp
+++ b/src/llmq/signing_shares.cpp
@@ -13,7 +13,7 @@
 #include <llmq/signhash.h>
 #include <llmq/signing.h>
 #include <spork.h>
-#include <util/ranges.h>
+#include <util/helpers.h>
 #include <util/std23.h>
 
 #include <chainparams.h>
diff --git a/src/llmq/snapshot.h b/src/llmq/snapshot.h
index 1a63beeba1de..6877366f2e6d 100644
--- a/src/llmq/snapshot.h
+++ b/src/llmq/snapshot.h
@@ -9,7 +9,7 @@
 #include <llmq/commitment.h>
 #include <llmq/params.h>
 #include <unordered_lru_cache.h>
-#include <util/ranges.h>
+#include <util/helpers.h>
 
 #include <saltedhasher.h>
 #include <serialize.h>
diff --git a/src/llmq/utils.cpp b/src/llmq/utils.cpp
index 1e382fc169cc..892f537151ec 100644
--- a/src/llmq/utils.cpp
+++ b/src/llmq/utils.cpp
@@ -10,7 +10,7 @@
 #include <llmq/snapshot.h>
 #include <llmq/types.h>
 #include <masternode/meta.h>
-#include <util/ranges.h>
+#include <util/helpers.h>
 #include <util/std23.h>
 
 #include <chainparams.h>
diff --git a/src/rpc/quorums.cpp b/src/rpc/quorums.cpp
index f50d723c0c8f..3ed5f4c35878 100644
--- a/src/rpc/quorums.cpp
+++ b/src/rpc/quorums.cpp
@@ -20,7 +20,7 @@
 #include <llmq/snapshot.h>
 #include <llmq/utils.h>
 #include <rpc/evo_util.h>
-#include <util/ranges.h>
+#include <util/helpers.h>
 
 #include <chainparams.h>
 #include <deploymentstatus.h>
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index 0c37567b5e15..a2c166efdf40 100644
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -57,7 +57,7 @@
 #include <llmq/commitment.h>
 #include <llmq/context.h>
 #include <rpc/index_util.h>
-#include <util/ranges.h>
+#include <util/helpers.h>
 
 #include <cstdint>
 #include <numeric>
diff --git a/src/spork.cpp b/src/spork.cpp
index 0d4fc7cabd5d..5413293561f7 100644
--- a/src/spork.cpp
+++ b/src/spork.cpp
@@ -5,7 +5,7 @@
 #include <spork.h>
 
 #include <flat-database.h>
-#include <util/ranges.h>
+#include <util/helpers.h>
 
 #include <chainparams.h>
 #include <key_io.h>
diff --git a/src/test/block_reward_reallocation_tests.cpp b/src/test/block_reward_reallocation_tests.cpp
index 6ab54912fe2d..e62edd4595d2 100644
--- a/src/test/block_reward_reallocation_tests.cpp
+++ b/src/test/block_reward_reallocation_tests.cpp
@@ -9,7 +9,7 @@
 #include <evo/providertx.h>
 #include <evo/specialtx.h>
 #include <masternode/payments.h>
-#include <util/ranges.h>
+#include <util/helpers.h>
 #include <util/std23.h>
 
 #include <chainparams.h>
diff --git a/src/test/bls_tests.cpp b/src/test/bls_tests.cpp
index 9c57f8a3e431..8161dc58ff4d 100644
--- a/src/test/bls_tests.cpp
+++ b/src/test/bls_tests.cpp
@@ -4,7 +4,7 @@
 
 #include <bls/bls.h>
 #include <bls/bls_batchverifier.h>
-#include <util/ranges.h>
+#include <util/helpers.h>
 
 #include <clientversion.h>
 #include <random.h>
diff --git a/src/test/evo_netinfo_tests.cpp b/src/test/evo_netinfo_tests.cpp
index a1df594c820b..9fc3e3d8be91 100644
--- a/src/test/evo_netinfo_tests.cpp
+++ b/src/test/evo_netinfo_tests.cpp
@@ -4,12 +4,13 @@
 
 #include <test/util/setup_common.h>
 
+#include <evo/netinfo.h>
+#include <util/helpers.h>
+
 #include <chainparams.h>
 #include <clientversion.h>
-#include <evo/netinfo.h>
 #include <netbase.h>
 #include <streams.h>
-#include <util/pointer.h>
 #include <util/strencodings.h>
 
 #include <boost/test/unit_test.hpp>
diff --git a/src/test/llmq_dkg_tests.cpp b/src/test/llmq_dkg_tests.cpp
index 33ef378bc5c8..2059ab0cb272 100644
--- a/src/test/llmq_dkg_tests.cpp
+++ b/src/test/llmq_dkg_tests.cpp
@@ -3,7 +3,7 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <llmq/dkgsession.h>
-#include <util/ranges.h>
+#include <util/helpers.h>
 #include <util/std23.h>
 
 #include <boost/test/unit_test.hpp>
diff --git a/src/util/helpers.h b/src/util/helpers.h
new file mode 100644
index 000000000000..4bc07535c3de
--- /dev/null
+++ b/src/util/helpers.h
@@ -0,0 +1,48 @@
+// Copyright (c) 2021-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.
+
+#ifndef BITCOIN_UTIL_HELPERS_H
+#define BITCOIN_UTIL_HELPERS_H
+
+#include <memory>
+#include <optional>
+#include <ranges>
+
+namespace util {
+template <typename X, typename Z>
+constexpr inline auto find_if_opt(const X& ds, const Z& fn)
+{
+    const auto it = std::ranges::find_if(ds, fn);
+    if (it != std::end(ds)) {
+        return std::make_optional(*it);
+    }
+    return std::optional<std::decay_t<decltype(*it)>>{};
+}
+
+template <typename T>
+constexpr inline auto irange(const T& max)
+{
+    return std::views::iota(T{0}, max);
+}
+
+template <typename T>
+inline bool shared_ptr_equal(const std::shared_ptr<T>& lhs, const std::shared_ptr<T>& rhs)
+    requires requires { *lhs == *rhs; }
+{
+    if (lhs == rhs) return true;    // Same object or both blank
+    if (!lhs || !rhs) return false; // Inequal initialization state
+    return *lhs == *rhs;            // Deep comparison
+}
+
+template <typename T>
+inline bool shared_ptr_not_equal(const std::shared_ptr<T>& lhs, const std::shared_ptr<T>& rhs)
+    requires requires { *lhs != *rhs; }
+{
+    if (lhs == rhs) return false;   // Same object or both blank
+    if (!lhs || !rhs) return true;  // Inequal initialization state
+    return *lhs != *rhs;            // Deep comparison
+}
+} // namespace util
+
+#endif // BITCOIN_UTIL_HELPERS_H
diff --git a/src/util/pointer.h b/src/util/pointer.h
deleted file mode 100644
index 71ec60e0217b..000000000000
--- a/src/util/pointer.h
+++ /dev/null
@@ -1,38 +0,0 @@
-// Copyright (c) 2025 The Dash Core developers
-// Distributed under the MIT software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#ifndef BITCOIN_UTIL_POINTER_H
-#define BITCOIN_UTIL_POINTER_H
-
-#include <memory>
-
-namespace util {
-/* Deep equality comparison helper for std::shared_ptr<T> */
-template <typename T>
-bool shared_ptr_equal(const std::shared_ptr<T>& lhs, const std::shared_ptr<T>& rhs)
-    requires requires { *lhs == *rhs; }
-{
-    /* Same object or both blank */
-    if (lhs == rhs) return true;
-    /* Inequal initialization state */
-    if (!lhs || !rhs) return false;
-    /* Deep comparison */
-    return *lhs == *rhs;
-}
-
-/* Deep inequality comparison helper for std::shared_ptr<T> */
-template <typename T>
-bool shared_ptr_not_equal(const std::shared_ptr<T>& lhs, const std::shared_ptr<T>& rhs)
-    requires requires { *lhs != *rhs; }
-{
-    /* Same object or both blank */
-    if (lhs == rhs) return false;
-    /* Inequal initialization state */
-    if (!lhs || !rhs) return true;
-    /* Deep comparison */
-    return *lhs != *rhs;
-}
-} // namespace util
-
-#endif // BITCOIN_UTIL_POINTER_H
diff --git a/src/util/ranges.h b/src/util/ranges.h
deleted file mode 100644
index bb745a251802..000000000000
--- a/src/util/ranges.h
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright (c) 2021-2022 The Dash Core developers
-// Distributed under the MIT software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#ifndef BITCOIN_UTIL_RANGES_H
-#define BITCOIN_UTIL_RANGES_H
-
-#include <optional>
-#include <ranges>
-
-namespace util {
-template <typename X, typename Z>
-constexpr inline auto find_if_opt(const X& ds, const Z& fn)
-{
-    const auto it = std::ranges::find_if(ds, fn);
-    if (it != std::end(ds)) {
-        return std::make_optional(*it);
-    }
-    return std::optional<std::decay_t<decltype(*it)>>{};
-}
-
-template <typename T>
-constexpr inline auto irange(const T& max)
-{
-    return std::views::iota(T{0}, max);
-}
-} // namespace util
-
-#endif // BITCOIN_UTIL_RANGES_H
diff --git a/test/util/data/non-backported.txt b/test/util/data/non-backported.txt
index 6ee62708bdf6..b4a43f027ac1 100644
--- a/test/util/data/non-backported.txt
+++ b/test/util/data/non-backported.txt
@@ -54,8 +54,7 @@ src/test/util/llmq_tests.h
 src/test/governance*.cpp
 src/unordered_lru_cache.h
 src/util/edge.*
-src/util/pointer.h
-src/util/ranges.h
+src/util/helpers.h
 src/util/ranges_set.*
 src/util/std23.h
 src/util/wpipe.*

From 75fd518792e2de8c62e2f436ca9864f2aa374d1e Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Sat, 10 Jan 2026 21:34:42 +0530
Subject: [PATCH 11/16] refactor: add `util::to_string(bool)` for convenience

---
 src/coinjoin/coinjoin.cpp | 3 ++-
 src/llmq/quorumsman.cpp   | 2 +-
 src/qt/guiutil_font.cpp   | 6 ++++--
 src/rpc/mempool.cpp       | 9 +++++----
 src/util/helpers.h        | 6 ++++++
 5 files changed, 18 insertions(+), 8 deletions(-)

diff --git a/src/coinjoin/coinjoin.cpp b/src/coinjoin/coinjoin.cpp
index 9cfe75b585ae..6db358e6c3e6 100644
--- a/src/coinjoin/coinjoin.cpp
+++ b/src/coinjoin/coinjoin.cpp
@@ -8,6 +8,7 @@
 #include <chainlock/chainlock.h>
 #include <instantsend/instantsend.h>
 #include <masternode/sync.h>
+#include <util/helpers.h>
 
 #include <chain.h>
 #include <chainparams.h>
@@ -64,7 +65,7 @@ bool CCoinJoinQueue::IsTimeOutOfBounds(int64_t current_time) const
 [[nodiscard]] std::string CCoinJoinQueue::ToString() const
 {
     return strprintf("nDenom=%d, nTime=%lld, fReady=%s, fTried=%s, masternode=%s",
-        nDenom, nTime, fReady ? "true" : "false", fTried ? "true" : "false", masternodeOutpoint.ToStringShort());
+        nDenom, nTime, util::to_string(fReady), util::to_string(fTried), masternodeOutpoint.ToStringShort());
 }
 
 uint256 CCoinJoinBroadcastTx::GetSignatureHash() const
diff --git a/src/llmq/quorumsman.cpp b/src/llmq/quorumsman.cpp
index 3802dafdfada..f25eb8ad6ada 100644
--- a/src/llmq/quorumsman.cpp
+++ b/src/llmq/quorumsman.cpp
@@ -285,7 +285,7 @@ std::vector<CQuorumCPtr> CQuorumManager::ScanQuorums(Consensus::LLMQType llmqTyp
         if (!quorum) {
             LogPrintf("%s: ERROR! Unexpected missing quorum with llmqType=%d, blockHash=%s, populate_cache=%s\n",
                       __func__, std23::to_underlying(llmqType), pQuorumBaseBlockIndex->GetBlockHash().ToString(),
-                      populate_cache ? "true" : "false");
+                      util::to_string(populate_cache));
             return {};
         }
         vecResultQuorums.emplace_back(quorum);
diff --git a/src/qt/guiutil_font.cpp b/src/qt/guiutil_font.cpp
index 7190a32fe5ec..2eb2a00422ef 100644
--- a/src/qt/guiutil_font.cpp
+++ b/src/qt/guiutil_font.cpp
@@ -4,6 +4,8 @@
 
 #include <qt/guiutil_font.h>
 
+#include <util/helpers.h>
+
 #include <tinyformat.h>
 #include <util/system.h>
 
@@ -352,7 +354,7 @@ void setApplicationFont()
 
     qDebug() << qstrprintf("%s: %s family: %s, style: %s match: %s", __func__, qApp->font().toString().toStdString(),
                            qApp->font().family().toStdString(), qApp->font().styleName().toStdString(),
-                           qApp->font().exactMatch() ? "true" : "false");
+                           util::to_string(qApp->font().exactMatch()));
 }
 
 void setFont(const std::vector<QWidget*>& vecWidgets, const FontAttrib& font_attrib)
@@ -518,7 +520,7 @@ QFont getFont(const FontAttrib& font_attrib)
     if (gArgs.GetBoolArg("-debug-ui", false)) {
         qDebug() << qstrprintf("%s: font size: %d, family: %s, style: %s, weight: %d match %s", __func__,
                                font.pointSizeF(), font.family().toStdString(), font.styleName().toStdString(),
-                               font.weight(), font.exactMatch() ? "true" : "false");
+                               font.weight(), util::to_string(font.exactMatch()));
     }
 
     return font;
diff --git a/src/rpc/mempool.cpp b/src/rpc/mempool.cpp
index adaf7eee581a..10939a2fb485 100644
--- a/src/rpc/mempool.cpp
+++ b/src/rpc/mempool.cpp
@@ -5,6 +5,10 @@
 
 #include <rpc/blockchain.h>
 
+#include <instantsend/instantsend.h>
+#include <llmq/context.h>
+#include <util/helpers.h>
+
 #include <core_io.h>
 #include <fs.h>
 #include <policy/settings.h>
@@ -19,9 +23,6 @@
 #include <util/system.h>
 #include <util/time.h>
 
-#include <instantsend/instantsend.h>
-#include <llmq/context.h>
-
 using node::DEFAULT_MAX_RAW_TX_FEE_RATE;
 using node::NodeContext;
 
@@ -325,7 +326,7 @@ static void entryToJSON(const CTxMemPool& pool, UniValue& info, const CTxMemPool
     }
 
     info.pushKV("spentby", spent);
-    info.pushKV("instantlock", isman ? (isman->IsLocked(tx.GetHash()) ? "true" : "false") : "unknown");
+    info.pushKV("instantlock", isman ? util::to_string(isman->IsLocked(tx.GetHash())) : "unknown");
     info.pushKV("unbroadcast", pool.IsUnbroadcastTx(tx.GetHash()));
 }
 
diff --git a/src/util/helpers.h b/src/util/helpers.h
index 4bc07535c3de..fbf2911619e0 100644
--- a/src/util/helpers.h
+++ b/src/util/helpers.h
@@ -8,6 +8,7 @@
 #include <memory>
 #include <optional>
 #include <ranges>
+#include <string_view>
 
 namespace util {
 template <typename X, typename Z>
@@ -43,6 +44,11 @@ inline bool shared_ptr_not_equal(const std::shared_ptr<T>& lhs, const std::share
     if (!lhs || !rhs) return true;  // Inequal initialization state
     return *lhs != *rhs;            // Deep comparison
 }
+
+inline constexpr std::string_view to_string(bool value)
+{
+    return value ? "true" : "false";
+}
 } // namespace util
 
 #endif // BITCOIN_UTIL_HELPERS_H

From 68daddbba29e1457faeecf53b3d8b7ffeebef3c6 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Sun, 11 Jan 2026 12:09:02 +0530
Subject: [PATCH 12/16] fix: enum bound check in GetSimulatedErrorRate

---
 src/llmq/dkgsession.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/llmq/dkgsession.cpp b/src/llmq/dkgsession.cpp
index 6160e2c28cf2..7346d30ec76d 100644
--- a/src/llmq/dkgsession.cpp
+++ b/src/llmq/dkgsession.cpp
@@ -47,7 +47,7 @@ void SetSimulatedDKGErrorRate(DKGError::type type, double rate)
 
 double GetSimulatedErrorRate(DKGError::type type)
 {
-    if (std23::to_underlying(type) >= DKGError::type::_COUNT) return 0;
+    if (type >= DKGError::type::_COUNT) return 0;
     return simDkgErrorMap[std23::to_underlying(type)];
 }
 

From be2f1e4188bfc03e6f32583549929df5323242a8 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Mon, 15 Dec 2025 07:50:34 +0530
Subject: [PATCH 13/16] fix: don't string quote numerical arguments

---
 src/test/rpc_tests.cpp                    |  2 +-
 test/functional/feature_llmq_dkgerrors.py | 26 +++++++++++------------
 2 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/src/test/rpc_tests.cpp b/src/test/rpc_tests.cpp
index 6ebc56e250e1..d7b6b6a305f7 100644
--- a/src/test/rpc_tests.cpp
+++ b/src/test/rpc_tests.cpp
@@ -612,7 +612,7 @@ BOOST_AUTO_TEST_CASE(rpc_convert_composite_commands)
 
     BOOST_CHECK_EQUAL(result[0].get_str(), "register_prepare");
     BOOST_CHECK_EQUAL(result[1].get_str(), "6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000");
-    BOOST_CHECK_EQUAL(result[2].get_str(), "1");
+    BOOST_CHECK_EQUAL(result[2].getInt<int>(), 1);
     BOOST_CHECK(result[3].isArray());
     BOOST_CHECK_EQUAL(result[3].size(), 2);
     BOOST_CHECK_EQUAL(result[3][0].get_str(), "1.1.1.1:19999");
diff --git a/test/functional/feature_llmq_dkgerrors.py b/test/functional/feature_llmq_dkgerrors.py
index 187bea3b8bc8..f86c656200cd 100755
--- a/test/functional/feature_llmq_dkgerrors.py
+++ b/test/functional/feature_llmq_dkgerrors.py
@@ -37,18 +37,18 @@ def run_test(self):
         mninfos_valid = self.mninfo.copy()[1:]
 
         self.log.info("Lets omit the contribution")
-        self.mninfo[0].get_node(self).quorum('dkgsimerror', 'contribution-omit', '100')
+        self.mninfo[0].get_node(self).quorum('dkgsimerror', 'contribution-omit', 100)
         qh = self.mine_quorum(expected_contributions=2, mninfos_valid=mninfos_valid)
         self.assert_member_valid(qh, self.mninfo[0].proTxHash, False)
 
         self.log.info("Lets lie in the contribution but provide a correct justification")
-        self.mninfo[0].get_node(self).quorum('dkgsimerror', 'contribution-omit', '0')
-        self.mninfo[0].get_node(self).quorum('dkgsimerror', 'contribution-lie', '100')
+        self.mninfo[0].get_node(self).quorum('dkgsimerror', 'contribution-omit', 0)
+        self.mninfo[0].get_node(self).quorum('dkgsimerror', 'contribution-lie', 100)
         qh = self.mine_quorum(expected_contributions=3, expected_complaints=2, expected_justifications=1, mninfos_valid=mninfos_valid)
         self.assert_member_valid(qh, self.mninfo[0].proTxHash, True)
 
         self.log.info("Lets lie in the contribution and then omit the justification")
-        self.mninfo[0].get_node(self).quorum('dkgsimerror', 'justify-omit', '100')
+        self.mninfo[0].get_node(self).quorum('dkgsimerror', 'justify-omit', 100)
         qh = self.mine_quorum(expected_contributions=3, expected_complaints=2, mninfos_valid=mninfos_valid)
         self.assert_member_valid(qh, self.mninfo[0].proTxHash, False)
 
@@ -56,27 +56,27 @@ def run_test(self):
         self.heal_masternodes(33)
 
         self.log.info("Lets lie in the contribution and then also lie in the justification")
-        self.mninfo[0].get_node(self).quorum('dkgsimerror', 'justify-omit', '0')
-        self.mninfo[0].get_node(self).quorum('dkgsimerror', 'justify-lie', '100')
+        self.mninfo[0].get_node(self).quorum('dkgsimerror', 'justify-omit', 0)
+        self.mninfo[0].get_node(self).quorum('dkgsimerror', 'justify-lie', 100)
         qh = self.mine_quorum(expected_contributions=3, expected_complaints=2, expected_justifications=1, mninfos_valid=mninfos_valid)
         self.assert_member_valid(qh, self.mninfo[0].proTxHash, False)
 
         self.log.info("Lets lie about another MN")
-        self.mninfo[0].get_node(self).quorum('dkgsimerror', 'contribution-lie', '0')
-        self.mninfo[0].get_node(self).quorum('dkgsimerror', 'justify-lie', '0')
-        self.mninfo[0].get_node(self).quorum('dkgsimerror', 'complain-lie', '100')
+        self.mninfo[0].get_node(self).quorum('dkgsimerror', 'contribution-lie', 0)
+        self.mninfo[0].get_node(self).quorum('dkgsimerror', 'justify-lie', 0)
+        self.mninfo[0].get_node(self).quorum('dkgsimerror', 'complain-lie', 100)
         qh = self.mine_quorum(expected_contributions=3, expected_complaints=1, expected_justifications=2, mninfos_valid=mninfos_valid)
         self.assert_member_valid(qh, self.mninfo[0].proTxHash, True)
 
         self.log.info("Lets omit 1 premature commitments")
-        self.mninfo[0].get_node(self).quorum('dkgsimerror', 'complain-lie', '0')
-        self.mninfo[0].get_node(self).quorum('dkgsimerror', 'commit-omit', '100')
+        self.mninfo[0].get_node(self).quorum('dkgsimerror', 'complain-lie', 0)
+        self.mninfo[0].get_node(self).quorum('dkgsimerror', 'commit-omit', 100)
         qh = self.mine_quorum(expected_contributions=3, expected_complaints=0, expected_justifications=0, expected_commitments=2, mninfos_valid=mninfos_valid)
         self.assert_member_valid(qh, self.mninfo[0].proTxHash, True)
 
         self.log.info("Lets lie in 1 premature commitments")
-        self.mninfo[0].get_node(self).quorum('dkgsimerror', 'commit-omit', '0')
-        self.mninfo[0].get_node(self).quorum('dkgsimerror', 'commit-lie', '100')
+        self.mninfo[0].get_node(self).quorum('dkgsimerror', 'commit-omit', 0)
+        self.mninfo[0].get_node(self).quorum('dkgsimerror', 'commit-lie', 100)
         qh = self.mine_quorum(expected_contributions=3, expected_complaints=0, expected_justifications=0, expected_commitments=2, mninfos_valid=mninfos_valid)
         self.assert_member_valid(qh, self.mninfo[0].proTxHash, True)
 

From c85984a601e9a3e6e13840c12a655067ecad0855 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Sun, 11 Jan 2026 12:01:39 +0530
Subject: [PATCH 14/16] refactor: remove `ParseInt{32,64}V()` usage in
 Dash-specific code

---
 src/rpc/client.cpp     | 40 ++++++++++++++++++++++++++++++++++++++++
 src/rpc/evo.cpp        | 12 ++++++------
 src/rpc/governance.cpp | 12 ++++++------
 src/rpc/masternode.cpp |  2 +-
 src/rpc/quorums.cpp    | 32 ++++++++++++++++----------------
 5 files changed, 69 insertions(+), 29 deletions(-)

diff --git a/src/rpc/client.cpp b/src/rpc/client.cpp
index 636ca29d6163..bbb806edf56c 100644
--- a/src/rpc/client.cpp
+++ b/src/rpc/client.cpp
@@ -255,8 +255,28 @@ static const CRPCConvertParam vRPCConvertParams[] =
     { "verifyislock", 3, "maxHeight" },
     { "submitchainlock", 2, "blockHeight" },
     { "mnauth", 0, "nodeId" },
+    // Compound RPCs (note: index position is offset by one to account for subcommand)
+    { "evodb repair", 1, "startBlock" },
+    { "evodb repair", 2, "stopBlock" },
+    { "evodb verify", 1, "startBlock" },
+    { "evodb verify", 2, "stopBlock" },
+    { "gobject list-prepared", 1, "count" },
+    { "gobject prepare", 2, "revision" },
+    { "gobject prepare", 3, "time" },
+    { "gobject prepare", 7, "outputIndex" },
+    { "gobject submit", 2, "revision" },
+    { "gobject submit", 3, "time" },
+    { "masternode payments", 2, "count" },
+    { "protx diff", 1, "baseBlock" },
+    { "protx diff", 2, "block" },
+    { "protx list", 3, "height" },
+    { "protx listdiff", 1, "baseBlock" },
+    { "protx listdiff", 2, "block" },
+    { "protx register", 2, "collateralIndex" },
     { "protx register", 3, "coreP2PAddrs", true },
+    { "protx register_legacy", 2, "collateralIndex" },
     { "protx register_legacy", 3, "coreP2PAddrs", true },
+    { "protx register_evo", 2, "collateralIndex" },
     { "protx register_evo", 3, "coreP2PAddrs", true },
     { "protx register_evo", 10, "platformP2PAddrs", true },
     { "protx register_evo", 11, "platformHTTPSAddrs", true },
@@ -265,15 +285,35 @@ static const CRPCConvertParam vRPCConvertParams[] =
     { "protx register_fund_evo", 2, "coreP2PAddrs", true },
     { "protx register_fund_evo", 9, "platformP2PAddrs", true },
     { "protx register_fund_evo", 10, "platformHTTPSAddrs", true },
+    { "protx register_prepare", 2, "collateralIndex" },
     { "protx register_prepare", 3, "coreP2PAddrs", true },
+    { "protx register_prepare_legacy", 2, "collateralIndex" },
     { "protx register_prepare_legacy", 3, "coreP2PAddrs", true },
+    { "protx register_prepare_evo", 2, "collateralIndex" },
     { "protx register_prepare_evo", 3, "coreP2PAddrs", true },
     { "protx register_prepare_evo", 10, "platformP2PAddrs", true },
     { "protx register_prepare_evo", 11, "platformHTTPSAddrs", true },
+    { "protx revoke", 3, "reason" },
     { "protx update_service", 2, "coreP2PAddrs", true },
     { "protx update_service_evo", 2, "coreP2PAddrs", true },
     { "protx update_service_evo", 5, "platformP2PAddrs", true },
     { "protx update_service_evo", 6, "platformHTTPSAddrs", true },
+    { "quorum dkgsimerror", 2, "rate" },
+    { "quorum dkgstatus", 1, "detail_level" },
+    { "quorum getdata", 1, "nodeId" },
+    { "quorum getdata", 2, "llmqType" },
+    { "quorum getdata", 4, "dataMask" },
+    { "quorum getrecsig", 1, "llmqType" },
+    { "quorum hasrecsig", 1, "llmqType" },
+    { "quorum info", 1, "llmqType" },
+    { "quorum isconflicting", 1, "llmqType" },
+    { "quorum listextended", 1, "height" },
+    { "quorum list", 1, "count" },
+    { "quorum memberof", 2, "scanQuorumsCount" },
+    { "quorum selectquorum", 1, "llmqType" },
+    { "quorum sign", 1, "llmqType" },
+    { "quorum verify", 1, "llmqType" },
+    { "quorum verify", 6, "signHeight" },
 };
 // clang-format on
 
diff --git a/src/rpc/evo.cpp b/src/rpc/evo.cpp
index d5d9c0dc1f1e..94af17898e33 100644
--- a/src/rpc/evo.cpp
+++ b/src/rpc/evo.cpp
@@ -713,7 +713,7 @@ static UniValue protx_register_common_wrapper(const JSONRPCRequest& request,
         paramIdx++;
     } else {
         uint256 collateralHash(ParseHashV(request.params[paramIdx], "collateralHash"));
-        int32_t collateralIndex = ParseInt32V(request.params[paramIdx + 1], "collateralIndex");
+        int32_t collateralIndex = request.params[paramIdx + 1].getInt<int>();
         if (collateralHash.IsNull() || collateralIndex < 0) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("invalid hash or index: %s-%d", collateralHash.ToString(), collateralIndex));
         }
@@ -1267,7 +1267,7 @@ static RPCHelpMan protx_revoke()
     CBLSSecretKey keyOperator = ParseBLSSecretKey(request.params[1].get_str(), "operatorKey");
 
     if (!request.params[2].isNull()) {
-        int32_t nReason = ParseInt32V(request.params[2], "reason");
+        int32_t nReason = request.params[2].getInt<int>();
         if (nReason < 0 || nReason > CProUpRevTx::REASON_LAST) {
             throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("invalid reason %d, must be between 0 and %d", nReason, CProUpRevTx::REASON_LAST));
         }
@@ -1452,7 +1452,7 @@ static RPCHelpMan protx_list()
         bool detailed = !request.params[1].isNull() ? ParseBoolV(request.params[1], "detailed") : false;
 
         LOCK2(wallet->cs_wallet, ::cs_main);
-        int height = !request.params[2].isNull() ? ParseInt32V(request.params[2], "height") : chainman.ActiveChain().Height();
+        int height = !request.params[2].isNull() ? request.params[2].getInt<int>() : chainman.ActiveChain().Height();
         if (height < 1 || height > chainman.ActiveChain().Height()) {
             throw JSONRPCError(RPC_INVALID_PARAMETER, "invalid height specified");
         }
@@ -1485,7 +1485,7 @@ static RPCHelpMan protx_list()
 #else
         LOCK(::cs_main);
 #endif
-        int height = !request.params[2].isNull() ? ParseInt32V(request.params[2], "height") : chainman.ActiveChain().Height();
+        int height = !request.params[2].isNull() ? request.params[2].getInt<int>() : chainman.ActiveChain().Height();
         if (height < 1 || height > chainman.ActiveChain().Height()) {
             throw JSONRPCError(RPC_INVALID_PARAMETER, "invalid height specified");
         }
@@ -1577,7 +1577,7 @@ static uint256 ParseBlock(const UniValue& v, const ChainstateManager& chainman,
     try {
         return ParseHashV(v, strName);
     } catch (...) {
-        int h = ParseInt32V(v, strName);
+        int h = v.getInt<int>();
         if (h < 1 || h > chainman.ActiveChain().Height())
             throw std::runtime_error(strprintf("%s must be a block hash or chain height and not %s", strName, v.getValStr()));
         return *chainman.ActiveChain()[h]->phashBlock;
@@ -1636,7 +1636,7 @@ static const CBlockIndex* ParseBlockIndex(const UniValue& v, const ChainstateMan
             throw std::runtime_error(strprintf("Block %s with hash %s not found", strName, v.getValStr()));
         return pblockindex;
     } catch (...) {
-        int h = ParseInt32V(v, strName);
+        int h = v.getInt<int>();
         if (h < 1 || h > chainman.ActiveChain().Height())
             throw std::runtime_error(strprintf("%s must be a chain height and not %s", strName, v.getValStr()));
         return chainman.ActiveChain()[h];
diff --git a/src/rpc/governance.cpp b/src/rpc/governance.cpp
index 6dd142cbbbd2..13f7cf6f609f 100644
--- a/src/rpc/governance.cpp
+++ b/src/rpc/governance.cpp
@@ -176,8 +176,8 @@ static RPCHelpMan gobject_prepare()
         hashParent = ParseHashV(request.params[0], "parent-hash");
     }
 
-    int nRevision = ParseInt32V(request.params[1], "revision");
-    int64_t nTime = ParseInt64V(request.params[2], "time");
+    int nRevision = request.params[1].getInt<int>();
+    int64_t nTime = request.params[2].getInt<int64_t>();
     std::string strDataHex = request.params[3].get_str();
 
     // CREATE A NEW COLLATERAL TRANSACTION FOR THIS SPECIFIC OBJECT
@@ -225,7 +225,7 @@ static RPCHelpMan gobject_prepare()
     outpoint.SetNull();
     if (!request.params[5].isNull() && !request.params[6].isNull()) {
         uint256 collateralHash(ParseHashV(request.params[5], "outputHash"));
-        int32_t collateralIndex = ParseInt32V(request.params[6], "outputIndex");
+        int32_t collateralIndex = request.params[6].getInt<int>();
         if (collateralHash.IsNull() || collateralIndex < 0) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("invalid hash or index: %s-%d", collateralHash.ToString(), collateralIndex));
         }
@@ -278,7 +278,7 @@ static RPCHelpMan gobject_list_prepared()
     if (!wallet) return UniValue::VNULL;
     EnsureWalletIsUnlocked(*wallet);
 
-    int64_t nCount = request.params.empty() ? 10 : ParseInt64V(request.params[0], "count");
+    int64_t nCount = request.params.empty() ? 10 : request.params[0].getInt<int64_t>();
     if (nCount < 0) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "Negative count");
     }
@@ -361,8 +361,8 @@ static RPCHelpMan gobject_submit()
 
     // GET THE PARAMETERS FROM USER
 
-    int nRevision = ParseInt32V(request.params[1], "revision");
-    int64_t nTime = ParseInt64V(request.params[2], "time");
+    int nRevision = request.params[1].getInt<int>();
+    int64_t nTime = request.params[2].getInt<int64_t>();
     std::string strDataHex = request.params[3].get_str();
 
     CGovernanceObject govobj(hashParent, nRevision, nTime, txidFee, strDataHex);
diff --git a/src/rpc/masternode.cpp b/src/rpc/masternode.cpp
index 6ba736403719..36e367ce6ceb 100644
--- a/src/rpc/masternode.cpp
+++ b/src/rpc/masternode.cpp
@@ -382,7 +382,7 @@ static RPCHelpMan masternode_payments()
         }
     }
 
-    int64_t nCount = request.params.size() > 1 ? ParseInt64V(request.params[1], "count") : 1;
+    int64_t nCount = request.params.size() > 1 ? request.params[1].getInt<int64_t>() : 1;
 
     // A temporary vector which is used to sort results properly (there is no "reverse" in/for UniValue)
     std::vector<UniValue> vecPayments;
diff --git a/src/rpc/quorums.cpp b/src/rpc/quorums.cpp
index 3ed5f4c35878..729814cc2e44 100644
--- a/src/rpc/quorums.cpp
+++ b/src/rpc/quorums.cpp
@@ -70,7 +70,7 @@ static RPCHelpMan quorum_list()
 
     int count = -1;
     if (!request.params[0].isNull()) {
-        count = ParseInt32V(request.params[0], "count");
+        count = request.params[0].getInt<int>();
         if (count < -1) {
             throw JSONRPCError(RPC_INVALID_PARAMETER, "count can't be negative");
         }
@@ -136,7 +136,7 @@ static RPCHelpMan quorum_list_extended()
 
     int nHeight = -1;
     if (!request.params[0].isNull()) {
-        nHeight = ParseInt32V(request.params[0], "height");
+        nHeight = request.params[0].getInt<int>();
         if (nHeight < 0 || nHeight > WITH_LOCK(cs_main, return chainman.ActiveChain().Height())) {
             throw JSONRPCError(RPC_INVALID_PARAMETER, "Block height out of range");
         }
@@ -275,7 +275,7 @@ static RPCHelpMan quorum_info()
     const NodeContext& node = EnsureAnyNodeContext(request.context);
     const LLMQContext& llmq_ctx = EnsureLLMQContext(node);
 
-    const Consensus::LLMQType llmqType{static_cast<Consensus::LLMQType>(ParseInt32V(request.params[0], "llmqType"))};
+    const Consensus::LLMQType llmqType{static_cast<Consensus::LLMQType>(request.params[0].getInt<int>())};
     if (!Params().GetLLMQ(llmqType).has_value()) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "invalid LLMQ type");
     }
@@ -336,7 +336,7 @@ static RPCHelpMan quorum_dkgstatus()
 {
     int detailLevel = 0;
     if (!request.params[0].isNull()) {
-        detailLevel = ParseInt32V(request.params[0], "detail_level");
+        detailLevel = request.params[0].getInt<int>();
         if (detailLevel < 0 || detailLevel > 2) {
             throw JSONRPCError(RPC_INVALID_PARAMETER, "invalid detail_level");
         }
@@ -462,7 +462,7 @@ static RPCHelpMan quorum_memberof()
     uint256 protxHash(ParseHashV(request.params[0], "proTxHash"));
     int scanQuorumsCount = -1;
     if (!request.params[1].isNull()) {
-        scanQuorumsCount = ParseInt32V(request.params[1], "scanQuorumsCount");
+        scanQuorumsCount = request.params[1].getInt<int>();
         if (scanQuorumsCount <= 0) {
             throw JSONRPCError(RPC_INVALID_PARAMETER, "invalid scanQuorumsCount parameter");
         }
@@ -592,7 +592,7 @@ static RPCHelpMan quorum_sign()
         RPCExamples{""},
         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
 {
-    const Consensus::LLMQType llmqType{static_cast<Consensus::LLMQType>(ParseInt32V(request.params[0], "llmqType"))};
+    const Consensus::LLMQType llmqType{static_cast<Consensus::LLMQType>(request.params[0].getInt<int>())};
 
     JSONRPCRequest new_request{request};
     new_request.params.setArray();
@@ -661,7 +661,7 @@ static RPCHelpMan quorum_verify()
     const ChainstateManager& chainman = EnsureChainman(node);
     const LLMQContext& llmq_ctx = EnsureLLMQContext(node);
 
-    const Consensus::LLMQType llmqType{static_cast<Consensus::LLMQType>(ParseInt32V(request.params[0], "llmqType"))};
+    const Consensus::LLMQType llmqType{static_cast<Consensus::LLMQType>(request.params[0].getInt<int>())};
 
     const auto llmq_params_opt = Params().GetLLMQ(llmqType);
     if (!llmq_params_opt.has_value()) {
@@ -680,7 +680,7 @@ static RPCHelpMan quorum_verify()
     if (request.params[4].isNull() || (request.params[4].get_str().empty() && !request.params[5].isNull())) {
         int signHeight{-1};
         if (!request.params[5].isNull()) {
-            signHeight = ParseInt32V(request.params[5], "signHeight");
+            signHeight = request.params[5].getInt<int>();
         }
         return VerifyRecoveredSigLatestQuorums(*llmq_params_opt, chainman.ActiveChain(), *llmq_ctx.qman, signHeight, id, msgHash, sig);
     }
@@ -714,7 +714,7 @@ static RPCHelpMan quorum_hasrecsig()
     const NodeContext& node = EnsureAnyNodeContext(request.context);
     const LLMQContext& llmq_ctx = EnsureLLMQContext(node);
 
-    const Consensus::LLMQType llmqType{static_cast<Consensus::LLMQType>(ParseInt32V(request.params[0], "llmqType"))};
+    const Consensus::LLMQType llmqType{static_cast<Consensus::LLMQType>(request.params[0].getInt<int>())};
     if (!Params().GetLLMQ(llmqType).has_value()) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "invalid LLMQ type");
     }
@@ -743,7 +743,7 @@ static RPCHelpMan quorum_getrecsig()
     const NodeContext& node = EnsureAnyNodeContext(request.context);
     const LLMQContext& llmq_ctx = EnsureLLMQContext(node);
 
-    const Consensus::LLMQType llmqType{static_cast<Consensus::LLMQType>(ParseInt32V(request.params[0], "llmqType"))};
+    const Consensus::LLMQType llmqType{static_cast<Consensus::LLMQType>(request.params[0].getInt<int>())};
     if (!Params().GetLLMQ(llmqType).has_value()) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "invalid LLMQ type");
     }
@@ -779,7 +779,7 @@ static RPCHelpMan quorum_isconflicting()
     const NodeContext& node = EnsureAnyNodeContext(request.context);
     const LLMQContext& llmq_ctx = EnsureLLMQContext(node);
 
-    const Consensus::LLMQType llmqType{static_cast<Consensus::LLMQType>(ParseInt32V(request.params[0], "llmqType"))};
+    const Consensus::LLMQType llmqType{static_cast<Consensus::LLMQType>(request.params[0].getInt<int>())};
     if (!Params().GetLLMQ(llmqType).has_value()) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "invalid LLMQ type");
     }
@@ -816,7 +816,7 @@ static RPCHelpMan quorum_selectquorum()
     const ChainstateManager& chainman = EnsureChainman(node);
     const LLMQContext& llmq_ctx = EnsureLLMQContext(node);
 
-    const Consensus::LLMQType llmqType{static_cast<Consensus::LLMQType>(ParseInt32V(request.params[0], "llmqType"))};
+    const Consensus::LLMQType llmqType{static_cast<Consensus::LLMQType>(request.params[0].getInt<int>())};
     const auto llmq_params_opt = Params().GetLLMQ(llmqType);
     if (!llmq_params_opt.has_value()) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "invalid LLMQ type");
@@ -858,7 +858,7 @@ static RPCHelpMan quorum_dkgsimerror()
         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
 {
     std::string type_str = request.params[0].get_str();
-    int32_t rate = ParseInt32V(request.params[1], "rate");
+    int32_t rate = request.params[1].getInt<int>();
 
     if (rate < 0 || rate > 100) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "invalid rate. Must be between 0 and 100");
@@ -898,10 +898,10 @@ static RPCHelpMan quorum_getdata()
     const LLMQContext& llmq_ctx = EnsureLLMQContext(node);
     CConnman& connman = EnsureConnman(node);
 
-    NodeId nodeId = ParseInt64V(request.params[0], "nodeId");
-    Consensus::LLMQType llmqType = static_cast<Consensus::LLMQType>(ParseInt32V(request.params[1], "llmqType"));
+    NodeId nodeId = request.params[0].getInt<int64_t>();
+    Consensus::LLMQType llmqType = static_cast<Consensus::LLMQType>(request.params[1].getInt<int>());
     uint256 quorumHash(ParseHashV(request.params[2], "quorumHash"));
-    uint16_t nDataMask = static_cast<uint16_t>(ParseInt32V(request.params[3], "dataMask"));
+    uint16_t nDataMask = static_cast<uint16_t>(request.params[3].getInt<int>());
     uint256 proTxHash;
 
     // Check if request wants ENCRYPTED_CONTRIBUTIONS data

From d2e7d75d6a04456201dd1f187286530164195188 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Sat, 10 Jan 2026 13:13:49 +0530
Subject: [PATCH 15/16] chore: drop unused `ParseInt{32,64}V()`, unresolvable
 `ParseDoubleV()`

---
 src/rpc/util.cpp | 18 ------------------
 src/rpc/util.h   |  3 ---
 2 files changed, 21 deletions(-)

diff --git a/src/rpc/util.cpp b/src/rpc/util.cpp
index 9aae2d7e0c96..98ff485c5de4 100644
--- a/src/rpc/util.cpp
+++ b/src/rpc/util.cpp
@@ -121,24 +121,6 @@ std::vector<unsigned char> ParseHexO(const UniValue& o, std::string strKey)
     return ParseHexV(o.find_value(strKey), strKey);
 }
 
-int32_t ParseInt32V(const UniValue& v, const std::string &strName)
-{
-    const std::string& strNum = v.getValStr();
-    int32_t num;
-    if (!ParseInt32(strNum, &num))
-        throw JSONRPCError(RPC_INVALID_PARAMETER, strName+" must be a 32bit integer (not '"+strNum+"')");
-    return num;
-}
-
-int64_t ParseInt64V(const UniValue& v, const std::string &strName)
-{
-    const std::string& strNum = v.getValStr();
-    int64_t num;
-    if (!ParseInt64(strNum, &num))
-        throw JSONRPCError(RPC_INVALID_PARAMETER, strName+" must be a 64bit integer (not '"+strNum+"')");
-    return num;
-}
-
 bool ParseBoolV(const UniValue& v, const std::string &strName)
 {
     std::string strBool;
diff --git a/src/rpc/util.h b/src/rpc/util.h
index fe12b4cbaf4f..95c609397f64 100644
--- a/src/rpc/util.h
+++ b/src/rpc/util.h
@@ -93,9 +93,6 @@ uint256 ParseHashO(const UniValue& o, std::string strKey);
 std::vector<unsigned char> ParseHexV(const UniValue& v, std::string strName);
 std::vector<unsigned char> ParseHexO(const UniValue& o, std::string strKey);
 
-int32_t ParseInt32V(const UniValue& v, const std::string &strName);
-int64_t ParseInt64V(const UniValue& v, const std::string &strName);
-double ParseDoubleV(const UniValue& v, const std::string &strName);
 bool ParseBoolV(const UniValue& v, const std::string &strName);
 
 /**

From f7f06fc725d5b6708b080bc6f966cfe21852707d Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Sun, 11 Jan 2026 12:20:20 +0530
Subject: [PATCH 16/16] chore: add composite RPC bools to conversion table,
 deprecation later

We cannot simply get rid of `ParseBoolV` because upstream parsing logic
is much more stricter, constituting a breaking change. This requires us
to therefore follow the deprecation process.

But these changes are scheduled for a minor release, where this is not
permissible. So we lay the foundations needed for a deprecation and then
actually use it in the next release.

This commit is practically a no-op until "|| true" is removed from
`ParseBoolV()`
---
 src/rpc/client.cpp | 21 +++++++++++++++++++++
 src/rpc/util.cpp   | 39 +++++++++++++++++++++++++--------------
 2 files changed, 46 insertions(+), 14 deletions(-)

diff --git a/src/rpc/client.cpp b/src/rpc/client.cpp
index bbb806edf56c..bc6cef660cc9 100644
--- a/src/rpc/client.cpp
+++ b/src/rpc/client.cpp
@@ -256,6 +256,10 @@ static const CRPCConvertParam vRPCConvertParams[] =
     { "submitchainlock", 2, "blockHeight" },
     { "mnauth", 0, "nodeId" },
     // Compound RPCs (note: index position is offset by one to account for subcommand)
+    { "bls generate", 1, "legacy" },
+    { "bls fromsecret", 2, "legacy" },
+    { "coinjoinsalt generate", 1, "overwrite" },
+    { "coinjoinsalt set", 2, "overwrite" },
     { "evodb repair", 1, "startBlock" },
     { "evodb repair", 2, "stopBlock" },
     { "evodb verify", 1, "startBlock" },
@@ -266,25 +270,34 @@ static const CRPCConvertParam vRPCConvertParams[] =
     { "gobject prepare", 7, "outputIndex" },
     { "gobject submit", 2, "revision" },
     { "gobject submit", 3, "time" },
+    { "masternode connect", 2, "v2transport" },
     { "masternode payments", 2, "count" },
     { "protx diff", 1, "baseBlock" },
     { "protx diff", 2, "block" },
+    { "protx diff", 3, "extended" },
+    { "protx list", 2, "detailed" },
     { "protx list", 3, "height" },
     { "protx listdiff", 1, "baseBlock" },
     { "protx listdiff", 2, "block" },
     { "protx register", 2, "collateralIndex" },
     { "protx register", 3, "coreP2PAddrs", true },
+    { "protx register", 10, "submit" },
     { "protx register_legacy", 2, "collateralIndex" },
     { "protx register_legacy", 3, "coreP2PAddrs", true },
+    { "protx register_legacy", 10, "submit" },
     { "protx register_evo", 2, "collateralIndex" },
     { "protx register_evo", 3, "coreP2PAddrs", true },
     { "protx register_evo", 10, "platformP2PAddrs", true },
     { "protx register_evo", 11, "platformHTTPSAddrs", true },
+    { "protx register_evo", 13, "submit" },
     { "protx register_fund", 2, "coreP2PAddrs", true },
+    { "protx register_fund", 9, "submit" },
     { "protx register_fund_legacy", 2, "coreP2PAddrs", true },
+    { "protx register_fund_legacy", 9, "submit" },
     { "protx register_fund_evo", 2, "coreP2PAddrs", true },
     { "protx register_fund_evo", 9, "platformP2PAddrs", true },
     { "protx register_fund_evo", 10, "platformHTTPSAddrs", true },
+    { "protx register_fund_evo", 12, "submit" },
     { "protx register_prepare", 2, "collateralIndex" },
     { "protx register_prepare", 3, "coreP2PAddrs", true },
     { "protx register_prepare_legacy", 2, "collateralIndex" },
@@ -294,10 +307,15 @@ static const CRPCConvertParam vRPCConvertParams[] =
     { "protx register_prepare_evo", 10, "platformP2PAddrs", true },
     { "protx register_prepare_evo", 11, "platformHTTPSAddrs", true },
     { "protx revoke", 3, "reason" },
+    { "protx revoke", 5, "submit" },
+    { "protx update_registrar", 6, "submit" },
+    { "protx update_registrar_legacy", 6, "submit" },
     { "protx update_service", 2, "coreP2PAddrs", true },
+    { "protx update_service", 6, "submit" },
     { "protx update_service_evo", 2, "coreP2PAddrs", true },
     { "protx update_service_evo", 5, "platformP2PAddrs", true },
     { "protx update_service_evo", 6, "platformHTTPSAddrs", true },
+    { "protx update_service_evo", 9, "submit" },
     { "quorum dkgsimerror", 2, "rate" },
     { "quorum dkgstatus", 1, "detail_level" },
     { "quorum getdata", 1, "nodeId" },
@@ -306,12 +324,15 @@ static const CRPCConvertParam vRPCConvertParams[] =
     { "quorum getrecsig", 1, "llmqType" },
     { "quorum hasrecsig", 1, "llmqType" },
     { "quorum info", 1, "llmqType" },
+    { "quorum info", 3, "includeSkShare" },
     { "quorum isconflicting", 1, "llmqType" },
     { "quorum listextended", 1, "height" },
     { "quorum list", 1, "count" },
     { "quorum memberof", 2, "scanQuorumsCount" },
+    { "quorum rotationinfo", 2, "extraShare" },
     { "quorum selectquorum", 1, "llmqType" },
     { "quorum sign", 1, "llmqType" },
+    { "quorum sign", 5, "submit" },
     { "quorum verify", 1, "llmqType" },
     { "quorum verify", 6, "signHeight" },
 };
diff --git a/src/rpc/util.cpp b/src/rpc/util.cpp
index 98ff485c5de4..a571d55168ef 100644
--- a/src/rpc/util.cpp
+++ b/src/rpc/util.cpp
@@ -17,6 +17,8 @@
 #include <util/system.h>
 #include <util/translation.h>
 
+#include <util/std23.h>
+
 const std::string UNIX_EPOCH_TIME = "UNIX epoch time";
 const std::string EXAMPLE_ADDRESS[2] = {"XunLY9Tf7Zsef8gMGL2fhWA9ZmMjt4KPw0", "XwQQkwA4FYkq2XERzMY2CiAZhJTEDAbtc0"};
 
@@ -123,22 +125,31 @@ std::vector<unsigned char> ParseHexO(const UniValue& o, std::string strKey)
 
 bool ParseBoolV(const UniValue& v, const std::string &strName)
 {
-    std::string strBool;
-    if (v.isBool())
-        return v.get_bool();
-    else if (v.isNum())
-        strBool = ToString(v.getInt<int>());
-    else if (v.isStr())
-        strBool = v.get_str();
-
-    strBool = ToLower(strBool);
+    // TODO: Remove "|| true" before releasing v24 to enforce deprecation
+    if (std23::ranges::contains(gArgs.GetArgs("-deprecatedrpc"), "permissive_bool") || true) {
+        std::string strBool;
+        if (v.isBool())
+            return v.get_bool();
+        else if (v.isNum())
+            strBool = ToString(v.getInt<int>());
+        else if (v.isStr())
+            strBool = v.get_str();
+
+        strBool = ToLower(strBool);
+
+        if (strBool == "true" || strBool == "yes" || strBool == "1") {
+            return true;
+        } else if (strBool == "false" || strBool == "no" || strBool == "0") {
+            return false;
+        }
+        throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("%s must be true, false, yes, no, 1 or 0 (not '%s')", strName, strBool));
+    }
 
-    if (strBool == "true" || strBool == "yes" || strBool == "1") {
-        return true;
-    } else if (strBool == "false" || strBool == "no" || strBool == "0") {
-        return false;
+    if (!v.isBool()) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("%s must be a JSON boolean. " /* Continued */
+                           "Pass -deprecatedrpc=permissive_bool to allow legacy boolean parsing.", strName));
     }
-    throw JSONRPCError(RPC_INVALID_PARAMETER, strName+" must be true, false, yes, no, 1 or 0 (not '"+strBool+"')");
+    return v.get_bool();
 }
 
 namespace {