diff --git a/src/Makefile.am b/src/Makefile.am
index 1c5fd1936399..d49bba590b53 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 \
@@ -400,7 +399,7 @@ BITCOIN_CORE_H = \
   util/golombrice.h \
   util/hasher.h \
   util/hash_type.h \
-  util/irange.h \
+  util/helpers.h \
   util/asmap.h \
   util/getuniquepath.h \
   util/macros.h \
@@ -408,13 +407,11 @@ 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/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/dkgsession.cpp b/src/active/dkgsession.cpp
index 15eb449ece7f..efcbfe46aef9 100644
--- a/src/active/dkgsession.cpp
+++ b/src/active/dkgsession.cpp
@@ -12,6 +12,8 @@
 #include <llmq/options.h>
 #include <llmq/utils.h>
 #include <masternode/meta.h>
+#include <util/helpers.h>
+#include <util/std23.h>
 
 #include <chain.h>
 #include <deploymentstatus.h>
@@ -81,7 +83,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 +152,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 +269,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,9 +354,9 @@ 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) {
+        if (!std23::ranges::contains(forMembers, m->dmn->proTxHash)) {
             continue;
         }
         logger.Batch("justifying for %s", m->dmn->proTxHash.ToString());
@@ -444,7 +446,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;
@@ -559,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/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..043d31fa0982 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/helpers.h>
 
 #include <chain.h>
 #include <chainparams.h>
@@ -24,6 +25,8 @@
 
 #include <cxxtimer.hpp>
 
+#include <ranges>
+
 namespace llmq {
 QuorumParticipant::QuorumParticipant(CBLSWorker& bls_worker, CConnman& connman, CDeterministicMNManager& dmnman,
                                      QuorumObserverParent& qman, CQuorumSnapshotManager& qsnapman,
@@ -47,13 +50,15 @@ 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},
                                            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 +68,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());
                 }
             }
         }
@@ -96,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;
@@ -156,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"};
             }
@@ -209,7 +214,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)) {
@@ -224,7 +231,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/bench/bls_dkg.cpp b/src/bench/bls_dkg.cpp
index 14e83810a100..dc157ca0ebd3 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/helpers.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/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/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..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/system.h>
-#include <util/underlying.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;
@@ -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/coinjoin/client.cpp b/src/coinjoin/client.cpp
index 8299cd9d86cb..be6727cc41b1 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/helpers.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.
@@ -620,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;
@@ -1302,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());
@@ -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;
@@ -1768,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/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..6db358e6c3e6 100644
--- a/src/coinjoin/coinjoin.cpp
+++ b/src/coinjoin/coinjoin.cpp
@@ -4,6 +4,12 @@
 
 #include <coinjoin/coinjoin.h>
 
+#include <bls/bls.h>
+#include <chainlock/chainlock.h>
+#include <instantsend/instantsend.h>
+#include <masternode/sync.h>
+#include <util/helpers.h>
+
 #include <chain.h>
 #include <chainparams.h>
 #include <txmempool.h>
@@ -13,11 +19,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};
@@ -63,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
@@ -104,7 +106,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..0d190414de65 100644
--- a/src/coinjoin/coinjoin.h
+++ b/src/coinjoin/coinjoin.h
@@ -7,13 +7,14 @@
 
 #include <coinjoin/common.h>
 
+#include <util/helpers.h>
+
 #include <core_io.h>
 #include <netaddress.h>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
 #include <sync.h>
 #include <timedata.h>
-#include <univalue.h>
 #include <util/translation.h>
 #include <version.h>
 
@@ -22,6 +23,8 @@
 #include <optional>
 #include <utility>
 
+#include <univalue.h>
+
 class CChainState;
 class CBLSPublicKey;
 class CBlockIndex;
@@ -346,7 +349,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..6c7abfba2266 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/helpers.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/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/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/deterministicmns.cpp b/src/evo/deterministicmns.cpp
index aa97f67de072..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/irange.h>
-#include <util/pointer.h>
+#include <util/helpers.h>
 
 #include <chainparams.h>
 #include <coins.h>
@@ -29,6 +28,7 @@
 #include <functional>
 #include <optional>
 #include <memory>
+#include <ranges>
 
 #include <univalue.h>
 
@@ -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;
     }
@@ -242,7 +243,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;
                     }
@@ -253,14 +254,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);
         }
     }
@@ -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);
         });
@@ -1465,7 +1466,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/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/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/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);
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/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/evo/smldiff.cpp b/src/evo/smldiff.cpp
index 823b24af1572..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,14 +74,14 @@ 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.
         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/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/governance/classes.cpp b/src/governance/classes.cpp
index 405ebbc530c5..954473a600fe 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");
     }
 
@@ -232,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/governance/governance.cpp b/src/governance/governance.cpp
index d64b63414939..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 {
@@ -284,7 +287,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 +302,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 +1292,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/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/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/instantsend/signing.cpp b/src/instantsend/signing.cpp
index 783b5757ca22..c2d247827c4b 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/helpers.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,
@@ -337,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 86b9617ff004..ce7948e62132 100644
--- a/src/llmq/blockprocessor.cpp
+++ b/src/llmq/blockprocessor.cpp
@@ -3,12 +3,14 @@
 // 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/helpers.h>
+#include <util/std23.h>
 
 #include <chain.h>
 #include <chainparams.h>
@@ -21,8 +23,6 @@
 #include <primitives/transaction.h>
 #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;
 }
@@ -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;
     }
@@ -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 {};
     }
 
@@ -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 7ee08a9fbd5d..b492df2e0c2d 100644
--- a/src/llmq/commitment.cpp
+++ b/src/llmq/commitment.cpp
@@ -6,17 +6,20 @@
 
 #include <evo/deterministicmns.h>
 #include <evo/specialtx.h>
+#include <llmq/options.h>
+#include <llmq/utils.h>
+#include <util/helpers.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>
 
+#include <ranges>
+
 namespace llmq
 {
 
@@ -35,7 +38,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();
@@ -58,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;
             }
@@ -98,7 +101,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();
@@ -154,14 +157,14 @@ 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];
         }
         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;
@@ -188,7 +191,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,13 +229,13 @@ 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");
     }
 
     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 3a8337b62746..292db406c71f 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/helpers.h>
+#include <util/std23.h>
+
+#include <primitives/transaction.h>
+#include <util/strencodings.h>
 
 #include <gsl/pointers.h>
 #include <univalue.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/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..0c5993d6c867 100644
--- a/src/llmq/debug.cpp
+++ b/src/llmq/debug.cpp
@@ -4,15 +4,15 @@
 
 #include <llmq/debug.h>
 
+#include <evo/deterministicmns.h>
+#include <llmq/utils.h>
+#include <util/helpers.h>
+#include <util/std23.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>
-
 namespace llmq
 {
 UniValue CDKGDebugSessionStatus::ToJson(CDeterministicMNManager& dmnman, CQuorumSnapshotManager& qsnapman,
@@ -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);
@@ -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 fba7e8b38d39..7346d30ec76d 100644
--- a/src/llmq/dkgsession.cpp
+++ b/src/llmq/dkgsession.cpp
@@ -12,19 +12,21 @@
 #include <llmq/options.h>
 #include <llmq/utils.h>
 #include <masternode/meta.h>
-#include <util/irange.h>
+#include <util/helpers.h>
+#include <util/std23.h>
 
 #include <chainparams.h>
 #include <deploymentstatus.h>
 #include <logging.h>
-#include <util/underlying.h>
 #include <validation.h>
 
 #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) :
@@ -35,18 +37,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 (type >= DKGError::type::_COUNT) return 0;
+    return simDkgErrorMap[std23::to_underlying(type)];
 }
 
 bool CDKGSession::ShouldSimulateError(DKGError::type type) const
@@ -93,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;
@@ -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());
 
@@ -356,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());
@@ -576,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;
@@ -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/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..76384c8e73ed 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/helpers.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};
         }
 
@@ -285,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};
@@ -294,14 +295,14 @@ 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;
                 }
                 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);
                 }
@@ -329,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;
@@ -341,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)) {
@@ -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/dkgsessionmgr.h b/src/llmq/dkgsessionmgr.h
index 56a13e7be285..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/irange.h>
+#include <util/helpers.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 cd37b14f86d9..6f0b019a84cb 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/helpers.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();
@@ -93,12 +94,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 +115,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 +176,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 +313,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..2241bc13efdc 100644
--- a/src/llmq/options.cpp
+++ b/src/llmq/options.cpp
@@ -5,17 +5,18 @@
 #include <llmq/options.h>
 
 #include <spork.h>
+#include <util/helpers.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>
+#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..0fb761ea18a7 100644
--- a/src/llmq/quorums.cpp
+++ b/src/llmq/quorums.cpp
@@ -6,10 +6,12 @@
 
 #include <evo/deterministicmns.h>
 #include <llmq/commitment.h>
+#include <util/helpers.h>
 
 #include <dbwrapper.h>
 
 #include <memory>
+#include <ranges>
 
 namespace llmq {
 const std::string DB_QUORUM_SK_SHARE = "q_Qsk";
@@ -134,14 +136,12 @@ 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
 {
-    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];
@@ -178,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);
@@ -217,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 ffcb90878fbf..f25eb8ad6ada 100644
--- a/src/llmq/quorumsman.cpp
+++ b/src/llmq/quorumsman.cpp
@@ -15,7 +15,8 @@
 #include <llmq/params.h>
 #include <llmq/signhash.h>
 #include <llmq/utils.h>
-#include <util/irange.h>
+#include <util/helpers.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,8 +284,8 @@ 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(),
-                      populate_cache ? "true" : "false");
+                      __func__, std23::to_underlying(llmqType), pQuorumBaseBlockIndex->GetBlockHash().ToString(),
+                      util::to_string(populate_cache));
             return {};
         }
         vecResultQuorums.emplace_back(quorum);
@@ -583,11 +583,11 @@ 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
-        for (const auto i : irange::range(pQuorum->members.size())) {
+        for (const auto i : util::irange(pQuorum->members.size())) {
             if (m_cache_interrupt) {
                 break;
             }
@@ -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());
     }
 }
@@ -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.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 5892b6e51bc5..2c174bcd6063 100644
--- a/src/llmq/signing_shares.cpp
+++ b/src/llmq/signing_shares.cpp
@@ -13,8 +13,8 @@
 #include <llmq/signhash.h>
 #include <llmq/signing.h>
 #include <spork.h>
-#include <util/irange.h>
-#include <util/underlying.h>
+#include <util/helpers.h>
+#include <util/std23.h>
 
 #include <chainparams.h>
 #include <net_processing.h>
@@ -25,6 +25,8 @@
 
 #include <cxxtimer.hpp>
 
+#include <ranges>
+
 namespace llmq
 {
 void CSigShare::UpdateKey()
@@ -36,12 +38,12 @@ 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)
 {
-    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];
         }
@@ -57,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;
         }
@@ -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,25 +306,23 @@ 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;
         }
     } 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());
             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;
         }
@@ -662,7 +660,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);
@@ -1055,7 +1053,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;
                 }
@@ -1128,7 +1126,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;
                 }
@@ -1273,8 +1271,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(
@@ -1517,7 +1515,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());
@@ -1762,7 +1760,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 +1803,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/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
diff --git a/src/llmq/snapshot.h b/src/llmq/snapshot.h
index d85758dd84df..6877366f2e6d 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/helpers.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 71720b6a3ba1..892f537151ec 100644
--- a/src/llmq/utils.cpp
+++ b/src/llmq/utils.cpp
@@ -10,20 +10,20 @@
 #include <llmq/snapshot.h>
 #include <llmq/types.h>
 #include <masternode/meta.h>
-#include <util/irange.h>
-#include <util/ranges.h>
+#include <util/helpers.h>
+#include <util/std23.h>
 
 #include <chainparams.h>
 #include <deploymentstatus.h>
 #include <net.h>
 #include <random.h>
 #include <util/time.h>
-#include <util/underlying.h>
 #include <validation.h>
 
 #include <atomic>
 #include <map>
 #include <optional>
+#include <ranges>
 
 /**
  * Forward declarations
@@ -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;
@@ -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()};
@@ -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);
     }
@@ -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/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/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/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/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/rpc/quorums.cpp b/src/rpc/quorums.cpp
index f82ec32def8d..3ed5f4c35878 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/helpers.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..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/irange.h>
+#include <util/helpers.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/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/spork.cpp b/src/spork.cpp
index 9842e44226f6..5413293561f7 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/helpers.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/test/block_reward_reallocation_tests.cpp b/src/test/block_reward_reallocation_tests.cpp
index ffb7ced72a22..e62edd4595d2 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/helpers.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);
@@ -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..8161dc58ff4d 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/helpers.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/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 9e57d63354d5..2059ab0cb272 100644
--- a/src/test/llmq_dkg_tests.cpp
+++ b/src/test/llmq_dkg_tests.cpp
@@ -3,8 +3,8 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <llmq/dkgsession.h>
-#include <util/irange.h>
-#include <util/underlying.h>
+#include <util/helpers.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 : 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/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/helpers.h b/src/util/helpers.h
new file mode 100644
index 000000000000..fbf2911619e0
--- /dev/null
+++ b/src/util/helpers.h
@@ -0,0 +1,54 @@
+// 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>
+#include <string_view>
+
+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
+}
+
+inline constexpr std::string_view to_string(bool value)
+{
+    return value ? "true" : "false";
+}
+} // namespace util
+
+#endif // BITCOIN_UTIL_HELPERS_H
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/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 055745a20d6e..000000000000
--- a/src/util/ranges.h
+++ /dev/null
@@ -1,25 +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 ranges {
-using namespace std::ranges;
-
-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)>>{};
-}
-}
-
-#endif // BITCOIN_UTIL_RANGES_H
diff --git a/src/util/std23.h b/src/util/std23.h
new file mode 100644
index 000000000000..81ea19a34e52
--- /dev/null
+++ b/src/util/std23.h
@@ -0,0 +1,107 @@
+// 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 <algorithm>
+#include <functional>
+#include <iterator>
+#include <numeric>
+#include <ranges>
+#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 ranges {
+#if __cplusplus >= 202302L
+using std::ranges::contains;
+using std::ranges::fold_left;
+#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;
+    });
+}
+
+/**
+ * @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
+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/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..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>
@@ -6059,7 +6060,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..b4a43f027ac1 100644
--- a/test/util/data/non-backported.txt
+++ b/test/util/data/non-backported.txt
@@ -54,11 +54,9 @@ 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
+src/util/helpers.h
 src/util/ranges_set.*
+src/util/std23.h
 src/util/wpipe.*
 src/wallet/bip39*
 src/wallet/coinjoin.*