dashpay · PastaPastaPasta · Apr 4, 2023 · Mar 29, 2023 · Mar 29, 2023 · Mar 29, 2023
diff --git a/depends/packages/dbus.mk b/depends/packages/dbus.mk
diff --git a/depends/packages/packages.mk b/depends/packages/packages.mk
@@ -1,6 +1,6 @@
 packages:=boost libevent gmp backtrace
 
-qt_linux_packages:=qt expat dbus libxcb xcb_proto libXau xproto freetype fontconfig libxkbcommon
+qt_linux_packages:=qt expat libxcb xcb_proto libXau xproto freetype fontconfig libxkbcommon
 
 qrencode_linux_packages = qrencode
 qrencode_android_packages = qrencode

diff --git a/doc/dependencies.md b/doc/dependencies.md
@@ -8,7 +8,6 @@ These are the dependencies currently used by Dash Core. You can find instruction
 | Berkeley DB | [4.8.30](https://www.oracle.com/technetwork/database/database-technologies/berkeleydb/downloads/index.html) | 4.8.x | No | | |
 | Boost | [1.73.0](https://www.boost.org/users/download/) | [1.64.0](https://github.com/bitcoin/bitcoin/pull/22320) | No | | |
 | Clang<sup>[ \* ](#note1)</sup> | | [5.0+](https://releases.llvm.org/download.html) (C++17 support) | | | |
-| D-Bus | [1.10.18](https://cgit.freedesktop.org/dbus/dbus/tree/NEWS?h=dbus-1.10) | | No | Yes | |
 | Expat | [2.2.7](https://libexpat.github.io/) | | No | Yes | |
 | fontconfig | [2.12.1](https://www.freedesktop.org/software/fontconfig/release/) | | No | Yes | |
 | FreeType | [2.7.1](https://download.savannah.gnu.org/releases/freetype) | | No | | [Yes](https://github.com/dashpay/dash/blob/develop/depends/packages/qt.mk) (Android only) |

diff --git a/doc/release-notes-5273.md b/doc/release-notes-5273.md
@@ -0,0 +1,5 @@
+Added RPCs
+--------
+
+- `cleardiscouraged` clears all the already discouraged peers.
+
diff --git a/src/Makefile.bench.include b/src/Makefile.bench.include
@@ -39,6 +39,7 @@ bench_bench_dash_SOURCES = \
  bench/mempool_stress.cpp \
  bench/nanobench.h \
  bench/nanobench.cpp \
+ bench/rpc_blockchain.cpp \
  bench/rpc_mempool.cpp \
  bench/util_time.cpp \
  bench/base58.cpp \

diff --git a/src/banman.cpp b/src/banman.cpp
@@ -68,6 +68,16 @@ void BanMan::ClearBanned()
  if (m_client_interface) m_client_interface->BannedListChanged();
 }
 
+void BanMan::ClearDiscouraged()
+{
+ {
+ LOCK(m_cs_banned);
+ m_discouraged.reset();
+ m_is_dirty = true;
+ }
+ if (m_client_interface) m_client_interface->BannedListChanged();
+}
+
 bool BanMan::IsDiscouraged(const CNetAddr& net_addr)
 {
  LOCK(m_cs_banned);

diff --git a/src/banman.h b/src/banman.h
@@ -63,6 +63,7 @@ class BanMan
  void Ban(const CSubNet& sub_net, int64_t ban_time_offset = 0, bool since_unix_epoch = false);
  void Discourage(const CNetAddr& net_addr);
  void ClearBanned();
+ void ClearDiscouraged();
 
  //! Return whether net_addr is banned
  bool IsBanned(const CNetAddr& net_addr);

diff --git a/src/bench/block_assemble.cpp b/src/bench/block_assemble.cpp
@@ -41,7 +41,7 @@ static void AssembleBlock(benchmark::Bench& bench)
 
  for (const auto& txr : txs) {
  CValidationState state;
- bool ret{::AcceptToMemoryPool(*test_setup.m_node.mempool, state, txr, nullptr /* pfMissingInputs */, false /* bypass_limits */, /* nAbsurdFee */ 0)};
+ bool ret{::AcceptToMemoryPool(::ChainstateActive(), *test_setup.m_node.mempool, state, txr, nullptr /* pfMissingInputs */, false /* bypass_limits */, /* nAbsurdFee */ 0)};
  assert(ret);
  }
  }

diff --git a/src/bench/rpc_blockchain.cpp b/src/bench/rpc_blockchain.cpp
@@ -0,0 +1,35 @@
+// Copyright (c) 2016-2019 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <bench/bench.h>
+#include <bench/data.h>
+
+#include <validation.h>
+#include <streams.h>
+#include <consensus/validation.h>
+#include <llmq/chainlocks.h>
+#include <llmq/instantsend.h>
+#include <rpc/blockchain.h>
+
+#include <univalue.h>
+
+static void BlockToJsonVerbose(benchmark::Bench& bench) {
+ CDataStream stream(benchmark::data::block813851, SER_NETWORK, PROTOCOL_VERSION);
+ char a = '\0';
+ stream.write(&a, 1); // Prevent compaction
+
+ CBlock block;
+ stream >> block;
+
+ CBlockIndex blockindex;
+ const uint256 blockHash = block.GetHash();
+ blockindex.phashBlock = &blockHash;
+ blockindex.nBits = 403014710;
+
+ bench.run([&] {
+ (void)blockToJSON(block, &blockindex, &blockindex, *llmq::chainLocksHandler, *llmq::quorumInstantSendManager, /*verbose*/ true);
+ });
+}
+
+BENCHMARK(BlockToJsonVerbose);
diff --git a/src/coinjoin/coinjoin.cpp b/src/coinjoin/coinjoin.cpp
@@ -352,7 +352,7 @@ bool CCoinJoin::IsCollateralValid(CTxMemPool& mempool, const CTransaction& txCol
  {
  LOCK(cs_main);
  CValidationState validationState;
- if (!AcceptToMemoryPool(mempool, validationState, MakeTransactionRef(txCollateral), /*pfMissingInputs=*/nullptr, /*bypass_limits=*/false, /*nAbsurdFee=*/DEFAULT_MAX_RAW_TX_FEE, /*test_accept=*/true)) {
+ if (!AcceptToMemoryPool(::ChainstateActive(), mempool, validationState, MakeTransactionRef(txCollateral), /*pfMissingInputs=*/nullptr, /*bypass_limits=*/false, /*nAbsurdFee=*/DEFAULT_MAX_RAW_TX_FEE, /*test_accept=*/true)) {
  LogPrint(BCLog::COINJOIN, "CCoinJoin::IsCollateralValid -- didn't pass AcceptToMemoryPool()\n");
  return false;
  }

diff --git a/src/coinjoin/server.cpp b/src/coinjoin/server.cpp
@@ -322,7 +322,7 @@ void CCoinJoinServer::CommitFinalTransaction()
  TRY_LOCK(cs_main, lockMain);
  CValidationState validationState;
  mempool.PrioritiseTransaction(hashTx, 0.1 * COIN);
- if (!lockMain || !AcceptToMemoryPool(mempool, validationState, finalTransaction, nullptr /* pfMissingInputs */, false /* bypass_limits */, DEFAULT_MAX_RAW_TX_FEE /* nAbsurdFee */)) {
+ if (!lockMain || !AcceptToMemoryPool(::ChainstateActive(), mempool, validationState, finalTransaction, nullptr /* pfMissingInputs */, false /* bypass_limits */, DEFAULT_MAX_RAW_TX_FEE /* nAbsurdFee */)) {
  LogPrint(BCLog::COINJOIN, "CCoinJoinServer::CommitFinalTransaction -- AcceptToMemoryPool() error: Transaction not valid\n");
  WITH_LOCK(cs_coinjoin, SetNull());
  // not much we can do in this case, just notify clients
@@ -455,7 +455,7 @@ void CCoinJoinServer::ConsumeCollateral(const CTransactionRef& txref) const
 {
  LOCK(cs_main);
  CValidationState validationState;
- if (!AcceptToMemoryPool(mempool, validationState, txref, nullptr /* pfMissingInputs */, false /* bypass_limits */, 0 /* nAbsurdFee */)) {
+ if (!AcceptToMemoryPool(::ChainstateActive(), mempool, validationState, txref, nullptr /* pfMissingInputs */, false /* bypass_limits */, 0 /* nAbsurdFee */)) {
  LogPrint(BCLog::COINJOIN, "%s -- AcceptToMemoryPool failed\n", __func__);
  } else {
  connman.RelayTransaction(*txref);

diff --git a/src/evo/deterministicmns.cpp b/src/evo/deterministicmns.cpp
@@ -218,15 +218,35 @@ std::vector<CDeterministicMNCPtr> CDeterministicMNList::GetProjectedMNPayees(int
  if (nCount < 0 ) {
  return {};
  }
- nCount = std::min(nCount, int(GetValidMNsCount()));
+ nCount = std::min(nCount, int(GetValidWeightedMNsCount()));
 
  std::vector<CDeterministicMNCPtr> result;
  result.reserve(nCount);
 
+ auto remaining_hpmn_payments = 0;
+ CDeterministicMNCPtr hpmn_to_be_skipped = nullptr;
  ForEachMNShared(true, [&](const CDeterministicMNCPtr& dmn) {
- result.emplace_back(dmn);
+ if (dmn->pdmnState->nLastPaidHeight == nHeight) {
+ // We found the last MN Payee.
+ // If the last payee is a HPMN, we need to check its consecutive payments and pay him again if needed
+ if (dmn->nType == MnType::HighPerformance && dmn->pdmnState->nConsecutivePayments < dmn_types::HighPerformance.voting_weight) {
+ remaining_hpmn_payments = dmn_types::HighPerformance.voting_weight - dmn->pdmnState->nConsecutivePayments;
+ for ([[maybe_unused]] auto _ : irange::range(remaining_hpmn_payments)) {
+ result.emplace_back(dmn);
+ hpmn_to_be_skipped = dmn;
+ }
+ }
+ }
+ return;
+ });
+
+ ForEachMNShared(true, [&](const CDeterministicMNCPtr& dmn) {
+ if (dmn == hpmn_to_be_skipped) return;
+ for ([[maybe_unused]] auto _ : irange::range(GetMnType(dmn->nType).voting_weight)) {
+ result.emplace_back(dmn);
+ }
  });
- std::sort(result.begin(), result.end(), [&](const CDeterministicMNCPtr& a, const CDeterministicMNCPtr& b) {
+ std::sort(result.begin() + remaining_hpmn_payments, result.end(), [&](const CDeterministicMNCPtr& a, const CDeterministicMNCPtr& b) {
  return CompareByLastPaid(a.get(), b.get());
  });
 

diff --git a/src/evo/deterministicmns.h b/src/evo/deterministicmns.h
@@ -19,6 +19,7 @@
 
 #include <immer/map.hpp>
 
+#include <numeric>
 #include <unordered_map>
 #include <utility>
 
@@ -241,6 +242,14 @@ class CDeterministicMNList
  return ranges::count_if(mnMap, [](const auto& p) { return p.second->nType == MnType::HighPerformance && IsMNValid(*p.second); });
  }
 
+ [[nodiscard]] size_t GetValidWeightedMNsCount() const
+ {
+ return std::accumulate(mnMap.begin(), mnMap.end(), 0, [](auto res, const auto& p) {
+ if (!IsMNValid(*p.second)) return res;
+ return res + GetMnType(p.second->nType).voting_weight;
+ });
+ }
+
  /**
  * Execute a callback on all masternodes in the mnList. This will pass a reference
  * of each masternode to the callback function. This should be preferred over ForEachMNShared.

diff --git a/src/evo/mnauth.cpp b/src/evo/mnauth.cpp
@@ -87,6 +87,7 @@ void CMNAuth::ProcessMessage(CNode& peer, CConnman& connman, std::string_view ms
 
  if (!mnauth.sig.IsValid()) {
  Misbehaving(peer.GetId(), 100, "invalid mnauth signature");
+ LogPrint(BCLog::NET_NETCONN, "CMNAuth::ProcessMessage -- invalid mnauth for protx=%s with sig=%s\n", mnauth.proRegTxHash.ToString(), mnauth.sig.ToString());
  return;
  }
 

diff --git a/src/evo/mnhftx.cpp b/src/evo/mnhftx.cpp
@@ -45,7 +45,7 @@ bool CheckMNHFTx(const CTransaction& tx, const CBlockIndex* pindexPrev, CValidat
  return state.Invalid(ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "bad-mnhf-version");
  }
 
- const CBlockIndex* pindexQuorum = LookupBlockIndex(mnhfTx.signal.quorumHash);
+ const CBlockIndex* pindexQuorum = g_chainman.m_blockman.LookupBlockIndex(mnhfTx.signal.quorumHash);
  if (!pindexQuorum) {
  return state.Invalid(ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "bad-mnhf-quorum-hash");
  }

diff --git a/src/evo/simplifiedmns.cpp b/src/evo/simplifiedmns.cpp
@@ -243,14 +243,14 @@ bool BuildSimplifiedMNListDiff(const uint256& baseBlockHash, const uint256& bloc
 
  const CBlockIndex* baseBlockIndex = ::ChainActive().Genesis();
  if (!baseBlockHash.IsNull()) {
- baseBlockIndex = LookupBlockIndex(baseBlockHash);
+ baseBlockIndex = g_chainman.m_blockman.LookupBlockIndex(baseBlockHash);
  if (!baseBlockIndex) {
  errorRet = strprintf("block %s not found", baseBlockHash.ToString());
  return false;
  }
  }
 
- const CBlockIndex* blockIndex = LookupBlockIndex(blockHash);
+ const CBlockIndex* blockIndex = g_chainman.m_blockman.LookupBlockIndex(blockHash);
  if (!blockIndex) {
  errorRet = strprintf("block %s not found", blockHash.ToString());
  return false;

diff --git a/src/evo/specialtxman.cpp b/src/evo/specialtxman.cpp
@@ -42,7 +42,7 @@ bool CheckSpecialTx(const CTransaction& tx, const CBlockIndex* pindexPrev, CVali
  case TRANSACTION_QUORUM_COMMITMENT:
  return llmq::CheckLLMQCommitment(tx, pindexPrev, state);
  case TRANSACTION_MNHF_SIGNAL:
- return VersionBitsTipState(Params().GetConsensus(), Consensus::DEPLOYMENT_DIP0024) == ThresholdState::ACTIVE && CheckMNHFTx(tx, pindexPrev, state);
+ return VersionBitsState(::ChainActive().Tip(), Params().GetConsensus(), Consensus::DEPLOYMENT_DIP0024, versionbitscache) == ThresholdState::ACTIVE && CheckMNHFTx(tx, pindexPrev, state);
  }
  } catch (const std::exception& e) {
  LogPrintf("%s -- failed: %s\n", __func__, e.what());

diff --git a/src/governance/classes.cpp b/src/governance/classes.cpp
@@ -525,7 +525,7 @@ void CSuperblock::ParsePaymentSchedule(const std::string& strPaymentAddresses, c
 
  // TODO: script addresses limit here and cs_main lock in
  // CGovernanceManager::InitOnLoad()once DIP0024 is active
- bool fAllowScript = (VersionBitsTipState(Params().GetConsensus(), Consensus::DEPLOYMENT_DIP0024) == ThresholdState::ACTIVE);
+ bool fAllowScript = (VersionBitsState(::ChainActive().Tip(), Params().GetConsensus(), Consensus::DEPLOYMENT_DIP0024, versionbitscache) == ThresholdState::ACTIVE);
  for (int i = 0; i < (int)vecParsed1.size(); i++) {
  CTxDestination dest = DecodeDestination(vecParsed1[i]);
  if (!IsValidDestination(dest)) {

diff --git a/src/governance/governance.cpp b/src/governance/governance.cpp
@@ -395,7 +395,7 @@ void CGovernanceManager::UpdateCachesAndClean()
  } else {
  // NOTE: triggers are handled via triggerman
  if (pObj->GetObjectType() == GOVERNANCE_OBJECT_PROPOSAL) {
- bool fAllowScript = (VersionBitsTipState(Params().GetConsensus(), Consensus::DEPLOYMENT_DIP0024) == ThresholdState::ACTIVE);
+ bool fAllowScript = (VersionBitsState(::ChainActive().Tip(), Params().GetConsensus(), Consensus::DEPLOYMENT_DIP0024, versionbitscache) == ThresholdState::ACTIVE);
  CProposalValidator validator(pObj->GetDataAsHexString(), fAllowScript);
  if (!validator.Validate()) {
  LogPrint(BCLog::GOBJECT, "CGovernanceManager::UpdateCachesAndClean -- set for deletion expired obj %s\n", strHash);
@@ -635,7 +635,7 @@ void CGovernanceManager::SyncObjects(CNode& peer, CConnman& connman) const
 
  LogPrint(BCLog::GOBJECT, "CGovernanceManager::%s -- syncing all objects to peer=%d\n", __func__, peer.GetId());
 
- bool fAllowScript = WITH_LOCK(cs_main, return VersionBitsTipState(Params().GetConsensus(), Consensus::DEPLOYMENT_DIP0024) == ThresholdState::ACTIVE);
+ bool fAllowScript = WITH_LOCK(cs_main, return VersionBitsState(::ChainActive().Tip(), Params().GetConsensus(), Consensus::DEPLOYMENT_DIP0024, versionbitscache) == ThresholdState::ACTIVE);
 
  LOCK(cs);
 

diff --git a/src/governance/object.cpp b/src/governance/object.cpp
@@ -469,7 +469,7 @@ bool CGovernanceObject::IsValidLocally(std::string& strError, bool& fMissingConf
 
  switch (nObjectType) {
  case GOVERNANCE_OBJECT_PROPOSAL: {
- bool fAllowScript = (VersionBitsTipState(Params().GetConsensus(), Consensus::DEPLOYMENT_DIP0024) == ThresholdState::ACTIVE);
+ bool fAllowScript = (VersionBitsState(::ChainActive().Tip(), Params().GetConsensus(), Consensus::DEPLOYMENT_DIP0024, versionbitscache) == ThresholdState::ACTIVE);
  CProposalValidator validator(GetDataAsHexString(), fAllowScript);
  // Note: It's ok to have expired proposals
  // they are going to be cleared by CGovernanceManager::UpdateCachesAndClean()
@@ -563,7 +563,7 @@ bool CGovernanceObject::IsCollateralValid(std::string& strError, bool& fMissingC
  findScript << OP_RETURN << ToByteVector(nExpectedHash);
 
  AssertLockHeld(cs_main);
- bool fork_active = VersionBitsState(LookupBlockIndex(nBlockHash), Params().GetConsensus(), Consensus::DEPLOYMENT_DIP0024, versionbitscache) == ThresholdState::ACTIVE;
+ bool fork_active = VersionBitsState(g_chainman.m_blockman.LookupBlockIndex(nBlockHash), Params().GetConsensus(), Consensus::DEPLOYMENT_DIP0024, versionbitscache) == ThresholdState::ACTIVE;
  CAmount nMinFee = GetMinCollateralFee(fork_active);
 
  LogPrint(BCLog::GOBJECT, "CGovernanceObject::IsCollateralValid -- txCollateral->vout.size() = %s, findScript = %s, nMinFee = %lld\n",
@@ -594,7 +594,7 @@ bool CGovernanceObject::IsCollateralValid(std::string& strError, bool& fMissingC
  AssertLockHeld(cs_main);
  int nConfirmationsIn = 0;
  if (nBlockHash != uint256()) {
- const CBlockIndex* pindex = LookupBlockIndex(nBlockHash);
+ const CBlockIndex* pindex = g_chainman.m_blockman.LookupBlockIndex(nBlockHash);
  if (pindex && ::ChainActive().Contains(pindex)) {
  nConfirmationsIn += ::ChainActive().Height() - pindex->nHeight + 1;
  }
@@ -692,7 +692,7 @@ void CGovernanceObject::Relay(CConnman& connman) const
  // But we don't want to relay it to pre-GOVSCRIPT_PROTO_VERSION peers if payment_address is p2sh
  // because they won't accept it anyway and will simply ban us eventually.
  LOCK(cs_main);
- bool fAllowScript = (VersionBitsTipState(Params().GetConsensus(), Consensus::DEPLOYMENT_DIP0024) == ThresholdState::ACTIVE);
+ bool fAllowScript = (VersionBitsState(::ChainActive().Tip(), Params().GetConsensus(), Consensus::DEPLOYMENT_DIP0024, versionbitscache) == ThresholdState::ACTIVE);
  if (fAllowScript) {
  CProposalValidator validator(GetDataAsHexString(), false /* no script */);
  if (!validator.Validate(false /* ignore expiration */)) {

diff --git a/src/index/base.cpp b/src/index/base.cpp
@@ -61,7 +61,7 @@ bool BaseIndex::Init()
  if (locator.IsNull()) {
  m_best_block_index = nullptr;
  } else {
- m_best_block_index = FindForkInGlobalIndex(::ChainActive(), locator);
+ m_best_block_index = g_chainman.m_blockman.FindForkInGlobalIndex(::ChainActive(), locator);
  }
  m_synced = m_best_block_index.load() == ::ChainActive().Tip();
  return true;
@@ -238,7 +238,7 @@ void BaseIndex::ChainStateFlushed(const CBlockLocator& locator)
  const CBlockIndex* locator_tip_index;
  {
  LOCK(cs_main);
- locator_tip_index = LookupBlockIndex(locator_tip_hash);
+ locator_tip_index = g_chainman.m_blockman.LookupBlockIndex(locator_tip_hash);
  }
 
  if (!locator_tip_index) {