diff --git a/doc/release-notes.md b/doc/release-notes.md
index 6d5e9e698..a074ee2e0 100644
--- a/doc/release-notes.md
+++ b/doc/release-notes.md
@@ -1,7 +1,9 @@
 # Bitcoin ABC 0.26.12 Release Notes
 
 Bitcoin ABC version 0.26.12 is now available from:
 
   <https://download.bitcoinabc.org/0.26.12/>
 
-This is a maintenance release with no user-visible change.
+ - Removed 10-block rolling finalization. This only affects configurations
+   where Avalanche is explicitly disabled. This removal includes associated
+   command-line parameters `-finalizationdelay` and `-maxreorgdepth`.
diff --git a/src/avalanche/processor.cpp b/src/avalanche/processor.cpp
index b354e3e02..34f497728 100644
--- a/src/avalanche/processor.cpp
+++ b/src/avalanche/processor.cpp
@@ -1,1027 +1,1022 @@
 // Copyright (c) 2018-2019 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <avalanche/processor.h>
 
 #include <avalanche/avalanche.h>
 #include <avalanche/delegationbuilder.h>
 #include <avalanche/peermanager.h>
 #include <avalanche/proofcomparator.h>
 #include <avalanche/validation.h>
 #include <avalanche/voterecord.h>
 #include <chain.h>
 #include <key_io.h> // For DecodeSecret
 #include <net.h>
 #include <netmessagemaker.h>
 #include <scheduler.h>
 #include <util/bitmanip.h>
 #include <util/moneystr.h>
 #include <util/translation.h>
 #include <validation.h>
 
 #include <chrono>
 #include <limits>
 #include <tuple>
 
 /**
  * Run the avalanche event loop every 10ms.
  */
 static constexpr std::chrono::milliseconds AVALANCHE_TIME_STEP{10};
 
 // Unfortunately, the bitcoind codebase is full of global and we are kinda
 // forced into it here.
 std::unique_ptr<avalanche::Processor> g_avalanche;
 
 namespace avalanche {
 static bool VerifyProof(const Amount &stakeUtxoDustThreshold,
                         const Proof &proof, bilingual_str &error) {
     ProofValidationState proof_state;
 
     if (!proof.verify(stakeUtxoDustThreshold, proof_state)) {
         switch (proof_state.GetResult()) {
             case ProofValidationResult::NO_STAKE:
                 error = _("The avalanche proof has no stake.");
                 return false;
             case ProofValidationResult::DUST_THRESHOLD:
                 error = _("The avalanche proof stake is too low.");
                 return false;
             case ProofValidationResult::DUPLICATE_STAKE:
                 error = _("The avalanche proof has duplicated stake.");
                 return false;
             case ProofValidationResult::INVALID_STAKE_SIGNATURE:
                 error = _("The avalanche proof has invalid stake signatures.");
                 return false;
             case ProofValidationResult::TOO_MANY_UTXOS:
                 error = strprintf(
                     _("The avalanche proof has too many utxos (max: %u)."),
                     AVALANCHE_MAX_PROOF_STAKES);
                 return false;
             default:
                 error = _("The avalanche proof is invalid.");
                 return false;
         }
     }
 
     return true;
 }
 
 static bool VerifyDelegation(const Delegation &dg,
                              const CPubKey &expectedPubKey,
                              bilingual_str &error) {
     DelegationState dg_state;
 
     CPubKey auth;
     if (!dg.verify(dg_state, auth)) {
         switch (dg_state.GetResult()) {
             case avalanche::DelegationResult::INVALID_SIGNATURE:
                 error = _("The avalanche delegation has invalid signatures.");
                 return false;
             case avalanche::DelegationResult::TOO_MANY_LEVELS:
                 error = _(
                     "The avalanche delegation has too many delegation levels.");
                 return false;
             default:
                 error = _("The avalanche delegation is invalid.");
                 return false;
         }
     }
 
     if (auth != expectedPubKey) {
         error = _(
             "The avalanche delegation does not match the expected public key.");
         return false;
     }
 
     return true;
 }
 
 struct Processor::PeerData {
     ProofRef proof;
     Delegation delegation;
 
     mutable Mutex cs_proofState;
     ProofRegistrationState proofState GUARDED_BY(cs_proofState);
 };
 
 class Processor::NotificationsHandler
     : public interfaces::Chain::Notifications {
     Processor *m_processor;
 
 public:
     NotificationsHandler(Processor *p) : m_processor(p) {}
 
     void updatedBlockTip() override {
         const bool registerLocalProof = m_processor->canShareLocalProof();
         auto registerProofs = [&]() {
             LOCK(m_processor->cs_peerManager);
 
             auto registeredProofs = m_processor->peerManager->updatedBlockTip();
 
             ProofRegistrationState localProofState;
             if (m_processor->peerData && m_processor->peerData->proof &&
                 registerLocalProof) {
                 if (m_processor->peerManager->registerProof(
                         m_processor->peerData->proof, localProofState)) {
                     registeredProofs.insert(m_processor->peerData->proof);
                 }
 
                 WITH_LOCK(m_processor->peerData->cs_proofState,
                           m_processor->peerData->proofState =
                               std::move(localProofState));
             }
 
             return registeredProofs;
         };
 
         auto registeredProofs = registerProofs();
         for (const auto &proof : registeredProofs) {
             m_processor->addToReconcile(proof);
         }
     }
 };
 
 Processor::Processor(Config avaconfigIn, interfaces::Chain &chain,
                      CConnman *connmanIn, ChainstateManager &chainmanIn,
                      CScheduler &scheduler,
                      std::unique_ptr<PeerData> peerDataIn, CKey sessionKeyIn,
                      uint32_t minQuorumTotalScoreIn,
                      double minQuorumConnectedScoreRatioIn,
                      int64_t minAvaproofsNodeCountIn,
                      uint32_t staleVoteThresholdIn, uint32_t staleVoteFactorIn,
                      Amount stakeUtxoDustThreshold)
     : avaconfig(std::move(avaconfigIn)), connman(connmanIn),
       chainman(chainmanIn), round(0), peerManager(std::make_unique<PeerManager>(
                                           stakeUtxoDustThreshold, chainman)),
       peerData(std::move(peerDataIn)), sessionKey(std::move(sessionKeyIn)),
       minQuorumScore(minQuorumTotalScoreIn),
       minQuorumConnectedScoreRatio(minQuorumConnectedScoreRatioIn),
       minAvaproofsNodeCount(minAvaproofsNodeCountIn),
       staleVoteThreshold(staleVoteThresholdIn),
       staleVoteFactor(staleVoteFactorIn) {
     // Make sure we get notified of chain state changes.
     chainNotificationsHandler =
         chain.handleNotifications(std::make_shared<NotificationsHandler>(this));
 
     scheduler.scheduleEvery(
         [this]() -> bool {
             WITH_LOCK(cs_peerManager,
                       peerManager->cleanupDanglingProofs(getLocalProof()));
             return true;
         },
         5min);
 }
 
 Processor::~Processor() {
     chainNotificationsHandler.reset();
     stopEventLoop();
 }
 
 std::unique_ptr<Processor>
 Processor::MakeProcessor(const ArgsManager &argsman, interfaces::Chain &chain,
                          CConnman *connman, ChainstateManager &chainman,
                          CScheduler &scheduler, bilingual_str &error) {
     std::unique_ptr<PeerData> peerData;
     CKey masterKey;
     CKey sessionKey;
 
     Amount stakeUtxoDustThreshold = PROOF_DUST_THRESHOLD;
     if (argsman.IsArgSet("-avaproofstakeutxodustthreshold") &&
         !ParseMoney(argsman.GetArg("-avaproofstakeutxodustthreshold", ""),
                     stakeUtxoDustThreshold)) {
         error = _("The avalanche stake utxo dust threshold amount is invalid.");
         return nullptr;
     }
 
     if (argsman.IsArgSet("-avasessionkey")) {
         sessionKey = DecodeSecret(argsman.GetArg("-avasessionkey", ""));
         if (!sessionKey.IsValid()) {
             error = _("The avalanche session key is invalid.");
             return nullptr;
         }
     } else {
         // Pick a random key for the session.
         sessionKey.MakeNewKey(true);
     }
 
     if (argsman.IsArgSet("-avaproof")) {
         if (!argsman.IsArgSet("-avamasterkey")) {
             error = _(
                 "The avalanche master key is missing for the avalanche proof.");
             return nullptr;
         }
 
         masterKey = DecodeSecret(argsman.GetArg("-avamasterkey", ""));
         if (!masterKey.IsValid()) {
             error = _("The avalanche master key is invalid.");
             return nullptr;
         }
 
         auto proof = RCUPtr<Proof>::make();
         if (!Proof::FromHex(*proof, argsman.GetArg("-avaproof", ""), error)) {
             // error is set by FromHex
             return nullptr;
         }
 
         peerData = std::make_unique<PeerData>();
         peerData->proof = std::move(proof);
         if (!VerifyProof(stakeUtxoDustThreshold, *peerData->proof, error)) {
             // error is set by VerifyProof
             return nullptr;
         }
 
         std::unique_ptr<DelegationBuilder> dgb;
         const CPubKey &masterPubKey = masterKey.GetPubKey();
 
         if (argsman.IsArgSet("-avadelegation")) {
             Delegation dg;
             if (!Delegation::FromHex(dg, argsman.GetArg("-avadelegation", ""),
                                      error)) {
                 // error is set by FromHex()
                 return nullptr;
             }
 
             if (dg.getProofId() != peerData->proof->getId()) {
                 error = _("The delegation does not match the proof.");
                 return nullptr;
             }
 
             if (masterPubKey != dg.getDelegatedPubkey()) {
                 error = _(
                     "The master key does not match the delegation public key.");
                 return nullptr;
             }
 
             dgb = std::make_unique<DelegationBuilder>(dg);
         } else {
             if (masterPubKey != peerData->proof->getMaster()) {
                 error =
                     _("The master key does not match the proof public key.");
                 return nullptr;
             }
 
             dgb = std::make_unique<DelegationBuilder>(*peerData->proof);
         }
 
         // Generate the delegation to the session key.
         const CPubKey sessionPubKey = sessionKey.GetPubKey();
         if (sessionPubKey != masterPubKey) {
             if (!dgb->addLevel(masterKey, sessionPubKey)) {
                 error = _("Failed to generate a delegation for this session.");
                 return nullptr;
             }
         }
         peerData->delegation = dgb->build();
 
         if (!VerifyDelegation(peerData->delegation, sessionPubKey, error)) {
             // error is set by VerifyDelegation
             return nullptr;
         }
     }
 
     const auto queryTimeoutDuration =
         std::chrono::milliseconds(argsman.GetIntArg(
             "-avatimeout", AVALANCHE_DEFAULT_QUERY_TIMEOUT.count()));
 
     // Determine quorum parameters
     Amount minQuorumStake = AVALANCHE_DEFAULT_MIN_QUORUM_STAKE;
     if (argsman.IsArgSet("-avaminquorumstake") &&
         !ParseMoney(argsman.GetArg("-avaminquorumstake", ""), minQuorumStake)) {
         error = _("The avalanche min quorum stake amount is invalid.");
         return nullptr;
     }
 
     if (!MoneyRange(minQuorumStake)) {
         error = _("The avalanche min quorum stake amount is out of range.");
         return nullptr;
     }
 
     double minQuorumConnectedStakeRatio =
         AVALANCHE_DEFAULT_MIN_QUORUM_CONNECTED_STAKE_RATIO;
     if (argsman.IsArgSet("-avaminquorumconnectedstakeratio") &&
         !ParseDouble(argsman.GetArg("-avaminquorumconnectedstakeratio", ""),
                      &minQuorumConnectedStakeRatio)) {
         error = _("The avalanche min quorum connected stake ratio is invalid.");
         return nullptr;
     }
 
     if (minQuorumConnectedStakeRatio < 0 || minQuorumConnectedStakeRatio > 1) {
         error = _(
             "The avalanche min quorum connected stake ratio is out of range.");
         return nullptr;
     }
 
     int64_t minAvaproofsNodeCount =
         argsman.GetIntArg("-avaminavaproofsnodecount",
                           AVALANCHE_DEFAULT_MIN_AVAPROOFS_NODE_COUNT);
     if (minAvaproofsNodeCount < 0) {
         error = _("The minimum number of node that sent avaproofs message "
                   "should be non-negative");
         return nullptr;
     }
 
     // Determine voting parameters
     int64_t staleVoteThreshold = argsman.GetIntArg(
         "-avastalevotethreshold", AVALANCHE_VOTE_STALE_THRESHOLD);
     if (staleVoteThreshold < AVALANCHE_VOTE_STALE_MIN_THRESHOLD) {
         error = strprintf(_("The avalanche stale vote threshold must be "
                             "greater than or equal to %d"),
                           AVALANCHE_VOTE_STALE_MIN_THRESHOLD);
         return nullptr;
     }
     if (staleVoteThreshold > std::numeric_limits<uint32_t>::max()) {
         error = strprintf(_("The avalanche stale vote threshold must be less "
                             "than or equal to %d"),
                           std::numeric_limits<uint32_t>::max());
         return nullptr;
     }
 
     int64_t staleVoteFactor =
         argsman.GetIntArg("-avastalevotefactor", AVALANCHE_VOTE_STALE_FACTOR);
     if (staleVoteFactor <= 0) {
         error = _("The avalanche stale vote factor must be greater than 0");
         return nullptr;
     }
     if (staleVoteFactor > std::numeric_limits<uint32_t>::max()) {
         error = strprintf(_("The avalanche stale vote factor must be less than "
                             "or equal to %d"),
                           std::numeric_limits<uint32_t>::max());
         return nullptr;
     }
 
     Config avaconfig(queryTimeoutDuration);
 
     // We can't use std::make_unique with a private constructor
     return std::unique_ptr<Processor>(new Processor(
         std::move(avaconfig), chain, connman, chainman, scheduler,
         std::move(peerData), std::move(sessionKey),
         Proof::amountToScore(minQuorumStake), minQuorumConnectedStakeRatio,
         minAvaproofsNodeCount, staleVoteThreshold, staleVoteFactor,
         stakeUtxoDustThreshold));
 }
 
 static bool isNull(const AnyVoteItem &item) {
     return item.valueless_by_exception() ||
            std::visit([](const auto &item) { return item == nullptr; }, item);
 };
 
 bool Processor::addToReconcile(const AnyVoteItem &item) {
     if (isNull(item)) {
         return false;
     }
 
     if (!isWorthPolling(item)) {
         return false;
     }
 
     // getLocalAcceptance() takes the voteRecords read lock, so we can't inline
     // the calls or we get a deadlock.
     const bool accepted = getLocalAcceptance(item);
 
     return voteRecords.getWriteView()
         ->insert(std::make_pair(item, VoteRecord(accepted)))
         .second;
 }
 
 bool Processor::isAccepted(const AnyVoteItem &item) const {
     if (isNull(item)) {
         return false;
     }
 
     auto r = voteRecords.getReadView();
     auto it = r->find(item);
     if (it == r.end()) {
         return false;
     }
 
     return it->second.isAccepted();
 }
 
 int Processor::getConfidence(const AnyVoteItem &item) const {
     if (isNull(item)) {
         return -1;
     }
 
     auto r = voteRecords.getReadView();
     auto it = r->find(item);
     if (it == r.end()) {
         return -1;
     }
 
     return it->second.getConfidence();
 }
 
 namespace {
     /**
      * When using TCP, we need to sign all messages as the transport layer is
      * not secure.
      */
     class TCPResponse {
         Response response;
         SchnorrSig sig;
 
     public:
         TCPResponse(Response responseIn, const CKey &key)
             : response(std::move(responseIn)) {
             CHashWriter hasher(SER_GETHASH, 0);
             hasher << response;
             const uint256 hash = hasher.GetHash();
 
             // Now let's sign!
             if (!key.SignSchnorr(hash, sig)) {
                 sig.fill(0);
             }
         }
 
         // serialization support
         SERIALIZE_METHODS(TCPResponse, obj) {
             READWRITE(obj.response, obj.sig);
         }
     };
 } // namespace
 
 void Processor::sendResponse(CNode *pfrom, Response response) const {
     connman->PushMessage(
         pfrom, CNetMsgMaker(pfrom->GetCommonVersion())
                    .Make(NetMsgType::AVARESPONSE,
                          TCPResponse(std::move(response), sessionKey)));
 }
 
 bool Processor::registerVotes(NodeId nodeid, const Response &response,
                               std::vector<VoteItemUpdate> &updates,
                               int &banscore, std::string &error) {
     {
         // Save the time at which we can query again.
         LOCK(cs_peerManager);
 
         // FIXME: This will override the time even when we received an old stale
         // message. This should check that the message is indeed the most up to
         // date one before updating the time.
         peerManager->updateNextRequestTime(
             nodeid, std::chrono::steady_clock::now() +
                         std::chrono::milliseconds(response.getCooldown()));
     }
 
     std::vector<CInv> invs;
 
     {
         // Check that the query exists.
         auto w = queries.getWriteView();
         auto it = w->find(std::make_tuple(nodeid, response.getRound()));
         if (it == w.end()) {
             banscore = 2;
             error = "unexpected-ava-response";
             return false;
         }
 
         invs = std::move(it->invs);
         w->erase(it);
     }
 
     // Verify that the request and the vote are consistent.
     const std::vector<Vote> &votes = response.GetVotes();
     size_t size = invs.size();
     if (votes.size() != size) {
         banscore = 100;
         error = "invalid-ava-response-size";
         return false;
     }
 
     for (size_t i = 0; i < size; i++) {
         if (invs[i].hash != votes[i].GetHash()) {
             banscore = 100;
             error = "invalid-ava-response-content";
             return false;
         }
     }
 
     auto getVoteItemFromInv = [&](const CInv &inv) -> AnyVoteItem {
         if (inv.IsMsgBlk()) {
             return WITH_LOCK(cs_main,
                              return chainman.m_blockman.LookupBlockIndex(
                                  BlockHash(inv.hash)));
         }
         if (inv.IsMsgProof()) {
             return WITH_LOCK(cs_peerManager,
                              return peerManager->getProof(ProofId(inv.hash)));
         }
 
         return {nullptr};
     };
 
     std::map<AnyVoteItem, Vote, VoteMapComparator> responseItems;
 
     // At this stage we are certain that invs[i] matches votes[i], so we can use
     // the inv type to retrieve what is being voted on.
     for (size_t i = 0; i < size; i++) {
         auto item = getVoteItemFromInv(invs[i]);
 
         if (isNull(item)) {
             // This should not happen, but just in case...
             continue;
         }
 
         if (!isWorthPolling(item)) {
             // There is no point polling this item.
             continue;
         }
 
         responseItems.insert(std::make_pair(std::move(item), votes[i]));
     }
 
     auto voteRecordsWriteView = voteRecords.getWriteView();
 
     // Register votes.
     for (const auto &p : responseItems) {
         auto item = p.first;
         const Vote &v = p.second;
 
         auto it = voteRecordsWriteView->find(item);
         if (it == voteRecordsWriteView.end()) {
             // We are not voting on that item anymore.
             continue;
         }
 
         auto &vr = it->second;
         if (!vr.registerVote(nodeid, v.GetError())) {
             if (vr.isStale(staleVoteThreshold, staleVoteFactor)) {
                 updates.emplace_back(std::move(item), VoteStatus::Stale);
 
                 // Just drop stale votes. If we see this item again, we'll
                 // do a new vote.
                 voteRecordsWriteView->erase(it);
             }
             // This vote did not provide any extra information, move on.
             continue;
         }
 
         if (!vr.hasFinalized()) {
             // This item has not been finalized, so we have nothing more to
             // do.
             updates.emplace_back(std::move(item), vr.isAccepted()
                                                       ? VoteStatus::Accepted
                                                       : VoteStatus::Rejected);
             continue;
         }
 
         // We just finalized a vote. If it is valid, then let the caller
         // know. Either way, remove the item from the map.
         updates.emplace_back(std::move(item), vr.isAccepted()
                                                   ? VoteStatus::Finalized
                                                   : VoteStatus::Invalid);
         voteRecordsWriteView->erase(it);
     }
 
     // FIXME This doesn't belong here as it has nothing to do with vote
     // registration.
     for (const auto &update : updates) {
         if (update.getStatus() != VoteStatus::Finalized) {
             continue;
         }
 
         const auto &item = update.getVoteItem();
         if (!std::holds_alternative<const CBlockIndex *>(item)) {
             continue;
         }
 
         const CBlockIndex *pindex = std::get<const CBlockIndex *>(item);
         LOCK(cs_finalizationTip);
         if (finalizationTip &&
             finalizationTip->GetAncestor(pindex->nHeight) == pindex) {
             continue;
         }
 
         finalizationTip = pindex;
     }
 
     return true;
 }
 
 CPubKey Processor::getSessionPubKey() const {
     return sessionKey.GetPubKey();
 }
 
 bool Processor::sendHelloInternal(CNode *pfrom) {
     AssertLockHeld(cs_delayedAvahelloNodeIds);
 
     Delegation delegation;
     if (peerData) {
         if (!canShareLocalProof()) {
             if (!delayedAvahelloNodeIds.emplace(pfrom->GetId()).second) {
                 // Nothing to do
                 return false;
             }
         } else {
             delegation = peerData->delegation;
             pfrom->AddKnownProof(delegation.getProofId());
         }
     }
 
     CHashWriter hasher(SER_GETHASH, 0);
     hasher << delegation.getId();
     hasher << pfrom->GetLocalNonce();
     hasher << pfrom->nRemoteHostNonce;
     hasher << pfrom->GetLocalExtraEntropy();
     hasher << pfrom->nRemoteExtraEntropy;
 
     // Now let's sign!
     SchnorrSig sig;
     if (!sessionKey.SignSchnorr(hasher.GetHash(), sig)) {
         return false;
     }
 
     connman->PushMessage(
         pfrom, CNetMsgMaker(pfrom->GetCommonVersion())
                    .Make(NetMsgType::AVAHELLO, Hello(delegation, sig)));
 
     return delegation.getLimitedProofId() != uint256::ZERO;
 }
 
 bool Processor::sendHello(CNode *pfrom) {
     return WITH_LOCK(cs_delayedAvahelloNodeIds,
                      return sendHelloInternal(pfrom));
 }
 
 void Processor::sendDelayedAvahello() {
     LOCK(cs_delayedAvahelloNodeIds);
 
     auto it = delayedAvahelloNodeIds.begin();
     while (it != delayedAvahelloNodeIds.end()) {
         if (connman->ForNode(*it, [&](CNode *pnode) EXCLUSIVE_LOCKS_REQUIRED(
                                       cs_delayedAvahelloNodeIds) {
                 return sendHelloInternal(pnode);
             })) {
             // Our proof has been announced to this node
             it = delayedAvahelloNodeIds.erase(it);
         } else {
             ++it;
         }
     }
 }
 
 ProofRef Processor::getLocalProof() const {
     return peerData ? peerData->proof : ProofRef();
 }
 
 ProofRegistrationState Processor::getLocalProofRegistrationState() const {
     return peerData
                ? WITH_LOCK(peerData->cs_proofState, return peerData->proofState)
                : ProofRegistrationState();
 }
 
 bool Processor::startEventLoop(CScheduler &scheduler) {
     return eventLoop.startEventLoop(
         scheduler, [this]() { this->runEventLoop(); }, AVALANCHE_TIME_STEP);
 }
 
 bool Processor::stopEventLoop() {
     return eventLoop.stopEventLoop();
 }
 
 void Processor::avaproofsSent(NodeId nodeid) {
     AssertLockNotHeld(cs_main);
 
     if (chainman.ActiveChainstate().IsInitialBlockDownload()) {
         // Before IBD is complete there is no way to make sure a proof is valid
         // or not, e.g. it can be spent in a block we don't know yet. In order
         // to increase confidence that our proof set is similar to other nodes
         // on the network, the messages received during IBD are not accounted.
         return;
     }
 
     LOCK(cs_peerManager);
     if (peerManager->latchAvaproofsSent(nodeid)) {
         avaproofsNodeCounter++;
     }
 }
 
 /*
  * Returns a bool indicating whether we have a usable Avalanche quorum enabling
  * us to take decisions based on polls.
  */
 bool Processor::isQuorumEstablished() {
     AssertLockNotHeld(cs_main);
 
     {
         LOCK(cs_peerManager);
         if (peerManager->getNodeCount() < 8) {
             // There is no point polling if we know the vote cannot converge
             return false;
         }
     }
 
     /*
      * The following parameters can naturally go temporarly below the threshold
      * under normal circumstances, like during a proof replacement with a lower
      * stake amount, or the discovery of a new proofs for which we don't have a
      * node yet.
      * In order to prevent our node from starting and stopping the polls
      * spuriously on such event, the quorum establishement is latched. The only
      * parameters that should not latched is the minimum node count, as this
      * would cause the poll to be inconclusive anyway and should not happen
      * under normal circumstances.
      */
     if (quorumIsEstablished) {
         return true;
     }
 
     // Don't do Avalanche while node is IBD'ing
     if (chainman.ActiveChainstate().IsInitialBlockDownload()) {
         return false;
     }
 
     if (avaproofsNodeCounter < minAvaproofsNodeCount) {
         return false;
     }
 
     auto localProof = getLocalProof();
 
     // Get the registered proof score and registered score we have nodes for
     uint32_t totalPeersScore;
     uint32_t connectedPeersScore;
     {
         LOCK(cs_peerManager);
         totalPeersScore = peerManager->getTotalPeersScore();
         connectedPeersScore = peerManager->getConnectedPeersScore();
 
         // Consider that we are always connected to our proof, even if we are
         // the single node using that proof.
         if (localProof &&
             peerManager->forPeer(localProof->getId(), [](const Peer &peer) {
                 return peer.node_count == 0;
             })) {
             connectedPeersScore += localProof->getScore();
         }
     }
 
     // Ensure enough is being staked overall
     if (totalPeersScore < minQuorumScore) {
         return false;
     }
 
     // Ensure we have connected score for enough of the overall score
     uint32_t minConnectedScore =
         std::round(double(totalPeersScore) * minQuorumConnectedScoreRatio);
     if (connectedPeersScore < minConnectedScore) {
         return false;
     }
 
     quorumIsEstablished = true;
     return true;
 }
 
 bool Processor::canShareLocalProof() {
     // The flag is latched
     if (m_canShareLocalProof) {
         return true;
     }
 
     // Don't share our proof if we don't have any inbound connection.
     // This is a best effort measure to prevent advertising a proof if we have
     // limited network connectivity.
     m_canShareLocalProof = connman->GetNodeCount(CConnman::CONNECTIONS_IN) > 0;
 
     return m_canShareLocalProof;
 }
 
 void Processor::FinalizeNode(const ::Config &config, const CNode &node) {
     AssertLockNotHeld(cs_main);
 
     const NodeId nodeid = node.GetId();
     WITH_LOCK(cs_peerManager, peerManager->removeNode(nodeid));
     WITH_LOCK(cs_delayedAvahelloNodeIds, delayedAvahelloNodeIds.erase(nodeid));
 }
 
 void Processor::runEventLoop() {
     // Don't poll if quorum hasn't been established yet
     if (!isQuorumEstablished()) {
         return;
     }
 
     // First things first, check if we have requests that timed out and clear
     // them.
     clearTimedoutRequests();
 
     // Make sure there is at least one suitable node to query before gathering
     // invs.
     NodeId nodeid = WITH_LOCK(cs_peerManager, return peerManager->selectNode());
     if (nodeid == NO_NODE) {
         return;
     }
     std::vector<CInv> invs = getInvsForNextPoll();
     if (invs.empty()) {
         return;
     }
 
     LOCK(cs_peerManager);
 
     do {
         /**
          * If we lost contact to that node, then we remove it from nodeids, but
          * never add the request to queries, which ensures bad nodes get cleaned
          * up over time.
          */
         bool hasSent = connman->ForNode(
             nodeid, [this, &invs](CNode *pnode) EXCLUSIVE_LOCKS_REQUIRED(
                         cs_peerManager) {
                 uint64_t current_round = round++;
 
                 {
                     // Compute the time at which this requests times out.
                     auto timeout = std::chrono::steady_clock::now() +
                                    avaconfig.queryTimeoutDuration;
                     // Register the query.
                     queries.getWriteView()->insert(
                         {pnode->GetId(), current_round, timeout, invs});
                     // Set the timeout.
                     peerManager->updateNextRequestTime(pnode->GetId(), timeout);
                 }
 
                 pnode->invsPolled(invs.size());
 
                 // Send the query to the node.
                 connman->PushMessage(
                     pnode, CNetMsgMaker(pnode->GetCommonVersion())
                                .Make(NetMsgType::AVAPOLL,
                                      Poll(current_round, std::move(invs))));
                 return true;
             });
 
         // Success!
         if (hasSent) {
             return;
         }
 
         // This node is obsolete, delete it.
         peerManager->removeNode(nodeid);
 
         // Get next suitable node to try again
         nodeid = peerManager->selectNode();
     } while (nodeid != NO_NODE);
 }
 
 void Processor::clearTimedoutRequests() {
     auto now = std::chrono::steady_clock::now();
     std::map<CInv, uint8_t> timedout_items{};
 
     {
         // Clear expired requests.
         auto w = queries.getWriteView();
         auto it = w->get<query_timeout>().begin();
         while (it != w->get<query_timeout>().end() && it->timeout < now) {
             for (const auto &i : it->invs) {
                 timedout_items[i]++;
             }
 
             w->get<query_timeout>().erase(it++);
         }
     }
 
     if (timedout_items.empty()) {
         return;
     }
 
     auto clearInflightRequest = [&](auto &_voteRecords, const auto &voteItem,
                                     uint8_t count) {
         if (!voteItem) {
             return false;
         }
 
         auto voteRecordsWriteView = _voteRecords.getWriteView();
         AnyVoteItem item{voteItem};
         auto it = voteRecordsWriteView->find(item);
         if (it == voteRecordsWriteView.end()) {
             return false;
         }
 
         it->second.clearInflightRequest(count);
 
         return true;
     };
 
     // In flight request accounting.
     for (const auto &p : timedout_items) {
         const CInv &inv = p.first;
         if (inv.IsMsgBlk()) {
             const CBlockIndex *pindex =
                 WITH_LOCK(cs_main, return chainman.m_blockman.LookupBlockIndex(
                                        BlockHash(inv.hash)));
 
             if (!clearInflightRequest(voteRecords, pindex, p.second)) {
                 continue;
             }
         }
 
         if (inv.IsMsgProof()) {
             const ProofRef proof =
                 WITH_LOCK(cs_peerManager,
                           return peerManager->getProof(ProofId(inv.hash)));
 
             if (!clearInflightRequest(voteRecords, proof, p.second)) {
                 continue;
             }
         }
     }
 }
 
 std::vector<CInv> Processor::getInvsForNextPoll(bool forPoll) {
     std::vector<CInv> invs;
 
     {
         // First remove all items that are not worth polling.
         auto w = voteRecords.getWriteView();
         for (auto it = w->begin(); it != w->end();) {
             if (!isWorthPolling(it->first)) {
                 it = w->erase(it);
             } else {
                 ++it;
             }
         }
     }
 
     auto buildInvFromVoteItem = variant::overloaded{
         [](const ProofRef &proof) {
             return CInv(MSG_AVA_PROOF, proof->getId());
         },
         [](const CBlockIndex *pindex) {
             return CInv(MSG_BLOCK, pindex->GetBlockHash());
         },
     };
 
     auto r = voteRecords.getReadView();
     for (const auto &[item, voteRecord] : r) {
         if (invs.size() >= AVALANCHE_MAX_ELEMENT_POLL) {
             // Make sure we do not produce more invs than specified by the
             // protocol.
             return invs;
         }
 
         const bool shouldPoll =
             forPoll ? voteRecord.registerPoll() : voteRecord.shouldPoll();
 
         if (!shouldPoll) {
             continue;
         }
 
         invs.emplace_back(std::visit(buildInvFromVoteItem, item));
     }
 
     return invs;
 }
 
 bool Processor::IsWorthPolling::operator()(const CBlockIndex *pindex) const {
     AssertLockNotHeld(cs_main);
 
     LOCK(cs_main);
 
     if (pindex->nStatus.isInvalid()) {
         // No point polling invalid blocks.
         return false;
     }
 
     if (WITH_LOCK(processor.cs_finalizationTip,
                   return processor.finalizationTip &&
                          processor.finalizationTip->GetAncestor(
                              pindex->nHeight) == pindex)) {
         // There is no point polling blocks that are ancestor of a block that
         // has been accepted by the network.
         return false;
     }
 
-    if (processor.chainman.ActiveChainstate().IsBlockFinalized(pindex)) {
-        // There is no point polling finalized block.
-        return false;
-    }
-
     return true;
 }
 
 bool Processor::IsWorthPolling::operator()(const ProofRef &proof) const {
     AssertLockNotHeld(processor.cs_peerManager);
 
     const ProofId &proofid = proof->getId();
 
     LOCK(processor.cs_peerManager);
 
     // No point polling immature or discarded proofs
     return processor.peerManager->isBoundToPeer(proofid) ||
            processor.peerManager->isInConflictingPool(proofid);
 }
 
 bool Processor::GetLocalAcceptance::operator()(
     const CBlockIndex *pindex) const {
     AssertLockNotHeld(cs_main);
 
     return WITH_LOCK(cs_main,
                      return processor.chainman.ActiveChain().Contains(pindex));
 }
 
 bool Processor::GetLocalAcceptance::operator()(const ProofRef &proof) const {
     AssertLockNotHeld(processor.cs_peerManager);
 
     return WITH_LOCK(
         processor.cs_peerManager,
         return processor.peerManager->isBoundToPeer(proof->getId()));
 }
 
 } // namespace avalanche
diff --git a/src/init.cpp b/src/init.cpp
index a7bebdeea..589e8a948 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -1,2982 +1,2970 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2018 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #if defined(HAVE_CONFIG_H)
 #include <config/bitcoin-config.h>
 #endif
 
 #include <init.h>
 
 #include <addrman.h>
 #include <avalanche/avalanche.h>
 #include <avalanche/processor.h>
 #include <avalanche/proof.h> // For AVALANCHE_LEGACY_PROOF_DEFAULT
 #include <avalanche/validation.h>
 #include <avalanche/voterecord.h> // For AVALANCHE_VOTE_STALE_*
 #include <banman.h>
 #include <blockfilter.h>
 #include <chain.h>
 #include <chainparams.h>
 #include <compat/sanity.h>
 #include <config.h>
 #include <consensus/amount.h>
 #include <currencyunit.h>
 #include <flatfile.h>
 #include <fs.h>
 #include <hash.h>
 #include <httprpc.h>
 #include <httpserver.h>
 #include <index/blockfilterindex.h>
 #include <index/coinstatsindex.h>
 #include <index/txindex.h>
 #include <init/common.h>
 #include <interfaces/chain.h>
 #include <interfaces/node.h>
 #include <mapport.h>
 #include <net.h>
 #include <net_permissions.h>
 #include <net_processing.h>
 #include <netbase.h>
 #include <node/blockstorage.h>
 #include <node/caches.h>
 #include <node/chainstate.h>
 #include <node/context.h>
 #include <node/miner.h>
 #include <node/ui_interface.h>
 #include <policy/mempool.h>
 #include <policy/policy.h>
 #include <policy/settings.h>
 #include <rpc/blockchain.h>
 #include <rpc/register.h>
 #include <rpc/server.h>
 #include <rpc/util.h>
 #include <scheduler.h>
 #include <script/scriptcache.h>
 #include <script/sigcache.h>
 #include <script/standard.h>
 #include <shutdown.h>
 #include <sync.h>
 #include <timedata.h>
 #include <torcontrol.h>
 #include <txdb.h>
 #include <txmempool.h>
 #include <txorphanage.h>
 #include <util/asmap.h>
 #include <util/check.h>
 #include <util/moneystr.h>
 #include <util/string.h>
 #include <util/thread.h>
 #include <util/threadnames.h>
 #include <util/translation.h>
 #include <validation.h>
 #include <validationinterface.h>
 #include <walletinitinterface.h>
 
 #include <boost/algorithm/string/replace.hpp>
 #include <boost/signals2/signal.hpp>
 
 #if ENABLE_CHRONIK
 #include <chronik-cpp/chronik.h>
 #endif
 
 #if ENABLE_ZMQ
 #include <zmq/zmqabstractnotifier.h>
 #include <zmq/zmqnotificationinterface.h>
 #include <zmq/zmqrpc.h>
 #endif
 
 #ifndef WIN32
 #include <attributes.h>
 #include <cerrno>
 #include <csignal>
 #include <sys/stat.h>
 #endif
 #include <cstdint>
 #include <cstdio>
 #include <functional>
 #include <set>
 #include <thread>
 #include <vector>
 
 using node::CacheSizes;
 using node::CalculateCacheSizes;
 using node::ChainstateLoadingError;
 using node::ChainstateLoadVerifyError;
 using node::CleanupBlockRevFiles;
 using node::DEFAULT_STOPAFTERBLOCKIMPORT;
 using node::fPruneMode;
 using node::fReindex;
 using node::LoadChainstate;
 using node::NodeContext;
 using node::nPruneTarget;
 using node::ThreadImport;
 using node::VerifyLoadedChainstate;
 
 static const bool DEFAULT_PROXYRANDOMIZE = true;
 static const bool DEFAULT_REST_ENABLE = false;
 
 #ifdef WIN32
 // Win32 LevelDB doesn't use filedescriptors, and the ones used for accessing
 // block files don't count towards the fd_set size limit anyway.
 #define MIN_CORE_FILEDESCRIPTORS 0
 #else
 #define MIN_CORE_FILEDESCRIPTORS 150
 #endif
 
 static const char *DEFAULT_ASMAP_FILENAME = "ip_asn.map";
 
 /**
  * The PID file facilities.
  */
 static const char *BITCOIN_PID_FILENAME = "bitcoind.pid";
 
 static fs::path GetPidFile(const ArgsManager &args) {
     return AbsPathForConfigVal(
         fs::PathFromString(args.GetArg("-pid", BITCOIN_PID_FILENAME)));
 }
 
 [[nodiscard]] static bool CreatePidFile(const ArgsManager &args) {
     fsbridge::ofstream file{GetPidFile(args)};
     if (file) {
 #ifdef WIN32
         tfm::format(file, "%d\n", GetCurrentProcessId());
 #else
         tfm::format(file, "%d\n", getpid());
 #endif
         return true;
     } else {
         return InitError(strprintf(_("Unable to create the PID file '%s': %s"),
                                    fs::PathToString(GetPidFile(args)),
                                    std::strerror(errno)));
     }
 }
 
 //////////////////////////////////////////////////////////////////////////////
 //
 // Shutdown
 //
 
 //
 // Thread management and startup/shutdown:
 //
 // The network-processing threads are all part of a thread group created by
 // AppInit() or the Qt main() function.
 //
 // A clean exit happens when StartShutdown() or the SIGTERM signal handler sets
 // fRequestShutdown, which makes main thread's WaitForShutdown() interrupts the
 // thread group.
 // And then, WaitForShutdown() makes all other on-going threads in the thread
 // group join the main thread.
 // Shutdown() is then called to clean up database connections, and stop other
 // threads that should only be stopped after the main network-processing threads
 // have exited.
 //
 // Shutdown for Qt is very similar, only it uses a QTimer to detect
 // ShutdownRequested() getting set, and then does the normal Qt shutdown thing.
 //
 
 void Interrupt(NodeContext &node) {
     InterruptHTTPServer();
     InterruptHTTPRPC();
     InterruptRPC();
     InterruptREST();
     InterruptTorControl();
     InterruptMapPort();
     if (g_avalanche) {
         // Avalanche needs to be stopped before we interrupt the thread group as
         // the scheduler will stop working then.
         g_avalanche->stopEventLoop();
     }
     if (node.connman) {
         node.connman->Interrupt();
     }
     if (g_txindex) {
         g_txindex->Interrupt();
     }
     ForEachBlockFilterIndex([](BlockFilterIndex &index) { index.Interrupt(); });
     if (g_coin_stats_index) {
         g_coin_stats_index->Interrupt();
     }
 }
 
 void Shutdown(NodeContext &node) {
     static Mutex g_shutdown_mutex;
     TRY_LOCK(g_shutdown_mutex, lock_shutdown);
     if (!lock_shutdown) {
         return;
     }
     LogPrintf("%s: In progress...\n", __func__);
     Assert(node.args);
 
     /// Note: Shutdown() must be able to handle cases in which initialization
     /// failed part of the way, for example if the data directory was found to
     /// be locked. Be sure that anything that writes files or flushes caches
     /// only does this if the respective module was initialized.
     util::ThreadRename("shutoff");
     if (node.mempool) {
         node.mempool->AddTransactionsUpdated(1);
     }
 
     StopHTTPRPC();
     StopREST();
     StopRPC();
     StopHTTPServer();
     for (const auto &client : node.chain_clients) {
         client->flush();
     }
     StopMapPort();
 
     // Because avalanche and the network depend on each other, it is important
     // to shut them down in this order:
     // 1. Stop avalanche event loop.
     // 2. Shutdown network processing.
     // 3. Destroy avalanche::Processor.
     // 4. Destroy CConnman
     if (g_avalanche) {
         g_avalanche->stopEventLoop();
     }
 
     // Because these depend on each-other, we make sure that neither can be
     // using the other before destroying them.
     if (node.peerman) {
         UnregisterValidationInterface(node.peerman.get());
     }
     if (node.connman) {
         node.connman->Stop();
     }
 
 #if ENABLE_CHRONIK
     chronik::Stop();
 #endif
 
     StopTorControl();
 
     // After everything has been shut down, but before things get flushed, stop
     // the CScheduler/checkqueue, scheduler and load block thread.
     if (node.scheduler) {
         node.scheduler->stop();
     }
     if (node.chainman && node.chainman->m_load_block.joinable()) {
         node.chainman->m_load_block.join();
     }
     StopScriptCheckWorkerThreads();
 
     // After the threads that potentially access these pointers have been
     // stopped, destruct and reset all to nullptr.
     node.peerman.reset();
 
     // Destroy various global instances
     g_avalanche.reset();
     node.connman.reset();
     node.banman.reset();
     node.addrman.reset();
 
     if (node.mempool && node.mempool->IsLoaded() &&
         node.args->GetBoolArg("-persistmempool", DEFAULT_PERSIST_MEMPOOL)) {
         DumpMempool(*node.mempool);
     }
 
     // FlushStateToDisk generates a ChainStateFlushed callback, which we should
     // avoid missing
     if (node.chainman) {
         LOCK(cs_main);
         for (CChainState *chainstate : node.chainman->GetAll()) {
             if (chainstate->CanFlushToDisk()) {
                 chainstate->ForceFlushStateToDisk();
             }
         }
     }
 
     // After there are no more peers/RPC left to give us new data which may
     // generate CValidationInterface callbacks, flush them...
     GetMainSignals().FlushBackgroundCallbacks();
 
     // Stop and delete all indexes only after flushing background callbacks.
     if (g_txindex) {
         g_txindex->Stop();
         g_txindex.reset();
     }
     if (g_coin_stats_index) {
         g_coin_stats_index->Stop();
         g_coin_stats_index.reset();
     }
     ForEachBlockFilterIndex([](BlockFilterIndex &index) { index.Stop(); });
     DestroyAllBlockFilterIndexes();
 
     // Any future callbacks will be dropped. This should absolutely be safe - if
     // missing a callback results in an unrecoverable situation, unclean
     // shutdown would too. The only reason to do the above flushes is to let the
     // wallet catch up with our current chain to avoid any strange pruning edge
     // cases and make next startup faster by avoiding rescan.
 
     if (node.chainman) {
         LOCK(cs_main);
         for (CChainState *chainstate : node.chainman->GetAll()) {
             if (chainstate->CanFlushToDisk()) {
                 chainstate->ForceFlushStateToDisk();
                 chainstate->ResetCoinsViews();
             }
         }
     }
     for (const auto &client : node.chain_clients) {
         client->stop();
     }
 
 #if ENABLE_ZMQ
     if (g_zmq_notification_interface) {
         UnregisterValidationInterface(g_zmq_notification_interface);
         delete g_zmq_notification_interface;
         g_zmq_notification_interface = nullptr;
     }
 #endif
 
     node.chain_clients.clear();
     UnregisterAllValidationInterfaces();
     GetMainSignals().UnregisterBackgroundSignalScheduler();
     init::UnsetGlobals();
     node.mempool.reset();
     node.chainman.reset();
     node.scheduler.reset();
 
     try {
         if (!fs::remove(GetPidFile(*node.args))) {
             LogPrintf("%s: Unable to remove PID file: File does not exist\n",
                       __func__);
         }
     } catch (const fs::filesystem_error &e) {
         LogPrintf("%s: Unable to remove PID file: %s\n", __func__,
                   fsbridge::get_filesystem_error_message(e));
     }
 
     node.args = nullptr;
     LogPrintf("%s: done\n", __func__);
 }
 
 /**
  * Signal handlers are very limited in what they are allowed to do.
  * The execution context the handler is invoked in is not guaranteed,
  * so we restrict handler operations to just touching variables:
  */
 #ifndef WIN32
 static void HandleSIGTERM(int) {
     StartShutdown();
 }
 
 static void HandleSIGHUP(int) {
     LogInstance().m_reopen_file = true;
 }
 #else
 static BOOL WINAPI consoleCtrlHandler(DWORD dwCtrlType) {
     StartShutdown();
     Sleep(INFINITE);
     return true;
 }
 #endif
 
 #ifndef WIN32
 static void registerSignalHandler(int signal, void (*handler)(int)) {
     struct sigaction sa;
     sa.sa_handler = handler;
     sigemptyset(&sa.sa_mask);
     sa.sa_flags = 0;
     sigaction(signal, &sa, NULL);
 }
 #endif
 
 static boost::signals2::connection rpc_notify_block_change_connection;
 static void OnRPCStarted() {
     rpc_notify_block_change_connection = uiInterface.NotifyBlockTip_connect(
         std::bind(RPCNotifyBlockChange, std::placeholders::_2));
 }
 
 static void OnRPCStopped() {
     rpc_notify_block_change_connection.disconnect();
     RPCNotifyBlockChange(nullptr);
     g_best_block_cv.notify_all();
     LogPrint(BCLog::RPC, "RPC stopped.\n");
 }
 
 void SetupServerArgs(NodeContext &node) {
     assert(!node.args);
     node.args = &gArgs;
     ArgsManager &argsman = *node.args;
 
     SetupHelpOptions(argsman);
     SetupCurrencyUnitOptions(argsman);
     // server-only for now
     argsman.AddArg("-help-debug",
                    "Print help message with debugging options and exit", false,
                    OptionsCategory::DEBUG_TEST);
 
     init::AddLoggingArgs(argsman);
 
     const auto defaultBaseParams =
         CreateBaseChainParams(CBaseChainParams::MAIN);
     const auto testnetBaseParams =
         CreateBaseChainParams(CBaseChainParams::TESTNET);
     const auto regtestBaseParams =
         CreateBaseChainParams(CBaseChainParams::REGTEST);
     const auto defaultChainParams = CreateChainParams(CBaseChainParams::MAIN);
     const auto testnetChainParams =
         CreateChainParams(CBaseChainParams::TESTNET);
     const auto regtestChainParams =
         CreateChainParams(CBaseChainParams::REGTEST);
 
     // Hidden Options
     std::vector<std::string> hidden_args = {
         "-dbcrashratio",
         "-forcecompactdb",
         "-maxaddrtosend",
         "-parkdeepreorg",
         "-automaticunparking",
         "-replayprotectionactivationtime",
         "-enableminerfund",
         // GUI args. These will be overwritten by SetupUIArgs for the GUI
         "-allowselfsignedrootcertificates",
         "-choosedatadir",
         "-lang=<lang>",
         "-min",
         "-resetguisettings",
         "-rootcertificates=<file>",
         "-splash",
         "-uiplatform",
         // TODO remove after the May 2023 upgrade
         "-wellingtonactivationtime",
     };
 
     // Set all of the args and their help
     // When adding new options to the categories, please keep and ensure
     // alphabetical ordering. Do not translate _(...) -help-debug options, Many
     // technical terms, and only a very small audience, so is unnecessary stress
     // to translators.
     argsman.AddArg("-version", "Print version and exit", ArgsManager::ALLOW_ANY,
                    OptionsCategory::OPTIONS);
 #if defined(HAVE_SYSTEM)
     argsman.AddArg(
         "-alertnotify=<cmd>",
         "Execute command when a relevant alert is received or we see "
         "a really long fork (%s in cmd is replaced by message)",
         ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
 #endif
     argsman.AddArg(
         "-assumevalid=<hex>",
         strprintf(
             "If this block is in the chain assume that it and its ancestors "
             "are valid and potentially skip their script verification (0 to "
             "verify all, default: %s, testnet: %s)",
             defaultChainParams->GetConsensus().defaultAssumeValid.GetHex(),
             testnetChainParams->GetConsensus().defaultAssumeValid.GetHex()),
         ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg("-blocksdir=<dir>",
                    "Specify directory to hold blocks subdirectory for *.dat "
                    "files (default: <datadir>)",
                    ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg("-fastprune",
                    "Use smaller block files and lower minimum prune height for "
                    "testing purposes",
                    ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                    OptionsCategory::DEBUG_TEST);
 #if defined(HAVE_SYSTEM)
     argsman.AddArg("-blocknotify=<cmd>",
                    "Execute command when the best block changes (%s in cmd is "
                    "replaced by block hash)",
                    ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
 #endif
     argsman.AddArg("-blockreconstructionextratxn=<n>",
                    strprintf("Extra transactions to keep in memory for compact "
                              "block reconstructions (default: %u)",
                              DEFAULT_BLOCK_RECONSTRUCTION_EXTRA_TXN),
                    ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg(
         "-blocksonly",
         strprintf("Whether to reject transactions from network peers.  "
                   "Automatic broadcast and rebroadcast of any transactions "
                   "from inbound peers is disabled, unless the peer has the "
                   "'forcerelay' permission. RPC transactions are"
                   " not affected. (default: %u)",
                   DEFAULT_BLOCKSONLY),
         ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg("-coinstatsindex",
                    strprintf("Maintain coinstats index used by the "
                              "gettxoutsetinfo RPC (default: %u)",
                              DEFAULT_COINSTATSINDEX),
                    ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg(
         "-conf=<file>",
         strprintf("Specify path to read-only configuration file. Relative "
                   "paths will be prefixed by datadir location. (default: %s)",
                   BITCOIN_CONF_FILENAME),
         ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg("-datadir=<dir>", "Specify data directory",
                    ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg(
         "-dbbatchsize",
         strprintf("Maximum database write batch size in bytes (default: %u)",
                   DEFAULT_DB_BATCH_SIZE),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::OPTIONS);
     argsman.AddArg(
         "-dbcache=<n>",
         strprintf("Set database cache size in MiB (%d to %d, default: %d)",
                   MIN_DB_CACHE_MB, MAX_DB_CACHE_MB, DEFAULT_DB_CACHE_MB),
         ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
-    argsman.AddArg(
-        "-finalizationdelay=<n>",
-        strprintf("Set the minimum amount of time to wait between a "
-                  "block header reception and the block finalization. "
-                  "Unit is seconds (default: %d)",
-                  DEFAULT_MIN_FINALIZATION_DELAY),
-        ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg(
         "-includeconf=<file>",
         "Specify additional configuration file, relative to the -datadir path "
         "(only useable from configuration file, not command line)",
         ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
-    argsman.AddArg("-maxreorgdepth=<n>",
-                   strprintf("Configure at what depth blocks are considered "
-                             "final (default: %d). Use -1 to disable.",
-                             DEFAULT_MAX_REORG_DEPTH),
-                   ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg("-loadblock=<file>",
                    "Imports blocks from external file on startup",
                    ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg("-maxmempool=<n>",
                    strprintf("Keep the transaction memory pool below <n> "
                              "megabytes (default: %u)",
                              DEFAULT_MAX_MEMPOOL_SIZE),
                    ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg("-maxorphantx=<n>",
                    strprintf("Keep at most <n> unconnectable transactions in "
                              "memory (default: %u)",
                              DEFAULT_MAX_ORPHAN_TRANSACTIONS),
                    ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg("-mempoolexpiry=<n>",
                    strprintf("Do not keep transactions in the mempool longer "
                              "than <n> hours (default: %u)",
                              DEFAULT_MEMPOOL_EXPIRY),
                    ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg(
         "-minimumchainwork=<hex>",
         strprintf(
             "Minimum work assumed to exist on a valid chain in hex "
             "(default: %s, testnet: %s)",
             defaultChainParams->GetConsensus().nMinimumChainWork.GetHex(),
             testnetChainParams->GetConsensus().nMinimumChainWork.GetHex()),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::OPTIONS);
     argsman.AddArg(
         "-par=<n>",
         strprintf("Set the number of script verification threads (%u to %d, 0 "
                   "= auto, <0 = leave that many cores free, default: %d)",
                   -GetNumCores(), MAX_SCRIPTCHECK_THREADS,
                   DEFAULT_SCRIPTCHECK_THREADS),
         ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg("-persistmempool",
                    strprintf("Whether to save the mempool on shutdown and load "
                              "on restart (default: %u)",
                              DEFAULT_PERSIST_MEMPOOL),
                    ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg(
         "-pid=<file>",
         strprintf("Specify pid file. Relative paths will be prefixed "
                   "by a net-specific datadir location. (default: %s)",
                   BITCOIN_PID_FILENAME),
         ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg(
         "-prune=<n>",
         strprintf("Reduce storage requirements by enabling pruning (deleting) "
                   "of old blocks. This allows the pruneblockchain RPC to be "
                   "called to delete specific blocks, and enables automatic "
                   "pruning of old blocks if a target size in MiB is provided. "
                   "This mode is incompatible with -txindex, -coinstatsindex "
                   "and -rescan. Warning: Reverting this setting requires "
                   "re-downloading the entire blockchain. (default: 0 = disable "
                   "pruning blocks, 1 = allow manual pruning via RPC, >=%u = "
                   "automatically prune block files to stay under the specified "
                   "target size in MiB)",
                   MIN_DISK_SPACE_FOR_BLOCK_FILES / 1024 / 1024),
         ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg(
         "-reindex-chainstate",
         "Rebuild chain state from the currently indexed blocks. When "
         "in pruning mode or if blocks on disk might be corrupted, use "
         "full -reindex instead.",
         ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg(
         "-reindex",
         "Rebuild chain state and block index from the blk*.dat files on disk",
         ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg(
         "-settings=<file>",
         strprintf(
             "Specify path to dynamic settings data file. Can be disabled with "
             "-nosettings. File is written at runtime and not meant to be "
             "edited by users (use %s instead for custom settings). Relative "
             "paths will be prefixed by datadir location. (default: %s)",
             BITCOIN_CONF_FILENAME, BITCOIN_SETTINGS_FILENAME),
         ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
 #if HAVE_SYSTEM
     argsman.AddArg("-startupnotify=<cmd>", "Execute command on startup.",
                    ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
 #endif
 #ifndef WIN32
     argsman.AddArg(
         "-sysperms",
         "Create new files with system default permissions, instead of umask "
         "077 (only effective with disabled wallet functionality)",
         ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
 #else
     hidden_args.emplace_back("-sysperms");
 #endif
     argsman.AddArg("-txindex",
                    strprintf("Maintain a full transaction index, used by the "
                              "getrawtransaction rpc call (default: %d)",
                              DEFAULT_TXINDEX),
                    ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
 #if ENABLE_CHRONIK
     argsman.AddArg(
         "-chronik",
         strprintf("Enable the Chronik indexer, which can be read via a "
                   "dedicated HTTP/Protobuf interface (default: %d)",
                   chronik::DEFAULT_ENABLED),
         ArgsManager::ALLOW_BOOL, OptionsCategory::CHRONIK);
     argsman.AddArg(
         "-chronikbind=<addr>[:port]",
         strprintf(
             "Bind the Chronik indexer to the given address to listen for "
             "HTTP/Protobuf connections to access the index. Unlike the "
             "JSON-RPC, it's ok to have this publicly exposed on the internet. "
             "This option can be specified multiple times (default: %s; default "
             "port: %u, testnet: %u, regtest: %u)",
             Join(chronik::DEFAULT_BINDS, ", "),
             defaultBaseParams->ChronikPort(), testnetBaseParams->ChronikPort(),
             regtestBaseParams->ChronikPort()),
         ArgsManager::ALLOW_STRING | ArgsManager::NETWORK_ONLY,
         OptionsCategory::CHRONIK);
 #endif
     argsman.AddArg(
         "-blockfilterindex=<type>",
         strprintf("Maintain an index of compact filters by block "
                   "(default: %s, values: %s).",
                   DEFAULT_BLOCKFILTERINDEX, ListBlockFilterTypes()) +
             " If <type> is not supplied or if <type> = 1, indexes for "
             "all known types are enabled.",
         ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg(
         "-usecashaddr",
         "Use Cash Address for destination encoding instead of base58 "
         "(activate by default on Jan, 14)",
         ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
 
     argsman.AddArg(
         "-addnode=<ip>",
         "Add a node to connect to and attempt to keep the connection "
         "open (see the `addnode` RPC command help for more info)",
         ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY,
         OptionsCategory::CONNECTION);
     argsman.AddArg("-asmap=<file>",
                    strprintf("Specify asn mapping used for bucketing of the "
                              "peers (default: %s). Relative paths will be "
                              "prefixed by the net-specific datadir location.",
                              DEFAULT_ASMAP_FILENAME),
                    ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg("-bantime=<n>",
                    strprintf("Default duration (in seconds) of manually "
                              "configured bans (default: %u)",
                              DEFAULT_MISBEHAVING_BANTIME),
                    ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg(
         "-bind=<addr>[:<port>][=onion]",
         strprintf("Bind to given address and always listen on it (default: "
                   "0.0.0.0). Use [host]:port notation for IPv6. Append =onion "
                   "to tag any incoming connections to that address and port as "
                   "incoming Tor connections (default: 127.0.0.1:%u=onion, "
                   "testnet: 127.0.0.1:%u=onion, regtest: 127.0.0.1:%u=onion)",
                   defaultBaseParams->OnionServiceTargetPort(),
                   testnetBaseParams->OnionServiceTargetPort(),
                   regtestBaseParams->OnionServiceTargetPort()),
         ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY,
         OptionsCategory::CONNECTION);
     argsman.AddArg(
         "-connect=<ip>",
         "Connect only to the specified node(s); -connect=0 disables automatic "
         "connections (the rules for this peer are the same as for -addnode)",
         ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY,
         OptionsCategory::CONNECTION);
     argsman.AddArg(
         "-discover",
         "Discover own IP addresses (default: 1 when listening and no "
         "-externalip or -proxy)",
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg("-dns",
                    strprintf("Allow DNS lookups for -addnode, -seednode and "
                              "-connect (default: %d)",
                              DEFAULT_NAME_LOOKUP),
                    ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg(
         "-dnsseed",
         strprintf(
             "Query for peer addresses via DNS lookup, if low on addresses "
             "(default: %u unless -connect used)",
             DEFAULT_DNSSEED),
         ArgsManager::ALLOW_BOOL, OptionsCategory::CONNECTION);
     argsman.AddArg("-externalip=<ip>", "Specify your own public address",
                    ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg(
         "-fixedseeds",
         strprintf(
             "Allow fixed seeds if DNS seeds don't provide peers (default: %u)",
             DEFAULT_FIXEDSEEDS),
         ArgsManager::ALLOW_BOOL, OptionsCategory::CONNECTION);
     argsman.AddArg(
         "-forcednsseed",
         strprintf(
             "Always query for peer addresses via DNS lookup (default: %d)",
             DEFAULT_FORCEDNSSEED),
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg("-overridednsseed",
                    "If set, only use the specified DNS seed when "
                    "querying for peer addresses via DNS lookup.",
                    ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg(
         "-listen",
         "Accept connections from outside (default: 1 if no -proxy or -connect)",
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg(
         "-listenonion",
         strprintf("Automatically create Tor onion service (default: %d)",
                   DEFAULT_LISTEN_ONION),
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg(
         "-maxconnections=<n>",
         strprintf("Maintain at most <n> connections to peers. The effective "
                   "limit depends on system limitations and might be lower than "
                   "the specified value (default: %u)",
                   DEFAULT_MAX_PEER_CONNECTIONS),
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg("-maxreceivebuffer=<n>",
                    strprintf("Maximum per-connection receive buffer, <n>*1000 "
                              "bytes (default: %u)",
                              DEFAULT_MAXRECEIVEBUFFER),
                    ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg(
         "-maxsendbuffer=<n>",
         strprintf(
             "Maximum per-connection send buffer, <n>*1000 bytes (default: %u)",
             DEFAULT_MAXSENDBUFFER),
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg(
         "-maxtimeadjustment",
         strprintf("Maximum allowed median peer time offset adjustment. Local "
                   "perspective of time may be influenced by peers forward or "
                   "backward by this amount. (default: %u seconds)",
                   DEFAULT_MAX_TIME_ADJUSTMENT),
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg("-onion=<ip:port>",
                    strprintf("Use separate SOCKS5 proxy to reach peers via Tor "
                              "onion services (default: %s)",
                              "-proxy"),
                    ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg("-i2psam=<ip:port>",
                    "I2P SAM proxy to reach I2P peers and accept I2P "
                    "connections (default: none)",
                    ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg(
         "-i2pacceptincoming",
         "If set and -i2psam is also set then incoming I2P connections are "
         "accepted via the SAM proxy. If this is not set but -i2psam is set "
         "then only outgoing connections will be made to the I2P network. "
         "Ignored if -i2psam is not set. Listening for incoming I2P connections "
         "is done through the SAM proxy, not by binding to a local address and "
         "port (default: 1)",
         ArgsManager::ALLOW_BOOL, OptionsCategory::CONNECTION);
 
     argsman.AddArg(
         "-onlynet=<net>",
         "Make outgoing connections only through network <net> (" +
             Join(GetNetworkNames(), ", ") +
             "). Incoming connections are not affected by this option. This "
             "option can be specified multiple times to allow multiple "
             "networks. Warning: if it is used with non-onion networks "
             "and the -onion or -proxy option is set, then outbound onion "
             "connections will still be made; use -noonion or -onion=0 to "
             "disable outbound onion connections in this case",
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg("-peerbloomfilters",
                    strprintf("Support filtering of blocks and transaction with "
                              "bloom filters (default: %d)",
                              DEFAULT_PEERBLOOMFILTERS),
                    ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg(
         "-peerblockfilters",
         strprintf(
             "Serve compact block filters to peers per BIP 157 (default: %u)",
             DEFAULT_PEERBLOCKFILTERS),
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg("-permitbaremultisig",
                    strprintf("Relay non-P2SH multisig (default: %d)",
                              DEFAULT_PERMIT_BAREMULTISIG),
                    ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     // TODO: remove the sentence "Nodes not using ... incoming connections."
     // once the changes from https://github.com/bitcoin/bitcoin/pull/23542 have
     // become widespread.
     argsman.AddArg("-port=<port>",
                    strprintf("Listen for connections on <port>. Nodes not "
                              "using the default ports (default: %u, "
                              "testnet: %u, regtest: %u) are unlikely to get "
                              "incoming connections.  Not relevant for I2P (see "
                              "doc/i2p.md).",
                              defaultChainParams->GetDefaultPort(),
                              testnetChainParams->GetDefaultPort(),
                              regtestChainParams->GetDefaultPort()),
                    ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY,
                    OptionsCategory::CONNECTION);
     argsman.AddArg("-proxy=<ip:port>", "Connect through SOCKS5 proxy",
                    ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg(
         "-proxyrandomize",
         strprintf("Randomize credentials for every proxy connection. "
                   "This enables Tor stream isolation (default: %d)",
                   DEFAULT_PROXYRANDOMIZE),
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg(
         "-seednode=<ip>",
         "Connect to a node to retrieve peer addresses, and disconnect",
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg(
         "-networkactive",
         "Enable all P2P network activity (default: 1). Can be changed "
         "by the setnetworkactive RPC command",
         ArgsManager::ALLOW_BOOL, OptionsCategory::CONNECTION);
     argsman.AddArg("-timeout=<n>",
                    strprintf("Specify connection timeout in milliseconds "
                              "(minimum: 1, default: %d)",
                              DEFAULT_CONNECT_TIMEOUT),
                    ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg(
         "-peertimeout=<n>",
         strprintf("Specify p2p connection timeout in seconds. This option "
                   "determines the amount of time a peer may be inactive before "
                   "the connection to it is dropped. (minimum: 1, default: %d)",
                   DEFAULT_PEER_CONNECT_TIMEOUT),
         true, OptionsCategory::CONNECTION);
     argsman.AddArg(
         "-torcontrol=<ip>:<port>",
         strprintf(
             "Tor control port to use if onion listening enabled (default: %s)",
             DEFAULT_TOR_CONTROL),
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg("-torpassword=<pass>",
                    "Tor control port password (default: empty)",
                    ArgsManager::ALLOW_ANY | ArgsManager::SENSITIVE,
                    OptionsCategory::CONNECTION);
 #ifdef USE_UPNP
 #if USE_UPNP
     argsman.AddArg("-upnp",
                    "Use UPnP to map the listening port (default: 1 when "
                    "listening and no -proxy)",
                    ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
 #else
     argsman.AddArg(
         "-upnp",
         strprintf("Use UPnP to map the listening port (default: %u)", 0),
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
 #endif
 #else
     hidden_args.emplace_back("-upnp");
 #endif
 #ifdef USE_NATPMP
     argsman.AddArg(
         "-natpmp",
         strprintf("Use NAT-PMP to map the listening port (default: %s)",
                   DEFAULT_NATPMP ? "1 when listening and no -proxy" : "0"),
         ArgsManager::ALLOW_BOOL, OptionsCategory::CONNECTION);
 #else
     hidden_args.emplace_back("-natpmp");
 #endif // USE_NATPMP
     argsman.AddArg(
         "-whitebind=<[permissions@]addr>",
         "Bind to the given address and add permission flags to the peers "
         "connecting to it."
         "Use [host]:port notation for IPv6. Allowed permissions: " +
             Join(NET_PERMISSIONS_DOC, ", ") +
             ". "
             "Specify multiple permissions separated by commas (default: "
             "download,noban,mempool,relay). Can be specified multiple times.",
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
 
     argsman.AddArg("-whitelist=<[permissions@]IP address or network>",
                    "Add permission flags to the peers connecting from the "
                    "given IP address (e.g. 1.2.3.4) or CIDR-notated network "
                    "(e.g. 1.2.3.0/24). "
                    "Uses the same permissions as -whitebind. Can be specified "
                    "multiple times.",
                    ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg(
         "-maxuploadtarget=<n>",
         strprintf("Tries to keep outbound traffic under the given target (in "
                   "MiB per 24h). Limit does not apply to peers with 'download' "
                   "permission. 0 = no limit (default: %d)",
                   DEFAULT_MAX_UPLOAD_TARGET),
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
 
     g_wallet_init_interface.AddWalletOptions(argsman);
 
 #if ENABLE_ZMQ
     argsman.AddArg("-zmqpubhashblock=<address>",
                    "Enable publish hash block in <address>",
                    ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
     argsman.AddArg("-zmqpubhashtx=<address>",
                    "Enable publish hash transaction in <address>",
                    ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
     argsman.AddArg("-zmqpubrawblock=<address>",
                    "Enable publish raw block in <address>",
                    ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
     argsman.AddArg("-zmqpubrawtx=<address>",
                    "Enable publish raw transaction in <address>",
                    ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
     argsman.AddArg("-zmqpubsequence=<address>",
                    "Enable publish hash block and tx sequence in <address>",
                    ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
     argsman.AddArg(
         "-zmqpubhashblockhwm=<n>",
         strprintf("Set publish hash block outbound message high water "
                   "mark (default: %d)",
                   CZMQAbstractNotifier::DEFAULT_ZMQ_SNDHWM),
         ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
     argsman.AddArg(
         "-zmqpubhashtxhwm=<n>",
         strprintf("Set publish hash transaction outbound message high "
                   "water mark (default: %d)",
                   CZMQAbstractNotifier::DEFAULT_ZMQ_SNDHWM),
         false, OptionsCategory::ZMQ);
     argsman.AddArg(
         "-zmqpubrawblockhwm=<n>",
         strprintf("Set publish raw block outbound message high water "
                   "mark (default: %d)",
                   CZMQAbstractNotifier::DEFAULT_ZMQ_SNDHWM),
         ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
     argsman.AddArg(
         "-zmqpubrawtxhwm=<n>",
         strprintf("Set publish raw transaction outbound message high "
                   "water mark (default: %d)",
                   CZMQAbstractNotifier::DEFAULT_ZMQ_SNDHWM),
         ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
     argsman.AddArg("-zmqpubsequencehwm=<n>",
                    strprintf("Set publish hash sequence message high water mark"
                              " (default: %d)",
                              CZMQAbstractNotifier::DEFAULT_ZMQ_SNDHWM),
                    ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
 #else
     hidden_args.emplace_back("-zmqpubhashblock=<address>");
     hidden_args.emplace_back("-zmqpubhashtx=<address>");
     hidden_args.emplace_back("-zmqpubrawblock=<address>");
     hidden_args.emplace_back("-zmqpubrawtx=<address>");
     hidden_args.emplace_back("-zmqpubsequence=<n>");
     hidden_args.emplace_back("-zmqpubhashblockhwm=<n>");
     hidden_args.emplace_back("-zmqpubhashtxhwm=<n>");
     hidden_args.emplace_back("-zmqpubrawblockhwm=<n>");
     hidden_args.emplace_back("-zmqpubrawtxhwm=<n>");
     hidden_args.emplace_back("-zmqpubsequencehwm=<n>");
 #endif
 
     argsman.AddArg(
         "-checkblocks=<n>",
         strprintf("How many blocks to check at startup (default: %u, 0 = all)",
                   DEFAULT_CHECKBLOCKS),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-checklevel=<n>",
                    strprintf("How thorough the block verification of "
                              "-checkblocks is: %s (0-4, default: %u)",
                              Join(CHECKLEVEL_DOC, ", "), DEFAULT_CHECKLEVEL),
                    ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                    OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-checkblockindex",
                    strprintf("Do a consistency check for the block tree, "
                              "chainstate, and other validation data structures "
                              "occasionally. (default: %u, regtest: %u)",
                              defaultChainParams->DefaultConsistencyChecks(),
                              regtestChainParams->DefaultConsistencyChecks()),
                    ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                    OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-checkaddrman=<n>",
                    strprintf("Run addrman consistency checks every <n> "
                              "operations. Use 0 to disable. (default: %u)",
                              DEFAULT_ADDRMAN_CONSISTENCY_CHECKS),
                    ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                    OptionsCategory::DEBUG_TEST);
     argsman.AddArg(
         "-checkmempool=<n>",
         strprintf("Run mempool consistency checks every <n> transactions. Use "
                   "0 to disable. (default: %u, regtest: %u)",
                   defaultChainParams->DefaultConsistencyChecks(),
                   regtestChainParams->DefaultConsistencyChecks()),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-checkpoints",
                    strprintf("Only accept block chain matching built-in "
                              "checkpoints (default: %d)",
                              DEFAULT_CHECKPOINTS_ENABLED),
                    ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                    OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-deprecatedrpc=<method>",
                    "Allows deprecated RPC method(s) to be used",
                    ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                    OptionsCategory::DEBUG_TEST);
     argsman.AddArg(
         "-stopafterblockimport",
         strprintf("Stop running after importing blocks from disk (default: %d)",
                   DEFAULT_STOPAFTERBLOCKIMPORT),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-stopatheight",
                    strprintf("Stop running after reaching the given height in "
                              "the main chain (default: %u)",
                              DEFAULT_STOPATHEIGHT),
                    ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                    OptionsCategory::DEBUG_TEST);
     argsman.AddArg(
         "-limitancestorcount=<n>",
         strprintf("Do not accept transactions if number of in-mempool "
                   "ancestors is <n> or more (default: %u)",
                   DEFAULT_ANCESTOR_LIMIT),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::DEBUG_TEST);
     argsman.AddArg(
         "-limitancestorsize=<n>",
         strprintf("Do not accept transactions whose size with all in-mempool "
                   "ancestors exceeds <n> kilobytes (default: %u)",
                   DEFAULT_ANCESTOR_SIZE_LIMIT),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::DEBUG_TEST);
     argsman.AddArg(
         "-limitdescendantcount=<n>",
         strprintf("Do not accept transactions if any ancestor would have <n> "
                   "or more in-mempool descendants (default: %u)",
                   DEFAULT_DESCENDANT_LIMIT),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::DEBUG_TEST);
     argsman.AddArg(
         "-limitdescendantsize=<n>",
         strprintf("Do not accept transactions if any ancestor would have more "
                   "than <n> kilobytes of in-mempool descendants (default: %u).",
                   DEFAULT_DESCENDANT_SIZE_LIMIT),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-addrmantest", "Allows to test address relay on localhost",
                    ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                    OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-capturemessages", "Capture all P2P messages to disk",
                    ArgsManager::ALLOW_BOOL | ArgsManager::DEBUG_ONLY,
                    OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-mocktime=<n>",
                    "Replace actual time with " + UNIX_EPOCH_TIME +
                        " (default: 0)",
                    ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                    OptionsCategory::DEBUG_TEST);
     argsman.AddArg(
         "-maxsigcachesize=<n>",
         strprintf("Limit size of signature cache to <n> MiB (default: %u)",
                   DEFAULT_MAX_SIG_CACHE_SIZE),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::DEBUG_TEST);
     argsman.AddArg(
         "-maxscriptcachesize=<n>",
         strprintf("Limit size of script cache to <n> MiB (default: %u)",
                   DEFAULT_MAX_SCRIPT_CACHE_SIZE),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-maxtipage=<n>",
                    strprintf("Maximum tip age in seconds to consider node in "
                              "initial block download (default: %u)",
                              DEFAULT_MAX_TIP_AGE),
                    ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                    OptionsCategory::DEBUG_TEST);
 
     argsman.AddArg("-uacomment=<cmt>",
                    "Append comment to the user agent string",
                    ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-uaclientname=<clientname>", "Set user agent client name",
                    ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-uaclientversion=<clientversion>",
                    "Set user agent client version", ArgsManager::ALLOW_ANY,
                    OptionsCategory::DEBUG_TEST);
 
     SetupChainParamsBaseOptions(argsman);
 
     argsman.AddArg(
         "-acceptnonstdtxn",
         strprintf(
             "Relay and mine \"non-standard\" transactions (%sdefault: %u)",
             "testnet/regtest only; ", defaultChainParams->RequireStandard()),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::NODE_RELAY);
     argsman.AddArg("-excessiveblocksize=<n>",
                    strprintf("Do not accept blocks larger than this limit, in "
                              "bytes (default: %d)",
                              DEFAULT_MAX_BLOCK_SIZE),
                    ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                    OptionsCategory::NODE_RELAY);
     const auto &ticker = Currency::get().ticker;
     argsman.AddArg(
         "-dustrelayfee=<amt>",
         strprintf("Fee rate (in %s/kB) used to define dust, the value of an "
                   "output such that it will cost about 1/3 of its value in "
                   "fees at this fee rate to spend it. (default: %s)",
                   ticker, FormatMoney(DUST_RELAY_TX_FEE)),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::NODE_RELAY);
 
     argsman.AddArg(
         "-bytespersigcheck",
         strprintf("Equivalent bytes per sigCheck in transactions for relay and "
                   "mining (default: %u).",
                   DEFAULT_BYTES_PER_SIGCHECK),
         ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
     argsman.AddArg(
         "-bytespersigop",
         strprintf("DEPRECATED: Equivalent bytes per sigCheck in transactions "
                   "for relay and mining (default: %u). This has been "
                   "deprecated since v0.26.8 and will be removed in the future, "
                   "please use -bytespersigcheck instead.",
                   DEFAULT_BYTES_PER_SIGCHECK),
         ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
     argsman.AddArg(
         "-datacarrier",
         strprintf("Relay and mine data carrier transactions (default: %d)",
                   DEFAULT_ACCEPT_DATACARRIER),
         ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
     argsman.AddArg(
         "-datacarriersize",
         strprintf("Maximum size of data in data carrier transactions "
                   "we relay and mine (default: %u)",
                   MAX_OP_RETURN_RELAY),
         ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
     argsman.AddArg(
         "-minrelaytxfee=<amt>",
         strprintf("Fees (in %s/kB) smaller than this are rejected for "
                   "relaying, mining and transaction creation (default: %s)",
                   ticker, FormatMoney(DEFAULT_MIN_RELAY_TX_FEE_PER_KB)),
         ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
     argsman.AddArg(
         "-whitelistrelay",
         strprintf("Add 'relay' permission to whitelisted inbound peers "
                   "with default permissions. This will accept relayed "
                   "transactions even when not relaying transactions "
                   "(default: %d)",
                   DEFAULT_WHITELISTRELAY),
         ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
     argsman.AddArg(
         "-whitelistforcerelay",
         strprintf("Add 'forcerelay' permission to whitelisted inbound peers"
                   " with default permissions. This will relay transactions "
                   "even if the transactions were already in the mempool "
                   "(default: %d)",
                   DEFAULT_WHITELISTFORCERELAY),
         ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
 
     // Not sure this really belongs here, but it will do for now.
     // FIXME: This doesn't work anyways.
     argsman.AddArg("-excessutxocharge=<amt>",
                    strprintf("Fees (in %s/kB) to charge per utxo created for "
                              "relaying, and mining (default: %s)",
                              ticker, FormatMoney(DEFAULT_UTXO_FEE)),
                    ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                    OptionsCategory::NODE_RELAY);
 
     argsman.AddArg("-blockmaxsize=<n>",
                    strprintf("Set maximum block size in bytes (default: %d)",
                              DEFAULT_MAX_GENERATED_BLOCK_SIZE),
                    ArgsManager::ALLOW_ANY, OptionsCategory::BLOCK_CREATION);
     argsman.AddArg(
         "-blockmintxfee=<amt>",
         strprintf("Set lowest fee rate (in %s/kB) for transactions to "
                   "be included in block creation. (default: %s)",
                   ticker, FormatMoney(DEFAULT_BLOCK_MIN_TX_FEE_PER_KB)),
         ArgsManager::ALLOW_ANY, OptionsCategory::BLOCK_CREATION);
 
     argsman.AddArg("-blockversion=<n>",
                    "Override block version to test forking scenarios",
                    ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                    OptionsCategory::BLOCK_CREATION);
 
     argsman.AddArg("-server", "Accept command line and JSON-RPC commands",
                    ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
     argsman.AddArg("-rest",
                    strprintf("Accept public REST requests (default: %d)",
                              DEFAULT_REST_ENABLE),
                    ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
     argsman.AddArg(
         "-rpcbind=<addr>[:port]",
         "Bind to given address to listen for JSON-RPC connections. Do not "
         "expose the RPC server to untrusted networks such as the public "
         "internet! This option is ignored unless -rpcallowip is also passed. "
         "Port is optional and overrides -rpcport.  Use [host]:port notation "
         "for IPv6. This option can be specified multiple times (default: "
         "127.0.0.1 and ::1 i.e., localhost)",
         ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY |
             ArgsManager::SENSITIVE,
         OptionsCategory::RPC);
     argsman.AddArg(
         "-rpccookiefile=<loc>",
         "Location of the auth cookie. Relative paths will be prefixed "
         "by a net-specific datadir location. (default: data dir)",
         ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
     argsman.AddArg("-rpcuser=<user>", "Username for JSON-RPC connections",
                    ArgsManager::ALLOW_ANY | ArgsManager::SENSITIVE,
                    OptionsCategory::RPC);
     argsman.AddArg("-rpcpassword=<pw>", "Password for JSON-RPC connections",
                    ArgsManager::ALLOW_ANY | ArgsManager::SENSITIVE,
                    OptionsCategory::RPC);
     argsman.AddArg(
         "-rpcwhitelist=<whitelist>",
         "Set a whitelist to filter incoming RPC calls for a specific user. The "
         "field <whitelist> comes in the format: <USERNAME>:<rpc 1>,<rpc "
         "2>,...,<rpc n>. If multiple whitelists are set for a given user, they "
         "are set-intersected. See -rpcwhitelistdefault documentation for "
         "information on default whitelist behavior.",
         ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
     argsman.AddArg(
         "-rpcwhitelistdefault",
         "Sets default behavior for rpc whitelisting. Unless "
         "rpcwhitelistdefault is set to 0, if any -rpcwhitelist is set, the rpc "
         "server acts as if all rpc users are subject to "
         "empty-unless-otherwise-specified whitelists. If rpcwhitelistdefault "
         "is set to 1 and no -rpcwhitelist is set, rpc server acts as if all "
         "rpc users are subject to empty whitelists.",
         ArgsManager::ALLOW_BOOL, OptionsCategory::RPC);
     argsman.AddArg(
         "-rpcauth=<userpw>",
         "Username and HMAC-SHA-256 hashed password for JSON-RPC connections. "
         "The field <userpw> comes in the format: <USERNAME>:<SALT>$<HASH>. A "
         "canonical python script is included in share/rpcauth. The client then "
         "connects normally using the rpcuser=<USERNAME>/rpcpassword=<PASSWORD> "
         "pair of arguments. This option can be specified multiple times",
         ArgsManager::ALLOW_ANY | ArgsManager::SENSITIVE, OptionsCategory::RPC);
     argsman.AddArg("-rpcport=<port>",
                    strprintf("Listen for JSON-RPC connections on <port> "
                              "(default: %u, testnet: %u, regtest: %u)",
                              defaultBaseParams->RPCPort(),
                              testnetBaseParams->RPCPort(),
                              regtestBaseParams->RPCPort()),
                    ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY,
                    OptionsCategory::RPC);
     argsman.AddArg(
         "-rpcallowip=<ip>",
         "Allow JSON-RPC connections from specified source. Valid for "
         "<ip> are a single IP (e.g. 1.2.3.4), a network/netmask (e.g. "
         "1.2.3.4/255.255.255.0) or a network/CIDR (e.g. 1.2.3.4/24). "
         "This option can be specified multiple times",
         ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
     argsman.AddArg(
         "-rpcthreads=<n>",
         strprintf(
             "Set the number of threads to service RPC calls (default: %d)",
             DEFAULT_HTTP_THREADS),
         ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
     argsman.AddArg(
         "-rpccorsdomain=value",
         "Domain from which to accept cross origin requests (browser enforced)",
         ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
 
     argsman.AddArg("-rpcworkqueue=<n>",
                    strprintf("Set the depth of the work queue to service RPC "
                              "calls (default: %d)",
                              DEFAULT_HTTP_WORKQUEUE),
                    ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                    OptionsCategory::RPC);
     argsman.AddArg("-rpcservertimeout=<n>",
                    strprintf("Timeout during HTTP requests (default: %d)",
                              DEFAULT_HTTP_SERVER_TIMEOUT),
                    ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                    OptionsCategory::RPC);
 
 #if HAVE_DECL_FORK
     argsman.AddArg("-daemon",
                    strprintf("Run in the background as a daemon and accept "
                              "commands (default: %d)",
                              DEFAULT_DAEMON),
                    ArgsManager::ALLOW_BOOL, OptionsCategory::OPTIONS);
     argsman.AddArg("-daemonwait",
                    strprintf("Wait for initialization to be finished before "
                              "exiting. This implies -daemon (default: %d)",
                              DEFAULT_DAEMONWAIT),
                    ArgsManager::ALLOW_BOOL, OptionsCategory::OPTIONS);
 #else
     hidden_args.emplace_back("-daemon");
     hidden_args.emplace_back("-daemonwait");
 #endif
 
     // Avalanche options.
     argsman.AddArg("-avalanche",
                    strprintf("Enable the avalanche feature (default: %u)",
                              AVALANCHE_DEFAULT_ENABLED),
                    ArgsManager::ALLOW_ANY, OptionsCategory::AVALANCHE);
     argsman.AddArg("-avalancheconflictingproofcooldown",
                    strprintf("Mandatory cooldown before a proof conflicting "
                              "with an already registered one can be considered "
                              "in seconds (default: %u)",
                              AVALANCHE_DEFAULT_CONFLICTING_PROOF_COOLDOWN),
                    ArgsManager::ALLOW_INT, OptionsCategory::AVALANCHE);
     argsman.AddArg("-avalanchepeerreplacementcooldown",
                    strprintf("Mandatory cooldown before a peer can be replaced "
                              "in seconds (default: %u)",
                              AVALANCHE_DEFAULT_PEER_REPLACEMENT_COOLDOWN),
                    ArgsManager::ALLOW_INT, OptionsCategory::AVALANCHE);
     argsman.AddArg(
         "-avaminquorumstake",
         strprintf(
             "Minimum amount of known stake for a usable quorum (default: %s)",
             FormatMoney(AVALANCHE_DEFAULT_MIN_QUORUM_STAKE)),
         ArgsManager::ALLOW_ANY, OptionsCategory::AVALANCHE);
     argsman.AddArg(
         "-avaminquorumconnectedstakeratio",
         strprintf("Minimum proportion of known stake we"
                   " need nodes for to have a usable quorum (default: %s)",
                   AVALANCHE_DEFAULT_MIN_QUORUM_CONNECTED_STAKE_RATIO),
         ArgsManager::ALLOW_STRING, OptionsCategory::AVALANCHE);
     argsman.AddArg(
         "-avaminavaproofsnodecount",
         strprintf("Minimum number of node that needs to send us an avaproofs"
                   " message before we consider we have a usable quorum"
                   " (default: %s)",
                   AVALANCHE_DEFAULT_MIN_AVAPROOFS_NODE_COUNT),
         ArgsManager::ALLOW_INT, OptionsCategory::AVALANCHE);
     argsman.AddArg(
         "-avastalevotethreshold",
         strprintf("Number of avalanche votes before a voted item goes stale "
                   "when voting confidence is low (default: %u)",
                   AVALANCHE_VOTE_STALE_THRESHOLD),
         ArgsManager::ALLOW_INT, OptionsCategory::AVALANCHE);
     argsman.AddArg(
         "-avastalevotefactor",
         strprintf(
             "Factor affecting the number of avalanche votes before a voted "
             "item goes stale when voting confidence is high (default: %u)",
             AVALANCHE_VOTE_STALE_FACTOR),
         ArgsManager::ALLOW_INT, OptionsCategory::AVALANCHE);
     argsman.AddArg("-avacooldown",
                    strprintf("Mandatory cooldown between two avapoll in "
                              "milliseconds (default: %u)",
                              AVALANCHE_DEFAULT_COOLDOWN),
                    ArgsManager::ALLOW_ANY, OptionsCategory::AVALANCHE);
     argsman.AddArg(
         "-avatimeout",
         strprintf("Avalanche query timeout in milliseconds (default: %u)",
                   AVALANCHE_DEFAULT_QUERY_TIMEOUT.count()),
         ArgsManager::ALLOW_ANY, OptionsCategory::AVALANCHE);
     argsman.AddArg(
         "-avadelegation",
         "Avalanche proof delegation to the master key used by this node "
         "(default: none). Should be used in conjunction with -avaproof and "
         "-avamasterkey",
         ArgsManager::ALLOW_ANY, OptionsCategory::AVALANCHE);
     argsman.AddArg("-avaproof",
                    "Avalanche proof to be used by this node (default: none)",
                    ArgsManager::ALLOW_ANY, OptionsCategory::AVALANCHE);
     argsman.AddArg(
         "-avaproofstakeutxoconfirmations",
         strprintf(
             "Minimum number of confirmations before a stake utxo is mature"
             " enough to be included into a proof. Utxos in the mempool are not "
             "accepted (i.e this value must be greater than 0) (default: %s)",
             AVALANCHE_DEFAULT_STAKE_UTXO_CONFIRMATIONS),
         ArgsManager::ALLOW_INT, OptionsCategory::HIDDEN);
     argsman.AddArg("-avaproofstakeutxodustthreshold",
                    strprintf("Minimum value each stake utxo must have to be "
                              "considered valid (default: %s)",
                              avalanche::PROOF_DUST_THRESHOLD),
                    ArgsManager::ALLOW_ANY, OptionsCategory::HIDDEN);
     argsman.AddArg("-avamasterkey",
                    "Master key associated with the proof. If a proof is "
                    "required, this is mandatory.",
                    ArgsManager::ALLOW_ANY | ArgsManager::SENSITIVE,
                    OptionsCategory::AVALANCHE);
     argsman.AddArg("-avasessionkey", "Avalanche session key (default: random)",
                    ArgsManager::ALLOW_ANY | ArgsManager::SENSITIVE,
                    OptionsCategory::HIDDEN);
     argsman.AddArg(
         "-maxavalancheoutbound",
         strprintf(
             "Set the maximum number of avalanche outbound peers to connect to. "
             "Note that the -maxconnections option takes precedence (default: "
             "%u).",
             DEFAULT_MAX_AVALANCHE_OUTBOUND_CONNECTIONS),
         ArgsManager::ALLOW_INT, OptionsCategory::AVALANCHE);
 
     hidden_args.emplace_back("-avalanchepreconsensus");
 
     // Add the hidden options
     argsman.AddHiddenArgs(hidden_args);
 }
 
 std::string LicenseInfo() {
     const std::string URL_SOURCE_CODE =
         "<https://github.com/Bitcoin-ABC/bitcoin-abc>";
     const std::string URL_WEBSITE = "<https://www.bitcoinabc.org>";
 
     return CopyrightHolders(strprintf(_("Copyright (C) %i-%i").translated, 2009,
                                       COPYRIGHT_YEAR) +
                             " ") +
            "\n" + "\n" +
            strprintf(_("Please contribute if you find %s useful. "
                        "Visit %s for further information about the software.")
                          .translated,
                      PACKAGE_NAME, URL_WEBSITE) +
            "\n" +
            strprintf(_("The source code is available from %s.").translated,
                      URL_SOURCE_CODE) +
            "\n" + "\n" + _("This is experimental software.").translated + "\n" +
            strprintf(_("Distributed under the MIT software license, see the "
                        "accompanying file %s or %s")
                          .translated,
                      "COPYING", "<https://opensource.org/licenses/MIT>") +
            "\n" + "\n" +
            strprintf(_("This product includes software developed by the "
                        "OpenSSL Project for use in the OpenSSL Toolkit %s and "
                        "cryptographic software written by Eric Young and UPnP "
                        "software written by Thomas Bernard.")
                          .translated,
                      "<https://www.openssl.org>") +
            "\n";
 }
 
 static bool fHaveGenesis = false;
 static Mutex g_genesis_wait_mutex;
 static std::condition_variable g_genesis_wait_cv;
 
 static void BlockNotifyGenesisWait(const CBlockIndex *pBlockIndex) {
     if (pBlockIndex != nullptr) {
         {
             LOCK(g_genesis_wait_mutex);
             fHaveGenesis = true;
         }
         g_genesis_wait_cv.notify_all();
     }
 }
 
 #if HAVE_SYSTEM
 static void StartupNotify(const ArgsManager &args) {
     std::string cmd = args.GetArg("-startupnotify", "");
     if (!cmd.empty()) {
         std::thread t(runCommand, cmd);
         // thread runs free
         t.detach();
     }
 }
 #endif
 
 static bool AppInitServers(Config &config,
                            HTTPRPCRequestProcessor &httpRPCRequestProcessor,
                            NodeContext &node) {
     const ArgsManager &args = *Assert(node.args);
     RPCServerSignals::OnStarted(&OnRPCStarted);
     RPCServerSignals::OnStopped(&OnRPCStopped);
     if (!InitHTTPServer(config)) {
         return false;
     }
 
     StartRPC();
     node.rpc_interruption_point = RpcInterruptionPoint;
 
     if (!StartHTTPRPC(httpRPCRequestProcessor)) {
         return false;
     }
     if (args.GetBoolArg("-rest", DEFAULT_REST_ENABLE)) {
         StartREST(&node);
     }
 
     StartHTTPServer();
     return true;
 }
 
 // Parameter interaction based on rules
 void InitParameterInteraction(ArgsManager &args) {
     // when specifying an explicit binding address, you want to listen on it
     // even when -connect or -proxy is specified.
     if (args.IsArgSet("-bind")) {
         if (args.SoftSetBoolArg("-listen", true)) {
             LogPrintf(
                 "%s: parameter interaction: -bind set -> setting -listen=1\n",
                 __func__);
         }
     }
     if (args.IsArgSet("-whitebind")) {
         if (args.SoftSetBoolArg("-listen", true)) {
             LogPrintf("%s: parameter interaction: -whitebind set -> setting "
                       "-listen=1\n",
                       __func__);
         }
     }
 
     if (args.IsArgSet("-connect")) {
         // when only connecting to trusted nodes, do not seed via DNS, or listen
         // by default.
         if (args.SoftSetBoolArg("-dnsseed", false)) {
             LogPrintf("%s: parameter interaction: -connect set -> setting "
                       "-dnsseed=0\n",
                       __func__);
         }
         if (args.SoftSetBoolArg("-listen", false)) {
             LogPrintf("%s: parameter interaction: -connect set -> setting "
                       "-listen=0\n",
                       __func__);
         }
     }
 
     if (args.IsArgSet("-proxy")) {
         // to protect privacy, do not listen by default if a default proxy
         // server is specified.
         if (args.SoftSetBoolArg("-listen", false)) {
             LogPrintf(
                 "%s: parameter interaction: -proxy set -> setting -listen=0\n",
                 __func__);
         }
         // to protect privacy, do not map ports when a proxy is set. The user
         // may still specify -listen=1 to listen locally, so don't rely on this
         // happening through -listen below.
         if (args.SoftSetBoolArg("-upnp", false)) {
             LogPrintf(
                 "%s: parameter interaction: -proxy set -> setting -upnp=0\n",
                 __func__);
         }
         if (args.SoftSetBoolArg("-natpmp", false)) {
             LogPrintf(
                 "%s: parameter interaction: -proxy set -> setting -natpmp=0\n",
                 __func__);
         }
         // to protect privacy, do not discover addresses by default
         if (args.SoftSetBoolArg("-discover", false)) {
             LogPrintf("%s: parameter interaction: -proxy set -> setting "
                       "-discover=0\n",
                       __func__);
         }
     }
 
     if (!args.GetBoolArg("-listen", DEFAULT_LISTEN)) {
         // do not map ports or try to retrieve public IP when not listening
         // (pointless)
         if (args.SoftSetBoolArg("-upnp", false)) {
             LogPrintf(
                 "%s: parameter interaction: -listen=0 -> setting -upnp=0\n",
                 __func__);
         }
         if (args.SoftSetBoolArg("-natpmp", false)) {
             LogPrintf(
                 "%s: parameter interaction: -listen=0 -> setting -natpmp=0\n",
                 __func__);
         }
         if (args.SoftSetBoolArg("-discover", false)) {
             LogPrintf(
                 "%s: parameter interaction: -listen=0 -> setting -discover=0\n",
                 __func__);
         }
         if (args.SoftSetBoolArg("-listenonion", false)) {
             LogPrintf("%s: parameter interaction: -listen=0 -> setting "
                       "-listenonion=0\n",
                       __func__);
         }
         if (args.SoftSetBoolArg("-i2pacceptincoming", false)) {
             LogPrintf("%s: parameter interaction: -listen=0 -> setting "
                       "-i2pacceptincoming=0\n",
                       __func__);
         }
     }
 
     if (args.IsArgSet("-externalip")) {
         // if an explicit public IP is specified, do not try to find others
         if (args.SoftSetBoolArg("-discover", false)) {
             LogPrintf("%s: parameter interaction: -externalip set -> setting "
                       "-discover=0\n",
                       __func__);
         }
     }
 
     // disable whitelistrelay in blocksonly mode
     if (args.GetBoolArg("-blocksonly", DEFAULT_BLOCKSONLY)) {
         if (args.SoftSetBoolArg("-whitelistrelay", false)) {
             LogPrintf("%s: parameter interaction: -blocksonly=1 -> setting "
                       "-whitelistrelay=0\n",
                       __func__);
         }
     }
 
     // Forcing relay from whitelisted hosts implies we will accept relays from
     // them in the first place.
     if (args.GetBoolArg("-whitelistforcerelay", DEFAULT_WHITELISTFORCERELAY)) {
         if (args.SoftSetBoolArg("-whitelistrelay", true)) {
             LogPrintf("%s: parameter interaction: -whitelistforcerelay=1 -> "
                       "setting -whitelistrelay=1\n",
                       __func__);
         }
     }
 
     // If avalanche is set, soft set all the feature flags accordingly.
     if (args.IsArgSet("-avalanche")) {
         const bool fAvalanche =
             args.GetBoolArg("-avalanche", AVALANCHE_DEFAULT_ENABLED);
         args.SoftSetBoolArg("-automaticunparking", !fAvalanche);
     }
 }
 
 /**
  * Initialize global loggers.
  *
  * Note that this is called very early in the process lifetime, so you should be
  * careful about what global state you rely on here.
  */
 void InitLogging(const ArgsManager &args) {
     init::SetLoggingOptions(args);
     init::LogPackageVersion();
 }
 
 namespace { // Variables internal to initialization process only
 
 int nMaxConnections;
 int nUserMaxConnections;
 int nFD;
 ServiceFlags nLocalServices = ServiceFlags(NODE_NETWORK | NODE_NETWORK_LIMITED);
 int64_t peer_connect_timeout;
 std::set<BlockFilterType> g_enabled_filter_types;
 
 } // namespace
 
 [[noreturn]] static void new_handler_terminate() {
     // Rather than throwing std::bad-alloc if allocation fails, terminate
     // immediately to (try to) avoid chain corruption. Since LogPrintf may
     // itself allocate memory, set the handler directly to terminate first.
     std::set_new_handler(std::terminate);
     LogPrintf("Error: Out of memory. Terminating.\n");
 
     // The log was successful, terminate now.
     std::terminate();
 };
 
 bool AppInitBasicSetup(const ArgsManager &args) {
 // Step 1: setup
 #ifdef _MSC_VER
     // Turn off Microsoft heap dump noise
     _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
     _CrtSetReportFile(_CRT_WARN, CreateFileA("NUL", GENERIC_WRITE, 0, nullptr,
                                              OPEN_EXISTING, 0, 0));
     // Disable confusing "helpful" text message on abort, Ctrl-C
     _set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
 #endif
 #ifdef WIN32
     // Enable Data Execution Prevention (DEP)
     SetProcessDEPPolicy(PROCESS_DEP_ENABLE);
 #endif
     if (!InitShutdownState()) {
         return InitError(
             Untranslated("Initializing wait-for-shutdown state failed."));
     }
 
     if (!SetupNetworking()) {
         return InitError(Untranslated("Initializing networking failed"));
     }
 
 #ifndef WIN32
     if (!args.GetBoolArg("-sysperms", false)) {
         umask(077);
     }
 
     // Clean shutdown on SIGTERM
     registerSignalHandler(SIGTERM, HandleSIGTERM);
     registerSignalHandler(SIGINT, HandleSIGTERM);
 
     // Reopen debug.log on SIGHUP
     registerSignalHandler(SIGHUP, HandleSIGHUP);
 
     // Ignore SIGPIPE, otherwise it will bring the daemon down if the client
     // closes unexpectedly
     signal(SIGPIPE, SIG_IGN);
 #else
     SetConsoleCtrlHandler(consoleCtrlHandler, true);
 #endif
 
     std::set_new_handler(new_handler_terminate);
 
     return true;
 }
 
 bool AppInitParameterInteraction(Config &config, const ArgsManager &args) {
     const CChainParams &chainparams = config.GetChainParams();
     // Step 2: parameter interactions
 
     // also see: InitParameterInteraction()
 
     // Error if network-specific options (-addnode, -connect, etc) are
     // specified in default section of config file, but not overridden
     // on the command line or in this network's section of the config file.
     std::string network = args.GetChainName();
     bilingual_str errors;
     for (const auto &arg : args.GetUnsuitableSectionOnlyArgs()) {
         errors += strprintf(_("Config setting for %s only applied on %s "
                               "network when in [%s] section.") +
                                 Untranslated("\n"),
                             arg, network, network);
     }
 
     if (!errors.empty()) {
         return InitError(errors);
     }
 
     // Warn if unrecognized section name are present in the config file.
     bilingual_str warnings;
     for (const auto &section : args.GetUnrecognizedSections()) {
         warnings += strprintf(Untranslated("%s:%i ") +
                                   _("Section [%s] is not recognized.") +
                                   Untranslated("\n"),
                               section.m_file, section.m_line, section.m_name);
     }
 
     if (!warnings.empty()) {
         InitWarning(warnings);
     }
 
     if (!fs::is_directory(args.GetBlocksDirPath())) {
         return InitError(
             strprintf(_("Specified blocks directory \"%s\" does not exist."),
                       args.GetArg("-blocksdir", "")));
     }
 
     // parse and validate enabled filter types
     std::string blockfilterindex_value =
         args.GetArg("-blockfilterindex", DEFAULT_BLOCKFILTERINDEX);
     if (blockfilterindex_value == "" || blockfilterindex_value == "1") {
         g_enabled_filter_types = AllBlockFilterTypes();
     } else if (blockfilterindex_value != "0") {
         const std::vector<std::string> names =
             args.GetArgs("-blockfilterindex");
         for (const auto &name : names) {
             BlockFilterType filter_type;
             if (!BlockFilterTypeByName(name, filter_type)) {
                 return InitError(
                     strprintf(_("Unknown -blockfilterindex value %s."), name));
             }
             g_enabled_filter_types.insert(filter_type);
         }
     }
 
     // Signal NODE_COMPACT_FILTERS if peerblockfilters and basic filters index
     // are both enabled.
     if (args.GetBoolArg("-peerblockfilters", DEFAULT_PEERBLOCKFILTERS)) {
         if (g_enabled_filter_types.count(BlockFilterType::BASIC) != 1) {
             return InitError(
                 _("Cannot set -peerblockfilters without -blockfilterindex."));
         }
 
         nLocalServices = ServiceFlags(nLocalServices | NODE_COMPACT_FILTERS);
     }
 
     // if using block pruning, then disallow txindex and coinstatsindex
     if (args.GetIntArg("-prune", 0)) {
         if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
             return InitError(_("Prune mode is incompatible with -txindex."));
         }
         if (args.GetBoolArg("-coinstatsindex", DEFAULT_COINSTATSINDEX)) {
             return InitError(
                 _("Prune mode is incompatible with -coinstatsindex."));
         }
     }
 
     // -bind and -whitebind can't be set when not listening
     size_t nUserBind =
         args.GetArgs("-bind").size() + args.GetArgs("-whitebind").size();
     if (nUserBind != 0 && !args.GetBoolArg("-listen", DEFAULT_LISTEN)) {
         return InitError(Untranslated(
             "Cannot set -bind or -whitebind together with -listen=0"));
     }
 
     // Make sure enough file descriptors are available
     int nBind = std::max(nUserBind, size_t(1));
     nUserMaxConnections =
         args.GetIntArg("-maxconnections", DEFAULT_MAX_PEER_CONNECTIONS);
     nMaxConnections = std::max(nUserMaxConnections, 0);
 
     // Trim requested connection counts, to fit into system limitations
     // <int> in std::min<int>(...) to work around FreeBSD compilation issue
     // described in #2695
     nFD = RaiseFileDescriptorLimit(
         nMaxConnections + nBind + MIN_CORE_FILEDESCRIPTORS +
         MAX_ADDNODE_CONNECTIONS + NUM_FDS_MESSAGE_CAPTURE);
 #ifdef USE_POLL
     int fd_max = nFD;
 #else
     int fd_max = FD_SETSIZE;
 #endif
     nMaxConnections = std::max(
         std::min<int>(nMaxConnections,
                       fd_max - nBind - MIN_CORE_FILEDESCRIPTORS -
                           MAX_ADDNODE_CONNECTIONS - NUM_FDS_MESSAGE_CAPTURE),
         0);
     if (nFD < MIN_CORE_FILEDESCRIPTORS) {
         return InitError(_("Not enough file descriptors available."));
     }
     nMaxConnections =
         std::min(nFD - MIN_CORE_FILEDESCRIPTORS - MAX_ADDNODE_CONNECTIONS,
                  nMaxConnections);
 
     if (nMaxConnections < nUserMaxConnections) {
         // Not categorizing as "Warning" because this is the normal behavior for
         // platforms using the select() interface for which FD_SETSIZE is
         // usually 1024.
         LogPrintf("Reducing -maxconnections from %d to %d, because of system "
                   "limitations.\n",
                   nUserMaxConnections, nMaxConnections);
     }
 
     // Step 3: parameter-to-internal-flags
     init::SetLoggingCategories(args);
 
     fCheckBlockIndex = args.GetBoolArg("-checkblockindex",
                                        chainparams.DefaultConsistencyChecks());
     fCheckpointsEnabled =
         args.GetBoolArg("-checkpoints", DEFAULT_CHECKPOINTS_ENABLED);
     if (fCheckpointsEnabled) {
         LogPrintf("Checkpoints will be verified.\n");
     } else {
         LogPrintf("Skipping checkpoint verification.\n");
     }
 
     hashAssumeValid = BlockHash::fromHex(
         args.GetArg("-assumevalid",
                     chainparams.GetConsensus().defaultAssumeValid.GetHex()));
     if (!hashAssumeValid.IsNull()) {
         LogPrintf("Assuming ancestors of block %s have valid signatures.\n",
                   hashAssumeValid.GetHex());
     } else {
         LogPrintf("Validating signatures for all blocks.\n");
     }
 
     if (args.IsArgSet("-minimumchainwork")) {
         const std::string minChainWorkStr =
             args.GetArg("-minimumchainwork", "");
         if (!IsHexNumber(minChainWorkStr)) {
             return InitError(strprintf(
                 Untranslated(
                     "Invalid non-hex (%s) minimum chain work value specified"),
                 minChainWorkStr));
         }
         nMinimumChainWork = UintToArith256(uint256S(minChainWorkStr));
     } else {
         nMinimumChainWork =
             UintToArith256(chainparams.GetConsensus().nMinimumChainWork);
     }
     LogPrintf("Setting nMinimumChainWork=%s\n", nMinimumChainWork.GetHex());
     if (nMinimumChainWork <
         UintToArith256(chainparams.GetConsensus().nMinimumChainWork)) {
         LogPrintf("Warning: nMinimumChainWork set below default value of %s\n",
                   chainparams.GetConsensus().nMinimumChainWork.GetHex());
     }
 
     // mempool limits
     int64_t nMempoolSizeMax =
         args.GetIntArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000;
     int64_t nMempoolSizeMin =
         args.GetIntArg("-limitdescendantsize", DEFAULT_DESCENDANT_SIZE_LIMIT) *
         1000 * 40;
     if (nMempoolSizeMax < 0 || nMempoolSizeMax < nMempoolSizeMin) {
         return InitError(strprintf(_("-maxmempool must be at least %d MB"),
                                    std::ceil(nMempoolSizeMin / 1000000.0)));
     }
 
     // Configure excessive block size.
     const int64_t nProposedExcessiveBlockSize =
         args.GetIntArg("-excessiveblocksize", DEFAULT_MAX_BLOCK_SIZE);
     if (nProposedExcessiveBlockSize <= 0 ||
         !config.SetMaxBlockSize(nProposedExcessiveBlockSize)) {
         return InitError(
             _("Excessive block size must be > 1,000,000 bytes (1MB)"));
     }
 
     // Check blockmaxsize does not exceed maximum accepted block size.
     const int64_t nProposedMaxGeneratedBlockSize =
         args.GetIntArg("-blockmaxsize", DEFAULT_MAX_GENERATED_BLOCK_SIZE);
     if (nProposedMaxGeneratedBlockSize <= 0) {
         return InitError(_("Max generated block size must be greater than 0"));
     }
     if (uint64_t(nProposedMaxGeneratedBlockSize) > config.GetMaxBlockSize()) {
         return InitError(_("Max generated block size (blockmaxsize) cannot "
                            "exceed the excessive block size "
                            "(excessiveblocksize)"));
     }
 
     // block pruning; get the amount of disk space (in MiB) to allot for block &
     // undo files
     int64_t nPruneArg = args.GetIntArg("-prune", 0);
     if (nPruneArg < 0) {
         return InitError(
             _("Prune cannot be configured with a negative value."));
     }
     nPruneTarget = (uint64_t)nPruneArg * 1024 * 1024;
     if (nPruneArg == 1) {
         // manual pruning: -prune=1
         LogPrintf("Block pruning enabled.  Use RPC call "
                   "pruneblockchain(height) to manually prune block and undo "
                   "files.\n");
         nPruneTarget = std::numeric_limits<uint64_t>::max();
         fPruneMode = true;
     } else if (nPruneTarget) {
         if (nPruneTarget < MIN_DISK_SPACE_FOR_BLOCK_FILES) {
             return InitError(
                 strprintf(_("Prune configured below the minimum of %d MiB. "
                             "Please use a higher number."),
                           MIN_DISK_SPACE_FOR_BLOCK_FILES / 1024 / 1024));
         }
         LogPrintf("Prune configured to target %u MiB on disk for block and "
                   "undo files.\n",
                   nPruneTarget / 1024 / 1024);
         fPruneMode = true;
     }
 
     nConnectTimeout = args.GetIntArg("-timeout", DEFAULT_CONNECT_TIMEOUT);
     if (nConnectTimeout <= 0) {
         nConnectTimeout = DEFAULT_CONNECT_TIMEOUT;
     }
 
     peer_connect_timeout =
         args.GetIntArg("-peertimeout", DEFAULT_PEER_CONNECT_TIMEOUT);
     if (peer_connect_timeout <= 0) {
         return InitError(Untranslated(
             "peertimeout cannot be configured with a negative value."));
     }
 
     // Obtain the amount to charge excess UTXO
     if (args.IsArgSet("-excessutxocharge")) {
         Amount n = Amount::zero();
         auto parsed = ParseMoney(args.GetArg("-excessutxocharge", ""), n);
         if (!parsed || Amount::zero() > n) {
             return InitError(AmountErrMsg(
                 "excessutxocharge", args.GetArg("-excessutxocharge", "")));
         }
         config.SetExcessUTXOCharge(n);
     } else {
         config.SetExcessUTXOCharge(DEFAULT_UTXO_FEE);
     }
 
     if (args.IsArgSet("-minrelaytxfee")) {
         Amount n = Amount::zero();
         auto parsed = ParseMoney(args.GetArg("-minrelaytxfee", ""), n);
         if (!parsed || n == Amount::zero()) {
             return InitError(AmountErrMsg("minrelaytxfee",
                                           args.GetArg("-minrelaytxfee", "")));
         }
         // High fee check is done afterward in CWallet::Create()
         ::minRelayTxFee = CFeeRate(n);
     }
 
     // Sanity check argument for min fee for including tx in block
     // TODO: Harmonize which arguments need sanity checking and where that
     // happens.
     if (args.IsArgSet("-blockmintxfee")) {
         Amount n = Amount::zero();
         if (!ParseMoney(args.GetArg("-blockmintxfee", ""), n)) {
             return InitError(AmountErrMsg("blockmintxfee",
                                           args.GetArg("-blockmintxfee", "")));
         }
     }
 
     // Feerate used to define dust.  Shouldn't be changed lightly as old
     // implementations may inadvertently create non-standard transactions.
     if (args.IsArgSet("-dustrelayfee")) {
         Amount n = Amount::zero();
         auto parsed = ParseMoney(args.GetArg("-dustrelayfee", ""), n);
         if (!parsed || Amount::zero() == n) {
             return InitError(
                 AmountErrMsg("dustrelayfee", args.GetArg("-dustrelayfee", "")));
         }
         dustRelayFee = CFeeRate(n);
     }
 
     fRequireStandard =
         !args.GetBoolArg("-acceptnonstdtxn", !chainparams.RequireStandard());
     if (!chainparams.IsTestChain() && !fRequireStandard) {
         return InitError(strprintf(
             Untranslated(
                 "acceptnonstdtxn is not currently supported for %s chain"),
             chainparams.NetworkIDString()));
     }
     nBytesPerSigCheck =
         args.IsArgSet("-bytespersigcheck")
             ? args.GetIntArg("-bytespersigcheck", nBytesPerSigCheck)
             : args.GetIntArg("-bytespersigop", nBytesPerSigCheck);
 
     if (!g_wallet_init_interface.ParameterInteraction()) {
         return false;
     }
 
     fIsBareMultisigStd =
         args.GetBoolArg("-permitbaremultisig", DEFAULT_PERMIT_BAREMULTISIG);
     fAcceptDatacarrier =
         args.GetBoolArg("-datacarrier", DEFAULT_ACCEPT_DATACARRIER);
 
     // Option to startup with mocktime set (used for regression testing):
     SetMockTime(args.GetIntArg("-mocktime", 0)); // SetMockTime(0) is a no-op
 
     if (args.GetBoolArg("-peerbloomfilters", DEFAULT_PEERBLOOMFILTERS)) {
         nLocalServices = ServiceFlags(nLocalServices | NODE_BLOOM);
     }
 
     nMaxTipAge = args.GetIntArg("-maxtipage", DEFAULT_MAX_TIP_AGE);
 
     if (args.IsArgSet("-proxy") && args.GetArg("-proxy", "").empty()) {
         return InitError(_(
             "No proxy server specified. Use -proxy=<ip> or -proxy=<ip:port>."));
     }
 
     // Avalanche parameters
     const int64_t stakeUtxoMinConfirmations =
         args.GetIntArg("-avaproofstakeutxoconfirmations",
                        AVALANCHE_DEFAULT_STAKE_UTXO_CONFIRMATIONS);
 
     if (!chainparams.IsTestChain() &&
         stakeUtxoMinConfirmations !=
             AVALANCHE_DEFAULT_STAKE_UTXO_CONFIRMATIONS) {
         return InitError(_("Avalanche stake UTXO minimum confirmations can "
                            "only be set on test chains."));
     }
 
     if (stakeUtxoMinConfirmations <= 0) {
         return InitError(_("Avalanche stake UTXO minimum confirmations must be "
                            "a positive integer."));
     }
 
     if (args.IsArgSet("-avaproofstakeutxodustthreshold")) {
         Amount amount = Amount::zero();
         auto parsed = ParseMoney(
             args.GetArg("-avaproofstakeutxodustthreshold", ""), amount);
         if (!parsed || Amount::zero() == amount) {
             return InitError(AmountErrMsg(
                 "avaproofstakeutxodustthreshold",
                 args.GetArg("-avaproofstakeutxodustthreshold", "")));
         }
 
         if (!chainparams.IsTestChain() &&
             amount != avalanche::PROOF_DUST_THRESHOLD) {
             return InitError(_("Avalanche stake UTXO dust threshold can "
                                "only be set on test chains."));
         }
     }
 
     return true;
 }
 
 static bool LockDataDirectory(bool probeOnly) {
     // Make sure only a single Bitcoin process is using the data directory.
     fs::path datadir = gArgs.GetDataDirNet();
     if (!DirIsWritable(datadir)) {
         return InitError(strprintf(
             _("Cannot write to data directory '%s'; check permissions."),
             fs::PathToString(datadir)));
     }
     if (!LockDirectory(datadir, ".lock", probeOnly)) {
         return InitError(strprintf(_("Cannot obtain a lock on data directory "
                                      "%s. %s is probably already running."),
                                    fs::PathToString(datadir), PACKAGE_NAME));
     }
     return true;
 }
 
 bool AppInitSanityChecks() {
     // Step 4: sanity checks
 
     init::SetGlobals();
 
     // Sanity check
     if (!init::SanityChecks()) {
         return InitError(strprintf(
             _("Initialization sanity check failed. %s is shutting down."),
             PACKAGE_NAME));
     }
 
     // Probe the data directory lock to give an early error message, if possible
     // We cannot hold the data directory lock here, as the forking for daemon()
     // hasn't yet happened, and a fork will cause weird behavior to it.
     return LockDataDirectory(true);
 }
 
 bool AppInitLockDataDirectory() {
     // After daemonization get the data directory lock again and hold on to it
     // until exit. This creates a slight window for a race condition to happen,
     // however this condition is harmless: it will at most make us exit without
     // printing a message to console.
     if (!LockDataDirectory(false)) {
         // Detailed error printed inside LockDataDirectory
         return false;
     }
     return true;
 }
 
 bool AppInitInterfaces(NodeContext &node) {
     node.chain = interfaces::MakeChain(node, Params());
     // Create client interfaces for wallets that are supposed to be loaded
     // according to -wallet and -disablewallet options. This only constructs
     // the interfaces, it doesn't load wallet data. Wallets actually get loaded
     // when load() and start() interface methods are called below.
     g_wallet_init_interface.Construct(node);
     return true;
 }
 
 bool AppInitMain(Config &config, RPCServer &rpcServer,
                  HTTPRPCRequestProcessor &httpRPCRequestProcessor,
                  NodeContext &node,
                  interfaces::BlockAndHeaderTipInfo *tip_info) {
     // Step 4a: application initialization
     const ArgsManager &args = *Assert(node.args);
     const CChainParams &chainparams = config.GetChainParams();
 
     if (!CreatePidFile(args)) {
         // Detailed error printed inside CreatePidFile().
         return false;
     }
     if (!init::StartLogging(args)) {
         // Detailed error printed inside StartLogging().
         return false;
     }
 
     LogPrintf("Using at most %i automatic connections (%i file descriptors "
               "available)\n",
               nMaxConnections, nFD);
 
     // Warn about relative -datadir path.
     if (args.IsArgSet("-datadir") &&
         !fs::PathFromString(args.GetArg("-datadir", "")).is_absolute()) {
         LogPrintf("Warning: relative datadir option '%s' specified, which will "
                   "be interpreted relative to the current working directory "
                   "'%s'. This is fragile, because if bitcoin is started in the "
                   "future from a different location, it will be unable to "
                   "locate the current data files. There could also be data "
                   "loss if bitcoin is started while in a temporary "
                   "directory.\n",
                   args.GetArg("-datadir", ""),
                   fs::PathToString(fs::current_path()));
     }
 
     InitSignatureCache();
     InitScriptExecutionCache();
 
     int script_threads = args.GetIntArg("-par", DEFAULT_SCRIPTCHECK_THREADS);
     if (script_threads <= 0) {
         // -par=0 means autodetect (number of cores - 1 script threads)
         // -par=-n means "leave n cores free" (number of cores - n - 1 script
         // threads)
         script_threads += GetNumCores();
     }
 
     // Subtract 1 because the main thread counts towards the par threads
     script_threads = std::max(script_threads - 1, 0);
 
     // Number of script-checking threads <= MAX_SCRIPTCHECK_THREADS
     script_threads = std::min(script_threads, MAX_SCRIPTCHECK_THREADS);
 
     LogPrintf("Script verification uses %d additional threads\n",
               script_threads);
     if (script_threads >= 1) {
         StartScriptCheckWorkerThreads(script_threads);
     }
 
     assert(!node.scheduler);
     node.scheduler = std::make_unique<CScheduler>();
 
     // Start the lightweight task scheduler thread
     node.scheduler->m_service_thread =
         std::thread(&util::TraceThread, "scheduler",
                     [&] { node.scheduler->serviceQueue(); });
 
     // Gather some entropy once per minute.
     node.scheduler->scheduleEvery(
         [] {
             RandAddPeriodic();
             return true;
         },
         std::chrono::minutes{1});
 
     GetMainSignals().RegisterBackgroundSignalScheduler(*node.scheduler);
 
     /**
      * Register RPC commands regardless of -server setting so they will be
      * available in the GUI RPC console even if external calls are disabled.
      */
     RegisterAllRPCCommands(config, rpcServer, tableRPC);
     for (const auto &client : node.chain_clients) {
         client->registerRpcs();
     }
 #if ENABLE_ZMQ
     RegisterZMQRPCCommands(tableRPC);
 #endif
 
     /**
      * Start the RPC server.  It will be started in "warmup" mode and not
      * process calls yet (but it will verify that the server is there and will
      * be ready later).  Warmup mode will be completed when initialisation is
      * finished.
      */
     if (args.GetBoolArg("-server", false)) {
         uiInterface.InitMessage_connect(SetRPCWarmupStatus);
         if (!AppInitServers(config, httpRPCRequestProcessor, node)) {
             return InitError(
                 _("Unable to start HTTP server. See debug log for details."));
         }
     }
 
     // Step 5: verify wallet database integrity
     for (const auto &client : node.chain_clients) {
         if (!client->verify()) {
             return false;
         }
     }
 
     // Step 6: network initialization
 
     // Note that we absolutely cannot open any actual connections
     // until the very end ("start node") as the UTXO/block state
     // is not yet setup and may end up being set up twice if we
     // need to reindex later.
 
     fListen = args.GetBoolArg("-listen", DEFAULT_LISTEN);
     fDiscover = args.GetBoolArg("-discover", true);
 
     {
         // Initialize addrman
         assert(!node.addrman);
 
         // Read asmap file if configured
         std::vector<bool> asmap;
         if (args.IsArgSet("-asmap")) {
             fs::path asmap_path = fs::PathFromString(args.GetArg("-asmap", ""));
             if (asmap_path.empty()) {
                 asmap_path = fs::PathFromString(DEFAULT_ASMAP_FILENAME);
             }
             if (!asmap_path.is_absolute()) {
                 asmap_path = args.GetDataDirNet() / asmap_path;
             }
             if (!fs::exists(asmap_path)) {
                 InitError(strprintf(_("Could not find asmap file %s"),
                                     fs::quoted(fs::PathToString(asmap_path))));
                 return false;
             }
             asmap = DecodeAsmap(asmap_path);
             if (asmap.size() == 0) {
                 InitError(strprintf(_("Could not parse asmap file %s"),
                                     fs::quoted(fs::PathToString(asmap_path))));
                 return false;
             }
             const uint256 asmap_version = SerializeHash(asmap);
             LogPrintf("Using asmap version %s for IP bucketing\n",
                       asmap_version.ToString());
         } else {
             LogPrintf("Using /16 prefix for IP bucketing\n");
         }
 
         uiInterface.InitMessage(_("Loading P2P addresses...").translated);
         if (const auto error{
                 LoadAddrman(chainparams, asmap, args, node.addrman)}) {
             return InitError(*error);
         }
     }
 
     assert(!node.banman);
     node.banman = std::make_unique<BanMan>(
         args.GetDataDirNet() / "banlist.dat", config.GetChainParams(),
         &uiInterface, args.GetIntArg("-bantime", DEFAULT_MISBEHAVING_BANTIME));
     assert(!node.connman);
     node.connman = std::make_unique<CConnman>(
         config, GetRand(std::numeric_limits<uint64_t>::max()),
         GetRand(std::numeric_limits<uint64_t>::max()), *node.addrman,
         args.GetBoolArg("-networkactive", true));
 
     assert(!node.mempool);
     int check_ratio = std::min<int>(
         std::max<int>(
             args.GetIntArg("-checkmempool",
                            chainparams.DefaultConsistencyChecks() ? 1 : 0),
             0),
         1000000);
     node.mempool = std::make_unique<CTxMemPool>(check_ratio);
 
     assert(!node.chainman);
     node.chainman = std::make_unique<ChainstateManager>();
     ChainstateManager &chainman = *node.chainman;
 
     assert(!node.peerman);
     node.peerman = PeerManager::make(
         chainparams, *node.connman, *node.addrman, node.banman.get(), chainman,
         *node.mempool, args.GetBoolArg("-blocksonly", DEFAULT_BLOCKSONLY));
     RegisterValidationInterface(node.peerman.get());
 
     // sanitize comments per BIP-0014, format user agent and check total size
     std::vector<std::string> uacomments;
     for (const std::string &cmt : args.GetArgs("-uacomment")) {
         if (cmt != SanitizeString(cmt, SAFE_CHARS_UA_COMMENT)) {
             return InitError(strprintf(
                 _("User Agent comment (%s) contains unsafe characters."), cmt));
         }
         uacomments.push_back(cmt);
     }
     const std::string client_name = args.GetArg("-uaclientname", CLIENT_NAME);
     const std::string client_version =
         args.GetArg("-uaclientversion", FormatVersion(CLIENT_VERSION));
     if (client_name != SanitizeString(client_name, SAFE_CHARS_UA_COMMENT)) {
         return InitError(strprintf(
             _("-uaclientname (%s) contains invalid characters."), client_name));
     }
     if (client_version !=
         SanitizeString(client_version, SAFE_CHARS_UA_COMMENT)) {
         return InitError(
             strprintf(_("-uaclientversion (%s) contains invalid characters."),
                       client_version));
     }
     const std::string strSubVersion =
         FormatUserAgent(client_name, client_version, uacomments);
     if (strSubVersion.size() > MAX_SUBVERSION_LENGTH) {
         return InitError(strprintf(
             _("Total length of network version string (%i) exceeds maximum "
               "length (%i). Reduce the number or size of uacomments."),
             strSubVersion.size(), MAX_SUBVERSION_LENGTH));
     }
 
     if (args.IsArgSet("-onlynet")) {
         std::set<enum Network> nets;
         for (const std::string &snet : args.GetArgs("-onlynet")) {
             enum Network net = ParseNetwork(snet);
             if (net == NET_UNROUTABLE) {
                 return InitError(strprintf(
                     _("Unknown network specified in -onlynet: '%s'"), snet));
             }
             nets.insert(net);
         }
         for (int n = 0; n < NET_MAX; n++) {
             enum Network net = (enum Network)n;
             if (!nets.count(net)) {
                 SetReachable(net, false);
             }
         }
     }
 
     // Check for host lookup allowed before parsing any network related
     // parameters
     fNameLookup = args.GetBoolArg("-dns", DEFAULT_NAME_LOOKUP);
 
     bool proxyRandomize =
         args.GetBoolArg("-proxyrandomize", DEFAULT_PROXYRANDOMIZE);
     // -proxy sets a proxy for all outgoing network traffic
     // -noproxy (or -proxy=0) as well as the empty string can be used to not set
     // a proxy, this is the default
     std::string proxyArg = args.GetArg("-proxy", "");
     SetReachable(NET_ONION, false);
     if (proxyArg != "" && proxyArg != "0") {
         CService proxyAddr;
         if (!Lookup(proxyArg, proxyAddr, 9050, fNameLookup)) {
             return InitError(strprintf(
                 _("Invalid -proxy address or hostname: '%s'"), proxyArg));
         }
 
         proxyType addrProxy = proxyType(proxyAddr, proxyRandomize);
         if (!addrProxy.IsValid()) {
             return InitError(strprintf(
                 _("Invalid -proxy address or hostname: '%s'"), proxyArg));
         }
 
         SetProxy(NET_IPV4, addrProxy);
         SetProxy(NET_IPV6, addrProxy);
         SetProxy(NET_ONION, addrProxy);
         SetNameProxy(addrProxy);
         // by default, -proxy sets onion as reachable, unless -noonion later
         SetReachable(NET_ONION, true);
     }
 
     // -onion can be used to set only a proxy for .onion, or override normal
     // proxy for .onion addresses.
     // -noonion (or -onion=0) disables connecting to .onion entirely. An empty
     // string is used to not override the onion proxy (in which case it defaults
     // to -proxy set above, or none)
     std::string onionArg = args.GetArg("-onion", "");
     if (onionArg != "") {
         if (onionArg == "0") {
             // Handle -noonion/-onion=0
             SetReachable(NET_ONION, false);
         } else {
             CService onionProxy;
             if (!Lookup(onionArg, onionProxy, 9050, fNameLookup)) {
                 return InitError(strprintf(
                     _("Invalid -onion address or hostname: '%s'"), onionArg));
             }
             proxyType addrOnion = proxyType(onionProxy, proxyRandomize);
             if (!addrOnion.IsValid()) {
                 return InitError(strprintf(
                     _("Invalid -onion address or hostname: '%s'"), onionArg));
             }
             SetProxy(NET_ONION, addrOnion);
             SetReachable(NET_ONION, true);
         }
     }
 
     for (const std::string &strAddr : args.GetArgs("-externalip")) {
         CService addrLocal;
         if (Lookup(strAddr, addrLocal, GetListenPort(), fNameLookup) &&
             addrLocal.IsValid()) {
             AddLocal(addrLocal, LOCAL_MANUAL);
         } else {
             return InitError(ResolveErrMsg("externalip", strAddr));
         }
     }
 
 #if ENABLE_ZMQ
     g_zmq_notification_interface = CZMQNotificationInterface::Create();
 
     if (g_zmq_notification_interface) {
         RegisterValidationInterface(g_zmq_notification_interface);
     }
 #endif
 
     // Step 6.5 (I guess ?): Initialize Avalanche.
     bilingual_str avalancheError;
     g_avalanche = avalanche::Processor::MakeProcessor(
         args, *node.chain, node.connman.get(), chainman, *node.scheduler,
         avalancheError);
     if (!g_avalanche) {
         InitError(avalancheError);
         return false;
     }
 
     if (isAvalancheEnabled(args) &&
         g_avalanche->isAvalancheServiceAvailable()) {
         nLocalServices = ServiceFlags(nLocalServices | NODE_AVALANCHE);
     }
 
     // Step 7: load block chain
 
     fReindex = args.GetBoolArg("-reindex", false);
     bool fReindexChainState = args.GetBoolArg("-reindex-chainstate", false);
 
     // cache size calculations
     CacheSizes cache_sizes =
         CalculateCacheSizes(args, g_enabled_filter_types.size());
 
     int64_t nMempoolSizeMax =
         args.GetIntArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000;
     LogPrintf("Cache configuration:\n");
     LogPrintf("* Using %.1f MiB for block index database\n",
               cache_sizes.block_tree_db * (1.0 / 1024 / 1024));
     if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
         LogPrintf("* Using %.1f MiB for transaction index database\n",
                   cache_sizes.tx_index * (1.0 / 1024 / 1024));
     }
     for (BlockFilterType filter_type : g_enabled_filter_types) {
         LogPrintf("* Using %.1f MiB for %s block filter index database\n",
                   cache_sizes.filter_index * (1.0 / 1024 / 1024),
                   BlockFilterTypeName(filter_type));
     }
     LogPrintf("* Using %.1f MiB for chain state database\n",
               cache_sizes.coins_db * (1.0 / 1024 / 1024));
     LogPrintf("* Using %.1f MiB for in-memory UTXO set (plus up to %.1f MiB of "
               "unused mempool space)\n",
               cache_sizes.coins * (1.0 / 1024 / 1024),
               nMempoolSizeMax * (1.0 / 1024 / 1024));
 
     bool fLoaded = false;
     while (!fLoaded && !ShutdownRequested()) {
         const bool fReset = fReindex;
         bilingual_str strLoadError;
 
         uiInterface.InitMessage(_("Loading block index...").translated);
 
         const int64_t load_block_index_start_time = GetTimeMillis();
         std::optional<ChainstateLoadingError> rv;
 
         try {
             rv = LoadChainstate(
                 fReset, chainman, Assert(node.mempool.get()), fPruneMode,
                 chainparams.GetConsensus(), fReindexChainState,
                 cache_sizes.block_tree_db, cache_sizes.coins_db,
                 cache_sizes.coins, false, false, ShutdownRequested, []() {
                     uiInterface.ThreadSafeMessageBox(
                         _("Error reading from database, shutting down."), "",
                         CClientUIInterface::MSG_ERROR);
                 });
         } catch (const std::exception &e) {
             LogPrintf("%s\n", e.what());
             rv = ChainstateLoadingError::ERROR_GENERIC_BLOCKDB_OPEN_FAILED;
         }
 
         if (rv.has_value()) {
             switch (rv.value()) {
                 case ChainstateLoadingError::ERROR_UPGRADING_BLOCK_DB:
                     strLoadError = _("Error upgrading block index database");
                     break;
                 case ChainstateLoadingError::ERROR_LOADING_BLOCK_DB:
                     strLoadError = _("Error loading block database");
                     break;
                 case ChainstateLoadingError::ERROR_BAD_GENESIS_BLOCK:
                     // If the loaded chain has a wrong genesis, bail out
                     // immediately (we're likely using a testnet datadir, or
                     // the other way around).
                     return InitError(_("Incorrect or no genesis block found. "
                                        "Wrong datadir for network?"));
                 case ChainstateLoadingError::ERROR_PRUNED_NEEDS_REINDEX:
                     strLoadError =
                         _("You need to rebuild the database using -reindex to "
                           "go back to unpruned mode.  This will redownload the "
                           "entire blockchain");
                     break;
                 case ChainstateLoadingError::ERROR_LOAD_GENESIS_BLOCK_FAILED:
                     strLoadError = _("Error initializing block database");
                     break;
                 case ChainstateLoadingError::ERROR_CHAINSTATE_UPGRADE_FAILED:
                     strLoadError = _("Error upgrading chainstate database");
                     break;
                 case ChainstateLoadingError::ERROR_REPLAYBLOCKS_FAILED:
                     strLoadError =
                         _("Unable to replay blocks. You will need to rebuild "
                           "the database using -reindex-chainstate.");
                     break;
                 case ChainstateLoadingError::ERROR_LOADCHAINTIP_FAILED:
                     strLoadError = _("Error initializing block database");
                     break;
                 case ChainstateLoadingError::ERROR_GENERIC_BLOCKDB_OPEN_FAILED:
                     strLoadError = _("Error opening block database");
                     break;
                 case ChainstateLoadingError::SHUTDOWN_PROBED:
                     break;
             }
         } else {
             std::optional<ChainstateLoadVerifyError> rv2;
             try {
                 uiInterface.InitMessage(_("Verifying blocks…").translated);
 
                 auto check_blocks =
                     args.GetIntArg("-checkblocks", DEFAULT_CHECKBLOCKS);
                 if (chainman.m_blockman.m_have_pruned &&
                     check_blocks > MIN_BLOCKS_TO_KEEP) {
                     LogPrintf("Prune: pruned datadir may not have more than %d "
                               "blocks; only checking available blocks\n",
                               MIN_BLOCKS_TO_KEEP);
                 }
 
                 rv2 = VerifyLoadedChainstate(
                     chainman, fReset, fReindexChainState, config, check_blocks,
                     args.GetIntArg("-checklevel", DEFAULT_CHECKLEVEL),
                     static_cast<int64_t (*)()>(GetTime));
             } catch (const std::exception &e) {
                 LogPrintf("%s\n", e.what());
                 rv2 = ChainstateLoadVerifyError::ERROR_GENERIC_FAILURE;
             }
 
             if (rv2.has_value()) {
                 switch (rv2.value()) {
                     case ChainstateLoadVerifyError::ERROR_BLOCK_FROM_FUTURE:
                         strLoadError = _(
                             "The block database contains a block which appears "
                             "to be from the future. "
                             "This may be due to your computer's date and time "
                             "being set incorrectly. "
                             "Only rebuild the block database if you are sure "
                             "that your computer's date and time are correct");
                         break;
                     case ChainstateLoadVerifyError::ERROR_CORRUPTED_BLOCK_DB:
                         strLoadError = _("Corrupted block database detected");
                         break;
                     case ChainstateLoadVerifyError::ERROR_GENERIC_FAILURE:
                         strLoadError = _("Error opening block database");
                         break;
                 }
             } else {
                 fLoaded = true;
                 LogPrintf(" block index %15dms\n",
                           GetTimeMillis() - load_block_index_start_time);
             }
         }
 
         if (!fLoaded && !ShutdownRequested()) {
             // first suggest a reindex
             if (!fReset) {
                 bool fRet = uiInterface.ThreadSafeQuestion(
                     strLoadError + Untranslated(".\n\n") +
                         _("Do you want to rebuild the block database now?"),
                     strLoadError.original +
                         ".\nPlease restart with -reindex or "
                         "-reindex-chainstate to recover.",
                     "",
                     CClientUIInterface::MSG_ERROR |
                         CClientUIInterface::BTN_ABORT);
                 if (fRet) {
                     fReindex = true;
                     AbortShutdown();
                 } else {
                     LogPrintf("Aborted block database rebuild. Exiting.\n");
                     return false;
                 }
             } else {
                 return InitError(strLoadError);
             }
         }
     }
 
     // As LoadBlockIndex can take several minutes, it's possible the user
     // requested to kill the GUI during the last operation. If so, exit.
     // As the program has not fully started yet, Shutdown() is possibly
     // overkill.
     if (ShutdownRequested()) {
         LogPrintf("Shutdown requested. Exiting.\n");
         return false;
     }
 
     // Encoded addresses using cashaddr instead of base58.
     // We do this by default to avoid confusion with BTC addresses.
     config.SetCashAddrEncoding(args.GetBoolArg("-usecashaddr", true));
 
     // Step 8: load indexers
     if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
         if (const auto error{CheckLegacyTxindex(
                 *Assert(chainman.m_blockman.m_block_tree_db))}) {
             return InitError(*error);
         }
 
         g_txindex =
             std::make_unique<TxIndex>(cache_sizes.tx_index, false, fReindex);
         g_txindex->Start(chainman.ActiveChainstate());
     }
 
     for (const auto &filter_type : g_enabled_filter_types) {
         InitBlockFilterIndex(filter_type, cache_sizes.filter_index, false,
                              fReindex);
         GetBlockFilterIndex(filter_type)->Start(chainman.ActiveChainstate());
     }
 
     if (args.GetBoolArg("-coinstatsindex", DEFAULT_COINSTATSINDEX)) {
         g_coin_stats_index = std::make_unique<CoinStatsIndex>(
             /* cache size */ 0, false, fReindex);
         g_coin_stats_index->Start(chainman.ActiveChainstate());
     }
 
 #if ENABLE_CHRONIK
     if (args.GetBoolArg("-chronik", chronik::DEFAULT_ENABLED)) {
         if (!chronik::Start(config, node)) {
             return false;
         }
     }
 #endif
 
     // Step 9: load wallet
     for (const auto &client : node.chain_clients) {
         if (!client->load()) {
             return false;
         }
     }
 
     // Step 10: data directory maintenance
 
     // if pruning, unset the service bit and perform the initial blockstore
     // prune after any wallet rescanning has taken place.
     if (fPruneMode) {
         LogPrintf("Unsetting NODE_NETWORK on prune mode\n");
         nLocalServices = ServiceFlags(nLocalServices & ~NODE_NETWORK);
         if (!fReindex) {
             LOCK(cs_main);
             for (CChainState *chainstate : chainman.GetAll()) {
                 uiInterface.InitMessage(_("Pruning blockstore...").translated);
                 chainstate->PruneAndFlush();
             }
         }
     }
 
     // Step 11: import blocks
     if (!CheckDiskSpace(args.GetDataDirNet())) {
         InitError(
             strprintf(_("Error: Disk space is low for %s"),
                       fs::quoted(fs::PathToString(args.GetDataDirNet()))));
         return false;
     }
     if (!CheckDiskSpace(args.GetBlocksDirPath())) {
         InitError(
             strprintf(_("Error: Disk space is low for %s"),
                       fs::quoted(fs::PathToString(args.GetBlocksDirPath()))));
         return false;
     }
 
     // Either install a handler to notify us when genesis activates, or set
     // fHaveGenesis directly.
     // No locking, as this happens before any background thread is started.
     boost::signals2::connection block_notify_genesis_wait_connection;
     if (chainman.ActiveTip() == nullptr) {
         block_notify_genesis_wait_connection =
             uiInterface.NotifyBlockTip_connect(
                 std::bind(BlockNotifyGenesisWait, std::placeholders::_2));
     } else {
         fHaveGenesis = true;
     }
 
 #if defined(HAVE_SYSTEM)
     const std::string block_notify = args.GetArg("-blocknotify", "");
     if (!block_notify.empty()) {
         uiInterface.NotifyBlockTip_connect([block_notify](
                                                SynchronizationState sync_state,
                                                const CBlockIndex *pBlockIndex) {
             if (sync_state != SynchronizationState::POST_INIT || !pBlockIndex) {
                 return;
             }
             std::string command = block_notify;
             boost::replace_all(command, "%s",
                                pBlockIndex->GetBlockHash().GetHex());
             std::thread t(runCommand, command);
             // thread runs free
             t.detach();
         });
     }
 #endif
 
     std::vector<fs::path> vImportFiles;
     for (const std::string &strFile : args.GetArgs("-loadblock")) {
         vImportFiles.push_back(fs::PathFromString(strFile));
     }
 
     chainman.m_load_block = std::thread(
         &util::TraceThread, "loadblk", [=, &config, &chainman, &args] {
             ThreadImport(config, chainman, vImportFiles, args);
         });
 
     // Wait for genesis block to be processed
     {
         WAIT_LOCK(g_genesis_wait_mutex, lock);
         // We previously could hang here if StartShutdown() is called prior to
         // ThreadImport getting started, so instead we just wait on a timer to
         // check ShutdownRequested() regularly.
         while (!fHaveGenesis && !ShutdownRequested()) {
             g_genesis_wait_cv.wait_for(lock, std::chrono::milliseconds(500));
         }
         block_notify_genesis_wait_connection.disconnect();
     }
 
     if (ShutdownRequested()) {
         return false;
     }
 
     // Step 12: start node
 
     int chain_active_height;
 
     //// debug print
     {
         LOCK(cs_main);
         LogPrintf("block tree size = %u\n", chainman.BlockIndex().size());
         chain_active_height = chainman.ActiveChain().Height();
         if (tip_info) {
             tip_info->block_height = chain_active_height;
             tip_info->block_time =
                 chainman.ActiveChain().Tip()
                     ? chainman.ActiveChain().Tip()->GetBlockTime()
                     : Params().GenesisBlock().GetBlockTime();
             tip_info->verification_progress = GuessVerificationProgress(
                 Params().TxData(), chainman.ActiveChain().Tip());
         }
         if (tip_info && chainman.m_best_header) {
             tip_info->header_height = chainman.m_best_header->nHeight;
             tip_info->header_time = chainman.m_best_header->GetBlockTime();
         }
     }
     LogPrintf("nBestHeight = %d\n", chain_active_height);
     if (node.peerman) {
         node.peerman->SetBestHeight(chain_active_height);
     }
 
     Discover();
 
     // Map ports with UPnP or NAT-PMP.
     StartMapPort(args.GetBoolArg("-upnp", DEFAULT_UPNP),
                  args.GetBoolArg("-natpmp", DEFAULT_NATPMP));
 
     CConnman::Options connOptions;
     connOptions.nLocalServices = nLocalServices;
     connOptions.nMaxConnections = nMaxConnections;
     connOptions.m_max_avalanche_outbound = std::min<int64_t>(
         g_avalanche && isAvalancheEnabled(args)
             ? args.GetIntArg("-maxavalancheoutbound",
                              DEFAULT_MAX_AVALANCHE_OUTBOUND_CONNECTIONS)
             : 0,
         connOptions.nMaxConnections);
     connOptions.m_max_outbound_full_relay = std::min(
         MAX_OUTBOUND_FULL_RELAY_CONNECTIONS,
         connOptions.nMaxConnections - connOptions.m_max_avalanche_outbound);
     connOptions.m_max_outbound_block_relay = std::min(
         MAX_BLOCK_RELAY_ONLY_CONNECTIONS,
         connOptions.nMaxConnections - connOptions.m_max_avalanche_outbound -
             connOptions.m_max_outbound_full_relay);
     connOptions.nMaxAddnode = MAX_ADDNODE_CONNECTIONS;
     connOptions.nMaxFeeler = MAX_FEELER_CONNECTIONS;
     connOptions.uiInterface = &uiInterface;
     connOptions.m_banman = node.banman.get();
     connOptions.m_msgproc.push_back(node.peerman.get());
     if (g_avalanche) {
         connOptions.m_msgproc.push_back(g_avalanche.get());
     }
     connOptions.nSendBufferMaxSize =
         1000 * args.GetIntArg("-maxsendbuffer", DEFAULT_MAXSENDBUFFER);
     connOptions.nReceiveFloodSize =
         1000 * args.GetIntArg("-maxreceivebuffer", DEFAULT_MAXRECEIVEBUFFER);
     connOptions.m_added_nodes = args.GetArgs("-addnode");
 
     connOptions.nMaxOutboundLimit =
         1024 * 1024 *
         args.GetIntArg("-maxuploadtarget", DEFAULT_MAX_UPLOAD_TARGET);
     connOptions.m_peer_connect_timeout = peer_connect_timeout;
 
     const auto BadPortWarning = [](const char *prefix, uint16_t port) {
         return strprintf(_("%s request to listen on port %u. This port is "
                            "considered \"bad\" and "
                            "thus it is unlikely that any Bitcoin ABC peers "
                            "connect to it. See "
                            "doc/p2p-bad-ports.md for details and a full list."),
                          prefix, port);
     };
 
     for (const std::string &bind_arg : args.GetArgs("-bind")) {
         CService bind_addr;
         const size_t index = bind_arg.rfind('=');
         if (index == std::string::npos) {
             if (Lookup(bind_arg, bind_addr, GetListenPort(), false)) {
                 connOptions.vBinds.push_back(bind_addr);
                 if (IsBadPort(bind_addr.GetPort())) {
                     InitWarning(BadPortWarning("-bind", bind_addr.GetPort()));
                 }
                 continue;
             }
         } else {
             const std::string network_type = bind_arg.substr(index + 1);
             if (network_type == "onion") {
                 const std::string truncated_bind_arg =
                     bind_arg.substr(0, index);
                 if (Lookup(truncated_bind_arg, bind_addr,
                            BaseParams().OnionServiceTargetPort(), false)) {
                     connOptions.onion_binds.push_back(bind_addr);
                     continue;
                 }
             }
         }
         return InitError(ResolveErrMsg("bind", bind_arg));
     }
 
     for (const std::string &strBind : args.GetArgs("-whitebind")) {
         NetWhitebindPermissions whitebind;
         bilingual_str error;
         if (!NetWhitebindPermissions::TryParse(strBind, whitebind, error)) {
             return InitError(error);
         }
         connOptions.vWhiteBinds.push_back(whitebind);
     }
 
     // If the user did not specify -bind= or -whitebind= then we bind
     // on any address - 0.0.0.0 (IPv4) and :: (IPv6).
     connOptions.bind_on_any =
         args.GetArgs("-bind").empty() && args.GetArgs("-whitebind").empty();
 
     // Emit a warning if a bad port is given to -port= but only if -bind and
     // -whitebind are not given, because if they are, then -port= is ignored.
     if (connOptions.bind_on_any && args.IsArgSet("-port")) {
         const uint16_t port_arg = args.GetIntArg("-port", 0);
         if (IsBadPort(port_arg)) {
             InitWarning(BadPortWarning("-port", port_arg));
         }
     }
 
     CService onion_service_target;
     if (!connOptions.onion_binds.empty()) {
         onion_service_target = connOptions.onion_binds.front();
     } else {
         onion_service_target = DefaultOnionServiceTarget();
         connOptions.onion_binds.push_back(onion_service_target);
     }
 
     if (args.GetBoolArg("-listenonion", DEFAULT_LISTEN_ONION)) {
         if (connOptions.onion_binds.size() > 1) {
             InitWarning(strprintf(
                 _("More than one onion bind address is provided. Using %s "
                   "for the automatically created Tor onion service."),
                 onion_service_target.ToStringIPPort()));
         }
         StartTorControl(onion_service_target);
     }
 
     for (const auto &net : args.GetArgs("-whitelist")) {
         NetWhitelistPermissions subnet;
         bilingual_str error;
         if (!NetWhitelistPermissions::TryParse(net, subnet, error)) {
             return InitError(error);
         }
         connOptions.vWhitelistedRange.push_back(subnet);
     }
 
     connOptions.vSeedNodes = args.GetArgs("-seednode");
 
     // Initiate outbound connections unless connect=0
     connOptions.m_use_addrman_outgoing = !args.IsArgSet("-connect");
     if (!connOptions.m_use_addrman_outgoing) {
         const auto connect = args.GetArgs("-connect");
         if (connect.size() != 1 || connect[0] != "0") {
             connOptions.m_specified_outgoing = connect;
         }
     }
 
     const std::string &i2psam_arg = args.GetArg("-i2psam", "");
     if (!i2psam_arg.empty()) {
         CService addr;
         if (!Lookup(i2psam_arg, addr, 7656, fNameLookup) || !addr.IsValid()) {
             return InitError(strprintf(
                 _("Invalid -i2psam address or hostname: '%s'"), i2psam_arg));
         }
         SetReachable(NET_I2P, true);
         SetProxy(NET_I2P, proxyType{addr});
     } else {
         SetReachable(NET_I2P, false);
     }
 
     connOptions.m_i2p_accept_incoming =
         args.GetBoolArg("-i2pacceptincoming", true);
 
     if (!node.connman->Start(*node.scheduler, connOptions)) {
         return false;
     }
 
     // Step 13: finished
 
     // At this point, the RPC is "started", but still in warmup, which means it
     // cannot yet be called. Before we make it callable, we need to make sure
     // that the RPC's view of the best block is valid and consistent with
     // ChainstateManager's ActiveTip.
     //
     // If we do not do this, RPC's view of the best block will be height=0 and
     // hash=0x0. This will lead to erroroneous responses for things like
     // waitforblockheight.
     RPCNotifyBlockChange(chainman.ActiveTip());
     SetRPCWarmupFinished();
 
     uiInterface.InitMessage(_("Done loading").translated);
 
     for (const auto &client : node.chain_clients) {
         client->start(*node.scheduler);
     }
 
     BanMan *banman = node.banman.get();
     node.scheduler->scheduleEvery(
         [banman] {
             banman->DumpBanlist();
             return true;
         },
         DUMP_BANS_INTERVAL);
 
     if (node.peerman) {
         node.peerman->StartScheduledTasks(*node.scheduler);
     }
 
     // Start Avalanche's event loop.
     g_avalanche->startEventLoop(*node.scheduler);
 
 #if HAVE_SYSTEM
     StartupNotify(args);
 #endif
 
     return true;
 }
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index a295ba4c0..f430d3271 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -1,3456 +1,3384 @@
 // Copyright (c) 2010 Satoshi Nakamoto
 // Copyright (c) 2009-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 <rpc/blockchain.h>
 
 #include <blockfilter.h>
 #include <chain.h>
 #include <chainparams.h>
 #include <coins.h>
 #include <config.h>
 #include <consensus/amount.h>
 #include <consensus/params.h>
 #include <consensus/validation.h>
 #include <core_io.h>
 #include <deploymentinfo.h>
 #include <deploymentstatus.h>
 #include <hash.h>
 #include <index/blockfilterindex.h>
 #include <index/coinstatsindex.h>
 #include <net.h>
 #include <net_processing.h>
 #include <node/blockstorage.h>
 #include <node/coinstats.h>
 #include <node/context.h>
 #include <node/utxo_snapshot.h>
 #include <policy/policy.h>
 #include <primitives/transaction.h>
 #include <rpc/server.h>
 #include <rpc/server_util.h>
 #include <rpc/util.h>
 #include <script/descriptor.h>
 #include <streams.h>
 #include <txdb.h>
 #include <txmempool.h>
 #include <undo.h>
 #include <util/strencodings.h>
 #include <util/translation.h>
 #include <validation.h>
 #include <validationinterface.h>
 #include <versionbits.h>
 #include <warnings.h>
 
 #include <condition_variable>
 #include <cstdint>
 #include <memory>
 #include <mutex>
 
 using node::BlockManager;
 using node::CCoinsStats;
 using node::CoinStatsHashType;
 using node::GetUTXOStats;
 using node::NodeContext;
 using node::ReadBlockFromDisk;
 using node::SnapshotMetadata;
 using node::UndoReadFromDisk;
 
 struct CUpdatedBlock {
     BlockHash hash;
     int height;
 };
 
 static Mutex cs_blockchange;
 static std::condition_variable cond_blockchange;
 static CUpdatedBlock latestblock GUARDED_BY(cs_blockchange);
 
 /**
  * Calculate the difficulty for a given block index.
  */
 double GetDifficulty(const CBlockIndex *blockindex) {
     CHECK_NONFATAL(blockindex);
 
     int nShift = (blockindex->nBits >> 24) & 0xff;
     double dDiff = double(0x0000ffff) / double(blockindex->nBits & 0x00ffffff);
 
     while (nShift < 29) {
         dDiff *= 256.0;
         nShift++;
     }
     while (nShift > 29) {
         dDiff /= 256.0;
         nShift--;
     }
 
     return dDiff;
 }
 
 static int ComputeNextBlockAndDepth(const CBlockIndex *tip,
                                     const CBlockIndex *blockindex,
                                     const CBlockIndex *&next) {
     next = tip->GetAncestor(blockindex->nHeight + 1);
     if (next && next->pprev == blockindex) {
         return tip->nHeight - blockindex->nHeight + 1;
     }
     next = nullptr;
     return blockindex == tip ? 1 : -1;
 }
 
 static const CBlockIndex *ParseHashOrHeight(const UniValue &param,
                                             ChainstateManager &chainman) {
     LOCK(::cs_main);
     CChain &active_chain = chainman.ActiveChain();
 
     if (param.isNum()) {
         const int height{param.get_int()};
         if (height < 0) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 strprintf("Target block height %d is negative", height));
         }
         const int current_tip{active_chain.Height()};
         if (height > current_tip) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 strprintf("Target block height %d after current tip %d", height,
                           current_tip));
         }
 
         return active_chain[height];
     } else {
         const BlockHash hash{ParseHashV(param, "hash_or_height")};
         const CBlockIndex *pindex = chainman.m_blockman.LookupBlockIndex(hash);
 
         if (!pindex) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
         }
 
         return pindex;
     }
 }
 UniValue blockheaderToJSON(const CBlockIndex *tip,
                            const CBlockIndex *blockindex) {
     // Serialize passed information without accessing chain state of the active
     // chain!
     // For performance reasons
     AssertLockNotHeld(cs_main);
 
     UniValue result(UniValue::VOBJ);
     result.pushKV("hash", blockindex->GetBlockHash().GetHex());
     const CBlockIndex *pnext;
     int confirmations = ComputeNextBlockAndDepth(tip, blockindex, pnext);
     result.pushKV("confirmations", confirmations);
     result.pushKV("height", blockindex->nHeight);
     result.pushKV("version", blockindex->nVersion);
     result.pushKV("versionHex", strprintf("%08x", blockindex->nVersion));
     result.pushKV("merkleroot", blockindex->hashMerkleRoot.GetHex());
     result.pushKV("time", int64_t(blockindex->nTime));
     result.pushKV("mediantime", int64_t(blockindex->GetMedianTimePast()));
     result.pushKV("nonce", uint64_t(blockindex->nNonce));
     result.pushKV("bits", strprintf("%08x", blockindex->nBits));
     result.pushKV("difficulty", GetDifficulty(blockindex));
     result.pushKV("chainwork", blockindex->nChainWork.GetHex());
     result.pushKV("nTx", uint64_t(blockindex->nTx));
 
     if (blockindex->pprev) {
         result.pushKV("previousblockhash",
                       blockindex->pprev->GetBlockHash().GetHex());
     }
     if (pnext) {
         result.pushKV("nextblockhash", pnext->GetBlockHash().GetHex());
     }
     return result;
 }
 
 UniValue blockToJSON(BlockManager &blockman, const CBlock &block,
                      const CBlockIndex *tip, const CBlockIndex *blockindex,
                      bool txDetails) {
     UniValue result = blockheaderToJSON(tip, blockindex);
 
     result.pushKV("size", (int)::GetSerializeSize(block, PROTOCOL_VERSION));
     UniValue txs(UniValue::VARR);
     if (txDetails) {
         CBlockUndo blockUndo;
         const bool is_not_pruned{
             WITH_LOCK(::cs_main, return !blockman.IsBlockPruned(blockindex))};
         const bool have_undo{is_not_pruned &&
                              UndoReadFromDisk(blockUndo, blockindex)};
         for (size_t i = 0; i < block.vtx.size(); ++i) {
             const CTransactionRef &tx = block.vtx.at(i);
             // coinbase transaction (i == 0) doesn't have undo data
             const CTxUndo *txundo =
                 (have_undo && i) ? &blockUndo.vtxundo.at(i - 1) : nullptr;
             UniValue objTx(UniValue::VOBJ);
             TxToUniv(*tx, BlockHash(), objTx, true, RPCSerializationFlags(),
                      txundo);
             txs.push_back(objTx);
         }
     } else {
         for (const CTransactionRef &tx : block.vtx) {
             txs.push_back(tx->GetId().GetHex());
         }
     }
     result.pushKV("tx", txs);
 
     return result;
 }
 
 static RPCHelpMan getblockcount() {
     return RPCHelpMan{
         "getblockcount",
         "Returns the height of the most-work fully-validated chain.\n"
         "The genesis block has height 0.\n",
         {},
         RPCResult{RPCResult::Type::NUM, "", "The current block count"},
         RPCExamples{HelpExampleCli("getblockcount", "") +
                     HelpExampleRpc("getblockcount", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             ChainstateManager &chainman = EnsureAnyChainman(request.context);
             LOCK(cs_main);
             return chainman.ActiveHeight();
         },
     };
 }
 
 static RPCHelpMan getbestblockhash() {
     return RPCHelpMan{
         "getbestblockhash",
         "Returns the hash of the best (tip) block in the "
         "most-work fully-validated chain.\n",
         {},
         RPCResult{RPCResult::Type::STR_HEX, "", "the block hash, hex-encoded"},
         RPCExamples{HelpExampleCli("getbestblockhash", "") +
                     HelpExampleRpc("getbestblockhash", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             ChainstateManager &chainman = EnsureAnyChainman(request.context);
             LOCK(cs_main);
             return chainman.ActiveTip()->GetBlockHash().GetHex();
         },
     };
 }
 
-RPCHelpMan getfinalizedblockhash() {
-    return RPCHelpMan{
-        "getfinalizedblockhash",
-        "Returns the hash of the currently finalized block\n",
-        {},
-        RPCResult{RPCResult::Type::STR_HEX, "", "the block hash, hex-encoded"},
-        RPCExamples{HelpExampleCli("getfinalizedblockhash", "") +
-                    HelpExampleRpc("getfinalizedblockhash", "")},
-        [&](const RPCHelpMan &self, const Config &config,
-            const JSONRPCRequest &request) -> UniValue {
-            ChainstateManager &chainman = EnsureAnyChainman(request.context);
-            LOCK(cs_main);
-            CChainState &active_chainstate = chainman.ActiveChainstate();
-            const CBlockIndex *blockIndexFinalized =
-                active_chainstate.GetFinalizedBlock();
-            if (blockIndexFinalized) {
-                return blockIndexFinalized->GetBlockHash().GetHex();
-            }
-            return UniValue(UniValue::VSTR);
-        },
-    };
-}
-
 void RPCNotifyBlockChange(const CBlockIndex *pindex) {
     if (pindex) {
         LOCK(cs_blockchange);
         latestblock.hash = pindex->GetBlockHash();
         latestblock.height = pindex->nHeight;
     }
     cond_blockchange.notify_all();
 }
 
 static RPCHelpMan waitfornewblock() {
     return RPCHelpMan{
         "waitfornewblock",
         "Waits for a specific new block and returns useful info about it.\n"
         "\nReturns the current block on timeout or exit.\n",
         {
             {"timeout", RPCArg::Type::NUM, /* default */ "0",
              "Time in milliseconds to wait for a response. 0 indicates no "
              "timeout."},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR_HEX, "hash", "The blockhash"},
                       {RPCResult::Type::NUM, "height", "Block height"},
                   }},
         RPCExamples{HelpExampleCli("waitfornewblock", "1000") +
                     HelpExampleRpc("waitfornewblock", "1000")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             int timeout = 0;
             if (!request.params[0].isNull()) {
                 timeout = request.params[0].get_int();
             }
 
             CUpdatedBlock block;
             {
                 WAIT_LOCK(cs_blockchange, lock);
                 block = latestblock;
                 if (timeout) {
                     cond_blockchange.wait_for(
                         lock, std::chrono::milliseconds(timeout),
                         [&block]() EXCLUSIVE_LOCKS_REQUIRED(cs_blockchange) {
                             return latestblock.height != block.height ||
                                    latestblock.hash != block.hash ||
                                    !IsRPCRunning();
                         });
                 } else {
                     cond_blockchange.wait(
                         lock,
                         [&block]() EXCLUSIVE_LOCKS_REQUIRED(cs_blockchange) {
                             return latestblock.height != block.height ||
                                    latestblock.hash != block.hash ||
                                    !IsRPCRunning();
                         });
                 }
                 block = latestblock;
             }
             UniValue ret(UniValue::VOBJ);
             ret.pushKV("hash", block.hash.GetHex());
             ret.pushKV("height", block.height);
             return ret;
         },
     };
 }
 
 static RPCHelpMan waitforblock() {
     return RPCHelpMan{
         "waitforblock",
         "Waits for a specific new block and returns useful info about it.\n"
         "\nReturns the current block on timeout or exit.\n",
         {
             {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "Block hash to wait for."},
             {"timeout", RPCArg::Type::NUM, /* default */ "0",
              "Time in milliseconds to wait for a response. 0 indicates no "
              "timeout."},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR_HEX, "hash", "The blockhash"},
                       {RPCResult::Type::NUM, "height", "Block height"},
                   }},
         RPCExamples{HelpExampleCli("waitforblock",
                                    "\"0000000000079f8ef3d2c688c244eb7a4570b24c9"
                                    "ed7b4a8c619eb02596f8862\" 1000") +
                     HelpExampleRpc("waitforblock",
                                    "\"0000000000079f8ef3d2c688c244eb7a4570b24c9"
                                    "ed7b4a8c619eb02596f8862\", 1000")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             int timeout = 0;
 
             BlockHash hash(ParseHashV(request.params[0], "blockhash"));
 
             if (!request.params[1].isNull()) {
                 timeout = request.params[1].get_int();
             }
 
             CUpdatedBlock block;
             {
                 WAIT_LOCK(cs_blockchange, lock);
                 if (timeout) {
                     cond_blockchange.wait_for(
                         lock, std::chrono::milliseconds(timeout),
                         [&hash]() EXCLUSIVE_LOCKS_REQUIRED(cs_blockchange) {
                             return latestblock.hash == hash || !IsRPCRunning();
                         });
                 } else {
                     cond_blockchange.wait(
                         lock,
                         [&hash]() EXCLUSIVE_LOCKS_REQUIRED(cs_blockchange) {
                             return latestblock.hash == hash || !IsRPCRunning();
                         });
                 }
                 block = latestblock;
             }
 
             UniValue ret(UniValue::VOBJ);
             ret.pushKV("hash", block.hash.GetHex());
             ret.pushKV("height", block.height);
             return ret;
         },
     };
 }
 
 static RPCHelpMan waitforblockheight() {
     return RPCHelpMan{
         "waitforblockheight",
         "Waits for (at least) block height and returns the height and "
         "hash\nof the current tip.\n"
         "\nReturns the current block on timeout or exit.\n",
         {
             {"height", RPCArg::Type::NUM, RPCArg::Optional::NO,
              "Block height to wait for."},
             {"timeout", RPCArg::Type::NUM, /* default */ "0",
              "Time in milliseconds to wait for a response. 0 indicates no "
              "timeout."},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR_HEX, "hash", "The blockhash"},
                       {RPCResult::Type::NUM, "height", "Block height"},
                   }},
         RPCExamples{HelpExampleCli("waitforblockheight", "100 1000") +
                     HelpExampleRpc("waitforblockheight", "100, 1000")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             int timeout = 0;
 
             int height = request.params[0].get_int();
 
             if (!request.params[1].isNull()) {
                 timeout = request.params[1].get_int();
             }
 
             CUpdatedBlock block;
             {
                 WAIT_LOCK(cs_blockchange, lock);
                 if (timeout) {
                     cond_blockchange.wait_for(
                         lock, std::chrono::milliseconds(timeout),
                         [&height]() EXCLUSIVE_LOCKS_REQUIRED(cs_blockchange) {
                             return latestblock.height >= height ||
                                    !IsRPCRunning();
                         });
                 } else {
                     cond_blockchange.wait(
                         lock,
                         [&height]() EXCLUSIVE_LOCKS_REQUIRED(cs_blockchange) {
                             return latestblock.height >= height ||
                                    !IsRPCRunning();
                         });
                 }
                 block = latestblock;
             }
             UniValue ret(UniValue::VOBJ);
             ret.pushKV("hash", block.hash.GetHex());
             ret.pushKV("height", block.height);
             return ret;
         },
     };
 }
 
 static RPCHelpMan syncwithvalidationinterfacequeue() {
     return RPCHelpMan{
         "syncwithvalidationinterfacequeue",
         "Waits for the validation interface queue to catch up on everything "
         "that was there when we entered this function.\n",
         {},
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("syncwithvalidationinterfacequeue", "") +
                     HelpExampleRpc("syncwithvalidationinterfacequeue", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             SyncWithValidationInterfaceQueue();
             return NullUniValue;
         },
     };
 }
 
 static RPCHelpMan getdifficulty() {
     return RPCHelpMan{
         "getdifficulty",
         "Returns the proof-of-work difficulty as a multiple of the minimum "
         "difficulty.\n",
         {},
         RPCResult{RPCResult::Type::NUM, "",
                   "the proof-of-work difficulty as a multiple of the minimum "
                   "difficulty."},
         RPCExamples{HelpExampleCli("getdifficulty", "") +
                     HelpExampleRpc("getdifficulty", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             ChainstateManager &chainman = EnsureAnyChainman(request.context);
             LOCK(cs_main);
             return GetDifficulty(chainman.ActiveTip());
         },
     };
 }
 
 static std::vector<RPCResult> MempoolEntryDescription() {
     const auto &ticker = Currency::get().ticker;
     return {
         RPCResult{RPCResult::Type::NUM, "size", "transaction size."},
         RPCResult{RPCResult::Type::STR_AMOUNT, "fee",
                   "transaction fee in " + ticker + " (DEPRECATED)"},
         RPCResult{RPCResult::Type::STR_AMOUNT, "modifiedfee",
                   "transaction fee with fee deltas used for mining priority "
                   "(DEPRECATED)"},
         RPCResult{RPCResult::Type::NUM_TIME, "time",
                   "local time transaction entered pool in seconds since 1 Jan "
                   "1970 GMT"},
         RPCResult{RPCResult::Type::NUM, "height",
                   "block height when transaction entered pool"},
         RPCResult{RPCResult::Type::NUM, "descendantcount",
                   "number of in-mempool descendant transactions (including "
                   "this one)"},
         RPCResult{RPCResult::Type::NUM, "descendantsize",
                   "transaction size of in-mempool descendants "
                   "(including this one)"},
         RPCResult{RPCResult::Type::STR_AMOUNT, "descendantfees",
                   "modified fees (see above) of in-mempool descendants "
                   "(including this one) (DEPRECATED)"},
         RPCResult{
             RPCResult::Type::NUM, "ancestorcount",
             "number of in-mempool ancestor transactions (including this one)"},
         RPCResult{
             RPCResult::Type::NUM, "ancestorsize",
             "transaction size of in-mempool ancestors (including this one)"},
         RPCResult{RPCResult::Type::STR_AMOUNT, "ancestorfees",
                   "modified fees (see above) of in-mempool ancestors "
                   "(including this one) (DEPRECATED)"},
         RPCResult{RPCResult::Type::OBJ,
                   "fees",
                   "",
                   {
                       RPCResult{RPCResult::Type::STR_AMOUNT, "base",
                                 "transaction fee in " + ticker},
                       RPCResult{RPCResult::Type::STR_AMOUNT, "modified",
                                 "transaction fee with fee deltas used for "
                                 "mining priority in " +
                                     ticker},
                       RPCResult{RPCResult::Type::STR_AMOUNT, "ancestor",
                                 "modified fees (see above) of in-mempool "
                                 "ancestors (including this one) in " +
                                     ticker},
                       RPCResult{RPCResult::Type::STR_AMOUNT, "descendant",
                                 "modified fees (see above) of in-mempool "
                                 "descendants (including this one) in " +
                                     ticker},
                   }},
         RPCResult{
             RPCResult::Type::ARR,
             "depends",
             "unconfirmed transactions used as inputs for this transaction",
             {RPCResult{RPCResult::Type::STR_HEX, "transactionid",
                        "parent transaction id"}}},
         RPCResult{
             RPCResult::Type::ARR,
             "spentby",
             "unconfirmed transactions spending outputs from this transaction",
             {RPCResult{RPCResult::Type::STR_HEX, "transactionid",
                        "child transaction id"}}},
         RPCResult{RPCResult::Type::BOOL, "unbroadcast",
                   "Whether this transaction is currently unbroadcast (initial "
                   "broadcast not yet acknowledged by any peers)"},
     };
 }
 
 static void entryToJSON(const CTxMemPool &pool, UniValue &info,
                         const CTxMemPoolEntry &e)
     EXCLUSIVE_LOCKS_REQUIRED(pool.cs) {
     AssertLockHeld(pool.cs);
 
     UniValue fees(UniValue::VOBJ);
     fees.pushKV("base", e.GetFee());
     fees.pushKV("modified", e.GetModifiedFee());
     fees.pushKV("ancestor", e.GetModFeesWithAncestors());
     fees.pushKV("descendant", e.GetModFeesWithDescendants());
     info.pushKV("fees", fees);
 
     info.pushKV("size", (int)e.GetTxSize());
     info.pushKV("fee", e.GetFee());
     info.pushKV("modifiedfee", e.GetModifiedFee());
     info.pushKV("time", count_seconds(e.GetTime()));
     info.pushKV("height", (int)e.GetHeight());
     info.pushKV("descendantcount", e.GetCountWithDescendants());
     info.pushKV("descendantsize", e.GetSizeWithDescendants());
     info.pushKV("descendantfees", e.GetModFeesWithDescendants() / SATOSHI);
     info.pushKV("ancestorcount", e.GetCountWithAncestors());
     info.pushKV("ancestorsize", e.GetSizeWithAncestors());
     info.pushKV("ancestorfees", e.GetModFeesWithAncestors() / SATOSHI);
     const CTransaction &tx = e.GetTx();
     std::set<std::string> setDepends;
     for (const CTxIn &txin : tx.vin) {
         if (pool.exists(txin.prevout.GetTxId())) {
             setDepends.insert(txin.prevout.GetTxId().ToString());
         }
     }
 
     UniValue depends(UniValue::VARR);
     for (const std::string &dep : setDepends) {
         depends.push_back(dep);
     }
 
     info.pushKV("depends", depends);
 
     UniValue spent(UniValue::VARR);
     const CTxMemPool::txiter &it = pool.mapTx.find(tx.GetId());
     const CTxMemPoolEntry::Children &children = it->GetMemPoolChildrenConst();
     for (const CTxMemPoolEntry &child : children) {
         spent.push_back(child.GetTx().GetId().ToString());
     }
 
     info.pushKV("spentby", spent);
     info.pushKV("unbroadcast", pool.IsUnbroadcastTx(tx.GetId()));
 }
 
 UniValue MempoolToJSON(const CTxMemPool &pool, bool verbose,
                        bool include_mempool_sequence) {
     if (verbose) {
         if (include_mempool_sequence) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 "Verbose results cannot contain mempool sequence values.");
         }
         LOCK(pool.cs);
         UniValue o(UniValue::VOBJ);
         for (const CTxMemPoolEntry &e : pool.mapTx) {
             const uint256 &txid = e.GetTx().GetId();
             UniValue info(UniValue::VOBJ);
             entryToJSON(pool, info, e);
             // Mempool has unique entries so there is no advantage in using
             // UniValue::pushKV, which checks if the key already exists in O(N).
             // UniValue::__pushKV is used instead which currently is O(1).
             o.__pushKV(txid.ToString(), info);
         }
         return o;
     } else {
         uint64_t mempool_sequence;
         std::vector<uint256> vtxids;
         {
             LOCK(pool.cs);
             pool.queryHashes(vtxids);
             mempool_sequence = pool.GetSequence();
         }
         UniValue a(UniValue::VARR);
         for (const uint256 &txid : vtxids) {
             a.push_back(txid.ToString());
         }
 
         if (!include_mempool_sequence) {
             return a;
         } else {
             UniValue o(UniValue::VOBJ);
             o.pushKV("txids", a);
             o.pushKV("mempool_sequence", mempool_sequence);
             return o;
         }
     }
 }
 
 static RPCHelpMan getrawmempool() {
     return RPCHelpMan{
         "getrawmempool",
         "Returns all transaction ids in memory pool as a json array of "
         "string transaction ids.\n"
         "\nHint: use getmempoolentry to fetch a specific transaction from the "
         "mempool.\n",
         {
             {"verbose", RPCArg::Type::BOOL, /* default */ "false",
              "True for a json object, false for array of transaction ids"},
             {"mempool_sequence", RPCArg::Type::BOOL, /* default */ "false",
              "If verbose=false, returns a json object with transaction list "
              "and mempool sequence number attached."},
         },
         {
             RPCResult{"for verbose = false",
                       RPCResult::Type::ARR,
                       "",
                       "",
                       {
                           {RPCResult::Type::STR_HEX, "", "The transaction id"},
                       }},
             RPCResult{"for verbose = true",
                       RPCResult::Type::OBJ_DYN,
                       "",
                       "",
                       {
                           {RPCResult::Type::OBJ, "transactionid", "",
                            MempoolEntryDescription()},
                       }},
             RPCResult{
                 "for verbose = false and mempool_sequence = true",
                 RPCResult::Type::OBJ,
                 "",
                 "",
                 {
                     {RPCResult::Type::ARR,
                      "txids",
                      "",
                      {
                          {RPCResult::Type::STR_HEX, "", "The transaction id"},
                      }},
                     {RPCResult::Type::NUM, "mempool_sequence",
                      "The mempool sequence value."},
                 }},
         },
         RPCExamples{HelpExampleCli("getrawmempool", "true") +
                     HelpExampleRpc("getrawmempool", "true")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             bool fVerbose = false;
             if (!request.params[0].isNull()) {
                 fVerbose = request.params[0].get_bool();
             }
 
             bool include_mempool_sequence = false;
             if (!request.params[1].isNull()) {
                 include_mempool_sequence = request.params[1].get_bool();
             }
 
             return MempoolToJSON(EnsureAnyMemPool(request.context), fVerbose,
                                  include_mempool_sequence);
         },
     };
 }
 
 static RPCHelpMan getmempoolancestors() {
     return RPCHelpMan{
         "getmempoolancestors",
         "If txid is in the mempool, returns all in-mempool ancestors.\n",
         {
             {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The transaction id (must be in mempool)"},
             {"verbose", RPCArg::Type::BOOL, /* default */ "false",
              "True for a json object, false for array of transaction ids"},
         },
         {
             RPCResult{
                 "for verbose = false",
                 RPCResult::Type::ARR,
                 "",
                 "",
                 {{RPCResult::Type::STR_HEX, "",
                   "The transaction id of an in-mempool ancestor transaction"}}},
             RPCResult{"for verbose = true",
                       RPCResult::Type::OBJ_DYN,
                       "",
                       "",
                       {
                           {RPCResult::Type::OBJ, "transactionid", "",
                            MempoolEntryDescription()},
                       }},
         },
         RPCExamples{HelpExampleCli("getmempoolancestors", "\"mytxid\"") +
                     HelpExampleRpc("getmempoolancestors", "\"mytxid\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             bool fVerbose = false;
             if (!request.params[1].isNull()) {
                 fVerbose = request.params[1].get_bool();
             }
 
             TxId txid(ParseHashV(request.params[0], "parameter 1"));
 
             const CTxMemPool &mempool = EnsureAnyMemPool(request.context);
             LOCK(mempool.cs);
 
             CTxMemPool::txiter it = mempool.mapTx.find(txid);
             if (it == mempool.mapTx.end()) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                    "Transaction not in mempool");
             }
 
             CTxMemPool::setEntries setAncestors;
             uint64_t noLimit = std::numeric_limits<uint64_t>::max();
             std::string dummy;
             mempool.CalculateMemPoolAncestors(*it, setAncestors, noLimit,
                                               noLimit, noLimit, noLimit, dummy,
                                               false);
 
             if (!fVerbose) {
                 UniValue o(UniValue::VARR);
                 for (CTxMemPool::txiter ancestorIt : setAncestors) {
                     o.push_back(ancestorIt->GetTx().GetId().ToString());
                 }
                 return o;
             } else {
                 UniValue o(UniValue::VOBJ);
                 for (CTxMemPool::txiter ancestorIt : setAncestors) {
                     const CTxMemPoolEntry &e = *ancestorIt;
                     const TxId &_txid = e.GetTx().GetId();
                     UniValue info(UniValue::VOBJ);
                     entryToJSON(mempool, info, e);
                     o.pushKV(_txid.ToString(), info);
                 }
                 return o;
             }
         },
     };
 }
 
 static RPCHelpMan getmempooldescendants() {
     return RPCHelpMan{
         "getmempooldescendants",
         "If txid is in the mempool, returns all in-mempool descendants.\n",
         {
             {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The transaction id (must be in mempool)"},
             {"verbose", RPCArg::Type::BOOL, /* default */ "false",
              "True for a json object, false for array of transaction ids"},
         },
         {
             RPCResult{"for verbose = false",
                       RPCResult::Type::ARR,
                       "",
                       "",
                       {{RPCResult::Type::STR_HEX, "",
                         "The transaction id of an in-mempool descendant "
                         "transaction"}}},
             RPCResult{"for verbose = true",
                       RPCResult::Type::OBJ_DYN,
                       "",
                       "",
                       {
                           {RPCResult::Type::OBJ, "transactionid", "",
                            MempoolEntryDescription()},
                       }},
         },
         RPCExamples{HelpExampleCli("getmempooldescendants", "\"mytxid\"") +
                     HelpExampleRpc("getmempooldescendants", "\"mytxid\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             bool fVerbose = false;
             if (!request.params[1].isNull()) {
                 fVerbose = request.params[1].get_bool();
             }
 
             TxId txid(ParseHashV(request.params[0], "parameter 1"));
 
             const CTxMemPool &mempool = EnsureAnyMemPool(request.context);
             LOCK(mempool.cs);
 
             CTxMemPool::txiter it = mempool.mapTx.find(txid);
             if (it == mempool.mapTx.end()) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                    "Transaction not in mempool");
             }
 
             CTxMemPool::setEntries setDescendants;
             mempool.CalculateDescendants(it, setDescendants);
             // CTxMemPool::CalculateDescendants will include the given tx
             setDescendants.erase(it);
 
             if (!fVerbose) {
                 UniValue o(UniValue::VARR);
                 for (CTxMemPool::txiter descendantIt : setDescendants) {
                     o.push_back(descendantIt->GetTx().GetId().ToString());
                 }
 
                 return o;
             } else {
                 UniValue o(UniValue::VOBJ);
                 for (CTxMemPool::txiter descendantIt : setDescendants) {
                     const CTxMemPoolEntry &e = *descendantIt;
                     const TxId &_txid = e.GetTx().GetId();
                     UniValue info(UniValue::VOBJ);
                     entryToJSON(mempool, info, e);
                     o.pushKV(_txid.ToString(), info);
                 }
                 return o;
             }
         },
     };
 }
 
 static RPCHelpMan getmempoolentry() {
     return RPCHelpMan{
         "getmempoolentry",
         "Returns mempool data for given transaction\n",
         {
             {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The transaction id (must be in mempool)"},
         },
         RPCResult{RPCResult::Type::OBJ, "", "", MempoolEntryDescription()},
         RPCExamples{HelpExampleCli("getmempoolentry", "\"mytxid\"") +
                     HelpExampleRpc("getmempoolentry", "\"mytxid\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             TxId txid(ParseHashV(request.params[0], "parameter 1"));
 
             const CTxMemPool &mempool = EnsureAnyMemPool(request.context);
             LOCK(mempool.cs);
 
             CTxMemPool::txiter it = mempool.mapTx.find(txid);
             if (it == mempool.mapTx.end()) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                    "Transaction not in mempool");
             }
 
             const CTxMemPoolEntry &e = *it;
             UniValue info(UniValue::VOBJ);
             entryToJSON(mempool, info, e);
             return info;
         },
     };
 }
 
 static RPCHelpMan getblockfrompeer() {
     return RPCHelpMan{
         "getblockfrompeer",
         "\nAttempt to fetch block from a given peer.\n"
         "\nWe must have the header for this block, e.g. using submitheader.\n"
         "Subsequent calls for the same block and a new peer will cause the "
         "response from the previous peer to be ignored.\n"
         "\nReturns an empty JSON object if the request was successfully "
         "scheduled.",
         {
             {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The block hash to try to fetch"},
             {"peer_id", RPCArg::Type::NUM, RPCArg::Optional::NO,
              "The peer to fetch it from (see getpeerinfo for peer IDs)"},
         },
         RPCResult{RPCResult::Type::OBJ_EMPTY, "", /*optional=*/false, "", {}},
         RPCExamples{HelpExampleCli("getblockfrompeer",
                                    "\"00000000c937983704a73af28acdec37b049d214a"
                                    "dbda81d7e2a3dd146f6ed09\" 0") +
                     HelpExampleRpc("getblockfrompeer",
                                    "\"00000000c937983704a73af28acdec37b049d214a"
                                    "dbda81d7e2a3dd146f6ed09\" 0")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             const NodeContext &node = EnsureAnyNodeContext(request.context);
             ChainstateManager &chainman = EnsureChainman(node);
             PeerManager &peerman = EnsurePeerman(node);
 
             const BlockHash block_hash{
                 ParseHashV(request.params[0], "blockhash")};
             const NodeId peer_id{request.params[1].get_int64()};
 
             const CBlockIndex *const index = WITH_LOCK(
                 cs_main,
                 return chainman.m_blockman.LookupBlockIndex(block_hash););
 
             if (!index) {
                 throw JSONRPCError(RPC_MISC_ERROR, "Block header missing");
             }
 
             if (WITH_LOCK(::cs_main, return index->nStatus.hasData())) {
                 throw JSONRPCError(RPC_MISC_ERROR, "Block already downloaded");
             }
 
             if (const auto err{peerman.FetchBlock(config, peer_id, *index)}) {
                 throw JSONRPCError(RPC_MISC_ERROR, err.value());
             }
             return UniValue::VOBJ;
         },
     };
 }
 
 static RPCHelpMan getblockhash() {
     return RPCHelpMan{
         "getblockhash",
         "Returns hash of block in best-block-chain at height provided.\n",
         {
             {"height", RPCArg::Type::NUM, RPCArg::Optional::NO,
              "The height index"},
         },
         RPCResult{RPCResult::Type::STR_HEX, "", "The block hash"},
         RPCExamples{HelpExampleCli("getblockhash", "1000") +
                     HelpExampleRpc("getblockhash", "1000")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             ChainstateManager &chainman = EnsureAnyChainman(request.context);
             LOCK(cs_main);
             const CChain &active_chain = chainman.ActiveChain();
 
             int nHeight = request.params[0].get_int();
             if (nHeight < 0 || nHeight > active_chain.Height()) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    "Block height out of range");
             }
 
             const CBlockIndex *pblockindex = active_chain[nHeight];
             return pblockindex->GetBlockHash().GetHex();
         },
     };
 }
 
 static RPCHelpMan getblockheader() {
     return RPCHelpMan{
         "getblockheader",
         "If verbose is false, returns a string that is serialized, hex-encoded "
         "data for blockheader 'hash'.\n"
         "If verbose is true, returns an Object with information about "
         "blockheader <hash>.\n",
         {
             {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The block hash"},
             {"verbose", RPCArg::Type::BOOL, /* default */ "true",
              "true for a json object, false for the hex-encoded data"},
         },
         {
             RPCResult{
                 "for verbose = true",
                 RPCResult::Type::OBJ,
                 "",
                 "",
                 {
                     {RPCResult::Type::STR_HEX, "hash",
                      "the block hash (same as provided)"},
                     {RPCResult::Type::NUM, "confirmations",
                      "The number of confirmations, or -1 if the block is not "
                      "on the main chain"},
                     {RPCResult::Type::NUM, "height",
                      "The block height or index"},
                     {RPCResult::Type::NUM, "version", "The block version"},
                     {RPCResult::Type::STR_HEX, "versionHex",
                      "The block version formatted in hexadecimal"},
                     {RPCResult::Type::STR_HEX, "merkleroot", "The merkle root"},
                     {RPCResult::Type::NUM_TIME, "time",
                      "The block time expressed in " + UNIX_EPOCH_TIME},
                     {RPCResult::Type::NUM_TIME, "mediantime",
                      "The median block time expressed in " + UNIX_EPOCH_TIME},
                     {RPCResult::Type::NUM, "nonce", "The nonce"},
                     {RPCResult::Type::STR_HEX, "bits", "The bits"},
                     {RPCResult::Type::NUM, "difficulty", "The difficulty"},
                     {RPCResult::Type::STR_HEX, "chainwork",
                      "Expected number of hashes required to produce the "
                      "current chain"},
                     {RPCResult::Type::NUM, "nTx",
                      "The number of transactions in the block"},
                     {RPCResult::Type::STR_HEX, "previousblockhash",
                      /* optional */ true,
                      "The hash of the previous block (if available)"},
                     {RPCResult::Type::STR_HEX, "nextblockhash",
                      /* optional */ true,
                      "The hash of the next block (if available)"},
                 }},
             RPCResult{"for verbose=false", RPCResult::Type::STR_HEX, "",
                       "A string that is serialized, hex-encoded data for block "
                       "'hash'"},
         },
         RPCExamples{HelpExampleCli("getblockheader",
                                    "\"00000000c937983704a73af28acdec37b049d214a"
                                    "dbda81d7e2a3dd146f6ed09\"") +
                     HelpExampleRpc("getblockheader",
                                    "\"00000000c937983704a73af28acdec37b049d214a"
                                    "dbda81d7e2a3dd146f6ed09\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             BlockHash hash(ParseHashV(request.params[0], "hash"));
 
             bool fVerbose = true;
             if (!request.params[1].isNull()) {
                 fVerbose = request.params[1].get_bool();
             }
 
             const CBlockIndex *pblockindex;
             const CBlockIndex *tip;
             {
                 ChainstateManager &chainman =
                     EnsureAnyChainman(request.context);
                 LOCK(cs_main);
                 pblockindex = chainman.m_blockman.LookupBlockIndex(hash);
                 tip = chainman.ActiveTip();
             }
 
             if (!pblockindex) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                    "Block not found");
             }
 
             if (!fVerbose) {
                 CDataStream ssBlock(SER_NETWORK, PROTOCOL_VERSION);
                 ssBlock << pblockindex->GetBlockHeader();
                 std::string strHex = HexStr(ssBlock);
                 return strHex;
             }
 
             return blockheaderToJSON(tip, pblockindex);
         },
     };
 }
 
 static CBlock GetBlockChecked(const Config &config, BlockManager &blockman,
                               const CBlockIndex *pblockindex) {
     CBlock block;
     {
         LOCK(cs_main);
         if (blockman.IsBlockPruned(pblockindex)) {
             throw JSONRPCError(RPC_MISC_ERROR,
                                "Block not available (pruned data)");
         }
     }
 
     if (!ReadBlockFromDisk(block, pblockindex,
                            config.GetChainParams().GetConsensus())) {
         // Block not found on disk. This could be because we have the block
         // header in our index but not yet have the block or did not accept the
         // block. Or if the block was pruned right after we released the lock
         // above.
         throw JSONRPCError(RPC_MISC_ERROR, "Block not found on disk");
     }
 
     return block;
 }
 
 static CBlockUndo GetUndoChecked(BlockManager &blockman,
                                  const CBlockIndex *pblockindex) {
     CBlockUndo blockUndo;
 
     {
         LOCK(cs_main);
         if (blockman.IsBlockPruned(pblockindex)) {
             throw JSONRPCError(RPC_MISC_ERROR,
                                "Undo data not available (pruned data)");
         }
     }
 
     if (!UndoReadFromDisk(blockUndo, pblockindex)) {
         throw JSONRPCError(RPC_MISC_ERROR, "Can't read undo data from disk");
     }
 
     return blockUndo;
 }
 
 static RPCHelpMan getblock() {
     return RPCHelpMan{
         "getblock",
         "If verbosity is 0 or false, returns a string that is serialized, "
         "hex-encoded data for block 'hash'.\n"
         "If verbosity is 1 or true, returns an Object with information about "
         "block <hash>.\n"
         "If verbosity is 2, returns an Object with information about block "
         "<hash> and information about each transaction.\n",
         {
             {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The block hash"},
             {"verbosity|verbose", RPCArg::Type::NUM, /* default */ "1",
              "0 for hex-encoded data, 1 for a json object, and 2 for json "
              "object with transaction data"},
         },
         {
             RPCResult{"for verbosity = 0", RPCResult::Type::STR_HEX, "",
                       "A string that is serialized, hex-encoded data for block "
                       "'hash'"},
             RPCResult{
                 "for verbosity = 1",
                 RPCResult::Type::OBJ,
                 "",
                 "",
                 {
                     {RPCResult::Type::STR_HEX, "hash",
                      "the block hash (same as provided)"},
                     {RPCResult::Type::NUM, "confirmations",
                      "The number of confirmations, or -1 if the block is not "
                      "on the main chain"},
                     {RPCResult::Type::NUM, "size", "The block size"},
                     {RPCResult::Type::NUM, "height",
                      "The block height or index"},
                     {RPCResult::Type::NUM, "version", "The block version"},
                     {RPCResult::Type::STR_HEX, "versionHex",
                      "The block version formatted in hexadecimal"},
                     {RPCResult::Type::STR_HEX, "merkleroot", "The merkle root"},
                     {RPCResult::Type::ARR,
                      "tx",
                      "The transaction ids",
                      {{RPCResult::Type::STR_HEX, "", "The transaction id"}}},
                     {RPCResult::Type::NUM_TIME, "time",
                      "The block time expressed in " + UNIX_EPOCH_TIME},
                     {RPCResult::Type::NUM_TIME, "mediantime",
                      "The median block time expressed in " + UNIX_EPOCH_TIME},
                     {RPCResult::Type::NUM, "nonce", "The nonce"},
                     {RPCResult::Type::STR_HEX, "bits", "The bits"},
                     {RPCResult::Type::NUM, "difficulty", "The difficulty"},
                     {RPCResult::Type::STR_HEX, "chainwork",
                      "Expected number of hashes required to produce the chain "
                      "up to this block (in hex)"},
                     {RPCResult::Type::NUM, "nTx",
                      "The number of transactions in the block"},
                     {RPCResult::Type::STR_HEX, "previousblockhash",
                      /* optional */ true,
                      "The hash of the previous block (if available)"},
                     {RPCResult::Type::STR_HEX, "nextblockhash",
                      /* optional */ true,
                      "The hash of the next block (if available)"},
                 }},
             RPCResult{"for verbosity = 2",
                       RPCResult::Type::OBJ,
                       "",
                       "",
                       {
                           {RPCResult::Type::ELISION, "",
                            "Same output as verbosity = 1"},
                           {RPCResult::Type::ARR,
                            "tx",
                            "",
                            {
                                {RPCResult::Type::OBJ,
                                 "",
                                 "",
                                 {
                                     {RPCResult::Type::ELISION, "",
                                      "The transactions in the format of the "
                                      "getrawtransaction RPC. Different from "
                                      "verbosity = 1 \"tx\" result"},
                                     {RPCResult::Type::STR_AMOUNT, "fee",
                                      "The transaction fee in " +
                                          Currency::get().ticker +
                                          ", omitted if block undo data is not "
                                          "available"},
                                 }},
                            }},
                       }},
         },
         RPCExamples{
             HelpExampleCli("getblock", "\"00000000c937983704a73af28acdec37b049d"
                                        "214adbda81d7e2a3dd146f6ed09\"") +
             HelpExampleRpc("getblock", "\"00000000c937983704a73af28acdec37b049d"
                                        "214adbda81d7e2a3dd146f6ed09\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             BlockHash hash(ParseHashV(request.params[0], "blockhash"));
 
             int verbosity = 1;
             if (!request.params[1].isNull()) {
                 if (request.params[1].isNum()) {
                     verbosity = request.params[1].get_int();
                 } else {
                     verbosity = request.params[1].get_bool() ? 1 : 0;
                 }
             }
 
             const CBlockIndex *pblockindex;
             const CBlockIndex *tip;
             ChainstateManager &chainman = EnsureAnyChainman(request.context);
             {
                 LOCK(cs_main);
                 pblockindex = chainman.m_blockman.LookupBlockIndex(hash);
                 tip = chainman.ActiveTip();
 
                 if (!pblockindex) {
                     throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                        "Block not found");
                 }
             }
 
             const CBlock block =
                 GetBlockChecked(config, chainman.m_blockman, pblockindex);
 
             if (verbosity <= 0) {
                 CDataStream ssBlock(SER_NETWORK,
                                     PROTOCOL_VERSION | RPCSerializationFlags());
                 ssBlock << block;
                 std::string strHex = HexStr(ssBlock);
                 return strHex;
             }
 
             return blockToJSON(chainman.m_blockman, block, tip, pblockindex,
                                verbosity >= 2);
         },
     };
 }
 
 static RPCHelpMan pruneblockchain() {
     return RPCHelpMan{
         "pruneblockchain",
         "",
         {
             {"height", RPCArg::Type::NUM, RPCArg::Optional::NO,
              "The block height to prune up to. May be set to a discrete "
              "height, or to a " +
                  UNIX_EPOCH_TIME +
                  "\n"
                  "                  to prune blocks whose block time is at "
                  "least 2 hours older than the provided timestamp."},
         },
         RPCResult{RPCResult::Type::NUM, "", "Height of the last block pruned"},
         RPCExamples{HelpExampleCli("pruneblockchain", "1000") +
                     HelpExampleRpc("pruneblockchain", "1000")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             if (!node::fPruneMode) {
                 throw JSONRPCError(
                     RPC_MISC_ERROR,
                     "Cannot prune blocks because node is not in prune mode.");
             }
 
             ChainstateManager &chainman = EnsureAnyChainman(request.context);
             LOCK(cs_main);
             CChainState &active_chainstate = chainman.ActiveChainstate();
             CChain &active_chain = active_chainstate.m_chain;
 
             int heightParam = request.params[0].get_int();
             if (heightParam < 0) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    "Negative block height.");
             }
 
             // Height value more than a billion is too high to be a block
             // height, and too low to be a block time (corresponds to timestamp
             // from Sep 2001).
             if (heightParam > 1000000000) {
                 // Add a 2 hour buffer to include blocks which might have had
                 // old timestamps
                 const CBlockIndex *pindex = active_chain.FindEarliestAtLeast(
                     heightParam - TIMESTAMP_WINDOW, 0);
                 if (!pindex) {
                     throw JSONRPCError(RPC_INVALID_PARAMETER,
                                        "Could not find block with at least the "
                                        "specified timestamp.");
                 }
                 heightParam = pindex->nHeight;
             }
 
             unsigned int height = (unsigned int)heightParam;
             unsigned int chainHeight = (unsigned int)active_chain.Height();
             if (chainHeight < config.GetChainParams().PruneAfterHeight()) {
                 throw JSONRPCError(RPC_MISC_ERROR,
                                    "Blockchain is too short for pruning.");
             } else if (height > chainHeight) {
                 throw JSONRPCError(
                     RPC_INVALID_PARAMETER,
                     "Blockchain is shorter than the attempted prune height.");
             } else if (height > chainHeight - MIN_BLOCKS_TO_KEEP) {
                 LogPrint(BCLog::RPC,
                          "Attempt to prune blocks close to the tip. "
                          "Retaining the minimum number of blocks.\n");
                 height = chainHeight - MIN_BLOCKS_TO_KEEP;
             }
 
             PruneBlockFilesManual(active_chainstate, height);
             const CBlockIndex *block = active_chain.Tip();
             CHECK_NONFATAL(block);
             while (block->pprev && (block->pprev->nStatus.hasData())) {
                 block = block->pprev;
             }
             return uint64_t(block->nHeight);
         },
     };
 }
 
 static CoinStatsHashType ParseHashType(const std::string &hash_type_input) {
     if (hash_type_input == "hash_serialized") {
         return CoinStatsHashType::HASH_SERIALIZED;
     } else if (hash_type_input == "muhash") {
         return CoinStatsHashType::MUHASH;
     } else if (hash_type_input == "none") {
         return CoinStatsHashType::NONE;
     } else {
         throw JSONRPCError(
             RPC_INVALID_PARAMETER,
             strprintf("%s is not a valid hash_type", hash_type_input));
     }
 }
 
 static RPCHelpMan gettxoutsetinfo() {
     return RPCHelpMan{
         "gettxoutsetinfo",
         "Returns statistics about the unspent transaction output set.\n"
         "Note this call may take some time if you are not using "
         "coinstatsindex.\n",
         {
             {"hash_type", RPCArg::Type::STR, /* default */ "hash_serialized",
              "Which UTXO set hash should be calculated. Options: "
              "'hash_serialized' (the legacy algorithm), 'muhash', 'none'."},
             {"hash_or_height",
              RPCArg::Type::NUM,
              RPCArg::Optional::OMITTED,
              "The block hash or height of the target height (only available "
              "with coinstatsindex).",
              "",
              {"", "string or numeric"}},
             {"use_index", RPCArg::Type::BOOL, /* default */ "true",
              "Use coinstatsindex, if available."},
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::NUM, "height",
                  "The current block height (index)"},
                 {RPCResult::Type::STR_HEX, "bestblock",
                  "The hash of the block at the tip of the chain"},
                 {RPCResult::Type::NUM, "txouts",
                  "The number of unspent transaction outputs"},
                 {RPCResult::Type::NUM, "bogosize",
                  "Database-independent, meaningless metric indicating "
                  "the UTXO set size"},
                 {RPCResult::Type::STR_HEX, "hash_serialized",
                  /* optional */ true,
                  "The serialized hash (only present if 'hash_serialized' "
                  "hash_type is chosen)"},
                 {RPCResult::Type::STR_HEX, "muhash", /* optional */ true,
                  "The serialized hash (only present if 'muhash' "
                  "hash_type is chosen)"},
                 {RPCResult::Type::NUM, "transactions",
                  "The number of transactions with unspent outputs (not "
                  "available when coinstatsindex is used)"},
                 {RPCResult::Type::NUM, "disk_size",
                  "The estimated size of the chainstate on disk (not "
                  "available when coinstatsindex is used)"},
                 {RPCResult::Type::STR_AMOUNT, "total_amount",
                  "The total amount"},
                 {RPCResult::Type::STR_AMOUNT, "total_unspendable_amount",
                  "The total amount of coins permanently excluded from the UTXO "
                  "set (only available if coinstatsindex is used)"},
                 {RPCResult::Type::OBJ,
                  "block_info",
                  "Info on amounts in the block at this block height (only "
                  "available if coinstatsindex is used)",
                  {{RPCResult::Type::STR_AMOUNT, "prevout_spent", ""},
                   {RPCResult::Type::STR_AMOUNT, "coinbase", ""},
                   {RPCResult::Type::STR_AMOUNT, "new_outputs_ex_coinbase", ""},
                   {RPCResult::Type::STR_AMOUNT, "unspendable", ""},
                   {RPCResult::Type::OBJ,
                    "unspendables",
                    "Detailed view of the unspendable categories",
                    {
                        {RPCResult::Type::STR_AMOUNT, "genesis_block", ""},
                        {RPCResult::Type::STR_AMOUNT, "bip30",
                         "Transactions overridden by duplicates (no longer "
                         "possible with BIP30)"},
                        {RPCResult::Type::STR_AMOUNT, "scripts",
                         "Amounts sent to scripts that are unspendable (for "
                         "example OP_RETURN outputs)"},
                        {RPCResult::Type::STR_AMOUNT, "unclaimed_rewards",
                         "Fee rewards that miners did not claim in their "
                         "coinbase transaction"},
                    }}}},
             }},
         RPCExamples{
             HelpExampleCli("gettxoutsetinfo", "") +
             HelpExampleCli("gettxoutsetinfo", R"("none")") +
             HelpExampleCli("gettxoutsetinfo", R"("none" 1000)") +
             HelpExampleCli(
                 "gettxoutsetinfo",
                 R"("none" '"00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09"')") +
             HelpExampleRpc("gettxoutsetinfo", "") +
             HelpExampleRpc("gettxoutsetinfo", R"("none")") +
             HelpExampleRpc("gettxoutsetinfo", R"("none", 1000)") +
             HelpExampleRpc(
                 "gettxoutsetinfo",
                 R"("none", "00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09")")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             UniValue ret(UniValue::VOBJ);
 
             const CBlockIndex *pindex{nullptr};
             const CoinStatsHashType hash_type{
                 request.params[0].isNull()
                     ? CoinStatsHashType::HASH_SERIALIZED
                     : ParseHashType(request.params[0].get_str())};
             CCoinsStats stats{hash_type};
             stats.index_requested =
                 request.params[2].isNull() || request.params[2].get_bool();
 
             NodeContext &node = EnsureAnyNodeContext(request.context);
             ChainstateManager &chainman = EnsureChainman(node);
             CChainState &active_chainstate = chainman.ActiveChainstate();
             active_chainstate.ForceFlushStateToDisk();
 
             CCoinsView *coins_view;
             BlockManager *blockman;
             {
                 LOCK(::cs_main);
                 coins_view = &active_chainstate.CoinsDB();
                 blockman = &active_chainstate.m_blockman;
                 pindex = blockman->LookupBlockIndex(coins_view->GetBestBlock());
             }
 
             if (!request.params[1].isNull()) {
                 if (!g_coin_stats_index) {
                     throw JSONRPCError(RPC_INVALID_PARAMETER,
                                        "Querying specific block heights "
                                        "requires coinstatsindex");
                 }
 
                 if (stats.m_hash_type == CoinStatsHashType::HASH_SERIALIZED) {
                     throw JSONRPCError(RPC_INVALID_PARAMETER,
                                        "hash_serialized hash type cannot be "
                                        "queried for a specific block");
                 }
 
                 pindex = ParseHashOrHeight(request.params[1], chainman);
             }
 
             if (GetUTXOStats(coins_view, *blockman, stats,
                              node.rpc_interruption_point, pindex)) {
                 ret.pushKV("height", int64_t(stats.nHeight));
                 ret.pushKV("bestblock", stats.hashBlock.GetHex());
                 ret.pushKV("txouts", int64_t(stats.nTransactionOutputs));
                 ret.pushKV("bogosize", int64_t(stats.nBogoSize));
                 if (hash_type == CoinStatsHashType::HASH_SERIALIZED) {
                     ret.pushKV("hash_serialized",
                                stats.hashSerialized.GetHex());
                 }
                 if (hash_type == CoinStatsHashType::MUHASH) {
                     ret.pushKV("muhash", stats.hashSerialized.GetHex());
                 }
                 ret.pushKV("total_amount", stats.nTotalAmount);
                 if (!stats.index_used) {
                     ret.pushKV("transactions",
                                static_cast<int64_t>(stats.nTransactions));
                     ret.pushKV("disk_size", stats.nDiskSize);
                 } else {
                     ret.pushKV("total_unspendable_amount",
                                stats.total_unspendable_amount);
 
                     CCoinsStats prev_stats{hash_type};
 
                     if (pindex->nHeight > 0) {
                         GetUTXOStats(coins_view, *blockman, prev_stats,
                                      node.rpc_interruption_point,
                                      pindex->pprev);
                     }
 
                     UniValue block_info(UniValue::VOBJ);
                     block_info.pushKV(
                         "prevout_spent",
                         stats.total_prevout_spent_amount -
                             prev_stats.total_prevout_spent_amount);
                     block_info.pushKV("coinbase",
                                       stats.total_coinbase_amount -
                                           prev_stats.total_coinbase_amount);
                     block_info.pushKV(
                         "new_outputs_ex_coinbase",
                         stats.total_new_outputs_ex_coinbase_amount -
                             prev_stats.total_new_outputs_ex_coinbase_amount);
                     block_info.pushKV("unspendable",
                                       stats.total_unspendable_amount -
                                           prev_stats.total_unspendable_amount);
 
                     UniValue unspendables(UniValue::VOBJ);
                     unspendables.pushKV(
                         "genesis_block",
                         stats.total_unspendables_genesis_block -
                             prev_stats.total_unspendables_genesis_block);
                     unspendables.pushKV(
                         "bip30", stats.total_unspendables_bip30 -
                                      prev_stats.total_unspendables_bip30);
                     unspendables.pushKV(
                         "scripts", stats.total_unspendables_scripts -
                                        prev_stats.total_unspendables_scripts);
                     unspendables.pushKV(
                         "unclaimed_rewards",
                         stats.total_unspendables_unclaimed_rewards -
                             prev_stats.total_unspendables_unclaimed_rewards);
                     block_info.pushKV("unspendables", unspendables);
 
                     ret.pushKV("block_info", block_info);
                 }
             } else {
                 if (g_coin_stats_index) {
                     const IndexSummary summary{
                         g_coin_stats_index->GetSummary()};
 
                     if (!summary.synced) {
                         throw JSONRPCError(
                             RPC_INTERNAL_ERROR,
                             strprintf("Unable to read UTXO set because "
                                       "coinstatsindex is still syncing. "
                                       "Current height: %d",
                                       summary.best_block_height));
                     }
                 }
                 throw JSONRPCError(RPC_INTERNAL_ERROR,
                                    "Unable to read UTXO set");
             }
             return ret;
         },
     };
 }
 
 RPCHelpMan gettxout() {
     return RPCHelpMan{
         "gettxout",
         "Returns details about an unspent transaction output.\n",
         {
             {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The transaction id"},
             {"n", RPCArg::Type::NUM, RPCArg::Optional::NO, "vout number"},
             {"include_mempool", RPCArg::Type::BOOL, /* default */ "true",
              "Whether to include the mempool. Note that an unspent output that "
              "is spent in the mempool won't appear."},
         },
         {
             RPCResult{"If the UTXO was not found", RPCResult::Type::NONE, "",
                       ""},
             RPCResult{
                 "Otherwise",
                 RPCResult::Type::OBJ,
                 "",
                 "",
                 {
                     {RPCResult::Type::STR_HEX, "bestblock",
                      "The hash of the block at the tip of the chain"},
                     {RPCResult::Type::NUM, "confirmations",
                      "The number of confirmations"},
                     {RPCResult::Type::STR_AMOUNT, "value",
                      "The transaction value in " + Currency::get().ticker},
                     {RPCResult::Type::OBJ,
                      "scriptPubKey",
                      "",
                      {
                          {RPCResult::Type::STR_HEX, "asm", ""},
                          {RPCResult::Type::STR_HEX, "hex", ""},
                          {RPCResult::Type::NUM, "reqSigs",
                           "Number of required signatures"},
                          {RPCResult::Type::STR_HEX, "type",
                           "The type, eg pubkeyhash"},
                          {RPCResult::Type::ARR,
                           "addresses",
                           "array of eCash addresses",
                           {{RPCResult::Type::STR, "address", "eCash address"}}},
                      }},
                     {RPCResult::Type::BOOL, "coinbase", "Coinbase or not"},
                 }},
         },
         RPCExamples{"\nGet unspent transactions\n" +
                     HelpExampleCli("listunspent", "") + "\nView the details\n" +
                     HelpExampleCli("gettxout", "\"txid\" 1") +
                     "\nAs a JSON-RPC call\n" +
                     HelpExampleRpc("gettxout", "\"txid\", 1")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             NodeContext &node = EnsureAnyNodeContext(request.context);
             ChainstateManager &chainman = EnsureChainman(node);
             LOCK(cs_main);
 
             UniValue ret(UniValue::VOBJ);
 
             TxId txid(ParseHashV(request.params[0], "txid"));
             int n = request.params[1].get_int();
             COutPoint out(txid, n);
             bool fMempool = true;
             if (!request.params[2].isNull()) {
                 fMempool = request.params[2].get_bool();
             }
 
             Coin coin;
             CChainState &active_chainstate = chainman.ActiveChainstate();
             CCoinsViewCache *coins_view = &active_chainstate.CoinsTip();
 
             if (fMempool) {
                 const CTxMemPool &mempool = EnsureMemPool(node);
                 LOCK(mempool.cs);
                 CCoinsViewMemPool view(coins_view, mempool);
                 if (!view.GetCoin(out, coin) || mempool.isSpent(out)) {
                     return NullUniValue;
                 }
             } else {
                 if (!coins_view->GetCoin(out, coin)) {
                     return NullUniValue;
                 }
             }
 
             const CBlockIndex *pindex =
                 active_chainstate.m_blockman.LookupBlockIndex(
                     coins_view->GetBestBlock());
             ret.pushKV("bestblock", pindex->GetBlockHash().GetHex());
             if (coin.GetHeight() == MEMPOOL_HEIGHT) {
                 ret.pushKV("confirmations", 0);
             } else {
                 ret.pushKV("confirmations",
                            int64_t(pindex->nHeight - coin.GetHeight() + 1));
             }
             ret.pushKV("value", coin.GetTxOut().nValue);
             UniValue o(UniValue::VOBJ);
             ScriptPubKeyToUniv(coin.GetTxOut().scriptPubKey, o, true);
             ret.pushKV("scriptPubKey", o);
             ret.pushKV("coinbase", coin.IsCoinBase());
 
             return ret;
         },
     };
 }
 
 static RPCHelpMan verifychain() {
     return RPCHelpMan{
         "verifychain",
         "Verifies blockchain database.\n",
         {
             {"checklevel", RPCArg::Type::NUM,
              /* default */ strprintf("%d, range=0-4", DEFAULT_CHECKLEVEL),
              strprintf("How thorough the block verification is:\n - %s",
                        Join(CHECKLEVEL_DOC, "\n- "))},
             {"nblocks", RPCArg::Type::NUM,
              /* default */ strprintf("%d, 0=all", DEFAULT_CHECKBLOCKS),
              "The number of blocks to check."},
         },
         RPCResult{RPCResult::Type::BOOL, "", "Verified or not"},
         RPCExamples{HelpExampleCli("verifychain", "") +
                     HelpExampleRpc("verifychain", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             const int check_level(request.params[0].isNull()
                                       ? DEFAULT_CHECKLEVEL
                                       : request.params[0].get_int());
             const int check_depth{request.params[1].isNull()
                                       ? DEFAULT_CHECKBLOCKS
                                       : request.params[1].get_int()};
 
             ChainstateManager &chainman = EnsureAnyChainman(request.context);
             LOCK(cs_main);
 
             CChainState &active_chainstate = chainman.ActiveChainstate();
             return CVerifyDB().VerifyDB(active_chainstate, config,
                                         active_chainstate.CoinsTip(),
                                         check_level, check_depth);
         },
     };
 }
 
 [[maybe_unused]] static void
 SoftForkDescPushBack(const CBlockIndex *active_chain_tip, UniValue &softforks,
                      const Consensus::Params &params,
                      Consensus::BuriedDeployment dep) {
     // For buried deployments.
     // A buried deployment is one where the height of the activation has been
     // hardcoded into the client implementation long after the consensus change
     // has activated. See BIP 90. Buried deployments with activation height
     // value of std::numeric_limits<int>::max() are disabled and thus hidden.
     if (!DeploymentEnabled(params, dep)) {
         return;
     }
 
     UniValue rv(UniValue::VOBJ);
     rv.pushKV("type", "buried");
     // getblockchaininfo reports the softfork as active from when the chain
     // height is one below the activation height
     rv.pushKV("active", DeploymentActiveAfter(active_chain_tip, params, dep));
     rv.pushKV("height", params.DeploymentHeight(dep));
     softforks.pushKV(DeploymentName(dep), rv);
 }
 
 static void SoftForkDescPushBack(const CBlockIndex *active_chain_tip,
                                  UniValue &softforks,
                                  const Consensus::Params &consensusParams,
                                  Consensus::DeploymentPos id) {
     // For BIP9 deployments.
     // Deployments (e.g. testdummy) with timeout value before Jan 1, 2009 are
     // hidden. A timeout value of 0 guarantees a softfork will never be
     // activated. This is used when merging logic to implement a proposed
     // softfork without a specified deployment schedule.
     if (consensusParams.vDeployments[id].nTimeout <= 1230768000) {
         return;
     }
 
     UniValue bip9(UniValue::VOBJ);
     const ThresholdState thresholdState =
         g_versionbitscache.State(active_chain_tip, consensusParams, id);
     switch (thresholdState) {
         case ThresholdState::DEFINED:
             bip9.pushKV("status", "defined");
             break;
         case ThresholdState::STARTED:
             bip9.pushKV("status", "started");
             break;
         case ThresholdState::LOCKED_IN:
             bip9.pushKV("status", "locked_in");
             break;
         case ThresholdState::ACTIVE:
             bip9.pushKV("status", "active");
             break;
         case ThresholdState::FAILED:
             bip9.pushKV("status", "failed");
             break;
     }
     if (ThresholdState::STARTED == thresholdState) {
         bip9.pushKV("bit", consensusParams.vDeployments[id].bit);
     }
     bip9.pushKV("start_time", consensusParams.vDeployments[id].nStartTime);
     bip9.pushKV("timeout", consensusParams.vDeployments[id].nTimeout);
     int64_t since_height = g_versionbitscache.StateSinceHeight(
         active_chain_tip, consensusParams, id);
     bip9.pushKV("since", since_height);
     if (ThresholdState::STARTED == thresholdState) {
         UniValue statsUV(UniValue::VOBJ);
         BIP9Stats statsStruct = g_versionbitscache.Statistics(
             active_chain_tip, consensusParams, id);
         statsUV.pushKV("period", statsStruct.period);
         statsUV.pushKV("threshold", statsStruct.threshold);
         statsUV.pushKV("elapsed", statsStruct.elapsed);
         statsUV.pushKV("count", statsStruct.count);
         statsUV.pushKV("possible", statsStruct.possible);
         bip9.pushKV("statistics", statsUV);
     }
 
     UniValue rv(UniValue::VOBJ);
     rv.pushKV("type", "bip9");
     rv.pushKV("bip9", bip9);
     if (ThresholdState::ACTIVE == thresholdState) {
         rv.pushKV("height", since_height);
     }
     rv.pushKV("active", ThresholdState::ACTIVE == thresholdState);
 
     softforks.pushKV(DeploymentName(id), rv);
 }
 
 RPCHelpMan getblockchaininfo() {
     return RPCHelpMan{
         "getblockchaininfo",
         "Returns an object containing various state info regarding blockchain "
         "processing.\n",
         {},
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::STR, "chain",
                  "current network name (main, test, regtest)"},
                 {RPCResult::Type::NUM, "blocks",
                  "the height of the most-work fully-validated chain. The "
                  "genesis block has height 0"},
                 {RPCResult::Type::NUM, "headers",
                  "the current number of headers we have validated"},
                 {RPCResult::Type::STR, "bestblockhash",
                  "the hash of the currently best block"},
                 {RPCResult::Type::NUM, "difficulty", "the current difficulty"},
                 {RPCResult::Type::NUM_TIME, "time",
                  "The block time expressed in " + UNIX_EPOCH_TIME},
                 {RPCResult::Type::NUM_TIME, "mediantime",
                  "The median block time expressed in " + UNIX_EPOCH_TIME},
                 {RPCResult::Type::NUM, "verificationprogress",
                  "estimate of verification progress [0..1]"},
                 {RPCResult::Type::BOOL, "initialblockdownload",
                  "(debug information) estimate of whether this node is in "
                  "Initial Block Download mode"},
                 {RPCResult::Type::STR_HEX, "chainwork",
                  "total amount of work in active chain, in hexadecimal"},
                 {RPCResult::Type::NUM, "size_on_disk",
                  "the estimated size of the block and undo files on disk"},
                 {RPCResult::Type::BOOL, "pruned",
                  "if the blocks are subject to pruning"},
                 {RPCResult::Type::NUM, "pruneheight",
                  "lowest-height complete block stored (only present if pruning "
                  "is enabled)"},
                 {RPCResult::Type::BOOL, "automatic_pruning",
                  "whether automatic pruning is enabled (only present if "
                  "pruning is enabled)"},
                 {RPCResult::Type::NUM, "prune_target_size",
                  "the target size used by pruning (only present if automatic "
                  "pruning is enabled)"},
                 {RPCResult::Type::OBJ_DYN,
                  "softforks",
                  "status of softforks",
                  {
                      {RPCResult::Type::OBJ,
                       "xxxx",
                       "name of the softfork",
                       {
                           {RPCResult::Type::STR, "type",
                            "one of \"buried\", \"bip9\""},
                           {RPCResult::Type::OBJ,
                            "bip9",
                            "status of bip9 softforks (only for \"bip9\" type)",
                            {
                                {RPCResult::Type::STR, "status",
                                 "one of \"defined\", \"started\", "
                                 "\"locked_in\", \"active\", \"failed\""},
                                {RPCResult::Type::NUM, "bit",
                                 "the bit (0-28) in the block version field "
                                 "used to signal this softfork (only for "
                                 "\"started\" status)"},
                                {RPCResult::Type::NUM_TIME, "start_time",
                                 "the minimum median time past of a block at "
                                 "which the bit gains its meaning"},
                                {RPCResult::Type::NUM_TIME, "timeout",
                                 "the median time past of a block at which the "
                                 "deployment is considered failed if not yet "
                                 "locked in"},
                                {RPCResult::Type::NUM, "since",
                                 "height of the first block to which the status "
                                 "applies"},
                                {RPCResult::Type::OBJ,
                                 "statistics",
                                 "numeric statistics about BIP9 signalling for "
                                 "a softfork",
                                 {
                                     {RPCResult::Type::NUM, "period",
                                      "the length in blocks of the BIP9 "
                                      "signalling period"},
                                     {RPCResult::Type::NUM, "threshold",
                                      "the number of blocks with the version "
                                      "bit set required to activate the "
                                      "feature"},
                                     {RPCResult::Type::NUM, "elapsed",
                                      "the number of blocks elapsed since the "
                                      "beginning of the current period"},
                                     {RPCResult::Type::NUM, "count",
                                      "the number of blocks with the version "
                                      "bit set in the current period"},
                                     {RPCResult::Type::BOOL, "possible",
                                      "returns false if there are not enough "
                                      "blocks left in this period to pass "
                                      "activation threshold"},
                                 }},
                            }},
                           {RPCResult::Type::NUM, "height",
                            "height of the first block which the rules are or "
                            "will be enforced (only for \"buried\" type, or "
                            "\"bip9\" type with \"active\" status)"},
                           {RPCResult::Type::BOOL, "active",
                            "true if the rules are enforced for the mempool and "
                            "the next block"},
                       }},
                  }},
                 {RPCResult::Type::STR, "warnings",
                  "any network and blockchain warnings"},
             }},
         RPCExamples{HelpExampleCli("getblockchaininfo", "") +
                     HelpExampleRpc("getblockchaininfo", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             const CChainParams &chainparams = config.GetChainParams();
 
             ChainstateManager &chainman = EnsureAnyChainman(request.context);
             LOCK(cs_main);
             CChainState &active_chainstate = chainman.ActiveChainstate();
 
             const CBlockIndex *tip = active_chainstate.m_chain.Tip();
             CHECK_NONFATAL(tip);
             const int height = tip->nHeight;
 
             UniValue obj(UniValue::VOBJ);
             obj.pushKV("chain", chainparams.NetworkIDString());
             obj.pushKV("blocks", height);
             obj.pushKV("headers", chainman.m_best_header
                                       ? chainman.m_best_header->nHeight
                                       : -1);
             obj.pushKV("bestblockhash", tip->GetBlockHash().GetHex());
             obj.pushKV("difficulty", double(GetDifficulty(tip)));
             obj.pushKV("time", tip->GetBlockTime());
             obj.pushKV("mediantime", tip->GetMedianTimePast());
             obj.pushKV("verificationprogress",
                        GuessVerificationProgress(Params().TxData(), tip));
             obj.pushKV("initialblockdownload",
                        active_chainstate.IsInitialBlockDownload());
             obj.pushKV("chainwork", tip->nChainWork.GetHex());
             obj.pushKV("size_on_disk",
                        chainman.m_blockman.CalculateCurrentUsage());
             obj.pushKV("pruned", node::fPruneMode);
 
             if (node::fPruneMode) {
                 const CBlockIndex *block = tip;
                 CHECK_NONFATAL(block);
                 while (block->pprev && (block->pprev->nStatus.hasData())) {
                     block = block->pprev;
                 }
 
                 obj.pushKV("pruneheight", block->nHeight);
 
                 // if 0, execution bypasses the whole if block.
                 bool automatic_pruning = (gArgs.GetIntArg("-prune", 0) != 1);
                 obj.pushKV("automatic_pruning", automatic_pruning);
                 if (automatic_pruning) {
                     obj.pushKV("prune_target_size", node::nPruneTarget);
                 }
             }
 
             UniValue softforks(UniValue::VOBJ);
             for (int i = 0; i < (int)Consensus::MAX_VERSION_BITS_DEPLOYMENTS;
                  i++) {
                 SoftForkDescPushBack(tip, softforks, chainparams.GetConsensus(),
                                      Consensus::DeploymentPos(i));
             }
             obj.pushKV("softforks", softforks);
 
             obj.pushKV("warnings", GetWarnings(false).original);
             return obj;
         },
     };
 }
 
 /** Comparison function for sorting the getchaintips heads.  */
 struct CompareBlocksByHeight {
     bool operator()(const CBlockIndex *a, const CBlockIndex *b) const {
         // Make sure that unequal blocks with the same height do not compare
         // equal. Use the pointers themselves to make a distinction.
         if (a->nHeight != b->nHeight) {
             return (a->nHeight > b->nHeight);
         }
 
         return a < b;
     }
 };
 
 static RPCHelpMan getchaintips() {
     return RPCHelpMan{
         "getchaintips",
         "Return information about all known tips in the block tree, including "
         "the main chain as well as orphaned branches.\n",
         {},
         RPCResult{
             RPCResult::Type::ARR,
             "",
             "",
             {{RPCResult::Type::OBJ,
               "",
               "",
               {
                   {RPCResult::Type::NUM, "height", "height of the chain tip"},
                   {RPCResult::Type::STR_HEX, "hash", "block hash of the tip"},
                   {RPCResult::Type::NUM, "branchlen",
                    "zero for main chain, otherwise length of branch connecting "
                    "the tip to the main chain"},
                   {RPCResult::Type::STR, "status",
                    "status of the chain, \"active\" for the main chain\n"
                    "Possible values for status:\n"
                    "1.  \"invalid\"               This branch contains at "
                    "least one invalid block\n"
                    "2.  \"parked\"                This branch contains at "
                    "least one parked block\n"
                    "3.  \"headers-only\"          Not all blocks for this "
                    "branch are available, but the headers are valid\n"
                    "4.  \"valid-headers\"         All blocks are available for "
                    "this branch, but they were never fully validated\n"
                    "5.  \"valid-fork\"            This branch is not part of "
                    "the active chain, but is fully validated\n"
                    "6.  \"active\"                This is the tip of the "
                    "active main chain, which is certainly valid"},
               }}}},
         RPCExamples{HelpExampleCli("getchaintips", "") +
                     HelpExampleRpc("getchaintips", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             ChainstateManager &chainman = EnsureAnyChainman(request.context);
             LOCK(cs_main);
             CChain &active_chain = chainman.ActiveChain();
 
             /**
              * Idea: The set of chain tips is the active chain tip, plus orphan
              * blocks which do not have another orphan building off of them.
              * Algorithm:
              *  - Make one pass through BlockIndex(), picking out the orphan
              * blocks, and also storing a set of the orphan block's pprev
              * pointers.
              *  - Iterate through the orphan blocks. If the block isn't pointed
              * to by another orphan, it is a chain tip.
              *  - Add the active chain tip
              */
             std::set<const CBlockIndex *, CompareBlocksByHeight> setTips;
             std::set<const CBlockIndex *> setOrphans;
             std::set<const CBlockIndex *> setPrevs;
 
             for (const auto &[_, block_index] : chainman.BlockIndex()) {
                 if (!active_chain.Contains(&block_index)) {
                     setOrphans.insert(&block_index);
                     setPrevs.insert(block_index.pprev);
                 }
             }
 
             for (std::set<const CBlockIndex *>::iterator it =
                      setOrphans.begin();
                  it != setOrphans.end(); ++it) {
                 if (setPrevs.erase(*it) == 0) {
                     setTips.insert(*it);
                 }
             }
 
             // Always report the currently active tip.
             setTips.insert(active_chain.Tip());
 
             /* Construct the output array.  */
             UniValue res(UniValue::VARR);
             for (const CBlockIndex *block : setTips) {
                 UniValue obj(UniValue::VOBJ);
                 obj.pushKV("height", block->nHeight);
                 obj.pushKV("hash", block->phashBlock->GetHex());
 
                 const int branchLen =
                     block->nHeight - active_chain.FindFork(block)->nHeight;
                 obj.pushKV("branchlen", branchLen);
 
                 std::string status;
                 if (active_chain.Contains(block)) {
                     // This block is part of the currently active chain.
                     status = "active";
                 } else if (block->nStatus.isInvalid()) {
                     // This block or one of its ancestors is invalid.
                     status = "invalid";
                 } else if (block->nStatus.isOnParkedChain()) {
                     // This block or one of its ancestors is parked.
                     status = "parked";
                 } else if (!block->HaveTxsDownloaded()) {
                     // This block cannot be connected because full block data
                     // for it or one of its parents is missing.
                     status = "headers-only";
                 } else if (block->IsValid(BlockValidity::SCRIPTS)) {
                     // This block is fully validated, but no longer part of the
                     // active chain. It was probably the active block once, but
                     // was reorganized.
                     status = "valid-fork";
                 } else if (block->IsValid(BlockValidity::TREE)) {
                     // The headers for this block are valid, but it has not been
                     // validated. It was probably never part of the most-work
                     // chain.
                     status = "valid-headers";
                 } else {
                     // No clue.
                     status = "unknown";
                 }
                 obj.pushKV("status", status);
 
                 res.push_back(obj);
             }
 
             return res;
         },
     };
 }
 
 UniValue MempoolInfoToJSON(const CTxMemPool &pool) {
     // Make sure this call is atomic in the pool.
     LOCK(pool.cs);
     UniValue ret(UniValue::VOBJ);
     ret.pushKV("loaded", pool.IsLoaded());
     ret.pushKV("size", (int64_t)pool.size());
     ret.pushKV("bytes", (int64_t)pool.GetTotalTxSize());
     ret.pushKV("usage", (int64_t)pool.DynamicMemoryUsage());
     ret.pushKV("total_fee", pool.GetTotalFee());
     size_t maxmempool =
         gArgs.GetIntArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000;
     ret.pushKV("maxmempool", (int64_t)maxmempool);
     ret.pushKV(
         "mempoolminfee",
         std::max(pool.GetMinFee(maxmempool), ::minRelayTxFee).GetFeePerK());
     ret.pushKV("minrelaytxfee", ::minRelayTxFee.GetFeePerK());
     ret.pushKV("unbroadcastcount", uint64_t{pool.GetUnbroadcastTxs().size()});
     return ret;
 }
 
 static RPCHelpMan getmempoolinfo() {
     const auto &ticker = Currency::get().ticker;
     return RPCHelpMan{
         "getmempoolinfo",
         "Returns details on the active state of the TX memory pool.\n",
         {},
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::BOOL, "loaded",
                  "True if the mempool is fully loaded"},
                 {RPCResult::Type::NUM, "size", "Current tx count"},
                 {RPCResult::Type::NUM, "bytes", "Sum of all transaction sizes"},
                 {RPCResult::Type::NUM, "usage",
                  "Total memory usage for the mempool"},
                 {RPCResult::Type::NUM, "maxmempool",
                  "Maximum memory usage for the mempool"},
                 {RPCResult::Type::STR_AMOUNT, "total_fee",
                  "Total fees for the mempool in " + ticker +
                      ", ignoring modified fees through prioritizetransaction"},
                 {RPCResult::Type::STR_AMOUNT, "mempoolminfee",
                  "Minimum fee rate in " + ticker +
                      "/kB for tx to be accepted. Is the maximum of "
                      "minrelaytxfee and minimum mempool fee"},
                 {RPCResult::Type::STR_AMOUNT, "minrelaytxfee",
                  "Current minimum relay fee for transactions"},
                 {RPCResult::Type::NUM, "unbroadcastcount",
                  "Current number of transactions that haven't passed initial "
                  "broadcast yet"},
             }},
         RPCExamples{HelpExampleCli("getmempoolinfo", "") +
                     HelpExampleRpc("getmempoolinfo", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             return MempoolInfoToJSON(EnsureAnyMemPool(request.context));
         },
     };
 }
 
 static RPCHelpMan preciousblock() {
     return RPCHelpMan{
         "preciousblock",
         "Treats a block as if it were received before others with the same "
         "work.\n"
         "\nA later preciousblock call can override the effect of an earlier "
         "one.\n"
         "\nThe effects of preciousblock are not retained across restarts.\n",
         {
             {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "the hash of the block to mark as precious"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("preciousblock", "\"blockhash\"") +
                     HelpExampleRpc("preciousblock", "\"blockhash\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             BlockHash hash(ParseHashV(request.params[0], "blockhash"));
             CBlockIndex *pblockindex;
 
             ChainstateManager &chainman = EnsureAnyChainman(request.context);
             {
                 LOCK(cs_main);
                 pblockindex = chainman.m_blockman.LookupBlockIndex(hash);
                 if (!pblockindex) {
                     throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                        "Block not found");
                 }
             }
 
             BlockValidationState state;
             chainman.ActiveChainstate().PreciousBlock(config, state,
                                                       pblockindex);
 
             if (!state.IsValid()) {
                 throw JSONRPCError(RPC_DATABASE_ERROR, state.GetRejectReason());
             }
 
             return NullUniValue;
         },
     };
 }
 
-RPCHelpMan finalizeblock() {
-    return RPCHelpMan{
-        "finalizeblock",
-        "Treats a block as final. It cannot be reorged. Any chain\n"
-        "that does not contain this block is invalid. Used on a less\n"
-        "work chain, it can effectively PUT YOU OUT OF CONSENSUS.\n"
-        "USE WITH CAUTION!\n",
-        {
-            {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
-             "the hash of the block to mark as invalid"},
-        },
-        RPCResult{RPCResult::Type::NONE, "", ""},
-        RPCExamples{HelpExampleCli("finalizeblock", "\"blockhash\"") +
-                    HelpExampleRpc("finalizeblock", "\"blockhash\"")},
-        [&](const RPCHelpMan &self, const Config &config,
-            const JSONRPCRequest &request) -> UniValue {
-            std::string strHash = request.params[0].get_str();
-            BlockHash hash(uint256S(strHash));
-            BlockValidationState state;
-
-            ChainstateManager &chainman = EnsureAnyChainman(request.context);
-            CBlockIndex *pblockindex = nullptr;
-            {
-                LOCK(cs_main);
-                pblockindex = chainman.m_blockman.LookupBlockIndex(hash);
-                if (!pblockindex) {
-                    throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
-                                       "Block not found");
-                }
-            } // end of locked cs_main scope
-
-            chainman.ActiveChainstate().FinalizeBlock(config, state,
-                                                      pblockindex);
-
-            if (state.IsValid()) {
-                chainman.ActiveChainstate().ActivateBestChain(config, state);
-            }
-
-            if (!state.IsValid()) {
-                throw JSONRPCError(RPC_DATABASE_ERROR, state.ToString());
-            }
-
-            return NullUniValue;
-        },
-    };
-}
-
 static RPCHelpMan invalidateblock() {
     return RPCHelpMan{
         "invalidateblock",
         "Permanently marks a block as invalid, as if it violated a consensus "
         "rule.\n",
         {
             {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "the hash of the block to mark as invalid"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("invalidateblock", "\"blockhash\"") +
                     HelpExampleRpc("invalidateblock", "\"blockhash\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             const BlockHash hash(ParseHashV(request.params[0], "blockhash"));
             BlockValidationState state;
 
             ChainstateManager &chainman = EnsureAnyChainman(request.context);
             CBlockIndex *pblockindex;
             {
                 LOCK(cs_main);
                 pblockindex = chainman.m_blockman.LookupBlockIndex(hash);
                 if (!pblockindex) {
                     throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                        "Block not found");
                 }
             }
             chainman.ActiveChainstate().InvalidateBlock(config, state,
                                                         pblockindex);
 
             if (state.IsValid()) {
                 chainman.ActiveChainstate().ActivateBestChain(config, state);
             }
 
             if (!state.IsValid()) {
                 throw JSONRPCError(RPC_DATABASE_ERROR, state.ToString());
             }
 
             return NullUniValue;
         },
     };
 }
 
 RPCHelpMan parkblock() {
     return RPCHelpMan{
         "parkblock",
         "Marks a block as parked.\n",
         {
             {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "the hash of the block to park"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("parkblock", "\"blockhash\"") +
                     HelpExampleRpc("parkblock", "\"blockhash\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             const std::string strHash = request.params[0].get_str();
             const BlockHash hash(uint256S(strHash));
             BlockValidationState state;
 
             ChainstateManager &chainman = EnsureAnyChainman(request.context);
             CChainState &active_chainstate = chainman.ActiveChainstate();
             CBlockIndex *pblockindex = nullptr;
             {
                 LOCK(cs_main);
                 pblockindex = chainman.m_blockman.LookupBlockIndex(hash);
                 if (!pblockindex) {
                     throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                        "Block not found");
                 }
 
                 if (active_chainstate.IsBlockAvalancheFinalized(pblockindex)) {
                     // Reset avalanche finalization if we park a finalized
                     // block.
                     active_chainstate.ClearAvalancheFinalizedBlock();
                 }
             }
 
             active_chainstate.ParkBlock(config, state, pblockindex);
 
             if (state.IsValid()) {
                 active_chainstate.ActivateBestChain(config, state);
             }
 
             if (!state.IsValid()) {
                 throw JSONRPCError(RPC_DATABASE_ERROR, state.GetRejectReason());
             }
 
             return NullUniValue;
         },
     };
 }
 
 static RPCHelpMan reconsiderblock() {
     return RPCHelpMan{
         "reconsiderblock",
         "Removes invalidity status of a block, its ancestors and its"
         "descendants, reconsider them for activation.\n"
         "This can be used to undo the effects of invalidateblock.\n",
         {
             {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "the hash of the block to reconsider"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("reconsiderblock", "\"blockhash\"") +
                     HelpExampleRpc("reconsiderblock", "\"blockhash\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             ChainstateManager &chainman = EnsureAnyChainman(request.context);
             const BlockHash hash(ParseHashV(request.params[0], "blockhash"));
 
             {
                 LOCK(cs_main);
                 CBlockIndex *pblockindex =
                     chainman.m_blockman.LookupBlockIndex(hash);
                 if (!pblockindex) {
                     throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                        "Block not found");
                 }
 
                 chainman.ActiveChainstate().ResetBlockFailureFlags(pblockindex);
             }
 
             BlockValidationState state;
             chainman.ActiveChainstate().ActivateBestChain(config, state);
 
             if (!state.IsValid()) {
                 throw JSONRPCError(RPC_DATABASE_ERROR, state.ToString());
             }
 
             return NullUniValue;
         },
     };
 }
 
 RPCHelpMan unparkblock() {
     return RPCHelpMan{
         "unparkblock",
         "Removes parked status of a block and its descendants, reconsider "
         "them for activation.\n"
         "This can be used to undo the effects of parkblock.\n",
         {
             {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "the hash of the block to unpark"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("unparkblock", "\"blockhash\"") +
                     HelpExampleRpc("unparkblock", "\"blockhash\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             const std::string strHash = request.params[0].get_str();
             ChainstateManager &chainman = EnsureAnyChainman(request.context);
             const BlockHash hash(uint256S(strHash));
             CChainState &active_chainstate = chainman.ActiveChainstate();
 
             {
                 LOCK(cs_main);
 
                 CBlockIndex *pblockindex =
                     chainman.m_blockman.LookupBlockIndex(hash);
                 if (!pblockindex) {
                     throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                        "Block not found");
                 }
 
                 if (!pblockindex->nStatus.isOnParkedChain()) {
                     // Block to unpark is not parked so there is nothing to do.
                     return NullUniValue;
                 }
 
                 const CBlockIndex *tip = active_chainstate.m_chain.Tip();
                 if (tip) {
                     const CBlockIndex *ancestor =
                         LastCommonAncestor(tip, pblockindex);
                     if (active_chainstate.IsBlockAvalancheFinalized(ancestor)) {
                         // Only reset avalanche finalization if we unpark a
                         // block that might conflict with avalanche finalized
                         // blocks.
                         active_chainstate.ClearAvalancheFinalizedBlock();
                     }
                 }
 
                 active_chainstate.UnparkBlockAndChildren(pblockindex);
             }
 
             BlockValidationState state;
             active_chainstate.ActivateBestChain(config, state);
 
             if (!state.IsValid()) {
                 throw JSONRPCError(RPC_DATABASE_ERROR, state.GetRejectReason());
             }
 
             return NullUniValue;
         },
     };
 }
 
 static RPCHelpMan getchaintxstats() {
     return RPCHelpMan{
         "getchaintxstats",
         "Compute statistics about the total number and rate of transactions "
         "in the chain.\n",
         {
             {"nblocks", RPCArg::Type::NUM, /* default */ "one month",
              "Size of the window in number of blocks"},
             {"blockhash", RPCArg::Type::STR_HEX, /* default */ "chain tip",
              "The hash of the block that ends the window."},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::NUM_TIME, "time",
                        "The timestamp for the final block in the window, "
                        "expressed in " +
                            UNIX_EPOCH_TIME},
                       {RPCResult::Type::NUM, "txcount",
                        "The total number of transactions in the chain up to "
                        "that point"},
                       {RPCResult::Type::STR_HEX, "window_final_block_hash",
                        "The hash of the final block in the window"},
                       {RPCResult::Type::NUM, "window_final_block_height",
                        "The height of the final block in the window."},
                       {RPCResult::Type::NUM, "window_block_count",
                        "Size of the window in number of blocks"},
                       {RPCResult::Type::NUM, "window_tx_count",
                        "The number of transactions in the window. Only "
                        "returned if \"window_block_count\" is > 0"},
                       {RPCResult::Type::NUM, "window_interval",
                        "The elapsed time in the window in seconds. Only "
                        "returned if \"window_block_count\" is > 0"},
                       {RPCResult::Type::NUM, "txrate",
                        "The average rate of transactions per second in the "
                        "window. Only returned if \"window_interval\" is > 0"},
                   }},
         RPCExamples{HelpExampleCli("getchaintxstats", "") +
                     HelpExampleRpc("getchaintxstats", "2016")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             ChainstateManager &chainman = EnsureAnyChainman(request.context);
             const CBlockIndex *pindex;
 
             // By default: 1 month
             int blockcount =
                 30 * 24 * 60 * 60 /
                 config.GetChainParams().GetConsensus().nPowTargetSpacing;
 
             if (request.params[1].isNull()) {
                 LOCK(cs_main);
                 pindex = chainman.ActiveTip();
             } else {
                 BlockHash hash(ParseHashV(request.params[1], "blockhash"));
                 LOCK(cs_main);
                 pindex = chainman.m_blockman.LookupBlockIndex(hash);
                 if (!pindex) {
                     throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                        "Block not found");
                 }
                 if (!chainman.ActiveChain().Contains(pindex)) {
                     throw JSONRPCError(RPC_INVALID_PARAMETER,
                                        "Block is not in main chain");
                 }
             }
 
             CHECK_NONFATAL(pindex != nullptr);
 
             if (request.params[0].isNull()) {
                 blockcount =
                     std::max(0, std::min(blockcount, pindex->nHeight - 1));
             } else {
                 blockcount = request.params[0].get_int();
 
                 if (blockcount < 0 ||
                     (blockcount > 0 && blockcount >= pindex->nHeight)) {
                     throw JSONRPCError(RPC_INVALID_PARAMETER,
                                        "Invalid block count: "
                                        "should be between 0 and "
                                        "the block's height - 1");
                 }
             }
 
             const CBlockIndex *pindexPast =
                 pindex->GetAncestor(pindex->nHeight - blockcount);
             int nTimeDiff =
                 pindex->GetMedianTimePast() - pindexPast->GetMedianTimePast();
             int nTxDiff =
                 pindex->GetChainTxCount() - pindexPast->GetChainTxCount();
 
             UniValue ret(UniValue::VOBJ);
             ret.pushKV("time", pindex->GetBlockTime());
             ret.pushKV("txcount", pindex->GetChainTxCount());
             ret.pushKV("window_final_block_hash",
                        pindex->GetBlockHash().GetHex());
             ret.pushKV("window_final_block_height", pindex->nHeight);
             ret.pushKV("window_block_count", blockcount);
             if (blockcount > 0) {
                 ret.pushKV("window_tx_count", nTxDiff);
                 ret.pushKV("window_interval", nTimeDiff);
                 if (nTimeDiff > 0) {
                     ret.pushKV("txrate", double(nTxDiff) / nTimeDiff);
                 }
             }
 
             return ret;
         },
     };
 }
 
 template <typename T>
 static T CalculateTruncatedMedian(std::vector<T> &scores) {
     size_t size = scores.size();
     if (size == 0) {
         return T();
     }
 
     std::sort(scores.begin(), scores.end());
     if (size % 2 == 0) {
         return (scores[size / 2 - 1] + scores[size / 2]) / 2;
     } else {
         return scores[size / 2];
     }
 }
 
 template <typename T> static inline bool SetHasKeys(const std::set<T> &set) {
     return false;
 }
 template <typename T, typename Tk, typename... Args>
 static inline bool SetHasKeys(const std::set<T> &set, const Tk &key,
                               const Args &...args) {
     return (set.count(key) != 0) || SetHasKeys(set, args...);
 }
 
 // outpoint (needed for the utxo index) + nHeight + fCoinBase
 static constexpr size_t PER_UTXO_OVERHEAD =
     sizeof(COutPoint) + sizeof(uint32_t) + sizeof(bool);
 
 static RPCHelpMan getblockstats() {
     const auto &ticker = Currency::get().ticker;
     return RPCHelpMan{
         "getblockstats",
         "Compute per block statistics for a given window. All amounts are "
         "in " +
             ticker +
             ".\n"
             "It won't work for some heights with pruning.\n",
         {
             {"hash_or_height",
              RPCArg::Type::NUM,
              RPCArg::Optional::NO,
              "The block hash or height of the target block",
              "",
              {"", "string or numeric"}},
             {"stats",
              RPCArg::Type::ARR,
              /* default */ "all values",
              "Values to plot (see result below)",
              {
                  {"height", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
                   "Selected statistic"},
                  {"time", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
                   "Selected statistic"},
              },
              "stats"},
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::NUM, "avgfee", "Average fee in the block"},
                 {RPCResult::Type::NUM, "avgfeerate",
                  "Average feerate (in satoshis per virtual byte)"},
                 {RPCResult::Type::NUM, "avgtxsize", "Average transaction size"},
                 {RPCResult::Type::STR_HEX, "blockhash",
                  "The block hash (to check for potential reorgs)"},
                 {RPCResult::Type::NUM, "height", "The height of the block"},
                 {RPCResult::Type::NUM, "ins",
                  "The number of inputs (excluding coinbase)"},
                 {RPCResult::Type::NUM, "maxfee", "Maximum fee in the block"},
                 {RPCResult::Type::NUM, "maxfeerate",
                  "Maximum feerate (in satoshis per virtual byte)"},
                 {RPCResult::Type::NUM, "maxtxsize", "Maximum transaction size"},
                 {RPCResult::Type::NUM, "medianfee",
                  "Truncated median fee in the block"},
                 {RPCResult::Type::NUM, "medianfeerate",
                  "Truncated median feerate (in " + ticker + " per byte)"},
                 {RPCResult::Type::NUM, "mediantime",
                  "The block median time past"},
                 {RPCResult::Type::NUM, "mediantxsize",
                  "Truncated median transaction size"},
                 {RPCResult::Type::NUM, "minfee", "Minimum fee in the block"},
                 {RPCResult::Type::NUM, "minfeerate",
                  "Minimum feerate (in satoshis per virtual byte)"},
                 {RPCResult::Type::NUM, "mintxsize", "Minimum transaction size"},
                 {RPCResult::Type::NUM, "outs", "The number of outputs"},
                 {RPCResult::Type::NUM, "subsidy", "The block subsidy"},
                 {RPCResult::Type::NUM, "time", "The block time"},
                 {RPCResult::Type::NUM, "total_out",
                  "Total amount in all outputs (excluding coinbase and thus "
                  "reward [ie subsidy + totalfee])"},
                 {RPCResult::Type::NUM, "total_size",
                  "Total size of all non-coinbase transactions"},
                 {RPCResult::Type::NUM, "totalfee", "The fee total"},
                 {RPCResult::Type::NUM, "txs",
                  "The number of transactions (including coinbase)"},
                 {RPCResult::Type::NUM, "utxo_increase",
                  "The increase/decrease in the number of unspent outputs"},
                 {RPCResult::Type::NUM, "utxo_size_inc",
                  "The increase/decrease in size for the utxo index (not "
                  "discounting op_return and similar)"},
             }},
         RPCExamples{
             HelpExampleCli(
                 "getblockstats",
                 R"('"00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09"' '["minfeerate","avgfeerate"]')") +
             HelpExampleCli("getblockstats",
                            R"(1000 '["minfeerate","avgfeerate"]')") +
             HelpExampleRpc(
                 "getblockstats",
                 R"("00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09", ["minfeerate","avgfeerate"])") +
             HelpExampleRpc("getblockstats",
                            R"(1000, ["minfeerate","avgfeerate"])")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             ChainstateManager &chainman = EnsureAnyChainman(request.context);
             const CBlockIndex *pindex{
                 ParseHashOrHeight(request.params[0], chainman)};
             CHECK_NONFATAL(pindex != nullptr);
 
             std::set<std::string> stats;
             if (!request.params[1].isNull()) {
                 const UniValue stats_univalue = request.params[1].get_array();
                 for (unsigned int i = 0; i < stats_univalue.size(); i++) {
                     const std::string stat = stats_univalue[i].get_str();
                     stats.insert(stat);
                 }
             }
 
             const CBlock block =
                 GetBlockChecked(config, chainman.m_blockman, pindex);
             const CBlockUndo blockUndo =
                 GetUndoChecked(chainman.m_blockman, pindex);
 
             // Calculate everything if nothing selected (default)
             const bool do_all = stats.size() == 0;
             const bool do_mediantxsize =
                 do_all || stats.count("mediantxsize") != 0;
             const bool do_medianfee = do_all || stats.count("medianfee") != 0;
             const bool do_medianfeerate =
                 do_all || stats.count("medianfeerate") != 0;
             const bool loop_inputs =
                 do_all || do_medianfee || do_medianfeerate ||
                 SetHasKeys(stats, "utxo_size_inc", "totalfee", "avgfee",
                            "avgfeerate", "minfee", "maxfee", "minfeerate",
                            "maxfeerate");
             const bool loop_outputs =
                 do_all || loop_inputs || stats.count("total_out");
             const bool do_calculate_size =
                 do_mediantxsize || loop_inputs ||
                 SetHasKeys(stats, "total_size", "avgtxsize", "mintxsize",
                            "maxtxsize");
 
             const int64_t blockMaxSize = config.GetMaxBlockSize();
             Amount maxfee = Amount::zero();
             Amount maxfeerate = Amount::zero();
             Amount minfee = MAX_MONEY;
             Amount minfeerate = MAX_MONEY;
             Amount total_out = Amount::zero();
             Amount totalfee = Amount::zero();
             int64_t inputs = 0;
             int64_t maxtxsize = 0;
             int64_t mintxsize = blockMaxSize;
             int64_t outputs = 0;
             int64_t total_size = 0;
             int64_t utxo_size_inc = 0;
             std::vector<Amount> fee_array;
             std::vector<Amount> feerate_array;
             std::vector<int64_t> txsize_array;
 
             for (size_t i = 0; i < block.vtx.size(); ++i) {
                 const auto &tx = block.vtx.at(i);
                 outputs += tx->vout.size();
                 Amount tx_total_out = Amount::zero();
                 if (loop_outputs) {
                     for (const CTxOut &out : tx->vout) {
                         tx_total_out += out.nValue;
                         utxo_size_inc +=
                             GetSerializeSize(out, PROTOCOL_VERSION) +
                             PER_UTXO_OVERHEAD;
                     }
                 }
 
                 if (tx->IsCoinBase()) {
                     continue;
                 }
 
                 // Don't count coinbase's fake input
                 inputs += tx->vin.size();
                 // Don't count coinbase reward
                 total_out += tx_total_out;
 
                 int64_t tx_size = 0;
                 if (do_calculate_size) {
                     tx_size = tx->GetTotalSize();
                     if (do_mediantxsize) {
                         txsize_array.push_back(tx_size);
                     }
                     maxtxsize = std::max(maxtxsize, tx_size);
                     mintxsize = std::min(mintxsize, tx_size);
                     total_size += tx_size;
                 }
 
                 if (loop_inputs) {
                     Amount tx_total_in = Amount::zero();
                     const auto &txundo = blockUndo.vtxundo.at(i - 1);
                     for (const Coin &coin : txundo.vprevout) {
                         const CTxOut &prevoutput = coin.GetTxOut();
 
                         tx_total_in += prevoutput.nValue;
                         utxo_size_inc -=
                             GetSerializeSize(prevoutput, PROTOCOL_VERSION) +
                             PER_UTXO_OVERHEAD;
                     }
 
                     Amount txfee = tx_total_in - tx_total_out;
                     CHECK_NONFATAL(MoneyRange(txfee));
                     if (do_medianfee) {
                         fee_array.push_back(txfee);
                     }
                     maxfee = std::max(maxfee, txfee);
                     minfee = std::min(minfee, txfee);
                     totalfee += txfee;
 
                     Amount feerate = txfee / tx_size;
                     if (do_medianfeerate) {
                         feerate_array.push_back(feerate);
                     }
                     maxfeerate = std::max(maxfeerate, feerate);
                     minfeerate = std::min(minfeerate, feerate);
                 }
             }
 
             UniValue ret_all(UniValue::VOBJ);
             ret_all.pushKV("avgfee",
                            block.vtx.size() > 1
                                ? (totalfee / int((block.vtx.size() - 1)))
                                : Amount::zero());
             ret_all.pushKV("avgfeerate", total_size > 0
                                              ? (totalfee / total_size)
                                              : Amount::zero());
             ret_all.pushKV("avgtxsize",
                            (block.vtx.size() > 1)
                                ? total_size / (block.vtx.size() - 1)
                                : 0);
             ret_all.pushKV("blockhash", pindex->GetBlockHash().GetHex());
             ret_all.pushKV("height", (int64_t)pindex->nHeight);
             ret_all.pushKV("ins", inputs);
             ret_all.pushKV("maxfee", maxfee);
             ret_all.pushKV("maxfeerate", maxfeerate);
             ret_all.pushKV("maxtxsize", maxtxsize);
             ret_all.pushKV("medianfee", CalculateTruncatedMedian(fee_array));
             ret_all.pushKV("medianfeerate",
                            CalculateTruncatedMedian(feerate_array));
             ret_all.pushKV("mediantime", pindex->GetMedianTimePast());
             ret_all.pushKV("mediantxsize",
                            CalculateTruncatedMedian(txsize_array));
             ret_all.pushKV("minfee",
                            minfee == MAX_MONEY ? Amount::zero() : minfee);
             ret_all.pushKV("minfeerate", minfeerate == MAX_MONEY
                                              ? Amount::zero()
                                              : minfeerate);
             ret_all.pushKV("mintxsize",
                            mintxsize == blockMaxSize ? 0 : mintxsize);
             ret_all.pushKV("outs", outputs);
             ret_all.pushKV("subsidy", GetBlockSubsidy(pindex->nHeight,
                                                       Params().GetConsensus()));
             ret_all.pushKV("time", pindex->GetBlockTime());
             ret_all.pushKV("total_out", total_out);
             ret_all.pushKV("total_size", total_size);
             ret_all.pushKV("totalfee", totalfee);
             ret_all.pushKV("txs", (int64_t)block.vtx.size());
             ret_all.pushKV("utxo_increase", outputs - inputs);
             ret_all.pushKV("utxo_size_inc", utxo_size_inc);
 
             if (do_all) {
                 return ret_all;
             }
 
             UniValue ret(UniValue::VOBJ);
             for (const std::string &stat : stats) {
                 const UniValue &value = ret_all[stat];
                 if (value.isNull()) {
                     throw JSONRPCError(
                         RPC_INVALID_PARAMETER,
                         strprintf("Invalid selected statistic %s", stat));
                 }
                 ret.pushKV(stat, value);
             }
             return ret;
         },
     };
 }
 
 static RPCHelpMan savemempool() {
     return RPCHelpMan{
         "savemempool",
         "Dumps the mempool to disk. It will fail until the previous dump is "
         "fully loaded.\n",
         {},
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR, "filename",
                        "the directory and file where the mempool was saved"},
                   }},
         RPCExamples{HelpExampleCli("savemempool", "") +
                     HelpExampleRpc("savemempool", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             const CTxMemPool &mempool = EnsureAnyMemPool(request.context);
 
             const NodeContext &node = EnsureAnyNodeContext(request.context);
 
             if (!mempool.IsLoaded()) {
                 throw JSONRPCError(RPC_MISC_ERROR,
                                    "The mempool was not loaded yet");
             }
 
             if (!DumpMempool(mempool)) {
                 throw JSONRPCError(RPC_MISC_ERROR,
                                    "Unable to dump mempool to disk");
             }
 
             UniValue ret(UniValue::VOBJ);
             ret.pushKV("filename",
                        fs::path((node.args->GetDataDirNet() / "mempool.dat"))
                            .u8string());
 
             return ret;
         },
     };
 }
 
 namespace {
 //! Search for a given set of pubkey scripts
 static bool FindScriptPubKey(std::atomic<int> &scan_progress,
                              const std::atomic<bool> &should_abort,
                              int64_t &count, CCoinsViewCursor *cursor,
                              const std::set<CScript> &needles,
                              std::map<COutPoint, Coin> &out_results,
                              std::function<void()> &interruption_point) {
     scan_progress = 0;
     count = 0;
     while (cursor->Valid()) {
         COutPoint key;
         Coin coin;
         if (!cursor->GetKey(key) || !cursor->GetValue(coin)) {
             return false;
         }
         if (++count % 8192 == 0) {
             interruption_point();
             if (should_abort) {
                 // allow to abort the scan via the abort reference
                 return false;
             }
         }
         if (count % 256 == 0) {
             // update progress reference every 256 item
             const TxId &txid = key.GetTxId();
             uint32_t high = 0x100 * *txid.begin() + *(txid.begin() + 1);
             scan_progress = int(high * 100.0 / 65536.0 + 0.5);
         }
         if (needles.count(coin.GetTxOut().scriptPubKey)) {
             out_results.emplace(key, coin);
         }
         cursor->Next();
     }
     scan_progress = 100;
     return true;
 }
 } // namespace
 
 /** RAII object to prevent concurrency issue when scanning the txout set */
 static std::atomic<int> g_scan_progress;
 static std::atomic<bool> g_scan_in_progress;
 static std::atomic<bool> g_should_abort_scan;
 class CoinsViewScanReserver {
 private:
     bool m_could_reserve;
 
 public:
     explicit CoinsViewScanReserver() : m_could_reserve(false) {}
 
     bool reserve() {
         CHECK_NONFATAL(!m_could_reserve);
         if (g_scan_in_progress.exchange(true)) {
             return false;
         }
         m_could_reserve = true;
         return true;
     }
 
     ~CoinsViewScanReserver() {
         if (m_could_reserve) {
             g_scan_in_progress = false;
         }
     }
 };
 
 static RPCHelpMan scantxoutset() {
     const auto &ticker = Currency::get().ticker;
     return RPCHelpMan{
         "scantxoutset",
         "Scans the unspent transaction output set for entries that match "
         "certain output descriptors.\n"
         "Examples of output descriptors are:\n"
         "    addr(<address>)                      Outputs whose scriptPubKey "
         "corresponds to the specified address (does not include P2PK)\n"
         "    raw(<hex script>)                    Outputs whose scriptPubKey "
         "equals the specified hex scripts\n"
         "    combo(<pubkey>)                      P2PK and P2PKH outputs for "
         "the given pubkey\n"
         "    pkh(<pubkey>)                        P2PKH outputs for the given "
         "pubkey\n"
         "    sh(multi(<n>,<pubkey>,<pubkey>,...)) P2SH-multisig outputs for "
         "the given threshold and pubkeys\n"
         "\nIn the above, <pubkey> either refers to a fixed public key in "
         "hexadecimal notation, or to an xpub/xprv optionally followed by one\n"
         "or more path elements separated by \"/\", and optionally ending in "
         "\"/*\" (unhardened), or \"/*'\" or \"/*h\" (hardened) to specify all\n"
         "unhardened or hardened child keys.\n"
         "In the latter case, a range needs to be specified by below if "
         "different from 1000.\n"
         "For more information on output descriptors, see the documentation in "
         "the doc/descriptors.md file.\n",
         {
             {"action", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The action to execute\n"
              "                                      \"start\" for starting a "
              "scan\n"
              "                                      \"abort\" for aborting the "
              "current scan (returns true when abort was successful)\n"
              "                                      \"status\" for "
              "progress report (in %) of the current scan"},
             {"scanobjects",
              RPCArg::Type::ARR,
              RPCArg::Optional::OMITTED,
              "Array of scan objects. Required for \"start\" action\n"
              "                                  Every scan object is either a "
              "string descriptor or an object:",
              {
                  {"descriptor", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
                   "An output descriptor"},
                  {
                      "",
                      RPCArg::Type::OBJ,
                      RPCArg::Optional::OMITTED,
                      "An object with output descriptor and metadata",
                      {
                          {"desc", RPCArg::Type::STR, RPCArg::Optional::NO,
                           "An output descriptor"},
                          {"range", RPCArg::Type::RANGE, /* default */ "1000",
                           "The range of HD chain indexes to explore (either "
                           "end or [begin,end])"},
                      },
                  },
              },
              "[scanobjects,...]"},
         },
         {
             RPCResult{"When action=='abort'", RPCResult::Type::BOOL, "", ""},
             RPCResult{"When action=='status' and no scan is in progress",
                       RPCResult::Type::NONE, "", ""},
             RPCResult{
                 "When action=='status' and scan is in progress",
                 RPCResult::Type::OBJ,
                 "",
                 "",
                 {
                     {RPCResult::Type::NUM, "progress", "The scan progress"},
                 }},
             RPCResult{
                 "When action=='start'",
                 RPCResult::Type::OBJ,
                 "",
                 "",
                 {
                     {RPCResult::Type::BOOL, "success",
                      "Whether the scan was completed"},
                     {RPCResult::Type::NUM, "txouts",
                      "The number of unspent transaction outputs scanned"},
                     {RPCResult::Type::NUM, "height",
                      "The current block height (index)"},
                     {RPCResult::Type::STR_HEX, "bestblock",
                      "The hash of the block at the tip of the chain"},
                     {RPCResult::Type::ARR,
                      "unspents",
                      "",
                      {
                          {RPCResult::Type::OBJ,
                           "",
                           "",
                           {
                               {RPCResult::Type::STR_HEX, "txid",
                                "The transaction id"},
                               {RPCResult::Type::NUM, "vout", "The vout value"},
                               {RPCResult::Type::STR_HEX, "scriptPubKey",
                                "The script key"},
                               {RPCResult::Type::STR, "desc",
                                "A specialized descriptor for the matched "
                                "scriptPubKey"},
                               {RPCResult::Type::STR_AMOUNT, "amount",
                                "The total amount in " + ticker +
                                    " of the unspent output"},
                               {RPCResult::Type::NUM, "height",
                                "Height of the unspent transaction output"},
                           }},
                      }},
                     {RPCResult::Type::STR_AMOUNT, "total_amount",
                      "The total amount of all found unspent outputs in " +
                          ticker},
                 }},
         },
         RPCExamples{""},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             RPCTypeCheck(request.params, {UniValue::VSTR, UniValue::VARR});
 
             UniValue result(UniValue::VOBJ);
             if (request.params[0].get_str() == "status") {
                 CoinsViewScanReserver reserver;
                 if (reserver.reserve()) {
                     // no scan in progress
                     return NullUniValue;
                 }
                 result.pushKV("progress", g_scan_progress.load());
                 return result;
             } else if (request.params[0].get_str() == "abort") {
                 CoinsViewScanReserver reserver;
                 if (reserver.reserve()) {
                     // reserve was possible which means no scan was running
                     return false;
                 }
                 // set the abort flag
                 g_should_abort_scan = true;
                 return true;
             } else if (request.params[0].get_str() == "start") {
                 CoinsViewScanReserver reserver;
                 if (!reserver.reserve()) {
                     throw JSONRPCError(RPC_INVALID_PARAMETER,
                                        "Scan already in progress, use action "
                                        "\"abort\" or \"status\"");
                 }
 
                 if (request.params.size() < 2) {
                     throw JSONRPCError(RPC_MISC_ERROR,
                                        "scanobjects argument is required for "
                                        "the start action");
                 }
 
                 std::set<CScript> needles;
                 std::map<CScript, std::string> descriptors;
                 Amount total_in = Amount::zero();
 
                 // loop through the scan objects
                 for (const UniValue &scanobject :
                      request.params[1].get_array().getValues()) {
                     FlatSigningProvider provider;
                     auto scripts =
                         EvalDescriptorStringOrObject(scanobject, provider);
                     for (const auto &script : scripts) {
                         std::string inferred =
                             InferDescriptor(script, provider)->ToString();
                         needles.emplace(script);
                         descriptors.emplace(std::move(script),
                                             std::move(inferred));
                     }
                 }
 
                 // Scan the unspent transaction output set for inputs
                 UniValue unspents(UniValue::VARR);
                 std::vector<CTxOut> input_txos;
                 std::map<COutPoint, Coin> coins;
                 g_should_abort_scan = false;
                 g_scan_progress = 0;
                 int64_t count = 0;
                 std::unique_ptr<CCoinsViewCursor> pcursor;
                 const CBlockIndex *tip;
                 NodeContext &node = EnsureAnyNodeContext(request.context);
                 {
                     ChainstateManager &chainman = EnsureChainman(node);
                     LOCK(cs_main);
                     CChainState &active_chainstate =
                         chainman.ActiveChainstate();
                     active_chainstate.ForceFlushStateToDisk();
                     pcursor = std::unique_ptr<CCoinsViewCursor>(
                         active_chainstate.CoinsDB().Cursor());
                     CHECK_NONFATAL(pcursor);
                     tip = active_chainstate.m_chain.Tip();
                     CHECK_NONFATAL(tip);
                 }
                 bool res = FindScriptPubKey(
                     g_scan_progress, g_should_abort_scan, count, pcursor.get(),
                     needles, coins, node.rpc_interruption_point);
                 result.pushKV("success", res);
                 result.pushKV("txouts", count);
                 result.pushKV("height", tip->nHeight);
                 result.pushKV("bestblock", tip->GetBlockHash().GetHex());
 
                 for (const auto &it : coins) {
                     const COutPoint &outpoint = it.first;
                     const Coin &coin = it.second;
                     const CTxOut &txo = coin.GetTxOut();
                     input_txos.push_back(txo);
                     total_in += txo.nValue;
 
                     UniValue unspent(UniValue::VOBJ);
                     unspent.pushKV("txid", outpoint.GetTxId().GetHex());
                     unspent.pushKV("vout", int32_t(outpoint.GetN()));
                     unspent.pushKV("scriptPubKey", HexStr(txo.scriptPubKey));
                     unspent.pushKV("desc", descriptors[txo.scriptPubKey]);
                     unspent.pushKV("amount", txo.nValue);
                     unspent.pushKV("height", int32_t(coin.GetHeight()));
 
                     unspents.push_back(unspent);
                 }
                 result.pushKV("unspents", unspents);
                 result.pushKV("total_amount", total_in);
             } else {
                 throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid command");
             }
             return result;
         },
     };
 }
 
 static RPCHelpMan getblockfilter() {
     return RPCHelpMan{
         "getblockfilter",
         "Retrieve a BIP 157 content filter for a particular block.\n",
         {
             {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The hash of the block"},
             {"filtertype", RPCArg::Type::STR, /*default*/ "basic",
              "The type name of the filter"},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR_HEX, "filter",
                        "the hex-encoded filter data"},
                       {RPCResult::Type::STR_HEX, "header",
                        "the hex-encoded filter header"},
                   }},
         RPCExamples{
             HelpExampleCli("getblockfilter",
                            "\"00000000c937983704a73af28acdec37b049d214a"
                            "dbda81d7e2a3dd146f6ed09\" \"basic\"") +
             HelpExampleRpc("getblockfilter",
                            "\"00000000c937983704a73af28acdec37b049d214adbda81d7"
                            "e2a3dd146f6ed09\", \"basic\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             const BlockHash block_hash(
                 ParseHashV(request.params[0], "blockhash"));
             std::string filtertype_name = "basic";
             if (!request.params[1].isNull()) {
                 filtertype_name = request.params[1].get_str();
             }
 
             BlockFilterType filtertype;
             if (!BlockFilterTypeByName(filtertype_name, filtertype)) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                    "Unknown filtertype");
             }
 
             BlockFilterIndex *index = GetBlockFilterIndex(filtertype);
             if (!index) {
                 throw JSONRPCError(RPC_MISC_ERROR,
                                    "Index is not enabled for filtertype " +
                                        filtertype_name);
             }
 
             const CBlockIndex *block_index;
             bool block_was_connected;
             {
                 ChainstateManager &chainman =
                     EnsureAnyChainman(request.context);
                 LOCK(cs_main);
                 block_index = chainman.m_blockman.LookupBlockIndex(block_hash);
                 if (!block_index) {
                     throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                        "Block not found");
                 }
                 block_was_connected =
                     block_index->IsValid(BlockValidity::SCRIPTS);
             }
 
             bool index_ready = index->BlockUntilSyncedToCurrentChain();
 
             BlockFilter filter;
             uint256 filter_header;
             if (!index->LookupFilter(block_index, filter) ||
                 !index->LookupFilterHeader(block_index, filter_header)) {
                 int err_code;
                 std::string errmsg = "Filter not found.";
 
                 if (!block_was_connected) {
                     err_code = RPC_INVALID_ADDRESS_OR_KEY;
                     errmsg += " Block was not connected to active chain.";
                 } else if (!index_ready) {
                     err_code = RPC_MISC_ERROR;
                     errmsg += " Block filters are still in the process of "
                               "being indexed.";
                 } else {
                     err_code = RPC_INTERNAL_ERROR;
                     errmsg += " This error is unexpected and indicates index "
                               "corruption.";
                 }
 
                 throw JSONRPCError(err_code, errmsg);
             }
 
             UniValue ret(UniValue::VOBJ);
             ret.pushKV("filter", HexStr(filter.GetEncodedFilter()));
             ret.pushKV("header", filter_header.GetHex());
             return ret;
         },
     };
 }
 
 /**
  * Serialize the UTXO set to a file for loading elsewhere.
  *
  * @see SnapshotMetadata
  */
 static RPCHelpMan dumptxoutset() {
     return RPCHelpMan{
         "dumptxoutset",
         "Write the serialized UTXO set to disk.\n",
         {
             {"path", RPCArg::Type::STR, RPCArg::Optional::NO,
              "path to the output file. If relative, will be prefixed by "
              "datadir."},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::NUM, "coins_written",
                        "the number of coins written in the snapshot"},
                       {RPCResult::Type::STR_HEX, "base_hash",
                        "the hash of the base of the snapshot"},
                       {RPCResult::Type::NUM, "base_height",
                        "the height of the base of the snapshot"},
                       {RPCResult::Type::STR, "path",
                        "the absolute path that the snapshot was written to"},
                   }},
         RPCExamples{HelpExampleCli("dumptxoutset", "utxo.dat")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             const fs::path path = fsbridge::AbsPathJoin(
                 gArgs.GetDataDirNet(), fs::u8path(request.params[0].get_str()));
             // Write to a temporary path and then move into `path` on completion
             // to avoid confusion due to an interruption.
             const fs::path temppath = fsbridge::AbsPathJoin(
                 gArgs.GetDataDirNet(),
                 fs::u8path(request.params[0].get_str() + ".incomplete"));
 
             if (fs::exists(path)) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    path.u8string() +
                                        " already exists. If you are sure this "
                                        "is what you want, "
                                        "move it out of the way first");
             }
 
             FILE *file{fsbridge::fopen(temppath, "wb")};
             CAutoFile afile{file, SER_DISK, CLIENT_VERSION};
             NodeContext &node = EnsureAnyNodeContext(request.context);
             UniValue result = CreateUTXOSnapshot(
                 node, node.chainman->ActiveChainstate(), afile);
             fs::rename(temppath, path);
 
             result.pushKV("path", path.u8string());
             return result;
         },
     };
 }
 
 UniValue CreateUTXOSnapshot(NodeContext &node, CChainState &chainstate,
                             CAutoFile &afile) {
     std::unique_ptr<CCoinsViewCursor> pcursor;
     CCoinsStats stats{CoinStatsHashType::NONE};
     const CBlockIndex *tip;
 
     {
         // We need to lock cs_main to ensure that the coinsdb isn't
         // written to between (i) flushing coins cache to disk
         // (coinsdb), (ii) getting stats based upon the coinsdb, and
         // (iii) constructing a cursor to the coinsdb for use below this
         // block.
         //
         // Cursors returned by leveldb iterate over snapshots, so the
         // contents of the pcursor will not be affected by simultaneous
         // writes during use below this block.
         //
         // See discussion here:
         //   https://github.com/bitcoin/bitcoin/pull/15606#discussion_r274479369
         //
         LOCK(::cs_main);
 
         chainstate.ForceFlushStateToDisk();
 
         if (!GetUTXOStats(&chainstate.CoinsDB(), chainstate.m_blockman, stats,
                           node.rpc_interruption_point)) {
             throw JSONRPCError(RPC_INTERNAL_ERROR, "Unable to read UTXO set");
         }
 
         pcursor =
             std::unique_ptr<CCoinsViewCursor>(chainstate.CoinsDB().Cursor());
         tip = chainstate.m_blockman.LookupBlockIndex(stats.hashBlock);
         CHECK_NONFATAL(tip);
     }
 
     SnapshotMetadata metadata{tip->GetBlockHash(), stats.coins_count,
                               uint64_t(tip->GetChainTxCount())};
 
     afile << metadata;
 
     COutPoint key;
     Coin coin;
     unsigned int iter{0};
 
     while (pcursor->Valid()) {
         if (iter % 5000 == 0) {
             node.rpc_interruption_point();
         }
         ++iter;
         if (pcursor->GetKey(key) && pcursor->GetValue(coin)) {
             afile << key;
             afile << coin;
         }
 
         pcursor->Next();
     }
 
     afile.fclose();
 
     UniValue result(UniValue::VOBJ);
     result.pushKV("coins_written", stats.coins_count);
     result.pushKV("base_hash", tip->GetBlockHash().ToString());
     result.pushKV("base_height", tip->nHeight);
     return result;
 }
 
 void RegisterBlockchainRPCCommands(CRPCTable &t) {
     // clang-format off
     static const CRPCCommand commands[] = {
         //  category            actor (function)
         //  ------------------  ----------------------
         { "blockchain",         getbestblockhash,                  },
         { "blockchain",         getblock,                          },
         { "blockchain",         getblockfrompeer,                  },
         { "blockchain",         getblockchaininfo,                 },
         { "blockchain",         getblockcount,                     },
         { "blockchain",         getblockhash,                      },
         { "blockchain",         getblockheader,                    },
         { "blockchain",         getblockstats,                     },
         { "blockchain",         getchaintips,                      },
         { "blockchain",         getchaintxstats,                   },
         { "blockchain",         getdifficulty,                     },
         { "blockchain",         getmempoolancestors,               },
         { "blockchain",         getmempooldescendants,             },
         { "blockchain",         getmempoolentry,                   },
         { "blockchain",         getmempoolinfo,                    },
         { "blockchain",         getrawmempool,                     },
         { "blockchain",         gettxout,                          },
         { "blockchain",         gettxoutsetinfo,                   },
         { "blockchain",         pruneblockchain,                   },
         { "blockchain",         savemempool,                       },
         { "blockchain",         verifychain,                       },
         { "blockchain",         preciousblock,                     },
         { "blockchain",         scantxoutset,                      },
         { "blockchain",         getblockfilter,                    },
 
         /* Not shown in help */
-        { "hidden",             getfinalizedblockhash,             },
-        { "hidden",             finalizeblock,                     },
         { "hidden",             invalidateblock,                   },
         { "hidden",             parkblock,                         },
         { "hidden",             reconsiderblock,                   },
         { "hidden",             syncwithvalidationinterfacequeue,  },
         { "hidden",             dumptxoutset,                      },
         { "hidden",             unparkblock,                       },
         { "hidden",             waitfornewblock,                   },
         { "hidden",             waitforblock,                      },
         { "hidden",             waitforblockheight,                },
     };
     // clang-format on
     for (const auto &c : commands) {
         t.appendCommand(c.name, &c);
     }
 }
diff --git a/src/test/CMakeLists.txt b/src/test/CMakeLists.txt
index ae04c0b03..e3c988b8b 100644
--- a/src/test/CMakeLists.txt
+++ b/src/test/CMakeLists.txt
@@ -1,300 +1,299 @@
 # Copyright (c) 2018 The Bitcoin developers
 
 project(bitcoin-test)
 
 # Process json files.
 file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/data")
 
 function(gen_json_header NAME)
 	set(HEADERS "")
 	foreach(f ${ARGN})
 		set(h "${CMAKE_CURRENT_BINARY_DIR}/${f}.h")
 
 		# Get the proper name for the test variable.
 		get_filename_component(TEST_NAME ${f} NAME_WE)
 		add_custom_command(OUTPUT ${h}
 			COMMAND
 				"${Python_EXECUTABLE}"
 				"${CMAKE_CURRENT_SOURCE_DIR}/data/generate_header.py"
 				"${TEST_NAME}"
 				"${CMAKE_CURRENT_SOURCE_DIR}/${f}" > ${h}
 			MAIN_DEPENDENCY ${f}
 			DEPENDS
 				"data/generate_header.py"
 			VERBATIM
 		)
 		list(APPEND HEADERS ${h})
 	endforeach(f)
 	set(${NAME} "${HEADERS}" PARENT_SCOPE)
 endfunction()
 
 gen_json_header(JSON_HEADERS
 	data/base58_encode_decode.json
 	data/blockfilters.json
 	data/key_io_valid.json
 	data/key_io_invalid.json
 	data/script_tests.json
 	data/sighash.json
 	data/tx_invalid.json
 	data/tx_valid.json
 )
 
 include(TestSuite)
 create_test_suite(bitcoin)
 add_dependencies(check check-bitcoin)
 
 # An utility library for bitcoin related test suites.
 add_library(testutil OBJECT
 	util/blockfilter.cpp
 	util/logging.cpp
 	util/mining.cpp
 	util/net.cpp
 	util/setup_common.cpp
 	util/str.cpp
 	util/transaction_utils.cpp
 	util/wallet.cpp
 )
 
 target_link_libraries(testutil server)
 
 if(BUILD_BITCOIN_WALLET)
 	set(BITCOIN_WALLET_TEST_FIXTURE
 		../wallet/test/init_test_fixture.cpp
 		../wallet/test/wallet_test_fixture.cpp
 	)
 	set(BITCOIN_WALLET_TESTS
 		../wallet/test/db_tests.cpp
 		../wallet/test/coinselector_tests.cpp
 		../wallet/test/init_tests.cpp
 		../wallet/test/ismine_tests.cpp
 		../wallet/test/psbt_wallet_tests.cpp
 		../wallet/test/scriptpubkeyman_tests.cpp
 		../wallet/test/wallet_tests.cpp
 		../wallet/test/walletdb_tests.cpp
 		../wallet/test/wallet_crypto_tests.cpp
 	)
 endif()
 
 function(gen_asmap_headers HEADERS_VAR)
 	foreach(INPUT_FILE ${ARGN})
 		set(OUTPUT_FILE "${CMAKE_CURRENT_BINARY_DIR}/${INPUT_FILE}.h")
 
 		add_custom_command(
 			OUTPUT "${OUTPUT_FILE}"
 			COMMENT "Generate ASMAP header from ${INPUT_FILE}"
 			COMMAND
 				"${Python_EXECUTABLE}"
 				"${CMAKE_CURRENT_SOURCE_DIR}/data/generate_asmap.py"
 				"${CMAKE_CURRENT_SOURCE_DIR}/${INPUT_FILE}"
 				"${OUTPUT_FILE}"
 			MAIN_DEPENDENCY "${INPUT_FILE}"
 			DEPENDS
 				"data/generate_header.py"
 			VERBATIM
 		)
 		list(APPEND ${HEADERS_VAR} "${OUTPUT_FILE}")
 	endforeach()
 	set(${HEADERS_VAR} ${${HEADERS_VAR}} PARENT_SCOPE)
 endfunction()
 
 gen_asmap_headers(ASMAP_HEADERS
 	data/asmap.raw
 )
 
 if(BUILD_BITCOIN_CHRONIK)
 	set(BITCOIN_CHRONIK_TESTS
 		../../chronik/test/chronikbridge_tests.cpp
 	)
 endif()
 
 add_boost_unit_tests_to_suite(bitcoin test_bitcoin
 	fixture.cpp
 	jsonutil.cpp
 	scriptflags.cpp
 	sigutil.cpp
 
 	${ASMAP_HEADERS}
 
 	# Tests generated from JSON
 	${JSON_HEADERS}
 
 	# Wallet test fixture
 	${BITCOIN_WALLET_TEST_FIXTURE}
 
 	TESTS
 		activation_tests.cpp
 		addrman_tests.cpp
 		allocator_tests.cpp
 		amount_tests.cpp
 		arith_uint256_tests.cpp
 		base32_tests.cpp
 		base58_tests.cpp
 		base64_tests.cpp
 		bip32_tests.cpp
 		bitmanip_tests.cpp
 		blockchain_tests.cpp
 		blockcheck_tests.cpp
 		blockencodings_tests.cpp
 		blockfilter_tests.cpp
 		blockfilter_index_tests.cpp
 		blockindex_tests.cpp
 		blockstatus_tests.cpp
 		bloom_tests.cpp
 		bswap_tests.cpp
 		cashaddr_tests.cpp
 		cashaddrenc_tests.cpp
 		checkdatasig_tests.cpp
 		checkpoints_tests.cpp
 		checkqueue_tests.cpp
 		coins_tests.cpp
 		coinstatsindex_tests.cpp
 		compilerbug_tests.cpp
 		compress_tests.cpp
 		config_tests.cpp
 		core_io_tests.cpp
 		crypto_tests.cpp
 		cuckoocache_tests.cpp
 		dbwrapper_tests.cpp
 		denialofservice_tests.cpp
 		descriptor_tests.cpp
 		dnsseeds_tests.cpp
 		dstencode_tests.cpp
 		feerate_tests.cpp
-		finalization_tests.cpp
 		flatfile_tests.cpp
 		fs_tests.cpp
 		getarg_tests.cpp
 		hash_tests.cpp
 		i2p_tests.cpp
 		interfaces_tests.cpp
 		intmath_tests.cpp
 		inv_tests.cpp
 		key_io_tests.cpp
 		key_tests.cpp
 		lcg_tests.cpp
 		logging_tests.cpp
 		mempool_tests.cpp
 		merkle_tests.cpp
 		merkleblock_tests.cpp
 		miner_tests.cpp
 		monolith_opcodes_tests.cpp
 		multisig_tests.cpp
 		net_peer_eviction_tests.cpp
 		net_tests.cpp
 		netbase_tests.cpp
 		op_reversebytes_tests.cpp
 		pmt_tests.cpp
 		policy_fee_tests.cpp
 		policyestimator_tests.cpp
 		prevector_tests.cpp
 		radix_tests.cpp
 		raii_event_tests.cpp
 		random_tests.cpp
 		rcu_tests.cpp
 		reverselock_tests.cpp
 		rpc_tests.cpp
 		rpc_server_tests.cpp
 		rwcollection_tests.cpp
 		sanity_tests.cpp
 		scheduler_tests.cpp
 		schnorr_tests.cpp
 		script_bitfield_tests.cpp
 		script_commitment_tests.cpp
 		script_p2sh_tests.cpp
 		script_standard_tests.cpp
 		script_tests.cpp
 		scriptnum_tests.cpp
 		serialize_tests.cpp
 		settings_tests.cpp
 		shortidprocessor_tests.cpp
 		sigcache_tests.cpp
 		sigencoding_tests.cpp
 		sighash_tests.cpp
 		sighashtype_tests.cpp
 		sigcheckcount_tests.cpp
 		skiplist_tests.cpp
 		sock_tests.cpp
 		streams_tests.cpp
 		sync_tests.cpp
 		timedata_tests.cpp
 		torcontrol_tests.cpp
 		transaction_tests.cpp
 		txindex_tests.cpp
 		txpackage_tests.cpp
 		txrequest_tests.cpp
 		txvalidation_tests.cpp
 		txvalidationcache_tests.cpp
 		uint256_tests.cpp
 		undo_tests.cpp
 		util_tests.cpp
 		util_threadnames_tests.cpp
 		validation_block_tests.cpp
 		validation_chainstate_tests.cpp
 		validation_chainstatemanager_tests.cpp
 		validation_flush_tests.cpp
 		validation_tests.cpp
 		validationinterface_tests.cpp
 		versionbits_tests.cpp
         blockindex_comparator_tests.cpp
 
 		# RPC Tests
 		../rpc/test/server_tests.cpp
 
 		# Wallet tests
 		${BITCOIN_WALLET_TESTS}
 
 		# Chronik tests
 		${BITCOIN_CHRONIK_TESTS}
 )
 
 function(add_boost_test_runners_with_upgrade_activated SUITE EXECUTABLE)
 	set(SUITE_UPGRADE_ACTIVATED "${SUITE}-upgrade-activated")
 	get_target_from_suite(${SUITE_UPGRADE_ACTIVATED} TARGET_UPGRADE_ACTIVATED)
 
 	if(NOT TARGET ${TARGET_UPGRADE_ACTIVATED})
 		create_test_suite_with_parent_targets(
 			${SUITE_UPGRADE_ACTIVATED}
 			check-upgrade-activated
 			check-upgrade-activated-extended
 		)
 		add_dependencies(${TARGET_UPGRADE_ACTIVATED} ${EXECUTABLE})
 	endif()
 
 	get_target_from_suite(${SUITE} SUITE_TARGET)
 	get_target_property(BOOST_TESTS ${SUITE_TARGET} UNIT_TESTS)
 
 	get_target_from_suite(${SUITE_UPGRADE_ACTIVATED} SUITE_UPGRADE_ACTIVATED_TARGET)
 
 	set(HRF_LOGGER "HRF,test_suite")
 
 	foreach(_test_name ${BOOST_TESTS})
 		if(ENABLE_JUNIT_REPORT)
 			set(JUNIT_LOGGER ":JUNIT,message,${SUITE_UPGRADE_ACTIVATED}-${_test_name}.xml")
 		endif()
 
 		add_test_runner(
 			${SUITE_UPGRADE_ACTIVATED}
 			"${_test_name}"
 			${EXECUTABLE}
 			JUNIT
 			"--run_test=${_test_name}"
 			"--logger=${HRF_LOGGER}${JUNIT_LOGGER}"
 			"--catch_system_errors=no"
 			--
 			"-testsuitename=Bitcoin ABC unit tests with next upgrade activated"
 			# Sep. 20th, 2022 at 12:00:00
 			-wellingtonactivationtime=1663675200
 		)
 	endforeach()
 endfunction()
 
 add_boost_test_runners_with_upgrade_activated(bitcoin test_bitcoin)
 
 target_link_libraries(test_bitcoin rpcclient testutil)
 if(TARGET bitcoinconsensus-shared)
 	target_link_libraries(test_bitcoin bitcoinconsensus-shared)
 else()
 	target_link_libraries(test_bitcoin bitcoinconsensus)
 endif()
 
 add_subdirectory(fuzz)
diff --git a/src/test/finalization_tests.cpp b/src/test/finalization_tests.cpp
deleted file mode 100644
index 48ad93f5e..000000000
--- a/src/test/finalization_tests.cpp
+++ /dev/null
@@ -1,106 +0,0 @@
-// Copyright (c) 2018-2019 The Bitcoin developers
-// Distributed under the MIT software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#include <chain.h>
-#include <chainparams.h>
-#include <config.h>
-#include <util/time.h>
-#include <validation.h>
-
-#include <test/util/setup_common.h>
-
-#include <boost/test/unit_test.hpp>
-
-BOOST_FIXTURE_TEST_SUITE(finalization_tests, TestChain100Setup)
-
-BOOST_AUTO_TEST_CASE(finalizationDelay) {
-    CScript p2pk_scriptPubKey =
-        CScript() << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
-    CBlock block;
-
-    {
-        LOCK(cs_main);
-        // We should have no finalized block because the 100 blocks generated by
-        // the deterministic test setup were created before the startup time;
-        BOOST_CHECK_MESSAGE(
-            m_node.chainman->ActiveChainstate().GetFinalizedBlock() == nullptr,
-            "No block finalized (tip at height "
-                << m_node.chainman->ActiveHeight() << ")");
-    }
-
-    // CChainState::FindBlockToFinalize takes both the mockable time and the
-    // startup time (not mockable) into account to decide if a block is mature
-    // enough for finalization.
-    int64_t mockedTime = std::max<int64_t>(GetTime(), GetStartupTime());
-    SetMockTime(mockedTime);
-
-    // Create maxreorgdepth blocks. Auto-finalization will not occur because
-    // the delay is not expired
-    for (uint32_t i = 0; i < DEFAULT_MAX_REORG_DEPTH; i++) {
-        block = CreateAndProcessBlock({}, p2pk_scriptPubKey);
-        LOCK(cs_main);
-        // These blocks are too recent.
-        BOOST_CHECK_MESSAGE(
-            m_node.chainman->ActiveChainstate().GetFinalizedBlock() == nullptr,
-            "No block finalized (tip at height "
-                << m_node.chainman->ActiveHeight() << ")");
-    }
-
-    // Make the finalization time to expire
-    mockedTime += DEFAULT_MIN_FINALIZATION_DELAY + 1;
-    SetMockTime(mockedTime);
-
-    // Next maxreorgdepth blocks should cause auto-finalization
-    CBlockIndex *blockToFinalize = m_node.chainman->ActiveTip()->GetAncestor(
-        m_node.chainman->ActiveHeight() - DEFAULT_MAX_REORG_DEPTH);
-
-    for (uint32_t i = 0; i < DEFAULT_MAX_REORG_DEPTH; i++) {
-        blockToFinalize = m_node.chainman->ActiveChain().Next(blockToFinalize);
-        block = CreateAndProcessBlock({}, p2pk_scriptPubKey);
-        LOCK(cs_main);
-        BOOST_CHECK_MESSAGE(
-            m_node.chainman->ActiveChainstate().GetFinalizedBlock() ==
-                blockToFinalize,
-            "Block finalized at height "
-                << blockToFinalize->nHeight << " (tip at height "
-                << m_node.chainman->ActiveHeight() << ")");
-    }
-
-    // Next blocks won't cause auto-finalization because the delay is not
-    // expired
-    for (uint32_t i = 0; i < DEFAULT_MAX_REORG_DEPTH; i++) {
-        block = CreateAndProcessBlock({}, p2pk_scriptPubKey);
-        LOCK(cs_main);
-        // These blocks are finalized.
-        BOOST_CHECK_MESSAGE(
-            m_node.chainman->ActiveChainstate().GetFinalizedBlock() ==
-                blockToFinalize,
-            "Finalized block remains unchanged at height "
-                << blockToFinalize->nHeight << " (tip at height "
-                << m_node.chainman->ActiveHeight() << ")");
-    }
-
-    // Make the finalization time to expire
-    mockedTime += DEFAULT_MIN_FINALIZATION_DELAY + 1;
-    SetMockTime(mockedTime);
-
-    blockToFinalize = m_node.chainman->ActiveTip()->GetAncestor(
-        m_node.chainman->ActiveHeight() - DEFAULT_MAX_REORG_DEPTH);
-
-    // Create some more blocks.
-    // Finalization should start moving again.
-    for (uint32_t i = 0; i < DEFAULT_MAX_REORG_DEPTH; i++) {
-        blockToFinalize = m_node.chainman->ActiveChain().Next(blockToFinalize);
-        block = CreateAndProcessBlock({}, p2pk_scriptPubKey);
-        LOCK(cs_main);
-        BOOST_CHECK_MESSAGE(
-            m_node.chainman->ActiveChainstate().GetFinalizedBlock() ==
-                blockToFinalize,
-            "Block finalized at height "
-                << blockToFinalize->nHeight << " (tip at height "
-                << m_node.chainman->ActiveHeight() << ")");
-    }
-}
-
-BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/validation.cpp b/src/validation.cpp
index eb0ed456d..54a553e36 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -1,6301 +1,6130 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2018 The Bitcoin Core developers
 // Copyright (c) 2017-2020 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <validation.h>
 
 #include <arith_uint256.h>
 #include <avalanche/avalanche.h>
 #include <avalanche/processor.h>
 #include <blockvalidity.h>
 #include <chainparams.h>
 #include <checkpoints.h>
 #include <checkqueue.h>
 #include <config.h>
 #include <consensus/activation.h>
 #include <consensus/amount.h>
 #include <consensus/merkle.h>
 #include <consensus/tx_check.h>
 #include <consensus/tx_verify.h>
 #include <consensus/validation.h>
 #include <deploymentstatus.h>
 #include <hash.h>
 #include <index/blockfilterindex.h>
 #include <logging.h>
 #include <logging/timer.h>
 #include <minerfund.h>
 #include <node/blockstorage.h>
 #include <node/coinstats.h>
 #include <node/ui_interface.h>
 #include <node/utxo_snapshot.h>
 #include <policy/mempool.h>
 #include <policy/policy.h>
 #include <policy/settings.h>
 #include <pow/pow.h>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
 #include <random.h>
 #include <reverse_iterator.h>
 #include <script/script.h>
 #include <script/scriptcache.h>
 #include <script/sigcache.h>
 #include <shutdown.h>
 #include <timedata.h>
 #include <tinyformat.h>
 #include <txdb.h>
 #include <txmempool.h>
 #include <undo.h>
 #include <util/check.h> // For NDEBUG compile time check
 #include <util/strencodings.h>
 #include <util/system.h>
 #include <util/trace.h>
 #include <util/translation.h>
 #include <validationinterface.h>
 #include <warnings.h>
 
 #include <boost/algorithm/string/replace.hpp>
 
 #include <algorithm>
 #include <numeric>
 #include <optional>
 #include <string>
 #include <thread>
 
 using node::BLOCKFILE_CHUNK_SIZE;
 using node::BlockManager;
 using node::BlockMap;
 using node::CCoinsStats;
 using node::CoinStatsHashType;
 using node::fImporting;
 using node::fPruneMode;
 using node::fReindex;
 using node::GetUTXOStats;
 using node::nPruneTarget;
 using node::OpenBlockFile;
 using node::ReadBlockFromDisk;
 using node::SnapshotMetadata;
 using node::UNDOFILE_CHUNK_SIZE;
 using node::UndoReadFromDisk;
 using node::UnlinkPrunedFiles;
 
 #define MICRO 0.000001
 #define MILLI 0.001
 
 /** Time to wait between writing blocks/block index to disk. */
 static constexpr std::chrono::hours DATABASE_WRITE_INTERVAL{1};
 /** Time to wait between flushing chainstate to disk. */
 static constexpr std::chrono::hours DATABASE_FLUSH_INTERVAL{24};
 const std::vector<std::string> CHECKLEVEL_DOC{
     "level 0 reads the blocks from disk",
     "level 1 verifies block validity",
     "level 2 verifies undo data",
     "level 3 checks disconnection of tip blocks",
     "level 4 tries to reconnect the blocks",
     "each level includes the checks of the previous levels",
 };
 
 /**
  * Global state
  *
  * Mutex to guard access to validation specific variables, such as reading
  * or changing the chainstate.
  *
  * This may also need to be locked when updating the transaction pool, e.g. on
  * AcceptToMemoryPool. See CTxMemPool::cs comment for details.
  *
  * The transaction pool has a separate lock to allow reading from it and the
  * chainstate at the same time.
  */
 RecursiveMutex cs_main;
 
 Mutex g_best_block_mutex;
 std::condition_variable g_best_block_cv;
 uint256 g_best_block;
 bool fRequireStandard = true;
 bool fCheckBlockIndex = false;
 bool fCheckpointsEnabled = DEFAULT_CHECKPOINTS_ENABLED;
 int64_t nMaxTipAge = DEFAULT_MAX_TIP_AGE;
 
 BlockHash hashAssumeValid;
 arith_uint256 nMinimumChainWork;
 
 CFeeRate minRelayTxFee = CFeeRate(DEFAULT_MIN_RELAY_TX_FEE_PER_KB);
 
 BlockValidationOptions::BlockValidationOptions(const Config &config)
     : excessiveBlockSize(config.GetMaxBlockSize()), checkPoW(true),
       checkMerkleRoot(true) {}
 
 const CBlockIndex *
 CChainState::FindForkInGlobalIndex(const CBlockLocator &locator) const {
     AssertLockHeld(cs_main);
 
     // Find the latest block common to locator and chain - we expect that
     // locator.vHave is sorted descending by height.
     for (const BlockHash &hash : locator.vHave) {
         const CBlockIndex *pindex{m_blockman.LookupBlockIndex(hash)};
         if (pindex) {
             if (m_chain.Contains(pindex)) {
                 return pindex;
             }
             if (pindex->GetAncestor(m_chain.Height()) == m_chain.Tip()) {
                 return m_chain.Tip();
             }
         }
     }
     return m_chain.Genesis();
 }
 
 static uint32_t GetNextBlockScriptFlags(const Consensus::Params &params,
                                         const CBlockIndex *pindex);
 
 bool CheckSequenceLocksAtTip(CBlockIndex *tip, const CCoinsView &coins_view,
                              const CTransaction &tx, LockPoints *lp,
                              bool useExistingLockPoints) {
     assert(tip != nullptr);
 
     CBlockIndex index;
     index.pprev = tip;
     // CheckSequenceLocksAtTip() uses active_chainstate.m_chain.Height()+1 to
     // evaluate height based locks because when SequenceLocks() is called within
     // ConnectBlock(), the height of the block *being* evaluated is what is
     // used. Thus if we want to know if a transaction can be part of the *next*
     // block, we need to use one more than active_chainstate.m_chain.Height()
     index.nHeight = tip->nHeight + 1;
 
     std::pair<int, int64_t> lockPair;
     if (useExistingLockPoints) {
         assert(lp);
         lockPair.first = lp->height;
         lockPair.second = lp->time;
     } else {
         std::vector<int> prevheights;
         prevheights.resize(tx.vin.size());
         for (size_t txinIndex = 0; txinIndex < tx.vin.size(); txinIndex++) {
             const CTxIn &txin = tx.vin[txinIndex];
             Coin coin;
             if (!coins_view.GetCoin(txin.prevout, coin)) {
                 return error("%s: Missing input", __func__);
             }
             if (coin.GetHeight() == MEMPOOL_HEIGHT) {
                 // Assume all mempool transaction confirm in the next block
                 prevheights[txinIndex] = tip->nHeight + 1;
             } else {
                 prevheights[txinIndex] = coin.GetHeight();
             }
         }
         lockPair = CalculateSequenceLocks(tx, STANDARD_LOCKTIME_VERIFY_FLAGS,
                                           prevheights, index);
         if (lp) {
             lp->height = lockPair.first;
             lp->time = lockPair.second;
             // Also store the hash of the block with the highest height of all
             // the blocks which have sequence locked prevouts. This hash needs
             // to still be on the chain for these LockPoint calculations to be
             // valid.
             // Note: It is impossible to correctly calculate a maxInputBlock if
             // any of the sequence locked inputs depend on unconfirmed txs,
             // except in the special case where the relative lock time/height is
             // 0, which is equivalent to no sequence lock. Since we assume input
             // height of tip+1 for mempool txs and test the resulting lockPair
             // from CalculateSequenceLocks against tip+1. We know
             // EvaluateSequenceLocks will fail if there was a non-zero sequence
             // lock on a mempool input, so we can use the return value of
             // CheckSequenceLocksAtTip to indicate the LockPoints validity.
             int maxInputHeight = 0;
             for (const int height : prevheights) {
                 // Can ignore mempool inputs since we'll fail if they had
                 // non-zero locks.
                 if (height != tip->nHeight + 1) {
                     maxInputHeight = std::max(maxInputHeight, height);
                 }
             }
             lp->maxInputBlock = tip->GetAncestor(maxInputHeight);
         }
     }
     return EvaluateSequenceLocks(index, lockPair);
 }
 
 // Command-line argument "-replayprotectionactivationtime=<timestamp>" will
 // cause the node to switch to replay protected SigHash ForkID value when the
 // median timestamp of the previous 11 blocks is greater than or equal to
 // <timestamp>. Defaults to the pre-defined timestamp when not set.
 static bool IsReplayProtectionEnabled(const Consensus::Params &params,
                                       int64_t nMedianTimePast) {
     return nMedianTimePast >= gArgs.GetIntArg("-replayprotectionactivationtime",
                                               params.wellingtonActivationTime);
 }
 
 static bool IsReplayProtectionEnabled(const Consensus::Params &params,
                                       const CBlockIndex *pindexPrev) {
     if (pindexPrev == nullptr) {
         return false;
     }
 
     return IsReplayProtectionEnabled(params, pindexPrev->GetMedianTimePast());
 }
 
 /**
  * Checks to avoid mempool polluting consensus critical paths since cached
  * signature and script validity results will be reused if we validate this
  * transaction again during block validation.
  */
 static bool CheckInputsFromMempoolAndCache(
     const CTransaction &tx, TxValidationState &state,
     const CCoinsViewCache &view, const CTxMemPool &pool, const uint32_t flags,
     PrecomputedTransactionData &txdata, int &nSigChecksOut,
     CCoinsViewCache &coins_tip) EXCLUSIVE_LOCKS_REQUIRED(cs_main, pool.cs) {
     AssertLockHeld(cs_main);
     AssertLockHeld(pool.cs);
 
     assert(!tx.IsCoinBase());
     for (const CTxIn &txin : tx.vin) {
         const Coin &coin = view.AccessCoin(txin.prevout);
 
         // This coin was checked in PreChecks and MemPoolAccept
         // has been holding cs_main since then.
         Assume(!coin.IsSpent());
         if (coin.IsSpent()) {
             return false;
         }
 
         // If the Coin is available, there are 2 possibilities:
         // it is available in our current ChainstateActive UTXO set,
         // or it's a UTXO provided by a transaction in our mempool.
         // Ensure the scriptPubKeys in Coins from CoinsView are correct.
         const CTransactionRef &txFrom = pool.get(txin.prevout.GetTxId());
         if (txFrom) {
             assert(txFrom->GetId() == txin.prevout.GetTxId());
             assert(txFrom->vout.size() > txin.prevout.GetN());
             assert(txFrom->vout[txin.prevout.GetN()] == coin.GetTxOut());
         } else {
             const Coin &coinFromUTXOSet = coins_tip.AccessCoin(txin.prevout);
             assert(!coinFromUTXOSet.IsSpent());
             assert(coinFromUTXOSet.GetTxOut() == coin.GetTxOut());
         }
     }
 
     // Call CheckInputScripts() to cache signature and script validity against
     // current tip consensus rules.
     return CheckInputScripts(tx, state, view, flags, /*sigCacheStore=*/true,
                              /*scriptCacheStore=*/true, txdata, nSigChecksOut);
 }
 
 namespace {
 
 class MemPoolAccept {
 public:
     MemPoolAccept(CTxMemPool &mempool, CChainState &active_chainstate)
         : m_pool(mempool), m_view(&m_dummy),
           m_viewmempool(&active_chainstate.CoinsTip(), m_pool),
           m_active_chainstate(active_chainstate),
           m_limit_ancestors(
               gArgs.GetIntArg("-limitancestorcount", DEFAULT_ANCESTOR_LIMIT)),
           m_limit_ancestor_size(gArgs.GetIntArg("-limitancestorsize",
                                                 DEFAULT_ANCESTOR_SIZE_LIMIT) *
                                 1000),
           m_limit_descendants(gArgs.GetIntArg("-limitdescendantcount",
                                               DEFAULT_DESCENDANT_LIMIT)),
           m_limit_descendant_size(
               gArgs.GetIntArg("-limitdescendantsize",
                               DEFAULT_DESCENDANT_SIZE_LIMIT) *
               1000) {}
 
     // We put the arguments we're handed into a struct, so we can pass them
     // around easier.
     struct ATMPArgs {
         const Config &m_config;
         const int64_t m_accept_time;
         const bool m_bypass_limits;
         /*
          * Return any outpoints which were not previously present in the coins
          * cache, but were added as a result of validating the tx for mempool
          * acceptance. This allows the caller to optionally remove the cache
          * additions if the associated transaction ends up being rejected by
          * the mempool.
          */
         std::vector<COutPoint> &m_coins_to_uncache;
         const bool m_test_accept;
         /**
          * When true, the mempool will not be trimmed when individual
          * transactions are submitted in Finalize(). Instead, limits should be
          * enforced at the end to ensure the package is not partially submitted.
          */
         const bool m_package_submission;
 
         /** Parameters for single transaction mempool validation. */
         static ATMPArgs SingleAccept(const Config &config, int64_t accept_time,
                                      bool bypass_limits,
                                      std::vector<COutPoint> &coins_to_uncache,
                                      bool test_accept) {
             return ATMPArgs{config,
                             accept_time,
                             bypass_limits,
                             coins_to_uncache,
                             test_accept,
                             /*m_package_submission=*/false};
         }
 
         /**
          * Parameters for test package mempool validation through
          * testmempoolaccept.
          */
         static ATMPArgs
         PackageTestAccept(const Config &config, int64_t accept_time,
                           std::vector<COutPoint> &coins_to_uncache) {
             return ATMPArgs{config, accept_time,
                             /*m_bypass_limits=*/false, coins_to_uncache,
                             /*m_test_accept=*/true,
                             // not submitting to mempool
                             /*m_package_submission=*/false};
         }
 
         /** Parameters for child-with-unconfirmed-parents package validation. */
         static ATMPArgs
         PackageChildWithParents(const Config &config, int64_t accept_time,
                                 std::vector<COutPoint> &coins_to_uncache) {
             return ATMPArgs{config,
                             accept_time,
                             /*m_bypass_limits=*/false,
                             coins_to_uncache,
                             /*m_test_accept=*/false,
                             /*m_package_submission=*/true};
         }
         // No default ctor to avoid exposing details to clients and allowing the
         // possibility of mixing up the order of the arguments. Use static
         // functions above instead.
         ATMPArgs() = delete;
     };
 
     // Single transaction acceptance
     MempoolAcceptResult AcceptSingleTransaction(const CTransactionRef &ptx,
                                                 ATMPArgs &args)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     /**
      * Multiple transaction acceptance. Transactions may or may not be
      * interdependent, but must not conflict with each other, and the
      * transactions cannot already be in the mempool. Parents must come
      * before children if any dependencies exist.
      */
     PackageMempoolAcceptResult
     AcceptMultipleTransactions(const std::vector<CTransactionRef> &txns,
                                ATMPArgs &args)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     /**
      * Package (more specific than just multiple transactions) acceptance.
      * Package must be a child with all of its unconfirmed parents, and
      * topologically sorted.
      */
     PackageMempoolAcceptResult AcceptPackage(const Package &package,
                                              ATMPArgs &args)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
 private:
     // All the intermediate state that gets passed between the various levels
     // of checking a given transaction.
     struct Workspace {
         Workspace(const CTransactionRef &ptx,
                   const uint32_t next_block_script_verify_flags)
             : m_ptx(ptx),
               m_next_block_script_verify_flags(next_block_script_verify_flags) {
         }
         /** All mempool ancestors of this transaction. */
         CTxMemPool::setEntries m_ancestors;
         /**
          * Mempool entry constructed for this transaction.
          * Constructed in PreChecks() but not inserted into the mempool until
          * Finalize().
          */
         std::unique_ptr<CTxMemPoolEntry> m_entry;
 
         /**
          * Virtual size of the transaction as used by the mempool, calculated
          * using serialized size of the transaction and sigchecks.
          */
         int64_t m_vsize;
         /**
          * Fees paid by this transaction: total input amounts subtracted by
          * total output amounts.
          */
         Amount m_base_fees;
 
         /**
          * Base fees + any fee delta set by the user with
          * prioritisetransaction.
          */
         Amount m_modified_fees;
 
         const CTransactionRef &m_ptx;
         TxValidationState m_state;
         /**
          * A temporary cache containing serialized transaction data for
          * signature verification.
          * Reused across PreChecks and ConsensusScriptChecks.
          */
         PrecomputedTransactionData m_precomputed_txdata;
 
         // ABC specific flags that are used in both PreChecks and
         // ConsensusScriptChecks
         const uint32_t m_next_block_script_verify_flags;
         int m_sig_checks_standard;
     };
 
     // Run the policy checks on a given transaction, excluding any script
     // checks. Looks up inputs, calculates feerate, considers replacement,
     // evaluates package limits, etc. As this function can be invoked for "free"
     // by a peer, only tests that are fast should be done here (to avoid CPU
     // DoS).
     bool PreChecks(ATMPArgs &args, Workspace &ws)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs);
 
     // Enforce package mempool ancestor/descendant limits (distinct from
     // individual ancestor/descendant limits done in PreChecks).
     bool PackageMempoolChecks(const std::vector<CTransactionRef> &txns,
                               PackageValidationState &package_state)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs);
 
     // Re-run the script checks, using consensus flags, and try to cache the
     // result in the scriptcache. This should be done after
     // PolicyScriptChecks(). This requires that all inputs either be in our
     // utxo set or in the mempool.
     bool ConsensusScriptChecks(const ATMPArgs &args, Workspace &ws)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs);
 
     // Try to add the transaction to the mempool, removing any conflicts first.
     // Returns true if the transaction is in the mempool after any size
     // limiting is performed, false otherwise.
     bool Finalize(const ATMPArgs &args, Workspace &ws)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs);
 
     // Submit all transactions to the mempool and call ConsensusScriptChecks to
     // add to the script cache - should only be called after successful
     // validation of all transactions in the package.
     // The package may end up partially-submitted after size limiting;
     // returns true if all transactions are successfully added to the mempool,
     // false otherwise.
     bool SubmitPackage(const ATMPArgs &args, std::vector<Workspace> &workspaces,
                        PackageValidationState &package_state,
                        std::map<const TxId, const MempoolAcceptResult> &results)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs);
 
 private:
     CTxMemPool &m_pool;
     CCoinsViewCache m_view;
     CCoinsViewMemPool m_viewmempool;
     CCoinsView m_dummy;
 
     CChainState &m_active_chainstate;
 
     // The package limits in effect at the time of invocation.
     const size_t m_limit_ancestors;
     const size_t m_limit_ancestor_size;
     // These may be modified while evaluating a transaction (eg to account for
     // in-mempool conflicts; see below).
     size_t m_limit_descendants;
     size_t m_limit_descendant_size;
 };
 
 bool MemPoolAccept::PreChecks(ATMPArgs &args, Workspace &ws) {
     AssertLockHeld(cs_main);
     AssertLockHeld(m_pool.cs);
     const CTransactionRef &ptx = ws.m_ptx;
     const CTransaction &tx = *ws.m_ptx;
     const TxId &txid = ws.m_ptx->GetId();
 
     // Copy/alias what we need out of args
     const int64_t nAcceptTime = args.m_accept_time;
     const bool bypass_limits = args.m_bypass_limits;
     std::vector<COutPoint> &coins_to_uncache = args.m_coins_to_uncache;
 
     // Alias what we need out of ws
     TxValidationState &state = ws.m_state;
     std::unique_ptr<CTxMemPoolEntry> &entry = ws.m_entry;
     // Coinbase is only valid in a block, not as a loose transaction.
     if (!CheckRegularTransaction(tx, state)) {
         // state filled in by CheckRegularTransaction.
         return false;
     }
 
     // Rather not work on nonstandard transactions (unless -testnet)
     std::string reason;
     if (fRequireStandard && !IsStandardTx(tx, reason)) {
         return state.Invalid(TxValidationResult::TX_NOT_STANDARD, reason);
     }
 
     // Only accept nLockTime-using transactions that can be mined in the next
     // block; we don't want our mempool filled up with transactions that can't
     // be mined yet.
     TxValidationState ctxState;
     if (!ContextualCheckTransactionForCurrentBlock(
             m_active_chainstate.m_chain.Tip(),
             args.m_config.GetChainParams().GetConsensus(), tx, ctxState)) {
         // We copy the state from a dummy to ensure we don't increase the
         // ban score of peer for transaction that could be valid in the future.
         return state.Invalid(TxValidationResult::TX_PREMATURE_SPEND,
                              ctxState.GetRejectReason(),
                              ctxState.GetDebugMessage());
     }
 
     // Is it already in the memory pool?
     if (m_pool.exists(txid)) {
         return state.Invalid(TxValidationResult::TX_CONFLICT,
                              "txn-already-in-mempool");
     }
 
     // Check for conflicts with in-memory transactions
     for (const CTxIn &txin : tx.vin) {
         auto itConflicting = m_pool.mapNextTx.find(txin.prevout);
         if (itConflicting != m_pool.mapNextTx.end()) {
             // Disable replacement feature for good
             return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY,
                                  "txn-mempool-conflict");
         }
     }
 
     LockPoints lp;
     m_view.SetBackend(m_viewmempool);
 
     const CCoinsViewCache &coins_cache = m_active_chainstate.CoinsTip();
     // Do all inputs exist?
     for (const CTxIn &txin : tx.vin) {
         if (!coins_cache.HaveCoinInCache(txin.prevout)) {
             coins_to_uncache.push_back(txin.prevout);
         }
 
         // Note: this call may add txin.prevout to the coins cache
         // (coins_cache.cacheCoins) by way of FetchCoin(). It should be
         // removed later (via coins_to_uncache) if this tx turns out to be
         // invalid.
         if (!m_view.HaveCoin(txin.prevout)) {
             // Are inputs missing because we already have the tx?
             for (size_t out = 0; out < tx.vout.size(); out++) {
                 // Optimistically just do efficient check of cache for
                 // outputs.
                 if (coins_cache.HaveCoinInCache(COutPoint(txid, out))) {
                     return state.Invalid(TxValidationResult::TX_CONFLICT,
                                          "txn-already-known");
                 }
             }
 
             // Otherwise assume this might be an orphan tx for which we just
             // haven't seen parents yet.
             return state.Invalid(TxValidationResult::TX_MISSING_INPUTS,
                                  "bad-txns-inputs-missingorspent");
         }
     }
 
     // Are the actual inputs available?
     if (!m_view.HaveInputs(tx)) {
         return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY,
                              "bad-txns-inputs-spent");
     }
 
     // Bring the best block into scope.
     m_view.GetBestBlock();
 
     // we have all inputs cached now, so switch back to dummy (to protect
     // against bugs where we pull more inputs from disk that miss being
     // added to coins_to_uncache)
     m_view.SetBackend(m_dummy);
 
     assert(m_active_chainstate.m_blockman.LookupBlockIndex(
                m_view.GetBestBlock()) == m_active_chainstate.m_chain.Tip());
 
     // Only accept BIP68 sequence locked transactions that can be mined in
     // the next block; we don't want our mempool filled up with transactions
     // that can't be mined yet.
     // Pass in m_view which has all of the relevant inputs cached. Note that,
     // since m_view's backend was removed, it no longer pulls coins from the
     // mempool.
     if (!CheckSequenceLocksAtTip(m_active_chainstate.m_chain.Tip(), m_view, tx,
                                  &lp)) {
         return state.Invalid(TxValidationResult::TX_PREMATURE_SPEND,
                              "non-BIP68-final");
     }
 
     // The mempool holds txs for the next block, so pass height+1 to
     // CheckTxInputs
     if (!Consensus::CheckTxInputs(tx, state, m_view,
                                   m_active_chainstate.m_chain.Height() + 1,
                                   ws.m_base_fees)) {
         // state filled in by CheckTxInputs
         return false;
     }
 
     // Check for non-standard pay-to-script-hash in inputs
     if (fRequireStandard &&
         !AreInputsStandard(tx, m_view, ws.m_next_block_script_verify_flags)) {
         return state.Invalid(TxValidationResult::TX_INPUTS_NOT_STANDARD,
                              "bad-txns-nonstandard-inputs");
     }
 
     // ws.m_modified_fess includes any fee deltas from PrioritiseTransaction
     ws.m_modified_fees = ws.m_base_fees;
     m_pool.ApplyDelta(txid, ws.m_modified_fees);
 
     // Keep track of transactions that spend a coinbase, which we re-scan
     // during reorgs to ensure COINBASE_MATURITY is still met.
     bool fSpendsCoinbase = false;
     for (const CTxIn &txin : tx.vin) {
         const Coin &coin = m_view.AccessCoin(txin.prevout);
         if (coin.IsCoinBase()) {
             fSpendsCoinbase = true;
             break;
         }
     }
 
     unsigned int nSize = tx.GetTotalSize();
 
     // No transactions are allowed below minRelayTxFee except from disconnected
     // blocks.
     // Do not change this to use virtualsize without coordinating a network
     // policy upgrade.
     if (!bypass_limits && ws.m_modified_fees < minRelayTxFee.GetFee(nSize)) {
         return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY,
                              "min relay fee not met",
                              strprintf("%d < %d", ws.m_modified_fees,
                                        ::minRelayTxFee.GetFee(nSize)));
     }
 
     // Validate input scripts against standard script flags.
     const uint32_t scriptVerifyFlags =
         ws.m_next_block_script_verify_flags | STANDARD_SCRIPT_VERIFY_FLAGS;
     ws.m_precomputed_txdata = PrecomputedTransactionData{tx};
     if (!CheckInputScripts(tx, state, m_view, scriptVerifyFlags, true, false,
                            ws.m_precomputed_txdata, ws.m_sig_checks_standard)) {
         // State filled in by CheckInputScripts
         return false;
     }
 
     entry.reset(new CTxMemPoolEntry(
         ptx, ws.m_base_fees, nAcceptTime, m_active_chainstate.m_chain.Height(),
         fSpendsCoinbase, ws.m_sig_checks_standard, lp));
 
     ws.m_vsize = entry->GetTxVirtualSize();
 
     Amount mempoolRejectFee =
         m_pool
             .GetMinFee(
                 gArgs.GetIntArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) *
                 1000000)
             .GetFee(ws.m_vsize);
     if (!bypass_limits && mempoolRejectFee > Amount::zero() &&
         ws.m_modified_fees < mempoolRejectFee) {
         return state.Invalid(
             TxValidationResult::TX_MEMPOOL_POLICY, "mempool min fee not met",
             strprintf("%d < %d", ws.m_modified_fees, mempoolRejectFee));
     }
 
     // Calculate in-mempool ancestors, up to a limit.
     std::string errString;
     if (!m_pool.CalculateMemPoolAncestors(
             *entry, ws.m_ancestors, m_limit_ancestors, m_limit_ancestor_size,
             m_limit_descendants, m_limit_descendant_size, errString)) {
         return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY,
                              "too-long-mempool-chain", errString);
     }
     return true;
 }
 
 bool MemPoolAccept::PackageMempoolChecks(
     const std::vector<CTransactionRef> &txns,
     PackageValidationState &package_state) {
     AssertLockHeld(cs_main);
     AssertLockHeld(m_pool.cs);
 
     // CheckPackageLimits expects the package transactions to not already be in
     // the mempool.
     assert(std::all_of(txns.cbegin(), txns.cend(), [this](const auto &tx) {
         return !m_pool.exists(tx->GetId());
     }));
 
     std::string err_string;
     if (!m_pool.CheckPackageLimits(txns, m_limit_ancestors,
                                    m_limit_ancestor_size, m_limit_descendants,
                                    m_limit_descendant_size, err_string)) {
         // This is a package-wide error, separate from an individual transaction
         // error.
         return package_state.Invalid(PackageValidationResult::PCKG_POLICY,
                                      "package-mempool-limits", err_string);
     }
     return true;
 }
 
 bool MemPoolAccept::ConsensusScriptChecks(const ATMPArgs &args, Workspace &ws) {
     AssertLockHeld(cs_main);
     AssertLockHeld(m_pool.cs);
     const CTransaction &tx = *ws.m_ptx;
     const TxId &txid = tx.GetId();
     TxValidationState &state = ws.m_state;
 
     // Check again against the next block's script verification flags
     // to cache our script execution flags.
     //
     // This is also useful in case of bugs in the standard flags that cause
     // transactions to pass as valid when they're actually invalid. For
     // instance the STRICTENC flag was incorrectly allowing certain CHECKSIG
     // NOT scripts to pass, even though they were invalid.
     //
     // There is a similar check in CreateNewBlock() to prevent creating
     // invalid blocks (using TestBlockValidity), however allowing such
     // transactions into the mempool can be exploited as a DoS attack.
     int nSigChecksConsensus;
     if (!CheckInputsFromMempoolAndCache(
             tx, state, m_view, m_pool, ws.m_next_block_script_verify_flags,
             ws.m_precomputed_txdata, nSigChecksConsensus,
             m_active_chainstate.CoinsTip())) {
         // This can occur under some circumstances, if the node receives an
         // unrequested tx which is invalid due to new consensus rules not
         // being activated yet (during IBD).
         LogPrintf("BUG! PLEASE REPORT THIS! CheckInputScripts failed against "
                   "latest-block but not STANDARD flags %s, %s\n",
                   txid.ToString(), state.ToString());
         return Assume(false);
     }
 
     if (ws.m_sig_checks_standard != nSigChecksConsensus) {
         // We can't accept this transaction as we've used the standard count
         // for the mempool/mining, but the consensus count will be enforced
         // in validation (we don't want to produce bad block templates).
         return error(
             "%s: BUG! PLEASE REPORT THIS! SigChecks count differed between "
             "standard and consensus flags in %s",
             __func__, txid.ToString());
     }
     return true;
 }
 
 bool MemPoolAccept::Finalize(const ATMPArgs &args, Workspace &ws) {
     AssertLockHeld(cs_main);
     AssertLockHeld(m_pool.cs);
     const TxId &txid = ws.m_ptx->GetId();
     TxValidationState &state = ws.m_state;
     const bool bypass_limits = args.m_bypass_limits;
 
     std::unique_ptr<CTxMemPoolEntry> &entry = ws.m_entry;
 
     // Store transaction in memory.
     m_pool.addUnchecked(*entry, ws.m_ancestors);
 
     // Trim mempool and check if tx was trimmed.
     // If we are validating a package, don't trim here because we could evict a
     // previous transaction in the package. LimitMempoolSize() should be called
     // at the very end to make sure the mempool is still within limits and
     // package submission happens atomically.
     if (!args.m_package_submission && !bypass_limits) {
         m_pool.LimitSize(
             m_active_chainstate.CoinsTip(),
             gArgs.GetIntArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000,
             std::chrono::hours{
                 gArgs.GetIntArg("-mempoolexpiry", DEFAULT_MEMPOOL_EXPIRY)});
         if (!m_pool.exists(txid)) {
             return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY,
                                  "mempool full");
         }
     }
     return true;
 }
 
 bool MemPoolAccept::SubmitPackage(
     const ATMPArgs &args, std::vector<Workspace> &workspaces,
     PackageValidationState &package_state,
     std::map<const TxId, const MempoolAcceptResult> &results) {
     AssertLockHeld(cs_main);
     AssertLockHeld(m_pool.cs);
     // Sanity check: none of the transactions should be in the mempool.
     assert(std::all_of(
         workspaces.cbegin(), workspaces.cend(),
         [this](const auto &ws) { return !m_pool.exists(ws.m_ptx->GetId()); }));
 
     bool all_submitted = true;
     // ConsensusScriptChecks adds to the script cache and is therefore
     // consensus-critical; CheckInputsFromMempoolAndCache asserts that
     // transactions only spend coins available from the mempool or UTXO set.
     // Submit each transaction to the mempool immediately after calling
     // ConsensusScriptChecks to make the outputs available for subsequent
     // transactions.
     for (Workspace &ws : workspaces) {
         if (!ConsensusScriptChecks(args, ws)) {
             results.emplace(ws.m_ptx->GetId(),
                             MempoolAcceptResult::Failure(ws.m_state));
             // Since PreChecks() passed, this should never fail.
             all_submitted = Assume(false);
         }
 
         // Re-calculate mempool ancestors to call addUnchecked(). They may have
         // changed since the last calculation done in PreChecks, since package
         // ancestors have already been submitted.
         std::string unused_err_string;
         if (!m_pool.CalculateMemPoolAncestors(
                 *ws.m_entry, ws.m_ancestors, m_limit_ancestors,
                 m_limit_ancestor_size, m_limit_descendants,
                 m_limit_descendant_size, unused_err_string)) {
             results.emplace(ws.m_ptx->GetId(),
                             MempoolAcceptResult::Failure(ws.m_state));
             // Since PreChecks() and PackageMempoolChecks() both enforce limits,
             // this should never fail.
             all_submitted = Assume(false);
         }
         // If we call LimitMempoolSize() for each individual Finalize(), the
         // mempool will not take the transaction's descendant feerate into
         // account because it hasn't seen them yet. Also, we risk evicting a
         // transaction that a subsequent package transaction depends on.
         // Instead, allow the mempool to temporarily bypass limits, the maximum
         // package size) while submitting transactions individually and then
         // trim at the very end.
         if (!Finalize(args, ws)) {
             results.emplace(ws.m_ptx->GetId(),
                             MempoolAcceptResult::Failure(ws.m_state));
             // Since LimitMempoolSize() won't be called, this should never fail.
             all_submitted = Assume(false);
         }
     }
 
     // It may or may not be the case that all the transactions made it into the
     // mempool. Regardless, make sure we haven't exceeded max mempool size.
     m_pool.LimitSize(
         m_active_chainstate.CoinsTip(),
         gArgs.GetIntArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000,
         std::chrono::hours{
             gArgs.GetIntArg("-mempoolexpiry", DEFAULT_MEMPOOL_EXPIRY)});
     if (!all_submitted) {
         return false;
     }
 
     // Find the txids of the transactions that made it into the mempool. Allow
     // partial submission, but don't report success unless they all made it into
     // the mempool.
     for (Workspace &ws : workspaces) {
         if (m_pool.exists(ws.m_ptx->GetId())) {
             results.emplace(ws.m_ptx->GetId(), MempoolAcceptResult::Success(
                                                    ws.m_vsize, ws.m_base_fees));
             GetMainSignals().TransactionAddedToMempool(
                 ws.m_ptx, m_pool.GetAndIncrementSequence());
         } else {
             all_submitted = false;
             ws.m_state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY,
                                "mempool full");
             results.emplace(ws.m_ptx->GetId(),
                             MempoolAcceptResult::Failure(ws.m_state));
         }
     }
     return all_submitted;
 }
 
 MempoolAcceptResult
 MemPoolAccept::AcceptSingleTransaction(const CTransactionRef &ptx,
                                        ATMPArgs &args) {
     AssertLockHeld(cs_main);
     // mempool "read lock" (held through
     // GetMainSignals().TransactionAddedToMempool())
     LOCK(m_pool.cs);
 
     Workspace ws(ptx, GetNextBlockScriptFlags(
                           args.m_config.GetChainParams().GetConsensus(),
                           m_active_chainstate.m_chain.Tip()));
 
     // Perform the inexpensive checks first and avoid hashing and signature
     // verification unless those checks pass, to mitigate CPU exhaustion
     // denial-of-service attacks.
     if (!PreChecks(args, ws)) {
         return MempoolAcceptResult::Failure(ws.m_state);
     }
 
     if (!ConsensusScriptChecks(args, ws)) {
         return MempoolAcceptResult::Failure(ws.m_state);
     }
 
     // Tx was accepted, but not added
     if (args.m_test_accept) {
         return MempoolAcceptResult::Success(ws.m_vsize, ws.m_base_fees);
     }
 
     if (!Finalize(args, ws)) {
         return MempoolAcceptResult::Failure(ws.m_state);
     }
 
     GetMainSignals().TransactionAddedToMempool(
         ptx, m_pool.GetAndIncrementSequence());
 
     return MempoolAcceptResult::Success(ws.m_vsize, ws.m_base_fees);
 }
 
 PackageMempoolAcceptResult MemPoolAccept::AcceptMultipleTransactions(
     const std::vector<CTransactionRef> &txns, ATMPArgs &args) {
     AssertLockHeld(cs_main);
 
     // These context-free package limits can be done before taking the mempool
     // lock.
     PackageValidationState package_state;
     if (!CheckPackage(txns, package_state)) {
         return PackageMempoolAcceptResult(package_state, {});
     }
 
     std::vector<Workspace> workspaces{};
     workspaces.reserve(txns.size());
     std::transform(txns.cbegin(), txns.cend(), std::back_inserter(workspaces),
                    [&args, this](const auto &tx) {
                        return Workspace(
                            tx,
                            GetNextBlockScriptFlags(
                                args.m_config.GetChainParams().GetConsensus(),
                                m_active_chainstate.m_chain.Tip()));
                    });
     std::map<const TxId, const MempoolAcceptResult> results;
 
     LOCK(m_pool.cs);
 
     // Do all PreChecks first and fail fast to avoid running expensive script
     // checks when unnecessary.
     for (Workspace &ws : workspaces) {
         if (!PreChecks(args, ws)) {
             package_state.Invalid(PackageValidationResult::PCKG_TX,
                                   "transaction failed");
             // Exit early to avoid doing pointless work. Update the failed tx
             // result; the rest are unfinished.
             results.emplace(ws.m_ptx->GetId(),
                             MempoolAcceptResult::Failure(ws.m_state));
             return PackageMempoolAcceptResult(package_state,
                                               std::move(results));
         }
         // Make the coins created by this transaction available for subsequent
         // transactions in the package to spend.
         m_viewmempool.PackageAddTransaction(ws.m_ptx);
         if (args.m_test_accept) {
             // When test_accept=true, transactions that pass PreChecks
             // are valid because there are no further mempool checks (passing
             // PreChecks implies passing ConsensusScriptChecks).
             results.emplace(ws.m_ptx->GetId(), MempoolAcceptResult::Success(
                                                    ws.m_vsize, ws.m_base_fees));
         }
     }
 
     // Apply package mempool ancestor/descendant limits. Skip if there is only
     // one transaction, because it's unnecessary. Also, CPFP carve out can
     // increase the limit for individual transactions, but this exemption is
     // not extended to packages in CheckPackageLimits().
     std::string err_string;
     if (txns.size() > 1 && !PackageMempoolChecks(txns, package_state)) {
         return PackageMempoolAcceptResult(package_state, std::move(results));
     }
 
     if (args.m_test_accept) {
         return PackageMempoolAcceptResult(package_state, std::move(results));
     }
 
     if (!SubmitPackage(args, workspaces, package_state, results)) {
         package_state.Invalid(PackageValidationResult::PCKG_TX,
                               "submission failed");
         return PackageMempoolAcceptResult(package_state, std::move(results));
     }
 
     return PackageMempoolAcceptResult(package_state, std::move(results));
 }
 
 PackageMempoolAcceptResult MemPoolAccept::AcceptPackage(const Package &package,
                                                         ATMPArgs &args) {
     AssertLockHeld(cs_main);
     PackageValidationState package_state;
 
     // Check that the package is well-formed. If it isn't, we won't try to
     // validate any of the transactions and thus won't return any
     // MempoolAcceptResults, just a package-wide error.
 
     // Context-free package checks.
     if (!CheckPackage(package, package_state)) {
         return PackageMempoolAcceptResult(package_state, {});
     }
 
     // All transactions in the package must be a parent of the last transaction.
     // This is just an opportunity for us to fail fast on a context-free check
     // without taking the mempool lock.
     if (!IsChildWithParents(package)) {
         package_state.Invalid(PackageValidationResult::PCKG_POLICY,
                               "package-not-child-with-parents");
         return PackageMempoolAcceptResult(package_state, {});
     }
 
     // IsChildWithParents() guarantees the package is > 1 transactions.
     assert(package.size() > 1);
     // The package must be 1 child with all of its unconfirmed parents. The
     // package is expected to be sorted, so the last transaction is the child.
     const auto &child = package.back();
     std::unordered_set<TxId, SaltedTxIdHasher> unconfirmed_parent_txids;
     std::transform(
         package.cbegin(), package.cend() - 1,
         std::inserter(unconfirmed_parent_txids, unconfirmed_parent_txids.end()),
         [](const auto &tx) { return tx->GetId(); });
 
     // All child inputs must refer to a preceding package transaction or a
     // confirmed UTXO. The only way to verify this is to look up the child's
     // inputs in our current coins view (not including mempool), and enforce
     // that all parents not present in the package be available at chain tip.
     // Since this check can bring new coins into the coins cache, keep track of
     // these coins and uncache them if we don't end up submitting this package
     // to the mempool.
     const CCoinsViewCache &coins_tip_cache = m_active_chainstate.CoinsTip();
     for (const auto &input : child->vin) {
         if (!coins_tip_cache.HaveCoinInCache(input.prevout)) {
             args.m_coins_to_uncache.push_back(input.prevout);
         }
     }
     // Using the MemPoolAccept m_view cache allows us to look up these same
     // coins faster later. This should be connecting directly to CoinsTip, not
     // to m_viewmempool, because we specifically require inputs to be confirmed
     // if they aren't in the package.
     m_view.SetBackend(m_active_chainstate.CoinsTip());
     const auto package_or_confirmed = [this, &unconfirmed_parent_txids](
                                           const auto &input) {
         return unconfirmed_parent_txids.count(input.prevout.GetTxId()) > 0 ||
                m_view.HaveCoin(input.prevout);
     };
     if (!std::all_of(child->vin.cbegin(), child->vin.cend(),
                      package_or_confirmed)) {
         package_state.Invalid(PackageValidationResult::PCKG_POLICY,
                               "package-not-child-with-unconfirmed-parents");
         return PackageMempoolAcceptResult(package_state, {});
     }
     // Protect against bugs where we pull more inputs from disk that miss being
     // added to coins_to_uncache. The backend will be connected again when
     // needed in PreChecks.
     m_view.SetBackend(m_dummy);
 
     LOCK(m_pool.cs);
     std::map<const TxId, const MempoolAcceptResult> results;
     // Node operators are free to set their mempool policies however they
     // please, nodes may receive transactions in different orders, and malicious
     // counterparties may try to take advantage of policy differences to pin or
     // delay propagation of transactions. As such, it's possible for some
     // package transaction(s) to already be in the mempool, and we don't want to
     // reject the entire package in that case (as that could be a censorship
     // vector). De-duplicate the transactions that are already in the mempool,
     // and only call AcceptMultipleTransactions() with the new transactions.
     // This ensures we don't double-count transaction counts and sizes when
     // checking ancestor/descendant limits, or double-count transaction fees for
     // fee-related policy.
     std::vector<CTransactionRef> txns_new;
     for (const auto &tx : package) {
         const auto &txid = tx->GetId();
         // An already confirmed tx is treated as one not in mempool, because all
         // we know is that the inputs aren't available.
         if (m_pool.exists(txid)) {
             // Exact transaction already exists in the mempool.
             auto iter = m_pool.GetIter(txid);
             assert(iter != std::nullopt);
             results.emplace(
                 txid, MempoolAcceptResult::MempoolTx(iter.value()->GetTxSize(),
                                                      iter.value()->GetFee()));
         } else {
             // Transaction does not already exist in the mempool.
             txns_new.push_back(tx);
         }
     }
 
     // Nothing to do if the entire package has already been submitted.
     if (txns_new.empty()) {
         return PackageMempoolAcceptResult(package_state, std::move(results));
     }
     // Validate the (deduplicated) transactions as a package.
     auto submission_result = AcceptMultipleTransactions(txns_new, args);
     // Include already-in-mempool transaction results in the final result.
     for (const auto &[txid, mempoolaccept_res] : results) {
         submission_result.m_tx_results.emplace(txid, mempoolaccept_res);
     }
     return submission_result;
 }
 } // namespace
 
 MempoolAcceptResult AcceptToMemoryPool(const Config &config,
                                        CChainState &active_chainstate,
                                        const CTransactionRef &tx,
                                        int64_t accept_time, bool bypass_limits,
                                        bool test_accept) {
     AssertLockHeld(::cs_main);
     assert(active_chainstate.GetMempool() != nullptr);
     CTxMemPool &pool{*active_chainstate.GetMempool()};
 
     std::vector<COutPoint> coins_to_uncache;
     auto args = MemPoolAccept::ATMPArgs::SingleAccept(
         config, accept_time, bypass_limits, coins_to_uncache, test_accept);
     const MempoolAcceptResult result = MemPoolAccept(pool, active_chainstate)
                                            .AcceptSingleTransaction(tx, args);
     if (result.m_result_type != MempoolAcceptResult::ResultType::VALID) {
         // Remove coins that were not present in the coins cache before calling
         // ATMPW; this is to prevent memory DoS in case we receive a large
         // number of invalid transactions that attempt to overrun the in-memory
         // coins cache
         // (`CCoinsViewCache::cacheCoins`).
 
         for (const COutPoint &outpoint : coins_to_uncache) {
             active_chainstate.CoinsTip().Uncache(outpoint);
         }
     }
 
     // After we've (potentially) uncached entries, ensure our coins cache is
     // still within its size limits
     BlockValidationState stateDummy;
     active_chainstate.FlushStateToDisk(stateDummy, FlushStateMode::PERIODIC);
     return result;
 }
 
 PackageMempoolAcceptResult
 ProcessNewPackage(const Config &config, CChainState &active_chainstate,
                   CTxMemPool &pool, const Package &package, bool test_accept) {
     AssertLockHeld(cs_main);
     assert(!package.empty());
     assert(std::all_of(package.cbegin(), package.cend(),
                        [](const auto &tx) { return tx != nullptr; }));
 
     std::vector<COutPoint> coins_to_uncache;
     const auto result = [&]() EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
         AssertLockHeld(cs_main);
         if (test_accept) {
             auto args = MemPoolAccept::ATMPArgs::PackageTestAccept(
                 config, GetTime(), coins_to_uncache);
             return MemPoolAccept(pool, active_chainstate)
                 .AcceptMultipleTransactions(package, args);
         } else {
             auto args = MemPoolAccept::ATMPArgs::PackageChildWithParents(
                 config, GetTime(), coins_to_uncache);
             return MemPoolAccept(pool, active_chainstate)
                 .AcceptPackage(package, args);
         }
     }();
 
     // Uncache coins pertaining to transactions that were not submitted to the
     // mempool.
     if (test_accept || result.m_state.IsInvalid()) {
         for (const COutPoint &hashTx : coins_to_uncache) {
             active_chainstate.CoinsTip().Uncache(hashTx);
         }
     }
     // Ensure the coins cache is still within limits.
     BlockValidationState state_dummy;
     active_chainstate.FlushStateToDisk(state_dummy, FlushStateMode::PERIODIC);
     return result;
 }
 
 Amount GetBlockSubsidy(int nHeight, const Consensus::Params &consensusParams) {
     int halvings = nHeight / consensusParams.nSubsidyHalvingInterval;
     // Force block reward to zero when right shift is undefined.
     if (halvings >= 64) {
         return Amount::zero();
     }
 
     Amount nSubsidy = 50 * COIN;
     // Subsidy is cut in half every 210,000 blocks which will occur
     // approximately every 4 years.
     return ((nSubsidy / SATOSHI) >> halvings) * SATOSHI;
 }
 
 CoinsViews::CoinsViews(std::string ldb_name, size_t cache_size_bytes,
                        bool in_memory, bool should_wipe)
     : m_dbview(gArgs.GetDataDirNet() / ldb_name, cache_size_bytes, in_memory,
                should_wipe),
       m_catcherview(&m_dbview) {}
 
 void CoinsViews::InitCache() {
     AssertLockHeld(::cs_main);
     m_cacheview = std::make_unique<CCoinsViewCache>(&m_catcherview);
 }
 
 CChainState::CChainState(CTxMemPool *mempool, BlockManager &blockman,
                          ChainstateManager &chainman,
                          std::optional<BlockHash> from_snapshot_blockhash)
     : m_mempool(mempool), m_blockman(blockman), m_params(::Params()),
       m_chainman(chainman), m_from_snapshot_blockhash(from_snapshot_blockhash) {
 }
 
 void CChainState::InitCoinsDB(size_t cache_size_bytes, bool in_memory,
                               bool should_wipe, std::string leveldb_name) {
     if (m_from_snapshot_blockhash) {
         leveldb_name += "_" + m_from_snapshot_blockhash->ToString();
     }
     m_coins_views = std::make_unique<CoinsViews>(leveldb_name, cache_size_bytes,
                                                  in_memory, should_wipe);
 }
 
 void CChainState::InitCoinsCache(size_t cache_size_bytes) {
     AssertLockHeld(::cs_main);
     assert(m_coins_views != nullptr);
     m_coinstip_cache_size_bytes = cache_size_bytes;
     m_coins_views->InitCache();
 }
 
 // Note that though this is marked const, we may end up modifying
 // `m_cached_finished_ibd`, which is a performance-related implementation
 // detail. This function must be marked `const` so that `CValidationInterface`
 // clients (which are given a `const CChainState*`) can call it.
 //
 bool CChainState::IsInitialBlockDownload() const {
     // Optimization: pre-test latch before taking the lock.
     if (m_cached_finished_ibd.load(std::memory_order_relaxed)) {
         return false;
     }
 
     LOCK(cs_main);
     if (m_cached_finished_ibd.load(std::memory_order_relaxed)) {
         return false;
     }
     if (fImporting || fReindex) {
         return true;
     }
     if (m_chain.Tip() == nullptr) {
         return true;
     }
     if (m_chain.Tip()->nChainWork < nMinimumChainWork) {
         return true;
     }
     if (m_chain.Tip()->GetBlockTime() < (GetTime() - nMaxTipAge)) {
         return true;
     }
     LogPrintf("Leaving InitialBlockDownload (latching to false)\n");
     m_cached_finished_ibd.store(true, std::memory_order_relaxed);
     return false;
 }
 
 static CBlockIndex const *pindexBestForkTip = nullptr;
 static CBlockIndex const *pindexBestForkBase = nullptr;
 
 static void AlertNotify(const std::string &strMessage) {
     uiInterface.NotifyAlertChanged();
 #if defined(HAVE_SYSTEM)
     std::string strCmd = gArgs.GetArg("-alertnotify", "");
     if (strCmd.empty()) {
         return;
     }
 
     // Alert text should be plain ascii coming from a trusted source, but to be
     // safe we first strip anything not in safeChars, then add single quotes
     // around the whole string before passing it to the shell:
     std::string singleQuote("'");
     std::string safeStatus = SanitizeString(strMessage);
     safeStatus = singleQuote + safeStatus + singleQuote;
     boost::replace_all(strCmd, "%s", safeStatus);
 
     std::thread t(runCommand, strCmd);
     // thread runs free
     t.detach();
 #endif
 }
 
 void CChainState::CheckForkWarningConditions() {
     AssertLockHeld(cs_main);
 
     // Before we get past initial download, we cannot reliably alert about forks
     // (we assume we don't get stuck on a fork before finishing our initial
     // sync)
     if (IsInitialBlockDownload()) {
         return;
     }
 
     // If our best fork is no longer within 72 blocks (+/- 12 hours if no one
     // mines it) of our head, drop it
     if (pindexBestForkTip &&
         m_chain.Height() - pindexBestForkTip->nHeight >= 72) {
         pindexBestForkTip = nullptr;
     }
 
     if (pindexBestForkTip ||
         (m_chainman.m_best_invalid &&
          m_chainman.m_best_invalid->nChainWork >
              m_chain.Tip()->nChainWork + (GetBlockProof(*m_chain.Tip()) * 6))) {
         if (!GetfLargeWorkForkFound() && pindexBestForkBase) {
             std::string warning =
                 std::string("'Warning: Large-work fork detected, forking after "
                             "block ") +
                 pindexBestForkBase->phashBlock->ToString() + std::string("'");
             AlertNotify(warning);
         }
 
         if (pindexBestForkTip && pindexBestForkBase) {
             LogPrintf("%s: Warning: Large fork found\n  forking the "
                       "chain at height %d (%s)\n  lasting to height %d "
                       "(%s).\nChain state database corruption likely.\n",
                       __func__, pindexBestForkBase->nHeight,
                       pindexBestForkBase->phashBlock->ToString(),
                       pindexBestForkTip->nHeight,
                       pindexBestForkTip->phashBlock->ToString());
             SetfLargeWorkForkFound(true);
         } else {
             LogPrintf("%s: Warning: Found invalid chain at least ~6 blocks "
                       "longer than our best chain.\nChain state database "
                       "corruption likely.\n",
                       __func__);
             SetfLargeWorkInvalidChainFound(true);
         }
     } else {
         SetfLargeWorkForkFound(false);
         SetfLargeWorkInvalidChainFound(false);
     }
 }
 
 void CChainState::CheckForkWarningConditionsOnNewFork(
     CBlockIndex *pindexNewForkTip) {
     AssertLockHeld(cs_main);
 
     // If we are on a fork that is sufficiently large, set a warning flag.
     const CBlockIndex *pfork = m_chain.FindFork(pindexNewForkTip);
 
     // We define a condition where we should warn the user about as a fork of at
     // least 7 blocks with a tip within 72 blocks (+/- 12 hours if no one mines
     // it) of ours. We use 7 blocks rather arbitrarily as it represents just
     // under 10% of sustained network hash rate operating on the fork, or a
     // chain that is entirely longer than ours and invalid (note that this
     // should be detected by both). We define it this way because it allows us
     // to only store the highest fork tip (+ base) which meets the 7-block
     // condition and from this always have the most-likely-to-cause-warning fork
     if (pfork &&
         (!pindexBestForkTip ||
          pindexNewForkTip->nHeight > pindexBestForkTip->nHeight) &&
         pindexNewForkTip->nChainWork - pfork->nChainWork >
             (GetBlockProof(*pfork) * 7) &&
         m_chain.Height() - pindexNewForkTip->nHeight < 72) {
         pindexBestForkTip = pindexNewForkTip;
         pindexBestForkBase = pfork;
     }
 
     CheckForkWarningConditions();
 }
 
 // Called both upon regular invalid block discovery *and* InvalidateBlock
 void CChainState::InvalidChainFound(CBlockIndex *pindexNew) {
     AssertLockHeld(cs_main);
     if (!m_chainman.m_best_invalid ||
         pindexNew->nChainWork > m_chainman.m_best_invalid->nChainWork) {
         m_chainman.m_best_invalid = pindexNew;
     }
     if (m_chainman.m_best_header != nullptr &&
         m_chainman.m_best_header->GetAncestor(pindexNew->nHeight) ==
             pindexNew) {
         m_chainman.m_best_header = m_chain.Tip();
     }
 
     // If the invalid chain found is supposed to be finalized, we need to move
     // back the finalization point.
-    if (IsBlockFinalized(pindexNew)) {
-        m_finalizedBlockIndex = pindexNew->pprev;
-    }
     if (IsBlockAvalancheFinalized(pindexNew)) {
         LOCK(cs_avalancheFinalizedBlockIndex);
         m_avalancheFinalizedBlockIndex = pindexNew->pprev;
     }
 
     LogPrintf("%s: invalid block=%s  height=%d  log2_work=%f  date=%s\n",
               __func__, pindexNew->GetBlockHash().ToString(),
               pindexNew->nHeight,
               log(pindexNew->nChainWork.getdouble()) / log(2.0),
               FormatISO8601DateTime(pindexNew->GetBlockTime()));
     CBlockIndex *tip = m_chain.Tip();
     assert(tip);
     LogPrintf("%s:  current best=%s  height=%d  log2_work=%f  date=%s\n",
               __func__, tip->GetBlockHash().ToString(), m_chain.Height(),
               log(tip->nChainWork.getdouble()) / log(2.0),
               FormatISO8601DateTime(tip->GetBlockTime()));
 }
 
 // Same as InvalidChainFound, above, except not called directly from
 // InvalidateBlock, which does its own setBlockIndexCandidates management.
 void CChainState::InvalidBlockFound(CBlockIndex *pindex,
                                     const BlockValidationState &state) {
     AssertLockHeld(cs_main);
     if (state.GetResult() != BlockValidationResult::BLOCK_MUTATED) {
         pindex->nStatus = pindex->nStatus.withFailed();
         m_chainman.m_failed_blocks.insert(pindex);
         m_blockman.m_dirty_blockindex.insert(pindex);
         InvalidChainFound(pindex);
     }
 }
 
 void SpendCoins(CCoinsViewCache &view, const CTransaction &tx, CTxUndo &txundo,
                 int nHeight) {
     // Mark inputs spent.
     if (tx.IsCoinBase()) {
         return;
     }
 
     txundo.vprevout.reserve(tx.vin.size());
     for (const CTxIn &txin : tx.vin) {
         txundo.vprevout.emplace_back();
         bool is_spent = view.SpendCoin(txin.prevout, &txundo.vprevout.back());
         assert(is_spent);
     }
 }
 
 void UpdateCoins(CCoinsViewCache &view, const CTransaction &tx, CTxUndo &txundo,
                  int nHeight) {
     SpendCoins(view, tx, txundo, nHeight);
     AddCoins(view, tx, nHeight);
 }
 
 bool CScriptCheck::operator()() {
     const CScript &scriptSig = ptxTo->vin[nIn].scriptSig;
     if (!VerifyScript(scriptSig, m_tx_out.scriptPubKey, nFlags,
                       CachingTransactionSignatureChecker(
                           ptxTo, nIn, m_tx_out.nValue, cacheStore, txdata),
                       metrics, &error)) {
         return false;
     }
     if ((pTxLimitSigChecks &&
          !pTxLimitSigChecks->consume_and_check(metrics.nSigChecks)) ||
         (pBlockLimitSigChecks &&
          !pBlockLimitSigChecks->consume_and_check(metrics.nSigChecks))) {
         // we can't assign a meaningful script error (since the script
         // succeeded), but remove the ScriptError::OK which could be
         // misinterpreted.
         error = ScriptError::SIGCHECKS_LIMIT_EXCEEDED;
         return false;
     }
     return true;
 }
 
 bool CheckInputScripts(const CTransaction &tx, TxValidationState &state,
                        const CCoinsViewCache &inputs, const uint32_t flags,
                        bool sigCacheStore, bool scriptCacheStore,
                        const PrecomputedTransactionData &txdata,
                        int &nSigChecksOut, TxSigCheckLimiter &txLimitSigChecks,
                        CheckInputsLimiter *pBlockLimitSigChecks,
                        std::vector<CScriptCheck> *pvChecks) {
     AssertLockHeld(cs_main);
     assert(!tx.IsCoinBase());
 
     if (pvChecks) {
         pvChecks->reserve(tx.vin.size());
     }
 
     // First check if script executions have been cached with the same flags.
     // Note that this assumes that the inputs provided are correct (ie that the
     // transaction hash which is in tx's prevouts properly commits to the
     // scriptPubKey in the inputs view of that transaction).
     ScriptCacheKey hashCacheEntry(tx, flags);
     if (IsKeyInScriptCache(hashCacheEntry, !scriptCacheStore, nSigChecksOut)) {
         if (!txLimitSigChecks.consume_and_check(nSigChecksOut) ||
             (pBlockLimitSigChecks &&
              !pBlockLimitSigChecks->consume_and_check(nSigChecksOut))) {
             return state.Invalid(TxValidationResult::TX_CONSENSUS,
                                  "too-many-sigchecks");
         }
         return true;
     }
 
     int nSigChecksTotal = 0;
 
     for (size_t i = 0; i < tx.vin.size(); i++) {
         const COutPoint &prevout = tx.vin[i].prevout;
         const Coin &coin = inputs.AccessCoin(prevout);
         assert(!coin.IsSpent());
 
         // We very carefully only pass in things to CScriptCheck which are
         // clearly committed to by tx's hash. This provides a sanity
         // check that our caching is not introducing consensus failures through
         // additional data in, eg, the coins being spent being checked as a part
         // of CScriptCheck.
 
         // Verify signature
         CScriptCheck check(coin.GetTxOut(), tx, i, flags, sigCacheStore, txdata,
                            &txLimitSigChecks, pBlockLimitSigChecks);
 
         // If pvChecks is not null, defer the check execution to the caller.
         if (pvChecks) {
             pvChecks->push_back(std::move(check));
             continue;
         }
 
         if (!check()) {
             ScriptError scriptError = check.GetScriptError();
             // Compute flags without the optional standardness flags.
             // This differs from MANDATORY_SCRIPT_VERIFY_FLAGS as it contains
             // additional upgrade flags (see AcceptToMemoryPoolWorker variable
             // extraFlags).
             uint32_t mandatoryFlags =
                 flags & ~STANDARD_NOT_MANDATORY_VERIFY_FLAGS;
             if (flags != mandatoryFlags) {
                 // Check whether the failure was caused by a non-mandatory
                 // script verification check. If so, ensure we return
                 // NOT_STANDARD instead of CONSENSUS to avoid downstream users
                 // splitting the network between upgraded and non-upgraded nodes
                 // by banning CONSENSUS-failing data providers.
                 CScriptCheck check2(coin.GetTxOut(), tx, i, mandatoryFlags,
                                     sigCacheStore, txdata);
                 if (check2()) {
                     return state.Invalid(
                         TxValidationResult::TX_NOT_STANDARD,
                         strprintf("non-mandatory-script-verify-flag (%s)",
                                   ScriptErrorString(scriptError)));
                 }
                 // update the error message to reflect the mandatory violation.
                 scriptError = check2.GetScriptError();
             }
 
             // MANDATORY flag failures correspond to
             // TxValidationResult::TX_CONSENSUS. Because CONSENSUS failures are
             // the most serious case of validation failures, we may need to
             // consider using RECENT_CONSENSUS_CHANGE for any script failure
             // that could be due to non-upgraded nodes which we may want to
             // support, to avoid splitting the network (but this depends on the
             // details of how net_processing handles such errors).
             return state.Invalid(
                 TxValidationResult::TX_CONSENSUS,
                 strprintf("mandatory-script-verify-flag-failed (%s)",
                           ScriptErrorString(scriptError)));
         }
 
         nSigChecksTotal += check.GetScriptExecutionMetrics().nSigChecks;
     }
 
     nSigChecksOut = nSigChecksTotal;
 
     if (scriptCacheStore && !pvChecks) {
         // We executed all of the provided scripts, and were told to cache the
         // result. Do so now.
         AddKeyInScriptCache(hashCacheEntry, nSigChecksTotal);
     }
 
     return true;
 }
 
 bool AbortNode(BlockValidationState &state, const std::string &strMessage,
                const bilingual_str &userMessage) {
     AbortNode(strMessage, userMessage);
     return state.Error(strMessage);
 }
 
 /** Restore the UTXO in a Coin at a given COutPoint. */
 DisconnectResult UndoCoinSpend(const Coin &undo, CCoinsViewCache &view,
                                const COutPoint &out) {
     bool fClean = true;
 
     if (view.HaveCoin(out)) {
         // Overwriting transaction output.
         fClean = false;
     }
 
     if (undo.GetHeight() == 0) {
         // Missing undo metadata (height and coinbase). Older versions included
         // this information only in undo records for the last spend of a
         // transactions' outputs. This implies that it must be present for some
         // other output of the same tx.
         const Coin &alternate = AccessByTxid(view, out.GetTxId());
         if (alternate.IsSpent()) {
             // Adding output for transaction without known metadata
             return DisconnectResult::FAILED;
         }
 
         // This is somewhat ugly, but hopefully utility is limited. This is only
         // useful when working from legacy on disck data. In any case, putting
         // the correct information in there doesn't hurt.
         const_cast<Coin &>(undo) = Coin(undo.GetTxOut(), alternate.GetHeight(),
                                         alternate.IsCoinBase());
     }
 
     // If the coin already exists as an unspent coin in the cache, then the
     // possible_overwrite parameter to AddCoin must be set to true. We have
     // already checked whether an unspent coin exists above using HaveCoin, so
     // we don't need to guess. When fClean is false, an unspent coin already
     // existed and it is an overwrite.
     view.AddCoin(out, std::move(undo), !fClean);
 
     return fClean ? DisconnectResult::OK : DisconnectResult::UNCLEAN;
 }
 
 /**
  * Undo the effects of this block (with given index) on the UTXO set represented
  * by coins. When FAILED is returned, view is left in an indeterminate state.
  */
 DisconnectResult CChainState::DisconnectBlock(const CBlock &block,
                                               const CBlockIndex *pindex,
                                               CCoinsViewCache &view) {
     AssertLockHeld(::cs_main);
     CBlockUndo blockUndo;
     if (!UndoReadFromDisk(blockUndo, pindex)) {
         error("DisconnectBlock(): failure reading undo data");
         return DisconnectResult::FAILED;
     }
 
     return ApplyBlockUndo(blockUndo, block, pindex, view);
 }
 
 DisconnectResult ApplyBlockUndo(const CBlockUndo &blockUndo,
                                 const CBlock &block, const CBlockIndex *pindex,
                                 CCoinsViewCache &view) {
     bool fClean = true;
 
     if (blockUndo.vtxundo.size() + 1 != block.vtx.size()) {
         error("DisconnectBlock(): block and undo data inconsistent");
         return DisconnectResult::FAILED;
     }
 
     // First, restore inputs.
     for (size_t i = 1; i < block.vtx.size(); i++) {
         const CTransaction &tx = *(block.vtx[i]);
         const CTxUndo &txundo = blockUndo.vtxundo[i - 1];
         if (txundo.vprevout.size() != tx.vin.size()) {
             error("DisconnectBlock(): transaction and undo data inconsistent");
             return DisconnectResult::FAILED;
         }
 
         for (size_t j = 0; j < tx.vin.size(); j++) {
             const COutPoint &out = tx.vin[j].prevout;
             const Coin &undo = txundo.vprevout[j];
             DisconnectResult res = UndoCoinSpend(undo, view, out);
             if (res == DisconnectResult::FAILED) {
                 return DisconnectResult::FAILED;
             }
             fClean = fClean && res != DisconnectResult::UNCLEAN;
         }
     }
 
     // Second, revert created outputs.
     for (const auto &ptx : block.vtx) {
         const CTransaction &tx = *ptx;
         const TxId &txid = tx.GetId();
         const bool is_coinbase = tx.IsCoinBase();
 
         // Check that all outputs are available and match the outputs in the
         // block itself exactly.
         for (size_t o = 0; o < tx.vout.size(); o++) {
             if (tx.vout[o].scriptPubKey.IsUnspendable()) {
                 continue;
             }
 
             COutPoint out(txid, o);
             Coin coin;
             bool is_spent = view.SpendCoin(out, &coin);
             if (!is_spent || tx.vout[o] != coin.GetTxOut() ||
                 uint32_t(pindex->nHeight) != coin.GetHeight() ||
                 is_coinbase != coin.IsCoinBase()) {
                 // transaction output mismatch
                 fClean = false;
             }
         }
     }
 
     // Move best block pointer to previous block.
     view.SetBestBlock(block.hashPrevBlock);
 
     return fClean ? DisconnectResult::OK : DisconnectResult::UNCLEAN;
 }
 
 static CCheckQueue<CScriptCheck> scriptcheckqueue(128);
 
 void StartScriptCheckWorkerThreads(int threads_num) {
     scriptcheckqueue.StartWorkerThreads(threads_num);
 }
 
 void StopScriptCheckWorkerThreads() {
     scriptcheckqueue.StopWorkerThreads();
 }
 
 // Returns the script flags which should be checked for the block after
 // the given block.
 static uint32_t GetNextBlockScriptFlags(const Consensus::Params &params,
                                         const CBlockIndex *pindex) {
     uint32_t flags = SCRIPT_VERIFY_NONE;
 
     // Enforce P2SH (BIP16)
     if (DeploymentActiveAfter(pindex, params, Consensus::DEPLOYMENT_P2SH)) {
         flags |= SCRIPT_VERIFY_P2SH;
     }
 
     // Enforce the DERSIG (BIP66) rule.
     if (DeploymentActiveAfter(pindex, params, Consensus::DEPLOYMENT_DERSIG)) {
         flags |= SCRIPT_VERIFY_DERSIG;
     }
 
     // Start enforcing CHECKLOCKTIMEVERIFY (BIP65) rule.
     if (DeploymentActiveAfter(pindex, params, Consensus::DEPLOYMENT_CLTV)) {
         flags |= SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY;
     }
 
     // Start enforcing CSV (BIP68, BIP112 and BIP113) rule.
     if (DeploymentActiveAfter(pindex, params, Consensus::DEPLOYMENT_CSV)) {
         flags |= SCRIPT_VERIFY_CHECKSEQUENCEVERIFY;
     }
 
     // If the UAHF is enabled, we start accepting replay protected txns
     if (IsUAHFenabled(params, pindex)) {
         flags |= SCRIPT_VERIFY_STRICTENC;
         flags |= SCRIPT_ENABLE_SIGHASH_FORKID;
     }
 
     // If the DAA HF is enabled, we start rejecting transaction that use a high
     // s in their signature. We also make sure that signature that are supposed
     // to fail (for instance in multisig or other forms of smart contracts) are
     // null.
     if (IsDAAEnabled(params, pindex)) {
         flags |= SCRIPT_VERIFY_LOW_S;
         flags |= SCRIPT_VERIFY_NULLFAIL;
     }
 
     // When the magnetic anomaly fork is enabled, we start accepting
     // transactions using the OP_CHECKDATASIG opcode and it's verify
     // alternative. We also start enforcing push only signatures and
     // clean stack.
     if (IsMagneticAnomalyEnabled(params, pindex)) {
         flags |= SCRIPT_VERIFY_SIGPUSHONLY;
         flags |= SCRIPT_VERIFY_CLEANSTACK;
     }
 
     if (IsGravitonEnabled(params, pindex)) {
         flags |= SCRIPT_ENABLE_SCHNORR_MULTISIG;
         flags |= SCRIPT_VERIFY_MINIMALDATA;
     }
 
     if (IsPhononEnabled(params, pindex)) {
         flags |= SCRIPT_ENFORCE_SIGCHECKS;
     }
 
     // We make sure this node will have replay protection during the next hard
     // fork.
     if (IsReplayProtectionEnabled(params, pindex)) {
         flags |= SCRIPT_ENABLE_REPLAY_PROTECTION;
     }
 
     return flags;
 }
 
 static int64_t nTimeCheck = 0;
 static int64_t nTimeForks = 0;
 static int64_t nTimeVerify = 0;
 static int64_t nTimeConnect = 0;
 static int64_t nTimeIndex = 0;
 static int64_t nTimeTotal = 0;
 static int64_t nBlocksTotal = 0;
 
 /**
  * Apply the effects of this block (with given index) on the UTXO set
  * represented by coins. Validity checks that depend on the UTXO set are also
  * done; ConnectBlock() can fail if those validity checks fail (among other
  * reasons).
  */
 bool CChainState::ConnectBlock(const CBlock &block, BlockValidationState &state,
                                CBlockIndex *pindex, CCoinsViewCache &view,
                                BlockValidationOptions options,
                                bool fJustCheck) {
     AssertLockHeld(cs_main);
     assert(pindex);
 
     const BlockHash block_hash{block.GetHash()};
     assert(*pindex->phashBlock == block_hash);
 
     int64_t nTimeStart = GetTimeMicros();
 
     const Consensus::Params &consensusParams = m_params.GetConsensus();
 
     // Check it again in case a previous version let a bad block in
     // NOTE: We don't currently (re-)invoke ContextualCheckBlock() or
     // ContextualCheckBlockHeader() here. This means that if we add a new
     // consensus rule that is enforced in one of those two functions, then we
     // may have let in a block that violates the rule prior to updating the
     // software, and we would NOT be enforcing the rule here. Fully solving
     // upgrade from one software version to the next after a consensus rule
     // change is potentially tricky and issue-specific.
     // Also, currently the rule against blocks more than 2 hours in the future
     // is enforced in ContextualCheckBlockHeader(); we wouldn't want to
     // re-enforce that rule here (at least until we make it impossible for
     // GetAdjustedTime() to go backward).
     if (!CheckBlock(block, state, consensusParams,
                     options.withCheckPoW(!fJustCheck)
                         .withCheckMerkleRoot(!fJustCheck))) {
         if (state.GetResult() == BlockValidationResult::BLOCK_MUTATED) {
             // We don't write down blocks to disk if they may have been
             // corrupted, so this should be impossible unless we're having
             // hardware problems.
             return AbortNode(state, "Corrupt block found indicating potential "
                                     "hardware failure; shutting down");
         }
         return error("%s: Consensus::CheckBlock: %s", __func__,
                      state.ToString());
     }
 
     // Verify that the view's current state corresponds to the previous block
     BlockHash hashPrevBlock =
         pindex->pprev == nullptr ? BlockHash() : pindex->pprev->GetBlockHash();
     assert(hashPrevBlock == view.GetBestBlock());
 
     nBlocksTotal++;
 
     // Special case for the genesis block, skipping connection of its
     // transactions (its coinbase is unspendable)
     if (block_hash == consensusParams.hashGenesisBlock) {
         if (!fJustCheck) {
             view.SetBestBlock(pindex->GetBlockHash());
         }
 
         return true;
     }
 
     bool fScriptChecks = true;
     if (!hashAssumeValid.IsNull()) {
         // We've been configured with the hash of a block which has been
         // externally verified to have a valid history. A suitable default value
         // is included with the software and updated from time to time. Because
         // validity relative to a piece of software is an objective fact these
         // defaults can be easily reviewed. This setting doesn't force the
         // selection of any particular chain but makes validating some faster by
         // effectively caching the result of part of the verification.
         BlockMap::const_iterator it =
             m_blockman.m_block_index.find(hashAssumeValid);
         if (it != m_blockman.m_block_index.end()) {
             if (it->second.GetAncestor(pindex->nHeight) == pindex &&
                 m_chainman.m_best_header->GetAncestor(pindex->nHeight) ==
                     pindex &&
                 m_chainman.m_best_header->nChainWork >= nMinimumChainWork) {
                 // This block is a member of the assumed verified chain and an
                 // ancestor of the best header.
                 // Script verification is skipped when connecting blocks under
                 // the assumevalid block. Assuming the assumevalid block is
                 // valid this is safe because block merkle hashes are still
                 // computed and checked, Of course, if an assumed valid block is
                 // invalid due to false scriptSigs this optimization would allow
                 // an invalid chain to be accepted.
                 // The equivalent time check discourages hash power from
                 // extorting the network via DOS attack into accepting an
                 // invalid block through telling users they must manually set
                 // assumevalid. Requiring a software change or burying the
                 // invalid block, regardless of the setting, makes it hard to
                 // hide the implication of the demand. This also avoids having
                 // release candidates that are hardly doing any signature
                 // verification at all in testing without having to artificially
                 // set the default assumed verified block further back. The test
                 // against nMinimumChainWork prevents the skipping when denied
                 // access to any chain at least as good as the expected chain.
                 fScriptChecks = (GetBlockProofEquivalentTime(
                                      *m_chainman.m_best_header, *pindex,
                                      *m_chainman.m_best_header,
                                      consensusParams) <= 60 * 60 * 24 * 7 * 2);
             }
         }
     }
 
     int64_t nTime1 = GetTimeMicros();
     nTimeCheck += nTime1 - nTimeStart;
     LogPrint(BCLog::BENCH, "    - Sanity checks: %.2fms [%.2fs (%.2fms/blk)]\n",
              MILLI * (nTime1 - nTimeStart), nTimeCheck * MICRO,
              nTimeCheck * MILLI / nBlocksTotal);
 
     // Do not allow blocks that contain transactions which 'overwrite' older
     // transactions, unless those are already completely spent. If such
     // overwrites are allowed, coinbases and transactions depending upon those
     // can be duplicated to remove the ability to spend the first instance --
     // even after being sent to another address.
     // See BIP30, CVE-2012-1909, and http://r6.ca/blog/20120206T005236Z.html
     // for more information. This rule was originally applied to all blocks
     // with a timestamp after March 15, 2012, 0:00 UTC. Now that the whole
     // chain is irreversibly beyond that time it is applied to all blocks
     // except the two in the chain that violate it. This prevents exploiting
     // the issue against nodes during their initial block download.
     bool fEnforceBIP30 = !((pindex->nHeight == 91842 &&
                             pindex->GetBlockHash() ==
                                 uint256S("0x00000000000a4d0a398161ffc163c503763"
                                          "b1f4360639393e0e4c8e300e0caec")) ||
                            (pindex->nHeight == 91880 &&
                             pindex->GetBlockHash() ==
                                 uint256S("0x00000000000743f190a18c5577a3c2d2a1f"
                                          "610ae9601ac046a38084ccb7cd721")));
 
     // Once BIP34 activated it was not possible to create new duplicate
     // coinbases and thus other than starting with the 2 existing duplicate
     // coinbase pairs, not possible to create overwriting txs. But by the time
     // BIP34 activated, in each of the existing pairs the duplicate coinbase had
     // overwritten the first before the first had been spent. Since those
     // coinbases are sufficiently buried it's no longer possible to create
     // further duplicate transactions descending from the known pairs either. If
     // we're on the known chain at height greater than where BIP34 activated, we
     // can save the db accesses needed for the BIP30 check.
 
     // BIP34 requires that a block at height X (block X) has its coinbase
     // scriptSig start with a CScriptNum of X (indicated height X).  The above
     // logic of no longer requiring BIP30 once BIP34 activates is flawed in the
     // case that there is a block X before the BIP34 height of 227,931 which has
     // an indicated height Y where Y is greater than X.  The coinbase for block
     // X would also be a valid coinbase for block Y, which could be a BIP30
     // violation.  An exhaustive search of all mainnet coinbases before the
     // BIP34 height which have an indicated height greater than the block height
     // reveals many occurrences. The 3 lowest indicated heights found are
     // 209,921, 490,897, and 1,983,702 and thus coinbases for blocks at these 3
     // heights would be the first opportunity for BIP30 to be violated.
 
     // The search reveals a great many blocks which have an indicated height
     // greater than 1,983,702, so we simply remove the optimization to skip
     // BIP30 checking for blocks at height 1,983,702 or higher.  Before we reach
     // that block in another 25 years or so, we should take advantage of a
     // future consensus change to do a new and improved version of BIP34 that
     // will actually prevent ever creating any duplicate coinbases in the
     // future.
     static constexpr int BIP34_IMPLIES_BIP30_LIMIT = 1983702;
 
     // There is no potential to create a duplicate coinbase at block 209,921
     // because this is still before the BIP34 height and so explicit BIP30
     // checking is still active.
 
     // The final case is block 176,684 which has an indicated height of
     // 490,897. Unfortunately, this issue was not discovered until about 2 weeks
     // before block 490,897 so there was not much opportunity to address this
     // case other than to carefully analyze it and determine it would not be a
     // problem. Block 490,897 was, in fact, mined with a different coinbase than
     // block 176,684, but it is important to note that even if it hadn't been or
     // is remined on an alternate fork with a duplicate coinbase, we would still
     // not run into a BIP30 violation.  This is because the coinbase for 176,684
     // is spent in block 185,956 in transaction
     // d4f7fbbf92f4a3014a230b2dc70b8058d02eb36ac06b4a0736d9d60eaa9e8781.  This
     // spending transaction can't be duplicated because it also spends coinbase
     // 0328dd85c331237f18e781d692c92de57649529bd5edf1d01036daea32ffde29.  This
     // coinbase has an indicated height of over 4.2 billion, and wouldn't be
     // duplicatable until that height, and it's currently impossible to create a
     // chain that long. Nevertheless we may wish to consider a future soft fork
     // which retroactively prevents block 490,897 from creating a duplicate
     // coinbase. The two historical BIP30 violations often provide a confusing
     // edge case when manipulating the UTXO and it would be simpler not to have
     // another edge case to deal with.
 
     // testnet3 has no blocks before the BIP34 height with indicated heights
     // post BIP34 before approximately height 486,000,000 and presumably will
     // be reset before it reaches block 1,983,702 and starts doing unnecessary
     // BIP30 checking again.
     assert(pindex->pprev);
     CBlockIndex *pindexBIP34height =
         pindex->pprev->GetAncestor(consensusParams.BIP34Height);
     // Only continue to enforce if we're below BIP34 activation height or the
     // block hash at that height doesn't correspond.
     fEnforceBIP30 =
         fEnforceBIP30 &&
         (!pindexBIP34height ||
          !(pindexBIP34height->GetBlockHash() == consensusParams.BIP34Hash));
 
     // TODO: Remove BIP30 checking from block height 1,983,702 on, once we have
     // a consensus change that ensures coinbases at those heights can not
     // duplicate earlier coinbases.
     if (fEnforceBIP30 || pindex->nHeight >= BIP34_IMPLIES_BIP30_LIMIT) {
         for (const auto &tx : block.vtx) {
             for (size_t o = 0; o < tx->vout.size(); o++) {
                 if (view.HaveCoin(COutPoint(tx->GetId(), o))) {
                     LogPrintf("ERROR: ConnectBlock(): tried to overwrite "
                               "transaction\n");
                     return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
                                          "bad-txns-BIP30");
                 }
             }
         }
     }
 
     // Enforce BIP68 (sequence locks).
     int nLockTimeFlags = 0;
     if (DeploymentActiveAt(*pindex, consensusParams,
                            Consensus::DEPLOYMENT_CSV)) {
         nLockTimeFlags |= LOCKTIME_VERIFY_SEQUENCE;
     }
 
     const uint32_t flags =
         GetNextBlockScriptFlags(consensusParams, pindex->pprev);
 
     int64_t nTime2 = GetTimeMicros();
     nTimeForks += nTime2 - nTime1;
     LogPrint(BCLog::BENCH, "    - Fork checks: %.2fms [%.2fs (%.2fms/blk)]\n",
              MILLI * (nTime2 - nTime1), nTimeForks * MICRO,
              nTimeForks * MILLI / nBlocksTotal);
 
     std::vector<int> prevheights;
     Amount nFees = Amount::zero();
     int nInputs = 0;
 
     // Limit the total executed signature operations in the block, a consensus
     // rule. Tracking during the CPU-consuming part (validation of uncached
     // inputs) is per-input atomic and validation in each thread stops very
     // quickly after the limit is exceeded, so an adversary cannot cause us to
     // exceed the limit by much at all.
     CheckInputsLimiter nSigChecksBlockLimiter(
         GetMaxBlockSigChecksCount(options.getExcessiveBlockSize()));
 
     std::vector<TxSigCheckLimiter> nSigChecksTxLimiters;
     nSigChecksTxLimiters.resize(block.vtx.size() - 1);
 
     CBlockUndo blockundo;
     blockundo.vtxundo.resize(block.vtx.size() - 1);
 
     CCheckQueueControl<CScriptCheck> control(fScriptChecks ? &scriptcheckqueue
                                                            : nullptr);
 
     // Add all outputs
     try {
         for (const auto &ptx : block.vtx) {
             AddCoins(view, *ptx, pindex->nHeight);
         }
     } catch (const std::logic_error &e) {
         // This error will be thrown from AddCoin if we try to connect a block
         // containing duplicate transactions. Such a thing should normally be
         // caught early nowadays (due to ContextualCheckBlock's CTOR
         // enforcement) however some edge cases can escape that:
         // - ContextualCheckBlock does not get re-run after saving the block to
         // disk, and older versions may have saved a weird block.
         // - its checks are not applied to pre-CTOR chains, which we might visit
         // with checkpointing off.
         LogPrintf("ERROR: ConnectBlock(): tried to overwrite transaction\n");
         return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
                              "tx-duplicate");
     }
 
     size_t txIndex = 0;
     // nSigChecksRet may be accurate (found in cache) or 0 (checks were
     // deferred into vChecks).
     int nSigChecksRet;
     for (const auto &ptx : block.vtx) {
         const CTransaction &tx = *ptx;
         const bool isCoinBase = tx.IsCoinBase();
         nInputs += tx.vin.size();
 
         {
             Amount txfee = Amount::zero();
             TxValidationState tx_state;
             if (!isCoinBase &&
                 !Consensus::CheckTxInputs(tx, tx_state, view, pindex->nHeight,
                                           txfee)) {
                 // Any transaction validation failure in ConnectBlock is a block
                 // consensus failure.
                 state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
                               tx_state.GetRejectReason(),
                               tx_state.GetDebugMessage());
 
                 return error("%s: Consensus::CheckTxInputs: %s, %s", __func__,
                              tx.GetId().ToString(), state.ToString());
             }
             nFees += txfee;
         }
 
         if (!MoneyRange(nFees)) {
             LogPrintf("ERROR: %s: accumulated fee in the block out of range.\n",
                       __func__);
             return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
                                  "bad-txns-accumulated-fee-outofrange");
         }
 
         // The following checks do not apply to the coinbase.
         if (isCoinBase) {
             continue;
         }
 
         // Check that transaction is BIP68 final BIP68 lock checks (as
         // opposed to nLockTime checks) must be in ConnectBlock because they
         // require the UTXO set.
         prevheights.resize(tx.vin.size());
         for (size_t j = 0; j < tx.vin.size(); j++) {
             prevheights[j] = view.AccessCoin(tx.vin[j].prevout).GetHeight();
         }
 
         if (!SequenceLocks(tx, nLockTimeFlags, prevheights, *pindex)) {
             LogPrintf("ERROR: %s: contains a non-BIP68-final transaction\n",
                       __func__);
             return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
                                  "bad-txns-nonfinal");
         }
 
         // Don't cache results if we're actually connecting blocks (still
         // consult the cache, though).
         bool fCacheResults = fJustCheck;
 
         const bool fEnforceSigCheck = flags & SCRIPT_ENFORCE_SIGCHECKS;
         if (!fEnforceSigCheck) {
             // Historically, there has been transactions with a very high
             // sigcheck count, so we need to disable this check for such
             // transactions.
             nSigChecksTxLimiters[txIndex] = TxSigCheckLimiter::getDisabled();
         }
 
         std::vector<CScriptCheck> vChecks;
         TxValidationState tx_state;
         if (fScriptChecks &&
             !CheckInputScripts(tx, tx_state, view, flags, fCacheResults,
                                fCacheResults, PrecomputedTransactionData(tx),
                                nSigChecksRet, nSigChecksTxLimiters[txIndex],
                                &nSigChecksBlockLimiter, &vChecks)) {
             // Any transaction validation failure in ConnectBlock is a block
             // consensus failure
             state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
                           tx_state.GetRejectReason(),
                           tx_state.GetDebugMessage());
             return error(
                 "ConnectBlock(): CheckInputScripts on %s failed with %s",
                 tx.GetId().ToString(), state.ToString());
         }
 
         control.Add(vChecks);
 
         // Note: this must execute in the same iteration as CheckTxInputs (not
         // in a separate loop) in order to detect double spends. However,
         // this does not prevent double-spending by duplicated transaction
         // inputs in the same transaction (cf. CVE-2018-17144) -- that check is
         // done in CheckBlock (CheckRegularTransaction).
         SpendCoins(view, tx, blockundo.vtxundo.at(txIndex), pindex->nHeight);
         txIndex++;
     }
 
     int64_t nTime3 = GetTimeMicros();
     nTimeConnect += nTime3 - nTime2;
     LogPrint(BCLog::BENCH,
              "      - Connect %u transactions: %.2fms (%.3fms/tx, %.3fms/txin) "
              "[%.2fs (%.2fms/blk)]\n",
              (unsigned)block.vtx.size(), MILLI * (nTime3 - nTime2),
              MILLI * (nTime3 - nTime2) / block.vtx.size(),
              nInputs <= 1 ? 0 : MILLI * (nTime3 - nTime2) / (nInputs - 1),
              nTimeConnect * MICRO, nTimeConnect * MILLI / nBlocksTotal);
 
     const Amount blockReward =
         nFees + GetBlockSubsidy(pindex->nHeight, consensusParams);
     if (block.vtx[0]->GetValueOut() > blockReward) {
         LogPrintf("ERROR: ConnectBlock(): coinbase pays too much (actual=%d vs "
                   "limit=%d)\n",
                   block.vtx[0]->GetValueOut(), blockReward);
         return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
                              "bad-cb-amount");
     }
 
     const std::vector<CTxDestination> whitelist =
         GetMinerFundWhitelist(consensusParams, pindex->pprev);
     if (!whitelist.empty()) {
         const Amount required = GetMinerFundAmount(blockReward);
 
         for (auto &o : block.vtx[0]->vout) {
             if (o.nValue < required) {
                 // This output doesn't qualify because its amount is too low.
                 continue;
             }
 
             CTxDestination address;
             if (!ExtractDestination(o.scriptPubKey, address)) {
                 // Cannot decode address.
                 continue;
             }
 
             if (std::find(whitelist.begin(), whitelist.end(), address) !=
                 whitelist.end()) {
                 goto MinerFundSuccess;
             }
         }
 
         // We did not find an output that match the miner fund requirements.
         return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
                              "bad-cb-minerfund");
     }
 
 MinerFundSuccess:
 
     if (!control.Wait()) {
         return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
                              "blk-bad-inputs", "parallel script check failed");
     }
 
     int64_t nTime4 = GetTimeMicros();
     nTimeVerify += nTime4 - nTime2;
     LogPrint(
         BCLog::BENCH,
         "    - Verify %u txins: %.2fms (%.3fms/txin) [%.2fs (%.2fms/blk)]\n",
         nInputs - 1, MILLI * (nTime4 - nTime2),
         nInputs <= 1 ? 0 : MILLI * (nTime4 - nTime2) / (nInputs - 1),
         nTimeVerify * MICRO, nTimeVerify * MILLI / nBlocksTotal);
 
     if (fJustCheck) {
         return true;
     }
 
     if (!m_blockman.WriteUndoDataForBlock(blockundo, state, pindex, m_params)) {
         return false;
     }
 
     if (!pindex->IsValid(BlockValidity::SCRIPTS)) {
         pindex->RaiseValidity(BlockValidity::SCRIPTS);
         m_blockman.m_dirty_blockindex.insert(pindex);
     }
 
     assert(pindex->phashBlock);
     // add this block to the view's block chain
     view.SetBestBlock(pindex->GetBlockHash());
 
     int64_t nTime5 = GetTimeMicros();
     nTimeIndex += nTime5 - nTime4;
     LogPrint(BCLog::BENCH, "    - Index writing: %.2fms [%.2fs (%.2fms/blk)]\n",
              MILLI * (nTime5 - nTime4), nTimeIndex * MICRO,
              nTimeIndex * MILLI / nBlocksTotal);
 
     TRACE6(validation, block_connected, block_hash.data(), pindex->nHeight,
            block.vtx.size(), nInputs, nSigChecksRet,
            // in microseconds (µs)
            nTime5 - nTimeStart);
 
     return true;
 }
 
 CoinsCacheSizeState CChainState::GetCoinsCacheSizeState() {
     AssertLockHeld(::cs_main);
     return this->GetCoinsCacheSizeState(
         m_coinstip_cache_size_bytes,
         gArgs.GetIntArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000);
 }
 
 CoinsCacheSizeState
 CChainState::GetCoinsCacheSizeState(size_t max_coins_cache_size_bytes,
                                     size_t max_mempool_size_bytes) {
     AssertLockHeld(::cs_main);
     int64_t nMempoolUsage = m_mempool ? m_mempool->DynamicMemoryUsage() : 0;
     int64_t cacheSize = CoinsTip().DynamicMemoryUsage();
     int64_t nTotalSpace =
         max_coins_cache_size_bytes +
         std::max<int64_t>(int64_t(max_mempool_size_bytes) - nMempoolUsage, 0);
 
     //! No need to periodic flush if at least this much space still available.
     static constexpr int64_t MAX_BLOCK_COINSDB_USAGE_BYTES =
         10 * 1024 * 1024; // 10MB
     int64_t large_threshold = std::max(
         (9 * nTotalSpace) / 10, nTotalSpace - MAX_BLOCK_COINSDB_USAGE_BYTES);
 
     if (cacheSize > nTotalSpace) {
         LogPrintf("Cache size (%s) exceeds total space (%s)\n", cacheSize,
                   nTotalSpace);
         return CoinsCacheSizeState::CRITICAL;
     } else if (cacheSize > large_threshold) {
         return CoinsCacheSizeState::LARGE;
     }
     return CoinsCacheSizeState::OK;
 }
 
 bool CChainState::FlushStateToDisk(BlockValidationState &state,
                                    FlushStateMode mode,
                                    int nManualPruneHeight) {
     LOCK(cs_main);
     assert(this->CanFlushToDisk());
     static std::chrono::microseconds nLastWrite{0};
     static std::chrono::microseconds nLastFlush{0};
     std::set<int> setFilesToPrune;
     bool full_flush_completed = false;
 
     const size_t coins_count = CoinsTip().GetCacheSize();
     const size_t coins_mem_usage = CoinsTip().DynamicMemoryUsage();
 
     try {
         {
             bool fFlushForPrune = false;
             bool fDoFullFlush = false;
 
             CoinsCacheSizeState cache_state = GetCoinsCacheSizeState();
             LOCK(m_blockman.cs_LastBlockFile);
             if (fPruneMode &&
                 (m_blockman.m_check_for_pruning || nManualPruneHeight > 0) &&
                 !fReindex) {
                 // Make sure we don't prune above the blockfilterindexes
                 // bestblocks. Pruning is height-based.
                 int last_prune = m_chain.Height();
                 ForEachBlockFilterIndex([&](BlockFilterIndex &index) {
                     last_prune = std::max(
                         1, std::min(last_prune,
                                     index.GetSummary().best_block_height));
                 });
 
                 if (nManualPruneHeight > 0) {
                     LOG_TIME_MILLIS_WITH_CATEGORY(
                         "find files to prune (manual)", BCLog::BENCH);
                     m_blockman.FindFilesToPruneManual(
                         setFilesToPrune,
                         std::min(last_prune, nManualPruneHeight),
                         m_chain.Height());
                 } else {
                     LOG_TIME_MILLIS_WITH_CATEGORY("find files to prune",
                                                   BCLog::BENCH);
                     m_blockman.FindFilesToPrune(
                         setFilesToPrune, m_params.PruneAfterHeight(),
                         m_chain.Height(), last_prune, IsInitialBlockDownload());
                     m_blockman.m_check_for_pruning = false;
                 }
                 if (!setFilesToPrune.empty()) {
                     fFlushForPrune = true;
                     if (!m_blockman.m_have_pruned) {
                         m_blockman.m_block_tree_db->WriteFlag(
                             "prunedblockfiles", true);
                         m_blockman.m_have_pruned = true;
                     }
                 }
             }
             const auto nNow = GetTime<std::chrono::microseconds>();
             // Avoid writing/flushing immediately after startup.
             if (nLastWrite.count() == 0) {
                 nLastWrite = nNow;
             }
             if (nLastFlush.count() == 0) {
                 nLastFlush = nNow;
             }
             // The cache is large and we're within 10% and 10 MiB of the limit,
             // but we have time now (not in the middle of a block processing).
             bool fCacheLarge = mode == FlushStateMode::PERIODIC &&
                                cache_state >= CoinsCacheSizeState::LARGE;
             // The cache is over the limit, we have to write now.
             bool fCacheCritical = mode == FlushStateMode::IF_NEEDED &&
                                   cache_state >= CoinsCacheSizeState::CRITICAL;
             // It's been a while since we wrote the block index to disk. Do this
             // frequently, so we don't need to redownload after a crash.
             bool fPeriodicWrite = mode == FlushStateMode::PERIODIC &&
                                   nNow > nLastWrite + DATABASE_WRITE_INTERVAL;
             // It's been very long since we flushed the cache. Do this
             // infrequently, to optimize cache usage.
             bool fPeriodicFlush = mode == FlushStateMode::PERIODIC &&
                                   nNow > nLastFlush + DATABASE_FLUSH_INTERVAL;
             // Combine all conditions that result in a full cache flush.
             fDoFullFlush = (mode == FlushStateMode::ALWAYS) || fCacheLarge ||
                            fCacheCritical || fPeriodicFlush || fFlushForPrune;
             // Write blocks and block index to disk.
             if (fDoFullFlush || fPeriodicWrite) {
                 // Ensure we can write block index
                 if (!CheckDiskSpace(gArgs.GetBlocksDirPath())) {
                     return AbortNode(state, "Disk space is too low!",
                                      _("Disk space is too low!"));
                 }
 
                 {
                     LOG_TIME_MILLIS_WITH_CATEGORY(
                         "write block and undo data to disk", BCLog::BENCH);
 
                     // First make sure all block and undo data is flushed to
                     // disk.
                     m_blockman.FlushBlockFile();
                 }
                 // Then update all block file information (which may refer to
                 // block and undo files).
                 {
                     LOG_TIME_MILLIS_WITH_CATEGORY("write block index to disk",
                                                   BCLog::BENCH);
 
                     if (!m_blockman.WriteBlockIndexDB()) {
                         return AbortNode(
                             state, "Failed to write to block index database");
                     }
                 }
 
                 // Finally remove any pruned files
                 if (fFlushForPrune) {
                     LOG_TIME_MILLIS_WITH_CATEGORY("unlink pruned files",
                                                   BCLog::BENCH);
 
                     UnlinkPrunedFiles(setFilesToPrune);
                 }
                 nLastWrite = nNow;
             }
             // Flush best chain related state. This can only be done if the
             // blocks / block index write was also done.
             if (fDoFullFlush && !CoinsTip().GetBestBlock().IsNull()) {
                 LOG_TIME_MILLIS_WITH_CATEGORY(
                     strprintf("write coins cache to disk (%d coins, %.2fkB)",
                               coins_count, coins_mem_usage / 1000),
                     BCLog::BENCH);
 
                 // Typical Coin structures on disk are around 48 bytes in size.
                 // Pushing a new one to the database can cause it to be written
                 // twice (once in the log, and once in the tables). This is
                 // already an overestimation, as most will delete an existing
                 // entry or overwrite one. Still, use a conservative safety
                 // factor of 2.
                 if (!CheckDiskSpace(gArgs.GetDataDirNet(),
                                     48 * 2 * 2 * CoinsTip().GetCacheSize())) {
                     return AbortNode(state, "Disk space is too low!",
                                      _("Disk space is too low!"));
                 }
 
                 // Flush the chainstate (which may refer to block index
                 // entries).
                 if (!CoinsTip().Flush()) {
                     return AbortNode(state, "Failed to write to coin database");
                 }
                 nLastFlush = nNow;
                 full_flush_completed = true;
             }
 
             TRACE5(utxocache, flush,
                    // in microseconds (µs)
                    GetTimeMicros() - nNow.count(), uint32_t(mode), coins_count,
                    uint64_t(coins_mem_usage), fFlushForPrune);
         }
 
         if (full_flush_completed) {
             // Update best block in wallet (so we can detect restored wallets).
             GetMainSignals().ChainStateFlushed(m_chain.GetLocator());
         }
     } catch (const std::runtime_error &e) {
         return AbortNode(state, std::string("System error while flushing: ") +
                                     e.what());
     }
     return true;
 }
 
 void CChainState::ForceFlushStateToDisk() {
     BlockValidationState state;
     if (!this->FlushStateToDisk(state, FlushStateMode::ALWAYS)) {
         LogPrintf("%s: failed to flush state (%s)\n", __func__,
                   state.ToString());
     }
 }
 
 void CChainState::PruneAndFlush() {
     BlockValidationState state;
     m_blockman.m_check_for_pruning = true;
     if (!this->FlushStateToDisk(state, FlushStateMode::NONE)) {
         LogPrintf("%s: failed to flush state (%s)\n", __func__,
                   state.ToString());
     }
 }
 
 static void UpdateTipLog(const CCoinsViewCache &coins_tip,
                          const CBlockIndex *tip, const CChainParams &params,
                          const std::string &func_name,
                          const std::string &prefix)
     EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
     AssertLockHeld(::cs_main);
     LogPrintf("%s%s: new best=%s height=%d version=0x%08x log2_work=%f tx=%ld "
               "date='%s' progress=%f cache=%.1fMiB(%utxo)\n",
               prefix, func_name, tip->GetBlockHash().ToString(), tip->nHeight,
               tip->nVersion, log(tip->nChainWork.getdouble()) / log(2.0),
               tip->GetChainTxCount(),
               FormatISO8601DateTime(tip->GetBlockTime()),
               GuessVerificationProgress(params.TxData(), tip),
               coins_tip.DynamicMemoryUsage() * (1.0 / (1 << 20)),
               coins_tip.GetCacheSize());
 }
 
 void CChainState::UpdateTip(const CBlockIndex *pindexNew) {
     AssertLockHeld(::cs_main);
     const auto &coins_tip = CoinsTip();
 
     // The remainder of the function isn't relevant if we are not acting on
     // the active chainstate, so return if need be.
     if (this != &m_chainman.ActiveChainstate()) {
         // Only log every so often so that we don't bury log messages at the
         // tip.
         constexpr int BACKGROUND_LOG_INTERVAL = 2000;
         if (pindexNew->nHeight % BACKGROUND_LOG_INTERVAL == 0) {
             UpdateTipLog(coins_tip, pindexNew, m_params, __func__,
                          "[background validation] ");
         }
         return;
     }
 
     // New best block
     if (m_mempool) {
         m_mempool->AddTransactionsUpdated(1);
     }
 
     {
         LOCK(g_best_block_mutex);
         g_best_block = pindexNew->GetBlockHash();
         g_best_block_cv.notify_all();
     }
 
     UpdateTipLog(coins_tip, pindexNew, m_params, __func__, "");
 }
 
 /**
  * Disconnect m_chain's tip.
  * After calling, the mempool will be in an inconsistent state, with
  * transactions from disconnected blocks being added to disconnectpool. You
  * should make the mempool consistent again by calling updateMempoolForReorg.
  * with cs_main held.
  *
  * If disconnectpool is nullptr, then no disconnected transactions are added to
  * disconnectpool (note that the caller is responsible for mempool consistency
  * in any case).
  */
 bool CChainState::DisconnectTip(BlockValidationState &state,
                                 DisconnectedBlockTransactions *disconnectpool) {
     AssertLockHeld(cs_main);
     if (m_mempool) {
         AssertLockHeld(m_mempool->cs);
     }
 
     CBlockIndex *pindexDelete = m_chain.Tip();
     const Consensus::Params &consensusParams = m_params.GetConsensus();
 
     assert(pindexDelete);
 
     // Read block from disk.
     std::shared_ptr<CBlock> pblock = std::make_shared<CBlock>();
     CBlock &block = *pblock;
     if (!ReadBlockFromDisk(block, pindexDelete, consensusParams)) {
         return error("DisconnectTip(): Failed to read block");
     }
 
     // Apply the block atomically to the chain state.
     int64_t nStart = GetTimeMicros();
     {
         CCoinsViewCache view(&CoinsTip());
         assert(view.GetBestBlock() == pindexDelete->GetBlockHash());
         if (DisconnectBlock(block, pindexDelete, view) !=
             DisconnectResult::OK) {
             return error("DisconnectTip(): DisconnectBlock %s failed",
                          pindexDelete->GetBlockHash().ToString());
         }
 
         bool flushed = view.Flush();
         assert(flushed);
     }
 
     LogPrint(BCLog::BENCH, "- Disconnect block: %.2fms\n",
              (GetTimeMicros() - nStart) * MILLI);
 
     // Write the chain state to disk, if necessary.
     if (!FlushStateToDisk(state, FlushStateMode::IF_NEEDED)) {
         return false;
     }
 
     if (m_mempool) {
         // If this block is deactivating a fork, we move all mempool
         // transactions in front of disconnectpool for reprocessing in a future
         // updateMempoolForReorg call
         if (pindexDelete->pprev != nullptr &&
             GetNextBlockScriptFlags(consensusParams, pindexDelete) !=
                 GetNextBlockScriptFlags(consensusParams, pindexDelete->pprev)) {
             LogPrint(BCLog::MEMPOOL,
                      "Disconnecting mempool due to rewind of upgrade block\n");
             if (disconnectpool) {
                 disconnectpool->importMempool(*m_mempool);
             }
             m_mempool->clear();
         }
 
         if (disconnectpool) {
             disconnectpool->addForBlock(block.vtx, *m_mempool);
         }
     }
 
-    // If the tip is finalized, then undo it.
-    if (m_finalizedBlockIndex == pindexDelete) {
-        m_finalizedBlockIndex = pindexDelete->pprev;
-    }
-
     m_chain.SetTip(pindexDelete->pprev);
 
     UpdateTip(pindexDelete->pprev);
     // Let wallets know transactions went from 1-confirmed to
     // 0-confirmed or conflicted:
     GetMainSignals().BlockDisconnected(pblock, pindexDelete);
     return true;
 }
 
 static int64_t nTimeReadFromDisk = 0;
 static int64_t nTimeConnectTotal = 0;
 static int64_t nTimeFlush = 0;
 static int64_t nTimeChainState = 0;
 static int64_t nTimePostConnect = 0;
 
 struct PerBlockConnectTrace {
     CBlockIndex *pindex = nullptr;
     std::shared_ptr<const CBlock> pblock;
     PerBlockConnectTrace() {}
 };
 
 /**
  * Used to track blocks whose transactions were applied to the UTXO state as a
  * part of a single ActivateBestChainStep call.
  *
  * This class is single-use, once you call GetBlocksConnected() you have to
  * throw it away and make a new one.
  */
 class ConnectTrace {
 private:
     std::vector<PerBlockConnectTrace> blocksConnected;
 
 public:
     explicit ConnectTrace() : blocksConnected(1) {}
 
     void BlockConnected(CBlockIndex *pindex,
                         std::shared_ptr<const CBlock> pblock) {
         assert(!blocksConnected.back().pindex);
         assert(pindex);
         assert(pblock);
         blocksConnected.back().pindex = pindex;
         blocksConnected.back().pblock = std::move(pblock);
         blocksConnected.emplace_back();
     }
 
     std::vector<PerBlockConnectTrace> &GetBlocksConnected() {
         // We always keep one extra block at the end of our list because blocks
         // are added after all the conflicted transactions have been filled in.
         // Thus, the last entry should always be an empty one waiting for the
         // transactions from the next block. We pop the last entry here to make
         // sure the list we return is sane.
         assert(!blocksConnected.back().pindex);
         blocksConnected.pop_back();
         return blocksConnected;
     }
 };
 
-bool CChainState::MarkBlockAsFinal(BlockValidationState &state,
-                                   const CBlockIndex *pindex) {
-    AssertLockHeld(cs_main);
-    if (pindex->nStatus.isInvalid()) {
-        // We try to finalize an invalid block.
-        LogPrintf("ERROR: %s: Trying to finalize invalid block %s\n", __func__,
-                  pindex->GetBlockHash().ToString());
-        return state.Invalid(BlockValidationResult::BLOCK_CACHED_INVALID,
-                             "finalize-invalid-block");
-    }
-
-    // Check that the request is consistent with current finalization.
-    if (m_finalizedBlockIndex &&
-        !AreOnTheSameFork(pindex, m_finalizedBlockIndex)) {
-        LogPrintf("ERROR: %s: Trying to finalize block %s which conflicts with "
-                  "already finalized block\n",
-                  __func__, pindex->GetBlockHash().ToString());
-        return state.Invalid(BlockValidationResult::BLOCK_FINALIZATION,
-                             "bad-fork-prior-finalized");
-    }
-
-    if (IsBlockFinalized(pindex)) {
-        // The block is already finalized.
-        return true;
-    }
-
-    // We have a new block to finalize.
-    m_finalizedBlockIndex = pindex;
-    return true;
-}
-
-const CBlockIndex *CChainState::FindBlockToFinalize(CBlockIndex *pindexNew) {
-    AssertLockHeld(cs_main);
-
-    const int32_t maxreorgdepth =
-        gArgs.GetIntArg("-maxreorgdepth", DEFAULT_MAX_REORG_DEPTH);
-
-    const int64_t finalizationdelay =
-        gArgs.GetIntArg("-finalizationdelay", DEFAULT_MIN_FINALIZATION_DELAY);
-
-    // Find our candidate.
-    // If maxreorgdepth is < 0 pindex will be null and auto finalization
-    // disabled
-    const CBlockIndex *pindex =
-        pindexNew->GetAncestor(pindexNew->nHeight - maxreorgdepth);
-
-    int64_t now = GetTime();
-
-    // If the finalization delay is not expired since the startup time,
-    // finalization should be avoided. Header receive time is not saved to disk
-    // and so cannot be anterior to startup time.
-    if (now < (GetStartupTime() + finalizationdelay)) {
-        return nullptr;
-    }
-
-    // While our candidate is not eligible (finalization delay not expired), try
-    // the previous one.
-    while (pindex && (pindex != GetFinalizedBlock())) {
-        // Check that the block to finalize is known for a long enough time.
-        // This test will ensure that an attacker could not cause a block to
-        // finalize by forking the chain with a depth > maxreorgdepth.
-        // If the block is loaded from disk, header receive time is 0 and the
-        // block will be finalized. This is safe because the delay since the
-        // node startup is already expired.
-        auto headerReceivedTime = pindex->GetHeaderReceivedTime();
-
-        // If finalization delay is <= 0, finalization always occurs immediately
-        if (now >= (headerReceivedTime + finalizationdelay)) {
-            return pindex;
-        }
-
-        pindex = pindex->pprev;
-    }
-
-    return nullptr;
-}
-
 /**
  * Connect a new block to m_chain. pblock is either nullptr or a pointer to
  * a CBlock corresponding to pindexNew, to bypass loading it again from disk.
  *
  * The block is always added to connectTrace (either after loading from disk or
  * by copying pblock) - if that is not intended, care must be taken to remove
  * the last entry in blocksConnected in case of failure.
  */
 bool CChainState::ConnectTip(const Config &config, BlockValidationState &state,
                              CBlockIndex *pindexNew,
                              const std::shared_ptr<const CBlock> &pblock,
                              ConnectTrace &connectTrace,
                              DisconnectedBlockTransactions &disconnectpool) {
     AssertLockHeld(cs_main);
     if (m_mempool) {
         AssertLockHeld(m_mempool->cs);
     }
 
     const Consensus::Params &consensusParams = m_params.GetConsensus();
 
     assert(pindexNew->pprev == m_chain.Tip());
     // Read block from disk.
     int64_t nTime1 = GetTimeMicros();
     std::shared_ptr<const CBlock> pthisBlock;
     if (!pblock) {
         std::shared_ptr<CBlock> pblockNew = std::make_shared<CBlock>();
         if (!ReadBlockFromDisk(*pblockNew, pindexNew, consensusParams)) {
             return AbortNode(state, "Failed to read block");
         }
         pthisBlock = pblockNew;
     } else {
         pthisBlock = pblock;
     }
 
     const CBlock &blockConnecting = *pthisBlock;
 
     // Apply the block atomically to the chain state.
     int64_t nTime2 = GetTimeMicros();
     nTimeReadFromDisk += nTime2 - nTime1;
     int64_t nTime3;
     LogPrint(BCLog::BENCH, "  - Load block from disk: %.2fms [%.2fs]\n",
              (nTime2 - nTime1) * MILLI, nTimeReadFromDisk * MICRO);
     {
         CCoinsViewCache view(&CoinsTip());
         bool rv = ConnectBlock(blockConnecting, state, pindexNew, view,
                                BlockValidationOptions(config));
         GetMainSignals().BlockChecked(blockConnecting, state);
         if (!rv) {
             if (state.IsInvalid()) {
                 InvalidBlockFound(pindexNew, state);
             }
 
             return error("%s: ConnectBlock %s failed, %s", __func__,
                          pindexNew->GetBlockHash().ToString(),
                          state.ToString());
         }
 
-        // Update the finalized block.
-        const CBlockIndex *pindexToFinalize = FindBlockToFinalize(pindexNew);
-        if (pindexToFinalize && !MarkBlockAsFinal(state, pindexToFinalize)) {
-            return error("ConnectTip(): MarkBlockAsFinal %s failed (%s)",
-                         pindexNew->GetBlockHash().ToString(),
-                         state.ToString());
-        }
-
         nTime3 = GetTimeMicros();
         nTimeConnectTotal += nTime3 - nTime2;
         assert(nBlocksTotal > 0);
         LogPrint(BCLog::BENCH,
                  "  - Connect total: %.2fms [%.2fs (%.2fms/blk)]\n",
                  (nTime3 - nTime2) * MILLI, nTimeConnectTotal * MICRO,
                  nTimeConnectTotal * MILLI / nBlocksTotal);
         bool flushed = view.Flush();
         assert(flushed);
     }
 
     int64_t nTime4 = GetTimeMicros();
     nTimeFlush += nTime4 - nTime3;
     LogPrint(BCLog::BENCH, "  - Flush: %.2fms [%.2fs (%.2fms/blk)]\n",
              (nTime4 - nTime3) * MILLI, nTimeFlush * MICRO,
              nTimeFlush * MILLI / nBlocksTotal);
 
     // Write the chain state to disk, if necessary.
     if (!FlushStateToDisk(state, FlushStateMode::IF_NEEDED)) {
         return false;
     }
 
     int64_t nTime5 = GetTimeMicros();
     nTimeChainState += nTime5 - nTime4;
     LogPrint(BCLog::BENCH,
              "  - Writing chainstate: %.2fms [%.2fs (%.2fms/blk)]\n",
              (nTime5 - nTime4) * MILLI, nTimeChainState * MICRO,
              nTimeChainState * MILLI / nBlocksTotal);
 
     // Remove conflicting transactions from the mempool.;
     if (m_mempool) {
         m_mempool->removeForBlock(blockConnecting.vtx, pindexNew->nHeight);
         disconnectpool.removeForBlock(blockConnecting.vtx);
 
         // If this block is activating a fork, we move all mempool transactions
         // in front of disconnectpool for reprocessing in a future
         // updateMempoolForReorg call
         if (pindexNew->pprev != nullptr &&
             GetNextBlockScriptFlags(consensusParams, pindexNew) !=
                 GetNextBlockScriptFlags(consensusParams, pindexNew->pprev)) {
             LogPrint(
                 BCLog::MEMPOOL,
                 "Disconnecting mempool due to acceptance of upgrade block\n");
             disconnectpool.importMempool(*m_mempool);
         }
     }
 
     // Update m_chain & related variables.
     m_chain.SetTip(pindexNew);
     UpdateTip(pindexNew);
 
     int64_t nTime6 = GetTimeMicros();
     nTimePostConnect += nTime6 - nTime5;
     nTimeTotal += nTime6 - nTime1;
     LogPrint(BCLog::BENCH,
              "  - Connect postprocess: %.2fms [%.2fs (%.2fms/blk)]\n",
              (nTime6 - nTime5) * MILLI, nTimePostConnect * MICRO,
              nTimePostConnect * MILLI / nBlocksTotal);
     LogPrint(BCLog::BENCH, "- Connect block: %.2fms [%.2fs (%.2fms/blk)]\n",
              (nTime6 - nTime1) * MILLI, nTimeTotal * MICRO,
              nTimeTotal * MILLI / nBlocksTotal);
 
     connectTrace.BlockConnected(pindexNew, std::move(pthisBlock));
     return true;
 }
 
 /**
  * Return the tip of the chain with the most work in it, that isn't known to be
  * invalid (it's however far from certain to be valid).
  */
 CBlockIndex *CChainState::FindMostWorkChain(
     std::vector<const CBlockIndex *> &blocksToReconcile) {
     AssertLockHeld(::cs_main);
     do {
         CBlockIndex *pindexNew = nullptr;
 
         // Find the best candidate header.
         {
             std::set<CBlockIndex *, CBlockIndexWorkComparator>::reverse_iterator
                 it = setBlockIndexCandidates.rbegin();
             if (it == setBlockIndexCandidates.rend()) {
                 return nullptr;
             }
             pindexNew = *it;
         }
 
-        // If this block will cause a finalized block to be reorged, then we
-        // mark it as invalid.
-        if (m_finalizedBlockIndex &&
-            !AreOnTheSameFork(pindexNew, m_finalizedBlockIndex)) {
-            LogPrintf("Mark block %s invalid because it forks prior to the "
-                      "finalization point %d.\n",
-                      pindexNew->GetBlockHash().ToString(),
-                      m_finalizedBlockIndex->nHeight);
-            pindexNew->nStatus = pindexNew->nStatus.withFailed();
-            InvalidChainFound(pindexNew);
-        }
-
         // If this block will cause an avalanche finalized block to be reorged,
         // then we park it.
         {
             LOCK(cs_avalancheFinalizedBlockIndex);
             if (m_avalancheFinalizedBlockIndex &&
                 !AreOnTheSameFork(pindexNew, m_avalancheFinalizedBlockIndex)) {
                 LogPrintf("Park block %s because it forks prior to the "
                           "avalanche finalized chaintip.\n",
                           pindexNew->GetBlockHash().ToString());
                 pindexNew->nStatus = pindexNew->nStatus.withParked();
                 m_blockman.m_dirty_blockindex.insert(pindexNew);
             }
         }
 
         const bool fAvalancheEnabled = isAvalancheEnabled(gArgs);
         const bool fAutoUnpark =
             gArgs.GetBoolArg("-automaticunparking", !fAvalancheEnabled);
 
         const CBlockIndex *pindexFork = m_chain.FindFork(pindexNew);
 
         // Check whether all blocks on the path between the currently active
         // chain and the candidate are valid. Just going until the active chain
         // is an optimization, as we know all blocks in it are valid already.
         CBlockIndex *pindexTest = pindexNew;
         bool hasValidAncestor = true;
         while (hasValidAncestor && pindexTest && pindexTest != pindexFork) {
             assert(pindexTest->HaveTxsDownloaded() || pindexTest->nHeight == 0);
 
             // If this is a parked chain, but it has enough PoW, clear the park
             // state.
             bool fParkedChain = pindexTest->nStatus.isOnParkedChain();
             if (fAutoUnpark && fParkedChain) {
                 const CBlockIndex *pindexTip = m_chain.Tip();
 
                 // During initialization, pindexTip and/or pindexFork may be
                 // null. In this case, we just ignore the fact that the chain is
                 // parked.
                 if (!pindexTip || !pindexFork) {
                     UnparkBlock(pindexTest);
                     continue;
                 }
 
                 // A parked chain can be unparked if it has twice as much PoW
                 // accumulated as the main chain has since the fork block.
                 CBlockIndex const *pindexExtraPow = pindexTip;
                 arith_uint256 requiredWork = pindexTip->nChainWork;
                 switch (pindexTip->nHeight - pindexFork->nHeight) {
                     // Limit the penality for depth 1, 2 and 3 to half a block
                     // worth of work to ensure we don't fork accidentally.
                     case 3:
                     case 2:
                         pindexExtraPow = pindexExtraPow->pprev;
                     // FALLTHROUGH
                     case 1: {
                         const arith_uint256 deltaWork =
                             pindexExtraPow->nChainWork - pindexFork->nChainWork;
                         requiredWork += (deltaWork >> 1);
                         break;
                     }
                     default:
                         requiredWork +=
                             pindexExtraPow->nChainWork - pindexFork->nChainWork;
                         break;
                 }
 
                 if (pindexNew->nChainWork > requiredWork) {
                     // We have enough, clear the parked state.
                     LogPrintf("Unpark chain up to block %s as it has "
                               "accumulated enough PoW.\n",
                               pindexNew->GetBlockHash().ToString());
                     fParkedChain = false;
                     UnparkBlock(pindexTest);
                 }
             }
 
             // Pruned nodes may have entries in setBlockIndexCandidates for
             // which block files have been deleted. Remove those as candidates
             // for the most work chain if we come across them; we can't switch
             // to a chain unless we have all the non-active-chain parent blocks.
             bool fInvalidChain = pindexTest->nStatus.isInvalid();
             bool fMissingData = !pindexTest->nStatus.hasData();
             if (!(fInvalidChain || fParkedChain || fMissingData)) {
                 // The current block is acceptable, move to the parent, up to
                 // the fork point.
                 pindexTest = pindexTest->pprev;
                 continue;
             }
 
             // Candidate chain is not usable (either invalid or parked or
             // missing data)
             hasValidAncestor = false;
             setBlockIndexCandidates.erase(pindexTest);
 
             if (fInvalidChain && (m_chainman.m_best_invalid == nullptr ||
                                   pindexNew->nChainWork >
                                       m_chainman.m_best_invalid->nChainWork)) {
                 m_chainman.m_best_invalid = pindexNew;
             }
 
             if (fParkedChain && (m_chainman.m_best_parked == nullptr ||
                                  pindexNew->nChainWork >
                                      m_chainman.m_best_parked->nChainWork)) {
                 m_chainman.m_best_parked = pindexNew;
             }
 
             LogPrintf("Considered switching to better tip %s but that chain "
                       "contains a%s%s%s block.\n",
                       pindexNew->GetBlockHash().ToString(),
                       fInvalidChain ? "n invalid" : "",
                       fParkedChain ? " parked" : "",
                       fMissingData ? " missing-data" : "");
 
             CBlockIndex *pindexFailed = pindexNew;
             // Remove the entire chain from the set.
             while (pindexTest != pindexFailed) {
                 if (fInvalidChain || fParkedChain) {
                     pindexFailed->nStatus =
                         pindexFailed->nStatus.withFailedParent(fInvalidChain)
                             .withParkedParent(fParkedChain);
                 } else if (fMissingData) {
                     // If we're missing data, then add back to
                     // m_blocks_unlinked, so that if the block arrives in the
                     // future we can try adding to setBlockIndexCandidates
                     // again.
                     m_blockman.m_blocks_unlinked.insert(
                         std::make_pair(pindexFailed->pprev, pindexFailed));
                 }
                 setBlockIndexCandidates.erase(pindexFailed);
                 pindexFailed = pindexFailed->pprev;
             }
 
             if (fInvalidChain || fParkedChain) {
                 // We discovered a new chain tip that is either parked or
                 // invalid, we may want to warn.
                 CheckForkWarningConditionsOnNewFork(pindexNew);
             }
         }
 
         if (fAvalancheEnabled && g_avalanche) {
             blocksToReconcile.push_back(pindexNew);
         }
 
         // We found a candidate that has valid ancestors. This is our guy.
         if (hasValidAncestor) {
             return pindexNew;
         }
     } while (true);
 }
 
 /**
  * Delete all entries in setBlockIndexCandidates that are worse than the current
  * tip.
  */
 void CChainState::PruneBlockIndexCandidates() {
     // Note that we can't delete the current block itself, as we may need to
     // return to it later in case a reorganization to a better block fails.
     auto it = setBlockIndexCandidates.begin();
     while (it != setBlockIndexCandidates.end() &&
            setBlockIndexCandidates.value_comp()(*it, m_chain.Tip())) {
         setBlockIndexCandidates.erase(it++);
     }
 
     // Either the current tip or a successor of it we're working towards is left
     // in setBlockIndexCandidates.
     assert(!setBlockIndexCandidates.empty());
 }
 
 /**
  * Try to make some progress towards making pindexMostWork the active block.
  * pblock is either nullptr or a pointer to a CBlock corresponding to
  * pindexMostWork.
  *
  * @returns true unless a system error occurred
  */
 bool CChainState::ActivateBestChainStep(
     const Config &config, BlockValidationState &state,
     CBlockIndex *pindexMostWork, const std::shared_ptr<const CBlock> &pblock,
     bool &fInvalidFound, ConnectTrace &connectTrace) {
     AssertLockHeld(cs_main);
     if (m_mempool) {
         AssertLockHeld(m_mempool->cs);
     }
 
     const CBlockIndex *pindexOldTip = m_chain.Tip();
     const CBlockIndex *pindexFork = m_chain.FindFork(pindexMostWork);
 
     // Disconnect active blocks which are no longer in the best chain.
     bool fBlocksDisconnected = false;
     DisconnectedBlockTransactions disconnectpool;
     while (m_chain.Tip() && m_chain.Tip() != pindexFork) {
         if (!DisconnectTip(state, &disconnectpool)) {
             // This is likely a fatal error, but keep the mempool consistent,
             // just in case. Only remove from the mempool in this case.
             if (m_mempool) {
                 disconnectpool.updateMempoolForReorg(config, *this, false,
                                                      *m_mempool);
             }
 
             // If we're unable to disconnect a block during normal operation,
             // then that is a failure of our local system -- we should abort
             // rather than stay on a less work chain.
             AbortNode(state,
                       "Failed to disconnect block; see debug.log for details");
             return false;
         }
 
         fBlocksDisconnected = true;
     }
 
     // Build list of new blocks to connect.
     std::vector<CBlockIndex *> vpindexToConnect;
     bool fContinue = true;
     int nHeight = pindexFork ? pindexFork->nHeight : -1;
     while (fContinue && nHeight != pindexMostWork->nHeight) {
         // Don't iterate the entire list of potential improvements toward the
         // best tip, as we likely only need a few blocks along the way.
         int nTargetHeight = std::min(nHeight + 32, pindexMostWork->nHeight);
         vpindexToConnect.clear();
         vpindexToConnect.reserve(nTargetHeight - nHeight);
         CBlockIndex *pindexIter = pindexMostWork->GetAncestor(nTargetHeight);
         while (pindexIter && pindexIter->nHeight != nHeight) {
             vpindexToConnect.push_back(pindexIter);
             pindexIter = pindexIter->pprev;
         }
 
         nHeight = nTargetHeight;
 
         // Connect new blocks.
         for (CBlockIndex *pindexConnect : reverse_iterate(vpindexToConnect)) {
             if (!ConnectTip(config, state, pindexConnect,
                             pindexConnect == pindexMostWork
                                 ? pblock
                                 : std::shared_ptr<const CBlock>(),
                             connectTrace, disconnectpool)) {
                 if (state.IsInvalid()) {
                     // The block violates a consensus rule.
                     if (state.GetResult() !=
                         BlockValidationResult::BLOCK_MUTATED) {
                         InvalidChainFound(vpindexToConnect.back());
                     }
                     state = BlockValidationState();
                     fInvalidFound = true;
                     fContinue = false;
                     break;
                 }
 
                 // A system error occurred (disk space, database error, ...).
                 // Make the mempool consistent with the current tip, just in
                 // case any observers try to use it before shutdown.
                 if (m_mempool) {
                     disconnectpool.updateMempoolForReorg(config, *this, false,
                                                          *m_mempool);
                 }
                 return false;
             } else {
                 PruneBlockIndexCandidates();
                 if (!pindexOldTip ||
                     m_chain.Tip()->nChainWork > pindexOldTip->nChainWork) {
                     // We're in a better position than we were. Return
                     // temporarily to release the lock.
                     fContinue = false;
                     break;
                 }
             }
         }
     }
 
     if (m_mempool) {
         if (fBlocksDisconnected || !disconnectpool.isEmpty()) {
             // If any blocks were disconnected, we need to update the mempool
             // even if disconnectpool is empty. The disconnectpool may also be
             // non-empty if the mempool was imported due to new validation rules
             // being in effect.
             LogPrint(BCLog::MEMPOOL,
                      "Updating mempool due to reorganization or "
                      "rules upgrade/downgrade\n");
             disconnectpool.updateMempoolForReorg(config, *this, true,
                                                  *m_mempool);
         }
 
         m_mempool->check(this->CoinsTip(), this->m_chain.Height() + 1);
     }
 
     // Callbacks/notifications for a new best chain.
     if (fInvalidFound) {
         CheckForkWarningConditionsOnNewFork(pindexMostWork);
     } else {
         CheckForkWarningConditions();
     }
 
     return true;
 }
 
 static SynchronizationState GetSynchronizationState(bool init) {
     if (!init) {
         return SynchronizationState::POST_INIT;
     }
     if (::fReindex) {
         return SynchronizationState::INIT_REINDEX;
     }
     return SynchronizationState::INIT_DOWNLOAD;
 }
 
 static bool NotifyHeaderTip(CChainState &chainstate) LOCKS_EXCLUDED(cs_main) {
     bool fNotify = false;
     bool fInitialBlockDownload = false;
     static CBlockIndex *pindexHeaderOld = nullptr;
     CBlockIndex *pindexHeader = nullptr;
     {
         LOCK(cs_main);
         pindexHeader = chainstate.m_chainman.m_best_header;
 
         if (pindexHeader != pindexHeaderOld) {
             fNotify = true;
             fInitialBlockDownload = chainstate.IsInitialBlockDownload();
             pindexHeaderOld = pindexHeader;
         }
     }
 
     // Send block tip changed notifications without cs_main
     if (fNotify) {
         uiInterface.NotifyHeaderTip(
             GetSynchronizationState(fInitialBlockDownload), pindexHeader);
     }
     return fNotify;
 }
 
 static void LimitValidationInterfaceQueue() LOCKS_EXCLUDED(cs_main) {
     AssertLockNotHeld(cs_main);
 
     if (GetMainSignals().CallbacksPending() > 10) {
         SyncWithValidationInterfaceQueue();
     }
 }
 
 bool CChainState::ActivateBestChain(const Config &config,
                                     BlockValidationState &state,
                                     std::shared_ptr<const CBlock> pblock) {
     AssertLockNotHeld(m_chainstate_mutex);
 
     // Note that while we're often called here from ProcessNewBlock, this is
     // far from a guarantee. Things in the P2P/RPC will often end up calling
     // us in the middle of ProcessNewBlock - do not assume pblock is set
     // sanely for performance or correctness!
     AssertLockNotHeld(::cs_main);
 
     // ABC maintains a fair degree of expensive-to-calculate internal state
     // because this function periodically releases cs_main so that it does not
     // lock up other threads for too long during large connects - and to allow
     // for e.g. the callback queue to drain we use m_chainstate_mutex to enforce
     // mutual exclusion so that only one caller may execute this function at a
     // time
     LOCK(m_chainstate_mutex);
 
     CBlockIndex *pindexMostWork = nullptr;
     CBlockIndex *pindexNewTip = nullptr;
     int nStopAtHeight = gArgs.GetIntArg("-stopatheight", DEFAULT_STOPATHEIGHT);
     do {
         // Block until the validation queue drains. This should largely
         // never happen in normal operation, however may happen during
         // reindex, causing memory blowup if we run too far ahead.
         // Note that if a validationinterface callback ends up calling
         // ActivateBestChain this may lead to a deadlock! We should
         // probably have a DEBUG_LOCKORDER test for this in the future.
         LimitValidationInterfaceQueue();
 
         std::vector<const CBlockIndex *> blocksToReconcile;
         bool blocks_connected = false;
 
         {
             LOCK(cs_main);
             // Lock transaction pool for at least as long as it takes for
             // connectTrace to be consumed
             LOCK(MempoolMutex());
             CBlockIndex *starting_tip = m_chain.Tip();
             do {
                 // We absolutely may not unlock cs_main until we've made forward
                 // progress (with the exception of shutdown due to hardware
                 // issues, low disk space, etc).
 
                 // Destructed before cs_main is unlocked
                 ConnectTrace connectTrace;
 
                 if (pindexMostWork == nullptr) {
                     pindexMostWork = FindMostWorkChain(blocksToReconcile);
                 }
 
                 // Whether we have anything to do at all.
                 if (pindexMostWork == nullptr ||
                     pindexMostWork == m_chain.Tip()) {
                     break;
                 }
 
                 bool fInvalidFound = false;
                 std::shared_ptr<const CBlock> nullBlockPtr;
                 if (!ActivateBestChainStep(
                         config, state, pindexMostWork,
                         pblock && pblock->GetHash() ==
                                       pindexMostWork->GetBlockHash()
                             ? pblock
                             : nullBlockPtr,
                         fInvalidFound, connectTrace)) {
                     // A system error occurred
                     return false;
                 }
                 blocks_connected = true;
 
                 if (fInvalidFound) {
                     // Wipe cache, we may need another branch now.
                     pindexMostWork = nullptr;
                 }
 
                 pindexNewTip = m_chain.Tip();
                 for (const PerBlockConnectTrace &trace :
                      connectTrace.GetBlocksConnected()) {
                     assert(trace.pblock && trace.pindex);
                     GetMainSignals().BlockConnected(trace.pblock, trace.pindex);
                 }
             } while (!m_chain.Tip() ||
                      (starting_tip && CBlockIndexWorkComparator()(
                                           m_chain.Tip(), starting_tip)));
 
             // Check the index once we're done with the above loop, since
             // we're going to release cs_main soon. If the index is in a bad
             // state now, then it's better to know immediately rather than
             // randomly have it cause a problem in a race.
             CheckBlockIndex();
 
             if (blocks_connected) {
                 const CBlockIndex *pindexFork = m_chain.FindFork(starting_tip);
                 bool fInitialDownload = IsInitialBlockDownload();
 
                 // Notify external listeners about the new tip.
                 // Enqueue while holding cs_main to ensure that UpdatedBlockTip
                 // is called in the order in which blocks are connected
                 if (pindexFork != pindexNewTip) {
                     // Notify ValidationInterface subscribers
                     GetMainSignals().UpdatedBlockTip(pindexNewTip, pindexFork,
                                                      fInitialDownload);
 
                     // Always notify the UI if a new block tip was connected
                     uiInterface.NotifyBlockTip(
                         GetSynchronizationState(fInitialDownload),
                         pindexNewTip);
                 }
             }
         }
         // When we reach this point, we switched to a new tip (stored in
         // pindexNewTip).
 
         for (const CBlockIndex *pindex : blocksToReconcile) {
             g_avalanche->addToReconcile(pindex);
         }
 
         if (!blocks_connected) {
             return true;
         }
 
         if (nStopAtHeight && pindexNewTip &&
             pindexNewTip->nHeight >= nStopAtHeight) {
             StartShutdown();
         }
 
         // We check shutdown only after giving ActivateBestChainStep a chance to
         // run once so that we never shutdown before connecting the genesis
         // block during LoadChainTip(). Previously this caused an assert()
         // failure during shutdown in such cases as the UTXO DB flushing checks
         // that the best block hash is non-null.
         if (ShutdownRequested()) {
             break;
         }
     } while (pindexNewTip != pindexMostWork);
 
     // Write changes periodically to disk, after relay.
     if (!FlushStateToDisk(state, FlushStateMode::PERIODIC)) {
         return false;
     }
 
     return true;
 }
 
 bool CChainState::PreciousBlock(const Config &config,
                                 BlockValidationState &state,
                                 CBlockIndex *pindex) {
     AssertLockNotHeld(m_chainstate_mutex);
     AssertLockNotHeld(::cs_main);
     {
         LOCK(cs_main);
         if (pindex->nChainWork < m_chain.Tip()->nChainWork) {
             // Nothing to do, this block is not at the tip.
             return true;
         }
 
         if (m_chain.Tip()->nChainWork > nLastPreciousChainwork) {
             // The chain has been extended since the last call, reset the
             // counter.
             nBlockReverseSequenceId = -1;
         }
 
         nLastPreciousChainwork = m_chain.Tip()->nChainWork;
         setBlockIndexCandidates.erase(pindex);
         pindex->nSequenceId = nBlockReverseSequenceId;
         if (nBlockReverseSequenceId > std::numeric_limits<int32_t>::min()) {
             // We can't keep reducing the counter if somebody really wants to
             // call preciousblock 2**31-1 times on the same set of tips...
             nBlockReverseSequenceId--;
         }
 
         // In case this was parked, unpark it.
         UnparkBlock(pindex);
 
         // Make sure it is added to the candidate list if appropriate.
         if (pindex->IsValid(BlockValidity::TRANSACTIONS) &&
             pindex->HaveTxsDownloaded()) {
             setBlockIndexCandidates.insert(pindex);
             PruneBlockIndexCandidates();
         }
     }
 
     return ActivateBestChain(config, state);
 }
 
 bool CChainState::UnwindBlock(const Config &config, BlockValidationState &state,
                               CBlockIndex *pindex, bool invalidate) {
     // Genesis block can't be invalidated or parked
     assert(pindex);
     if (pindex->nHeight == 0) {
         return false;
     }
 
     CBlockIndex *to_mark_failed_or_parked = pindex;
     bool pindex_was_in_chain = false;
     int disconnected = 0;
 
     // We do not allow ActivateBestChain() to run while UnwindBlock() is
     // running, as that could cause the tip to change while we disconnect
     // blocks. (Note for backport of Core PR16849: we acquire
     // LOCK(m_chainstate_mutex) in the Park, Invalidate and FinalizeBlock
     // functions due to differences in our code)
     AssertLockHeld(m_chainstate_mutex);
 
     // We'll be acquiring and releasing cs_main below, to allow the validation
     // callbacks to run. However, we should keep the block index in a
     // consistent state as we disconnect blocks -- in particular we need to
     // add equal-work blocks to setBlockIndexCandidates as we disconnect.
     // To avoid walking the block index repeatedly in search of candidates,
     // build a map once so that we can look up candidate blocks by chain
     // work as we go.
     std::multimap<const arith_uint256, CBlockIndex *> candidate_blocks_by_work;
 
     {
         LOCK(cs_main);
         for (auto &entry : m_blockman.m_block_index) {
             CBlockIndex *candidate = &entry.second;
             // We don't need to put anything in our active chain into the
             // multimap, because those candidates will be found and considered
             // as we disconnect.
             // Instead, consider only non-active-chain blocks that have at
             // least as much work as where we expect the new tip to end up.
             if (!m_chain.Contains(candidate) &&
                 !CBlockIndexWorkComparator()(candidate, pindex->pprev) &&
                 candidate->IsValid(BlockValidity::TRANSACTIONS) &&
                 candidate->HaveTxsDownloaded()) {
                 candidate_blocks_by_work.insert(
                     std::make_pair(candidate->nChainWork, candidate));
             }
         }
     }
 
     // Disconnect (descendants of) pindex, and mark them invalid.
     while (true) {
         if (ShutdownRequested()) {
             break;
         }
 
         // Make sure the queue of validation callbacks doesn't grow unboundedly.
         LimitValidationInterfaceQueue();
 
         LOCK(cs_main);
         // Lock for as long as disconnectpool is in scope to make sure
         // UpdateMempoolForReorg is called after DisconnectTip without unlocking
         // in between
         LOCK(MempoolMutex());
 
         if (!m_chain.Contains(pindex)) {
             break;
         }
 
         pindex_was_in_chain = true;
         CBlockIndex *invalid_walk_tip = m_chain.Tip();
 
         // ActivateBestChain considers blocks already in m_chain
         // unconditionally valid already, so force disconnect away from it.
 
         DisconnectedBlockTransactions disconnectpool;
 
         bool ret = DisconnectTip(state, &disconnectpool);
 
         // DisconnectTip will add transactions to disconnectpool.
         // Adjust the mempool to be consistent with the new tip, adding
         // transactions back to the mempool if disconnecting was successful,
         // and we're not doing a very deep invalidation (in which case
         // keeping the mempool up to date is probably futile anyway).
         if (m_mempool) {
             disconnectpool.updateMempoolForReorg(
                 config, *this,
                 /* fAddToMempool = */ (++disconnected <= 10) && ret,
                 *m_mempool);
         }
 
         if (!ret) {
             return false;
         }
 
         assert(invalid_walk_tip->pprev == m_chain.Tip());
 
         // We immediately mark the disconnected blocks as invalid.
         // This prevents a case where pruned nodes may fail to invalidateblock
         // and be left unable to start as they have no tip candidates (as there
         // are no blocks that meet the "have data and are not invalid per
         // nStatus" criteria for inclusion in setBlockIndexCandidates).
 
         invalid_walk_tip->nStatus =
             invalidate ? invalid_walk_tip->nStatus.withFailed()
                        : invalid_walk_tip->nStatus.withParked();
 
         m_blockman.m_dirty_blockindex.insert(invalid_walk_tip);
         setBlockIndexCandidates.insert(invalid_walk_tip->pprev);
 
         if (invalid_walk_tip == to_mark_failed_or_parked->pprev &&
             (invalidate ? to_mark_failed_or_parked->nStatus.hasFailed()
                         : to_mark_failed_or_parked->nStatus.isParked())) {
             // We only want to mark the last disconnected block as
             // Failed (or Parked); its children need to be FailedParent (or
             // ParkedParent) instead.
             to_mark_failed_or_parked->nStatus =
                 (invalidate
                      ? to_mark_failed_or_parked->nStatus.withFailed(false)
                            .withFailedParent()
                      : to_mark_failed_or_parked->nStatus.withParked(false)
                            .withParkedParent());
 
             m_blockman.m_dirty_blockindex.insert(to_mark_failed_or_parked);
         }
 
         // Add any equal or more work headers to setBlockIndexCandidates
         auto candidate_it = candidate_blocks_by_work.lower_bound(
             invalid_walk_tip->pprev->nChainWork);
         while (candidate_it != candidate_blocks_by_work.end()) {
             if (!CBlockIndexWorkComparator()(candidate_it->second,
                                              invalid_walk_tip->pprev)) {
                 setBlockIndexCandidates.insert(candidate_it->second);
                 candidate_it = candidate_blocks_by_work.erase(candidate_it);
             } else {
                 ++candidate_it;
             }
         }
 
         // Track the last disconnected block, so we can correct its
         // FailedParent (or ParkedParent) status in future iterations, or, if
         // it's the last one, call InvalidChainFound on it.
         to_mark_failed_or_parked = invalid_walk_tip;
     }
 
     CheckBlockIndex();
 
     {
         LOCK(cs_main);
         if (m_chain.Contains(to_mark_failed_or_parked)) {
             // If the to-be-marked invalid block is in the active chain,
             // something is interfering and we can't proceed.
             return false;
         }
 
         // Mark pindex (or the last disconnected block) as invalid (or parked),
         // even when it never was in the main chain.
         to_mark_failed_or_parked->nStatus =
             invalidate ? to_mark_failed_or_parked->nStatus.withFailed()
                        : to_mark_failed_or_parked->nStatus.withParked();
         m_blockman.m_dirty_blockindex.insert(to_mark_failed_or_parked);
         if (invalidate) {
             m_chainman.m_failed_blocks.insert(to_mark_failed_or_parked);
         }
 
         // If any new blocks somehow arrived while we were disconnecting
         // (above), then the pre-calculation of what should go into
         // setBlockIndexCandidates may have missed entries. This would
         // technically be an inconsistency in the block index, but if we clean
         // it up here, this should be an essentially unobservable error.
         // Loop back over all block index entries and add any missing entries
         // to setBlockIndexCandidates.
         for (auto &[_, block_index] : m_blockman.m_block_index) {
             if (block_index.IsValid(BlockValidity::TRANSACTIONS) &&
                 block_index.HaveTxsDownloaded() &&
                 !setBlockIndexCandidates.value_comp()(&block_index,
                                                       m_chain.Tip())) {
                 setBlockIndexCandidates.insert(&block_index);
             }
         }
 
         if (invalidate) {
             InvalidChainFound(to_mark_failed_or_parked);
         }
     }
 
     // Only notify about a new block tip if the active chain was modified.
     if (pindex_was_in_chain) {
         uiInterface.NotifyBlockTip(
             GetSynchronizationState(IsInitialBlockDownload()),
             to_mark_failed_or_parked->pprev);
     }
     return true;
 }
 
 bool CChainState::InvalidateBlock(const Config &config,
                                   BlockValidationState &state,
                                   CBlockIndex *pindex) {
     AssertLockNotHeld(m_chainstate_mutex);
     AssertLockNotHeld(::cs_main);
     // See 'Note for backport of Core PR16849' in CChainState::UnwindBlock
     LOCK(m_chainstate_mutex);
 
     return UnwindBlock(config, state, pindex, true);
 }
 
 bool CChainState::ParkBlock(const Config &config, BlockValidationState &state,
                             CBlockIndex *pindex) {
     AssertLockNotHeld(m_chainstate_mutex);
     AssertLockNotHeld(::cs_main);
     // See 'Note for backport of Core PR16849' in CChainState::UnwindBlock
     LOCK(m_chainstate_mutex);
 
     return UnwindBlock(config, state, pindex, false);
 }
 
-bool CChainState::FinalizeBlock(const Config &config,
-                                BlockValidationState &state,
-                                CBlockIndex *pindex) {
-    AssertLockNotHeld(m_chainstate_mutex);
-    AssertLockNotHeld(::cs_main);
-    // See 'Note for backport of Core PR16849' in CChainState::UnwindBlock
-    LOCK(m_chainstate_mutex);
-
-    AssertLockNotHeld(cs_main);
-    CBlockIndex *pindexToInvalidate = nullptr;
-    {
-        LOCK(cs_main);
-        if (!MarkBlockAsFinal(state, pindex)) {
-            // state is set by MarkBlockAsFinal.
-            return false;
-        }
-
-        // We have a valid candidate, make sure it is not parked.
-        if (pindex->nStatus.isOnParkedChain()) {
-            UnparkBlock(pindex);
-        }
-
-        // If the finalized block is on the active chain, there is no need to
-        // rewind.
-        if (m_chain.Contains(pindex)) {
-            return true;
-        }
-
-        // If the finalized block is not on the active chain, that chain is
-        // invalid
-        // ...
-        const CBlockIndex *pindexFork = m_chain.FindFork(pindex);
-        pindexToInvalidate = m_chain.Next(pindexFork);
-        if (!pindexToInvalidate) {
-            return false;
-        }
-    } // end of locked cs_main scope
-
-    // ... therefore, we invalidate the block on the active chain that comes
-    // immediately after it
-    return UnwindBlock(config, state, pindexToInvalidate,
-                       true /* invalidating */);
-}
-
 template <typename F>
 bool CChainState::UpdateFlagsForBlock(CBlockIndex *pindexBase,
                                       CBlockIndex *pindex, F f) {
     BlockStatus newStatus = f(pindex->nStatus);
     if (pindex->nStatus != newStatus &&
         (!pindexBase ||
          pindex->GetAncestor(pindexBase->nHeight) == pindexBase)) {
         pindex->nStatus = newStatus;
         m_blockman.m_dirty_blockindex.insert(pindex);
         if (newStatus.isValid()) {
             m_chainman.m_failed_blocks.erase(pindex);
         }
 
         if (pindex->IsValid(BlockValidity::TRANSACTIONS) &&
             pindex->HaveTxsDownloaded() &&
             setBlockIndexCandidates.value_comp()(m_chain.Tip(), pindex)) {
             setBlockIndexCandidates.insert(pindex);
         }
         return true;
     }
     return false;
 }
 
 template <typename F, typename C, typename AC>
 void CChainState::UpdateFlags(CBlockIndex *pindex, CBlockIndex *&pindexReset,
                               F f, C fChild, AC fAncestorWasChanged) {
     AssertLockHeld(cs_main);
 
     // Update the current block and ancestors; while we're doing this, identify
     // which was the deepest ancestor we changed.
     CBlockIndex *pindexDeepestChanged = pindex;
     for (auto pindexAncestor = pindex; pindexAncestor != nullptr;
          pindexAncestor = pindexAncestor->pprev) {
         if (UpdateFlagsForBlock(nullptr, pindexAncestor, f)) {
             pindexDeepestChanged = pindexAncestor;
         }
     }
 
     if (pindexReset &&
         pindexReset->GetAncestor(pindexDeepestChanged->nHeight) ==
             pindexDeepestChanged) {
         // reset pindexReset if it had a modified ancestor.
         pindexReset = nullptr;
     }
 
     // Update all blocks under modified blocks.
     for (auto &[_, block_index] : m_blockman.m_block_index) {
         UpdateFlagsForBlock(pindex, &block_index, fChild);
         UpdateFlagsForBlock(pindexDeepestChanged, &block_index,
                             fAncestorWasChanged);
     }
 }
 
 void CChainState::ResetBlockFailureFlags(CBlockIndex *pindex) {
     AssertLockHeld(cs_main);
 
-    // In case we are reconsidering something before the finalization point,
-    // move the finalization point to the last common ancestor.
-    if (m_finalizedBlockIndex) {
-        m_finalizedBlockIndex =
-            LastCommonAncestor(pindex, m_finalizedBlockIndex);
-    }
-
     UpdateFlags(
         pindex, m_chainman.m_best_invalid,
         [](const BlockStatus status) {
             return status.withClearedFailureFlags();
         },
         [](const BlockStatus status) {
             return status.withClearedFailureFlags();
         },
         [](const BlockStatus status) {
             return status.withFailedParent(false);
         });
 }
 
 void CChainState::UnparkBlockImpl(CBlockIndex *pindex, bool fClearChildren) {
     AssertLockHeld(cs_main);
 
     UpdateFlags(
         pindex, m_chainman.m_best_parked,
         [](const BlockStatus status) {
             return status.withClearedParkedFlags();
         },
         [fClearChildren](const BlockStatus status) {
             return fClearChildren ? status.withClearedParkedFlags()
                                   : status.withParkedParent(false);
         },
         [](const BlockStatus status) {
             return status.withParkedParent(false);
         });
 }
 
 void CChainState::UnparkBlockAndChildren(CBlockIndex *pindex) {
     return UnparkBlockImpl(pindex, true);
 }
 
 void CChainState::UnparkBlock(CBlockIndex *pindex) {
     return UnparkBlockImpl(pindex, false);
 }
 
-bool CChainState::IsBlockFinalized(const CBlockIndex *pindex) const {
-    AssertLockHeld(cs_main);
-    return m_finalizedBlockIndex &&
-           m_finalizedBlockIndex->GetAncestor(pindex->nHeight) == pindex;
-}
-
-/** Return the currently finalized block index. */
-const CBlockIndex *CChainState::GetFinalizedBlock() const {
-    AssertLockHeld(cs_main);
-    return m_finalizedBlockIndex;
-}
-
 bool CChainState::AvalancheFinalizeBlock(CBlockIndex *pindex) {
     if (!pindex) {
         return false;
     }
 
     if (!m_chain.Contains(pindex)) {
         LogPrint(BCLog::AVALANCHE,
                  "The block to mark finalized by avalanche is not on the "
                  "active chain: %s\n",
                  pindex->GetBlockHash().ToString());
         return false;
     }
 
     if (IsBlockAvalancheFinalized(pindex)) {
         return true;
     }
 
     LOCK(cs_avalancheFinalizedBlockIndex);
     m_avalancheFinalizedBlockIndex = pindex;
 
     GetMainSignals().BlockFinalized(pindex);
 
     return true;
 }
 
 void CChainState::ClearAvalancheFinalizedBlock() {
     LOCK(cs_avalancheFinalizedBlockIndex);
     m_avalancheFinalizedBlockIndex = nullptr;
 }
 
 bool CChainState::IsBlockAvalancheFinalized(const CBlockIndex *pindex) const {
     LOCK(cs_avalancheFinalizedBlockIndex);
     return pindex && m_avalancheFinalizedBlockIndex &&
            m_avalancheFinalizedBlockIndex->GetAncestor(pindex->nHeight) ==
                pindex;
 }
 
 /**
  * Mark a block as having its data received and checked (up to
  * BLOCK_VALID_TRANSACTIONS).
  */
 void CChainState::ReceivedBlockTransactions(const CBlock &block,
                                             CBlockIndex *pindexNew,
                                             const FlatFilePos &pos) {
     pindexNew->nTx = block.vtx.size();
     pindexNew->nSize = ::GetSerializeSize(block, PROTOCOL_VERSION);
     pindexNew->nFile = pos.nFile;
     pindexNew->nDataPos = pos.nPos;
     pindexNew->nUndoPos = 0;
     pindexNew->nStatus = pindexNew->nStatus.withData();
     pindexNew->RaiseValidity(BlockValidity::TRANSACTIONS);
     m_blockman.m_dirty_blockindex.insert(pindexNew);
 
     if (pindexNew->UpdateChainStats()) {
         // If pindexNew is the genesis block or all parents are
         // BLOCK_VALID_TRANSACTIONS.
         std::deque<CBlockIndex *> queue;
         queue.push_back(pindexNew);
 
         // Recursively process any descendant blocks that now may be eligible to
         // be connected.
         while (!queue.empty()) {
             CBlockIndex *pindex = queue.front();
             queue.pop_front();
             pindex->UpdateChainStats();
             if (pindex->nSequenceId == 0) {
                 // We assign a sequence is when transaction are received to
                 // prevent a miner from being able to broadcast a block but not
                 // its content. However, a sequence id may have been set
                 // manually, for instance via PreciousBlock, in which case, we
                 // don't need to assign one.
                 pindex->nSequenceId = nBlockSequenceId++;
             }
 
             if (m_chain.Tip() == nullptr ||
                 !setBlockIndexCandidates.value_comp()(pindex, m_chain.Tip())) {
                 setBlockIndexCandidates.insert(pindex);
             }
 
             std::pair<std::multimap<CBlockIndex *, CBlockIndex *>::iterator,
                       std::multimap<CBlockIndex *, CBlockIndex *>::iterator>
                 range = m_blockman.m_blocks_unlinked.equal_range(pindex);
             while (range.first != range.second) {
                 std::multimap<CBlockIndex *, CBlockIndex *>::iterator it =
                     range.first;
                 queue.push_back(it->second);
                 range.first++;
                 m_blockman.m_blocks_unlinked.erase(it);
             }
         }
     } else if (pindexNew->pprev &&
                pindexNew->pprev->IsValid(BlockValidity::TREE)) {
         m_blockman.m_blocks_unlinked.insert(
             std::make_pair(pindexNew->pprev, pindexNew));
     }
 }
 
 /**
  * Return true if the provided block header is valid.
  * Only verify PoW if blockValidationOptions is configured to do so.
  * This allows validation of headers on which the PoW hasn't been done.
  * For example: to validate template handed to mining software.
  * Do not call this for any check that depends on the context.
  * For context-dependent calls, see ContextualCheckBlockHeader.
  */
 static bool CheckBlockHeader(const CBlockHeader &block,
                              BlockValidationState &state,
                              const Consensus::Params &params,
                              BlockValidationOptions validationOptions) {
     // Check proof of work matches claimed amount
     if (validationOptions.shouldValidatePoW() &&
         !CheckProofOfWork(block.GetHash(), block.nBits, params)) {
         return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER,
                              "high-hash", "proof of work failed");
     }
 
     return true;
 }
 
 bool CheckBlock(const CBlock &block, BlockValidationState &state,
                 const Consensus::Params &params,
                 BlockValidationOptions validationOptions) {
     // These are checks that are independent of context.
     if (block.fChecked) {
         return true;
     }
 
     // Check that the header is valid (particularly PoW).  This is mostly
     // redundant with the call in AcceptBlockHeader.
     if (!CheckBlockHeader(block, state, params, validationOptions)) {
         return false;
     }
 
     // Check the merkle root.
     if (validationOptions.shouldValidateMerkleRoot()) {
         bool mutated;
         uint256 hashMerkleRoot2 = BlockMerkleRoot(block, &mutated);
         if (block.hashMerkleRoot != hashMerkleRoot2) {
             return state.Invalid(BlockValidationResult::BLOCK_MUTATED,
                                  "bad-txnmrklroot", "hashMerkleRoot mismatch");
         }
 
         // Check for merkle tree malleability (CVE-2012-2459): repeating
         // sequences of transactions in a block without affecting the merkle
         // root of a block, while still invalidating it.
         if (mutated) {
             return state.Invalid(BlockValidationResult::BLOCK_MUTATED,
                                  "bad-txns-duplicate", "duplicate transaction");
         }
     }
 
     // All potential-corruption validation must be done before we do any
     // transaction validation, as otherwise we may mark the header as invalid
     // because we receive the wrong transactions for it.
 
     // First transaction must be coinbase.
     if (block.vtx.empty()) {
         return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
                              "bad-cb-missing", "first tx is not coinbase");
     }
 
     // Size limits.
     auto nMaxBlockSize = validationOptions.getExcessiveBlockSize();
 
     // Bail early if there is no way this block is of reasonable size.
     if ((block.vtx.size() * MIN_TRANSACTION_SIZE) > nMaxBlockSize) {
         return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
                              "bad-blk-length", "size limits failed");
     }
 
     auto currentBlockSize = ::GetSerializeSize(block, PROTOCOL_VERSION);
     if (currentBlockSize > nMaxBlockSize) {
         return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
                              "bad-blk-length", "size limits failed");
     }
 
     // And a valid coinbase.
     TxValidationState tx_state;
     if (!CheckCoinbase(*block.vtx[0], tx_state)) {
         return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
                              tx_state.GetRejectReason(),
                              strprintf("Coinbase check failed (txid %s) %s",
                                        block.vtx[0]->GetId().ToString(),
                                        tx_state.GetDebugMessage()));
     }
 
     // Check transactions for regularity, skipping the first. Note that this
     // is the first time we check that all after the first are !IsCoinBase.
     for (size_t i = 1; i < block.vtx.size(); i++) {
         auto *tx = block.vtx[i].get();
         if (!CheckRegularTransaction(*tx, tx_state)) {
             return state.Invalid(
                 BlockValidationResult::BLOCK_CONSENSUS,
                 tx_state.GetRejectReason(),
                 strprintf("Transaction check failed (txid %s) %s",
                           tx->GetId().ToString(), tx_state.GetDebugMessage()));
         }
     }
 
     if (validationOptions.shouldValidatePoW() &&
         validationOptions.shouldValidateMerkleRoot()) {
         block.fChecked = true;
     }
 
     return true;
 }
 
 /**
  * Context-dependent validity checks.
  * By "context", we mean only the previous block headers, but not the UTXO
  * set; UTXO-related validity checks are done in ConnectBlock().
  * NOTE: This function is not currently invoked by ConnectBlock(), so we
  * should consider upgrade issues if we change which consensus rules are
  * enforced in this function (eg by adding a new consensus rule). See comment
  * in ConnectBlock().
  * Note that -reindex-chainstate skips the validation that happens here!
  */
 static bool
 ContextualCheckBlockHeader(const CChainParams &params,
                            const CBlockHeader &block,
                            BlockValidationState &state, BlockManager &blockman,
                            const CBlockIndex *pindexPrev, int64_t nAdjustedTime)
     EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
     AssertLockHeld(::cs_main);
     assert(pindexPrev != nullptr);
     const int nHeight = pindexPrev->nHeight + 1;
 
     // Check proof of work
     if (block.nBits != GetNextWorkRequired(pindexPrev, &block, params)) {
         LogPrintf("bad bits after height: %d\n", pindexPrev->nHeight);
         return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER,
                              "bad-diffbits", "incorrect proof of work");
     }
 
     // Check against checkpoints
     if (fCheckpointsEnabled) {
         const CCheckpointData &checkpoints = params.Checkpoints();
 
         // Check that the block chain matches the known block chain up to a
         // checkpoint.
         if (!Checkpoints::CheckBlock(checkpoints, nHeight, block.GetHash())) {
             LogPrint(BCLog::VALIDATION,
                      "ERROR: %s: rejected by checkpoint lock-in at %d\n",
                      __func__, nHeight);
             return state.Invalid(BlockValidationResult::BLOCK_CHECKPOINT,
                                  "checkpoint mismatch");
         }
 
         // Don't accept any forks from the main chain prior to last checkpoint.
         // GetLastCheckpoint finds the last checkpoint in MapCheckpoints that's
         // in our BlockIndex().
 
         const CBlockIndex *pcheckpoint =
             blockman.GetLastCheckpoint(checkpoints);
         if (pcheckpoint && nHeight < pcheckpoint->nHeight) {
             LogPrint(BCLog::VALIDATION,
                      "ERROR: %s: forked chain older than last checkpoint "
                      "(height %d)\n",
                      __func__, nHeight);
             return state.Invalid(BlockValidationResult::BLOCK_CHECKPOINT,
                                  "bad-fork-prior-to-checkpoint");
         }
     }
 
     // Check timestamp against prev
     if (block.GetBlockTime() <= pindexPrev->GetMedianTimePast()) {
         return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER,
                              "time-too-old", "block's timestamp is too early");
     }
 
     // Check timestamp
     if (block.GetBlockTime() > nAdjustedTime + MAX_FUTURE_BLOCK_TIME) {
         return state.Invalid(BlockValidationResult::BLOCK_TIME_FUTURE,
                              "time-too-new",
                              "block timestamp too far in the future");
     }
 
     const Consensus::Params &consensusParams = params.GetConsensus();
     // Reject blocks with outdated version
     if ((block.nVersion < 2 &&
          DeploymentActiveAfter(pindexPrev, consensusParams,
                                Consensus::DEPLOYMENT_HEIGHTINCB)) ||
         (block.nVersion < 3 &&
          DeploymentActiveAfter(pindexPrev, consensusParams,
                                Consensus::DEPLOYMENT_DERSIG)) ||
         (block.nVersion < 4 &&
          DeploymentActiveAfter(pindexPrev, consensusParams,
                                Consensus::DEPLOYMENT_CLTV))) {
         return state.Invalid(
             BlockValidationResult::BLOCK_INVALID_HEADER,
             strprintf("bad-version(0x%08x)", block.nVersion),
             strprintf("rejected nVersion=0x%08x block", block.nVersion));
     }
 
     return true;
 }
 
 bool ContextualCheckTransactionForCurrentBlock(
     const CBlockIndex *active_chain_tip, const Consensus::Params &params,
     const CTransaction &tx, TxValidationState &state) {
     AssertLockHeld(cs_main);
     // TODO: Make active_chain_tip a reference
     assert(active_chain_tip);
 
     // ContextualCheckTransactionForCurrentBlock() uses
     // active_chain_tip.Height()+1 to evaluate nLockTime because when
     // IsFinalTx() is called within AcceptBlock(), the height of the
     // block *being* evaluated is what is used. Thus if we want to know if a
     // transaction can be part of the *next* block, we need to call
     // ContextualCheckTransaction() with one more than
     // active_chain_tip.Height().
     const int nBlockHeight = active_chain_tip->nHeight + 1;
 
     // BIP113 will require that time-locked transactions have nLockTime set to
     // less than the median time of the previous block they're contained in.
     // When the next block is created its previous block will be the current
     // chain tip, so we use that to calculate the median time passed to
     // ContextualCheckTransaction().
     const int64_t nLockTimeCutoff{active_chain_tip->GetMedianTimePast()};
 
     return ContextualCheckTransaction(params, tx, state, nBlockHeight,
                                       nLockTimeCutoff);
 }
 
 /**
  * NOTE: This function is not currently invoked by ConnectBlock(), so we
  * should consider upgrade issues if we change which consensus rules are
  * enforced in this function (eg by adding a new consensus rule). See comment
  * in ConnectBlock().
  * Note that -reindex-chainstate skips the validation that happens here!
  */
 static bool ContextualCheckBlock(const CBlock &block,
                                  BlockValidationState &state,
                                  const Consensus::Params &params,
                                  const CBlockIndex *pindexPrev) {
     const int nHeight = pindexPrev == nullptr ? 0 : pindexPrev->nHeight + 1;
 
     // Enforce BIP113 (Median Time Past).
     int nLockTimeFlags = 0;
     if (DeploymentActiveAfter(pindexPrev, params, Consensus::DEPLOYMENT_CSV)) {
         assert(pindexPrev != nullptr);
         nLockTimeFlags |= LOCKTIME_MEDIAN_TIME_PAST;
     }
 
     const int64_t nMedianTimePast =
         pindexPrev == nullptr ? 0 : pindexPrev->GetMedianTimePast();
 
     const int64_t nLockTimeCutoff = (nLockTimeFlags & LOCKTIME_MEDIAN_TIME_PAST)
                                         ? nMedianTimePast
                                         : block.GetBlockTime();
 
     const bool fIsMagneticAnomalyEnabled =
         IsMagneticAnomalyEnabled(params, pindexPrev);
 
     // Check transactions:
     // - canonical ordering
     // - ensure they are finalized
     // - check they have the minimum size
     const CTransaction *prevTx = nullptr;
     for (const auto &ptx : block.vtx) {
         const CTransaction &tx = *ptx;
         if (fIsMagneticAnomalyEnabled) {
             if (prevTx && (tx.GetId() <= prevTx->GetId())) {
                 if (tx.GetId() == prevTx->GetId()) {
                     return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
                                          "tx-duplicate",
                                          strprintf("Duplicated transaction %s",
                                                    tx.GetId().ToString()));
                 }
 
                 return state.Invalid(
                     BlockValidationResult::BLOCK_CONSENSUS, "tx-ordering",
                     strprintf("Transaction order is invalid (%s < %s)",
                               tx.GetId().ToString(),
                               prevTx->GetId().ToString()));
             }
 
             if (prevTx || !tx.IsCoinBase()) {
                 prevTx = &tx;
             }
         }
 
         TxValidationState tx_state;
         if (!ContextualCheckTransaction(params, tx, tx_state, nHeight,
                                         nLockTimeCutoff)) {
             return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
                                  tx_state.GetRejectReason(),
                                  tx_state.GetDebugMessage());
         }
     }
 
     // Enforce rule that the coinbase starts with serialized block height
     if (DeploymentActiveAfter(pindexPrev, params,
                               Consensus::DEPLOYMENT_HEIGHTINCB)) {
         CScript expect = CScript() << nHeight;
         if (block.vtx[0]->vin[0].scriptSig.size() < expect.size() ||
             !std::equal(expect.begin(), expect.end(),
                         block.vtx[0]->vin[0].scriptSig.begin())) {
             return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
                                  "bad-cb-height",
                                  "block height mismatch in coinbase");
         }
     }
 
     return true;
 }
 
 /**
  * If the provided block header is valid, add it to the block index.
  *
  * Returns true if the block is successfully added to the block index.
  */
 bool ChainstateManager::AcceptBlockHeader(const Config &config,
                                           const CBlockHeader &block,
                                           BlockValidationState &state,
                                           CBlockIndex **ppindex) {
     AssertLockHeld(cs_main);
     const CChainParams &chainparams = config.GetChainParams();
 
     // Check for duplicate
     BlockHash hash = block.GetHash();
     BlockMap::iterator miSelf{m_blockman.m_block_index.find(hash)};
     if (hash != chainparams.GetConsensus().hashGenesisBlock) {
         if (miSelf != m_blockman.m_block_index.end()) {
             // Block header is already known.
             CBlockIndex *pindex = &(miSelf->second);
             if (ppindex) {
                 *ppindex = pindex;
             }
 
             if (pindex->nStatus.isInvalid()) {
                 LogPrint(BCLog::VALIDATION, "%s: block %s is marked invalid\n",
                          __func__, hash.ToString());
                 return state.Invalid(
                     BlockValidationResult::BLOCK_CACHED_INVALID, "duplicate");
             }
 
             return true;
         }
 
         if (!CheckBlockHeader(block, state, chainparams.GetConsensus(),
                               BlockValidationOptions(config))) {
             LogPrint(BCLog::VALIDATION,
                      "%s: Consensus::CheckBlockHeader: %s, %s\n", __func__,
                      hash.ToString(), state.ToString());
             return false;
         }
 
         // Get prev block index
         BlockMap::iterator mi{
             m_blockman.m_block_index.find(block.hashPrevBlock)};
         if (mi == m_blockman.m_block_index.end()) {
             LogPrint(BCLog::VALIDATION,
                      "header %s has prev block not found: %s\n",
                      hash.ToString(), block.hashPrevBlock.ToString());
             return state.Invalid(BlockValidationResult::BLOCK_MISSING_PREV,
                                  "prev-blk-not-found");
         }
 
         CBlockIndex *pindexPrev = &((*mi).second);
         assert(pindexPrev);
         if (pindexPrev->nStatus.isInvalid()) {
             LogPrint(BCLog::VALIDATION,
                      "header %s has prev block invalid: %s\n", hash.ToString(),
                      block.hashPrevBlock.ToString());
             return state.Invalid(BlockValidationResult::BLOCK_INVALID_PREV,
                                  "bad-prevblk");
         }
 
         if (!ContextualCheckBlockHeader(chainparams, block, state, m_blockman,
                                         pindexPrev, GetAdjustedTime())) {
             LogPrint(BCLog::VALIDATION,
                      "%s: Consensus::ContextualCheckBlockHeader: %s, %s\n",
                      __func__, hash.ToString(), state.ToString());
             return false;
         }
 
         /* Determine if this block descends from any block which has been found
          * invalid (m_failed_blocks), then mark pindexPrev and any blocks
          * between them as failed. For example:
          *
          *                D3
          *              /
          *      B2 - C2
          *    /         \
          *  A             D2 - E2 - F2
          *    \
          *      B1 - C1 - D1 - E1
          *
          * In the case that we attempted to reorg from E1 to F2, only to find
          * C2 to be invalid, we would mark D2, E2, and F2 as BLOCK_FAILED_CHILD
          * but NOT D3 (it was not in any of our candidate sets at the time).
          *
          * In any case D3 will also be marked as BLOCK_FAILED_CHILD at restart
          * in LoadBlockIndex.
          */
         if (!pindexPrev->IsValid(BlockValidity::SCRIPTS)) {
             // The above does not mean "invalid": it checks if the previous
             // block hasn't been validated up to BlockValidity::SCRIPTS. This is
             // a performance optimization, in the common case of adding a new
             // block to the tip, we don't need to iterate over the failed blocks
             // list.
             for (const CBlockIndex *failedit : m_failed_blocks) {
                 if (pindexPrev->GetAncestor(failedit->nHeight) == failedit) {
                     assert(failedit->nStatus.hasFailed());
                     CBlockIndex *invalid_walk = pindexPrev;
                     while (invalid_walk != failedit) {
                         invalid_walk->nStatus =
                             invalid_walk->nStatus.withFailedParent();
                         m_blockman.m_dirty_blockindex.insert(invalid_walk);
                         invalid_walk = invalid_walk->pprev;
                     }
                     LogPrint(BCLog::VALIDATION,
                              "header %s has prev block invalid: %s\n",
                              hash.ToString(), block.hashPrevBlock.ToString());
                     return state.Invalid(
                         BlockValidationResult::BLOCK_INVALID_PREV,
                         "bad-prevblk");
                 }
             }
         }
     }
 
     CBlockIndex *pindex{m_blockman.AddToBlockIndex(block, m_best_header)};
 
     if (ppindex) {
         *ppindex = pindex;
     }
 
     return true;
 }
 
 // Exposed wrapper for AcceptBlockHeader
 bool ChainstateManager::ProcessNewBlockHeaders(
     const Config &config, const std::vector<CBlockHeader> &headers,
     BlockValidationState &state, const CBlockIndex **ppindex) {
     AssertLockNotHeld(cs_main);
     {
         LOCK(cs_main);
         for (const CBlockHeader &header : headers) {
             // Use a temp pindex instead of ppindex to avoid a const_cast
             CBlockIndex *pindex = nullptr;
             bool accepted = AcceptBlockHeader(config, header, state, &pindex);
             ActiveChainstate().CheckBlockIndex();
 
             if (!accepted) {
                 return false;
             }
 
             if (ppindex) {
                 *ppindex = pindex;
             }
         }
     }
 
     if (NotifyHeaderTip(ActiveChainstate())) {
         if (ActiveChainstate().IsInitialBlockDownload() && ppindex &&
             *ppindex) {
             const CBlockIndex &last_accepted{**ppindex};
             const int64_t blocks_left{
                 (GetTime() - last_accepted.GetBlockTime()) /
                 config.GetChainParams().GetConsensus().nPowTargetSpacing};
             const double progress{100.0 * last_accepted.nHeight /
                                   (last_accepted.nHeight + blocks_left)};
             LogPrintf("Synchronizing blockheaders, height: %d (~%.2f%%)\n",
                       last_accepted.nHeight, progress);
         }
     }
     return true;
 }
 
 /**
  * Store a block on disk.
  *
  * @param[in]     config     The global config.
  * @param[in,out] pblock     The block we want to accept.
  * @param[in]     fRequested A boolean to indicate if this block was requested
  *                           from our peers.
  * @param[in]     dbp        If non-null, the disk position of the block.
  * @param[in,out] fNewBlock  True if block was first received via this call.
  * @return True if the block is accepted as a valid block and written to disk.
  */
 bool CChainState::AcceptBlock(const Config &config,
                               const std::shared_ptr<const CBlock> &pblock,
                               BlockValidationState &state, bool fRequested,
                               const FlatFilePos *dbp, bool *fNewBlock) {
     AssertLockHeld(cs_main);
 
     const CBlock &block = *pblock;
     if (fNewBlock) {
         *fNewBlock = false;
     }
 
     CBlockIndex *pindex = nullptr;
 
     bool accepted_header{
         m_chainman.AcceptBlockHeader(config, block, state, &pindex)};
     CheckBlockIndex();
 
     if (!accepted_header) {
         return false;
     }
 
     // Try to process all requested blocks that we don't have, but only
     // process an unrequested block if it's new and has enough work to
     // advance our tip, and isn't too many blocks ahead.
     bool fAlreadyHave = pindex->nStatus.hasData();
 
     // TODO: deal better with return value and error conditions for duplicate
     // and unrequested blocks.
     if (fAlreadyHave) {
         return true;
     }
 
     // Compare block header timestamps and received times of the block and the
     // chaintip.  If they have the same chain height, use these diffs as a
     // tie-breaker, attempting to pick the more honestly-mined block.
     int64_t newBlockTimeDiff = std::llabs(pindex->GetReceivedTimeDiff());
     int64_t chainTipTimeDiff =
         m_chain.Tip() ? std::llabs(m_chain.Tip()->GetReceivedTimeDiff()) : 0;
 
     bool isSameHeight =
         m_chain.Tip() && (pindex->nChainWork == m_chain.Tip()->nChainWork);
     if (isSameHeight) {
         LogPrintf("Chain tip timestamp-to-received-time difference: hash=%s, "
                   "diff=%d\n",
                   m_chain.Tip()->GetBlockHash().ToString(), chainTipTimeDiff);
         LogPrintf("New block timestamp-to-received-time difference: hash=%s, "
                   "diff=%d\n",
                   pindex->GetBlockHash().ToString(), newBlockTimeDiff);
     }
 
     bool fHasMoreOrSameWork =
         (m_chain.Tip() ? pindex->nChainWork >= m_chain.Tip()->nChainWork
                        : true);
 
     // Blocks that are too out-of-order needlessly limit the effectiveness of
     // pruning, because pruning will not delete block files that contain any
     // blocks which are too close in height to the tip.  Apply this test
     // regardless of whether pruning is enabled; it should generally be safe to
     // not process unrequested blocks.
     bool fTooFarAhead{pindex->nHeight >
                       m_chain.Height() + int(MIN_BLOCKS_TO_KEEP)};
 
     // TODO: Decouple this function from the block download logic by removing
     // fRequested
     // This requires some new chain data structure to efficiently look up if a
     // block is in a chain leading to a candidate for best tip, despite not
     // being such a candidate itself.
     // Note that this would break the getblockfrompeer RPC
 
     // If we didn't ask for it:
     if (!fRequested) {
         // This is a previously-processed block that was pruned.
         if (pindex->nTx != 0) {
             return true;
         }
 
         // Don't process less-work chains.
         if (!fHasMoreOrSameWork) {
             return true;
         }
 
         // Block height is too high.
         if (fTooFarAhead) {
             return true;
         }
 
         // Protect against DoS attacks from low-work chains.
         // If our tip is behind, a peer could try to send us
         // low-work blocks on a fake chain that we would never
         // request; don't process these.
         if (pindex->nChainWork < nMinimumChainWork) {
             return true;
         }
     }
 
     const Consensus::Params &consensusParams = m_params.GetConsensus();
 
     if (!CheckBlock(block, state, consensusParams,
                     BlockValidationOptions(config)) ||
         !ContextualCheckBlock(block, state, consensusParams, pindex->pprev)) {
         if (state.IsInvalid() &&
             state.GetResult() != BlockValidationResult::BLOCK_MUTATED) {
             pindex->nStatus = pindex->nStatus.withFailed();
             m_blockman.m_dirty_blockindex.insert(pindex);
         }
 
         return error("%s: %s (block %s)", __func__, state.ToString(),
                      block.GetHash().ToString());
     }
 
     // If connecting the new block would require rewinding more than one block
     // from the active chain (i.e., a "deep reorg"), then mark the new block as
     // parked. If it has enough work then it will be automatically unparked
     // later, during FindMostWorkChain. We mark the block as parked at the very
     // last minute so we can make sure everything is ready to be reorged if
     // needed.
     if (gArgs.GetBoolArg("-parkdeepreorg", true)) {
         const CBlockIndex *pindexFork = m_chain.FindFork(pindex);
         if (pindexFork && pindexFork->nHeight + 1 < m_chain.Height()) {
             LogPrintf("Park block %s as it would cause a deep reorg.\n",
                       pindex->GetBlockHash().ToString());
             pindex->nStatus = pindex->nStatus.withParked();
             m_blockman.m_dirty_blockindex.insert(pindex);
         }
     }
 
     // Header is valid/has work and the merkle tree is good.
     // Relay now, but if it does not build on our best tip, let the
     // SendMessages loop relay it.
     if (!IsInitialBlockDownload() && m_chain.Tip() == pindex->pprev) {
         GetMainSignals().NewPoWValidBlock(pindex, pblock);
     }
 
     // Write block to history file
     if (fNewBlock) {
         *fNewBlock = true;
     }
     try {
         FlatFilePos blockPos{m_blockman.SaveBlockToDisk(
             block, pindex->nHeight, m_chain, m_params, dbp)};
         if (blockPos.IsNull()) {
             state.Error(strprintf(
                 "%s: Failed to find position to write new block to disk",
                 __func__));
             return false;
         }
         ReceivedBlockTransactions(block, pindex, blockPos);
     } catch (const std::runtime_error &e) {
         return AbortNode(state, std::string("System error: ") + e.what());
     }
 
     FlushStateToDisk(state, FlushStateMode::NONE);
 
     CheckBlockIndex();
 
     return true;
 }
 
 bool ChainstateManager::ProcessNewBlock(
     const Config &config, const std::shared_ptr<const CBlock> &block,
     bool force_processing, bool *new_block) {
     AssertLockNotHeld(cs_main);
 
     {
         if (new_block) {
             *new_block = false;
         }
 
         BlockValidationState state;
 
         // CheckBlock() does not support multi-threaded block validation
         // because CBlock::fChecked can cause data race.
         // Therefore, the following critical section must include the
         // CheckBlock() call as well.
         LOCK(cs_main);
 
         // Skipping AcceptBlock() for CheckBlock() failures means that we will
         // never mark a block as invalid if CheckBlock() fails.  This is
         // protective against consensus failure if there are any unknown form
         // s of block malleability that cause CheckBlock() to fail; see e.g.
         // CVE-2012-2459 and
         // https://lists.linuxfoundation.org/pipermail/bitcoin-dev/2019-February/016697.html.
         // Because CheckBlock() is not very expensive, the anti-DoS benefits of
         // caching failure (of a definitely-invalid block) are not substantial.
         bool ret =
             CheckBlock(*block, state, config.GetChainParams().GetConsensus(),
                        BlockValidationOptions(config));
         if (ret) {
             // Store to disk
             ret = ActiveChainstate().AcceptBlock(
                 config, block, state, force_processing, nullptr, new_block);
         }
 
         if (!ret) {
             GetMainSignals().BlockChecked(*block, state);
             return error("%s: AcceptBlock FAILED (%s)", __func__,
                          state.ToString());
         }
     }
 
     NotifyHeaderTip(ActiveChainstate());
 
     // Only used to report errors, not invalidity - ignore it
     BlockValidationState state;
     if (!ActiveChainstate().ActivateBestChain(config, state, block)) {
         return error("%s: ActivateBestChain failed (%s)", __func__,
                      state.ToString());
     }
 
     return true;
 }
 
 MempoolAcceptResult
 ChainstateManager::ProcessTransaction(const CTransactionRef &tx,
                                       bool test_accept) {
     AssertLockHeld(cs_main);
     CChainState &active_chainstate = ActiveChainstate();
     if (!active_chainstate.GetMempool()) {
         TxValidationState state;
         state.Invalid(TxValidationResult::TX_NO_MEMPOOL, "no-mempool");
         return MempoolAcceptResult::Failure(state);
     }
     // Use GetConfig() temporarily. It will be removed in a follow-up by
     // making AcceptToMemoryPool take a CChainParams instead of a Config.
     // This avoids passing an extra Config argument to this function that will
     // be removed soon.
     auto result =
         AcceptToMemoryPool(::GetConfig(), active_chainstate, tx, GetTime(),
                            /*bypass_limits=*/false, test_accept);
     active_chainstate.GetMempool()->check(
         active_chainstate.CoinsTip(), active_chainstate.m_chain.Height() + 1);
     return result;
 }
 
 bool TestBlockValidity(BlockValidationState &state, const CChainParams &params,
                        CChainState &chainstate, const CBlock &block,
                        CBlockIndex *pindexPrev,
                        BlockValidationOptions validationOptions) {
     AssertLockHeld(cs_main);
     assert(pindexPrev && pindexPrev == chainstate.m_chain.Tip());
     CCoinsViewCache viewNew(&chainstate.CoinsTip());
     BlockHash block_hash(block.GetHash());
     CBlockIndex indexDummy(block);
     indexDummy.pprev = pindexPrev;
     indexDummy.nHeight = pindexPrev->nHeight + 1;
     indexDummy.phashBlock = &block_hash;
 
     // NOTE: CheckBlockHeader is called by CheckBlock
     if (!ContextualCheckBlockHeader(params, block, state, chainstate.m_blockman,
                                     pindexPrev, GetAdjustedTime())) {
         return error("%s: Consensus::ContextualCheckBlockHeader: %s", __func__,
                      state.ToString());
     }
 
     if (!CheckBlock(block, state, params.GetConsensus(), validationOptions)) {
         return error("%s: Consensus::CheckBlock: %s", __func__,
                      state.ToString());
     }
 
     if (!ContextualCheckBlock(block, state, params.GetConsensus(),
                               pindexPrev)) {
         return error("%s: Consensus::ContextualCheckBlock: %s", __func__,
                      state.ToString());
     }
 
     if (!chainstate.ConnectBlock(block, state, &indexDummy, viewNew,
                                  validationOptions, true)) {
         return false;
     }
 
     assert(state.IsValid());
     return true;
 }
 
 /* This function is called from the RPC code for pruneblockchain */
 void PruneBlockFilesManual(CChainState &active_chainstate,
                            int nManualPruneHeight) {
     BlockValidationState state;
     if (active_chainstate.FlushStateToDisk(state, FlushStateMode::NONE,
                                            nManualPruneHeight)) {
         LogPrintf("%s: failed to flush state (%s)\n", __func__,
                   state.ToString());
     }
 }
 
 void CChainState::LoadMempool(const Config &config, const ArgsManager &args) {
     if (!m_mempool) {
         return;
     }
     if (args.GetBoolArg("-persistmempool", DEFAULT_PERSIST_MEMPOOL)) {
         ::LoadMempool(config, *m_mempool, *this);
     }
     m_mempool->SetIsLoaded(!ShutdownRequested());
 }
 
 bool CChainState::LoadChainTip() {
     AssertLockHeld(cs_main);
     const CCoinsViewCache &coins_cache = CoinsTip();
     // Never called when the coins view is empty
     assert(!coins_cache.GetBestBlock().IsNull());
     const CBlockIndex *tip = m_chain.Tip();
 
     if (tip && tip->GetBlockHash() == coins_cache.GetBestBlock()) {
         return true;
     }
 
     // Load pointer to end of best chain
     CBlockIndex *pindex =
         m_blockman.LookupBlockIndex(coins_cache.GetBestBlock());
     if (!pindex) {
         return false;
     }
     m_chain.SetTip(pindex);
     PruneBlockIndexCandidates();
 
     tip = m_chain.Tip();
     LogPrintf(
         "Loaded best chain: hashBestChain=%s height=%d date=%s progress=%f\n",
         tip->GetBlockHash().ToString(), m_chain.Height(),
         FormatISO8601DateTime(tip->GetBlockTime()),
         GuessVerificationProgress(m_params.TxData(), tip));
     return true;
 }
 
 CVerifyDB::CVerifyDB() {
     uiInterface.ShowProgress(_("Verifying blocks...").translated, 0, false);
 }
 
 CVerifyDB::~CVerifyDB() {
     uiInterface.ShowProgress("", 100, false);
 }
 
 bool CVerifyDB::VerifyDB(CChainState &chainstate, const Config &config,
                          CCoinsView &coinsview, int nCheckLevel,
                          int nCheckDepth) {
     AssertLockHeld(cs_main);
 
     const CChainParams &params = config.GetChainParams();
     const Consensus::Params &consensusParams = params.GetConsensus();
 
     if (chainstate.m_chain.Tip() == nullptr ||
         chainstate.m_chain.Tip()->pprev == nullptr) {
         return true;
     }
 
     // Verify blocks in the best chain
     if (nCheckDepth <= 0 || nCheckDepth > chainstate.m_chain.Height()) {
         nCheckDepth = chainstate.m_chain.Height();
     }
 
     nCheckLevel = std::max(0, std::min(4, nCheckLevel));
     LogPrintf("Verifying last %i blocks at level %i\n", nCheckDepth,
               nCheckLevel);
 
     CCoinsViewCache coins(&coinsview);
     CBlockIndex *pindex;
     CBlockIndex *pindexFailure = nullptr;
     int nGoodTransactions = 0;
     BlockValidationState state;
     int reportDone = 0;
     LogPrintfToBeContinued("[0%%]...");
 
     const bool is_snapshot_cs{!chainstate.m_from_snapshot_blockhash};
 
     for (pindex = chainstate.m_chain.Tip(); pindex && pindex->pprev;
          pindex = pindex->pprev) {
         const int percentageDone = std::max(
             1, std::min(99, (int)(((double)(chainstate.m_chain.Height() -
                                             pindex->nHeight)) /
                                   (double)nCheckDepth *
                                   (nCheckLevel >= 4 ? 50 : 100))));
         if (reportDone < percentageDone / 10) {
             // report every 10% step
             LogPrintfToBeContinued("[%d%%]...", percentageDone);
             reportDone = percentageDone / 10;
         }
 
         uiInterface.ShowProgress(_("Verifying blocks...").translated,
                                  percentageDone, false);
         if (pindex->nHeight <= chainstate.m_chain.Height() - nCheckDepth) {
             break;
         }
 
         if ((fPruneMode || is_snapshot_cs) && !pindex->nStatus.hasData()) {
             // If pruning or running under an assumeutxo snapshot, only go
             // back as far as we have data.
             LogPrintf("VerifyDB(): block verification stopping at height %d "
                       "(pruning, no data)\n",
                       pindex->nHeight);
             break;
         }
 
         CBlock block;
 
         // check level 0: read from disk
         if (!ReadBlockFromDisk(block, pindex, consensusParams)) {
             return error(
                 "VerifyDB(): *** ReadBlockFromDisk failed at %d, hash=%s",
                 pindex->nHeight, pindex->GetBlockHash().ToString());
         }
 
         // check level 1: verify block validity
         if (nCheckLevel >= 1 && !CheckBlock(block, state, consensusParams,
                                             BlockValidationOptions(config))) {
             return error("%s: *** found bad block at %d, hash=%s (%s)\n",
                          __func__, pindex->nHeight,
                          pindex->GetBlockHash().ToString(), state.ToString());
         }
 
         // check level 2: verify undo validity
         if (nCheckLevel >= 2 && pindex) {
             CBlockUndo undo;
             if (!pindex->GetUndoPos().IsNull()) {
                 if (!UndoReadFromDisk(undo, pindex)) {
                     return error(
                         "VerifyDB(): *** found bad undo data at %d, hash=%s\n",
                         pindex->nHeight, pindex->GetBlockHash().ToString());
                 }
             }
         }
         // check level 3: check for inconsistencies during memory-only
         // disconnect of tip blocks
         size_t curr_coins_usage = coins.DynamicMemoryUsage() +
                                   chainstate.CoinsTip().DynamicMemoryUsage();
 
         if (nCheckLevel >= 3 &&
             curr_coins_usage <= chainstate.m_coinstip_cache_size_bytes) {
             assert(coins.GetBestBlock() == pindex->GetBlockHash());
             DisconnectResult res =
                 chainstate.DisconnectBlock(block, pindex, coins);
             if (res == DisconnectResult::FAILED) {
                 return error("VerifyDB(): *** irrecoverable inconsistency in "
                              "block data at %d, hash=%s",
                              pindex->nHeight,
                              pindex->GetBlockHash().ToString());
             }
 
             if (res == DisconnectResult::UNCLEAN) {
                 nGoodTransactions = 0;
                 pindexFailure = pindex;
             } else {
                 nGoodTransactions += block.vtx.size();
             }
         }
 
         if (ShutdownRequested()) {
             return true;
         }
     }
 
     if (pindexFailure) {
         return error("VerifyDB(): *** coin database inconsistencies found "
                      "(last %i blocks, %i good transactions before that)\n",
                      chainstate.m_chain.Height() - pindexFailure->nHeight + 1,
                      nGoodTransactions);
     }
 
     // store block count as we move pindex at check level >= 4
     int block_count = chainstate.m_chain.Height() - pindex->nHeight;
 
     // check level 4: try reconnecting blocks
     if (nCheckLevel >= 4) {
         while (pindex != chainstate.m_chain.Tip()) {
             const int percentageDone = std::max(
                 1, std::min(99, 100 - int(double(chainstate.m_chain.Height() -
                                                  pindex->nHeight) /
                                           double(nCheckDepth) * 50)));
             if (reportDone < percentageDone / 10) {
                 // report every 10% step
                 LogPrintfToBeContinued("[%d%%]...", percentageDone);
                 reportDone = percentageDone / 10;
             }
             uiInterface.ShowProgress(_("Verifying blocks...").translated,
                                      percentageDone, false);
             pindex = chainstate.m_chain.Next(pindex);
             CBlock block;
             if (!ReadBlockFromDisk(block, pindex, consensusParams)) {
                 return error(
                     "VerifyDB(): *** ReadBlockFromDisk failed at %d, hash=%s",
                     pindex->nHeight, pindex->GetBlockHash().ToString());
             }
             if (!chainstate.ConnectBlock(block, state, pindex, coins,
                                          BlockValidationOptions(config))) {
                 return error("VerifyDB(): *** found unconnectable block at %d, "
                              "hash=%s (%s)",
                              pindex->nHeight, pindex->GetBlockHash().ToString(),
                              state.ToString());
             }
             if (ShutdownRequested()) {
                 return true;
             }
         }
     }
 
     LogPrintf("[DONE].\n");
     LogPrintf("No coin database inconsistencies in last %i blocks (%i "
               "transactions)\n",
               block_count, nGoodTransactions);
 
     return true;
 }
 
 /**
  * Apply the effects of a block on the utxo cache, ignoring that it may already
  * have been applied.
  */
 bool CChainState::RollforwardBlock(const CBlockIndex *pindex,
                                    CCoinsViewCache &view) {
     AssertLockHeld(cs_main);
     // TODO: merge with ConnectBlock
     CBlock block;
     if (!ReadBlockFromDisk(block, pindex, m_params.GetConsensus())) {
         return error("ReplayBlock(): ReadBlockFromDisk failed at %d, hash=%s",
                      pindex->nHeight, pindex->GetBlockHash().ToString());
     }
 
     for (const CTransactionRef &tx : block.vtx) {
         // Pass check = true as every addition may be an overwrite.
         AddCoins(view, *tx, pindex->nHeight, true);
     }
 
     for (const CTransactionRef &tx : block.vtx) {
         if (tx->IsCoinBase()) {
             continue;
         }
 
         for (const CTxIn &txin : tx->vin) {
             view.SpendCoin(txin.prevout);
         }
     }
 
     return true;
 }
 
 bool CChainState::ReplayBlocks() {
     LOCK(cs_main);
 
     CCoinsView &db = this->CoinsDB();
     CCoinsViewCache cache(&db);
 
     std::vector<BlockHash> hashHeads = db.GetHeadBlocks();
     if (hashHeads.empty()) {
         // We're already in a consistent state.
         return true;
     }
     if (hashHeads.size() != 2) {
         return error("ReplayBlocks(): unknown inconsistent state");
     }
 
     uiInterface.ShowProgress(_("Replaying blocks...").translated, 0, false);
     LogPrintf("Replaying blocks\n");
 
     // Old tip during the interrupted flush.
     const CBlockIndex *pindexOld = nullptr;
     // New tip during the interrupted flush.
     const CBlockIndex *pindexNew;
     // Latest block common to both the old and the new tip.
     const CBlockIndex *pindexFork = nullptr;
 
     if (m_blockman.m_block_index.count(hashHeads[0]) == 0) {
         return error(
             "ReplayBlocks(): reorganization to unknown block requested");
     }
 
     pindexNew = &(m_blockman.m_block_index[hashHeads[0]]);
 
     if (!hashHeads[1].IsNull()) {
         // The old tip is allowed to be 0, indicating it's the first flush.
         if (m_blockman.m_block_index.count(hashHeads[1]) == 0) {
             return error(
                 "ReplayBlocks(): reorganization from unknown block requested");
         }
 
         pindexOld = &(m_blockman.m_block_index[hashHeads[1]]);
         pindexFork = LastCommonAncestor(pindexOld, pindexNew);
         assert(pindexFork != nullptr);
     }
 
     // Rollback along the old branch.
     while (pindexOld != pindexFork) {
         if (pindexOld->nHeight > 0) {
             // Never disconnect the genesis block.
             CBlock block;
             if (!ReadBlockFromDisk(block, pindexOld, m_params.GetConsensus())) {
                 return error("RollbackBlock(): ReadBlockFromDisk() failed at "
                              "%d, hash=%s",
                              pindexOld->nHeight,
                              pindexOld->GetBlockHash().ToString());
             }
 
             LogPrintf("Rolling back %s (%i)\n",
                       pindexOld->GetBlockHash().ToString(), pindexOld->nHeight);
             DisconnectResult res = DisconnectBlock(block, pindexOld, cache);
             if (res == DisconnectResult::FAILED) {
                 return error(
                     "RollbackBlock(): DisconnectBlock failed at %d, hash=%s",
                     pindexOld->nHeight, pindexOld->GetBlockHash().ToString());
             }
 
             // If DisconnectResult::UNCLEAN is returned, it means a non-existing
             // UTXO was deleted, or an existing UTXO was overwritten. It
             // corresponds to cases where the block-to-be-disconnect never had
             // all its operations applied to the UTXO set. However, as both
             // writing a UTXO and deleting a UTXO are idempotent operations, the
             // result is still a version of the UTXO set with the effects of
             // that block undone.
         }
         pindexOld = pindexOld->pprev;
     }
 
     // Roll forward from the forking point to the new tip.
     int nForkHeight = pindexFork ? pindexFork->nHeight : 0;
     for (int nHeight = nForkHeight + 1; nHeight <= pindexNew->nHeight;
          ++nHeight) {
         const CBlockIndex *pindex = pindexNew->GetAncestor(nHeight);
         LogPrintf("Rolling forward %s (%i)\n",
                   pindex->GetBlockHash().ToString(), nHeight);
         uiInterface.ShowProgress(_("Replaying blocks...").translated,
                                  (int)((nHeight - nForkHeight) * 100.0 /
                                        (pindexNew->nHeight - nForkHeight)),
                                  false);
         if (!RollforwardBlock(pindex, cache)) {
             return false;
         }
     }
 
     cache.SetBestBlock(pindexNew->GetBlockHash());
     cache.Flush();
     uiInterface.ShowProgress("", 100, false);
     return true;
 }
 
 // May NOT be used after any connections are up as much of the peer-processing
 // logic assumes a consistent block index state
 void CChainState::UnloadBlockIndex() {
     AssertLockHeld(::cs_main);
     nBlockSequenceId = 1;
     setBlockIndexCandidates.clear();
-
-    // Do not point to CBlockIndex that will be free'd
-    m_finalizedBlockIndex = nullptr;
 }
 
 // May NOT be used after any connections are up as much
 // of the peer-processing logic assumes a consistent
 // block index state
 void UnloadBlockIndex(CTxMemPool *mempool, ChainstateManager &chainman) {
     AssertLockHeld(::cs_main);
     chainman.Unload();
     pindexBestForkTip = nullptr;
     pindexBestForkBase = nullptr;
     if (mempool) {
         mempool->clear();
     }
 }
 
 bool ChainstateManager::LoadBlockIndex() {
     AssertLockHeld(cs_main);
     // Load block index from databases
     bool needs_init = fReindex;
     if (!fReindex) {
         bool ret = m_blockman.LoadBlockIndexDB();
         if (!ret) {
             return false;
         }
 
         std::vector<CBlockIndex *> vSortedByHeight{
             m_blockman.GetAllBlockIndices()};
         std::sort(vSortedByHeight.begin(), vSortedByHeight.end(),
                   CBlockIndexHeightOnlyComparator());
 
         // Find start of assumed-valid region.
         int first_assumed_valid_height = std::numeric_limits<int>::max();
 
         for (const CBlockIndex *block : vSortedByHeight) {
             if (block->IsAssumedValid()) {
                 auto chainstates = GetAll();
 
                 // If we encounter an assumed-valid block index entry, ensure
                 // that we have one chainstate that tolerates assumed-valid
                 // entries and another that does not (i.e. the background
                 // validation chainstate), since assumed-valid entries should
                 // always be pending validation by a fully-validated chainstate.
                 auto any_chain = [&](auto fnc) {
                     return std::any_of(chainstates.cbegin(), chainstates.cend(),
                                        fnc);
                 };
                 assert(any_chain([](auto chainstate) {
                     return chainstate->reliesOnAssumedValid();
                 }));
                 assert(any_chain([](auto chainstate) {
                     return !chainstate->reliesOnAssumedValid();
                 }));
 
                 first_assumed_valid_height = block->nHeight;
                 break;
             }
         }
 
         for (CBlockIndex *pindex : vSortedByHeight) {
             if (ShutdownRequested()) {
                 return false;
             }
             if (pindex->IsAssumedValid() ||
                 (pindex->IsValid(BlockValidity::TRANSACTIONS) &&
                  (pindex->HaveTxsDownloaded() || pindex->pprev == nullptr))) {
                 // Fill each chainstate's block candidate set. Only add
                 // assumed-valid blocks to the tip candidate set if the
                 // chainstate is allowed to rely on assumed-valid blocks.
                 //
                 // If all setBlockIndexCandidates contained the assumed-valid
                 // blocks, the background chainstate's ActivateBestChain() call
                 // would add assumed-valid blocks to the chain (based on how
                 // FindMostWorkChain() works). Obviously we don't want this
                 // since the purpose of the background validation chain is to
                 // validate assumed-valid blocks.
                 //
                 // Note: This is considering all blocks whose height is greater
                 // or equal to the first assumed-valid block to be assumed-valid
                 // blocks, and excluding them from the background chainstate's
                 // setBlockIndexCandidates set. This does mean that some blocks
                 // which are not technically assumed-valid (later blocks on a
                 // fork beginning before the first assumed-valid block) might
                 // not get added to the background chainstate, but this is ok,
                 // because they will still be attached to the active chainstate
                 // if they actually contain more work.
                 //
                 // Instead of this height-based approach, an earlier attempt was
                 // made at detecting "holistically" whether the block index
                 // under consideration relied on an assumed-valid ancestor, but
                 // this proved to be too slow to be practical.
                 for (CChainState *chainstate : GetAll()) {
                     if (chainstate->reliesOnAssumedValid() ||
                         pindex->nHeight < first_assumed_valid_height) {
                         chainstate->setBlockIndexCandidates.insert(pindex);
                     }
                 }
             }
 
             if (pindex->nStatus.isInvalid() &&
                 (!m_best_invalid ||
                  pindex->nChainWork > m_best_invalid->nChainWork)) {
                 m_best_invalid = pindex;
             }
 
             if (pindex->nStatus.isOnParkedChain() &&
                 (!m_best_parked ||
                  pindex->nChainWork > m_best_parked->nChainWork)) {
                 m_best_parked = pindex;
             }
 
             if (pindex->IsValid(BlockValidity::TREE) &&
                 (m_best_header == nullptr ||
                  CBlockIndexWorkComparator()(m_best_header, pindex))) {
                 m_best_header = pindex;
             }
         }
 
         needs_init = m_blockman.m_block_index.empty();
     }
 
     if (needs_init) {
         // Everything here is for *new* reindex/DBs. Thus, though
         // LoadBlockIndexDB may have set fReindex if we shut down
         // mid-reindex previously, we don't check fReindex and
         // instead only check it prior to LoadBlockIndexDB to set
         // needs_init.
 
         LogPrintf("Initializing databases...\n");
     }
     return true;
 }
 
 bool CChainState::LoadGenesisBlock() {
     LOCK(cs_main);
 
     // Check whether we're already initialized by checking for genesis in
     // m_blockman.m_block_index. Note that we can't use m_chain here, since it
     // is set based on the coins db, not the block index db, which is the only
     // thing loaded at this point.
     if (m_blockman.m_block_index.count(m_params.GenesisBlock().GetHash())) {
         return true;
     }
 
     try {
         const CBlock &block = m_params.GenesisBlock();
         FlatFilePos blockPos{
             m_blockman.SaveBlockToDisk(block, 0, m_chain, m_params, nullptr)};
         if (blockPos.IsNull()) {
             return error("%s: writing genesis block to disk failed", __func__);
         }
         CBlockIndex *pindex =
             m_blockman.AddToBlockIndex(block, m_chainman.m_best_header);
         ReceivedBlockTransactions(block, pindex, blockPos);
     } catch (const std::runtime_error &e) {
         return error("%s: failed to write genesis block: %s", __func__,
                      e.what());
     }
 
     return true;
 }
 
 void CChainState::LoadExternalBlockFile(const Config &config, FILE *fileIn,
                                         FlatFilePos *dbp) {
     AssertLockNotHeld(m_chainstate_mutex);
     // Map of disk positions for blocks with unknown parent (only used for
     // reindex)
     static std::multimap<uint256, FlatFilePos> mapBlocksUnknownParent;
     int64_t nStart = GetTimeMillis();
 
     int nLoaded = 0;
     try {
         // This takes over fileIn and calls fclose() on it in the CBufferedFile
         // destructor. Make sure we have at least 2*MAX_TX_SIZE space in there
         // so any transaction can fit in the buffer.
         CBufferedFile blkdat(fileIn, 2 * MAX_TX_SIZE, MAX_TX_SIZE + 8, SER_DISK,
                              CLIENT_VERSION);
         uint64_t nRewind = blkdat.GetPos();
         while (!blkdat.eof()) {
             if (ShutdownRequested()) {
                 return;
             }
 
             blkdat.SetPos(nRewind);
             // Start one byte further next time, in case of failure.
             nRewind++;
             // Remove former limit.
             blkdat.SetLimit();
             unsigned int nSize = 0;
             try {
                 // Locate a header.
                 uint8_t buf[CMessageHeader::MESSAGE_START_SIZE];
                 blkdat.FindByte(char(m_params.DiskMagic()[0]));
                 nRewind = blkdat.GetPos() + 1;
                 blkdat >> buf;
                 if (memcmp(buf, m_params.DiskMagic().data(),
                            CMessageHeader::MESSAGE_START_SIZE)) {
                     continue;
                 }
 
                 // Read size.
                 blkdat >> nSize;
                 if (nSize < 80) {
                     continue;
                 }
             } catch (const std::exception &) {
                 // No valid block header found; don't complain.
                 break;
             }
 
             try {
                 // read block
                 uint64_t nBlockPos = blkdat.GetPos();
                 if (dbp) {
                     dbp->nPos = nBlockPos;
                 }
                 blkdat.SetLimit(nBlockPos + nSize);
                 std::shared_ptr<CBlock> pblock = std::make_shared<CBlock>();
                 CBlock &block = *pblock;
                 blkdat >> block;
                 nRewind = blkdat.GetPos();
 
                 const BlockHash hash = block.GetHash();
                 {
                     LOCK(cs_main);
                     // detect out of order blocks, and store them for later
                     if (hash != m_params.GetConsensus().hashGenesisBlock &&
                         !m_blockman.LookupBlockIndex(block.hashPrevBlock)) {
                         LogPrint(
                             BCLog::REINDEX,
                             "%s: Out of order block %s, parent %s not known\n",
                             __func__, hash.ToString(),
                             block.hashPrevBlock.ToString());
                         if (dbp) {
                             mapBlocksUnknownParent.insert(
                                 std::make_pair(block.hashPrevBlock, *dbp));
                         }
                         continue;
                     }
 
                     // process in case the block isn't known yet
                     const CBlockIndex *pindex =
                         m_blockman.LookupBlockIndex(hash);
                     if (!pindex || !pindex->nStatus.hasData()) {
                         BlockValidationState state;
                         if (AcceptBlock(config, pblock, state, true, dbp,
                                         nullptr)) {
                             nLoaded++;
                         }
                         if (state.IsError()) {
                             break;
                         }
                     } else if (hash !=
                                    m_params.GetConsensus().hashGenesisBlock &&
                                pindex->nHeight % 1000 == 0) {
                         LogPrint(
                             BCLog::REINDEX,
                             "Block Import: already had block %s at height %d\n",
                             hash.ToString(), pindex->nHeight);
                     }
                 }
 
                 // Activate the genesis block so normal node progress can
                 // continue
                 if (hash == m_params.GetConsensus().hashGenesisBlock) {
                     BlockValidationState state;
                     if (!ActivateBestChain(config, state, nullptr)) {
                         break;
                     }
                 }
 
                 NotifyHeaderTip(*this);
 
                 // Recursively process earlier encountered successors of this
                 // block
                 std::deque<uint256> queue;
                 queue.push_back(hash);
                 while (!queue.empty()) {
                     uint256 head = queue.front();
                     queue.pop_front();
                     std::pair<std::multimap<uint256, FlatFilePos>::iterator,
                               std::multimap<uint256, FlatFilePos>::iterator>
                         range = mapBlocksUnknownParent.equal_range(head);
                     while (range.first != range.second) {
                         std::multimap<uint256, FlatFilePos>::iterator it =
                             range.first;
                         std::shared_ptr<CBlock> pblockrecursive =
                             std::make_shared<CBlock>();
                         if (ReadBlockFromDisk(*pblockrecursive, it->second,
                                               m_params.GetConsensus())) {
                             LogPrint(
                                 BCLog::REINDEX,
                                 "%s: Processing out of order child %s of %s\n",
                                 __func__, pblockrecursive->GetHash().ToString(),
                                 head.ToString());
                             LOCK(cs_main);
                             BlockValidationState dummy;
                             if (AcceptBlock(config, pblockrecursive, dummy,
                                             true, &it->second, nullptr)) {
                                 nLoaded++;
                                 queue.push_back(pblockrecursive->GetHash());
                             }
                         }
                         range.first++;
                         mapBlocksUnknownParent.erase(it);
                         NotifyHeaderTip(*this);
                     }
                 }
             } catch (const std::exception &e) {
                 LogPrintf("%s: Deserialize or I/O error - %s\n", __func__,
                           e.what());
             }
         }
     } catch (const std::runtime_error &e) {
         AbortNode(std::string("System error: ") + e.what());
     }
 
     LogPrintf("Loaded %i blocks from external file in %dms\n", nLoaded,
               GetTimeMillis() - nStart);
 }
 
 void CChainState::CheckBlockIndex() {
     if (!fCheckBlockIndex) {
         return;
     }
 
     LOCK(cs_main);
 
     // During a reindex, we read the genesis block and call CheckBlockIndex
     // before ActivateBestChain, so we have the genesis block in
     // m_blockman.m_block_index but no active chain. (A few of the tests when
     // iterating the block tree require that m_chain has been initialized.)
     if (m_chain.Height() < 0) {
         assert(m_blockman.m_block_index.size() <= 1);
         return;
     }
 
     // Build forward-pointing map of the entire block tree.
     std::multimap<CBlockIndex *, CBlockIndex *> forward;
     for (auto &[_, block_index] : m_blockman.m_block_index) {
         forward.emplace(block_index.pprev, &block_index);
     }
 
     assert(forward.size() == m_blockman.m_block_index.size());
 
     std::pair<std::multimap<CBlockIndex *, CBlockIndex *>::iterator,
               std::multimap<CBlockIndex *, CBlockIndex *>::iterator>
         rangeGenesis = forward.equal_range(nullptr);
     CBlockIndex *pindex = rangeGenesis.first->second;
     rangeGenesis.first++;
     // There is only one index entry with parent nullptr.
     assert(rangeGenesis.first == rangeGenesis.second);
 
     // Iterate over the entire block tree, using depth-first search.
     // Along the way, remember whether there are blocks on the path from genesis
     // block being explored which are the first to have certain properties.
     size_t nNodes = 0;
     int nHeight = 0;
     // Oldest ancestor of pindex which is invalid.
     CBlockIndex *pindexFirstInvalid = nullptr;
     // Oldest ancestor of pindex which is parked.
     CBlockIndex *pindexFirstParked = nullptr;
     // Oldest ancestor of pindex which does not have data available.
     CBlockIndex *pindexFirstMissing = nullptr;
     // Oldest ancestor of pindex for which nTx == 0.
     CBlockIndex *pindexFirstNeverProcessed = nullptr;
     // Oldest ancestor of pindex which does not have BLOCK_VALID_TREE
     // (regardless of being valid or not).
     CBlockIndex *pindexFirstNotTreeValid = nullptr;
     // Oldest ancestor of pindex which does not have BLOCK_VALID_TRANSACTIONS
     // (regardless of being valid or not).
     CBlockIndex *pindexFirstNotTransactionsValid = nullptr;
     // Oldest ancestor of pindex which does not have BLOCK_VALID_CHAIN
     // (regardless of being valid or not).
     CBlockIndex *pindexFirstNotChainValid = nullptr;
     // Oldest ancestor of pindex which does not have BLOCK_VALID_SCRIPTS
     // (regardless of being valid or not).
     CBlockIndex *pindexFirstNotScriptsValid = nullptr;
     while (pindex != nullptr) {
         nNodes++;
         if (pindexFirstInvalid == nullptr && pindex->nStatus.hasFailed()) {
             pindexFirstInvalid = pindex;
         }
         if (pindexFirstParked == nullptr && pindex->nStatus.isParked()) {
             pindexFirstParked = pindex;
         }
         // Assumed-valid index entries will not have data since we haven't
         // downloaded the full block yet.
         if (pindexFirstMissing == nullptr && !pindex->nStatus.hasData() &&
             !pindex->IsAssumedValid()) {
             pindexFirstMissing = pindex;
         }
         if (pindexFirstNeverProcessed == nullptr && pindex->nTx == 0) {
             pindexFirstNeverProcessed = pindex;
         }
         if (pindex->pprev != nullptr && pindexFirstNotTreeValid == nullptr &&
             pindex->nStatus.getValidity() < BlockValidity::TREE) {
             pindexFirstNotTreeValid = pindex;
         }
         if (pindex->pprev != nullptr && !pindex->IsAssumedValid()) {
             if (pindexFirstNotTransactionsValid == nullptr &&
                 pindex->nStatus.getValidity() < BlockValidity::TRANSACTIONS) {
                 pindexFirstNotTransactionsValid = pindex;
             }
             if (pindexFirstNotChainValid == nullptr &&
                 pindex->nStatus.getValidity() < BlockValidity::CHAIN) {
                 pindexFirstNotChainValid = pindex;
             }
             if (pindexFirstNotScriptsValid == nullptr &&
                 pindex->nStatus.getValidity() < BlockValidity::SCRIPTS) {
                 pindexFirstNotScriptsValid = pindex;
             }
         }
 
         // Begin: actual consistency checks.
         if (pindex->pprev == nullptr) {
             // Genesis block checks.
             // Genesis block's hash must match.
             assert(pindex->GetBlockHash() ==
                    m_params.GetConsensus().hashGenesisBlock);
             // The current active chain's genesis block must be this block.
             assert(pindex == m_chain.Genesis());
         }
         if (!pindex->HaveTxsDownloaded()) {
             // nSequenceId can't be set positive for blocks that aren't linked
             // (negative is used for preciousblock)
             assert(pindex->nSequenceId <= 0);
         }
         // VALID_TRANSACTIONS is equivalent to nTx > 0 for all nodes (whether or
         // not pruning has occurred). HAVE_DATA is only equivalent to nTx > 0
         // (or VALID_TRANSACTIONS) if no pruning has occurred.
         // Unless these indexes are assumed valid and pending block download on
         // a background chainstate.
         if (!m_blockman.m_have_pruned && !pindex->IsAssumedValid()) {
             // If we've never pruned, then HAVE_DATA should be equivalent to nTx
             // > 0
             assert(pindex->nStatus.hasData() == (pindex->nTx > 0));
             assert(pindexFirstMissing == pindexFirstNeverProcessed);
         } else if (pindex->nStatus.hasData()) {
             // If we have pruned, then we can only say that HAVE_DATA implies
             // nTx > 0
             assert(pindex->nTx > 0);
         }
         if (pindex->nStatus.hasUndo()) {
             assert(pindex->nStatus.hasData());
         }
         if (pindex->IsAssumedValid()) {
             // Assumed-valid blocks should have some nTx value.
             assert(pindex->nTx > 0);
             // Assumed-valid blocks should connect to the main chain.
             assert(pindex->nStatus.getValidity() >= BlockValidity::TREE);
         } else {
             // Otherwise there should only be an nTx value if we have
             // actually seen a block's transactions.
             // This is pruning-independent.
             assert((pindex->nStatus.getValidity() >=
                     BlockValidity::TRANSACTIONS) == (pindex->nTx > 0));
         }
         // All parents having had data (at some point) is equivalent to all
         // parents being VALID_TRANSACTIONS, which is equivalent to
         // HaveTxsDownloaded(). All parents having had data (at some point) is
         // equivalent to all parents being VALID_TRANSACTIONS, which is
         // equivalent to HaveTxsDownloaded().
         assert((pindexFirstNeverProcessed == nullptr) ==
                (pindex->HaveTxsDownloaded()));
         assert((pindexFirstNotTransactionsValid == nullptr) ==
                (pindex->HaveTxsDownloaded()));
         // nHeight must be consistent.
         assert(pindex->nHeight == nHeight);
         // For every block except the genesis block, the chainwork must be
         // larger than the parent's.
         assert(pindex->pprev == nullptr ||
                pindex->nChainWork >= pindex->pprev->nChainWork);
         // The pskip pointer must point back for all but the first 2 blocks.
         assert(nHeight < 2 ||
                (pindex->pskip && (pindex->pskip->nHeight < nHeight)));
         // All m_blockman.m_block_index entries must at least be TREE valid
         assert(pindexFirstNotTreeValid == nullptr);
         if (pindex->nStatus.getValidity() >= BlockValidity::TREE) {
             // TREE valid implies all parents are TREE valid
             assert(pindexFirstNotTreeValid == nullptr);
         }
         if (pindex->nStatus.getValidity() >= BlockValidity::CHAIN) {
             // CHAIN valid implies all parents are CHAIN valid
             assert(pindexFirstNotChainValid == nullptr);
         }
         if (pindex->nStatus.getValidity() >= BlockValidity::SCRIPTS) {
             // SCRIPTS valid implies all parents are SCRIPTS valid
             assert(pindexFirstNotScriptsValid == nullptr);
         }
         if (pindexFirstInvalid == nullptr) {
             // Checks for not-invalid blocks.
             // The failed mask cannot be set for blocks without invalid parents.
             assert(!pindex->nStatus.isInvalid());
         }
         if (pindexFirstParked == nullptr) {
             // Checks for not-parked blocks.
             // The parked mask cannot be set for blocks without parked parents.
             // (i.e., hasParkedParent only if an ancestor is properly parked).
             assert(!pindex->nStatus.isOnParkedChain());
         }
         if (!CBlockIndexWorkComparator()(pindex, m_chain.Tip()) &&
             pindexFirstNeverProcessed == nullptr) {
             if (pindexFirstInvalid == nullptr) {
                 // Don't perform this check for the background chainstate since
                 // its setBlockIndexCandidates shouldn't have some entries (i.e.
                 // those past the snapshot block) which do exist in the block
                 // index for the active chainstate.
                 if (this == &m_chainman.ActiveChainstate()) {
                     // If this block sorts at least as good as the current tip
                     // and is valid and we have all data for its parents, it
                     // must be in setBlockIndexCandidates or be parked.
                     if (pindexFirstMissing == nullptr) {
                         assert(pindex->nStatus.isOnParkedChain() ||
                                setBlockIndexCandidates.count(pindex));
                     }
                     // m_chain.Tip() must also be there even if some data has
                     // been pruned.
                     if (pindex == m_chain.Tip()) {
                         assert(setBlockIndexCandidates.count(pindex));
                     }
                 }
                 // If some parent is missing, then it could be that this block
                 // was in setBlockIndexCandidates but had to be removed because
                 // of the missing data. In this case it must be in
                 // m_blocks_unlinked -- see test below.
             }
         } else {
             // If this block sorts worse than the current tip or some ancestor's
             // block has never been seen, it cannot be in
             // setBlockIndexCandidates.
             assert(setBlockIndexCandidates.count(pindex) == 0);
         }
         // Check whether this block is in m_blocks_unlinked.
         std::pair<std::multimap<CBlockIndex *, CBlockIndex *>::iterator,
                   std::multimap<CBlockIndex *, CBlockIndex *>::iterator>
             rangeUnlinked =
                 m_blockman.m_blocks_unlinked.equal_range(pindex->pprev);
         bool foundInUnlinked = false;
         while (rangeUnlinked.first != rangeUnlinked.second) {
             assert(rangeUnlinked.first->first == pindex->pprev);
             if (rangeUnlinked.first->second == pindex) {
                 foundInUnlinked = true;
                 break;
             }
             rangeUnlinked.first++;
         }
         if (pindex->pprev && pindex->nStatus.hasData() &&
             pindexFirstNeverProcessed != nullptr &&
             pindexFirstInvalid == nullptr) {
             // If this block has block data available, some parent was never
             // received, and has no invalid parents, it must be in
             // m_blocks_unlinked.
             assert(foundInUnlinked);
         }
         if (!pindex->nStatus.hasData()) {
             // Can't be in m_blocks_unlinked if we don't HAVE_DATA
             assert(!foundInUnlinked);
         }
         if (pindexFirstMissing == nullptr) {
             // We aren't missing data for any parent -- cannot be in
             // m_blocks_unlinked.
             assert(!foundInUnlinked);
         }
         if (pindex->pprev && pindex->nStatus.hasData() &&
             pindexFirstNeverProcessed == nullptr &&
             pindexFirstMissing != nullptr) {
             // We HAVE_DATA for this block, have received data for all parents
             // at some point, but we're currently missing data for some parent.
             // We must have pruned.
             assert(m_blockman.m_have_pruned);
             // This block may have entered m_blocks_unlinked if:
             //  - it has a descendant that at some point had more work than the
             //    tip, and
             //  - we tried switching to that descendant but were missing
             //    data for some intermediate block between m_chain and the
             //    tip.
             // So if this block is itself better than m_chain.Tip() and it
             // wasn't in
             // setBlockIndexCandidates, then it must be in m_blocks_unlinked.
             if (!CBlockIndexWorkComparator()(pindex, m_chain.Tip()) &&
                 setBlockIndexCandidates.count(pindex) == 0) {
                 if (pindexFirstInvalid == nullptr) {
                     assert(foundInUnlinked);
                 }
             }
         }
         // Perhaps too slow
         // assert(pindex->GetBlockHash() == pindex->GetBlockHeader().GetHash());
         // End: actual consistency checks.
 
         // Try descending into the first subnode.
         std::pair<std::multimap<CBlockIndex *, CBlockIndex *>::iterator,
                   std::multimap<CBlockIndex *, CBlockIndex *>::iterator>
             range = forward.equal_range(pindex);
         if (range.first != range.second) {
             // A subnode was found.
             pindex = range.first->second;
             nHeight++;
             continue;
         }
         // This is a leaf node. Move upwards until we reach a node of which we
         // have not yet visited the last child.
         while (pindex) {
             // We are going to either move to a parent or a sibling of pindex.
             // If pindex was the first with a certain property, unset the
             // corresponding variable.
             if (pindex == pindexFirstInvalid) {
                 pindexFirstInvalid = nullptr;
             }
             if (pindex == pindexFirstParked) {
                 pindexFirstParked = nullptr;
             }
             if (pindex == pindexFirstMissing) {
                 pindexFirstMissing = nullptr;
             }
             if (pindex == pindexFirstNeverProcessed) {
                 pindexFirstNeverProcessed = nullptr;
             }
             if (pindex == pindexFirstNotTreeValid) {
                 pindexFirstNotTreeValid = nullptr;
             }
             if (pindex == pindexFirstNotTransactionsValid) {
                 pindexFirstNotTransactionsValid = nullptr;
             }
             if (pindex == pindexFirstNotChainValid) {
                 pindexFirstNotChainValid = nullptr;
             }
             if (pindex == pindexFirstNotScriptsValid) {
                 pindexFirstNotScriptsValid = nullptr;
             }
             // Find our parent.
             CBlockIndex *pindexPar = pindex->pprev;
             // Find which child we just visited.
             std::pair<std::multimap<CBlockIndex *, CBlockIndex *>::iterator,
                       std::multimap<CBlockIndex *, CBlockIndex *>::iterator>
                 rangePar = forward.equal_range(pindexPar);
             while (rangePar.first->second != pindex) {
                 // Our parent must have at least the node we're coming from as
                 // child.
                 assert(rangePar.first != rangePar.second);
                 rangePar.first++;
             }
             // Proceed to the next one.
             rangePar.first++;
             if (rangePar.first != rangePar.second) {
                 // Move to the sibling.
                 pindex = rangePar.first->second;
                 break;
             } else {
                 // Move up further.
                 pindex = pindexPar;
                 nHeight--;
                 continue;
             }
         }
     }
 
     // Check that we actually traversed the entire map.
     assert(nNodes == forward.size());
 }
 
 std::string CChainState::ToString() {
     AssertLockHeld(::cs_main);
     CBlockIndex *tip = m_chain.Tip();
     return strprintf("Chainstate [%s] @ height %d (%s)",
                      m_from_snapshot_blockhash ? "snapshot" : "ibd",
                      tip ? tip->nHeight : -1,
                      tip ? tip->GetBlockHash().ToString() : "null");
 }
 
 bool CChainState::ResizeCoinsCaches(size_t coinstip_size, size_t coinsdb_size) {
     AssertLockHeld(::cs_main);
     if (coinstip_size == m_coinstip_cache_size_bytes &&
         coinsdb_size == m_coinsdb_cache_size_bytes) {
         // Cache sizes are unchanged, no need to continue.
         return true;
     }
     size_t old_coinstip_size = m_coinstip_cache_size_bytes;
     m_coinstip_cache_size_bytes = coinstip_size;
     m_coinsdb_cache_size_bytes = coinsdb_size;
     CoinsDB().ResizeCache(coinsdb_size);
 
     LogPrintf("[%s] resized coinsdb cache to %.1f MiB\n", this->ToString(),
               coinsdb_size * (1.0 / 1024 / 1024));
     LogPrintf("[%s] resized coinstip cache to %.1f MiB\n", this->ToString(),
               coinstip_size * (1.0 / 1024 / 1024));
 
     BlockValidationState state;
     bool ret;
 
     if (coinstip_size > old_coinstip_size) {
         // Likely no need to flush if cache sizes have grown.
         ret = FlushStateToDisk(state, FlushStateMode::IF_NEEDED);
     } else {
         // Otherwise, flush state to disk and deallocate the in-memory coins
         // map.
         ret = FlushStateToDisk(state, FlushStateMode::ALWAYS);
         CoinsTip().ReallocateCache();
     }
     return ret;
 }
 
 static const uint64_t MEMPOOL_DUMP_VERSION = 1;
 
 bool LoadMempool(const Config &config, CTxMemPool &pool,
                  CChainState &active_chainstate) {
     int64_t nExpiryTimeout =
         gArgs.GetIntArg("-mempoolexpiry", DEFAULT_MEMPOOL_EXPIRY) * 60 * 60;
     FILE *filestr =
         fsbridge::fopen(gArgs.GetDataDirNet() / "mempool.dat", "rb");
     CAutoFile file(filestr, SER_DISK, CLIENT_VERSION);
     if (file.IsNull()) {
         LogPrintf(
             "Failed to open mempool file from disk. Continuing anyway.\n");
         return false;
     }
 
     int64_t count = 0;
     int64_t expired = 0;
     int64_t failed = 0;
     int64_t already_there = 0;
     int64_t unbroadcast = 0;
     int64_t nNow = GetTime();
 
     try {
         uint64_t version;
         file >> version;
         if (version != MEMPOOL_DUMP_VERSION) {
             return false;
         }
 
         uint64_t num;
         file >> num;
         while (num) {
             --num;
             CTransactionRef tx;
             int64_t nTime;
             int64_t nFeeDelta;
             file >> tx;
             file >> nTime;
             file >> nFeeDelta;
 
             Amount amountdelta = nFeeDelta * SATOSHI;
             if (amountdelta != Amount::zero()) {
                 pool.PrioritiseTransaction(tx->GetId(), amountdelta);
             }
             if (nTime > nNow - nExpiryTimeout) {
                 LOCK(cs_main);
                 const auto &accepted =
                     AcceptToMemoryPool(config, active_chainstate, tx, nTime,
                                        /*bypass_limits=*/false,
                                        /*test_accept=*/false);
                 if (accepted.m_result_type ==
                     MempoolAcceptResult::ResultType::VALID) {
                     ++count;
                 } else {
                     // mempool may contain the transaction already, e.g. from
                     // wallet(s) having loaded it while we were processing
                     // mempool transactions; consider these as valid, instead of
                     // failed, but mark them as 'already there'
                     if (pool.exists(tx->GetId())) {
                         ++already_there;
                     } else {
                         ++failed;
                     }
                 }
             } else {
                 ++expired;
             }
 
             if (ShutdownRequested()) {
                 return false;
             }
         }
         std::map<TxId, Amount> mapDeltas;
         file >> mapDeltas;
 
         for (const auto &i : mapDeltas) {
             pool.PrioritiseTransaction(i.first, i.second);
         }
 
         std::set<TxId> unbroadcast_txids;
         file >> unbroadcast_txids;
         unbroadcast = unbroadcast_txids.size();
         for (const auto &txid : unbroadcast_txids) {
             // Ensure transactions were accepted to mempool then add to
             // unbroadcast set.
             if (pool.get(txid) != nullptr) {
                 pool.AddUnbroadcastTx(txid);
             }
         }
     } catch (const std::exception &e) {
         LogPrintf("Failed to deserialize mempool data on disk: %s. Continuing "
                   "anyway.\n",
                   e.what());
         return false;
     }
 
     LogPrintf("Imported mempool transactions from disk: %i succeeded, %i "
               "failed, %i expired, %i already there, %i waiting for initial "
               "broadcast\n",
               count, failed, expired, already_there, unbroadcast);
     return true;
 }
 
 bool DumpMempool(const CTxMemPool &pool) {
     int64_t start = GetTimeMicros();
 
     std::map<uint256, Amount> mapDeltas;
     std::vector<TxMempoolInfo> vinfo;
     std::set<TxId> unbroadcast_txids;
 
     static Mutex dump_mutex;
     LOCK(dump_mutex);
 
     {
         LOCK(pool.cs);
         for (const auto &i : pool.mapDeltas) {
             mapDeltas[i.first] = i.second;
         }
 
         vinfo = pool.infoAll();
         unbroadcast_txids = pool.GetUnbroadcastTxs();
     }
 
     int64_t mid = GetTimeMicros();
 
     try {
         FILE *filestr =
             fsbridge::fopen(gArgs.GetDataDirNet() / "mempool.dat.new", "wb");
         if (!filestr) {
             return false;
         }
 
         CAutoFile file(filestr, SER_DISK, CLIENT_VERSION);
 
         uint64_t version = MEMPOOL_DUMP_VERSION;
         file << version;
 
         file << uint64_t(vinfo.size());
         for (const auto &i : vinfo) {
             file << *(i.tx);
             file << int64_t(count_seconds(i.m_time));
             file << i.nFeeDelta;
             mapDeltas.erase(i.tx->GetId());
         }
 
         file << mapDeltas;
 
         LogPrintf("Writing %d unbroadcast transactions to disk.\n",
                   unbroadcast_txids.size());
         file << unbroadcast_txids;
 
         if (!FileCommit(file.Get())) {
             throw std::runtime_error("FileCommit failed");
         }
         file.fclose();
         if (!RenameOver(gArgs.GetDataDirNet() / "mempool.dat.new",
                         gArgs.GetDataDirNet() / "mempool.dat")) {
             throw std::runtime_error("Rename failed");
         }
         int64_t last = GetTimeMicros();
         LogPrintf("Dumped mempool: %gs to copy, %gs to dump\n",
                   (mid - start) * MICRO, (last - mid) * MICRO);
     } catch (const std::exception &e) {
         LogPrintf("Failed to dump mempool: %s. Continuing anyway.\n", e.what());
         return false;
     }
     return true;
 }
 
 //! Guess how far we are in the verification process at the given block index
 //! require cs_main if pindex has not been validated yet (because the chain's
 //! transaction count might be unset) This conditional lock requirement might be
 //! confusing, see: https://github.com/bitcoin/bitcoin/issues/15994
 double GuessVerificationProgress(const ChainTxData &data,
                                  const CBlockIndex *pindex) {
     if (pindex == nullptr) {
         return 0.0;
     }
 
     int64_t nNow = time(nullptr);
 
     double fTxTotal;
     if (pindex->GetChainTxCount() <= data.nTxCount) {
         fTxTotal = data.nTxCount + (nNow - data.nTime) * data.dTxRate;
     } else {
         fTxTotal = pindex->GetChainTxCount() +
                    (nNow - pindex->GetBlockTime()) * data.dTxRate;
     }
 
     return std::min<double>(pindex->GetChainTxCount() / fTxTotal, 1.0);
 }
 
 std::optional<BlockHash> ChainstateManager::SnapshotBlockhash() const {
     LOCK(::cs_main);
     if (m_active_chainstate && m_active_chainstate->m_from_snapshot_blockhash) {
         // If a snapshot chainstate exists, it will always be our active.
         return m_active_chainstate->m_from_snapshot_blockhash;
     }
     return std::nullopt;
 }
 
 std::vector<CChainState *> ChainstateManager::GetAll() {
     LOCK(::cs_main);
     std::vector<CChainState *> out;
 
     if (!IsSnapshotValidated() && m_ibd_chainstate) {
         out.push_back(m_ibd_chainstate.get());
     }
 
     if (m_snapshot_chainstate) {
         out.push_back(m_snapshot_chainstate.get());
     }
 
     return out;
 }
 
 CChainState &ChainstateManager::InitializeChainstate(
     CTxMemPool *mempool, const std::optional<BlockHash> &snapshot_blockhash) {
     AssertLockHeld(::cs_main);
     bool is_snapshot = snapshot_blockhash.has_value();
     std::unique_ptr<CChainState> &to_modify =
         is_snapshot ? m_snapshot_chainstate : m_ibd_chainstate;
 
     if (to_modify) {
         throw std::logic_error("should not be overwriting a chainstate");
     }
     to_modify.reset(
         new CChainState(mempool, m_blockman, *this, snapshot_blockhash));
 
     // Snapshot chainstates and initial IBD chaintates always become active.
     if (is_snapshot || (!is_snapshot && !m_active_chainstate)) {
         LogPrintf("Switching active chainstate to %s\n", to_modify->ToString());
         m_active_chainstate = to_modify.get();
     } else {
         throw std::logic_error("unexpected chainstate activation");
     }
 
     return *to_modify;
 }
 
 const AssumeutxoData *ExpectedAssumeutxo(const int height,
                                          const CChainParams &chainparams) {
     const MapAssumeutxo &valid_assumeutxos_map = chainparams.Assumeutxo();
     const auto assumeutxo_found = valid_assumeutxos_map.find(height);
 
     if (assumeutxo_found != valid_assumeutxos_map.end()) {
         return &assumeutxo_found->second;
     }
     return nullptr;
 }
 
 bool ChainstateManager::ActivateSnapshot(CAutoFile &coins_file,
                                          const SnapshotMetadata &metadata,
                                          bool in_memory) {
     BlockHash base_blockhash = metadata.m_base_blockhash;
 
     if (this->SnapshotBlockhash()) {
         LogPrintf("[snapshot] can't activate a snapshot-based chainstate more "
                   "than once\n");
         return false;
     }
 
     int64_t current_coinsdb_cache_size{0};
     int64_t current_coinstip_cache_size{0};
 
     // Cache percentages to allocate to each chainstate.
     //
     // These particular percentages don't matter so much since they will only be
     // relevant during snapshot activation; caches are rebalanced at the
     // conclusion of this function. We want to give (essentially) all available
     // cache capacity to the snapshot to aid the bulk load later in this
     // function.
     static constexpr double IBD_CACHE_PERC = 0.01;
     static constexpr double SNAPSHOT_CACHE_PERC = 0.99;
 
     {
         LOCK(::cs_main);
         // Resize the coins caches to ensure we're not exceeding memory limits.
         //
         // Allocate the majority of the cache to the incoming snapshot
         // chainstate, since (optimistically) getting to its tip will be the top
         // priority. We'll need to call `MaybeRebalanceCaches()` once we're done
         // with this function to ensure the right allocation (including the
         // possibility that no snapshot was activated and that we should restore
         // the active chainstate caches to their original size).
         //
         current_coinsdb_cache_size =
             this->ActiveChainstate().m_coinsdb_cache_size_bytes;
         current_coinstip_cache_size =
             this->ActiveChainstate().m_coinstip_cache_size_bytes;
 
         // Temporarily resize the active coins cache to make room for the
         // newly-created snapshot chain.
         this->ActiveChainstate().ResizeCoinsCaches(
             static_cast<size_t>(current_coinstip_cache_size * IBD_CACHE_PERC),
             static_cast<size_t>(current_coinsdb_cache_size * IBD_CACHE_PERC));
     }
 
     auto snapshot_chainstate =
         WITH_LOCK(::cs_main, return std::make_unique<CChainState>(
                                  /* mempool */ nullptr, m_blockman, *this,
                                  base_blockhash));
 
     {
         LOCK(::cs_main);
         snapshot_chainstate->InitCoinsDB(
             static_cast<size_t>(current_coinsdb_cache_size *
                                 SNAPSHOT_CACHE_PERC),
             in_memory, false, "chainstate");
         snapshot_chainstate->InitCoinsCache(static_cast<size_t>(
             current_coinstip_cache_size * SNAPSHOT_CACHE_PERC));
     }
 
     const bool snapshot_ok = this->PopulateAndValidateSnapshot(
         *snapshot_chainstate, coins_file, metadata);
 
     if (!snapshot_ok) {
         WITH_LOCK(::cs_main, this->MaybeRebalanceCaches());
         return false;
     }
 
     {
         LOCK(::cs_main);
         assert(!m_snapshot_chainstate);
         m_snapshot_chainstate.swap(snapshot_chainstate);
         const bool chaintip_loaded = m_snapshot_chainstate->LoadChainTip();
         assert(chaintip_loaded);
 
         m_active_chainstate = m_snapshot_chainstate.get();
 
         LogPrintf("[snapshot] successfully activated snapshot %s\n",
                   base_blockhash.ToString());
         LogPrintf("[snapshot] (%.2f MB)\n",
                   m_snapshot_chainstate->CoinsTip().DynamicMemoryUsage() /
                       (1000 * 1000));
 
         this->MaybeRebalanceCaches();
     }
     return true;
 }
 
 static void FlushSnapshotToDisk(CCoinsViewCache &coins_cache,
                                 bool snapshot_loaded) {
     LOG_TIME_MILLIS_WITH_CATEGORY_MSG_ONCE(
         strprintf("%s (%.2f MB)",
                   snapshot_loaded ? "saving snapshot chainstate"
                                   : "flushing coins cache",
                   coins_cache.DynamicMemoryUsage() / (1000 * 1000)),
         BCLog::LogFlags::ALL);
 
     coins_cache.Flush();
 }
 
 bool ChainstateManager::PopulateAndValidateSnapshot(
     CChainState &snapshot_chainstate, CAutoFile &coins_file,
     const SnapshotMetadata &metadata) {
     // It's okay to release cs_main before we're done using `coins_cache`
     // because we know that nothing else will be referencing the newly created
     // snapshot_chainstate yet.
     CCoinsViewCache &coins_cache =
         *WITH_LOCK(::cs_main, return &snapshot_chainstate.CoinsTip());
 
     BlockHash base_blockhash = metadata.m_base_blockhash;
 
     CBlockIndex *snapshot_start_block = WITH_LOCK(
         ::cs_main, return m_blockman.LookupBlockIndex(base_blockhash));
 
     if (!snapshot_start_block) {
         // Needed for GetUTXOStats and ExpectedAssumeutxo to determine the
         // height and to avoid a crash when base_blockhash.IsNull()
         LogPrintf("[snapshot] Did not find snapshot start blockheader %s\n",
                   base_blockhash.ToString());
         return false;
     }
 
     int base_height = snapshot_start_block->nHeight;
     auto maybe_au_data = ExpectedAssumeutxo(base_height, ::Params());
 
     if (!maybe_au_data) {
         LogPrintf("[snapshot] assumeutxo height in snapshot metadata not "
                   "recognized (%d) - refusing to load snapshot\n",
                   base_height);
         return false;
     }
 
     const AssumeutxoData &au_data = *maybe_au_data;
 
     COutPoint outpoint;
     Coin coin;
     const uint64_t coins_count = metadata.m_coins_count;
     uint64_t coins_left = metadata.m_coins_count;
 
     LogPrintf("[snapshot] loading coins from snapshot %s\n",
               base_blockhash.ToString());
     int64_t coins_processed{0};
 
     while (coins_left > 0) {
         try {
             coins_file >> outpoint;
             coins_file >> coin;
         } catch (const std::ios_base::failure &) {
             LogPrintf("[snapshot] bad snapshot format or truncated snapshot "
                       "after deserializing %d coins\n",
                       coins_count - coins_left);
             return false;
         }
         if (coin.GetHeight() > uint32_t(base_height) ||
             // Avoid integer wrap-around in coinstats.cpp:ApplyHash
             outpoint.GetN() >=
                 std::numeric_limits<decltype(outpoint.GetN())>::max()) {
             LogPrintf(
                 "[snapshot] bad snapshot data after deserializing %d coins\n",
                 coins_count - coins_left);
             return false;
         }
         coins_cache.EmplaceCoinInternalDANGER(std::move(outpoint),
                                               std::move(coin));
 
         --coins_left;
         ++coins_processed;
 
         if (coins_processed % 1000000 == 0) {
             LogPrintf("[snapshot] %d coins loaded (%.2f%%, %.2f MB)\n",
                       coins_processed,
                       static_cast<float>(coins_processed) * 100 /
                           static_cast<float>(coins_count),
                       coins_cache.DynamicMemoryUsage() / (1000 * 1000));
         }
 
         // Batch write and flush (if we need to) every so often.
         //
         // If our average Coin size is roughly 41 bytes, checking every 120,000
         // coins means <5MB of memory imprecision.
         if (coins_processed % 120000 == 0) {
             if (ShutdownRequested()) {
                 return false;
             }
 
             const auto snapshot_cache_state = WITH_LOCK(
                 ::cs_main, return snapshot_chainstate.GetCoinsCacheSizeState());
 
             if (snapshot_cache_state >= CoinsCacheSizeState::CRITICAL) {
                 // This is a hack - we don't know what the actual best block is,
                 // but that doesn't matter for the purposes of flushing the
                 // cache here. We'll set this to its correct value
                 // (`base_blockhash`) below after the coins are loaded.
                 coins_cache.SetBestBlock(BlockHash{GetRandHash()});
 
                 // No need to acquire cs_main since this chainstate isn't being
                 // used yet.
                 FlushSnapshotToDisk(coins_cache, /*snapshot_loaded=*/false);
             }
         }
     }
 
     // Important that we set this. This and the coins_cache accesses above are
     // sort of a layer violation, but either we reach into the innards of
     // CCoinsViewCache here or we have to invert some of the CChainState to
     // embed them in a snapshot-activation-specific CCoinsViewCache bulk load
     // method.
     coins_cache.SetBestBlock(base_blockhash);
 
     bool out_of_coins{false};
     try {
         coins_file >> outpoint;
     } catch (const std::ios_base::failure &) {
         // We expect an exception since we should be out of coins.
         out_of_coins = true;
     }
     if (!out_of_coins) {
         LogPrintf("[snapshot] bad snapshot - coins left over after "
                   "deserializing %d coins\n",
                   coins_count);
         return false;
     }
 
     LogPrintf("[snapshot] loaded %d (%.2f MB) coins from snapshot %s\n",
               coins_count, coins_cache.DynamicMemoryUsage() / (1000 * 1000),
               base_blockhash.ToString());
 
     // No need to acquire cs_main since this chainstate isn't being used yet.
     FlushSnapshotToDisk(coins_cache, /*snapshot_loaded=*/true);
 
     assert(coins_cache.GetBestBlock() == base_blockhash);
 
     CCoinsStats stats{CoinStatsHashType::HASH_SERIALIZED};
     auto breakpoint_fnc = [] { /* TODO insert breakpoint here? */ };
 
     // As above, okay to immediately release cs_main here since no other context
     // knows about the snapshot_chainstate.
     CCoinsViewDB *snapshot_coinsdb =
         WITH_LOCK(::cs_main, return &snapshot_chainstate.CoinsDB());
 
     if (!GetUTXOStats(snapshot_coinsdb, m_blockman, stats, breakpoint_fnc)) {
         LogPrintf("[snapshot] failed to generate coins stats\n");
         return false;
     }
 
     // Assert that the deserialized chainstate contents match the expected
     // assumeutxo value.
     if (AssumeutxoHash{stats.hashSerialized} != au_data.hash_serialized) {
         LogPrintf("[snapshot] bad snapshot content hash: expected %s, got %s\n",
                   au_data.hash_serialized.ToString(),
                   stats.hashSerialized.ToString());
         return false;
     }
 
     snapshot_chainstate.m_chain.SetTip(snapshot_start_block);
 
     // The remainder of this function requires modifying data protected by
     // cs_main.
     LOCK(::cs_main);
 
     // Fake various pieces of CBlockIndex state:
     CBlockIndex *index = nullptr;
 
     // Don't make any modifications to the genesis block.
     // This is especially important because we don't want to erroneously
     // apply ASSUMED_VALID_FLAG to genesis, which would happen if we didn't
     // skip it here (since it apparently isn't BlockValidity::SCRIPTS).
     constexpr int AFTER_GENESIS_START{1};
 
     for (int i = AFTER_GENESIS_START; i <= snapshot_chainstate.m_chain.Height();
          ++i) {
         index = snapshot_chainstate.m_chain[i];
 
         // Fake nTx so that LoadBlockIndex() loads assumed-valid CBlockIndex
         // entries (among other things)
         if (!index->nTx) {
             index->nTx = 1;
         }
         // Fake nChainTx so that GuessVerificationProgress reports accurately
         index->nChainTx = index->pprev->nChainTx + index->nTx;
 
         // Mark unvalidated block index entries beneath the snapshot base block
         // as assumed-valid.
         if (!index->IsValid(BlockValidity::SCRIPTS)) {
             // This flag will be removed once the block is fully validated by a
             // background chainstate.
             index->nStatus = index->nStatus.withAssumedValid();
         }
 
         m_blockman.m_dirty_blockindex.insert(index);
         // Changes to the block index will be flushed to disk after this call
         // returns in `ActivateSnapshot()`, when `MaybeRebalanceCaches()` is
         // called, since we've added a snapshot chainstate and therefore will
         // have to downsize the IBD chainstate, which will result in a call to
         // `FlushStateToDisk(ALWAYS)`.
     }
 
     assert(index);
     index->nChainTx = au_data.nChainTx;
     snapshot_chainstate.setBlockIndexCandidates.insert(snapshot_start_block);
 
     LogPrintf("[snapshot] validated snapshot (%.2f MB)\n",
               coins_cache.DynamicMemoryUsage() / (1000 * 1000));
     return true;
 }
 
 CChainState &ChainstateManager::ActiveChainstate() const {
     LOCK(::cs_main);
     assert(m_active_chainstate);
     return *m_active_chainstate;
 }
 
 bool ChainstateManager::IsSnapshotActive() const {
     LOCK(::cs_main);
     return m_snapshot_chainstate &&
            m_active_chainstate == m_snapshot_chainstate.get();
 }
 
 void ChainstateManager::Unload() {
     AssertLockHeld(::cs_main);
     for (CChainState *chainstate : this->GetAll()) {
         chainstate->m_chain.SetTip(nullptr);
         chainstate->UnloadBlockIndex();
     }
 
     m_failed_blocks.clear();
     m_blockman.Unload();
     m_best_header = nullptr;
     m_best_invalid = nullptr;
     m_best_parked = nullptr;
 }
 
 void ChainstateManager::MaybeRebalanceCaches() {
     AssertLockHeld(::cs_main);
     if (m_ibd_chainstate && !m_snapshot_chainstate) {
         LogPrintf("[snapshot] allocating all cache to the IBD chainstate\n");
         // Allocate everything to the IBD chainstate.
         m_ibd_chainstate->ResizeCoinsCaches(m_total_coinstip_cache,
                                             m_total_coinsdb_cache);
     } else if (m_snapshot_chainstate && !m_ibd_chainstate) {
         LogPrintf(
             "[snapshot] allocating all cache to the snapshot chainstate\n");
         // Allocate everything to the snapshot chainstate.
         m_snapshot_chainstate->ResizeCoinsCaches(m_total_coinstip_cache,
                                                  m_total_coinsdb_cache);
     } else if (m_ibd_chainstate && m_snapshot_chainstate) {
         // If both chainstates exist, determine who needs more cache based on
         // IBD status.
         //
         // Note: shrink caches first so that we don't inadvertently overwhelm
         // available memory.
         if (m_snapshot_chainstate->IsInitialBlockDownload()) {
             m_ibd_chainstate->ResizeCoinsCaches(m_total_coinstip_cache * 0.05,
                                                 m_total_coinsdb_cache * 0.05);
             m_snapshot_chainstate->ResizeCoinsCaches(
                 m_total_coinstip_cache * 0.95, m_total_coinsdb_cache * 0.95);
         } else {
             m_snapshot_chainstate->ResizeCoinsCaches(
                 m_total_coinstip_cache * 0.05, m_total_coinsdb_cache * 0.05);
             m_ibd_chainstate->ResizeCoinsCaches(m_total_coinstip_cache * 0.95,
                                                 m_total_coinsdb_cache * 0.95);
         }
     }
 }
diff --git a/src/validation.h b/src/validation.h
index 68c1f3cfc..3547369fc 100644
--- a/src/validation.h
+++ b/src/validation.h
@@ -1,1335 +1,1301 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2019 The Bitcoin Core developers
 // Copyright (c) 2017-2020 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_VALIDATION_H
 #define BITCOIN_VALIDATION_H
 
 #if defined(HAVE_CONFIG_H)
 #include <config/bitcoin-config.h>
 #endif
 
 #include <arith_uint256.h>
 #include <attributes.h>
 #include <blockfileinfo.h>
 #include <blockindexcomparators.h>
 #include <chain.h>
 #include <consensus/amount.h>
 #include <consensus/consensus.h>
 #include <disconnectresult.h>
 #include <flatfile.h>
 #include <fs.h>
 #include <node/blockstorage.h>
 #include <policy/packages.h>
 #include <script/script_error.h>
 #include <script/script_metrics.h>
 #include <sync.h>
 #include <txdb.h>
 #include <txmempool.h> // For CTxMemPool::cs
 #include <uint256.h>
 #include <util/check.h>
 #include <util/translation.h>
 
 #include <atomic>
 #include <cstdint>
 #include <map>
 #include <memory>
 #include <optional>
 #include <set>
 #include <string>
 #include <thread>
 #include <utility>
 #include <vector>
 
 class CChainParams;
 class CChainState;
 class ChainstateManager;
 class Config;
 class CScriptCheck;
 class CTxMemPool;
 class CTxUndo;
 class DisconnectedBlockTransactions;
 
 struct ChainTxData;
 struct FlatFilePos;
 struct PrecomputedTransactionData;
 struct LockPoints;
 struct AssumeutxoData;
 namespace node {
 class SnapshotMetadata;
 } // namespace node
 
 namespace Consensus {
 struct Params;
 }
 
 #define MIN_TRANSACTION_SIZE                                                   \
     (::GetSerializeSize(CTransaction(), PROTOCOL_VERSION))
 
 /** Default for -minrelaytxfee, minimum relay fee for transactions */
 static const Amount DEFAULT_MIN_RELAY_TX_FEE_PER_KB(1000 * SATOSHI);
 /** Default for -excessutxocharge for transactions transactions */
 static const Amount DEFAULT_UTXO_FEE = Amount::zero();
 /**
  * Default for -mempoolexpiry, expiration time for mempool transactions in
  * hours.
  */
 static const unsigned int DEFAULT_MEMPOOL_EXPIRY = 336;
 /** Maximum number of dedicated script-checking threads allowed */
 static const int MAX_SCRIPTCHECK_THREADS = 15;
 /** -par default (number of script-checking threads, 0 = auto) */
 static const int DEFAULT_SCRIPTCHECK_THREADS = 0;
 static const int64_t DEFAULT_MAX_TIP_AGE = 24 * 60 * 60;
 static const bool DEFAULT_CHECKPOINTS_ENABLED = true;
 static const bool DEFAULT_TXINDEX = false;
 static constexpr bool DEFAULT_COINSTATSINDEX{false};
 static const char *const DEFAULT_BLOCKFILTERINDEX = "0";
 
 /** Default for -persistmempool */
 static const bool DEFAULT_PERSIST_MEMPOOL = true;
 
 static const bool DEFAULT_PEERBLOOMFILTERS = true;
 
 /** Default for -stopatheight */
 static const int DEFAULT_STOPATHEIGHT = 0;
-/** Default for -maxreorgdepth */
-static const int DEFAULT_MAX_REORG_DEPTH = 10;
-/**
- * Default for -finalizationdelay
- * This is the minimum time between a block header reception and the block
- * finalization.
- * This value should be >> block propagation and validation time
- */
-static const int64_t DEFAULT_MIN_FINALIZATION_DELAY = 2 * 60 * 60;
 /**
  * Block files containing a block-height within MIN_BLOCKS_TO_KEEP of
  * ActiveChain().Tip() will not be pruned.
  */
 static const unsigned int MIN_BLOCKS_TO_KEEP = 288;
 static const signed int DEFAULT_CHECKBLOCKS = 6;
 static const unsigned int DEFAULT_CHECKLEVEL = 3;
 /**
  * Require that user allocate at least 550 MiB for block & undo files
  * (blk???.dat and rev???.dat)
  * At 1MB per block, 288 blocks = 288MB.
  * Add 15% for Undo data = 331MB
  * Add 20% for Orphan block rate = 397MB
  * We want the low water mark after pruning to be at least 397 MB and since we
  * prune in full block file chunks, we need the high water mark which triggers
  * the prune to be one 128MB block file + added 15% undo data = 147MB greater
  * for a total of 545MB
  * Setting the target to >= 550 MiB will make it likely we can respect the
  * target.
  */
 static const uint64_t MIN_DISK_SPACE_FOR_BLOCK_FILES = 550 * 1024 * 1024;
 
 /** Current sync state passed to tip changed callbacks. */
 enum class SynchronizationState { INIT_REINDEX, INIT_DOWNLOAD, POST_INIT };
 
 extern RecursiveMutex cs_main;
 extern Mutex g_best_block_mutex;
 extern std::condition_variable g_best_block_cv;
 /** Used to notify getblocktemplate RPC of new tips. */
 extern uint256 g_best_block;
 extern bool fRequireStandard;
 extern bool fCheckBlockIndex;
 extern bool fCheckpointsEnabled;
 
 /**
  * A fee rate smaller than this is considered zero fee (for relaying, mining and
  * transaction creation)
  */
 extern CFeeRate minRelayTxFee;
 /**
  * If the tip is older than this (in seconds), the node is considered to be in
  * initial block download.
  */
 extern int64_t nMaxTipAge;
 
 /**
  * Block hash whose ancestors we will assume to have valid scripts without
  * checking them.
  */
 extern BlockHash hashAssumeValid;
 
 /**
  * Minimum work we will assume exists on some valid chain.
  */
 extern arith_uint256 nMinimumChainWork;
 
 /** Documentation for argument 'checklevel'. */
 extern const std::vector<std::string> CHECKLEVEL_DOC;
 
 class BlockValidationOptions {
 private:
     uint64_t excessiveBlockSize;
     bool checkPoW : 1;
     bool checkMerkleRoot : 1;
 
 public:
     // Do full validation by default
     explicit BlockValidationOptions(const Config &config);
     explicit BlockValidationOptions(uint64_t _excessiveBlockSize,
                                     bool _checkPow = true,
                                     bool _checkMerkleRoot = true)
         : excessiveBlockSize(_excessiveBlockSize), checkPoW(_checkPow),
           checkMerkleRoot(_checkMerkleRoot) {}
 
     BlockValidationOptions withCheckPoW(bool _checkPoW = true) const {
         BlockValidationOptions ret = *this;
         ret.checkPoW = _checkPoW;
         return ret;
     }
 
     BlockValidationOptions
     withCheckMerkleRoot(bool _checkMerkleRoot = true) const {
         BlockValidationOptions ret = *this;
         ret.checkMerkleRoot = _checkMerkleRoot;
         return ret;
     }
 
     bool shouldValidatePoW() const { return checkPoW; }
     bool shouldValidateMerkleRoot() const { return checkMerkleRoot; }
     uint64_t getExcessiveBlockSize() const { return excessiveBlockSize; }
 };
 
 /**
  * Unload database information.
  */
 void UnloadBlockIndex(CTxMemPool *mempool, ChainstateManager &chainman)
     EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
 /**
  * Run instances of script checking worker threads
  */
 void StartScriptCheckWorkerThreads(int threads_num);
 
 /**
  * Stop all of the script checking worker threads
  */
 void StopScriptCheckWorkerThreads();
 
 Amount GetBlockSubsidy(int nHeight, const Consensus::Params &consensusParams);
 
 bool AbortNode(BlockValidationState &state, const std::string &strMessage,
                const bilingual_str &userMessage = bilingual_str{});
 
 /**
  * Guess verification progress (as a fraction between 0.0=genesis and
  * 1.0=current tip).
  */
 double GuessVerificationProgress(const ChainTxData &data,
                                  const CBlockIndex *pindex);
 
 /** Prune block files up to a given height */
 void PruneBlockFilesManual(CChainState &active_chainstate,
                            int nManualPruneHeight);
 
 /**
  * Validation result for a single transaction mempool acceptance.
  */
 struct MempoolAcceptResult {
     /** Used to indicate the results of mempool validation. */
     enum class ResultType {
         //! Fully validated, valid.
         VALID,
         //! Invalid.
         INVALID,
         //! Valid, transaction was already in the mempool.
         MEMPOOL_ENTRY,
     };
     const ResultType m_result_type;
     const TxValidationState m_state;
 
     // The following fields are only present when m_result_type =
     // ResultType::VALID or MEMPOOL_ENTRY
     /**
      * Virtual size as used by the mempool, calculated using serialized size
      * and sigchecks.
      */
     const std::optional<int64_t> m_vsize;
     /** Raw base fees in satoshis. */
     const std::optional<Amount> m_base_fees;
     static MempoolAcceptResult Failure(TxValidationState state) {
         return MempoolAcceptResult(state);
     }
 
     /** Constructor for success case */
     static MempoolAcceptResult Success(int64_t vsize, Amount fees) {
         return MempoolAcceptResult(ResultType::VALID, vsize, fees);
     }
 
     /**
      * Constructor for already-in-mempool case. It wouldn't replace any
      * transactions.
      */
     static MempoolAcceptResult MempoolTx(int64_t vsize, Amount fees) {
         return MempoolAcceptResult(ResultType::MEMPOOL_ENTRY, vsize, fees);
     }
 
     // Private constructors. Use static methods MempoolAcceptResult::Success,
     // etc. to construct.
 private:
     /** Constructor for failure case */
     explicit MempoolAcceptResult(TxValidationState state)
         : m_result_type(ResultType::INVALID), m_state(state),
           m_base_fees(std::nullopt) {
         // Can be invalid or error
         Assume(!state.IsValid());
     }
 
     /** Generic constructor for success cases */
     explicit MempoolAcceptResult(ResultType result_type, int64_t vsize,
                                  Amount fees)
         : m_result_type(result_type), m_vsize{vsize}, m_base_fees(fees) {}
 };
 
 /**
  * Validation result for package mempool acceptance.
  */
 struct PackageMempoolAcceptResult {
     const PackageValidationState m_state;
     /**
      * Map from txid to finished MempoolAcceptResults. The client is
      * responsible for keeping track of the transaction objects themselves.
      * If a result is not present, it means validation was unfinished for that
      * transaction. If there was a package-wide error (see result in m_state),
      * m_tx_results will be empty.
      */
     std::map<const TxId, const MempoolAcceptResult> m_tx_results;
 
     explicit PackageMempoolAcceptResult(
         PackageValidationState state,
         std::map<const TxId, const MempoolAcceptResult> &&results)
         : m_state{state}, m_tx_results(std::move(results)) {}
 
     /**
      * Constructor to create a PackageMempoolAcceptResult from a
      * MempoolAcceptResult
      */
     explicit PackageMempoolAcceptResult(const TxId &txid,
                                         const MempoolAcceptResult &result)
         : m_tx_results{{txid, result}} {}
 };
 
 /**
  * Try to add a transaction to the mempool. This is an internal function and is
  * exposed only for testing. Client code should use
  * ChainstateManager::ProcessTransaction()
  *
  * @param[in]  config             The global configuration.
  * @param[in]  active_chainstate  Reference to the active chainstate.
  * @param[in]  tx                 The transaction to submit for mempool
  *                                acceptance.
  * @param[in]  accept_time        The timestamp for adding the transaction to
  *                                the mempool.
  *                                It is also used to determine when the entry
  *                                expires.
  * @param[in]  bypass_limits      When true, don't enforce mempool fee and
  *                                capacity limits.
  * @param[in]  test_accept        When true, run validation checks but don't
  *                                submit to mempool.
  *
  * @returns a MempoolAcceptResult indicating whether the transaction was
  *     accepted/rejected with reason.
  */
 MempoolAcceptResult
 AcceptToMemoryPool(const Config &config, CChainState &active_chainstate,
                    const CTransactionRef &tx, int64_t accept_time,
                    bool bypass_limits, bool test_accept = false)
     EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
 /**
  * Validate (and maybe submit) a package to the mempool.
  * See doc/policy/packages.md for full detailson package validation rules.
  *
  * @param[in]    test_accept     When true, run validation checks but don't
  *                               submit to mempool.
  * @returns a PackageMempoolAcceptResult which includes a MempoolAcceptResult
  *     for each transaction. If a transaction fails, validation will exit early
  *     and some results may be missing. It is also possible for the package to
  *     be partially submitted.
  */
 PackageMempoolAcceptResult
 ProcessNewPackage(const Config &config, CChainState &active_chainstate,
                   CTxMemPool &pool, const Package &txns, bool test_accept)
     EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
 /**
  * Simple class for regulating resource usage during CheckInputScripts (and
  * CScriptCheck), atomic so as to be compatible with parallel validation.
  */
 class CheckInputsLimiter {
 protected:
     std::atomic<int64_t> remaining;
 
 public:
     explicit CheckInputsLimiter(int64_t limit) : remaining(limit) {}
 
     bool consume_and_check(int consumed) {
         auto newvalue = (remaining -= consumed);
         return newvalue >= 0;
     }
 
     bool check() { return remaining >= 0; }
 };
 
 class TxSigCheckLimiter : public CheckInputsLimiter {
 public:
     TxSigCheckLimiter() : CheckInputsLimiter(MAX_TX_SIGCHECKS) {}
 
     // Let's make this bad boy copiable.
     TxSigCheckLimiter(const TxSigCheckLimiter &rhs)
         : CheckInputsLimiter(rhs.remaining.load()) {}
 
     TxSigCheckLimiter &operator=(const TxSigCheckLimiter &rhs) {
         remaining = rhs.remaining.load();
         return *this;
     }
 
     static TxSigCheckLimiter getDisabled() {
         TxSigCheckLimiter txLimiter;
         // Historically, there has not been a transaction with more than 20k sig
         // checks on testnet or mainnet, so this effectively disable sigchecks.
         txLimiter.remaining = 20000;
         return txLimiter;
     }
 };
 
 class ConnectTrace;
 
 /**
  * Check whether all of this transaction's input scripts succeed.
  *
  * This involves ECDSA signature checks so can be computationally intensive.
  * This function should only be called after the cheap sanity checks in
  * CheckTxInputs passed.
  *
  * If pvChecks is not nullptr, script checks are pushed onto it instead of being
  * performed inline. Any script checks which are not necessary (eg due to script
  * execution cache hits) are, obviously, not pushed onto pvChecks/run.
  *
  * Upon success nSigChecksOut will be filled in with either:
  * - correct total for all inputs, or,
  * - 0, in the case when checks were pushed onto pvChecks (i.e., a cache miss
  * with pvChecks non-null), in which case the total can be found by executing
  * pvChecks and adding the results.
  *
  * Setting sigCacheStore/scriptCacheStore to false will remove elements from the
  * corresponding cache which are matched. This is useful for checking blocks
  * where we will likely never need the cache entry again.
  *
  * pLimitSigChecks can be passed to limit the sigchecks count either in parallel
  * or serial validation. With pvChecks null (serial validation), breaking the
  * pLimitSigChecks limit will abort evaluation early and return false. With
  * pvChecks not-null (parallel validation): the cached nSigChecks may itself
  * break the limit in which case false is returned, OR, each entry in the
  * returned pvChecks must be executed exactly once in order to probe the limit
  * accurately.
  */
 bool CheckInputScripts(const CTransaction &tx, TxValidationState &state,
                        const CCoinsViewCache &view, const uint32_t flags,
                        bool sigCacheStore, bool scriptCacheStore,
                        const PrecomputedTransactionData &txdata,
                        int &nSigChecksOut, TxSigCheckLimiter &txLimitSigChecks,
                        CheckInputsLimiter *pBlockLimitSigChecks,
                        std::vector<CScriptCheck> *pvChecks)
     EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
 /**
  * Handy shortcut to full fledged CheckInputScripts call.
  */
 static inline bool
 CheckInputScripts(const CTransaction &tx, TxValidationState &state,
                   const CCoinsViewCache &view, const uint32_t flags,
                   bool sigCacheStore, bool scriptCacheStore,
                   const PrecomputedTransactionData &txdata, int &nSigChecksOut)
     EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
     TxSigCheckLimiter nSigChecksTxLimiter;
     return CheckInputScripts(tx, state, view, flags, sigCacheStore,
                              scriptCacheStore, txdata, nSigChecksOut,
                              nSigChecksTxLimiter, nullptr, nullptr);
 }
 
 /**
  * Mark all the coins corresponding to a given transaction inputs as spent.
  */
 void SpendCoins(CCoinsViewCache &view, const CTransaction &tx, CTxUndo &txundo,
                 int nHeight);
 
 /**
  * Apply the effects of this transaction on the UTXO set represented by view.
  */
 void UpdateCoins(CCoinsViewCache &view, const CTransaction &tx, CTxUndo &txundo,
                  int nHeight);
 
 /**
  * Check if transaction will be BIP68 final in the next block to be created on
  * top of tip.
  * @param[in]   tip             Chain tip to check tx sequence locks against.
  *     For example, the tip of the current active chain.
  * @param[in]   coins_view      Any CCoinsView that provides access to the
  *     relevant coins for checking sequence locks. For example, it can be a
  *     CCoinsViewCache that isn't connected to anything but contains all the
  *     relevant coins, or a CCoinsViewMemPool that is connected to the mempool
  *     and chainstate UTXO set. In the latter case, the caller is responsible
  *     for holding the appropriate locks to ensure that calls to GetCoin()
  *     return correct coins.
  * Simulates calling SequenceLocks() with data from the tip passed in.
  * Optionally stores in LockPoints the resulting height and time
  * calculated and the hash of the block needed for calculation or skips the
  * calculation and uses the LockPoints passed in for evaluation. The LockPoints
  * should not be considered valid if CheckSequenceLocksAtTip returns false.
  */
 bool CheckSequenceLocksAtTip(CBlockIndex *tip, const CCoinsView &coins_view,
                              const CTransaction &tx, LockPoints *lp = nullptr,
                              bool useExistingLockPoints = false);
 
 /**
  * Closure representing one script verification.
  * Note that this stores references to the spending transaction.
  *
  * Note that if pLimitSigChecks is passed, then failure does not imply that
  * scripts have failed.
  */
 class CScriptCheck {
 private:
     CTxOut m_tx_out;
     const CTransaction *ptxTo;
     unsigned int nIn;
     uint32_t nFlags;
     bool cacheStore;
     ScriptError error;
     ScriptExecutionMetrics metrics;
     PrecomputedTransactionData txdata;
     TxSigCheckLimiter *pTxLimitSigChecks;
     CheckInputsLimiter *pBlockLimitSigChecks;
 
 public:
     CScriptCheck()
         : ptxTo(nullptr), nIn(0), nFlags(0), cacheStore(false),
           error(ScriptError::UNKNOWN), txdata(), pTxLimitSigChecks(nullptr),
           pBlockLimitSigChecks(nullptr) {}
 
     CScriptCheck(const CTxOut &outIn, const CTransaction &txToIn,
                  unsigned int nInIn, uint32_t nFlagsIn, bool cacheIn,
                  const PrecomputedTransactionData &txdataIn,
                  TxSigCheckLimiter *pTxLimitSigChecksIn = nullptr,
                  CheckInputsLimiter *pBlockLimitSigChecksIn = nullptr)
         : m_tx_out(outIn), ptxTo(&txToIn), nIn(nInIn), nFlags(nFlagsIn),
           cacheStore(cacheIn), error(ScriptError::UNKNOWN), txdata(txdataIn),
           pTxLimitSigChecks(pTxLimitSigChecksIn),
           pBlockLimitSigChecks(pBlockLimitSigChecksIn) {}
 
     bool operator()();
 
     void swap(CScriptCheck &check) {
         std::swap(ptxTo, check.ptxTo);
         std::swap(m_tx_out, check.m_tx_out);
         std::swap(nIn, check.nIn);
         std::swap(nFlags, check.nFlags);
         std::swap(cacheStore, check.cacheStore);
         std::swap(error, check.error);
         std::swap(metrics, check.metrics);
         std::swap(txdata, check.txdata);
         std::swap(pTxLimitSigChecks, check.pTxLimitSigChecks);
         std::swap(pBlockLimitSigChecks, check.pBlockLimitSigChecks);
     }
 
     ScriptError GetScriptError() const { return error; }
 
     ScriptExecutionMetrics GetScriptExecutionMetrics() const { return metrics; }
 };
 
 /** Functions for validating blocks and updating the block tree */
 
 /**
  * Context-independent validity checks.
  *
  * Returns true if the provided block is valid (has valid header,
  * transactions are valid, block is a valid size, etc.)
  */
 bool CheckBlock(const CBlock &block, BlockValidationState &state,
                 const Consensus::Params &params,
                 BlockValidationOptions validationOptions);
 
 /**
  * This is a variant of ContextualCheckTransaction which computes the contextual
  * check for a transaction based on the chain tip.
  *
  * See consensus/consensus.h for flag definitions.
  */
 bool ContextualCheckTransactionForCurrentBlock(
     const CBlockIndex *active_chain_tip, const Consensus::Params &params,
     const CTransaction &tx, TxValidationState &state)
     EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
 /**
  * Check a block is completely valid from start to finish (only works on top of
  * our current best block)
  */
 bool TestBlockValidity(BlockValidationState &state, const CChainParams &params,
                        CChainState &chainstate, const CBlock &block,
                        CBlockIndex *pindexPrev,
                        BlockValidationOptions validationOptions)
     EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
 /**
  * RAII wrapper for VerifyDB: Verify consistency of the block and coin
  * databases.
  */
 class CVerifyDB {
 public:
     CVerifyDB();
 
     ~CVerifyDB();
 
     bool VerifyDB(CChainState &chainstate, const Config &config,
                   CCoinsView &coinsview, int nCheckLevel, int nCheckDepth)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 };
 
 /** @see CChainState::FlushStateToDisk */
 enum class FlushStateMode { NONE, IF_NEEDED, PERIODIC, ALWAYS };
 
 /**
  * A convenience class for constructing the CCoinsView* hierarchy used
  * to facilitate access to the UTXO set.
  *
  * This class consists of an arrangement of layered CCoinsView objects,
  * preferring to store and retrieve coins in memory via `m_cacheview` but
  * ultimately falling back on cache misses to the canonical store of UTXOs on
  * disk, `m_dbview`.
  */
 class CoinsViews {
 public:
     //! The lowest level of the CoinsViews cache hierarchy sits in a leveldb
     //! database on disk. All unspent coins reside in this store.
     CCoinsViewDB m_dbview GUARDED_BY(cs_main);
 
     //! This view wraps access to the leveldb instance and handles read errors
     //! gracefully.
     CCoinsViewErrorCatcher m_catcherview GUARDED_BY(cs_main);
 
     //! This is the top layer of the cache hierarchy - it keeps as many coins in
     //! memory as can fit per the dbcache setting.
     std::unique_ptr<CCoinsViewCache> m_cacheview GUARDED_BY(cs_main);
 
     //! This constructor initializes CCoinsViewDB and CCoinsViewErrorCatcher
     //! instances, but it *does not* create a CCoinsViewCache instance by
     //! default. This is done separately because the presence of the cache has
     //! implications on whether or not we're allowed to flush the cache's state
     //! to disk, which should not be done until the health of the database is
     //! verified.
     //!
     //! All arguments forwarded onto CCoinsViewDB.
     CoinsViews(std::string ldb_name, size_t cache_size_bytes, bool in_memory,
                bool should_wipe);
 
     //! Initialize the CCoinsViewCache member.
     void InitCache() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 };
 
 enum class CoinsCacheSizeState {
     //! The coins cache is in immediate need of a flush.
     CRITICAL = 2,
     //! The cache is at >= 90% capacity.
     LARGE = 1,
     OK = 0
 };
 
 /**
  * CChainState stores and provides an API to update our local knowledge of the
  * current best chain.
  *
  * Eventually, the API here is targeted at being exposed externally as a
  * consumable libconsensus library, so any functions added must only call
  * other class member functions, pure functions in other parts of the consensus
  * library, callbacks via the validation interface, or read/write-to-disk
  * functions (eventually this will also be via callbacks).
  *
  * Anything that is contingent on the current tip of the chain is stored here,
  * whereas block information and metadata independent of the current tip is
  * kept in `BlockManager`.
  */
 class CChainState {
 private:
     /**
      * The ChainState Mutex.
      * A lock that must be held when modifying this ChainState.
      */
     Mutex m_chainstate_mutex;
 
     /**
      * Every received block is assigned a unique and increasing identifier, so
      * we know which one to give priority in case of a fork.
      * Blocks loaded from disk are assigned id 0, so start the counter at 1.
      */
     std::atomic<int32_t> nBlockSequenceId{1};
     /** Decreasing counter (used by subsequent preciousblock calls). */
     int32_t nBlockReverseSequenceId = -1;
     /** chainwork for the last block that preciousblock has been applied to. */
     arith_uint256 nLastPreciousChainwork = 0;
 
     /**
      * Whether this chainstate is undergoing initial block download.
      *
      * Mutable because we need to be able to mark IsInitialBlockDownload()
      * const, which latches this for caching purposes.
      */
     mutable std::atomic<bool> m_cached_finished_ibd{false};
 
     //! Optional mempool that is kept in sync with the chain.
     //! Only the active chainstate has a mempool.
     CTxMemPool *m_mempool;
 
     //! Manages the UTXO set, which is a reflection of the contents of
     //! `m_chain`.
     std::unique_ptr<CoinsViews> m_coins_views;
 
-    /**
-     * The best finalized block.
-     * This block cannot be reorged in any way except by explicit user action.
-     */
-    const CBlockIndex *m_finalizedBlockIndex GUARDED_BY(cs_main) = nullptr;
-
     mutable Mutex cs_avalancheFinalizedBlockIndex;
 
     /**
      * The best block via avalanche voting.
      * This block cannot be reorged in any way except by explicit user action.
      */
     const CBlockIndex *m_avalancheFinalizedBlockIndex
         GUARDED_BY(cs_avalancheFinalizedBlockIndex) = nullptr;
 
 public:
     //! Reference to a BlockManager instance which itself is shared across all
     //! CChainState instances.
     node::BlockManager &m_blockman;
 
     /** Chain parameters for this chainstate */
     const CChainParams &m_params;
 
     //! The chainstate manager that owns this chainstate. The reference is
     //! necessary so that this instance can check whether it is the active
     //! chainstate within deeply nested method calls.
     ChainstateManager &m_chainman;
 
     explicit CChainState(
         CTxMemPool *mempool, node::BlockManager &blockman,
         ChainstateManager &chainman,
         std::optional<BlockHash> from_snapshot_blockhash = std::nullopt);
 
     /**
      * Initialize the CoinsViews UTXO set database management data structures.
      * The in-memory cache is initialized separately.
      *
      * All parameters forwarded to CoinsViews.
      */
     void InitCoinsDB(size_t cache_size_bytes, bool in_memory, bool should_wipe,
                      std::string leveldb_name = "chainstate");
 
     //! Initialize the in-memory coins cache (to be done after the health of the
     //! on-disk database is verified).
     void InitCoinsCache(size_t cache_size_bytes)
         EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
     //! @returns whether or not the CoinsViews object has been fully initialized
     //! and we can
     //!          safely flush this object to disk.
     bool CanFlushToDisk() const EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
         AssertLockHeld(::cs_main);
         return m_coins_views && m_coins_views->m_cacheview;
     }
 
     //! The current chain of blockheaders we consult and build on.
     //! @see CChain, CBlockIndex.
     CChain m_chain;
 
     /**
      * The blockhash which is the base of the snapshot this chainstate was
      * created from.
      *
      * std::nullopt if this chainstate was not created from a snapshot.
      */
     const std::optional<BlockHash> m_from_snapshot_blockhash{};
 
     //! Return true if this chainstate relies on blocks that are assumed-valid.
     //! In practice this means it was created based on a UTXO snapshot.
     bool reliesOnAssumedValid() {
         return m_from_snapshot_blockhash.has_value();
     }
 
     /**
      * The set of all CBlockIndex entries with either BLOCK_VALID_TRANSACTIONS
      * (for itself and all ancestors) *or* BLOCK_ASSUMED_VALID (if using
      * background chainstates) and as good as our current tip or better.
      * Entries may be failed, though, and pruning nodes may be missing the data
      * for the block.
      */
     std::set<CBlockIndex *, CBlockIndexWorkComparator> setBlockIndexCandidates;
 
     //! @returns A reference to the in-memory cache of the UTXO set.
     CCoinsViewCache &CoinsTip() EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
         AssertLockHeld(::cs_main);
         assert(m_coins_views->m_cacheview);
         return *m_coins_views->m_cacheview.get();
     }
 
     //! @returns A reference to the on-disk UTXO set database.
     CCoinsViewDB &CoinsDB() EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
         AssertLockHeld(::cs_main);
         return m_coins_views->m_dbview;
     }
 
     //! @returns A pointer to the mempool.
     CTxMemPool *GetMempool() { return m_mempool; }
 
     //! @returns A reference to a wrapped view of the in-memory UTXO set that
     //!     handles disk read errors gracefully.
     CCoinsViewErrorCatcher &CoinsErrorCatcher()
         EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
         AssertLockHeld(::cs_main);
         return m_coins_views->m_catcherview;
     }
 
     //! Destructs all objects related to accessing the UTXO set.
     void ResetCoinsViews() { m_coins_views.reset(); }
 
     //! The cache size of the on-disk coins view.
     size_t m_coinsdb_cache_size_bytes{0};
 
     //! The cache size of the in-memory coins view.
     size_t m_coinstip_cache_size_bytes{0};
 
     //! Resize the CoinsViews caches dynamically and flush state to disk.
     //! @returns true unless an error occurred during the flush.
     bool ResizeCoinsCaches(size_t coinstip_size, size_t coinsdb_size)
         EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
     /** Import blocks from an external file */
     void LoadExternalBlockFile(const Config &config, FILE *fileIn,
                                FlatFilePos *dbp = nullptr)
         EXCLUSIVE_LOCKS_REQUIRED(!m_chainstate_mutex);
 
     /**
      * Update the on-disk chain state.
      * The caches and indexes are flushed depending on the mode we're called
      * with if they're too large, if it's been a while since the last write, or
      * always and in all cases if we're in prune mode and are deleting files.
      *
      * If FlushStateMode::NONE is used, then FlushStateToDisk(...) won't do
      * anything besides checking if we need to prune.
      *
      * @returns true unless a system error occurred
      */
     bool FlushStateToDisk(BlockValidationState &state, FlushStateMode mode,
                           int nManualPruneHeight = 0);
 
     //! Unconditionally flush all changes to disk.
     void ForceFlushStateToDisk();
 
     //! Prune blockfiles from the disk if necessary and then flush chainstate
     //! changes if we pruned.
     void PruneAndFlush();
 
     /**
      * Find the best known block, and make it the tip of the block chain. The
      * result is either failure or an activated best chain. pblock is either
      * nullptr or a pointer to a block that is already loaded (to avoid loading
      * it again from disk).
      *
      * ActivateBestChain is split into steps (see ActivateBestChainStep) so that
      * we avoid holding cs_main for an extended period of time; the length of
      * this call may be quite long during reindexing or a substantial reorg.
      *
      * May not be called with cs_main held. May not be called in a
      * validationinterface callback.
      *
      * @returns true unless a system error occurred
      */
     bool ActivateBestChain(const Config &config, BlockValidationState &state,
                            std::shared_ptr<const CBlock> pblock = nullptr)
         EXCLUSIVE_LOCKS_REQUIRED(!m_chainstate_mutex) LOCKS_EXCLUDED(cs_main);
 
     bool AcceptBlock(const Config &config,
                      const std::shared_ptr<const CBlock> &pblock,
                      BlockValidationState &state, bool fRequested,
                      const FlatFilePos *dbp, bool *fNewBlock)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     // Block (dis)connection on a given view:
     DisconnectResult DisconnectBlock(const CBlock &block,
                                      const CBlockIndex *pindex,
                                      CCoinsViewCache &view)
         EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
     bool ConnectBlock(const CBlock &block, BlockValidationState &state,
                       CBlockIndex *pindex, CCoinsViewCache &view,
                       BlockValidationOptions options, bool fJustCheck = false)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     // Apply the effects of a block disconnection on the UTXO set.
     bool DisconnectTip(BlockValidationState &state,
                        DisconnectedBlockTransactions *disconnectpool)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_mempool->cs);
 
     // Manual block validity manipulation:
     /**
      * Mark a block as precious and reorganize.
      *
      * May not be called in a validationinterface callback.
      */
     bool PreciousBlock(const Config &config, BlockValidationState &state,
                        CBlockIndex *pindex)
         EXCLUSIVE_LOCKS_REQUIRED(!m_chainstate_mutex) LOCKS_EXCLUDED(cs_main);
     /** Mark a block as invalid. */
     bool InvalidateBlock(const Config &config, BlockValidationState &state,
                          CBlockIndex *pindex) LOCKS_EXCLUDED(cs_main)
         EXCLUSIVE_LOCKS_REQUIRED(!m_chainstate_mutex);
     /** Park a block. */
     bool ParkBlock(const Config &config, BlockValidationState &state,
                    CBlockIndex *pindex) LOCKS_EXCLUDED(cs_main)
         EXCLUSIVE_LOCKS_REQUIRED(!m_chainstate_mutex);
 
-    /**
-     * Finalize a block.
-     * A finalized block can not be reorged in any way.
-     */
-    bool FinalizeBlock(const Config &config, BlockValidationState &state,
-                       CBlockIndex *pindex) LOCKS_EXCLUDED(cs_main)
-        EXCLUSIVE_LOCKS_REQUIRED(!m_chainstate_mutex);
-    /** Return the currently finalized block index. */
-    const CBlockIndex *GetFinalizedBlock() const
-        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
-    /**
-     * Checks if a block is finalized.
-     */
-    bool IsBlockFinalized(const CBlockIndex *pindex) const
-        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
-
     /**
      * Mark a block as finalized by avalanche.
      */
     bool AvalancheFinalizeBlock(CBlockIndex *pindex);
 
     /**
      * Clear avalanche finalization.
      */
     void ClearAvalancheFinalizedBlock();
 
     /**
      * Checks if a block is finalized by avalanche voting.
      */
     bool IsBlockAvalancheFinalized(const CBlockIndex *pindex) const;
 
     /** Remove invalidity status from a block and its descendants. */
     void ResetBlockFailureFlags(CBlockIndex *pindex)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
     template <typename F>
     bool UpdateFlagsForBlock(CBlockIndex *pindexBase, CBlockIndex *pindex, F f)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
     template <typename F, typename C, typename AC>
     void UpdateFlags(CBlockIndex *pindex, CBlockIndex *&pindexReset, F f,
                      C fChild, AC fAncestorWasChanged)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     /** Remove parked status from a block and its descendants. */
     void UnparkBlockAndChildren(CBlockIndex *pindex)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     /** Remove parked status from a block. */
     void UnparkBlock(CBlockIndex *pindex) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     /** Replay blocks that aren't fully applied to the database. */
     bool ReplayBlocks();
 
     /**
      * Ensures we have a genesis block in the block tree, possibly writing one
      * to disk.
      */
     bool LoadGenesisBlock();
 
     void PruneBlockIndexCandidates();
 
     void UnloadBlockIndex() EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     /**
      * Check whether we are doing an initial block download (synchronizing from
      * disk or network)
      */
     bool IsInitialBlockDownload() const;
 
     /** Find the last common block of this chain and a locator. */
     const CBlockIndex *FindForkInGlobalIndex(const CBlockLocator &locator) const
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     /**
      * Make various assertions about the state of the block index.
      *
      * By default this only executes fully when using the Regtest chain; see:
      * fCheckBlockIndex.
      */
     void CheckBlockIndex();
 
     /** Load the persisted mempool from disk */
     void LoadMempool(const Config &config, const ArgsManager &args);
 
     /** Update the chain tip based on database information, i.e. CoinsTip()'s
      * best block. */
     bool LoadChainTip() EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     //! Dictates whether we need to flush the cache to disk or not.
     //!
     //! @return the state of the size of the coins cache.
     CoinsCacheSizeState GetCoinsCacheSizeState()
         EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
     CoinsCacheSizeState
     GetCoinsCacheSizeState(size_t max_coins_cache_size_bytes,
                            size_t max_mempool_size_bytes)
         EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
     std::string ToString() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
 private:
     bool ActivateBestChainStep(const Config &config,
                                BlockValidationState &state,
                                CBlockIndex *pindexMostWork,
                                const std::shared_ptr<const CBlock> &pblock,
                                bool &fInvalidFound, ConnectTrace &connectTrace)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_mempool->cs);
     bool ConnectTip(const Config &config, BlockValidationState &state,
                     CBlockIndex *pindexNew,
                     const std::shared_ptr<const CBlock> &pblock,
                     ConnectTrace &connectTrace,
                     DisconnectedBlockTransactions &disconnectpool)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_mempool->cs);
     void InvalidBlockFound(CBlockIndex *pindex,
                            const BlockValidationState &state)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
     CBlockIndex *
     FindMostWorkChain(std::vector<const CBlockIndex *> &blocksToReconcile)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
-    bool MarkBlockAsFinal(BlockValidationState &state,
-                          const CBlockIndex *pindex)
-        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
     void ReceivedBlockTransactions(const CBlock &block, CBlockIndex *pindexNew,
                                    const FlatFilePos &pos)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     bool RollforwardBlock(const CBlockIndex *pindex, CCoinsViewCache &inputs)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     void UnparkBlockImpl(CBlockIndex *pindex, bool fClearChildren)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     bool UnwindBlock(const Config &config, BlockValidationState &state,
                      CBlockIndex *pindex, bool invalidate)
         EXCLUSIVE_LOCKS_REQUIRED(m_chainstate_mutex);
 
     void CheckForkWarningConditions() EXCLUSIVE_LOCKS_REQUIRED(cs_main);
     void CheckForkWarningConditionsOnNewFork(CBlockIndex *pindexNewForkTip)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
     void InvalidChainFound(CBlockIndex *pindexNew)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     const CBlockIndex *FindBlockToFinalize(CBlockIndex *pindexNew)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     //! Indirection necessary to make lock annotations work with an optional
     //! mempool.
     RecursiveMutex *MempoolMutex() const LOCK_RETURNED(m_mempool->cs) {
         return m_mempool ? &m_mempool->cs : nullptr;
     }
 
     /**
      * Check warning conditions and do some notifications on new chain tip set.
      */
     void UpdateTip(const CBlockIndex *pindexNew)
         EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
     friend ChainstateManager;
 };
 
 /**
  * Provides an interface for creating and interacting with one or two
  * chainstates: an IBD chainstate generated by downloading blocks, and
  * an optional snapshot chainstate loaded from a UTXO snapshot. Managed
  * chainstates can be maintained at different heights simultaneously.
  *
  * This class provides abstractions that allow the retrieval of the current
  * most-work chainstate ("Active") as well as chainstates which may be in
  * background use to validate UTXO snapshots.
  *
  * Definitions:
  *
  * *IBD chainstate*: a chainstate whose current state has been "fully"
  *   validated by the initial block download process.
  *
  * *Snapshot chainstate*: a chainstate populated by loading in an
  *    assumeutxo UTXO snapshot.
  *
  * *Active chainstate*: the chainstate containing the current most-work
  *    chain. Consulted by most parts of the system (net_processing,
  *    wallet) as a reflection of the current chain and UTXO set.
  *    This may either be an IBD chainstate or a snapshot chainstate.
  *
  * *Background IBD chainstate*: an IBD chainstate for which the
  *    IBD process is happening in the background while use of the
  *    active (snapshot) chainstate allows the rest of the system to function.
  */
 class ChainstateManager {
 private:
     //! The chainstate used under normal operation (i.e. "regular" IBD) or, if
     //! a snapshot is in use, for background validation.
     //!
     //! Its contents (including on-disk data) will be deleted *upon shutdown*
     //! after background validation of the snapshot has completed. We do not
     //! free the chainstate contents immediately after it finishes validation
     //! to cautiously avoid a case where some other part of the system is still
     //! using this pointer (e.g. net_processing).
     //!
     //! Once this pointer is set to a corresponding chainstate, it will not
     //! be reset until init.cpp:Shutdown().
     //!
     //! This is especially important when, e.g., calling ActivateBestChain()
     //! on all chainstates because we are not able to hold ::cs_main going into
     //! that call.
     std::unique_ptr<CChainState> m_ibd_chainstate GUARDED_BY(::cs_main);
 
     //! A chainstate initialized on the basis of a UTXO snapshot. If this is
     //! non-null, it is always our active chainstate.
     //!
     //! Once this pointer is set to a corresponding chainstate, it will not
     //! be reset until init.cpp:Shutdown().
     //!
     //! This is especially important when, e.g., calling ActivateBestChain()
     //! on all chainstates because we are not able to hold ::cs_main going into
     //! that call.
     std::unique_ptr<CChainState> m_snapshot_chainstate GUARDED_BY(::cs_main);
 
     //! Points to either the ibd or snapshot chainstate; indicates our
     //! most-work chain.
     //!
     //! Once this pointer is set to a corresponding chainstate, it will not
     //! be reset until init.cpp:Shutdown().
     //!
     //! This is especially important when, e.g., calling ActivateBestChain()
     //! on all chainstates because we are not able to hold ::cs_main going into
     //! that call.
     CChainState *m_active_chainstate GUARDED_BY(::cs_main){nullptr};
 
     //! If true, the assumed-valid chainstate has been fully validated
     //! by the background validation chainstate.
     bool m_snapshot_validated{false};
 
     CBlockIndex *m_best_invalid;
     CBlockIndex *m_best_parked;
     friend bool node::BlockManager::LoadBlockIndex(const Consensus::Params &);
 
     //! Internal helper for ActivateSnapshot().
     [[nodiscard]] bool
     PopulateAndValidateSnapshot(CChainState &snapshot_chainstate,
                                 CAutoFile &coins_file,
                                 const node::SnapshotMetadata &metadata);
     /**
      * If a block header hasn't already been seen, call CheckBlockHeader on it,
      * ensure that it doesn't descend from an invalid block, and then add it to
      * m_block_index.
      */
     bool AcceptBlockHeader(const Config &config, const CBlockHeader &block,
                            BlockValidationState &state, CBlockIndex **ppindex)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
     friend CChainState;
 
 public:
     std::thread m_load_block;
     //! A single BlockManager instance is shared across each constructed
     //! chainstate to avoid duplicating block metadata.
     node::BlockManager m_blockman;
 
     /**
      * In order to efficiently track invalidity of headers, we keep the set of
      * blocks which we tried to connect and found to be invalid here (ie which
      * were set to BLOCK_FAILED_VALID since the last restart). We can then
      * walk this set and check if a new header is a descendant of something in
      * this set, preventing us from having to walk m_block_index when we try
      * to connect a bad block and fail.
      *
      * While this is more complicated than marking everything which descends
      * from an invalid block as invalid at the time we discover it to be
      * invalid, doing so would require walking all of m_block_index to find all
      * descendants. Since this case should be very rare, keeping track of all
      * BLOCK_FAILED_VALID blocks in a set should be just fine and work just as
      * well.
      *
      * Because we already walk m_block_index in height-order at startup, we go
      * ahead and mark descendants of invalid blocks as FAILED_CHILD at that
      * time, instead of putting things in this set.
      */
     std::set<CBlockIndex *> m_failed_blocks;
 
     /**
      * Best header we've seen so far (used for getheaders queries' starting
      * points).
      */
     CBlockIndex *m_best_header = nullptr;
 
     //! The total number of bytes available for us to use across all in-memory
     //! coins caches. This will be split somehow across chainstates.
     int64_t m_total_coinstip_cache{0};
     //
     //! The total number of bytes available for us to use across all leveldb
     //! coins databases. This will be split somehow across chainstates.
     int64_t m_total_coinsdb_cache{0};
 
     //! Instantiate a new chainstate and assign it based upon whether it is
     //! from a snapshot.
     //!
     //! @param[in] mempool              The mempool to pass to the chainstate
     //                                  constructor
     //! @param[in] snapshot_blockhash   If given, signify that this chainstate
     //!                                 is based on a snapshot.
     CChainState &
     InitializeChainstate(CTxMemPool *mempool,
                          const std::optional<BlockHash> &snapshot_blockhash =
                              std::nullopt) LIFETIMEBOUND
         EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
     //! Get all chainstates currently being used.
     std::vector<CChainState *> GetAll();
 
     //! Construct and activate a Chainstate on the basis of UTXO snapshot data.
     //!
     //! Steps:
     //!
     //! - Initialize an unused CChainState.
     //! - Load its `CoinsViews` contents from `coins_file`.
     //! - Verify that the hash of the resulting coinsdb matches the expected
     //!   hash per assumeutxo chain parameters.
     //! - Wait for our headers chain to include the base block of the snapshot.
     //! - "Fast forward" the tip of the new chainstate to the base of the
     //!   snapshot, faking nTx* block index data along the way.
     //! - Move the new chainstate to `m_snapshot_chainstate` and make it our
     //!   ActiveChainstate().
     [[nodiscard]] bool ActivateSnapshot(CAutoFile &coins_file,
                                         const node::SnapshotMetadata &metadata,
                                         bool in_memory);
 
     //! The most-work chain.
     CChainState &ActiveChainstate() const;
     CChain &ActiveChain() const { return ActiveChainstate().m_chain; }
     int ActiveHeight() const { return ActiveChain().Height(); }
     CBlockIndex *ActiveTip() const { return ActiveChain().Tip(); }
 
     node::BlockMap &BlockIndex() EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
         AssertLockHeld(::cs_main);
         return m_blockman.m_block_index;
     }
 
     //! @returns true if a snapshot-based chainstate is in use. Also implies
     //!          that a background validation chainstate is also in use.
     bool IsSnapshotActive() const;
 
     std::optional<BlockHash> SnapshotBlockhash() const;
 
     //! Is there a snapshot in use and has it been fully validated?
     bool IsSnapshotValidated() const { return m_snapshot_validated; }
 
     /**
      * Process an incoming block. This only returns after the best known valid
      * block is made active. Note that it does not, however, guarantee that the
      * specific block passed to it has been checked for validity!
      *
      * If you want to *possibly* get feedback on whether block is valid, you
      * must install a CValidationInterface (see validationinterface.h) - this
      * will have its BlockChecked method called whenever *any* block completes
      * validation.
      *
      * Note that we guarantee that either the proof-of-work is valid on block,
      * or (and possibly also) BlockChecked will have been called.
      *
      * May not be called in a validationinterface callback.
      *
      * @param[in]   config  The global config.
      * @param[in]   block  The block we want to process.
      * @param[in]   force_processing Process this block even if unrequested;
      *              used for non-network block sources.
      * @param[out]  new_block A boolean which is set to indicate if the block
      * was first received via this call.
      * @returns     If the block was processed, independently of block validity
      */
     bool ProcessNewBlock(const Config &config,
                          const std::shared_ptr<const CBlock> &block,
                          bool force_processing, bool *new_block)
         LOCKS_EXCLUDED(cs_main);
 
     /**
      * Process incoming block headers.
      *
      * May not be called in a validationinterface callback.
      *
      * @param[in]  config        The config.
      * @param[in]  block         The block headers themselves.
      * @param[out] state         This may be set to an Error state if any error
      *                           occurred processing them.
      * @param[out] ppindex       If set, the pointer will be set to point to the
      *                           last new block index object for the given
      * headers.
      * @return True if block headers were accepted as valid.
      */
     bool ProcessNewBlockHeaders(const Config &config,
                                 const std::vector<CBlockHeader> &block,
                                 BlockValidationState &state,
                                 const CBlockIndex **ppindex = nullptr)
         LOCKS_EXCLUDED(cs_main);
 
     /**
      * Try to add a transaction to the memory pool.
      *
      * @param[in]  tx              The transaction to submit for mempool
      *                             acceptance.
      * @param[in]  test_accept     When true, run validation checks but don't
      *                             submit to mempool.
      */
     [[nodiscard]] MempoolAcceptResult
     ProcessTransaction(const CTransactionRef &tx, bool test_accept = false)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     //! Load the block tree and coins database from disk, initializing state if
     //! we're running with -reindex
     bool LoadBlockIndex() EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     //! Unload block index and chain data before shutdown.
     void Unload() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
     //! Check to see if caches are out of balance and if so, call
     //! ResizeCoinsCaches() as needed.
     void MaybeRebalanceCaches() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
     ~ChainstateManager() {
         LOCK(::cs_main);
         UnloadBlockIndex(/*mempool=*/nullptr, *this);
     }
 };
 
 /** Dump the mempool to disk. */
 bool DumpMempool(const CTxMemPool &pool);
 
 /** Load the mempool from disk. */
 bool LoadMempool(const Config &config, CTxMemPool &pool,
                  CChainState &active_chainstate);
 
 /**
  * Return the expected assumeutxo value for a given height, if one exists.
  *
  * @param[in] height Get the assumeutxo value for this height.
  *
  * @returns empty if no assumeutxo configuration exists for the given height.
  */
 const AssumeutxoData *ExpectedAssumeutxo(const int height,
                                          const CChainParams &params);
 
 #endif // BITCOIN_VALIDATION_H
diff --git a/test/functional/abc-finalize-block.py b/test/functional/abc-finalize-block.py
deleted file mode 100755
index 3ad81d7e9..000000000
--- a/test/functional/abc-finalize-block.py
+++ /dev/null
@@ -1,323 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (c) 2018 The Bitcoin developers
-# Distributed under the MIT software license, see the accompanying
-# file COPYING or http://www.opensource.org/licenses/mit-license.php.
-"""Test the finalizeblock RPC calls."""
-
-import time
-
-from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import (
-    assert_equal,
-    assert_raises_rpc_error,
-    set_node_times,
-)
-
-RPC_FINALIZE_INVALID_BLOCK_ERROR = 'finalize-invalid-block'
-RPC_FORK_PRIOR_FINALIZED_ERROR = 'bad-fork-prior-finalized'
-RPC_BLOCK_NOT_FOUND_ERROR = 'Block not found'
-
-
-class FinalizeBlockTest(BitcoinTestFramework):
-    def set_test_params(self):
-        self.num_nodes = 3
-        self.extra_args = [["-finalizationdelay=0", "-whitelist=noban@127.0.0.1"],
-                           ["-finalizationdelay=0"], []]
-        self.finalization_delay = 2 * 60 * 60
-
-    def run_test(self):
-        node = self.nodes[0]
-
-        self.mocktime = int(time.time())
-
-        self.log.info("Test block finalization...")
-        self.generate(node, 10, sync_fun=self.no_op)
-        tip = node.getbestblockhash()
-        node.finalizeblock(tip)
-        assert_equal(node.getbestblockhash(), tip)
-        assert_equal(node.getfinalizedblockhash(), tip)
-
-        def wait_for_tip(node, tip):
-            def check_tip():
-                return node.getbestblockhash() == tip
-            self.wait_until(check_tip)
-
-        alt_node = self.nodes[1]
-        wait_for_tip(alt_node, tip)
-
-        alt_node.invalidateblock(tip)
-        # We will use this later
-        fork_block = alt_node.getbestblockhash()
-
-        # Node 0 should not accept the whole alt_node's chain due to tip being finalized,
-        # even though it is longer.
-        # Headers would not be accepted if previousblock is invalid:
-        #    - First block from alt node has same height than node tip, but is on a minority chain. Its
-        #    status is "valid-headers"
-        #    - Second block from alt node has height > node tip height, will be marked as invalid because
-        #    node tip is finalized
-        #    - Later blocks from alt node will be rejected because their previous block are invalid
-        #
-        # Expected state:
-        #
-        # On alt_node:
-        #                           >(210)->(211)-> // ->(218 tip)
-        #                          /
-        # (200)->(201)-> // ->(209)->(210 invalid)
-        #
-        # On node:
-        #                           >(210 valid-headers)->(211 invalid)->(212 to 218 dropped)
-        #                          /
-        # (200)->(201)-> // ->(209)->(210 finalized, tip)
-
-        def wait_for_block(node, block, status="invalid"):
-            def check_block():
-                for tip in node.getchaintips():
-                    if tip["hash"] == block:
-                        assert tip["status"] != "active"
-                        return tip["status"] == status
-                return False
-            self.wait_until(check_block)
-
-        # First block header is accepted as valid-header
-        self.generate(alt_node, 1, sync_fun=self.no_op)
-        wait_for_block(node, alt_node.getbestblockhash(), "valid-headers")
-
-        # Second block header is accepted but set invalid
-        self.generate(alt_node, 1, sync_fun=self.no_op)
-        invalid_block = alt_node.getbestblockhash()
-        wait_for_block(node, invalid_block)
-
-        # Later block headers are rejected
-        for _ in range(2, 9):
-            self.generate(alt_node, 1, sync_fun=self.no_op)
-            assert_raises_rpc_error(-5, RPC_BLOCK_NOT_FOUND_ERROR,
-                                    node.getblockheader, alt_node.getbestblockhash())
-
-        assert_equal(node.getbestblockhash(), tip)
-        assert_equal(node.getfinalizedblockhash(), tip)
-
-        self.log.info("Test that an invalid block cannot be finalized...")
-        assert_raises_rpc_error(-20, RPC_FINALIZE_INVALID_BLOCK_ERROR,
-                                node.finalizeblock, invalid_block)
-
-        self.log.info(
-            "Test that invalidating a finalized block moves the finalization backward...")
-
-        # Node's finalized block will be invalidated, which causes the finalized block to
-        # move to the previous block.
-        #
-        # Expected state:
-        #
-        # On alt_node:
-        #                                                 >(210)->(211)-> // ->(218 tip)
-        #                                                /
-        # (200)->(201)-> // ->(208 auto-finalized)->(209)->(210 invalid)
-        #
-        # On node:
-        #                                     >(210 valid-headers)->(211 invalid)->(212 to 218 dropped)
-        #                                    /
-        # (200)->(201)-> // ->(209 finalized)->(210 tip)
-        node.invalidateblock(tip)
-        node.reconsiderblock(tip)
-
-        assert_equal(node.getbestblockhash(), tip)
-        assert_equal(node.getfinalizedblockhash(), fork_block)
-
-        assert_equal(alt_node.getfinalizedblockhash(), node.getblockheader(
-            node.getfinalizedblockhash())['previousblockhash'])
-
-        # The node will now accept that chain as the finalized block moved back.
-        # Generate a new block on alt_node to trigger getheader from node
-        # Previous 212-218 height blocks have been droped because their previous was invalid
-        #
-        # Expected state:
-        #
-        # On alt_node:
-        #                                          >(210)->(211)-> // ->(218)->(219 tip)
-        #                                         /
-        # (200)->(201)-> // ->(209 auto-finalized)->(210 invalid)
-        #
-        # On node:
-        #                                     >(210)->(211)->(212)-> // ->(218)->(219 tip)
-        #                                    /
-        # (200)->(201)-> // ->(209 finalized)->(210)
-        node.reconsiderblock(invalid_block)
-
-        alt_node_tip = self.generate(alt_node, 1, sync_fun=self.no_op)[-1]
-        wait_for_tip(node, alt_node_tip)
-
-        assert_equal(node.getbestblockhash(), alt_node.getbestblockhash())
-        assert_equal(node.getfinalizedblockhash(), fork_block)
-        assert_equal(alt_node.getfinalizedblockhash(), fork_block)
-
-        self.log.info("Trigger reorg via block finalization...")
-        # Finalize node tip to reorg
-        #
-        # Expected state:
-        #
-        # On alt_node:
-        #                                          >(210)->(211)-> // ->(218)->(219 tip)
-        #                                         /
-        # (200)->(201)-> // ->(209 auto-finalized)->(210 invalid)
-        #
-        # On node:
-        #                           >(210 invalid)-> // ->(219 invalid)
-        #                          /
-        # (200)->(201)-> // ->(209)->(210 finalized, tip)
-        node.finalizeblock(tip)
-        assert_equal(node.getfinalizedblockhash(), tip)
-
-        self.log.info("Try to finalize a block on a competiting fork...")
-        assert_raises_rpc_error(-20, RPC_FINALIZE_INVALID_BLOCK_ERROR,
-                                node.finalizeblock, alt_node.getbestblockhash())
-        assert_equal(node.getfinalizedblockhash(), tip)
-
-        self.log.info(
-            "Check auto-finalization occurs as the tip move forward...")
-        # Reconsider alt_node tip then generate some more blocks on alt_node.
-        # Auto-finalization will occur on both chains.
-        #
-        # Expected state:
-        #
-        # On alt_node:
-        #                           >(210)->(211)-> // ->(219 auto-finalized)-> // ->(229 tip)
-        #                          /
-        # (200)->(201)-> // ->(209)->(210 invalid)
-        #
-        # On node:
-        #                           >(210)->(211)-> // ->(219 auto-finalized)-> // ->(229 tip)
-        #                          /
-        # (200)->(201)-> // ->(209)->(210 invalid)
-        node.reconsiderblock(alt_node.getbestblockhash())
-        block_to_autofinalize = self.generate(
-            alt_node, 1, sync_fun=self.no_op)[-1]
-        alt_node_new_tip = self.generate(alt_node, 9, sync_fun=self.no_op)[-1]
-        wait_for_tip(node, alt_node_new_tip)
-
-        assert_equal(node.getbestblockhash(), alt_node.getbestblockhash())
-        assert_equal(node.getfinalizedblockhash(), alt_node_tip)
-        assert_equal(alt_node.getfinalizedblockhash(), alt_node_tip)
-
-        self.log.info(
-            "Try to finalize a block on an already finalized chain...")
-        # Finalizing a block of an already finalized chain should have no
-        # effect
-        block_218 = node.getblockheader(alt_node_tip)['previousblockhash']
-        node.finalizeblock(block_218)
-        assert_equal(node.getfinalizedblockhash(), alt_node_tip)
-
-        self.log.info(
-            "Make sure reconsidering block move the finalization point...")
-        # Reconsidering the tip will move back the finalized block on node
-        #
-        # Expected state:
-        #
-        # On alt_node:
-        #                           >(210)->(211)-> // ->(219 auto-finalized)-> // ->(229 tip)
-        #                          /
-        # (200)->(201)-> // ->(209)->(210 invalid)
-        #
-        # On node:
-        #                                     >(210)->(211)-> // ->(219)-> // ->(229 tip)
-        #                                    /
-        # (200)->(201)-> // ->(209 finalized)->(210)
-        node.reconsiderblock(tip)
-
-        assert_equal(node.getbestblockhash(), alt_node_new_tip)
-        assert_equal(node.getfinalizedblockhash(), fork_block)
-
-        # TEST FINALIZATION DELAY
-
-        self.log.info("Check that finalization delay prevents eclipse attacks")
-        # Because there has been no delay since the beginning of this test,
-        # there should have been no auto-finalization on delay_node.
-        #
-        # Expected state:
-        #
-        # On alt_node:
-        #                           >(210)->(211)-> // ->(219 auto-finalized)-> // ->(229 tip)
-        #                          /
-        # (200)->(201)-> // ->(209)->(210 invalid)
-        #
-        # On delay_node:
-        #                           >(210)->(211)-> // ->(219)-> // ->(229 tip)
-        #                          /
-        # (200)->(201)-> // ->(209)->(210)
-        delay_node = self.nodes[2]
-        wait_for_tip(delay_node, alt_node_new_tip)
-        assert_equal(delay_node.getfinalizedblockhash(), str())
-
-        self.log.info(
-            "Check that finalization delay does not prevent auto-finalization")
-        # Expire the delay, then generate 1 new block with alt_node to
-        # update the tip on all chains.
-        # Because the finalization delay is expired, auto-finalization
-        # should occur.
-        #
-        # Expected state:
-        #
-        # On alt_node:
-        #                           >(220 auto-finalized)-> // ->(230 tip)
-        #                          /
-        # (200)->(201)-> // ->(209)->(210 invalid)
-        #
-        # On delay_node:
-        #                           >(220 auto-finalized)-> // ->(230 tip)
-        #                          /
-        # (200)->(201)-> // ->(209)->(210)
-        self.mocktime += self.finalization_delay
-        set_node_times([delay_node], self.mocktime)
-        new_tip = self.generate(alt_node, 1, sync_fun=self.no_op)[-1]
-
-        assert_equal(alt_node.getbestblockhash(), new_tip)
-        assert_equal(alt_node.getfinalizedblockhash(), block_to_autofinalize)
-
-        wait_for_tip(node, new_tip)
-        assert_equal(node.getfinalizedblockhash(), block_to_autofinalize)
-
-        wait_for_tip(delay_node, new_tip)
-        self.log.info(
-            "Check that finalization delay is effective on node boot")
-        # Restart the new node, so the blocks have no header received time.
-        self.restart_node(2)
-
-        # There should be no finalized block (getfinalizedblockhash returns an
-        # empty string)
-        assert_equal(delay_node.getfinalizedblockhash(), str())
-
-        # Generate 20 blocks with no delay. This should not trigger auto-finalization.
-        #
-        # Expected state:
-        #
-        # On delay_node:
-        #                           >(220)-> // ->(250 tip)
-        #                          /
-        # (200)->(201)-> // ->(209)->(210)
-        blocks = self.generate(delay_node, 20, sync_fun=self.no_op)
-        reboot_autofinalized_block = blocks[10]
-        new_tip = blocks[-1]
-        wait_for_tip(delay_node, new_tip)
-
-        assert_equal(delay_node.getfinalizedblockhash(), str())
-
-        # Now let the finalization delay to expire, then generate one more block.
-        # This should resume auto-finalization.
-        #
-        # Expected state:
-        #
-        # On delay_node:
-        #                           >(220)-> // ->(241 auto-finalized)-> // ->(251 tip)
-        #                          /
-        # (200)->(201)-> // ->(209)->(210)
-        self.mocktime += self.finalization_delay
-        set_node_times([delay_node], self.mocktime)
-        new_tip = self.generate(delay_node, 1, sync_fun=self.no_op)[-1]
-        wait_for_tip(delay_node, new_tip)
-
-        assert_equal(delay_node.getfinalizedblockhash(),
-                     reboot_autofinalized_block)
-
-
-if __name__ == '__main__':
-    FinalizeBlockTest().main()
diff --git a/test/functional/abc-parkedchain.py b/test/functional/abc-parkedchain.py
index 36cd67496..37a2c7e4a 100755
--- a/test/functional/abc-parkedchain.py
+++ b/test/functional/abc-parkedchain.py
@@ -1,246 +1,245 @@
 #!/usr/bin/env python3
 # Copyright (c) 2018 The Bitcoin developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test the parkblock and unparkblock RPC calls."""
 
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal
 
 
 class ParkedChainTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 2
         self.extra_args = [
             [
                 "-noparkdeepreorg",
                 "-noautomaticunparking",
                 "-whitelist=noban@127.0.0.1",
             ],
             [
                 "-automaticunparking=1",
-                "-maxreorgdepth=-1"
             ]
         ]
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
     # There should only be one chaintip, which is expected_tip
     def only_valid_tip(self, expected_tip, other_tip_status=None):
         node = self.nodes[0]
         assert_equal(node.getbestblockhash(), expected_tip)
         for tip in node.getchaintips():
             if tip["hash"] == expected_tip:
                 assert_equal(tip["status"], "active")
             else:
                 assert_equal(tip["status"], other_tip_status)
 
     def run_test(self):
         def wait_for_tip(node, tip):
             def check_tip():
                 return node.getbestblockhash() == tip
             self.wait_until(check_tip)
 
         node = self.nodes[0]
         parking_node = self.nodes[1]
 
         self.log.info("Test chain parking...")
         self.generate(node, 10, sync_fun=self.no_op)
         tip = node.getbestblockhash()
         self.generate(node, 1, sync_fun=self.no_op)
         block_to_park = node.getbestblockhash()
         self.generate(node, 10)
         parked_tip = node.getbestblockhash()
 
         # Let's park the chain.
         assert parked_tip != tip
         assert block_to_park != tip
         assert block_to_park != parked_tip
         node.parkblock(block_to_park)
         assert_equal(node.getbestblockhash(), tip)
 
         # When the chain is unparked, the node reorg into its original chain.
         node.unparkblock(parked_tip)
         assert_equal(node.getbestblockhash(), parked_tip)
 
         # Parking and then unparking a block should not change its validity,
         # and invaliding and reconsidering a block should not change its
         # parked state.  See the following test cases:
         self.log.info("Test invalidate, park, unpark, reconsider...")
         self.generate(node, 1, sync_fun=self.no_op)
         tip = node.getbestblockhash()
         self.generate(node, 1, sync_fun=self.no_op)
         bad_tip = node.getbestblockhash()
         # Generate an extra block to check that children are invalidated as
         # expected and do not produce dangling chaintips
         self.generate(node, 1)
         good_tip = node.getbestblockhash()
 
         node.invalidateblock(bad_tip)
         self.only_valid_tip(tip, other_tip_status="invalid")
         node.parkblock(bad_tip)
         self.only_valid_tip(tip, other_tip_status="invalid")
         node.unparkblock(bad_tip)
         self.only_valid_tip(tip, other_tip_status="invalid")
         node.reconsiderblock(bad_tip)
         self.only_valid_tip(good_tip)
 
         self.log.info("Test park, invalidate, reconsider, unpark")
         self.generate(node, 1, sync_fun=self.no_op)
         tip = node.getbestblockhash()
         self.generate(node, 1, sync_fun=self.no_op)
         bad_tip = node.getbestblockhash()
         self.generate(node, 1)
         good_tip = node.getbestblockhash()
 
         node.parkblock(bad_tip)
         self.only_valid_tip(tip, other_tip_status="parked")
         node.invalidateblock(bad_tip)
         # NOTE: Intuitively, other_tip_status would be "invalid", but because
         # only valid (unparked) chains are walked, child blocks' statuses are
         # not updated, so the "parked" state remains.
         self.only_valid_tip(tip, other_tip_status="parked")
         node.reconsiderblock(bad_tip)
         self.only_valid_tip(tip, other_tip_status="parked")
         node.unparkblock(bad_tip)
         self.only_valid_tip(good_tip)
 
         self.log.info("Test invalidate, park, reconsider, unpark...")
         self.generate(node, 1, sync_fun=self.no_op)
         tip = node.getbestblockhash()
         self.generate(node, 1, sync_fun=self.no_op)
         bad_tip = node.getbestblockhash()
         self.generate(node, 1)
         good_tip = node.getbestblockhash()
 
         node.invalidateblock(bad_tip)
         self.only_valid_tip(tip, other_tip_status="invalid")
         node.parkblock(bad_tip)
         self.only_valid_tip(tip, other_tip_status="invalid")
         node.reconsiderblock(bad_tip)
         self.only_valid_tip(tip, other_tip_status="parked")
         node.unparkblock(bad_tip)
         self.only_valid_tip(good_tip)
 
         self.log.info("Test park, invalidate, unpark, reconsider")
         self.generate(node, 1, sync_fun=self.no_op)
         tip = node.getbestblockhash()
         self.generate(node, 1, sync_fun=self.no_op)
         bad_tip = node.getbestblockhash()
         self.generate(node, 1)
         good_tip = node.getbestblockhash()
 
         node.parkblock(bad_tip)
         self.only_valid_tip(tip, other_tip_status="parked")
         node.invalidateblock(bad_tip)
         # NOTE: Intuitively, other_tip_status would be "invalid", but because
         # only valid (unparked) chains are walked, child blocks' statuses are
         # not updated, so the "parked" state remains.
         self.only_valid_tip(tip, other_tip_status="parked")
         node.unparkblock(bad_tip)
         self.only_valid_tip(tip, other_tip_status="invalid")
         node.reconsiderblock(bad_tip)
         self.only_valid_tip(good_tip)
 
         # To get ready for next testset, make sure both nodes are in sync.
         wait_for_tip(parking_node, good_tip)
         assert_equal(node.getbestblockhash(), parking_node.getbestblockhash())
 
         # Wait for node 1 to park the chain.
         def wait_for_parked_block(block):
             def check_block():
                 for tip in parking_node.getchaintips():
                     if tip["hash"] == block:
                         assert tip["status"] != "active"
                         return tip["status"] == "parked"
                 return False
             self.wait_until(check_block)
 
         def check_reorg_protection(depth, extra_blocks):
             self.log.info(
                 "Test deep reorg parking, {} block deep".format(depth))
 
             # Invalidate the tip on node 0, so it doesn't follow node 1.
             node.invalidateblock(node.getbestblockhash())
             # Mine block to create a fork of proper depth
             self.generatetoaddress(parking_node,
                                    nblocks=depth - 1,
                                    address=parking_node.getnewaddress(
                                        label='coinbase'),
                                    sync_fun=self.no_op,
                                    )
             self.generatetoaddress(node,
                                    nblocks=depth,
                                    address=node.getnewaddress(
                                        label='coinbase'),
                                    sync_fun=self.no_op,
                                    )
             # extra block should now find themselves parked
             for _ in range(extra_blocks):
                 self.generate(node, 1, sync_fun=self.no_op)
                 wait_for_parked_block(node.getbestblockhash())
 
             # If we mine one more block, the node reorgs (generate also waits
             # for chain sync).
             self.generate(node, 1)
 
         check_reorg_protection(1, 0)
         check_reorg_protection(2, 0)
         check_reorg_protection(3, 1)
         check_reorg_protection(4, 4)
         check_reorg_protection(5, 5)
         check_reorg_protection(6, 6)
         check_reorg_protection(100, 100)
 
         # try deep reorg with a log check.
         with parking_node.assert_debug_log(["Park block"]):
             check_reorg_protection(3, 1)
 
         self.log.info(
             "Accepting many blocks at once (possibly out of order) should not park if there is no reorg.")
         # rewind one block to make a reorg that is shallow.
         node.invalidateblock(parking_node.getbestblockhash())
         # generate a ton of blocks at once.
         try:
             with parking_node.assert_debug_log(["Park block"]):
                 # Also waits for chain sync
                 self.generatetoaddress(node,
                                        nblocks=20,
                                        address=node.getnewaddress(label='coinbase'))
         except AssertionError as exc:
             # good, we want an absence of "Park block" messages
             assert "does not partially match log" in exc.args[0]
         else:
             raise AssertionError("Parked block when there was no deep reorg")
 
         self.log.info("Test that unparking works when -parkdeepreorg=0")
         # Set up parking node height = fork + 4, node height = fork + 5
         node.invalidateblock(node.getbestblockhash())
         self.generate(parking_node, 3, sync_fun=self.no_op)
         self.generatetoaddress(node,
                                nblocks=5,
                                address=node.getnewaddress(label='coinbase'),
                                sync_fun=self.no_op,
                                )
         wait_for_parked_block(node.getbestblockhash())
         # Restart the parking node without parkdeepreorg.
         self.restart_node(1, self.extra_args[1] + ["-parkdeepreorg=0"])
         parking_node = self.nodes[1]
         self.connect_nodes(node.index, parking_node.index)
         # The other chain should still be marked 'parked'.
         wait_for_parked_block(node.getbestblockhash())
         # Three more blocks is not enough to unpark. Even though its PoW is
         # larger, we are still following the delayed-unparking rules.
         self.generate(node, 3, sync_fun=self.no_op)
         wait_for_parked_block(node.getbestblockhash())
         # Final block pushes over the edge, and should unpark (generate also
         # waits for chain sync).
         self.generate(node, 1)
 
         # Do not append tests after this point without restarting node again.
         # Parking node is no longer parking.
 
 
 if __name__ == '__main__':
     ParkedChainTest().main()
diff --git a/test/functional/abc_p2p_avalanche_voting.py b/test/functional/abc_p2p_avalanche_voting.py
index c6f342f9e..87f8725a4 100755
--- a/test/functional/abc_p2p_avalanche_voting.py
+++ b/test/functional/abc_p2p_avalanche_voting.py
@@ -1,321 +1,320 @@
 #!/usr/bin/env python3
 # Copyright (c) 2020-2021 The Bitcoin developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test the resolution of forks via avalanche."""
 import random
 
 from test_framework.avatools import get_ava_p2p_interface
 from test_framework.key import ECPubKey
 from test_framework.messages import AvalancheVote, AvalancheVoteError
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal
 
 QUORUM_NODE_COUNT = 16
 
 ADDRS = [
     "ecregtest:pqv2r67sgz3qumufap3h2uuj0zfmnzuv8v38gtrh5v",
     "ecregtest:qqca3gh95tnjxqja7dt4kfdryyp0d2uss55p4myvzk",
     "ecregtest:qqzkkywqd9xyqgal27hc2wweu47392xywqz0pes57w",
     "ecregtest:qz7xgksy86wnenxf9t4hqc3lyvpjf6tpycfzk2wjml",
     "ecregtest:qq7dt5j42hvj8txm3jc66mp7x029txwp5cmuu4wmxq",
     "ecregtest:qrf5yf3t05hjlax0vl475t5nru29rwtegvzna37wyh",
 ]
 
 
 class AvalancheTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 2
         self.extra_args = [
             [
                 '-avaproofstakeutxodustthreshold=1000000',
                 '-avaproofstakeutxoconfirmations=1',
                 '-avacooldown=0',
                 '-avaminquorumstake=0',
                 '-avaminavaproofsnodecount=0',
                 '-whitelist=noban@127.0.0.1',
             ],
             [
                 '-avaproofstakeutxodustthreshold=1000000',
                 '-avaproofstakeutxoconfirmations=1',
                 '-avacooldown=0',
                 '-avaminquorumstake=0',
                 '-avaminavaproofsnodecount=0',
                 '-noparkdeepreorg',
-                '-maxreorgdepth=-1',
                 '-whitelist=noban@127.0.0.1',
             ],
         ]
         self.supports_cli = False
         self.rpc_timeout = 120
 
     def run_test(self):
         node = self.nodes[0]
 
         # Build a fake quorum of nodes.
         def get_quorum():
             return [get_ava_p2p_interface(self, node)
                     for _ in range(0, QUORUM_NODE_COUNT)]
 
         # Pick one node from the quorum for polling.
         quorum = get_quorum()
         poll_node = quorum[0]
 
         assert node.getavalancheinfo()['ready_to_poll'] is True
 
         # Generate many block and poll for them.
         self.generate(node, 100 - node.getblockcount())
 
         fork_node = self.nodes[1]
 
         # Get the key so we can verify signatures.
         avakey = ECPubKey()
         avakey.set(bytes.fromhex(node.getavalanchekey()))
 
         self.log.info("Poll for the chain tip...")
         best_block_hash = int(node.getbestblockhash(), 16)
         poll_node.send_poll([best_block_hash])
 
         def assert_response(expected):
             response = poll_node.wait_for_avaresponse()
             r = response.response
             assert_equal(r.cooldown, 0)
 
             # Verify signature.
             assert avakey.verify_schnorr(response.sig, r.get_hash())
 
             votes = r.votes
             assert_equal(len(votes), len(expected))
             for i in range(0, len(votes)):
                 assert_equal(repr(votes[i]), repr(expected[i]))
 
         assert_response(
             [AvalancheVote(AvalancheVoteError.ACCEPTED, best_block_hash)])
 
         self.log.info("Poll for a selection of blocks...")
         various_block_hashes = [
             int(node.getblockhash(0), 16),
             int(node.getblockhash(1), 16),
             int(node.getblockhash(10), 16),
             int(node.getblockhash(25), 16),
             int(node.getblockhash(42), 16),
             int(node.getblockhash(96), 16),
             int(node.getblockhash(99), 16),
             int(node.getblockhash(100), 16),
         ]
 
         poll_node.send_poll(various_block_hashes)
         assert_response([AvalancheVote(AvalancheVoteError.ACCEPTED, h)
                          for h in various_block_hashes])
 
         self.log.info(
             "Poll for a selection of blocks, but some are now invalid...")
         invalidated_block = node.getblockhash(76)
         node.invalidateblock(invalidated_block)
         # We need to send the coin to a new address in order to make sure we do
         # not regenerate the same block.
         self.generatetoaddress(node, 26, ADDRS[0], sync_fun=self.no_op)
         node.reconsiderblock(invalidated_block)
 
         poll_node.send_poll(various_block_hashes)
         assert_response([AvalancheVote(AvalancheVoteError.ACCEPTED, h) for h in various_block_hashes[:5]] +
                         [AvalancheVote(AvalancheVoteError.FORK, h) for h in various_block_hashes[-3:]])
 
         self.log.info("Poll for unknown blocks...")
         various_block_hashes = [
             int(node.getblockhash(0), 16),
             int(node.getblockhash(25), 16),
             int(node.getblockhash(42), 16),
             various_block_hashes[5],
             various_block_hashes[6],
             various_block_hashes[7],
             random.randrange(1 << 255, (1 << 256) - 1),
             random.randrange(1 << 255, (1 << 256) - 1),
             random.randrange(1 << 255, (1 << 256) - 1),
         ]
         poll_node.send_poll(various_block_hashes)
         assert_response([AvalancheVote(AvalancheVoteError.ACCEPTED, h) for h in various_block_hashes[:3]] +
                         [AvalancheVote(AvalancheVoteError.FORK, h) for h in various_block_hashes[3:6]] +
                         [AvalancheVote(AvalancheVoteError.UNKNOWN, h) for h in various_block_hashes[-3:]])
 
         self.log.info("Trigger polling from the node...")
 
         def can_find_block_in_poll(hash, resp=AvalancheVoteError.ACCEPTED):
             found_hash = False
             for n in quorum:
                 poll = n.get_avapoll_if_available()
 
                 # That node has not received a poll
                 if poll is None:
                     continue
 
                 # We got a poll, check for the hash and repond
                 votes = []
                 for inv in poll.invs:
                     # Vote yes to everything
                     r = AvalancheVoteError.ACCEPTED
 
                     # Look for what we expect
                     if inv.hash == hash:
                         r = resp
                         found_hash = True
 
                     votes.append(AvalancheVote(r, inv.hash))
 
                 n.send_avaresponse(poll.round, votes, n.delegated_privkey)
 
             return found_hash
 
         # Now that we have a peer, we should start polling for the tip.
         hash_tip = int(node.getbestblockhash(), 16)
         self.wait_until(lambda: can_find_block_in_poll(hash_tip))
 
         # Make sure the fork node has synced the blocks
         self.sync_blocks([node, fork_node])
 
         # Create a fork 2 blocks deep. This should trigger polling.
         fork_node.invalidateblock(fork_node.getblockhash(100))
         self.generate(fork_node, 2, sync_fun=self.no_op)
 
         # Because the new tip is a deep reorg, the node will not accept it
         # right away, but poll for it.
         def parked_block(blockhash):
             for tip in node.getchaintips():
                 if tip["hash"] == blockhash:
                     assert tip["status"] != "active"
                     return tip["status"] == "parked"
             return False
 
         fork_tip = fork_node.getbestblockhash()
         self.wait_until(lambda: parked_block(fork_tip))
 
         self.log.info("Answer all polls to finalize...")
         hash_tip_final = int(fork_tip, 16)
 
         def has_accepted_new_tip():
             can_find_block_in_poll(hash_tip_final)
             return node.getbestblockhash() == fork_tip
 
         # Because everybody answers yes, the node will accept that block.
         self.wait_until(has_accepted_new_tip)
 
         def has_finalized_new_tip():
             can_find_block_in_poll(hash_tip_final)
             return node.isfinalblock(fork_tip)
 
         # And continuing to answer yes finalizes the block.
         with node.assert_debug_log([f"Avalanche finalized block {fork_tip}"]):
             self.wait_until(has_finalized_new_tip)
         assert_equal(node.getbestblockhash(), fork_tip)
 
         self.log.info("Answer all polls to park...")
         self.generate(node, 1, sync_fun=self.no_op)
 
         tip_to_park = node.getbestblockhash()
         hash_tip_park = int(tip_to_park, 16)
         assert tip_to_park != fork_tip
 
         def has_parked_new_tip():
             can_find_block_in_poll(hash_tip_park, AvalancheVoteError.PARKED)
             return node.getbestblockhash() == fork_tip
 
         # Because everybody answers no, the node will park that block.
         with node.assert_debug_log([f"Avalanche rejected block {tip_to_park}"]):
             self.wait_until(has_parked_new_tip)
         assert_equal(node.getbestblockhash(), fork_tip)
 
         # Vote a few more times until the block gets invalidated
         node.wait_for_debug_log(
             [f"Avalanche invalidated block {tip_to_park}"],
             chatty_callable=lambda: can_find_block_in_poll(
                 hash_tip_park, AvalancheVoteError.PARKED)
         )
 
         # Mine on the current chaintip to trigger polling and so we don't reorg
         old_fork_tip = fork_tip
         fork_tip = self.generate(fork_node, 2, sync_fun=self.no_op)[-1]
         hash_tip_final = int(fork_tip, 16)
 
         # Manually unparking the invalidated block will reset finalization.
         node.unparkblock(tip_to_park)
         assert not node.isfinalblock(old_fork_tip)
 
         # Wait until the new tip is finalized
         self.sync_blocks([node, fork_node])
         self.wait_until(has_finalized_new_tip)
         assert_equal(node.getbestblockhash(), fork_tip)
 
         # Manually parking the finalized chaintip will reset finalization.
         node.parkblock(fork_tip)
         assert not node.isfinalblock(fork_tip)
 
         # Trigger polling and finalize a new tip to setup for the next test.
         node.unparkblock(fork_tip)
         fork_tip = self.generate(fork_node, 1)[-1]
         hash_tip_final = int(fork_tip, 16)
         self.wait_until(has_finalized_new_tip)
         assert_equal(node.getbestblockhash(), fork_tip)
 
         self.log.info("Verify finalization sticks...")
         chain_head = fork_tip
 
         self.log.info("...for a chain 1 block long...")
         # Create a new fork at the chaintip
         fork_node.invalidateblock(chain_head)
         # We need to send the coin to a new address in order to make sure we do
         # not regenerate the same block.
         blocks = self.generatetoaddress(
             fork_node, 1, ADDRS[1], sync_fun=self.no_op)
         chain_head = blocks[0]
         fork_tip = blocks[0]
 
         # node does not attempt to connect alternate chaintips so it is not
         # parked. We check for an inactive valid header instead.
         def valid_headers_block(blockhash):
             for tip in node.getchaintips():
                 if tip["hash"] == blockhash:
                     assert tip["status"] != "active"
                     return tip["status"] == "valid-headers"
             return False
         self.wait_until(lambda: valid_headers_block(fork_tip))
 
         # sanity check
         hash_to_find = int(fork_tip, 16)
         poll_node.send_poll([hash_to_find])
         assert_response([AvalancheVote(AvalancheVoteError.FORK, hash_to_find)])
 
         # Try some longer fork chains
         for numblocks in range(2, len(ADDRS)):
             self.log.info("...for a chain {} blocks long...".format(numblocks))
 
             # Create a new fork N blocks deep
             fork_node.invalidateblock(chain_head)
             # We need to send the coin to a new address in order to make sure we do
             # not regenerate the same block.
             blocks = self.generatetoaddress(
                 fork_node, numblocks, ADDRS[numblocks], sync_fun=self.no_op)
             chain_head = blocks[0]
             fork_tip = blocks[-1]
 
             # node should park the block if attempting to connect it because
             # its tip is finalized
             self.wait_until(lambda: parked_block(fork_tip))
 
             # sanity check
             hash_to_find = int(fork_tip, 16)
             poll_node.send_poll([hash_to_find])
             assert_response(
                 [AvalancheVote(AvalancheVoteError.PARKED, hash_to_find)])
 
         self.log.info(
             "Check the node is discouraging unexpected avaresponses.")
         with node.assert_debug_log(
                 ['Misbehaving', 'peer=1 (0 -> 2): unexpected-ava-response']):
             # unknown voting round
             poll_node.send_avaresponse(
                 round=2**32 - 1, votes=[], privkey=poll_node.delegated_privkey)
 
 
 if __name__ == '__main__':
     AvalancheTest().main()
diff --git a/test/functional/feature_bip68_sequence.py b/test/functional/feature_bip68_sequence.py
index f339ab39c..d4be3c7b2 100755
--- a/test/functional/feature_bip68_sequence.py
+++ b/test/functional/feature_bip68_sequence.py
@@ -1,503 +1,501 @@
 #!/usr/bin/env python3
 # Copyright (c) 2014-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.
 """Test BIP68 implementation."""
 
 import time
 
 from test_framework.blocktools import create_block
 from test_framework.messages import (
     XEC,
     COutPoint,
     CTransaction,
     CTxIn,
     CTxOut,
     FromHex,
     ToHex,
 )
 from test_framework.script import CScript
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.txtools import pad_tx
 from test_framework.util import (
     assert_equal,
     assert_greater_than,
     assert_raises_rpc_error,
     satoshi_round,
 )
 
 SEQUENCE_LOCKTIME_DISABLE_FLAG = (1 << 31)
 # this means use time (0 means height)
 SEQUENCE_LOCKTIME_TYPE_FLAG = (1 << 22)
 # this is a bit-shift
 SEQUENCE_LOCKTIME_GRANULARITY = 9
 SEQUENCE_LOCKTIME_MASK = 0x0000ffff
 
 # RPC error for non-BIP68 final transactions
 NOT_FINAL_ERROR = "non-BIP68-final"
 
 
 class BIP68Test(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 2
         self.extra_args = [
             [
                 "-noparkdeepreorg",
-                "-maxreorgdepth=-1",
                 "-acceptnonstdtxn=1",
             ],
             [
                 "-acceptnonstdtxn=0",
-                "-maxreorgdepth=-1",
                 "-automaticunparking=1",
             ]
         ]
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
     def run_test(self):
         self.relayfee = self.nodes[0].getnetworkinfo()["relayfee"]
 
         # Generate some coins
         self.generate(self.nodes[0], 110)
 
         self.log.info("Running test disable flag")
         self.test_disable_flag()
 
         self.log.info("Running test sequence-lock-confirmed-inputs")
         self.test_sequence_lock_confirmed_inputs()
 
         self.log.info("Running test sequence-lock-unconfirmed-inputs")
         self.test_sequence_lock_unconfirmed_inputs()
 
         self.log.info(
             "Running test BIP68 not consensus before versionbits activation")
         self.test_bip68_not_consensus()
 
         self.log.info("Activating BIP68 (and 112/113)")
         self.activateCSV()
 
         print("Verifying nVersion=2 transactions are standard.")
         print("Note that with current versions of bitcoin software, nVersion=2 transactions are always standard (independent of BIP68 activation status).")
         self.test_version2_relay()
 
         self.log.info("Passed")
 
     # Test that BIP68 is not in effect if tx version is 1, or if
     # the first sequence bit is set.
     def test_disable_flag(self):
         # Create some unconfirmed inputs
         new_addr = self.nodes[0].getnewaddress()
         # send 2,000,000 XEC
         self.nodes[0].sendtoaddress(new_addr, 2000000)
 
         utxos = self.nodes[0].listunspent(0, 0)
         assert len(utxos) > 0
 
         utxo = utxos[0]
 
         tx1 = CTransaction()
         value = int(satoshi_round(utxo["amount"] - self.relayfee) * XEC)
 
         # Check that the disable flag disables relative locktime.
         # If sequence locks were used, this would require 1 block for the
         # input to mature.
         sequence_value = SEQUENCE_LOCKTIME_DISABLE_FLAG | 1
         tx1.vin = [
             CTxIn(COutPoint(int(utxo["txid"], 16), utxo["vout"]), nSequence=sequence_value)]
         tx1.vout = [CTxOut(value, CScript([b'a']))]
         pad_tx(tx1)
 
         tx1_signed = self.nodes[0].signrawtransactionwithwallet(ToHex(tx1))[
             "hex"]
         tx1_id = self.nodes[0].sendrawtransaction(tx1_signed)
         tx1_id = int(tx1_id, 16)
 
         # This transaction will enable sequence-locks, so this transaction should
         # fail
         tx2 = CTransaction()
         tx2.nVersion = 2
         sequence_value = sequence_value & 0x7fffffff
         tx2.vin = [CTxIn(COutPoint(tx1_id, 0), nSequence=sequence_value)]
         tx2.vout = [CTxOut(int(value - self.relayfee * XEC), CScript([b'a']))]
         pad_tx(tx2)
         tx2.rehash()
 
         assert_raises_rpc_error(-26, NOT_FINAL_ERROR,
                                 self.nodes[0].sendrawtransaction, ToHex(tx2))
 
         # Setting the version back down to 1 should disable the sequence lock,
         # so this should be accepted.
         tx2.nVersion = 1
 
         self.nodes[0].sendrawtransaction(ToHex(tx2))
 
     # Calculate the median time past of a prior block ("confirmations" before
     # the current tip).
     def get_median_time_past(self, confirmations):
         block_hash = self.nodes[0].getblockhash(
             self.nodes[0].getblockcount() - confirmations)
         return self.nodes[0].getblockheader(block_hash)["mediantime"]
 
     # Test that sequence locks are respected for transactions spending
     # confirmed inputs.
     def test_sequence_lock_confirmed_inputs(self):
         # Create lots of confirmed utxos, and use them to generate lots of random
         # transactions.
         max_outputs = 50
         addresses = []
         while len(addresses) < max_outputs:
             addresses.append(self.nodes[0].getnewaddress())
         while len(self.nodes[0].listunspent()) < 200:
             import random
             random.shuffle(addresses)
             num_outputs = random.randint(1, max_outputs)
             outputs = {}
             for i in range(num_outputs):
                 outputs[addresses[i]] = random.randint(1, 20) * 10000
             self.nodes[0].sendmany("", outputs)
             self.generate(self.nodes[0], 1)
 
         utxos = self.nodes[0].listunspent()
 
         # Try creating a lot of random transactions.
         # Each time, choose a random number of inputs, and randomly set
         # some of those inputs to be sequence locked (and randomly choose
         # between height/time locking). Small random chance of making the locks
         # all pass.
         for _ in range(400):
             # Randomly choose up to 10 inputs
             num_inputs = random.randint(1, 10)
             random.shuffle(utxos)
 
             # Track whether any sequence locks used should fail
             should_pass = True
 
             # Track whether this transaction was built with sequence locks
             using_sequence_locks = False
 
             tx = CTransaction()
             tx.nVersion = 2
             value = 0
             for j in range(num_inputs):
                 # this disables sequence locks
                 sequence_value = 0xfffffffe
 
                 # 50% chance we enable sequence locks
                 if random.randint(0, 1):
                     using_sequence_locks = True
 
                     # 10% of the time, make the input sequence value pass
                     input_will_pass = (random.randint(1, 10) == 1)
                     sequence_value = utxos[j]["confirmations"]
                     if not input_will_pass:
                         sequence_value += 1
                         should_pass = False
 
                     # Figure out what the median-time-past was for the confirmed input
                     # Note that if an input has N confirmations, we're going back N blocks
                     # from the tip so that we're looking up MTP of the block
                     # PRIOR to the one the input appears in, as per the BIP68
                     # spec.
                     orig_time = self.get_median_time_past(
                         utxos[j]["confirmations"])
                     # MTP of the tip
                     cur_time = self.get_median_time_past(0)
 
                     # can only timelock this input if it's not too old --
                     # otherwise use height
                     can_time_lock = True
                     if ((cur_time - orig_time)
                             >> SEQUENCE_LOCKTIME_GRANULARITY) >= SEQUENCE_LOCKTIME_MASK:
                         can_time_lock = False
 
                     # if time-lockable, then 50% chance we make this a time
                     # lock
                     if random.randint(0, 1) and can_time_lock:
                         # Find first time-lock value that fails, or latest one
                         # that succeeds
                         time_delta = sequence_value << SEQUENCE_LOCKTIME_GRANULARITY
                         if input_will_pass and time_delta > cur_time - orig_time:
                             sequence_value = (
                                 (cur_time - orig_time) >> SEQUENCE_LOCKTIME_GRANULARITY)
                         elif (not input_will_pass and time_delta <= cur_time - orig_time):
                             sequence_value = (
                                 (cur_time - orig_time) >> SEQUENCE_LOCKTIME_GRANULARITY) + 1
                         sequence_value |= SEQUENCE_LOCKTIME_TYPE_FLAG
                 tx.vin.append(
                     CTxIn(COutPoint(int(utxos[j]["txid"], 16), utxos[j]["vout"]), nSequence=sequence_value))
                 value += utxos[j]["amount"] * XEC
             # Overestimate the size of the tx - signatures should be less than
             # 120 bytes, and leave 50 for the output
             tx_size = len(ToHex(tx)) // 2 + 120 * num_inputs + 50
             tx.vout.append(
                 CTxOut(int(value - self.relayfee * tx_size * XEC / 1000), CScript([b'a'])))
             rawtx = self.nodes[0].signrawtransactionwithwallet(ToHex(tx))[
                 "hex"]
 
             if (using_sequence_locks and not should_pass):
                 # This transaction should be rejected
                 assert_raises_rpc_error(-26, NOT_FINAL_ERROR,
                                         self.nodes[0].sendrawtransaction, rawtx)
             else:
                 # This raw transaction should be accepted
                 self.nodes[0].sendrawtransaction(rawtx)
                 utxos = self.nodes[0].listunspent()
 
     # Test that sequence locks on unconfirmed inputs must have nSequence
     # height or time of 0 to be accepted.
     # Then test that BIP68-invalid transactions are removed from the mempool
     # after a reorg.
     def test_sequence_lock_unconfirmed_inputs(self):
         # Store height so we can easily reset the chain at the end of the test
         cur_height = self.nodes[0].getblockcount()
 
         # Create a mempool tx.
         txid = self.nodes[0].sendtoaddress(
             self.nodes[0].getnewaddress(), 2000000)
         tx1 = FromHex(CTransaction(), self.nodes[0].getrawtransaction(txid))
         tx1.rehash()
 
         # As the fees are calculated prior to the transaction being signed,
         # there is some uncertainty that calculate fee provides the correct
         # minimal fee. Since regtest coins are free, let's go ahead and
         # increase the fee by an order of magnitude to ensure this test
         # passes.
         fee_multiplier = 10
 
         # Anyone-can-spend mempool tx.
         # Sequence lock of 0 should pass.
         tx2 = CTransaction()
         tx2.nVersion = 2
         tx2.vin = [CTxIn(COutPoint(tx1.sha256, 0), nSequence=0)]
         tx2.vout = [
             CTxOut(int(0), CScript([b'a']))]
         tx2.vout[0].nValue = tx1.vout[0].nValue - \
             fee_multiplier * self.nodes[0].calculate_fee(tx2)
         tx2_raw = self.nodes[0].signrawtransactionwithwallet(ToHex(tx2))["hex"]
         tx2 = FromHex(tx2, tx2_raw)
         tx2.rehash()
         self.nodes[0].sendrawtransaction(tx2_raw)
 
         # Create a spend of the 0th output of orig_tx with a sequence lock
         # of 1, and test what happens when submitting.
         # orig_tx.vout[0] must be an anyone-can-spend output
         def test_nonzero_locks(orig_tx, node, use_height_lock):
             sequence_value = 1
             if not use_height_lock:
                 sequence_value |= SEQUENCE_LOCKTIME_TYPE_FLAG
 
             tx = CTransaction()
             tx.nVersion = 2
             tx.vin = [
                 CTxIn(COutPoint(orig_tx.sha256, 0), nSequence=sequence_value)]
             tx.vout = [
                 CTxOut(int(orig_tx.vout[0].nValue - fee_multiplier * node.calculate_fee(tx)), CScript([b'a']))]
             pad_tx(tx)
             tx.rehash()
 
             if (orig_tx.hash in node.getrawmempool()):
                 # sendrawtransaction should fail if the tx is in the mempool
                 assert_raises_rpc_error(-26, NOT_FINAL_ERROR,
                                         node.sendrawtransaction, ToHex(tx))
             else:
                 # sendrawtransaction should succeed if the tx is not in the
                 # mempool
                 node.sendrawtransaction(ToHex(tx))
 
             return tx
 
         test_nonzero_locks(
             tx2, self.nodes[0], use_height_lock=True)
         test_nonzero_locks(
             tx2, self.nodes[0], use_height_lock=False)
 
         # Now mine some blocks, but make sure tx2 doesn't get mined.
         # Use prioritisetransaction to lower the effective feerate to 0
         self.nodes[0].prioritisetransaction(
             txid=tx2.hash, fee_delta=-fee_multiplier * self.nodes[0].calculate_fee(tx2))
         cur_time = int(time.time())
         for _ in range(10):
             self.nodes[0].setmocktime(cur_time + 600)
             self.generate(self.nodes[0], 1, sync_fun=self.no_op)
             cur_time += 600
 
         assert tx2.hash in self.nodes[0].getrawmempool()
 
         test_nonzero_locks(
             tx2, self.nodes[0], use_height_lock=True)
         test_nonzero_locks(
             tx2, self.nodes[0], use_height_lock=False)
 
         # Mine tx2, and then try again
         self.nodes[0].prioritisetransaction(
             txid=tx2.hash, fee_delta=fee_multiplier * self.nodes[0].calculate_fee(tx2))
 
         # Advance the time on the node so that we can test timelocks
         self.nodes[0].setmocktime(cur_time + 600)
         # Save block template now to use for the reorg later
         tmpl = self.nodes[0].getblocktemplate()
         self.generate(self.nodes[0], 1)
         assert tx2.hash not in self.nodes[0].getrawmempool()
 
         # Now that tx2 is not in the mempool, a sequence locked spend should
         # succeed
         tx3 = test_nonzero_locks(
             tx2, self.nodes[0], use_height_lock=False)
         assert tx3.hash in self.nodes[0].getrawmempool()
 
         self.generate(self.nodes[0], 1)
         assert tx3.hash not in self.nodes[0].getrawmempool()
 
         # One more test, this time using height locks
         tx4 = test_nonzero_locks(
             tx3, self.nodes[0], use_height_lock=True)
         assert tx4.hash in self.nodes[0].getrawmempool()
 
         # Now try combining confirmed and unconfirmed inputs
         tx5 = test_nonzero_locks(
             tx4, self.nodes[0], use_height_lock=True)
         assert tx5.hash not in self.nodes[0].getrawmempool()
 
         utxos = self.nodes[0].listunspent()
         tx5.vin.append(
             CTxIn(COutPoint(int(utxos[0]["txid"], 16), utxos[0]["vout"]), nSequence=1))
         tx5.vout[0].nValue += int(utxos[0]["amount"] * XEC)
         raw_tx5 = self.nodes[0].signrawtransactionwithwallet(ToHex(tx5))["hex"]
 
         assert_raises_rpc_error(-26, NOT_FINAL_ERROR,
                                 self.nodes[0].sendrawtransaction, raw_tx5)
 
         # Test mempool-BIP68 consistency after reorg
         #
         # State of the transactions in the last blocks:
         # ... -> [ tx2 ] ->  [ tx3 ]
         #         tip-1        tip
         # And currently tx4 is in the mempool.
         #
         # If we invalidate the tip, tx3 should get added to the mempool, causing
         # tx4 to be removed (fails sequence-lock).
         self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
         assert tx4.hash not in self.nodes[0].getrawmempool()
         assert tx3.hash in self.nodes[0].getrawmempool()
 
         # Now mine 2 empty blocks to reorg out the current tip (labeled tip-1 in
         # diagram above).
         # This would cause tx2 to be added back to the mempool, which in turn causes
         # tx3 to be removed.
         for i in range(2):
             block = create_block(tmpl=tmpl, ntime=cur_time)
             block.rehash()
             block.solve()
             tip = block.sha256
             assert_equal(
                 None if i == 1 else 'inconclusive',
                 self.nodes[0].submitblock(
                     ToHex(block)))
             tmpl = self.nodes[0].getblocktemplate()
             tmpl['previousblockhash'] = f"{tip:x}"
             tmpl['transactions'] = []
             cur_time += 1
 
         mempool = self.nodes[0].getrawmempool()
         assert tx3.hash not in mempool
         assert tx2.hash in mempool
 
         # Reset the chain and get rid of the mocktimed-blocks
         self.nodes[0].setmocktime(0)
         self.nodes[0].invalidateblock(
             self.nodes[0].getblockhash(cur_height + 1))
         self.generate(self.nodes[0], 10, sync_fun=self.no_op)
 
     def get_csv_status(self):
         height = self.nodes[0].getblockchaininfo()['blocks']
         return height >= 576
 
     # Make sure that BIP68 isn't being used to validate blocks, prior to
     # versionbits activation.  If more blocks are mined prior to this test
     # being run, then it's possible the test has activated the soft fork, and
     # this test should be moved to run earlier, or deleted.
     def test_bip68_not_consensus(self):
         assert_equal(self.get_csv_status(), False)
         txid = self.nodes[0].sendtoaddress(
             self.nodes[0].getnewaddress(), 2000000)
 
         tx1 = FromHex(CTransaction(), self.nodes[0].getrawtransaction(txid))
         tx1.rehash()
 
         # Make an anyone-can-spend transaction
         tx2 = CTransaction()
         tx2.nVersion = 1
         tx2.vin = [CTxIn(COutPoint(tx1.sha256, 0), nSequence=0)]
         tx2.vout = [
             CTxOut(int(tx1.vout[0].nValue - self.relayfee * XEC), CScript([b'a']))]
 
         # sign tx2
         tx2_raw = self.nodes[0].signrawtransactionwithwallet(ToHex(tx2))["hex"]
         tx2 = FromHex(tx2, tx2_raw)
         pad_tx(tx2)
         tx2.rehash()
 
         self.nodes[0].sendrawtransaction(ToHex(tx2))
 
         # Now make an invalid spend of tx2 according to BIP68
         # 100 block relative locktime
         sequence_value = 100
 
         tx3 = CTransaction()
         tx3.nVersion = 2
         tx3.vin = [CTxIn(COutPoint(tx2.sha256, 0), nSequence=sequence_value)]
         tx3.vout = [
             CTxOut(int(tx2.vout[0].nValue - self.relayfee * XEC), CScript([b'a']))]
         pad_tx(tx3)
         tx3.rehash()
 
         assert_raises_rpc_error(-26, NOT_FINAL_ERROR,
                                 self.nodes[0].sendrawtransaction, ToHex(tx3))
 
         # make a block that violates bip68; ensure that the tip updates
         block = create_block(tmpl=self.nodes[0].getblocktemplate())
         block.vtx.extend(
             sorted([tx1, tx2, tx3], key=lambda tx: tx.get_id()))
         block.hashMerkleRoot = block.calc_merkle_root()
         block.rehash()
         block.solve()
 
         assert_equal(None, self.nodes[0].submitblock(ToHex(block)))
         assert_equal(self.nodes[0].getbestblockhash(), block.hash)
 
     def activateCSV(self):
         # activation should happen at block height 576
         csv_activation_height = 576
         height = self.nodes[0].getblockcount()
         assert_greater_than(csv_activation_height - height, 1)
         self.generate(
             self.nodes[0],
             csv_activation_height - height - 1,
             sync_fun=self.no_op)
         assert_equal(self.get_csv_status(), False)
         self.disconnect_nodes(0, 1)
         self.generate(self.nodes[0], 1, sync_fun=self.no_op)
         assert_equal(self.get_csv_status(), True)
         # We have a block that has CSV activated, but we want to be at
         # the activation point, so we invalidate the tip.
         self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
         self.connect_nodes(0, 1)
         self.sync_blocks()
 
     # Use self.nodes[1] to test that version 2 transactions are standard.
     def test_version2_relay(self):
         inputs = []
         outputs = {self.nodes[1].getnewaddress(): 1000000.0}
         rawtx = self.nodes[1].createrawtransaction(inputs, outputs)
         rawtxfund = self.nodes[1].fundrawtransaction(rawtx)['hex']
         tx = FromHex(CTransaction(), rawtxfund)
         tx.nVersion = 2
         tx_signed = self.nodes[1].signrawtransactionwithwallet(ToHex(tx))[
             "hex"]
         self.nodes[1].sendrawtransaction(tx_signed)
 
 
 if __name__ == '__main__':
     BIP68Test().main()
diff --git a/test/functional/feature_block.py b/test/functional/feature_block.py
index 7289aa274..8838cf8bf 100755
--- a/test/functional/feature_block.py
+++ b/test/functional/feature_block.py
@@ -1,1293 +1,1293 @@
 #!/usr/bin/env python3
 # Copyright (c) 2015-2017 The Bitcoin Core developers
 # Copyright (c) 2019 The Bitcoin developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test block processing."""
 import copy
 import struct
 import time
 
 from data import invalid_txs
 from test_framework.blocktools import (
     create_block,
     create_coinbase,
     create_tx_with_script,
     make_conform_to_ctor,
 )
 from test_framework.cdefs import LEGACY_MAX_BLOCK_SIZE
 from test_framework.key import ECKey
 from test_framework.messages import (
     COIN,
     CBlock,
     COutPoint,
     CTransaction,
     CTxIn,
     CTxOut,
     uint256_from_compact,
     uint256_from_str,
 )
 from test_framework.p2p import P2PDataStore
 from test_framework.script import (
     OP_ELSE,
     OP_ENDIF,
     OP_FALSE,
     OP_IF,
     OP_INVALIDOPCODE,
     OP_RETURN,
     OP_TRUE,
     SIGHASH_ALL,
     SIGHASH_FORKID,
     CScript,
     SignatureHashForkId,
 )
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.txtools import pad_tx
 from test_framework.util import assert_equal
 
 #  Use this class for tests that require behavior other than normal p2p behavior.
 #  For now, it is used to serialize a bloated varint (b64).
 
 
 class CBrokenBlock(CBlock):
     def initialize(self, base_block):
         self.vtx = copy.deepcopy(base_block.vtx)
         self.hashMerkleRoot = self.calc_merkle_root()
 
     def serialize(self):
         r = b""
         r += super(CBlock, self).serialize()
         r += struct.pack("<BQ", 255, len(self.vtx))
         for tx in self.vtx:
             r += tx.serialize()
         return r
 
     def normal_serialize(self):
         return super().serialize()
 
 
 # Valid for block at height 120
 DUPLICATE_COINBASE_SCRIPT_SIG = b'\x01\x78'
 
 
 class FullBlockTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 1
         self.setup_clean_chain = True
         # This is a consensus block test, we don't care about tx policy
         self.extra_args = [['-noparkdeepreorg',
-                            '-maxreorgdepth=-1', '-acceptnonstdtxn=1']]
+                            '-acceptnonstdtxn=1']]
 
     def run_test(self):
         node = self.nodes[0]  # convenience reference to the node
 
         self.bootstrap_p2p()  # Add one p2p connection to the node
 
         self.block_heights = {}
         self.coinbase_key = ECKey()
         self.coinbase_key.generate()
         self.coinbase_pubkey = self.coinbase_key.get_pubkey().get_bytes()
         self.tip = None
         self.blocks = {}
         self.genesis_hash = int(self.nodes[0].getbestblockhash(), 16)
         self.block_heights[self.genesis_hash] = 0
         self.spendable_outputs = []
 
         # Create a new block
         b_dup_cb = self.next_block('dup_cb')
         b_dup_cb.vtx[0].vin[0].scriptSig = DUPLICATE_COINBASE_SCRIPT_SIG
         b_dup_cb.vtx[0].rehash()
         duplicate_tx = b_dup_cb.vtx[0]
         b_dup_cb = self.update_block('dup_cb', [])
         self.send_blocks([b_dup_cb])
 
         b0 = self.next_block(0)
         self.save_spendable_output()
         self.send_blocks([b0])
 
         # These constants chosen specifically to trigger an immature coinbase spend
         # at a certain time below.
         NUM_BUFFER_BLOCKS_TO_GENERATE = 99
         NUM_OUTPUTS_TO_COLLECT = 33
 
         # Allow the block to mature
         blocks = []
         for i in range(NUM_BUFFER_BLOCKS_TO_GENERATE):
             blocks.append(self.next_block("maturitybuffer.{}".format(i)))
             self.save_spendable_output()
         self.send_blocks(blocks)
 
         # collect spendable outputs now to avoid cluttering the code later on
         out = []
         for _ in range(NUM_OUTPUTS_TO_COLLECT):
             out.append(self.get_spendable_output())
 
         # Start by building a couple of blocks on top (which output is spent is
         # in parentheses):
         #     genesis -> b1 (0) -> b2 (1)
         b1 = self.next_block(1, spend=out[0])
         self.save_spendable_output()
 
         b2 = self.next_block(2, spend=out[1])
         self.save_spendable_output()
 
         self.send_blocks([b1, b2], timeout=4)
 
         # Select a txn with an output eligible for spending. This won't actually be spent,
         # since we're testing submission of a series of blocks with invalid
         # txns.
         attempt_spend_tx = out[2]
 
         # Submit blocks for rejection, each of which contains a single transaction
         # (aside from coinbase) which should be considered invalid.
         for TxTemplate in invalid_txs.iter_all_templates():
             template = TxTemplate(spend_tx=attempt_spend_tx)
 
             if template.valid_in_block:
                 continue
 
             self.log.info(
                 "Reject block with invalid tx: %s",
                 TxTemplate.__name__)
             blockname = "for_invalid.{}".format(TxTemplate.__name__)
             badblock = self.next_block(blockname)
             badtx = template.get_tx()
             if TxTemplate != invalid_txs.InputMissing:
                 self.sign_tx(badtx, attempt_spend_tx)
             badtx.rehash()
             badblock = self.update_block(blockname, [badtx])
             self.send_blocks(
                 [badblock], success=False,
                 reject_reason=(
                     template.block_reject_reason or template.reject_reason),
                 reconnect=True, timeout=2)
 
             self.move_tip(2)
 
         # Fork like this:
         #
         #     genesis -> b1 (0) -> b2 (1)
         #                      \-> b3 (1)
         #
         # Nothing should happen at this point. We saw b2 first so it takes
         # priority.
         self.log.info("Don't reorg to a chain of the same length")
         self.move_tip(1)
         b3 = self.next_block(3, spend=out[1])
         txout_b3 = b3.vtx[1]
         self.send_blocks([b3], False)
 
         # Now we add another block to make the alternative chain longer.
         #
         #     genesis -> b1 (0) -> b2 (1)
         #                      \-> b3 (1) -> b4 (2)
         self.log.info("Reorg to a longer chain")
         b4 = self.next_block(4, spend=out[2])
         self.send_blocks([b4])
 
         # ... and back to the first chain.
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
         #                      \-> b3 (1) -> b4 (2)
         self.move_tip(2)
         b5 = self.next_block(5, spend=out[2])
         self.save_spendable_output()
         self.send_blocks([b5], False)
 
         self.log.info("Reorg back to the original chain")
         b6 = self.next_block(6, spend=out[3])
         self.send_blocks([b6], True)
 
         # Try to create a fork that double-spends
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
         #                                          \-> b7 (2) -> b8 (4)
         #                      \-> b3 (1) -> b4 (2)
         self.log.info(
             "Reject a chain with a double spend, even if it is longer")
         self.move_tip(5)
         b7 = self.next_block(7, spend=out[2])
         self.send_blocks([b7], False)
 
         b8 = self.next_block(8, spend=out[4])
         self.send_blocks([b8], False, reconnect=True)
 
         # Try to create a block that has too much fee
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
         #                                                    \-> b9 (4)
         #                      \-> b3 (1) -> b4 (2)
         self.log.info(
             "Reject a block where the miner creates too much coinbase reward")
         self.move_tip(6)
         b9 = self.next_block(9, spend=out[4], additional_coinbase_value=1)
         self.send_blocks([b9], success=False,
                          reject_reason='bad-cb-amount', reconnect=True)
 
         # Create a fork that ends in a block with too much fee (the one that causes the reorg)
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6  (3)
         #                                          \-> b10 (3) -> b11 (4)
         #                      \-> b3 (1) -> b4 (2)
         self.log.info(
             "Reject a chain where the miner creates too much coinbase reward, even if the chain is longer")
         self.move_tip(5)
         b10 = self.next_block(10, spend=out[3])
         self.send_blocks([b10], False)
 
         b11 = self.next_block(11, spend=out[4], additional_coinbase_value=1)
         self.send_blocks([b11], success=False,
                          reject_reason='bad-cb-amount', reconnect=True)
 
         # Try again, but with a valid fork first
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6  (3)
         #                                          \-> b12 (3) -> b13 (4) -> b14 (5)
         #                      \-> b3 (1) -> b4 (2)
         self.log.info(
             "Reject a chain where the miner creates too much coinbase reward, even if the chain is longer (on a forked chain)")
         self.move_tip(5)
         b12 = self.next_block(12, spend=out[3])
         self.save_spendable_output()
         b13 = self.next_block(13, spend=out[4])
         self.save_spendable_output()
         b14 = self.next_block(14, spend=out[5], additional_coinbase_value=1)
         self.send_blocks([b12, b13, b14], success=False,
                          reject_reason='bad-cb-amount', reconnect=True)
 
         # New tip should be b13.
         assert_equal(node.getbestblockhash(), b13.hash)
 
         self.move_tip(13)
         b15 = self.next_block(15)
         self.save_spendable_output()
         self.send_blocks([b15], True)
 
         # Attempt to spend a transaction created on a different fork
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6  (3)
         #                                          \-> b12 (3) -> b13 (4) -> b15 (5) -> b17 (b3.vtx[1])
         #                      \-> b3 (1) -> b4 (2)
         self.log.info("Reject a block with a spend from a re-org'ed out tx")
         self.move_tip(15)
         b17 = self.next_block(17, spend=txout_b3)
         self.send_blocks([b17], success=False,
                          reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
 
         # Attempt to spend a transaction created on a different fork (on a fork this time)
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6  (3)
         #                                          \-> b12 (3) -> b13 (4) -> b15 (5)
         #                                                                \-> b18 (b3.vtx[1]) -> b19 (6)
         #                      \-> b3 (1) -> b4 (2)
         self.log.info(
             "Reject a block with a spend from a re-org'ed out tx (on a forked chain)")
         self.move_tip(13)
         b18 = self.next_block(18, spend=txout_b3)
         self.send_blocks([b18], False)
 
         b19 = self.next_block(19, spend=out[6])
         self.send_blocks([b19], success=False,
                          reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
 
         # Attempt to spend a coinbase at depth too low
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6  (3)
         #                                          \-> b12 (3) -> b13 (4) -> b15 (5) -> b20 (7)
         #                      \-> b3 (1) -> b4 (2)
         self.log.info("Reject a block spending an immature coinbase.")
         self.move_tip(15)
         b20 = self.next_block(20, spend=out[7])
         self.send_blocks(
             [b20],
             success=False,
             reject_reason='bad-txns-premature-spend-of-coinbase',
             reconnect=True)
 
         # Attempt to spend a coinbase at depth too low (on a fork this time)
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6  (3)
         #                                          \-> b12 (3) -> b13 (4) -> b15 (5)
         #                                                                \-> b21 (6) -> b22 (5)
         #                      \-> b3 (1) -> b4 (2)
         self.log.info(
             "Reject a block spending an immature coinbase (on a forked chain)")
         self.move_tip(13)
         b21 = self.next_block(21, spend=out[6])
         self.send_blocks([b21], False)
 
         b22 = self.next_block(22, spend=out[5])
         self.send_blocks(
             [b22],
             success=False,
             reject_reason='bad-txns-premature-spend-of-coinbase',
             reconnect=True)
 
         # Create a block on either side of LEGACY_MAX_BLOCK_SIZE and make sure its accepted/rejected
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6  (3)
         #                                          \-> b12 (3) -> b13 (4) -> b15 (5) -> b23 (6)
         #                                                                           \-> b24 (6) -> b25 (7)
         #                      \-> b3 (1) -> b4 (2)
         self.log.info("Accept a block of size LEGACY_MAX_BLOCK_SIZE")
         self.move_tip(15)
         b23 = self.next_block(23, spend=out[6])
         tx = CTransaction()
         script_length = LEGACY_MAX_BLOCK_SIZE - len(b23.serialize()) - 69
         script_output = CScript([b'\x00' * script_length])
         tx.vout.append(CTxOut(0, script_output))
         tx.vin.append(CTxIn(COutPoint(b23.vtx[1].sha256, 0)))
         b23 = self.update_block(23, [tx])
         # Make sure the math above worked out to produce a max-sized block
         assert_equal(len(b23.serialize()), LEGACY_MAX_BLOCK_SIZE)
         self.send_blocks([b23], True)
         self.save_spendable_output()
 
         # Create blocks with a coinbase input script size out of range
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6  (3)
         #                                          \-> b12 (3) -> b13 (4) -> b15 (5) -> b23 (6) -> b30 (7)
         #                                                                           \-> ... (6) -> ... (7)
         #                      \-> b3 (1) -> b4 (2)
         self.log.info(
             "Reject a block with coinbase input script size out of range")
         self.move_tip(15)
         b26 = self.next_block(26, spend=out[6])
         b26.vtx[0].vin[0].scriptSig = b'\x00'
         b26.vtx[0].rehash()
         # update_block causes the merkle root to get updated, even with no new
         # transactions, and updates the required state.
         b26 = self.update_block(26, [])
         self.send_blocks([b26], success=False,
                          reject_reason='bad-cb-length', reconnect=True)
 
         # Extend the b26 chain to make sure bitcoind isn't accepting b26
         b27 = self.next_block(27, spend=out[7])
         self.send_blocks([b27], False)
 
         # Now try a too-large-coinbase script
         self.move_tip(15)
         b28 = self.next_block(28, spend=out[6])
         b28.vtx[0].vin[0].scriptSig = b'\x00' * 101
         b28.vtx[0].rehash()
         b28 = self.update_block(28, [])
         self.send_blocks([b28], success=False,
                          reject_reason='bad-cb-length', reconnect=True)
 
         # Extend the b28 chain to make sure bitcoind isn't accepting b28
         b29 = self.next_block(29, spend=out[7])
         self.send_blocks([b29], False)
 
         # b30 has a max-sized coinbase scriptSig.
         self.move_tip(23)
         b30 = self.next_block(30)
         b30.vtx[0].vin[0].scriptSig = b'\x00' * 100
         b30.vtx[0].rehash()
         b30 = self.update_block(30, [])
         self.send_blocks([b30], True)
         self.save_spendable_output()
 
         b31 = self.next_block(31)
         self.save_spendable_output()
         b33 = self.next_block(33)
         self.save_spendable_output()
         b35 = self.next_block(35)
         self.save_spendable_output()
         self.send_blocks([b31, b33, b35], True)
 
         # Check spending of a transaction in a block which failed to connect
         #
         # b6  (3)
         # b12 (3) -> b13 (4) -> b15 (5) -> b23 (6) -> b30 (7) -> b31 (8) -> b33 (9) -> b35 (10)
         #                                                                                     \-> b37 (11)
         #                                                                                     \-> b38 (11/37)
         #
 
         # save 37's spendable output, but then double-spend out11 to invalidate
         # the block
         self.log.info(
             "Reject a block spending transaction from a block which failed to connect")
         self.move_tip(35)
         b37 = self.next_block(37, spend=out[11])
         txout_b37 = b37.vtx[1]
         tx = self.create_and_sign_transaction(out[11], 0)
         b37 = self.update_block(37, [tx])
         self.send_blocks([b37], success=False,
                          reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
 
         # attempt to spend b37's first non-coinbase tx, at which point b37 was
         # still considered valid
         self.move_tip(35)
         b38 = self.next_block(38, spend=txout_b37)
         self.send_blocks([b38], success=False,
                          reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
 
         self.move_tip(35)
         b39 = self.next_block(39)
         self.save_spendable_output()
         b41 = self.next_block(41)
         self.send_blocks([b39, b41], True)
 
         # Fork off of b39 to create a constant base again
         #
         # b23 (6) -> b30 (7) -> b31 (8) -> b33 (9) -> b35 (10) -> b39 (11) -> b42 (12) -> b43 (13)
         #                                                                  \-> b41 (12)
         #
         self.move_tip(39)
         b42 = self.next_block(42, spend=out[12])
         self.save_spendable_output()
 
         b43 = self.next_block(43, spend=out[13])
         self.save_spendable_output()
         self.send_blocks([b42, b43], True)
 
         # Test a number of really invalid scenarios
         #
         #  -> b31 (8) -> b33 (9) -> b35 (10) -> b39 (11) -> b42 (12) -> b43 (13) -> b44 (14)
         #                                                                                   \-> ??? (15)
 
         # The next few blocks are going to be created "by hand" since they'll do funky things, such as having
         # the first transaction be non-coinbase, etc.  The purpose of b44 is to
         # make sure this works.
         self.log.info("Build block 44 manually")
         height = self.block_heights[self.tip.sha256] + 1
         coinbase = create_coinbase(height, self.coinbase_pubkey)
         b44 = CBlock()
         b44.nTime = self.tip.nTime + 1
         b44.hashPrevBlock = self.tip.sha256
         b44.nBits = 0x207fffff
         b44.vtx.append(coinbase)
         b44.hashMerkleRoot = b44.calc_merkle_root()
         b44.solve()
         self.tip = b44
         self.block_heights[b44.sha256] = height
         self.blocks[44] = b44
         self.send_blocks([b44], True)
 
         self.log.info("Reject a block with a non-coinbase as the first tx")
         non_coinbase = self.create_tx(out[15], 0, 1)
         b45 = CBlock()
         b45.nTime = self.tip.nTime + 1
         b45.hashPrevBlock = self.tip.sha256
         b45.nBits = 0x207fffff
         b45.vtx.append(non_coinbase)
         b45.hashMerkleRoot = b45.calc_merkle_root()
         b45.calc_sha256()
         b45.solve()
         self.block_heights[b45.sha256] = self.block_heights[
             self.tip.sha256] + 1
         self.tip = b45
         self.blocks[45] = b45
         self.send_blocks([b45], success=False,
                          reject_reason='bad-cb-missing', reconnect=True)
 
         self.log.info("Reject a block with no transactions")
         self.move_tip(44)
         b46 = CBlock()
         b46.nTime = b44.nTime + 1
         b46.hashPrevBlock = b44.sha256
         b46.nBits = 0x207fffff
         b46.vtx = []
         b46.hashMerkleRoot = 0
         b46.solve()
         self.block_heights[b46.sha256] = self.block_heights[b44.sha256] + 1
         self.tip = b46
         assert 46 not in self.blocks
         self.blocks[46] = b46
         self.send_blocks([b46], success=False,
                          reject_reason='bad-cb-missing', reconnect=True)
 
         self.log.info("Reject a block with invalid work")
         self.move_tip(44)
         b47 = self.next_block(47)
         target = uint256_from_compact(b47.nBits)
         while b47.sha256 <= target:
             # Rehash nonces until an invalid too-high-hash block is found.
             b47.nNonce += 1
             b47.rehash()
         self.send_blocks(
             [b47],
             False,
             force_send=True,
             reject_reason='high-hash',
             reconnect=True)
 
         self.log.info("Reject a block with a timestamp >2 hours in the future")
         self.move_tip(44)
         b48 = self.next_block(48)
         b48.nTime = int(time.time()) + 60 * 60 * 3
         # Header timestamp has changed. Re-solve the block.
         b48.solve()
         self.send_blocks([b48], False, force_send=True,
                          reject_reason='time-too-new')
 
         self.log.info("Reject a block with invalid merkle hash")
         self.move_tip(44)
         b49 = self.next_block(49)
         b49.hashMerkleRoot += 1
         b49.solve()
         self.send_blocks([b49], success=False,
                          reject_reason='bad-txnmrklroot', reconnect=True)
 
         self.log.info("Reject a block with incorrect POW limit")
         self.move_tip(44)
         b50 = self.next_block(50)
         b50.nBits = b50.nBits - 1
         b50.solve()
         self.send_blocks(
             [b50],
             False,
             force_send=True,
             reject_reason='bad-diffbits',
             reconnect=True)
 
         self.log.info("Reject a block with two coinbase transactions")
         self.move_tip(44)
         b51 = self.next_block(51)
         cb2 = create_coinbase(51, self.coinbase_pubkey)
         b51 = self.update_block(51, [cb2])
         self.send_blocks([b51], success=False,
                          reject_reason='bad-tx-coinbase', reconnect=True)
 
         self.log.info("Reject a block with duplicate transactions")
         self.move_tip(44)
         b52 = self.next_block(52, spend=out[15])
         b52 = self.update_block(52, [b52.vtx[1]])
         self.send_blocks([b52], success=False,
                          reject_reason='tx-duplicate', reconnect=True)
 
         # Test block timestamps
         #  -> b31 (8) -> b33 (9) -> b35 (10) -> b39 (11) -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15)
         #                                                                                   \-> b54 (15)
         #
         self.move_tip(43)
         b53 = self.next_block(53, spend=out[14])
         self.send_blocks([b53], False)
         self.save_spendable_output()
 
         self.log.info("Reject a block with timestamp before MedianTimePast")
         b54 = self.next_block(54, spend=out[15])
         b54.nTime = b35.nTime - 1
         b54.solve()
         self.send_blocks(
             [b54],
             False,
             force_send=True,
             reject_reason='time-too-old',
             reconnect=True)
 
         # valid timestamp
         self.move_tip(53)
         b55 = self.next_block(55, spend=out[15])
         b55.nTime = b35.nTime
         self.update_block(55, [])
         self.send_blocks([b55], True)
         self.save_spendable_output()
 
         # Test Merkle tree malleability
         #
         # -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15) -> b57p2 (16)
         #                                                \-> b57   (16)
         #                                                \-> b56p2 (16)
         #                                                \-> b56   (16)
         #
         # Merkle tree malleability (CVE-2012-2459): repeating sequences of transactions in a block without
         #                           affecting the merkle root of a block, while still invalidating it.
         #                           See:  src/consensus/merkle.h
         #
         #  b57 has three txns:  coinbase, tx, tx1.  The merkle root computation will duplicate tx.
         #  Result:  OK
         #
         #  b56 copies b57 but duplicates tx1 and does not recalculate the block hash.  So it has a valid merkle
         #  root but duplicate transactions.
         #  Result:  Fails
         #
         #  b57p2 has six transactions in its merkle tree:
         #       - coinbase, tx, tx1, tx2, tx3, tx4
         #  Merkle root calculation will duplicate as necessary.
         #  Result:  OK.
         #
         #  b56p2 copies b57p2 but adds both tx3 and tx4.  The purpose of the test is to make sure the code catches
         #  duplicate txns that are not next to one another with the "bad-txns-duplicate" error (which indicates
         #  that the error was caught early, avoiding a DOS vulnerability.)
 
         # b57 - a good block with 2 txs, don't submit until end
         self.move_tip(55)
         b57 = self.next_block(57)
         tx = self.create_and_sign_transaction(out[16], 1)
         tx1 = self.create_tx(tx, 0, 1)
         b57 = self.update_block(57, [tx, tx1])
 
         # b56 - copy b57, add a duplicate tx
         self.log.info(
             "Reject a block with a duplicate transaction in the Merkle Tree (but with a valid Merkle Root)")
         self.move_tip(55)
         b56 = copy.deepcopy(b57)
         self.blocks[56] = b56
         assert_equal(len(b56.vtx), 3)
         b56 = self.update_block(56, [b57.vtx[2]])
         assert_equal(b56.hash, b57.hash)
         self.send_blocks([b56], success=False,
                          reject_reason='bad-txns-duplicate', reconnect=True)
 
         # b57p2 - a good block with 6 tx'es, don't submit until end
         self.move_tip(55)
         b57p2 = self.next_block("57p2")
         tx = self.create_and_sign_transaction(out[16], 1)
         tx1 = self.create_tx(tx, 0, 1)
         tx2 = self.create_tx(tx1, 0, 1)
         tx3 = self.create_tx(tx2, 0, 1)
         tx4 = self.create_tx(tx3, 0, 1)
         b57p2 = self.update_block("57p2", [tx, tx1, tx2, tx3, tx4])
 
         # b56p2 - copy b57p2, duplicate two non-consecutive tx's
         self.log.info(
             "Reject a block with two duplicate transactions in the Merkle Tree (but with a valid Merkle Root)")
         self.move_tip(55)
         b56p2 = copy.deepcopy(b57p2)
         self.blocks["b56p2"] = b56p2
         assert_equal(len(b56p2.vtx), 6)
         b56p2 = self.update_block("b56p2", b56p2.vtx[4:6], reorder=False)
         assert_equal(b56p2.hash, b57p2.hash)
         self.send_blocks([b56p2], success=False,
                          reject_reason='bad-txns-duplicate', reconnect=True)
 
         self.move_tip("57p2")
         self.send_blocks([b57p2], True)
 
         self.move_tip(57)
         # The tip is not updated because 57p2 seen first
         self.send_blocks([b57], False)
         self.save_spendable_output()
 
         # Test a few invalid tx types
         #
         # -> b35 (10) -> b39 (11) -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 ()
         #                                                                                    \-> ??? (17)
         #
 
         # tx with prevout.n out of range
         self.log.info(
             "Reject a block with a transaction with prevout.n out of range")
         self.move_tip(57)
         b58 = self.next_block(58, spend=out[17])
         tx = CTransaction()
         assert len(out[17].vout) < 42
         tx.vin.append(
             CTxIn(COutPoint(out[17].sha256, 42), CScript([OP_TRUE]), 0xffffffff))
         tx.vout.append(CTxOut(0, b""))
         pad_tx(tx)
         tx.calc_sha256()
         b58 = self.update_block(58, [tx])
         self.send_blocks([b58], success=False,
                          reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
 
         # tx with output value > input value
         self.log.info(
             "Reject a block with a transaction with outputs > inputs")
         self.move_tip(57)
         b59 = self.next_block(59)
         tx = self.create_and_sign_transaction(out[17], 51 * COIN)
         b59 = self.update_block(59, [tx])
         self.send_blocks([b59], success=False,
                          reject_reason='bad-txns-in-belowout', reconnect=True)
 
         # reset to good chain
         self.move_tip(57)
         b60 = self.next_block(60)
         self.send_blocks([b60], True)
         self.save_spendable_output()
 
         # Test BIP30 (reject duplicate)
         #
         # -> b39 (11) -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 ()
         #                                                                                  \-> b61 ()
         #
         # Blocks are not allowed to contain a transaction whose id matches that of an earlier,
         # not-fully-spent transaction in the same chain. To test, make identical coinbases;
         # the second one should be rejected. See also CVE-2012-1909.
         #
         self.log.info(
             "Reject a block with a transaction with a duplicate hash of a previous transaction (BIP30)")
         self.move_tip(60)
         b61 = self.next_block(61)
         b61.vtx[0].vin[0].scriptSig = DUPLICATE_COINBASE_SCRIPT_SIG
         b61.vtx[0].rehash()
         b61 = self.update_block(61, [])
         assert_equal(duplicate_tx.serialize(), b61.vtx[0].serialize())
         self.send_blocks([b61], success=False,
                          reject_reason='bad-txns-BIP30', reconnect=True)
 
         # Test BIP30 (allow duplicate if spent)
         #
         # -> b57 (16) -> b60 ()
         #            \-> b_spend_dup_cb (b_dup_cb) -> b_dup_2 ()
         #
         self.move_tip(57)
         b_spend_dup_cb = self.next_block('spend_dup_cb')
         tx = CTransaction()
         tx.vin.append(CTxIn(COutPoint(duplicate_tx.sha256, 0)))
         tx.vout.append(CTxOut(0, CScript([OP_TRUE])))
         self.sign_tx(tx, duplicate_tx)
         tx.rehash()
         b_spend_dup_cb = self.update_block('spend_dup_cb', [tx])
 
         b_dup_2 = self.next_block('dup_2')
         b_dup_2.vtx[0].vin[0].scriptSig = DUPLICATE_COINBASE_SCRIPT_SIG
         b_dup_2.vtx[0].rehash()
         b_dup_2 = self.update_block('dup_2', [])
         assert_equal(duplicate_tx.serialize(), b_dup_2.vtx[0].serialize())
         assert_equal(
             self.nodes[0].gettxout(
                 txid=duplicate_tx.hash,
                 n=0)['confirmations'],
             119)
         self.send_blocks([b_spend_dup_cb, b_dup_2], success=True)
         # The duplicate has less confirmations
         assert_equal(
             self.nodes[0].gettxout(
                 txid=duplicate_tx.hash,
                 n=0)['confirmations'],
             1)
 
         # Test tx.isFinal is properly rejected (not an exhaustive tx.isFinal test, that should be in data-driven transaction tests)
         #
         # -> b_spend_dup_cb (b_dup_cb) -> b_dup_2 ()
         #                                           \-> b62 (18)
         #
         self.log.info(
             "Reject a block with a transaction with a nonfinal locktime")
         self.move_tip('dup_2')
         b62 = self.next_block(62)
         tx = CTransaction()
         tx.nLockTime = 0xffffffff  # this locktime is non-final
         # don't set nSequence
         tx.vin.append(CTxIn(COutPoint(out[18].sha256, 0)))
         tx.vout.append(CTxOut(0, CScript([OP_TRUE])))
         assert tx.vin[0].nSequence < 0xffffffff
         tx.calc_sha256()
         b62 = self.update_block(62, [tx])
         self.send_blocks(
             [b62],
             success=False,
             reject_reason='bad-txns-nonfinal',
             reconnect=True)
 
         # Test a non-final coinbase is also rejected
         #
         # -> b_spend_dup_cb (b_dup_cb) -> b_dup_2 ()
         #                                           \-> b63 (-)
         #
         self.log.info(
             "Reject a block with a coinbase transaction with a nonfinal locktime")
         self.move_tip('dup_2')
         b63 = self.next_block(63)
         b63.vtx[0].nLockTime = 0xffffffff
         b63.vtx[0].vin[0].nSequence = 0xDEADBEEF
         b63.vtx[0].rehash()
         b63 = self.update_block(63, [])
         self.send_blocks(
             [b63],
             success=False,
             reject_reason='bad-txns-nonfinal',
             reconnect=True)
 
         #  This checks that a block with a bloated VARINT between the block_header and the array of tx such that
         #  the block is > LEGACY_MAX_BLOCK_SIZE with the bloated varint, but <= LEGACY_MAX_BLOCK_SIZE without the bloated varint,
         #  does not cause a subsequent, identical block with canonical encoding to be rejected.  The test does not
         #  care whether the bloated block is accepted or rejected; it only cares that the second block is accepted.
         #
         #  What matters is that the receiving node should not reject the bloated block, and then reject the canonical
         #  block on the basis that it's the same as an already-rejected block (which would be a consensus failure.)
         #
         #  -> b_spend_dup_cb (b_dup_cb) -> b_dup_2 () -> b64 (18)
         #                                              \
         #                                               b64a (18)
         #  b64a is a bloated block (non-canonical varint)
         #  b64 is a good block (same as b64 but w/ canonical varint)
         #
         self.log.info(
             "Accept a valid block even if a bloated version of the block has previously been sent")
         self.move_tip('dup_2')
         regular_block = self.next_block("64a", spend=out[18])
 
         # make it a "broken_block," with non-canonical serialization
         b64a = CBrokenBlock(regular_block)
         b64a.initialize(regular_block)
         self.blocks["64a"] = b64a
         self.tip = b64a
         tx = CTransaction()
 
         # use canonical serialization to calculate size
         script_length = LEGACY_MAX_BLOCK_SIZE - \
             len(b64a.normal_serialize()) - 69
         script_output = CScript([b'\x00' * script_length])
         tx.vout.append(CTxOut(0, script_output))
         tx.vin.append(CTxIn(COutPoint(b64a.vtx[1].sha256, 0)))
         b64a = self.update_block("64a", [tx])
         assert_equal(len(b64a.serialize()), LEGACY_MAX_BLOCK_SIZE + 8)
         self.send_blocks([b64a], success=False,
                          reject_reason='non-canonical ReadCompactSize()')
 
         # bitcoind doesn't disconnect us for sending a bloated block, but if we subsequently
         # resend the header message, it won't send us the getdata message again. Just
         # disconnect and reconnect and then call send_blocks.
         # TODO: improve this test to be less dependent on P2P DOS behaviour.
         node.disconnect_p2ps()
         self.reconnect_p2p()
 
         self.move_tip('dup_2')
         b64 = CBlock(b64a)
         b64.vtx = copy.deepcopy(b64a.vtx)
         assert_equal(b64.hash, b64a.hash)
         assert_equal(len(b64.serialize()), LEGACY_MAX_BLOCK_SIZE)
         self.blocks[64] = b64
         b64 = self.update_block(64, [])
         self.send_blocks([b64], True)
         self.save_spendable_output()
 
         # Spend an output created in the block itself
         #
         # -> b_dup_2 () -> b64 (18) -> b65 (19)
         #
         self.log.info(
             "Accept a block with a transaction spending an output created in the same block")
         self.move_tip(64)
         b65 = self.next_block(65)
         tx1 = self.create_and_sign_transaction(out[19], out[19].vout[0].nValue)
         tx2 = self.create_and_sign_transaction(tx1, 0)
         b65 = self.update_block(65, [tx1, tx2])
         self.send_blocks([b65], True)
         self.save_spendable_output()
 
         # Attempt to double-spend a transaction created in a block
         #
         # -> b64 (18) -> b65 (19)
         #                        \-> b67 (20)
         #
         #
         self.log.info(
             "Reject a block with a transaction double spending a transaction created in the same block")
         self.move_tip(65)
         b67 = self.next_block(67)
         tx1 = self.create_and_sign_transaction(out[20], out[20].vout[0].nValue)
         tx2 = self.create_and_sign_transaction(tx1, 1)
         tx3 = self.create_and_sign_transaction(tx1, 2)
         b67 = self.update_block(67, [tx1, tx2, tx3])
         self.send_blocks([b67], success=False,
                          reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
 
         # More tests of block subsidy
         #
         # -> b64 (18) -> b65 (19) -> b69 (20)
         #                        \-> b68 (20)
         #
         # b68 - coinbase with an extra 10 satoshis,
         #       creates a tx that has 9 satoshis from out[20] go to fees
         #       this fails because the coinbase is trying to claim 1 satoshi too much in fees
         #
         # b69 - coinbase with extra 10 satoshis, and a tx that gives a 10 satoshi fee
         #       this succeeds
         #
         self.log.info(
             "Reject a block trying to claim too much subsidy in the coinbase transaction")
         self.move_tip(65)
         b68 = self.next_block(68, additional_coinbase_value=10)
         tx = self.create_and_sign_transaction(
             out[20], out[20].vout[0].nValue - 9)
         b68 = self.update_block(68, [tx])
         self.send_blocks([b68], success=False,
                          reject_reason='bad-cb-amount', reconnect=True)
 
         self.log.info(
             "Accept a block claiming the correct subsidy in the coinbase transaction")
         self.move_tip(65)
         b69 = self.next_block(69, additional_coinbase_value=10)
         tx = self.create_and_sign_transaction(
             out[20], out[20].vout[0].nValue - 10)
         self.update_block(69, [tx])
         self.send_blocks([b69], True)
         self.save_spendable_output()
 
         # Test spending the outpoint of a non-existent transaction
         #
         # -> b65 (19) -> b69 (20)
         #                        \-> b70 (21)
         #
         self.log.info(
             "Reject a block containing a transaction spending from a non-existent input")
         self.move_tip(69)
         b70 = self.next_block(70, spend=out[21])
         bogus_tx = CTransaction()
         bogus_tx.sha256 = uint256_from_str(
             b"23c70ed7c0506e9178fc1a987f40a33946d4ad4c962b5ae3a52546da53af0c5c")
         tx = CTransaction()
         tx.vin.append(CTxIn(COutPoint(bogus_tx.sha256, 0), b"", 0xffffffff))
         tx.vout.append(CTxOut(1, b""))
         pad_tx(tx)
         b70 = self.update_block(70, [tx])
         self.send_blocks([b70], success=False,
                          reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
 
         # Test accepting an invalid block which has the same hash as a valid one (via merkle tree tricks)
         #
         #  -> b65 (19) -> b69 (20) -> b72 (21)
         #                          \-> b71 (21)
         #
         # b72 is a good block.
         # b71 is a copy of 72, but re-adds one of its transactions.  However,
         # it has the same hash as b72.
         self.log.info(
             "Reject a block containing a duplicate transaction but with the same Merkle root (Merkle tree malleability")
         self.move_tip(69)
         b72 = self.next_block(72)
         tx1 = self.create_and_sign_transaction(out[21], 2)
         tx2 = self.create_and_sign_transaction(tx1, 1)
         b72 = self.update_block(72, [tx1, tx2])  # now tip is 72
         b71 = copy.deepcopy(b72)
         # add duplicate last transaction
         b71.vtx.append(b72.vtx[-1])
         # b71 builds off b69
         self.block_heights[b71.sha256] = self.block_heights[b69.sha256] + 1
         self.blocks[71] = b71
 
         assert_equal(len(b71.vtx), 4)
         assert_equal(len(b72.vtx), 3)
         assert_equal(b72.sha256, b71.sha256)
 
         self.move_tip(71)
         self.send_blocks([b71], success=False,
                          reject_reason='bad-txns-duplicate', reconnect=True)
 
         self.move_tip(72)
         self.send_blocks([b72], True)
         self.save_spendable_output()
 
         b75 = self.next_block(75)
         self.save_spendable_output()
         b76 = self.next_block(76)
         self.save_spendable_output()
         self.send_blocks([b75, b76], True)
 
         # Test transaction resurrection
         #
         # -> b77 (24) -> b78 (25) -> b79 (26)
         #            \-> b80 (25) -> b81 (26) -> b82 (27)
         #
         #    b78 creates a tx, which is spent in b79. After b82, both should be in mempool
         #
         #    The tx'es must be unsigned and pass the node's mempool policy.  It is unsigned for the
         #    rather obscure reason that the Python signature code does not distinguish between
         #    Low-S and High-S values (whereas the bitcoin code has custom code which does so);
         #    as a result of which, the odds are 50% that the python code will use the right
         #    value and the transaction will be accepted into the mempool. Until we modify the
         #    test framework to support low-S signing, we are out of luck.
         #
         #    To get around this issue, we construct transactions which are not signed and which
         #    spend to OP_TRUE.  If the standard-ness rules change, this test would need to be
         #    updated.  (Perhaps to spend to a P2SH OP_TRUE script)
         self.log.info("Test transaction resurrection during a re-org")
         self.move_tip(76)
         b77 = self.next_block(77)
         tx77 = self.create_and_sign_transaction(out[24], 10 * COIN)
         b77 = self.update_block(77, [tx77])
         self.send_blocks([b77], True)
         self.save_spendable_output()
 
         b78 = self.next_block(78)
         tx78 = self.create_tx(tx77, 0, 9 * COIN)
         b78 = self.update_block(78, [tx78])
         self.send_blocks([b78], True)
 
         b79 = self.next_block(79)
         tx79 = self.create_tx(tx78, 0, 8 * COIN)
         b79 = self.update_block(79, [tx79])
         self.send_blocks([b79], True)
 
         # mempool should be empty
         assert_equal(len(self.nodes[0].getrawmempool()), 0)
 
         self.move_tip(77)
         b80 = self.next_block(80, spend=out[25])
         self.send_blocks([b80], False, force_send=True)
         self.save_spendable_output()
 
         b81 = self.next_block(81, spend=out[26])
         # other chain is same length
         self.send_blocks([b81], False, force_send=True)
         self.save_spendable_output()
 
         b82 = self.next_block(82, spend=out[27])
         # now this chain is longer, triggers re-org
         self.send_blocks([b82], True)
         self.save_spendable_output()
 
         # now check that tx78 and tx79 have been put back into the peer's
         # mempool
         mempool = self.nodes[0].getrawmempool()
         assert_equal(len(mempool), 2)
         assert tx78.hash in mempool
         assert tx79.hash in mempool
 
         # Test invalid opcodes in dead execution paths.
         #
         #  -> b81 (26) -> b82 (27) -> b83 (28)
         #
         self.log.info(
             "Accept a block with invalid opcodes in dead execution paths")
         b83 = self.next_block(83)
         op_codes = [OP_IF, OP_INVALIDOPCODE, OP_ELSE, OP_TRUE, OP_ENDIF]
         script = CScript(op_codes)
         tx1 = self.create_and_sign_transaction(
             out[28], out[28].vout[0].nValue, script)
 
         tx2 = self.create_and_sign_transaction(tx1, 0, CScript([OP_TRUE]))
         tx2.vin[0].scriptSig = CScript([OP_FALSE])
         tx2.rehash()
 
         b83 = self.update_block(83, [tx1, tx2])
         self.send_blocks([b83], True)
         self.save_spendable_output()
 
         # Reorg on/off blocks that have OP_RETURN in them (and try to spend them)
         #
         #  -> b81 (26) -> b82 (27) -> b83 (28) -> b84 (29) -> b87 (30) -> b88 (31)
         #                                    \-> b85 (29) -> b86 (30)            \-> b89a (32)
         #
         self.log.info("Test re-orging blocks with OP_RETURN in them")
         b84 = self.next_block(84)
         tx1 = self.create_tx(out[29], 0, 0, CScript([OP_RETURN]))
         vout_offset = len(tx1.vout)
         tx1.vout.append(CTxOut(0, CScript([OP_TRUE])))
         tx1.vout.append(CTxOut(0, CScript([OP_TRUE])))
         tx1.vout.append(CTxOut(0, CScript([OP_TRUE])))
         tx1.vout.append(CTxOut(0, CScript([OP_TRUE])))
         tx1.calc_sha256()
         self.sign_tx(tx1, out[29])
         tx1.rehash()
         tx2 = self.create_tx(tx1, vout_offset, 0, CScript([OP_RETURN]))
         tx2.vout.append(CTxOut(0, CScript([OP_RETURN])))
         tx3 = self.create_tx(tx1, vout_offset + 1, 0, CScript([OP_RETURN]))
         tx3.vout.append(CTxOut(0, CScript([OP_TRUE])))
         tx4 = self.create_tx(tx1, vout_offset + 2, 0, CScript([OP_TRUE]))
         tx4.vout.append(CTxOut(0, CScript([OP_RETURN])))
         tx5 = self.create_tx(tx1, vout_offset + 3, 0, CScript([OP_RETURN]))
 
         b84 = self.update_block(84, [tx1, tx2, tx3, tx4, tx5])
         self.send_blocks([b84], True)
         self.save_spendable_output()
 
         self.move_tip(83)
         b85 = self.next_block(85, spend=out[29])
         self.send_blocks([b85], False)  # other chain is same length
 
         b86 = self.next_block(86, spend=out[30])
         self.send_blocks([b86], True)
 
         self.move_tip(84)
         b87 = self.next_block(87, spend=out[30])
         self.send_blocks([b87], False)  # other chain is same length
         self.save_spendable_output()
 
         b88 = self.next_block(88, spend=out[31])
         self.send_blocks([b88], True)
         self.save_spendable_output()
 
         # trying to spend the OP_RETURN output is rejected
         b89a = self.next_block("89a", spend=out[32])
         tx = self.create_tx(tx1, 0, 0, CScript([OP_TRUE]))
         b89a = self.update_block("89a", [tx])
         self.send_blocks([b89a], success=False,
                          reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
 
         self.log.info(
             "Test a re-org of one week's worth of blocks (1088 blocks)")
 
         self.move_tip(88)
         LARGE_REORG_SIZE = 1088
         blocks = []
         spend = out[32]
         for i in range(89, LARGE_REORG_SIZE + 89):
             b = self.next_block(i, spend)
             tx = CTransaction()
             script_length = LEGACY_MAX_BLOCK_SIZE - len(b.serialize()) - 69
             script_output = CScript([b'\x00' * script_length])
             tx.vout.append(CTxOut(0, script_output))
             tx.vin.append(CTxIn(COutPoint(b.vtx[1].sha256, 0)))
             b = self.update_block(i, [tx])
             assert_equal(len(b.serialize()), LEGACY_MAX_BLOCK_SIZE)
             blocks.append(b)
             self.save_spendable_output()
             spend = self.get_spendable_output()
 
         self.send_blocks(blocks, True, timeout=2440)
         chain1_tip = i
 
         # now create alt chain of same length
         self.move_tip(88)
         blocks2 = []
         for i in range(89, LARGE_REORG_SIZE + 89):
             blocks2.append(self.next_block("alt" + str(i)))
         self.send_blocks(blocks2, False, force_send=True)
 
         # extend alt chain to trigger re-org
         block = self.next_block("alt" + str(chain1_tip + 1))
         self.send_blocks([block], True, timeout=2440)
 
         # ... and re-org back to the first chain
         self.move_tip(chain1_tip)
         block = self.next_block(chain1_tip + 1)
         self.send_blocks([block], False, force_send=True)
         block = self.next_block(chain1_tip + 2)
         self.send_blocks([block], True, timeout=2440)
 
         self.log.info("Reject a block with an invalid block header version")
         b_v1 = self.next_block('b_v1', version=1)
         self.send_blocks(
             [b_v1],
             success=False,
             force_send=True,
             reject_reason='bad-version(0x00000001)',
             reconnect=True)
 
         self.move_tip(chain1_tip + 2)
         b_cb34 = self.next_block('b_cb34')
         b_cb34.vtx[0].vin[0].scriptSig = b_cb34.vtx[0].vin[0].scriptSig[:-1]
         b_cb34.vtx[0].rehash()
         b_cb34.hashMerkleRoot = b_cb34.calc_merkle_root()
         b_cb34.solve()
         self.send_blocks(
             [b_cb34],
             success=False,
             reject_reason='bad-cb-height',
             reconnect=True)
 
     # Helper methods
     ################
 
     def add_transactions_to_block(self, block, tx_list):
         [tx.rehash() for tx in tx_list]
         block.vtx.extend(tx_list)
 
     # this is a little handier to use than the version in blocktools.py
     def create_tx(self, spend_tx, n, value, script=CScript([OP_TRUE])):
         return create_tx_with_script(
             spend_tx, n, amount=value, script_pub_key=script)
 
     # sign a transaction, using the key we know about
     # this signs input 0 in tx, which is assumed to be spending output n in
     # spend_tx
     def sign_tx(self, tx, spend_tx):
         scriptPubKey = bytearray(spend_tx.vout[0].scriptPubKey)
         if (scriptPubKey[0] == OP_TRUE):  # an anyone-can-spend
             tx.vin[0].scriptSig = CScript()
             return
         sighash = SignatureHashForkId(
             spend_tx.vout[0].scriptPubKey, tx, 0, SIGHASH_ALL | SIGHASH_FORKID, spend_tx.vout[0].nValue)
         tx.vin[0].scriptSig = CScript(
             [self.coinbase_key.sign_ecdsa(sighash) + bytes(bytearray([SIGHASH_ALL | SIGHASH_FORKID]))])
 
     def create_and_sign_transaction(
             self, spend_tx, value, script=CScript([OP_TRUE])):
         tx = self.create_tx(spend_tx, 0, value, script)
         self.sign_tx(tx, spend_tx)
         tx.rehash()
         return tx
 
     def next_block(self, number, spend=None, additional_coinbase_value=0,
                    script=CScript([OP_TRUE]), *, version=4):
         if self.tip is None:
             base_block_hash = self.genesis_hash
             block_time = int(time.time()) + 1
         else:
             base_block_hash = self.tip.sha256
             block_time = self.tip.nTime + 1
         # First create the coinbase
         height = self.block_heights[base_block_hash] + 1
         coinbase = create_coinbase(height, self.coinbase_pubkey)
         coinbase.vout[0].nValue += additional_coinbase_value
         coinbase.rehash()
         if spend is None:
             block = create_block(
                 base_block_hash,
                 coinbase,
                 block_time,
                 version=version)
         else:
             # all but one satoshi to fees
             coinbase.vout[0].nValue += spend.vout[0].nValue - 1
             coinbase.rehash()
             block = create_block(
                 base_block_hash,
                 coinbase,
                 block_time,
                 version=version)
             # spend 1 satoshi
             tx = self.create_tx(spend, 0, 1, script)
             self.sign_tx(tx, spend)
             self.add_transactions_to_block(block, [tx])
             block.hashMerkleRoot = block.calc_merkle_root()
         # Block is created. Find a valid nonce.
         block.solve()
         self.tip = block
         self.block_heights[block.sha256] = height
         assert number not in self.blocks
         self.blocks[number] = block
         return block
 
     # save the current tip so it can be spent by a later block
     def save_spendable_output(self):
         self.log.debug("saving spendable output {}".format(self.tip.vtx[0]))
         self.spendable_outputs.append(self.tip)
 
     # get an output that we previously marked as spendable
     def get_spendable_output(self):
         self.log.debug("getting spendable output {}".format(
             self.spendable_outputs[0].vtx[0]))
         return self.spendable_outputs.pop(0).vtx[0]
 
     # move the tip back to a previous block
     def move_tip(self, number):
         self.tip = self.blocks[number]
 
     # adds transactions to the block and updates state
     def update_block(self, block_number, new_transactions, reorder=True):
         block = self.blocks[block_number]
         self.add_transactions_to_block(block, new_transactions)
         old_sha256 = block.sha256
         if reorder:
             make_conform_to_ctor(block)
         block.hashMerkleRoot = block.calc_merkle_root()
         block.solve()
         # Update the internal state just like in next_block
         self.tip = block
         if block.sha256 != old_sha256:
             self.block_heights[block.sha256] = self.block_heights[old_sha256]
             del self.block_heights[old_sha256]
         self.blocks[block_number] = block
         return block
 
     def bootstrap_p2p(self, timeout=10):
         """Add a P2P connection to the node.
 
         Helper to connect and wait for version handshake."""
         self.helper_peer = self.nodes[0].add_p2p_connection(P2PDataStore())
         # We need to wait for the initial getheaders from the peer before we
         # start populating our blockstore. If we don't, then we may run ahead
         # to the next subtest before we receive the getheaders. We'd then send
         # an INV for the next block and receive two getheaders - one for the
         # IBD and one for the INV. We'd respond to both and could get
         # unexpectedly disconnected if the DoS score for that error is 50.
         self.helper_peer.wait_for_getheaders(timeout=timeout)
 
     def reconnect_p2p(self, timeout=60):
         """Tear down and bootstrap the P2P connection to the node.
 
         The node gets disconnected several times in this test. This helper
         method reconnects the p2p and restarts the network thread."""
         self.nodes[0].disconnect_p2ps()
         self.bootstrap_p2p(timeout=timeout)
 
     def send_blocks(self, blocks, success=True, reject_reason=None,
                     force_send=False, reconnect=False, timeout=60):
         """Sends blocks to test node. Syncs and verifies that tip has advanced to most recent block.
 
         Call with success = False if the tip shouldn't advance to the most recent block."""
         self.helper_peer.send_blocks_and_test(blocks, self.nodes[0], success=success,
                                               reject_reason=reject_reason, force_send=force_send, timeout=timeout, expect_disconnect=reconnect)
 
         if reconnect:
             self.reconnect_p2p(timeout=timeout)
 
 
 if __name__ == '__main__':
     FullBlockTest().main()
diff --git a/test/functional/feature_pruning.py b/test/functional/feature_pruning.py
index 8d669bf07..5ae388623 100755
--- a/test/functional/feature_pruning.py
+++ b/test/functional/feature_pruning.py
@@ -1,515 +1,515 @@
 #!/usr/bin/env python3
 # Copyright (c) 2014-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.
 """Test the pruning code.
 
 WARNING:
 This test uses 4GB of disk space.
 This test takes 30 mins or more (up to 2 hours)
 """
 
 import os
 
 from test_framework.blocktools import create_coinbase
 from test_framework.messages import CBlock, ToHex
 from test_framework.script import OP_NOP, OP_RETURN, CScript
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_equal,
     assert_greater_than,
     assert_raises_rpc_error,
 )
 
 # Rescans start at the earliest block up to 2 hours before a key timestamp, so
 # the manual prune RPC avoids pruning blocks in the same window to be
 # compatible with pruning based on key creation time.
 TIMESTAMP_WINDOW = 2 * 60 * 60
 
 
 def mine_large_blocks(node, n):
     # Make a large scriptPubKey for the coinbase transaction. This is OP_RETURN
     # followed by 950k of OP_NOP. This would be non-standard in a non-coinbase
     # transaction but is consensus valid.
 
     # Set the nTime if this is the first time this function has been called.
     # A static variable ensures that time is monotonicly increasing and is therefore
     # different for each block created => blockhash is unique.
     if "nTimes" not in mine_large_blocks.__dict__:
         mine_large_blocks.nTime = 0
 
     # Get the block parameters for the first block
     big_script = CScript([OP_RETURN] + [OP_NOP] * 950000)
     best_block = node.getblock(node.getbestblockhash())
     height = int(best_block["height"]) + 1
     mine_large_blocks.nTime = max(
         mine_large_blocks.nTime, int(best_block["time"])) + 1
     previousblockhash = int(best_block["hash"], 16)
 
     for _ in range(n):
         # Build the coinbase transaction (with large scriptPubKey)
         coinbase_tx = create_coinbase(height)
         coinbase_tx.vin[0].nSequence = 2 ** 32 - 1
         coinbase_tx.vout[0].scriptPubKey = big_script
         coinbase_tx.rehash()
 
         # Build the block
         block = CBlock()
         block.nVersion = best_block["version"]
         block.hashPrevBlock = previousblockhash
         block.nTime = mine_large_blocks.nTime
         block.nBits = int('207fffff', 16)
         block.nNonce = 0
         block.vtx = [coinbase_tx]
         block.hashMerkleRoot = block.calc_merkle_root()
         block.solve()
 
         # Submit to the node
         node.submitblock(ToHex(block))
 
         previousblockhash = block.sha256
         height += 1
         mine_large_blocks.nTime += 1
 
 
 def calc_usage(blockdir):
     return sum(os.path.getsize(blockdir + f) for f in os.listdir(blockdir)
                if os.path.isfile(os.path.join(blockdir, f))) / (1024. * 1024.)
 
 
 class PruneTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 6
         self.supports_cli = False
 
         # Create nodes 0 and 1 to mine.
         # Create node 2 to test pruning.
         self.full_node_default_args = ["-maxreceivebuffer=20000", "-blockmaxsize=999000",
-                                       "-checkblocks=5", "-noparkdeepreorg", "-maxreorgdepth=-1"]
+                                       "-checkblocks=5", "-noparkdeepreorg"]
         # Create nodes 3 and 4 to test manual pruning (they will be re-started with manual pruning later)
         # Create nodes 5 to test wallet in prune mode, but do not connect
         self.extra_args = [self.full_node_default_args,
                            self.full_node_default_args,
                            ["-maxreceivebuffer=20000", "-prune=550",
-                               "-noparkdeepreorg", "-maxreorgdepth=-1"],
+                               "-noparkdeepreorg"],
                            ["-maxreceivebuffer=20000", "-blockmaxsize=999000",
-                               "-noparkdeepreorg", "-maxreorgdepth=-1"],
+                               "-noparkdeepreorg"],
                            ["-maxreceivebuffer=20000", "-blockmaxsize=999000",
-                               "-noparkdeepreorg", "-maxreorgdepth=-1"],
+                               "-noparkdeepreorg"],
                            ["-prune=550"]]
         self.rpc_timeout = 120
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
     def setup_network(self):
         self.setup_nodes()
 
         self.prunedir = os.path.join(
             self.nodes[2].datadir, self.chain, 'blocks', '')
 
         self.connect_nodes(0, 1)
         self.connect_nodes(1, 2)
         self.connect_nodes(0, 2)
         self.connect_nodes(0, 3)
         self.connect_nodes(0, 4)
         self.sync_blocks(self.nodes[0:5])
 
     def setup_nodes(self):
         self.add_nodes(self.num_nodes, self.extra_args)
         self.start_nodes()
         self.import_deterministic_coinbase_privkeys()
 
     def create_big_chain(self):
         # Start by creating some coinbases we can spend later
         self.generate(
             self.nodes[1], 200, sync_fun=lambda: self.sync_blocks(self.nodes[0:2]))
         self.generate(self.nodes[0], 150, sync_fun=self.no_op)
 
         # Then mine enough full blocks to create more than 550MiB of data
         mine_large_blocks(self.nodes[0], 645)
 
         self.sync_blocks(self.nodes[0:5])
 
     def test_height_min(self):
         assert os.path.isfile(os.path.join(
             self.prunedir, "blk00000.dat")), "blk00000.dat is missing, pruning too early"
         self.log.info("Success")
         self.log.info("Though we're already using more than 550MiB, current usage: {}".format(
                       calc_usage(self.prunedir)))
         self.log.info(
             "Mining 25 more blocks should cause the first block file to be pruned")
         # Pruning doesn't run until we're allocating another chunk, 20 full
         # blocks past the height cutoff will ensure this
         mine_large_blocks(self.nodes[0], 25)
 
         # Wait for blk00000.dat to be pruned
         self.wait_until(
             lambda: not os.path.isfile(
                 os.path.join(self.prunedir, "blk00000.dat")),
             timeout=30)
 
         self.log.info("Success")
         usage = calc_usage(self.prunedir)
         self.log.info("Usage should be below target: {}".format(usage))
         assert_greater_than(550, usage)
 
     def create_chain_with_staleblocks(self):
         # Create stale blocks in manageable sized chunks
         self.log.info(
             "Mine 24 (stale) blocks on Node 1, followed by 25 (main chain) block reorg from Node 0, for 12 rounds")
 
         for _ in range(12):
             # Disconnect node 0 so it can mine a longer reorg chain without knowing about node 1's soon-to-be-stale chain
             # Node 2 stays connected, so it hears about the stale blocks and
             # then reorg's when node0 reconnects
             self.disconnect_nodes(0, 1)
             self.disconnect_nodes(0, 2)
             # Mine 24 blocks in node 1
             mine_large_blocks(self.nodes[1], 24)
 
             # Reorg back with 25 block chain from node 0
             mine_large_blocks(self.nodes[0], 25)
 
             # Create connections in the order so both nodes can see the reorg
             # at the same time
             self.connect_nodes(0, 1)
             self.connect_nodes(0, 2)
             self.sync_blocks(self.nodes[0:3])
 
         self.log.info("Usage can be over target because of high stale rate: {}".format(
                       calc_usage(self.prunedir)))
 
     def reorg_test(self):
         # Node 1 will mine a 300 block chain starting 287 blocks back from Node
         # 0 and Node 2's tip. This will cause Node 2 to do a reorg requiring
         # 288 blocks of undo data to the reorg_test chain.
 
         height = self.nodes[1].getblockcount()
         self.log.info("Current block height: {}".format(height))
 
         self.forkheight = height - 287
         self.forkhash = self.nodes[1].getblockhash(self.forkheight)
         self.log.info("Invalidating block {} at height {}".format(
             self.forkhash, self.forkheight))
         self.nodes[1].invalidateblock(self.forkhash)
 
         # We've now switched to our previously mined-24 block fork on node 1, but that's not what we want.
         # So invalidate that fork as well, until we're on the same chain as
         # node 0/2 (but at an ancestor 288 blocks ago)
         mainchainhash = self.nodes[0].getblockhash(self.forkheight - 1)
         curhash = self.nodes[1].getblockhash(self.forkheight - 1)
         while curhash != mainchainhash:
             self.nodes[1].invalidateblock(curhash)
             curhash = self.nodes[1].getblockhash(self.forkheight - 1)
 
         assert self.nodes[1].getblockcount() == self.forkheight - 1
         self.log.info("New best height: {}".format(
                       self.nodes[1].getblockcount()))
 
         # Disconnect node1 and generate the new chain
         self.disconnect_nodes(0, 1)
         self.disconnect_nodes(1, 2)
 
         self.log.info("Generating new longer chain of 300 more blocks")
         self.generate(self.nodes[1], 300, sync_fun=self.no_op)
 
         self.log.info("Reconnect nodes")
         self.connect_nodes(0, 1)
         self.connect_nodes(1, 2)
         self.sync_blocks(self.nodes[0:3], timeout=120)
 
         self.log.info("Verify height on node 2: {}".format(
                       self.nodes[2].getblockcount()))
         self.log.info("Usage possibly still high because of stale blocks in block files: {}".format(
                       calc_usage(self.prunedir)))
 
         self.log.info(
             "Mine 220 more large blocks so we have requisite history")
 
         mine_large_blocks(self.nodes[0], 220)
         self.sync_blocks(self.nodes[0:3], timeout=120)
 
         usage = calc_usage(self.prunedir)
         self.log.info("Usage should be below target: {}".format(usage))
         assert_greater_than(550, usage)
 
     def reorg_back(self):
         # Verify that a block on the old main chain fork has been pruned away
         assert_raises_rpc_error(
             -1, "Block not available (pruned data)", self.nodes[2].getblock, self.forkhash)
         with self.nodes[2].assert_debug_log(expected_msgs=['block verification stopping at height', '(pruning, no data)']):
             self.nodes[2].verifychain(checklevel=4, nblocks=0)
         self.log.info(
             "Will need to redownload block {}".format(self.forkheight))
 
         # Verify that we have enough history to reorg back to the fork point.
         # Although this is more than 288 blocks, because this chain was written
         # more recently and only its other 299 small and 220 large blocks are in
         # the block files after it, it is expected to still be retained.
         self.nodes[2].getblock(self.nodes[2].getblockhash(self.forkheight))
 
         first_reorg_height = self.nodes[2].getblockcount()
         curchainhash = self.nodes[2].getblockhash(self.mainchainheight)
         self.nodes[2].invalidateblock(curchainhash)
         goalbestheight = self.mainchainheight
         goalbesthash = self.mainchainhash2
 
         # As of 0.10 the current block download logic is not able to reorg to
         # the original chain created in create_chain_with_stale_blocks because
         # it doesn't know of any peer that's on that chain from which to
         # redownload its missing blocks. Invalidate the reorg_test chain in
         # node 0 as well, it can successfully switch to the original chain
         # because it has all the block data. However it must mine enough blocks
         # to have a more work chain than the reorg_test chain in order to
         # trigger node 2's block download logic. At this point node 2 is within
         # 288 blocks of the fork point so it will preserve its ability to
         # reorg.
         if self.nodes[2].getblockcount() < self.mainchainheight:
             blocks_to_mine = first_reorg_height + 1 - self.mainchainheight
             self.log.info(
                 "Rewind node 0 to prev main chain to mine longer chain to trigger redownload. Blocks needed: {}".format(
                     blocks_to_mine))
             self.nodes[0].invalidateblock(curchainhash)
             assert_equal(self.nodes[0].getblockcount(), self.mainchainheight)
             assert_equal(self.nodes[0].getbestblockhash(), self.mainchainhash2)
             goalbesthash = self.generate(
                 self.nodes[0], blocks_to_mine, sync_fun=self.no_op)[-1]
             goalbestheight = first_reorg_height + 1
 
         self.log.info(
             "Verify node 2 reorged back to the main chain, some blocks of which it had to redownload")
         # Wait for Node 2 to reorg to proper height
         self.wait_until(lambda: self.nodes[2].getblockcount() >= goalbestheight,
                         timeout=900)
         assert_equal(self.nodes[2].getbestblockhash(), goalbesthash)
         # Verify we can now have the data for a block previously pruned
         assert_equal(self.nodes[2].getblock(
             self.forkhash)["height"], self.forkheight)
 
     def manual_test(self, node_number, use_timestamp):
         # at this point, node has 995 blocks and has not yet run in prune mode
         self.start_node(node_number)
         node = self.nodes[node_number]
         assert_equal(node.getblockcount(), 995)
         assert_raises_rpc_error(-1, "not in prune mode",
                                 node.pruneblockchain, 500)
 
         # now re-start in manual pruning mode
         self.restart_node(node_number, extra_args=["-prune=1"])
         node = self.nodes[node_number]
         assert_equal(node.getblockcount(), 995)
 
         def height(index):
             if use_timestamp:
                 return node.getblockheader(node.getblockhash(index))[
                     "time"] + TIMESTAMP_WINDOW
             else:
                 return index
 
         def prune(index):
             ret = node.pruneblockchain(height=height(index))
             assert_equal(ret, node.getblockchaininfo()['pruneheight'])
 
         def has_block(index):
             return os.path.isfile(os.path.join(
                 self.nodes[node_number].datadir, self.chain, "blocks", "blk{:05}.dat".format(index)))
 
         # should not prune because chain tip of node 3 (995) < PruneAfterHeight
         # (1000)
         assert_raises_rpc_error(
             -1, "Blockchain is too short for pruning", node.pruneblockchain, height(500))
 
         # Save block transaction count before pruning, assert value
         block1_details = node.getblock(node.getblockhash(1))
         assert_equal(block1_details["nTx"], len(block1_details["tx"]))
 
         # mine 6 blocks so we are at height 1001 (i.e., above PruneAfterHeight)
         self.generate(node, 6, sync_fun=self.no_op)
         assert_equal(node.getblockchaininfo()["blocks"], 1001)
 
         # Pruned block should still know the number of transactions
         assert_equal(node.getblockheader(node.getblockhash(1))
                      ["nTx"], block1_details["nTx"])
 
         # negative heights should raise an exception
         assert_raises_rpc_error(-8, "Negative", node.pruneblockchain, -10)
 
         # height=100 too low to prune first block file so this is a no-op
         prune(100)
         assert has_block(
             0), "blk00000.dat is missing when should still be there"
 
         # Does nothing
         node.pruneblockchain(height(0))
         assert has_block(
             0), "blk00000.dat is missing when should still be there"
 
         # height=500 should prune first file
         prune(500)
         assert not has_block(
             0), "blk00000.dat is still there, should be pruned by now"
         assert has_block(
             1), "blk00001.dat is missing when should still be there"
 
         # height=650 should prune second file
         prune(650)
         assert not has_block(
             1), "blk00001.dat is still there, should be pruned by now"
 
         # height=1000 should not prune anything more, because tip-288 is in
         # blk00002.dat.
         prune(1000)
         assert has_block(
             2), "blk00002.dat is still there, should be pruned by now"
 
         # advance the tip so blk00002.dat and blk00003.dat can be pruned (the
         # last 288 blocks should now be in blk00004.dat)
         self.generate(node, 288, sync_fun=self.no_op)
         prune(1000)
         assert not has_block(
             2), "blk00002.dat is still there, should be pruned by now"
         assert not has_block(
             3), "blk00003.dat is still there, should be pruned by now"
 
         # stop node, start back up with auto-prune at 550 MiB, make sure still
         # runs
         self.restart_node(node_number, extra_args=["-prune=550"])
 
         self.log.info("Success")
 
     def wallet_test(self):
         # check that the pruning node's wallet is still in good shape
         self.log.info("Stop and start pruning node to trigger wallet rescan")
         self.restart_node(
-            2, extra_args=["-prune=550", "-noparkdeepreorg", "-maxreorgdepth=-1"])
+            2, extra_args=["-prune=550", "-noparkdeepreorg"])
         self.log.info("Success")
 
         # check that wallet loads successfully when restarting a pruned node after IBD.
         # this was reported to fail in #7494.
         self.log.info("Syncing node 5 to test wallet")
         self.connect_nodes(0, 5)
         nds = [self.nodes[0], self.nodes[5]]
         self.sync_blocks(nds, wait=5, timeout=300)
         self.restart_node(
-            5, extra_args=["-prune=550", "-noparkdeepreorg", "-maxreorgdepth=-1"])
+            5, extra_args=["-prune=550", "-noparkdeepreorg"])
         self.log.info("Success")
 
     def run_test(self):
         self.log.info("Warning! This test requires 4GB of disk space")
 
         self.log.info("Mining a big blockchain of 995 blocks")
         self.create_big_chain()
         # Chain diagram key:
         # *   blocks on main chain
         # +,&,$,@ blocks on other forks
         # X   invalidated block
         # N1  Node 1
         #
         # Start by mining a simple chain that all nodes have
         # N0=N1=N2 **...*(995)
 
         # stop manual-pruning node with 995 blocks
         self.stop_node(3)
         self.stop_node(4)
 
         self.log.info(
             "Check that we haven't started pruning yet because we're below PruneAfterHeight")
         self.test_height_min()
         # Extend this chain past the PruneAfterHeight
         # N0=N1=N2 **...*(1020)
 
         self.log.info(
             "Check that we'll exceed disk space target if we have a very high stale block rate")
         self.create_chain_with_staleblocks()
         # Disconnect N0
         # And mine a 24 block chain on N1 and a separate 25 block chain on N0
         # N1=N2 **...*+...+(1044)
         # N0    **...**...**(1045)
         #
         # reconnect nodes causing reorg on N1 and N2
         # N1=N2 **...*(1020) *...**(1045)
         #                   \
         #                    +...+(1044)
         #
         # repeat this process until you have 12 stale forks hanging off the
         # main chain on N1 and N2
         # N0    *************************...***************************(1320)
         #
         # N1=N2 **...*(1020) *...**(1045) *..         ..**(1295) *...**(1320)
         #                   \            \                      \
         #                    +...+(1044)  &..                    $...$(1319)
 
         # Save some current chain state for later use
         self.mainchainheight = self.nodes[2].getblockcount()  # 1320
         self.mainchainhash2 = self.nodes[2].getblockhash(self.mainchainheight)
 
         self.log.info("Check that we can survive a 288 block reorg still")
         self.reorg_test()  # (1033, )
         # Now create a 288 block reorg by mining a longer chain on N1
         # First disconnect N1
         # Then invalidate 1033 on main chain and 1032 on fork so height is 1032 on main chain
         # N1   **...*(1020) **...**(1032)X..
         #                  \
         #                   ++...+(1031)X..
         #
         # Now mine 300 more blocks on N1
         # N1    **...*(1020) **...**(1032) @@...@(1332)
         #                 \               \
         #                  \               X...
         #                   \                 \
         #                    ++...+(1031)X..   ..
         #
         # Reconnect nodes and mine 220 more blocks on N1
         # N1    **...*(1020) **...**(1032) @@...@@@(1552)
         #                 \               \
         #                  \               X...
         #                   \                 \
         #                    ++...+(1031)X..   ..
         #
         # N2    **...*(1020) **...**(1032) @@...@@@(1552)
         #                 \               \
         #                  \               *...**(1320)
         #                   \                 \
         #                    ++...++(1044)     ..
         #
         # N0    ********************(1032) @@...@@@(1552)
         #                                 \
         #                                  *...**(1320)
 
         self.log.info(
             "Test that we can rerequest a block we previously pruned if needed for a reorg")
         self.reorg_back()
         # Verify that N2 still has block 1033 on current chain (@), but not on main chain (*)
         # Invalidate 1033 on current chain (@) on N2 and we should be able to reorg to
         # original main chain (*), but will require redownload of some blocks
         # In order to have a peer we think we can download from, must also perform this invalidation
         # on N0 and mine a new longest chain to trigger.
         # Final result:
         # N0    ********************(1032) **...****(1553)
         #                                 \
         #                                  X@...@@@(1552)
         #
         # N2    **...*(1020) **...**(1032) **...****(1553)
         #                 \               \
         #                  \               X@...@@@(1552)
         #                   \
         #                    +..
         #
         # N1 doesn't change because 1033 on main chain (*) is invalid
 
         self.log.info("Test manual pruning with block indices")
         self.manual_test(3, use_timestamp=False)
 
         self.log.info("Test manual pruning with timestamps")
         self.manual_test(4, use_timestamp=True)
 
         self.log.info("Test wallet re-scan")
         self.wallet_test()
 
         self.log.info("Done")
 
 
 if __name__ == '__main__':
     PruneTest().main()
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index 56329773e..f63fcb378 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -1,931 +1,931 @@
 #!/usr/bin/env python3
 # Copyright (c) 2014-2019 The Bitcoin Core developers
 # Copyright (c) 2017 The Bitcoin developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Run regression test suite.
 
 This module calls down into individual test cases via subprocess. It will
 forward all unrecognized arguments onto the individual test scripts.
 
 For a description of arguments recognized by test scripts, see
 `test/functional/test_framework/test_framework.py:BitcoinTestFramework.main`.
 
 """
 
 import argparse
 import configparser
 import datetime
 import json
 import logging
 import multiprocessing
 import os
 import re
 import shutil
 import subprocess
 import sys
 import tempfile
 import threading
 import time
 import unittest
 import xml.etree.ElementTree as ET
 from collections import deque
 from queue import Empty, Queue
 
 # Formatting. Default colors to empty strings.
 BOLD, GREEN, RED, GREY = ("", ""), ("", ""), ("", ""), ("", "")
 try:
     # Make sure python thinks it can write unicode to its stdout
     "\u2713".encode("utf_8").decode(sys.stdout.encoding)
     TICK = "✓ "
     CROSS = "✖ "
     CIRCLE = "○ "
 except UnicodeDecodeError:
     TICK = "P "
     CROSS = "x "
     CIRCLE = "o "
 
 if os.name != 'nt' or sys.getwindowsversion() >= (10, 0, 14393):  # type: ignore
     if os.name == 'nt':
         import ctypes
         kernel32 = ctypes.windll.kernel32  # type: ignore
         ENABLE_VIRTUAL_TERMINAL_PROCESSING = 4
         STD_OUTPUT_HANDLE = -11
         STD_ERROR_HANDLE = -12
         # Enable ascii color control to stdout
         stdout = kernel32.GetStdHandle(STD_OUTPUT_HANDLE)
         stdout_mode = ctypes.c_int32()
         kernel32.GetConsoleMode(stdout, ctypes.byref(stdout_mode))
         kernel32.SetConsoleMode(
             stdout, stdout_mode.value | ENABLE_VIRTUAL_TERMINAL_PROCESSING)
         # Enable ascii color control to stderr
         stderr = kernel32.GetStdHandle(STD_ERROR_HANDLE)
         stderr_mode = ctypes.c_int32()
         kernel32.GetConsoleMode(stderr, ctypes.byref(stderr_mode))
         kernel32.SetConsoleMode(
             stderr, stderr_mode.value | ENABLE_VIRTUAL_TERMINAL_PROCESSING)
     # primitive formatting on supported
     # terminal via ANSI escape sequences:
     BOLD = ('\033[0m', '\033[1m')
     GREEN = ('\033[0m', '\033[0;32m')
     RED = ('\033[0m', '\033[0;31m')
     GREY = ('\033[0m', '\033[1;30m')
 
 TEST_EXIT_PASSED = 0
 TEST_EXIT_SKIPPED = 77
 
 TEST_FRAMEWORK_MODULES = [
     "address",
     "blocktools",
     "messages",
     "muhash",
     "script",
     "txtools",
     "util",
 ]
 
 NON_SCRIPTS = [
     # These are python files that live in the functional tests directory, but
     # are not test scripts.
     "combine_logs.py",
     "create_cache.py",
     "test_runner.py",
 ]
 
 EXTRA_PRIVILEGES_TESTS = [
     # These tests can only run with extra privileges.
     # They need to be excluded from the timing file because they are not
     # designed to run in the same context as the other tests.
     "interface_usdt_net.py",
     "interface_usdt_utxocache.py",
     "interface_usdt_validation.py",
 ]
 
 TEST_PARAMS = {
     # Some test can be run with additional parameters.
     # When a test is listed here, then it will be run without parameter as well
     # as with additional parameters listed here.
     # This:
     #    example "testName" : [["--param1", "--param2"] , ["--param3"]]
     # will run the test 3 times:
     #    testName
     #    testName --param1 --param2
     #    testname --param3
     "rpc_bind.py": [["--ipv4"], ["--ipv6"], ["--nonloopback"]],
     "rpc_createmultisig.py": [["--descriptors"]],
     "rpc_deriveaddresses.py": [["--usecli"]],
     "rpc_fundrawtransaction.py": [["--descriptors"]],
     "rpc_rawtransaction.py": [["--descriptors"]],
     "rpc_signrawtransaction.py": [["--descriptors"]],
     # FIXME: "rpc_psbt.py": [["--descriptors"]],
     "wallet_address_types.py": [["--descriptors"]],
     "tool_wallet.py": [["--descriptors"]],
     "wallet_avoidreuse.py": [["--descriptors"]],
     "wallet_balance.py": [["--descriptors"]],
     # FIXME: "wallet_basic.py": [["--descriptors"]],
     "wallet_createwallet.py": [["--usecli"], ["--descriptors"]],
     "wallet_encryption.py": [["--descriptors"]],
     "wallet_hd.py": [["--descriptors"]],
     "wallet_importprunedfunds.py": [["--descriptors"]],
     # FIXME: "wallet_keypool.py": [["--descriptors"]],
     "wallet_keypool_topup.py": [["--descriptors"]],
     "wallet_labels.py": [["--descriptors"]],
     "wallet_listsinceblock.py": [["--descriptors"]],
     "wallet_listtransactions.py": [["--descriptors"]],
     "wallet_multiwallet.py": [["--usecli"]],
     "wallet_txn_doublespend.py": [["--mineblock"]],
     "wallet_txn_clone.py": [["--mineblock"]],
     "wallet_watchonly.py": [["--usecli"]],
 }
 
 # Used to limit the number of tests, when list of tests is not provided on command line
 # When --extended is specified, we run all tests, otherwise
 # we only run a test if its execution time in seconds does not exceed
 # EXTENDED_CUTOFF
 DEFAULT_EXTENDED_CUTOFF = 40
 DEFAULT_JOBS = (multiprocessing.cpu_count() // 3) + 1
 
 
 class TestCase:
     """
     Data structure to hold and run information necessary to launch a test case.
     """
 
     def __init__(self, test_num, test_case, tests_dir,
                  tmpdir, failfast_event, flags=None):
         self.tests_dir = tests_dir
         self.tmpdir = tmpdir
         self.test_case = test_case
         self.test_num = test_num
         self.failfast_event = failfast_event
         self.flags = flags
 
     def run(self):
         if self.failfast_event.is_set():
             return TestResult(self.test_num, self.test_case,
                               "", "Skipped", 0, "", "")
 
         portseed = self.test_num
         portseed_arg = ["--portseed={}".format(portseed)]
         log_stdout = tempfile.SpooledTemporaryFile(max_size=2**16)
         log_stderr = tempfile.SpooledTemporaryFile(max_size=2**16)
         test_argv = self.test_case.split()
         testdir = os.path.join("{}", "{}_{}").format(
             self.tmpdir, re.sub(".py$", "", test_argv[0]), portseed)
         tmpdir_arg = ["--tmpdir={}".format(testdir)]
         start_time = time.time()
         process = subprocess.Popen([sys.executable, os.path.join(self.tests_dir, test_argv[0])] + test_argv[1:] + self.flags + portseed_arg + tmpdir_arg,
                                    universal_newlines=True,
                                    stdout=log_stdout,
                                    stderr=log_stderr)
 
         process.wait()
         log_stdout.seek(0), log_stderr.seek(0)
         [stdout, stderr] = [log.read().decode('utf-8')
                             for log in (log_stdout, log_stderr)]
         log_stdout.close(), log_stderr.close()
         if process.returncode == TEST_EXIT_PASSED and stderr == "":
             status = "Passed"
         elif process.returncode == TEST_EXIT_SKIPPED:
             status = "Skipped"
         else:
             status = "Failed"
 
         return TestResult(self.test_num, self.test_case, testdir, status,
                           time.time() - start_time, stdout, stderr)
 
 
 def on_ci():
     return os.getenv('TRAVIS') == 'true' or os.getenv(
         'TEAMCITY_VERSION') is not None
 
 
 def main():
     # Read config generated by configure.
     config = configparser.ConfigParser()
     configfile = os.path.join(os.path.abspath(
         os.path.dirname(__file__)), "..", "config.ini")
     config.read_file(open(configfile, encoding="utf8"))
 
     src_dir = config["environment"]["SRCDIR"]
     build_dir = config["environment"]["BUILDDIR"]
     tests_dir = os.path.join(src_dir, 'test', 'functional')
 
     # SRCDIR must be set for cdefs.py to find and parse consensus.h
     os.environ["SRCDIR"] = src_dir
 
     # Parse arguments and pass through unrecognised args
     parser = argparse.ArgumentParser(add_help=False,
                                      usage='%(prog)s [test_runner.py options] [script options] [scripts]',
                                      description=__doc__,
                                      epilog='''
     Help text and arguments for individual test script:''',
                                      formatter_class=argparse.ArgumentDefaultsHelpFormatter)
     parser.add_argument('--combinedlogslen', '-c', type=int, default=0, metavar='n',
                         help='On failure, print a log (of length n lines) to '
                              'the console, combined from the test framework '
                              'and all test nodes.')
     parser.add_argument('--coverage', action='store_true',
                         help='generate a basic coverage report for the RPC interface')
     parser.add_argument(
         '--exclude', '-x', help='specify a comma-separated-list of scripts to exclude.')
     parser.add_argument('--extended', action='store_true',
                         help='run the extended test suite in addition to the basic tests')
     parser.add_argument('--cutoff', type=int, default=DEFAULT_EXTENDED_CUTOFF,
                         help='set the cutoff runtime for what tests get run')
     parser.add_argument('--help', '-h', '-?',
                         action='store_true', help='print help text and exit')
     parser.add_argument('--jobs', '-j', type=int, default=DEFAULT_JOBS,
                         help='how many test scripts to run in parallel.')
     parser.add_argument('--keepcache', '-k', action='store_true',
                         help='the default behavior is to flush the cache directory on startup. --keepcache retains the cache from the previous testrun.')
     parser.add_argument('--quiet', '-q', action='store_true',
                         help='only print results summary and failure logs')
     parser.add_argument('--tmpdirprefix', '-t',
                         default=os.path.join(build_dir, 'test', 'tmp'), help="Root directory for datadirs")
     parser.add_argument(
         '--failfast',
         action='store_true',
         help='stop execution after the first test failure')
     parser.add_argument('--junitoutput', '-J',
                         help="File that will store JUnit formatted test results. If no absolute path is given it is treated as relative to the temporary directory.")
     parser.add_argument('--testsuitename', '-n', default='Bitcoin ABC functional tests',
                         help="Name of the test suite, as it will appear in the logs and in the JUnit report.")
     args, unknown_args = parser.parse_known_args()
 
     # args to be passed on always start with two dashes; tests are the
     # remaining unknown args
     tests = [arg for arg in unknown_args if arg[:2] != "--"]
     passon_args = [arg for arg in unknown_args if arg[:2] == "--"]
     passon_args.append("--configfile={}".format(configfile))
 
     # Set up logging
     logging_level = logging.INFO if args.quiet else logging.DEBUG
     logging.basicConfig(format='%(message)s', level=logging_level)
     logging.info("Starting {}".format(args.testsuitename))
 
     # Create base test directory
     tmpdir = os.path.join("{}", "test_runner_₿₵_🏃_{:%Y%m%d_%H%M%S}").format(
         args.tmpdirprefix, datetime.datetime.now())
 
     os.makedirs(tmpdir)
 
     logging.debug("Temporary test directory at {}".format(tmpdir))
 
     if args.junitoutput and not os.path.isabs(args.junitoutput):
         args.junitoutput = os.path.join(tmpdir, args.junitoutput)
 
     enable_bitcoind = config["components"].getboolean("ENABLE_BITCOIND")
 
     if not enable_bitcoind:
         print("No functional tests to run.")
         print("Rerun ./configure with --with-daemon and then make")
         sys.exit(0)
 
     # Build list of tests
     all_scripts = get_all_scripts_from_disk(tests_dir, NON_SCRIPTS)
 
     # Check all tests with parameters actually exist
     for test in TEST_PARAMS:
         if test not in all_scripts:
             print("ERROR: Test with parameter {} does not exist, check it has "
                   "not been renamed or deleted".format(test))
             sys.exit(1)
 
     if tests:
         # Individual tests have been specified. Run specified tests that exist
         # in the all_scripts list. Accept the name with or without .py
         # extension.
         individual_tests = [
             re.sub(r"\.py$", "", test) + ".py" for test in tests if not test.endswith('*')]
         test_list = []
         for test in individual_tests:
             if test in all_scripts:
                 test_list.append(test)
             else:
                 print("{}WARNING!{} Test '{}' not found in full test list.".format(
                     BOLD[1], BOLD[0], test))
 
         # Allow for wildcard at the end of the name, so a single input can
         # match multiple tests
         for test in tests:
             if test.endswith('*'):
                 test_list.extend(
                     [t for t in all_scripts if t.startswith(test[:-1])])
 
         # do not cut off explicitly specified tests
         cutoff = sys.maxsize
     else:
         # Run base tests only
         test_list = all_scripts
         cutoff = sys.maxsize if args.extended else args.cutoff
 
     # Remove the test cases that the user has explicitly asked to exclude.
     if args.exclude:
         exclude_tests = [re.sub(r"\.py$", "", test)
                          + (".py" if ".py" not in test else "") for test in args.exclude.split(',')]
         for exclude_test in exclude_tests:
             if exclude_test in test_list:
                 test_list.remove(exclude_test)
             else:
                 print("{}WARNING!{} Test '{}' not found in current test list.".format(
                     BOLD[1], BOLD[0], exclude_test))
 
     # Update timings from build_dir only if separate build directory is used.
     # We do not want to pollute source directory.
     build_timings = None
     if (src_dir != build_dir):
         build_timings = Timings(os.path.join(build_dir, 'timing.json'))
 
     # Always use timings from src_dir if present
     src_timings = Timings(os.path.join(
         src_dir, "test", "functional", 'timing.json'))
 
     # Add test parameters and remove long running tests if needed
     test_list = get_tests_to_run(
         test_list, TEST_PARAMS, cutoff, src_timings)
 
     if not test_list:
         print("No valid test scripts specified. Check that your test is in one "
               "of the test lists in test_runner.py, or run test_runner.py with no arguments to run all tests")
         sys.exit(0)
 
     if args.help:
         # Print help for test_runner.py, then print help of the first script
         # and exit.
         parser.print_help()
         subprocess.check_call(
             [sys.executable, os.path.join(tests_dir, test_list[0]), '-h'])
         sys.exit(0)
 
     check_script_prefixes(all_scripts)
 
     if not args.keepcache:
         shutil.rmtree(os.path.join(build_dir, "test",
                                    "cache"), ignore_errors=True)
 
     run_tests(
         test_list,
         build_dir,
         tests_dir,
         args.junitoutput,
         tmpdir,
         num_jobs=args.jobs,
         test_suite_name=args.testsuitename,
         enable_coverage=args.coverage,
         args=passon_args,
         combined_logs_len=args.combinedlogslen,
         build_timings=build_timings,
         failfast=args.failfast
     )
 
 
 def run_tests(test_list, build_dir, tests_dir, junitoutput, tmpdir, num_jobs, test_suite_name,
               enable_coverage=False, args=None, combined_logs_len=0, build_timings=None, failfast=False):
     args = args or []
 
     # Warn if bitcoind is already running
     try:
         # pgrep exits with code zero when one or more matching processes found
         if subprocess.run(["pgrep", "-x", "bitcoind"],
                           stdout=subprocess.DEVNULL).returncode == 0:
             print("{}WARNING!{} There is already a bitcoind process running on this system. Tests may fail unexpectedly due to resource contention!".format(
                 BOLD[1], BOLD[0]))
     except OSError:
         # pgrep not supported
         pass
 
     # Warn if there is a cache directory
     cache_dir = os.path.join(build_dir, "test", "cache")
     if os.path.isdir(cache_dir):
         print("{}WARNING!{} There is a cache directory here: {}. If tests fail unexpectedly, try deleting the cache directory.".format(
             BOLD[1], BOLD[0], cache_dir))
 
     # Test Framework Tests
     print("Running Unit Tests for Test Framework Modules")
     test_framework_tests = unittest.TestSuite()
     for module in TEST_FRAMEWORK_MODULES:
         test_framework_tests.addTest(
             unittest.TestLoader().loadTestsFromName(
                 "test_framework.{}".format(module)))
     result = unittest.TextTestRunner(
         verbosity=1, failfast=True).run(test_framework_tests)
     if not result.wasSuccessful():
         logging.debug(
             "Early exiting after failure in TestFramework unit tests")
         sys.exit(False)
 
     flags = ['--cachedir={}'.format(cache_dir)] + args
 
     if enable_coverage:
         coverage = RPCCoverage()
         flags.append(coverage.flag)
         logging.debug(
             "Initializing coverage directory at {}".format(coverage.dir))
     else:
         coverage = None
 
     if len(test_list) > 1 and num_jobs > 1:
         # Populate cache
         try:
             subprocess.check_output([sys.executable, os.path.join(
                 tests_dir, 'create_cache.py')] + flags + [os.path.join("--tmpdir={}", "cache") .format(tmpdir)])
         except subprocess.CalledProcessError as e:
             sys.stdout.buffer.write(e.output)
             raise
 
     # Run Tests
     start_time = time.time()
     test_results = execute_test_processes(
         num_jobs, test_list, tests_dir, tmpdir, flags, failfast)
     runtime = time.time() - start_time
 
     max_len_name = len(max(test_list, key=len))
     print_results(test_results, tests_dir, max_len_name,
                   runtime, combined_logs_len)
 
     if junitoutput is not None:
         save_results_as_junit(
             test_results,
             junitoutput,
             runtime,
             test_suite_name)
 
     if (build_timings is not None):
         build_timings.save_timings(test_results)
 
     if coverage:
         coverage_passed = coverage.report_rpc_coverage()
 
         logging.debug("Cleaning up coverage data")
         coverage.cleanup()
     else:
         coverage_passed = True
 
     # Clear up the temp directory if all subdirectories are gone
     if not os.listdir(tmpdir):
         os.rmdir(tmpdir)
 
     all_passed = all(map(
         lambda test_result: test_result.was_successful, test_results)) and coverage_passed
 
     sys.exit(not all_passed)
 
 
 def execute_test_processes(
         num_jobs, test_list, tests_dir, tmpdir, flags, failfast=False):
     update_queue = Queue()
     job_queue = Queue()
     failfast_event = threading.Event()
     test_results = []
     poll_timeout = 10  # seconds
 
     ##
     # Define some helper functions we will need for threading.
     ##
 
     def handle_message(message, running_jobs):
         """
         handle_message handles a single message from handle_test_cases
         """
         if isinstance(message, TestCase):
             running_jobs.append((message.test_num, message.test_case))
             print("{}{}{} started".format(BOLD[1], message.test_case, BOLD[0]))
             return
 
         if isinstance(message, TestResult):
             test_result = message
 
             running_jobs.remove((test_result.num, test_result.name))
             test_results.append(test_result)
 
             if test_result.status == "Passed":
                 print("{}{}{} passed, Duration: {} s".format(
                     BOLD[1], test_result.name, BOLD[0], TimeResolution.seconds(test_result.time)))
             elif test_result.status == "Skipped":
                 print("{}{}{} skipped".format(
                     BOLD[1], test_result.name, BOLD[0]))
             else:
                 print("{}{}{} failed, Duration: {} s\n".format(
                     BOLD[1], test_result.name, BOLD[0], TimeResolution.seconds(test_result.time)))
                 print(BOLD[1] + 'stdout:' + BOLD[0])
                 print(test_result.stdout)
                 print(BOLD[1] + 'stderr:' + BOLD[0])
                 print(test_result.stderr)
 
                 if failfast:
                     logging.debug("Early exiting after test failure")
                     failfast_event.set()
             return
 
         assert False, "we should not be here"
 
     def handle_update_messages():
         """
         handle_update_messages waits for messages to be sent from handle_test_cases via the
         update_queue.  It serializes the results so we can print nice status update messages.
         """
         printed_status = False
         running_jobs = []
 
         while True:
             message = None
             try:
                 message = update_queue.get(True, poll_timeout)
                 if message is None:
                     break
 
                 # We printed a status message, need to kick to the next line
                 # before printing more.
                 if printed_status:
                     print()
                     printed_status = False
 
                 handle_message(message, running_jobs)
                 update_queue.task_done()
             except Empty:
                 if not on_ci():
                     print("Running jobs: {}".format(
                         ", ".join([j[1] for j in running_jobs])), end="\r")
                     sys.stdout.flush()
                     printed_status = True
 
     def handle_test_cases():
         """
         job_runner represents a single thread that is part of a worker pool.
         It waits for a test, then executes that test.
         It also reports start and result messages to handle_update_messages
         """
         while True:
             test = job_queue.get()
             if test is None:
                 break
             # Signal that the test is starting to inform the poor waiting
             # programmer
             update_queue.put(test)
             result = test.run()
             update_queue.put(result)
             job_queue.task_done()
 
     ##
     # Setup our threads, and start sending tasks
     ##
 
     # Start our result collection thread.
     resultCollector = threading.Thread(target=handle_update_messages)
     resultCollector.daemon = True
     resultCollector.start()
 
     # Start some worker threads
     for _ in range(num_jobs):
         t = threading.Thread(target=handle_test_cases)
         t.daemon = True
         t.start()
 
     # Push all our test cases into the job queue.
     for i, t in enumerate(test_list):
         job_queue.put(TestCase(i, t, tests_dir, tmpdir, failfast_event, flags))
 
     # Wait for all the jobs to be completed
     job_queue.join()
 
     # Wait for all the results to be compiled
     update_queue.join()
 
     # Flush our queues so the threads exit
     update_queue.put(None)
     for _ in range(num_jobs):
         job_queue.put(None)
 
     return test_results
 
 
 def print_results(test_results, tests_dir, max_len_name,
                   runtime, combined_logs_len):
     results = "\n" + BOLD[1] + "{} | {} | {}\n\n".format(
         "TEST".ljust(max_len_name), "STATUS   ", "DURATION") + BOLD[0]
 
     test_results.sort(key=TestResult.sort_key)
     all_passed = True
     time_sum = 0
 
     for test_result in test_results:
         all_passed = all_passed and test_result.was_successful
         time_sum += test_result.time
         test_result.padding = max_len_name
         results += str(test_result)
 
         testdir = test_result.testdir
         if combined_logs_len and os.path.isdir(testdir):
             # Print the final `combinedlogslen` lines of the combined logs
             print('{}Combine the logs and print the last {} lines ...{}'.format(
                 BOLD[1], combined_logs_len, BOLD[0]))
             print('\n============')
             print('{}Combined log for {}:{}'.format(BOLD[1], testdir, BOLD[0]))
             print('============\n')
             combined_logs_args = [
                 sys.executable, os.path.join(
                     tests_dir, 'combine_logs.py'), testdir]
 
             if BOLD[0]:
                 combined_logs_args += ['--color']
                 combined_logs, _ = subprocess.Popen(
                     combined_logs_args, universal_newlines=True, stdout=subprocess.PIPE).communicate()
             print(
                 "\n".join(
                     deque(
                         combined_logs.splitlines(),
                         combined_logs_len)))
 
     status = TICK + "Passed" if all_passed else CROSS + "Failed"
     if not all_passed:
         results += RED[1]
     results += BOLD[1] + "\n{} | {} | {} s (accumulated) \n".format(
         "ALL".ljust(max_len_name), status.ljust(9), TimeResolution.seconds(time_sum)) + BOLD[0]
     if not all_passed:
         results += RED[0]
     results += "Runtime: {} s\n".format(TimeResolution.seconds(runtime))
     print(results)
 
 
 class TestResult:
     """
     Simple data structure to store test result values and print them properly
     """
 
     def __init__(self, num, name, testdir, status, time, stdout, stderr):
         self.num = num
         self.name = name
         self.testdir = testdir
         self.status = status
         self.time = time
         self.padding = 0
         self.stdout = stdout
         self.stderr = stderr
 
     def sort_key(self):
         if self.status == "Passed":
             return 0, self.name.lower()
         elif self.status == "Failed":
             return 2, self.name.lower()
         elif self.status == "Skipped":
             return 1, self.name.lower()
 
     def __repr__(self):
         if self.status == "Passed":
             color = GREEN
             glyph = TICK
         elif self.status == "Failed":
             color = RED
             glyph = CROSS
         elif self.status == "Skipped":
             color = GREY
             glyph = CIRCLE
 
         return color[1] + "{} | {}{} | {} s\n".format(
             self.name.ljust(self.padding), glyph, self.status.ljust(7), TimeResolution.seconds(self.time)) + color[0]
 
     @property
     def was_successful(self):
         return self.status != "Failed"
 
 
 def get_all_scripts_from_disk(test_dir, non_scripts):
     """
     Return all available test script from script directory (excluding NON_SCRIPTS)
     """
     python_files = set([t for t in os.listdir(test_dir) if t[-3:] == ".py"])
     return list(python_files - set(non_scripts))
 
 
 def check_script_prefixes(all_scripts):
     """Check that no more than `EXPECTED_VIOLATION_COUNT` of the
        test scripts don't start with one of the allowed name prefixes."""
-    EXPECTED_VIOLATION_COUNT = 16
+    EXPECTED_VIOLATION_COUNT = 15
 
     # LEEWAY is provided as a transition measure, so that pull-requests
     # that introduce new tests that don't conform with the naming
     # convention don't immediately cause the tests to fail.
     LEEWAY = 0
 
     good_prefixes_re = re.compile(
         "(abc_)?(example|feature|interface|mempool|mining|p2p|rpc|wallet|tool|chronik)_")
     bad_script_names = [
         script for script in all_scripts if good_prefixes_re.match(script) is None]
 
     if len(bad_script_names) < EXPECTED_VIOLATION_COUNT:
         print(
             "{}HURRAY!{} Number of functional tests violating naming convention reduced!".format(
                 BOLD[1],
                 BOLD[0]))
         print("Consider reducing EXPECTED_VIOLATION_COUNT from {} to {}".format(
             EXPECTED_VIOLATION_COUNT, len(bad_script_names)))
     elif len(bad_script_names) > EXPECTED_VIOLATION_COUNT:
         print(
             "INFO: {} tests not meeting naming conventions (expected {}):".format(len(bad_script_names), EXPECTED_VIOLATION_COUNT))
         print("  {}".format("\n  ".join(sorted(bad_script_names))))
         assert len(bad_script_names) <= EXPECTED_VIOLATION_COUNT + \
             LEEWAY, "Too many tests not following naming convention! ({} found, expected: <= {})".format(
                 len(bad_script_names), EXPECTED_VIOLATION_COUNT)
 
 
 def get_tests_to_run(test_list, test_params, cutoff, src_timings):
     """
     Returns only test that will not run longer that cutoff.
     Long running tests are returned first to favor running tests in parallel
     Timings from build directory override those from src directory
     """
 
     def get_test_time(test):
         # Return 0 if test is unknown to always run it
         return next(
             (x['time'] for x in src_timings.existing_timings if x['name'] == test), 0)
 
     # Some tests must also be run with additional parameters. Add them to the
     # list.
     tests_with_params = []
     for test_name in test_list:
         # always execute a test without parameters
         tests_with_params.append(test_name)
         params = test_params.get(test_name)
         if params is not None:
             tests_with_params.extend(
                 [test_name + " " + " ".join(parameter) for parameter in params])
 
     result = [
         test for test in tests_with_params if get_test_time(test) <= cutoff]
     result.sort(key=lambda x: (-get_test_time(x), x))
     return result
 
 
 class RPCCoverage:
     """
     Coverage reporting utilities for test_runner.
 
     Coverage calculation works by having each test script subprocess write
     coverage files into a particular directory. These files contain the RPC
     commands invoked during testing, as well as a complete listing of RPC
     commands per `bitcoin-cli help` (`rpc_interface.txt`).
 
     After all tests complete, the commands run are combined and diff'd against
     the complete list to calculate uncovered RPC commands.
 
     See also: test/functional/test_framework/coverage.py
 
     """
 
     def __init__(self):
         self.dir = tempfile.mkdtemp(prefix="coverage")
         self.flag = '--coveragedir={}'.format(self.dir)
 
     def report_rpc_coverage(self):
         """
         Print out RPC commands that were unexercised by tests.
 
         """
         uncovered = self._get_uncovered_rpc_commands()
 
         if uncovered:
             print("Uncovered RPC commands:")
             print("".join(("  - {}\n".format(i)) for i in sorted(uncovered)))
             return False
         else:
             print("All RPC commands covered.")
             return True
 
     def cleanup(self):
         return shutil.rmtree(self.dir)
 
     def _get_uncovered_rpc_commands(self):
         """
         Return a set of currently untested RPC commands.
 
         """
         # This is shared from `test/functional/test_framework/coverage.py`
         reference_filename = 'rpc_interface.txt'
         coverage_file_prefix = 'coverage.'
 
         coverage_ref_filename = os.path.join(self.dir, reference_filename)
         coverage_filenames = set()
         all_cmds = set()
         # Consider RPC generate covered, because it is overloaded in
         # test_framework/test_node.py and not seen by the coverage check.
         covered_cmds = set({'generate'})
 
         if not os.path.isfile(coverage_ref_filename):
             raise RuntimeError("No coverage reference found")
 
         with open(coverage_ref_filename, 'r', encoding="utf8") as file:
             all_cmds.update([line.strip() for line in file.readlines()])
 
         for root, _, files in os.walk(self.dir):
             for filename in files:
                 if filename.startswith(coverage_file_prefix):
                     coverage_filenames.add(os.path.join(root, filename))
 
         for filename in coverage_filenames:
             with open(filename, 'r', encoding="utf8") as file:
                 covered_cmds.update([line.strip()
                                      for line in file.readlines()])
 
         return all_cmds - covered_cmds
 
 
 def save_results_as_junit(test_results, file_name, time, test_suite_name):
     """
     Save tests results to file in JUnit format
 
     See http://llg.cubic.org/docs/junit/ for specification of format
     """
     e_test_suite = ET.Element("testsuite",
                               {"name": "{}".format(test_suite_name),
                                "tests": str(len(test_results)),
                                # "errors":
                                "failures": str(len([t for t in test_results if t.status == "Failed"])),
                                "id": "0",
                                "skipped": str(len([t for t in test_results if t.status == "Skipped"])),
                                "time": str(TimeResolution.milliseconds(time)),
                                "timestamp": datetime.datetime.now().isoformat('T')
                                })
 
     for test_result in test_results:
         e_test_case = ET.SubElement(e_test_suite, "testcase",
                                     {"name": test_result.name,
                                      "classname": test_result.name,
                                      "time": str(TimeResolution.milliseconds(test_result.time))
                                      }
                                     )
         if test_result.status == "Skipped":
             ET.SubElement(e_test_case, "skipped")
         elif test_result.status == "Failed":
             ET.SubElement(e_test_case, "failure")
         # no special element for passed tests
 
         ET.SubElement(e_test_case, "system-out").text = test_result.stdout
         ET.SubElement(e_test_case, "system-err").text = test_result.stderr
 
     ET.ElementTree(e_test_suite).write(
         file_name, "UTF-8", xml_declaration=True)
 
 
 class Timings:
     """
     Takes care of loading, merging and saving tests execution times.
     """
 
     def __init__(self, timing_file):
         self.timing_file = timing_file
         self.existing_timings = self.load_timings()
 
     def load_timings(self):
         if os.path.isfile(self.timing_file):
             with open(self.timing_file, encoding="utf8") as file:
                 return json.load(file)
         else:
             return []
 
     def get_merged_timings(self, new_timings):
         """
         Return new list containing existing timings updated with new timings
         Tests that do not exists are not removed
         """
 
         key = 'name'
         merged = {}
         for item in self.existing_timings + new_timings:
             if item[key] in merged:
                 merged[item[key]].update(item)
             else:
                 merged[item[key]] = item
 
         # Sort the result to preserve test ordering in file
         merged = list(merged.values())
         merged.sort(key=lambda t, key=key: t[key])
         return merged
 
     def save_timings(self, test_results):
         # we only save test that have passed - timings for failed test might be
         # wrong (timeouts or early fails), and we exclude the tests that require
         # extra privileges.
         passed_results = [
             test for test in test_results if test.status == 'Passed' and test.name not in EXTRA_PRIVILEGES_TESTS]
         new_timings = list(map(lambda test: {'name': test.name, 'time': TimeResolution.seconds(test.time)},
                                passed_results))
         merged_timings = self.get_merged_timings(new_timings)
 
         with open(self.timing_file, 'w', encoding="utf8") as file:
             json.dump(merged_timings, file, indent=True)
 
 
 class TimeResolution:
     @staticmethod
     def seconds(time_fractional_second):
         return round(time_fractional_second)
 
     @staticmethod
     def milliseconds(time_fractional_second):
         return round(time_fractional_second, 3)
 
 
 if __name__ == '__main__':
     main()