refactor: implement irange::range and use it

src/Makefile.am

@@ -301,6 +301,7 @@ BITCOIN_CORE_H = \
   util/check.h \
   util/error.h \
   util/fees.h \
+  util/irange.h \
   util/spanparsing.h \
   util/system.h \
   util/asmap.h \

src/bench/bls_dkg.cpp

@@ -3,8 +3,9 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <bench/bench.h>
-#include <random.h>
 #include <bls/bls_worker.h>
+#include <random.h>
+#include <util/irange.h>
 
 struct Member {
     CBLSId id;
@@ -27,24 +28,24 @@ class DKG
     void ReceiveVvecs()
     {
         receivedVvecs.clear();
-        for (size_t i = 0; i < members.size(); i++) {
-            receivedVvecs.emplace_back(members[i].vvec);
+        for (const auto& member : members) {
+            receivedVvecs.emplace_back(member.vvec);
         }
         quorumVvec = blsWorker.BuildQuorumVerificationVector(receivedVvecs);
     }
 
     void ReceiveShares(size_t whoAmI)
     {
         receivedSkShares.clear();
-        for (size_t i = 0; i < members.size(); i++) {
-            receivedSkShares.emplace_back(members[i].skShares[whoAmI]);
+        for (const auto& member : members) {
+            receivedSkShares.emplace_back(member.skShares[whoAmI]);
         }
     }
 
     void VerifyContributionShares(size_t whoAmI, const std::set<size_t>& invalidIndexes, bool aggregated)
     {
         auto result = blsWorker.VerifyContributionShares(members[whoAmI].id, receivedVvecs, receivedSkShares, aggregated);
-        for (size_t i = 0; i < receivedVvecs.size(); i++) {
+        for (const size_t i : irange::range(receivedVvecs.size())) {
             if (invalidIndexes.count(i)) {
                 assert(!result[i]);
             } else {
@@ -59,16 +60,16 @@ class DKG
         members.reserve(quorumSize);
         ids.reserve(quorumSize);
 
-        for (int i = 0; i < quorumSize; i++) {
+        for (const int i : irange::range(quorumSize)) {
             uint256 id;
             WriteLE64(id.begin(), i + 1);
             members.push_back({CBLSId(id), {}, {}});
             ids.emplace_back(id);
         }
 
         blsWorker.Start();
-        for (int i = 0; i < quorumSize; i++) {
-            blsWorker.GenerateContributions(quorumSize / 2 + 1, ids, members[i].vvec, members[i].skShares);
+        for (auto& member : members) {
+            blsWorker.GenerateContributions(quorumSize / 2 + 1, ids, member.vvec, member.skShares);
         }
     }
     ~DKG()
@@ -93,7 +94,7 @@ class DKG
             ReceiveShares(memberIdx);
 
             std::set<size_t> invalidIndexes;
-            for (int i = 0; i < invalidCount; i++) {
+            for ([[maybe_unused]] const auto _ : irange::range(invalidCount)) {
                 int shareIdx = GetRandInt(receivedSkShares.size());
                 receivedSkShares[shareIdx].MakeNewKey();
                 invalidIndexes.emplace(shareIdx);
@@ -112,15 +113,15 @@ static void BLSDKG_GenerateContributions(benchmark::Bench& bench, uint32_t epoch
     blsWorker.Start();
     std::vector<CBLSId> ids;
     std::vector<Member> members;
-    for (int i = 0; i < quorumSize; i++) {
+    for (const int i : irange::range(quorumSize)) {
         uint256 id;
         WriteLE64(id.begin(), i + 1);
         members.push_back({CBLSId(id), {}, {}});
         ids.emplace_back(id);
     }
     bench.minEpochIterations(epoch_iters).run([&blsWorker, &quorumSize, &ids, &members] {
-        for (int i = 0; i < quorumSize; i++) {
-            blsWorker.GenerateContributions(quorumSize / 2 + 1, ids, members[i].vvec, members[i].skShares);
+        for (auto& member : members) {
+            blsWorker.GenerateContributions(quorumSize / 2 + 1, ids, member.vvec, member.skShares);
         }
     });
     blsWorker.Stop();

src/coinjoin/client.cpp

@@ -15,6 +15,7 @@
 #include <netmessagemaker.h>
 #include <script/sign.h>
 #include <shutdown.h>
+#include <util/irange.h>
 #include <util/moneystr.h>
 #include <util/ranges.h>
 #include <util/system.h>
@@ -579,7 +580,7 @@ bool CCoinJoinClientSession::SignFinalTransaction(const CTransaction& finalTrans
             int nMyInputIndex = -1;
             CScript prevPubKey = CScript();
 
-            for (unsigned int i = 0; i < finalMutableTransaction.vin.size(); i++) {
+            for (const auto i : irange::range(finalMutableTransaction.vin.size())) {
                 if (finalMutableTransaction.vin[i] == txdsin) {
                     nMyInputIndex = i;
                     prevPubKey = txdsin.prevPubKey;
@@ -1222,7 +1223,7 @@ bool CCoinJoinClientSession::SubmitDenominate(CConnman& connman)
 
     std::vector<std::pair<int, size_t> > vecInputsByRounds;
 
-    for (int i = 0; i < CCoinJoinClientOptions::GetRounds() + CCoinJoinClientOptions::GetRandomRounds(); i++) {
+    for (const auto i : irange::range(CCoinJoinClientOptions::GetRounds() + CCoinJoinClientOptions::GetRandomRounds())) {
         if (PrepareDenominate(i, i, strError, vecTxDSIn, vecPSInOutPairsTmp, true)) {
             LogPrint(BCLog::COINJOIN, "CCoinJoinClientSession::SubmitDenominate -- Running CoinJoin denominate for %d rounds, success\n", i);
             vecInputsByRounds.emplace_back(i, vecPSInOutPairsTmp.size());
@@ -1712,7 +1713,7 @@ bool CCoinJoinClientSession::CreateDenominated(CAmount nBalanceToDenominate, con
             LogPrint(BCLog::COINJOIN, "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 (int i = 0; i < denomsToCreate; i++) {
+            for (const auto i : irange::range(denomsToCreate)) {
                 // Never go above the cap unless it's the largest denom
                 if (nDenomValue != nLargestDenomValue && it->second >= CCoinJoinClientOptions::GetDenomsHardCap()) break;
 

src/coinjoin/server.cpp

@@ -4,20 +4,20 @@
 
 #include <coinjoin/server.h>
 
-#include <masternode/node.h>
-#include <evo/deterministicmns.h>
 #include <consensus/validation.h>
 #include <core_io.h>
+#include <evo/deterministicmns.h>
 #include <masternode/meta.h>
+#include <masternode/node.h>
 #include <masternode/sync.h>
 #include <net_processing.h>
 #include <netmessagemaker.h>
 #include <script/interpreter.h>
 #include <shutdown.h>
 #include <txmempool.h>
+#include <util/moneystr.h>
 #include <util/ranges.h>
 #include <util/system.h>
-#include <util/moneystr.h>
 #include <validation.h>
 #include <version.h>
 
@@ -272,11 +272,11 @@ void CCoinJoinServer::CreateFinalTransaction(CConnman& connman)
     CMutableTransaction txNew;
 
     // make our new transaction
-    for (int i = 0; i < GetEntriesCountLocked(); i++) {
-        for (const auto& txout : vecEntries[i].vecTxOut) {
+    for (const auto& entry : vecEntries) {
+        for (const auto& txout : entry.vecTxOut) {
             txNew.vout.push_back(txout);
         }
-        for (const auto& txdsin : vecEntries[i].vecTxDSIn) {
+        for (const auto& txdsin : entry.vecTxDSIn) {
             txNew.vin.push_back(txdsin);
         }
     }
@@ -632,8 +632,8 @@ bool CCoinJoinServer::AddScriptSig(const CTxIn& txinNew)
             LogPrint(BCLog::COINJOIN, "CCoinJoinServer::AddScriptSig -- adding to finalMutableTransaction, scriptSig=%s\n", ScriptToAsmStr(txinNew.scriptSig).substr(0, 24));
         }
     }
-    for (int i = 0; i < GetEntriesCountLocked(); i++) {
-        if (vecEntries[i].AddScriptSig(txinNew)) {
+    for (auto& entry : vecEntries) {
+        if (entry.AddScriptSig(txinNew)) {
             LogPrint(BCLog::COINJOIN, "CCoinJoinServer::AddScriptSig -- adding to entries, scriptSig=%s\n", ScriptToAsmStr(txinNew.scriptSig).substr(0, 24));
             return true;
         }

src/llmq/blockprocessor.cpp

@@ -16,9 +16,10 @@
 #include <net_processing.h>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
-#include <validation.h>
 #include <saltedhasher.h>
 #include <sync.h>
+#include <util/irange.h>
+#include <validation.h>
 
 #include <map>
 
@@ -446,7 +447,7 @@ bool CQuorumBlockProcessor::IsCommitmentRequired(const Consensus::LLMQParams& ll
     assert(nHeight <= ::ChainActive().Height() + 1);
     const auto *const pindex = ::ChainActive().Height() < nHeight ? ::ChainActive().Tip() : ::ChainActive().Tip()->GetAncestor(nHeight);
 
-    for (int quorumIndex = 0; quorumIndex < llmqParams.signingActiveQuorumCount; ++quorumIndex) {
+    for (const auto quorumIndex : irange::range(llmqParams.signingActiveQuorumCount)) {
         uint256 quorumHash = GetQuorumBlockHash(llmqParams, nHeight, quorumIndex);
         if (quorumHash.IsNull()) return false;
         if (HasMinedCommitment(llmqParams.type, quorumHash)) return false;
@@ -600,7 +601,7 @@ std::vector<std::pair<int, const CBlockIndex*>> CQuorumBlockProcessor::GetLastMi
     const Consensus::LLMQParams& llmqParams = GetLLMQParams(llmqType);
     std::vector<std::pair<int, const CBlockIndex*>> ret;
 
-    for (int quorumIndex = 0; quorumIndex < llmqParams.signingActiveQuorumCount; ++quorumIndex) {
+    for (const auto quorumIndex : irange::range(llmqParams.signingActiveQuorumCount)) {
         std::optional<const CBlockIndex*> q = GetLastMinedCommitmentsByQuorumIndexUntilBlock(llmqType, pindex, quorumIndex, cycle);
         if (q.has_value()) {
             ret.emplace_back(quorumIndex, q.value());
@@ -728,7 +729,7 @@ std::optional<std::vector<CFinalCommitment>> CQuorumBlockProcessor::GetMineableC
     const auto *const pindex = ::ChainActive().Height() < nHeight ? ::ChainActive().Tip() : ::ChainActive().Tip()->GetAncestor(nHeight);
 
     std::stringstream ss;
-    for (int quorumIndex = 0; quorumIndex < llmqParams.signingActiveQuorumCount; ++quorumIndex) {
+    for (const auto quorumIndex : irange::range(llmqParams.signingActiveQuorumCount)) {
         CFinalCommitment cf;
 
         uint256 quorumHash = GetQuorumBlockHash(llmqParams, nHeight, quorumIndex);

src/llmq/commitment.cpp

@@ -10,6 +10,7 @@
 #include <chainparams.h>
 #include <consensus/validation.h>
 #include <logging.h>
+#include <util/irange.h>
 #include <validation.h>
 
 namespace llmq
@@ -80,16 +81,16 @@ bool CFinalCommitment::Verify(const CBlockIndex* pQuorumBaseBlockIndex, bool che
     }
     auto members = CLLMQUtils::GetAllQuorumMembers(llmqType, pQuorumBaseBlockIndex);
     std::stringstream ss;
-    for (size_t i = 0; i < llmq_params.size; i++) {
+    for (const auto i : irange::range(llmq_params.size)) {
         ss << "v[" << i << "]=" << validMembers[i];
     }
     std::stringstream ss2;
-    for (size_t i = 0; i < llmq_params.size; i++) {
+    for (const auto i : irange::range(llmq_params.size)) {
         ss2 << "s[" << i << "]=" << signers[i];
     }
 
     LogPrintfFinalCommitment("CFinalCommitment::%s mns[%d] validMembers[%s] signers[%s]\n", __func__, members.size(), ss.str(), ss2.str());
-    for (size_t i = members.size(); i < size_t(llmq_params.size); i++) {
+    for (const auto i : irange::range(members.size(), size_t(llmq_params.size))) {
         if (validMembers[i]) {
             LogPrintfFinalCommitment("q[%s] invalid validMembers bitset. bit %d should not be set\n", quorumHash.ToString(), i);
             return false;
@@ -109,7 +110,7 @@ bool CFinalCommitment::Verify(const CBlockIndex* pQuorumBaseBlockIndex, bool che
         }
         LogPrintfFinalCommitment("CFinalCommitment::%s members[%s] quorumPublicKey[%s] commitmentHash[%s]\n", __func__, ss3.str(), quorumPublicKey.ToString(), commitmentHash.ToString());
         std::vector<CBLSPublicKey> memberPubKeys;
-        for (size_t i = 0; i < members.size(); i++) {
+        for (const auto i : irange::range(members.size())) {
             if (!signers[i]) {
                 continue;
             }
@@ -168,7 +169,7 @@ bool CheckLLMQCommitment(const CTransaction& tx, const CBlockIndex* pindexPrev,
     }
     const auto& llmq_params = GetLLMQParams(qcTx.commitment.llmqType);
     std::stringstream ss;
-    for (size_t i = 0; i < llmq_params.size; i++) {
+    for (const auto i : irange::range(llmq_params.size)) {
         ss << "v[" << i << "]=" << qcTx.commitment.validMembers[i];
     }
     LogPrintfFinalCommitment("%s llmqType[%d] validMembers[%s] signers[]\n", __func__, int(qcTx.commitment.llmqType), ss.str());

src/llmq/debug.cpp

@@ -10,6 +10,7 @@
 
 #include <evo/deterministicmns.h>
 #include <llmq/utils.h>
+#include <util/irange.h>
 
 namespace llmq
 {
@@ -79,7 +80,7 @@ UniValue CDKGDebugSessionStatus::ToJson(int quorumIndex, int detailLevel) const
         }
     };
 
-    for (size_t i = 0; i < members.size(); i++) {
+    for (const auto i : irange::range(members.size())) {
         const auto& m = members[i];
         add(badMembers, i, m.bad);
         add(weComplain, i, m.weComplain);

src/llmq/dkgsession.cpp

@@ -20,6 +20,7 @@
 
 #include <cxxtimer.hpp>
 #include <memory>
+#include <util/irange.h>
 
 namespace llmq
 {
@@ -79,14 +80,14 @@ bool CDKGSession::Init(const CBlockIndex* _pQuorumBaseBlockIndex, const std::vec
     receivedSkContributions.resize(members.size());
     vecEncryptedContributions.resize(members.size());
 
-    for (size_t i = 0; i < mns.size(); i++) {
+    for (const auto i : irange::range(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 (size_t i = 0; i < members.size(); i++) {
+        for (const auto i : irange::range(members.size())) {
             const auto& m = members[i];
             if (m->dmn->proTxHash == _myProTxHash) {
                 myIdx = i;
@@ -176,7 +177,7 @@ void CDKGSession::SendContributions(CDKGPendingMessages& pendingMessages)
     qc.contributions = std::make_shared<CBLSIESMultiRecipientObjects<CBLSSecretKey>>();
     qc.contributions->InitEncrypt(members.size());
 
-    for (size_t i = 0; i < members.size(); i++) {
+    for (const auto i : irange::range(members.size())) {
         const auto& m = members[i];
         CBLSSecretKey skContrib = skContributions[i];
 
@@ -383,7 +384,7 @@ void CDKGSession::VerifyPendingContributions()
         return;
     }
 
-    for (size_t i = 0; i < memberIndexes.size(); i++) {
+    for (const auto i : irange::range(memberIndexes.size())) {
         if (!result[i]) {
             const auto& m = members[memberIndexes[i]];
             logger.Batch("invalid contribution from %s. will complain later", m->dmn->proTxHash.ToString());
@@ -493,7 +494,7 @@ void CDKGSession::SendComplaint(CDKGPendingMessages& pendingMessages)
 
     int badCount = 0;
     int complaintCount = 0;
-    for (size_t i = 0; i < members.size(); i++) {
+    for (const auto i : irange::range(members.size())) {
         const auto& m = members[i];
         if (m->bad || m->badConnection) {
             qc.badMembers[i] = true;
@@ -601,7 +602,7 @@ void CDKGSession::ReceiveMessage(const CDKGComplaint& qc, bool& retBan)
     }
 
     int receivedCount = 0;
-    for (size_t i = 0; i < members.size(); i++) {
+    for (const auto i : irange::range(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());
@@ -682,7 +683,7 @@ void CDKGSession::SendJustification(CDKGPendingMessages& pendingMessages, const
     qj.proTxHash = myProTxHash;
     qj.contributions.reserve(forMembers.size());
 
-    for (size_t i = 0; i < members.size(); i++) {
+    for (const auto i : irange::range(members.size())) {
         const auto& m = members[i];
         if (!forMembers.count(m->dmn->proTxHash)) {
             continue;
@@ -929,7 +930,7 @@ void CDKGSession::SendCommitment(CDKGPendingMessages& pendingMessages)
     qc.quorumHash = m_quorum_base_block_index->GetBlockHash();
     qc.proTxHash = myProTxHash;
 
-    for (size_t i = 0; i < members.size(); i++) {
+    for (const auto i : irange::range(members.size())) {
         const auto& m = members[i];
         if (!m->bad) {
             qc.validMembers[i] = true;
@@ -1069,7 +1070,7 @@ bool CDKGSession::PreVerifyMessage(const CDKGPrematureCommitment& qc, bool& retB
         return false;
     }
 
-    for (size_t i = members.size(); i < size_t(params.size); i++) {
+    for (const auto i : irange::range(members.size(), size_t(params.size))) {
         if (qc.validMembers[i]) {
             retBan = true;
             logger.Batch("invalid validMembers bitset. bit %d should not be set", i);