diff --git a/doc/release-notes.md b/doc/release-notes.md
index 663bb06bb..fac4dc59f 100644
--- a/doc/release-notes.md
+++ b/doc/release-notes.md
@@ -1,7 +1,10 @@
 # Bitcoin ABC 0.27.6 Release Notes
 
 Bitcoin ABC version 0.27.6 is now available from:
 
   <https://download.bitcoinabc.org/0.27.6/>
 
-This is a maintenance release with no user-visible change.
+This release includes the following features and fixes:
+ - The `ancestorcount`, `ancestorsize` and `ancestorfees` fields from the
+   `listunspent` RPC have been removed. They were deprecated since the v0.27.0
+   and are no longer computed since the May 15th, 2023 eCash network upgrade.
diff --git a/src/bench/chained_tx.cpp b/src/bench/chained_tx.cpp
index a1db7787e..5203e06eb 100644
--- a/src/bench/chained_tx.cpp
+++ b/src/bench/chained_tx.cpp
@@ -1,514 +1,469 @@
 // Copyright (c) 2021 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <bench/bench.h>
 #include <config.h>
 #include <consensus/amount.h>
 #include <node/context.h>
 #include <node/miner.h>
 #include <primitives/transaction.h>
 #include <script/script.h>
 #include <txmempool.h>
 #include <util/string.h>
 #include <util/system.h>
 #include <validation.h>
 
 #include <test/util/mining.h>
 #include <test/util/setup_common.h>
 
 #include <list>
 #include <queue>
 #include <vector>
 
 /// This file contains benchmarks focusing on chained transactions in the
 /// mempool.
 
 static const CScript REDEEM_SCRIPT = CScript() << OP_DROP << OP_TRUE;
 
 static const CScript SCRIPT_PUB_KEY =
     CScript() << OP_HASH160 << ToByteVector(CScriptID(REDEEM_SCRIPT))
               << OP_EQUAL;
 
 static const CScript SCRIPT_SIG = CScript() << std::vector<uint8_t>(100, 0xff)
                                             << ToByteVector(REDEEM_SCRIPT);
 
 /// Mine new utxos
 static std::vector<CTxIn> createUTXOs(const Config &config, size_t n,
                                       node::NodeContext &node) {
     std::vector<CTxIn> utxos;
     utxos.reserve(n);
 
     for (size_t i = 0; i < n; ++i) {
         utxos.emplace_back(MineBlock(config, node, SCRIPT_PUB_KEY));
     }
 
     for (size_t i = 0; i < COINBASE_MATURITY + 1; ++i) {
         MineBlock(config, node, SCRIPT_PUB_KEY);
     }
 
     return utxos;
 }
 
 /// Create a transaction spending a coinbase utxo
 static CTransactionRef toTx(const Config &config, CTxIn txin) {
     CMutableTransaction tx;
     tx.vin.emplace_back(txin);
     tx.vin.back().scriptSig = SCRIPT_SIG;
     tx.vout.emplace_back(25 * COIN - 1337 * SATOSHI, SCRIPT_PUB_KEY);
     return MakeTransactionRef(tx);
 }
 
 /// Creates a chain of transactions with 1-input-1-output.
 static std::vector<CTransactionRef>
 oneInOneOutChain(const Config &config, CTxIn utxo, const size_t chainLength) {
     auto firstTx = toTx(config, std::move(utxo));
 
     // Build the chain
     std::vector<CTransactionRef> chain = {firstTx};
     chain.reserve(chainLength);
     while (chain.size() < chainLength) {
         const COutPoint parent(chain.back()->GetId(), 0);
         const Amount inAmount(chain.back()->vout[0].nValue);
         CMutableTransaction tx;
         tx.vin.emplace_back(CTxIn(parent, SCRIPT_SIG));
         tx.vout.emplace_back(inAmount - 1337 * SATOSHI, SCRIPT_PUB_KEY);
         chain.emplace_back(MakeTransactionRef(tx));
     }
     assert(chain.size() == chainLength);
     return chain;
 }
 
 /// Creates a tree of transactions with 2-inputs-1-output. It has similar
 /// properties to a complete binary-tree, where the last transaction is the
 /// "top" of the tree.
 static std::vector<CTransactionRef> twoInOneOutTree(const Config &config,
                                                     node::NodeContext &node,
                                                     const size_t treeDepth) {
     // Total number of txs is the sum of nodes at each depth of a binary tree.
     size_t txs = 0;
     for (size_t i = 0; i <= treeDepth; ++i) {
         txs += std::pow(2, i);
     }
     const size_t leafs = std::pow(2, treeDepth);
 
     std::vector<CTransactionRef> chain;
     chain.reserve(txs);
 
     std::queue<CTransactionRef> queue;
     for (auto txin : createUTXOs(config, leafs, node)) {
         auto tx = toTx(config, std::move(txin));
         queue.push(tx);
         chain.emplace_back(tx);
     }
 
     while (true) {
         CMutableTransaction tx;
 
         const CTransactionRef txin1 = queue.front();
         queue.pop();
         const CTransactionRef txin2 = queue.front();
         queue.pop();
 
         const Amount inAmount = txin1->vout[0].nValue + txin2->vout[0].nValue;
 
         tx.vin.emplace_back(CTxIn(COutPoint(txin1->GetId(), 0), SCRIPT_SIG));
         tx.vin.emplace_back(CTxIn(COutPoint(txin2->GetId(), 0), SCRIPT_SIG));
         tx.vout.emplace_back(inAmount - 1337 * SATOSHI, SCRIPT_PUB_KEY);
 
         CTransactionRef txref = MakeTransactionRef(tx);
         chain.push_back(txref);
         if (queue.empty()) {
             break;
         }
         queue.emplace(txref);
     }
     assert(chain.size() == txs);
     return chain;
 }
 
 /// Run benchmark on AcceptToMemoryPool
 static void benchATMP(const Config &config, node::NodeContext &node,
                       benchmark::Bench &bench,
                       const std::vector<CTransactionRef> chainedTxs) {
-    // ATMP uses gArgs, so we oblige
-    gArgs.ForceSetArg("-limitdescendantcount", ToString(chainedTxs.size()));
-    gArgs.ForceSetArg("-limitancestorcount", ToString(chainedTxs.size()));
-    gArgs.ForceSetArg("-limitancestorsize", ToString(chainedTxs.size() * 1000));
-    gArgs.ForceSetArg("-limitdescendantsize",
-                      ToString(chainedTxs.size() * 1000));
-
     auto chainman = Assert(node.chainman.get());
     Chainstate &activeChainState = chainman->ActiveChainstate();
 
     CTxMemPool &mempool{*Assert(activeChainState.GetMempool())};
     assert(mempool.size() == 0);
 
-    // test with wellington latched (faster)
-    const bool wellingtonBefore = mempool.wellingtonLatched.exchange(true);
-
     bench.run([&] {
         LOCK(::cs_main);
         for (const auto &tx : chainedTxs) {
             MempoolAcceptResult result =
                 AcceptToMemoryPool(config, activeChainState, tx, GetTime(),
                                    /*bypass_limits=*/false);
             assert(result.m_result_type ==
                    MempoolAcceptResult::ResultType::VALID);
         }
         mempool.clear();
     });
-
-    // restore state
-    mempool.wellingtonLatched = wellingtonBefore;
-
-    gArgs.ClearForcedArg("-limitdescendantcount");
-    gArgs.ClearForcedArg("-limitancestorcount");
-    gArgs.ClearForcedArg("-limitancestorsize");
-    gArgs.ClearForcedArg("-limitdescendantsize");
 }
 
 /// Run benchmark that reorganizes blocks with one-input-one-output transaction
 /// chains in them.
 ///
 /// If 'includeMempoolTxRemoval' is set, the benchmark will include the time
 /// it takes to remove the transactions of re-connected blocks from the mempool.
 static void benchReorg(const Config &config, node::NodeContext &node,
                        benchmark::Bench &bench, size_t reorgDepth,
                        size_t chainSizePerBlock, bool includeMempoolTxRemoval) {
     auto utxos = createUTXOs(config, reorgDepth, node);
     std::vector<std::vector<CTransactionRef>> chains;
     for (auto &utxo : utxos) {
         chains.emplace_back(
             oneInOneOutChain(config, std::move(utxo), chainSizePerBlock));
     }
 
     auto chainman = Assert(node.chainman.get());
     Chainstate &activeChainState = chainman->ActiveChainstate();
 
     // Current tip will be last valid block.
     CBlockIndex *tipBeforeInvalidate = activeChainState.m_chain.Tip();
     assert(tipBeforeInvalidate != nullptr);
 
     CBlockIndex *blockToInvalidate = nullptr;
 
     CTxMemPool &mempool{*Assert(activeChainState.GetMempool())};
     assert(mempool.size() == 0);
 
-    // test with wellington latched (faster)
-    const bool wellingtonBefore = mempool.wellingtonLatched.exchange(true);
-
     // Build blocks
     TestMemPoolEntryHelper entry;
     entry.nFee = 1337 * SATOSHI;
     for (const auto &chain : chains) {
         {
             entry.spendsCoinbase = true;
             LOCK2(cs_main, mempool.cs);
             for (const auto &tx : chain) {
                 mempool.addUnchecked(entry.FromTx(tx));
                 // Setting spendCoinbase to false here assumes it's a chain of
                 // 1-in-1-out transaction chain.
                 entry.spendsCoinbase = false;
             }
         }
         assert(mempool.size() == chain.size());
         MineBlock(config, node, SCRIPT_PUB_KEY);
         assert(mempool.size() == 0);
 
         assert(activeChainState.m_chain.Tip()->nTx ==
                chain.size() + 1 /* coinbase */);
 
         if (blockToInvalidate == nullptr) {
             blockToInvalidate = activeChainState.m_chain.Tip();
         }
     }
     CBlockIndex *mostWorkTip = activeChainState.m_chain.Tip();
 
-    // `AcceptToMemoryPool` is used during re-org, so we need to ajust its
-    // limits.
-    gArgs.ForceSetArg("-limitdescendantcount", ToString(chainSizePerBlock));
-    gArgs.ForceSetArg("-limitancestorcount", ToString(chainSizePerBlock));
-    gArgs.ForceSetArg("-limitancestorsize", ToString(chainSizePerBlock * 1000));
-    gArgs.ForceSetArg("-limitdescendantsize",
-                      ToString(chainSizePerBlock * 1000));
-
     bench.run([&] {
         BlockValidationState state;
 
         // Disconnect blocks with long transaction chains
         activeChainState.InvalidateBlock(config, state, blockToInvalidate);
         assert(state.IsValid());
 
         activeChainState.ActivateBestChain(config, state);
         assert(state.IsValid());
         assert(activeChainState.m_chain.Tip() == tipBeforeInvalidate);
 
         // Transactions should be stuffed back into the mempool.
         assert(mempool.size() == reorgDepth * chainSizePerBlock);
 
         if (!includeMempoolTxRemoval) {
             // As of writing this test, removing transactions from mempool
             // during re-connect takes significant amount of time, so we allow
             // to test both with and without this process.
             mempool.clear();
         }
 
         // Reconnect block
         {
             LOCK(cs_main);
             activeChainState.ResetBlockFailureFlags(blockToInvalidate);
         }
 
         activeChainState.ActivateBestChain(config, state);
         assert(state.IsValid());
         assert(activeChainState.m_chain.Tip() == mostWorkTip);
         assert(mempool.size() == 0);
     });
-
-    // restore state
-    mempool.wellingtonLatched = wellingtonBefore;
-
-    gArgs.ClearForcedArg("-limitdescendantcount");
-    gArgs.ClearForcedArg("-limitancestorcount");
-    gArgs.ClearForcedArg("-limitancestorsize");
-    gArgs.ClearForcedArg("-limitdescendantsize");
 }
 
 static void
 benchGenerateNewBlock(const Config &config, node::NodeContext &node,
                       benchmark::Bench &bench,
                       const std::vector<std::vector<CTransactionRef>> &chains) {
     TestMemPoolEntryHelper entry;
     entry.nFee = 1337 * SATOSHI;
 
     auto chainman = Assert(node.chainman.get());
     Chainstate &activeChainState = chainman->ActiveChainstate();
     CTxMemPool &mempool{*Assert(activeChainState.GetMempool())};
 
-    // test with wellington latched (faster)
-    const bool wellingtonBefore = mempool.wellingtonLatched.exchange(true);
-
     // Fill mempool
     size_t txCount = 0;
     for (const auto &chain : chains) {
         entry.spendsCoinbase = true;
         LOCK2(cs_main, mempool.cs);
         for (const auto &tx : chain) {
             mempool.addUnchecked(entry.FromTx(tx));
             // Setting spendCoinbase to false here assumes it's a chain of
             // 1-in-1-out transaction chain.
             entry.spendsCoinbase = false;
             ++txCount;
         }
     }
     assert(mempool.size() == txCount);
 
     const CScript dummy = CScript() << OP_TRUE;
     bench.run([&] {
         auto blocktemplate =
             node::BlockAssembler(config, activeChainState, mempool)
                 .CreateNewBlock(dummy);
         assert(blocktemplate);
         // +1 for coinbase
         assert(blocktemplate->block.vtx.size() == txCount + 1);
     });
-
-    // restore state
-    mempool.wellingtonLatched = wellingtonBefore;
 }
 
 static void
 benchEviction(const Config &, benchmark::Bench &bench,
               const std::vector<std::vector<CTransactionRef>> &chains,
               bool revFee = true) {
     std::list<CTxMemPool> pools;
 
     // Note: in order to isolate how long eviction takes (as opposed to add +
     // eviction), we are forced to pre-create all the pools we will be needing
     // up front.
 
     bench.epochs(2).epochIterations(1);
 
     for (uint64_t i = 0; i < bench.epochs() * bench.epochIterations() + 1;
          ++i) {
         pools.emplace_back();
         CTxMemPool &pool = pools.back();
-        // test with wellington latched (faster)
-        pool.wellingtonLatched = true;
         TestMemPoolEntryHelper entry;
         // Fill mempool
         size_t txCount = 0;
         entry.nFee = 1337 * SATOSHI;
         // add in order of decreasing fee if revFee, increasing otherwise
         const Amount feeBump =
             revFee ? int64_t(-1) * SATOSHI : int64_t(1) * SATOSHI;
         for (const auto &chain : chains) {
             entry.spendsCoinbase = true;
             if (revFee) {
                 entry.nFee += int64_t(chain.size()) * SATOSHI;
             }
             LOCK2(cs_main, pool.cs);
             for (const auto &tx : chain) {
                 pool.addUnchecked(entry.FromTx(tx));
                 entry.nFee += feeBump;
                 // Setting spendCoinbase to false here assumes it's a chain of
                 // 1-in-1-out transaction chain.
                 entry.spendsCoinbase = false;
                 ++txCount;
             }
             if (revFee) {
                 entry.nFee += int64_t(chain.size()) * SATOSHI;
             }
         }
         assert(pool.size() == txCount);
     }
 
     auto it = pools.begin();
 
     bench.run([&] {
         assert(it != pools.end());
         auto &pool = *it++;
         LOCK2(cs_main, pool.cs);
         while (auto prevSize = pool.size()) {
             pool.TrimToSize(pool.DynamicMemoryUsage() * 99 / 100);
             assert(pool.size() < prevSize);
         }
     });
 }
 
 /// Tests a chain of 50 1-input-1-output transactions.
 static void MempoolAcceptance50ChainedTxs(benchmark::Bench &bench) {
     RegTestingSetup test_setup{};
     const Config &config = GetConfig();
     const std::vector<CTransactionRef> chainedTxs = oneInOneOutChain(
         config, createUTXOs(config, 1, test_setup.m_node).back(), 50);
     benchATMP(config, test_setup.m_node, bench, chainedTxs);
 }
 
 /// Tests a chain of 500 1-input-1-output transactions.
 static void MempoolAcceptance500ChainedTxs(benchmark::Bench &bench) {
     RegTestingSetup test_setup{};
     const Config &config = GetConfig();
     const std::vector<CTransactionRef> chainedTxs = oneInOneOutChain(
         config, createUTXOs(config, 1, test_setup.m_node).back(), 500);
     benchATMP(config, test_setup.m_node, bench, chainedTxs);
 }
 
 /// Test a tree of 63 2-inputs-1-output transactions
 static void MempoolAcceptance63TxTree(benchmark::Bench &bench) {
     RegTestingSetup test_setup{};
     const Config &config = GetConfig();
     const std::vector<CTransactionRef> chainedTxs =
         twoInOneOutTree(config, test_setup.m_node, 5);
     assert(chainedTxs.size() == 63);
     benchATMP(config, test_setup.m_node, bench, chainedTxs);
 }
 
 /// Test a tree of 511 2-inputs-1-output transactions
 static void MempoolAcceptance511TxTree(benchmark::Bench &bench) {
     RegTestingSetup test_setup{};
     const Config &config = GetConfig();
     const std::vector<CTransactionRef> chainedTxs =
         twoInOneOutTree(config, test_setup.m_node, 8);
     assert(chainedTxs.size() == 511);
     benchATMP(config, test_setup.m_node, bench, chainedTxs);
 }
 
 /// Try to reorg a chain of depth 10 where each block has a 50 tx
 /// 1-input-1-output chain.
 static void Reorg10BlocksWith50TxChain(benchmark::Bench &bench) {
     RegTestingSetup test_setup{};
     const Config &config = GetConfig();
     benchReorg(config, test_setup.m_node, bench, 10, 50, true);
 }
 
 /// Try to reorg a chain of depth 10 where each block has a 500 tx
 /// 1-input-1-output chain.
 static void Reorg10BlocksWith500TxChain(benchmark::Bench &bench) {
     RegTestingSetup test_setup{};
     const Config &config = GetConfig();
     benchReorg(config, test_setup.m_node, bench, 10, 500, true);
 }
 
 /// Try to reorg a chain of depth 10 where each block has a 50 tx
 /// 1-input-1-output chain, skipping the process of removing transactions from
 /// the mempool during re-connect.
 static void Reorg10BlocksWith50TxChainSkipMempool(benchmark::Bench &bench) {
     RegTestingSetup test_setup{};
     const Config &config = GetConfig();
     benchReorg(config, test_setup.m_node, bench, 10, 50, false);
 }
 
 /// Try to reorg a chain of depth 10 where each block has a 500 tx
 /// 1-input-1-output chain, skipping the process of removing transactions from
 /// the mempool during re-connect.
 static void Reorg10BlocksWith500TxChainSkipMempool(benchmark::Bench &bench) {
     RegTestingSetup test_setup{};
     const Config &config = GetConfig();
     benchReorg(config, test_setup.m_node, bench, 10, 500, false);
 }
 
 /// Generate a block with 50 1-input-1-output transactions
 static void GenerateBlock50ChainedTxs(benchmark::Bench &bench) {
     RegTestingSetup test_setup{};
     const Config &config = GetConfig();
     const CTxIn utxo = createUTXOs(config, 1, test_setup.m_node).back();
     benchGenerateNewBlock(config, test_setup.m_node, bench,
                           {oneInOneOutChain(config, std::move(utxo), 50)});
 }
 
 /// Generate a block with 500 1-input-1-output transactions
 static void GenerateBlock500ChainedTxs(benchmark::Bench &bench) {
     RegTestingSetup test_setup{};
     const Config &config = GetConfig();
     const CTxIn utxo = createUTXOs(config, 1, test_setup.m_node).back();
     benchGenerateNewBlock(config, test_setup.m_node, bench,
                           {oneInOneOutChain(config, std::move(utxo), 500)});
 }
 
 /// Fill a mempool then evict 2000 x 50 1-input-1-output transactions,
 /// CTxMemPool version, in order of increasing fee
 static void EvictChained50Tx(benchmark::Bench &bench) {
     RegTestingSetup test_setup{};
     const Config &config = GetConfig();
     // create 2000 chains of 50 1-in-1-out each
     std::vector<std::vector<CTransactionRef>> chains;
     constexpr int NChains = 2000;
     const auto utxos = createUTXOs(config, NChains, test_setup.m_node);
     for (int i = 0; i < NChains; ++i) {
         chains.push_back(oneInOneOutChain(config, utxos[i], 50));
     }
     benchEviction(config, bench, chains, false);
 }
 
 /// Fill a mempool then evict 2000 x 50 1-input-1-output transactions,
 /// CTxMemPool version, in order of decreasing fee
 static void EvictChained50TxRev(benchmark::Bench &bench) {
     RegTestingSetup test_setup{};
     const Config &config = GetConfig();
     // create 2000 chains of 50 1-in-1-out each
     std::vector<std::vector<CTransactionRef>> chains;
     constexpr int NChains = 2000;
     const auto utxos = createUTXOs(config, NChains, test_setup.m_node);
     for (int i = 0; i < NChains; ++i) {
         chains.push_back(oneInOneOutChain(config, utxos[i], 50));
     }
     benchEviction(config, bench, chains, true);
 }
 
 BENCHMARK(MempoolAcceptance50ChainedTxs);
 BENCHMARK(MempoolAcceptance500ChainedTxs);
 BENCHMARK(MempoolAcceptance63TxTree);
 BENCHMARK(MempoolAcceptance511TxTree);
 
 BENCHMARK(Reorg10BlocksWith50TxChain);
 BENCHMARK(Reorg10BlocksWith500TxChain);
 BENCHMARK(Reorg10BlocksWith50TxChainSkipMempool);
 BENCHMARK(Reorg10BlocksWith500TxChainSkipMempool);
 
 BENCHMARK(GenerateBlock50ChainedTxs);
 BENCHMARK(GenerateBlock500ChainedTxs);
 
 BENCHMARK(EvictChained50Tx);
 BENCHMARK(EvictChained50TxRev);
diff --git a/src/interfaces/chain.h b/src/interfaces/chain.h
index 502e4c2c5..8593e8ffb 100644
--- a/src/interfaces/chain.h
+++ b/src/interfaces/chain.h
@@ -1,355 +1,345 @@
 // Copyright (c) 2018-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.
 
 #ifndef BITCOIN_INTERFACES_CHAIN_H
 #define BITCOIN_INTERFACES_CHAIN_H
 
 #include <primitives/transaction.h>
 #include <primitives/txid.h>
 #include <util/settings.h> // For util::SettingsValue
 
 #include <cstddef>
 #include <cstdint>
 #include <functional>
 #include <memory>
 #include <optional>
 #include <string>
 #include <vector>
 
 class ArgsManager;
 class CBlock;
 class CChainParams;
 class Coin;
 class Config;
 class CRPCCommand;
 class CScheduler;
 class TxValidationState;
 
 enum class MemPoolRemovalReason;
 
 struct BlockHash;
 struct bilingual_str;
 struct CBlockLocator;
 namespace node {
 struct NodeContext;
 } // namespace node
 
 namespace Consensus {
 struct Params;
 }
 
 namespace interfaces {
 
 class Handler;
 class Wallet;
 
 //! Helper for findBlock to selectively return pieces of block data.
 class FoundBlock {
 public:
     FoundBlock &hash(BlockHash &hash) {
         m_hash = &hash;
         return *this;
     }
     FoundBlock &height(int &height) {
         m_height = &height;
         return *this;
     }
     FoundBlock &time(int64_t &time) {
         m_time = &time;
         return *this;
     }
     FoundBlock &maxTime(int64_t &max_time) {
         m_max_time = &max_time;
         return *this;
     }
     FoundBlock &mtpTime(int64_t &mtp_time) {
         m_mtp_time = &mtp_time;
         return *this;
     }
     //! Return whether block is in the active (most-work) chain.
     FoundBlock &inActiveChain(bool &in_active_chain) {
         m_in_active_chain = &in_active_chain;
         return *this;
     }
     //! Return next block in the active chain if current block is in the active
     //! chain.
     FoundBlock &nextBlock(const FoundBlock &next_block) {
         m_next_block = &next_block;
         return *this;
     }
     //! Read block data from disk. If the block exists but doesn't have data
     //! (for example due to pruning), the CBlock variable will be set to null.
     FoundBlock &data(CBlock &data) {
         m_data = &data;
         return *this;
     }
 
     BlockHash *m_hash = nullptr;
     int *m_height = nullptr;
     int64_t *m_time = nullptr;
     int64_t *m_max_time = nullptr;
     int64_t *m_mtp_time = nullptr;
     bool *m_in_active_chain = nullptr;
     const FoundBlock *m_next_block = nullptr;
     CBlock *m_data = nullptr;
 };
 
 //! Interface giving clients (wallet processes, maybe other analysis tools in
 //! the future) ability to access to the chain state, receive notifications,
 //! estimate fees, and submit transactions.
 //!
 //! TODO: Current chain methods are too low level, exposing too much of the
 //! internal workings of the bitcoin node, and not being very convenient to use.
 //! Chain methods should be cleaned up and simplified over time. Examples:
 //!
 //! * The initMessages() and showProgress() methods which the wallet uses to
 //! send
 //!   notifications to the GUI should go away when GUI and wallet can directly
 //!   communicate with each other without going through the node
 //!   (https://github.com/bitcoin/bitcoin/pull/15288#discussion_r253321096).
 //!
 //! * The handleRpc, registerRpcs, rpcEnableDeprecated methods and other RPC
 //!   methods can go away if wallets listen for HTTP requests on their own
 //!   ports instead of registering to handle requests on the node HTTP port.
 //!
 //! * Move fee estimation queries to an asynchronous interface and let the
 //!   wallet cache it, fee estimation being driven by node mempool, wallet
 //!   should be the consumer.
 //!
 //! * `guessVerificationProgress` and similar methods can go away if rescan
 //!   logic moves out of the wallet, and the wallet just requests scans from the
 //!   node (https://github.com/bitcoin/bitcoin/issues/11756)
 class Chain {
 public:
     virtual ~Chain() {}
 
     //! Get current chain height, not including genesis block (returns 0 if
     //! chain only contains genesis block, std::nullopt if chain does not
     //! contain any blocks)
     virtual std::optional<int> getHeight() = 0;
 
     //! Get block hash. Height must be valid or this function will abort.
     virtual BlockHash getBlockHash(int height) = 0;
 
     //! Check that the block is available on disk (i.e. has not been
     //! pruned), and contains transactions.
     virtual bool haveBlockOnDisk(int height) = 0;
 
     //! Get locator for the current chain tip.
     virtual CBlockLocator getTipLocator() = 0;
 
     //! Return height of the highest block on chain in common with the locator,
     //! which will either be the original block used to create the locator,
     //! or one of its ancestors.
     virtual std::optional<int>
     findLocatorFork(const CBlockLocator &locator) = 0;
 
     //! Return whether node has the block and optionally return block metadata
     //! or contents.
     virtual bool findBlock(const BlockHash &hash,
                            const FoundBlock &block = {}) = 0;
 
     //! Find first block in the chain with timestamp >= the given time
     //! and height >= than the given height, return false if there is no block
     //! with a high enough timestamp and height. Optionally return block
     //! information.
     virtual bool
     findFirstBlockWithTimeAndHeight(int64_t min_time, int min_height,
                                     const FoundBlock &block = {}) = 0;
 
     //! Find ancestor of block at specified height and optionally return
     //! ancestor information.
     virtual bool findAncestorByHeight(const BlockHash &block_hash,
                                       int ancestor_height,
                                       const FoundBlock &ancestor_out = {}) = 0;
 
     //! Return whether block descends from a specified ancestor, and
     //! optionally return ancestor information.
     virtual bool findAncestorByHash(const BlockHash &block_hash,
                                     const BlockHash &ancestor_hash,
                                     const FoundBlock &ancestor_out = {}) = 0;
 
     //! Find most recent common ancestor between two blocks and optionally
     //! return block information.
     virtual bool findCommonAncestor(const BlockHash &block_hash1,
                                     const BlockHash &block_hash2,
                                     const FoundBlock &ancestor_out = {},
                                     const FoundBlock &block1_out = {},
                                     const FoundBlock &block2_out = {}) = 0;
 
     //! Look up unspent output information. Returns coins in the mempool and in
     //! the current chain UTXO set. Iterates through all the keys in the map and
     //! populates the values.
     virtual void findCoins(std::map<COutPoint, Coin> &coins) = 0;
 
     //! Estimate fraction of total transactions verified if blocks up to
     //! the specified block hash are verified.
     virtual double guessVerificationProgress(const BlockHash &block_hash) = 0;
 
     //! Return true if data is available for all blocks in the specified range
     //! of blocks. This checks all blocks that are ancestors of block_hash in
     //! the height range from min_height to max_height, inclusive.
     virtual bool hasBlocks(const BlockHash &block_hash, int min_height = 0,
                            std::optional<int> max_height = {}) = 0;
 
     //! Check if transaction has descendants in mempool.
     virtual bool hasDescendantsInMempool(const TxId &txid) = 0;
 
     //! Transaction is added to memory pool, if the transaction fee is below the
     //! amount specified by max_tx_fee, and broadcast to all peers if relay is
     //! set to true. Return false if the transaction could not be added due to
     //! the fee or for another reason.
     virtual bool broadcastTransaction(const Config &config,
                                       const CTransactionRef &tx,
                                       const Amount &max_tx_fee, bool relay,
                                       std::string &err_string) = 0;
 
-    //! Calculate mempool ancestor and descendant counts for the given
-    //! transaction.
-    virtual void getTransactionAncestry(const TxId &txid, size_t &ancestors,
-                                        size_t &descendants,
-                                        size_t *ancestorsize = nullptr,
-                                        Amount *ancestorfees = nullptr) = 0;
-
     //! Get the node's package limits.
     //! Currently only returns the ancestor and descendant count limits, but
     //! could be enhanced to return more policy settings.
     virtual void getPackageLimits(size_t &limit_ancestor_count,
                                   size_t &limit_descendant_count) = 0;
 
-    //! Check if transaction will pass the mempool's chain limits.
-    virtual bool checkChainLimits(const CTransactionRef &tx) = 0;
-
     //! Estimate fee
     virtual CFeeRate estimateFee() const = 0;
 
     //! Relay current minimum fee (from -minrelaytxfee settings).
     virtual CFeeRate relayMinFee() = 0;
 
     //! Relay dust fee setting (-dustrelayfee), reflecting lowest rate it's
     //! economical to spend.
     virtual CFeeRate relayDustFee() = 0;
 
     //! Check if any block has been pruned.
     virtual bool havePruned() = 0;
 
     //! Check if the node is ready to broadcast transactions.
     virtual bool isReadyToBroadcast() = 0;
 
     //! Check if in IBD.
     virtual bool isInitialBlockDownload() = 0;
 
     //! Check if shutdown requested.
     virtual bool shutdownRequested() = 0;
 
     //! Get adjusted time.
     virtual int64_t getAdjustedTime() = 0;
 
     //! Send init message.
     virtual void initMessage(const std::string &message) = 0;
 
     //! Send init warning.
     virtual void initWarning(const bilingual_str &message) = 0;
 
     //! Send init error.
     virtual void initError(const bilingual_str &message) = 0;
 
     //! Send progress indicator.
     virtual void showProgress(const std::string &title, int progress,
                               bool resume_possible) = 0;
 
     //! Chain notifications.
     class Notifications {
     public:
         virtual ~Notifications() {}
         virtual void transactionAddedToMempool(const CTransactionRef &tx,
                                                uint64_t mempool_sequence) {}
         virtual void transactionRemovedFromMempool(const CTransactionRef &ptx,
                                                    MemPoolRemovalReason reason,
                                                    uint64_t mempool_sequence) {}
         virtual void blockConnected(const CBlock &block, int height) {}
         virtual void blockDisconnected(const CBlock &block, int height) {}
         virtual void updatedBlockTip() {}
         virtual void chainStateFlushed(const CBlockLocator &locator) {}
     };
 
     //! Register handler for notifications.
     virtual std::unique_ptr<Handler>
     handleNotifications(std::shared_ptr<Notifications> notifications) = 0;
 
     //! Wait for pending notifications to be processed unless block hash points
     //! to the current chain tip.
     virtual void waitForNotificationsIfTipChanged(const BlockHash &old_tip) = 0;
 
     //! Register handler for RPC. Command is not copied, so reference
     //! needs to remain valid until Handler is disconnected.
     virtual std::unique_ptr<Handler> handleRpc(const CRPCCommand &command) = 0;
 
     //! Check if deprecated RPC is enabled.
     virtual bool rpcEnableDeprecated(const std::string &method) = 0;
 
     //! Run function after given number of seconds. Cancel any previous calls
     //! with same name.
     virtual void rpcRunLater(const std::string &name, std::function<void()> fn,
                              int64_t seconds) = 0;
 
     //! Current RPC serialization flags.
     virtual int rpcSerializationFlags() = 0;
 
     //! Return <datadir>/settings.json setting value.
     virtual util::SettingsValue getRwSetting(const std::string &name) = 0;
 
     //! Write a setting to <datadir>/settings.json.
     virtual bool updateRwSetting(const std::string &name,
                                  const util::SettingsValue &value) = 0;
 
     //! Synchronously send transactionAddedToMempool notifications about all
     //! current mempool transactions to the specified handler and return after
     //! the last one is sent. These notifications aren't coordinated with async
     //! notifications sent by handleNotifications, so out of date async
     //! notifications from handleNotifications can arrive during and after
     //! synchronous notifications from requestMempoolTransactions. Clients need
     //! to be prepared to handle this by ignoring notifications about unknown
     //! removed transactions and already added new transactions.
     virtual void requestMempoolTransactions(Notifications &notifications) = 0;
 
     //! This Chain's parameters
     virtual const CChainParams &params() const = 0;
 };
 
 //! Interface to let node manage chain clients (wallets, or maybe tools for
 //! monitoring and analysis in the future).
 class ChainClient {
 public:
     virtual ~ChainClient() {}
 
     //! Register rpcs.
     virtual void registerRpcs() = 0;
 
     //! Check for errors before loading.
     virtual bool verify() = 0;
 
     //! Load saved state.
     virtual bool load() = 0;
 
     //! Start client execution and provide a scheduler.
     virtual void start(CScheduler &scheduler) = 0;
 
     //! Save state to disk.
     virtual void flush() = 0;
 
     //! Shut down client.
     virtual void stop() = 0;
 
     //! Set mock time.
     virtual void setMockTime(int64_t time) = 0;
 };
 
 //! Return implementation of Chain interface.
 std::unique_ptr<Chain> MakeChain(node::NodeContext &node,
                                  const CChainParams &params);
 
 } // namespace interfaces
 
 #endif // BITCOIN_INTERFACES_CHAIN_H
diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index 861ca8254..16a304254 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -1,782 +1,744 @@
 // Copyright (c) 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.
 
 #include <addrdb.h>
 #include <banman.h>
 #include <chain.h>
 #include <chainparams.h>
 #include <config.h>
 #include <init.h>
 #include <interfaces/chain.h>
 #include <interfaces/handler.h>
 #include <interfaces/node.h>
 #include <interfaces/wallet.h>
 #include <mapport.h>
 #include <net.h>
 #include <net_processing.h>
 #include <netaddress.h>
 #include <netbase.h>
 #include <node/blockstorage.h>
 #include <node/coin.h>
 #include <node/context.h>
 #include <node/transaction.h>
 #include <node/ui_interface.h>
 #include <policy/mempool.h>
 #include <policy/settings.h>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
 #include <rpc/protocol.h>
 #include <rpc/server.h>
 #include <shutdown.h>
 #include <sync.h>
 #include <timedata.h>
 #include <txmempool.h>
 #include <uint256.h>
 #include <util/check.h>
 #include <util/system.h>
 #include <util/translation.h>
 #include <validation.h>
 #include <validationinterface.h>
 #include <warnings.h>
 
 #if defined(HAVE_CONFIG_H)
 #include <config/bitcoin-config.h>
 #endif
 
 #include <univalue.h>
 
 #include <boost/signals2/signal.hpp>
 
 #include <memory>
 #include <utility>
 
 class HTTPRPCRequestProcessor;
 
 using interfaces::BlockTip;
 using interfaces::Chain;
 using interfaces::FoundBlock;
 using interfaces::Handler;
 using interfaces::MakeHandler;
 using interfaces::Node;
 using interfaces::WalletClient;
 
 namespace node {
 namespace {
 
     class NodeImpl : public Node {
     private:
         ChainstateManager &chainman() { return *Assert(m_context->chainman); }
 
     public:
         explicit NodeImpl(NodeContext *context) { setContext(context); }
         void initLogging() override { InitLogging(*Assert(m_context->args)); }
         void initParameterInteraction() override {
             InitParameterInteraction(*Assert(m_context->args));
         }
         bilingual_str getWarnings() override { return GetWarnings(true); }
         bool baseInitialize(Config &config) override {
             return AppInitBasicSetup(gArgs) &&
                    AppInitParameterInteraction(config, gArgs) &&
                    AppInitSanityChecks() && AppInitLockDataDirectory() &&
                    AppInitInterfaces(*m_context);
         }
         bool appInitMain(Config &config, RPCServer &rpcServer,
                          HTTPRPCRequestProcessor &httpRPCRequestProcessor,
                          interfaces::BlockAndHeaderTipInfo *tip_info) override {
             return AppInitMain(config, rpcServer, httpRPCRequestProcessor,
                                *m_context, tip_info);
         }
         void appShutdown() override {
             Interrupt(*m_context);
             Shutdown(*m_context);
         }
         void startShutdown() override {
             StartShutdown();
             // Stop RPC for clean shutdown if any of waitfor* commands is
             // executed.
             if (gArgs.GetBoolArg("-server", false)) {
                 InterruptRPC();
                 StopRPC();
             }
         }
         bool shutdownRequested() override { return ShutdownRequested(); }
         void mapPort(bool use_upnp, bool use_natpmp) override {
             StartMapPort(use_upnp, use_natpmp);
         }
         bool getProxy(Network net, proxyType &proxy_info) override {
             return GetProxy(net, proxy_info);
         }
         size_t getNodeCount(CConnman::NumConnections flags) override {
             return m_context->connman ? m_context->connman->GetNodeCount(flags)
                                       : 0;
         }
         bool getNodesStats(NodesStats &stats) override {
             stats.clear();
 
             if (m_context->connman) {
                 std::vector<CNodeStats> stats_temp;
                 m_context->connman->GetNodeStats(stats_temp);
 
                 stats.reserve(stats_temp.size());
                 for (auto &node_stats_temp : stats_temp) {
                     stats.emplace_back(std::move(node_stats_temp), false,
                                        CNodeStateStats());
                 }
 
                 // Try to retrieve the CNodeStateStats for each node.
                 if (m_context->peerman) {
                     TRY_LOCK(::cs_main, lockMain);
                     if (lockMain) {
                         for (auto &node_stats : stats) {
                             std::get<1>(node_stats) =
                                 m_context->peerman->GetNodeStateStats(
                                     std::get<0>(node_stats).nodeid,
                                     std::get<2>(node_stats));
                         }
                     }
                 }
                 return true;
             }
             return false;
         }
         bool getBanned(banmap_t &banmap) override {
             if (m_context->banman) {
                 m_context->banman->GetBanned(banmap);
                 return true;
             }
             return false;
         }
         bool ban(const CNetAddr &net_addr, int64_t ban_time_offset) override {
             if (m_context->banman) {
                 m_context->banman->Ban(net_addr, ban_time_offset);
                 return true;
             }
             return false;
         }
         bool unban(const CSubNet &ip) override {
             if (m_context->banman) {
                 m_context->banman->Unban(ip);
                 return true;
             }
             return false;
         }
         bool disconnectByAddress(const CNetAddr &net_addr) override {
             if (m_context->connman) {
                 return m_context->connman->DisconnectNode(net_addr);
             }
             return false;
         }
         bool disconnectById(NodeId id) override {
             if (m_context->connman) {
                 return m_context->connman->DisconnectNode(id);
             }
             return false;
         }
         int64_t getTotalBytesRecv() override {
             return m_context->connman ? m_context->connman->GetTotalBytesRecv()
                                       : 0;
         }
         int64_t getTotalBytesSent() override {
             return m_context->connman ? m_context->connman->GetTotalBytesSent()
                                       : 0;
         }
         size_t getMempoolSize() override {
             return m_context->mempool ? m_context->mempool->size() : 0;
         }
         size_t getMempoolDynamicUsage() override {
             return m_context->mempool ? m_context->mempool->DynamicMemoryUsage()
                                       : 0;
         }
         bool getHeaderTip(int &height, int64_t &block_time) override {
             LOCK(::cs_main);
             auto best_header = chainman().m_best_header;
             if (best_header) {
                 height = best_header->nHeight;
                 block_time = best_header->GetBlockTime();
                 return true;
             }
             return false;
         }
         int getNumBlocks() override {
             LOCK(::cs_main);
             return chainman().ActiveChain().Height();
         }
         BlockHash getBestBlockHash() override {
             const CBlockIndex *tip =
                 WITH_LOCK(::cs_main, return chainman().ActiveTip());
             return tip ? tip->GetBlockHash()
                        : Params().GenesisBlock().GetHash();
         }
         int64_t getLastBlockTime() override {
             LOCK(::cs_main);
             if (chainman().ActiveChain().Tip()) {
                 return chainman().ActiveChain().Tip()->GetBlockTime();
             }
             // Genesis block's time of current network
             return Params().GenesisBlock().GetBlockTime();
         }
         double getVerificationProgress() override {
             const CBlockIndex *tip;
             {
                 LOCK(::cs_main);
                 tip = chainman().ActiveChain().Tip();
             }
             return GuessVerificationProgress(Params().TxData(), tip);
         }
         bool isInitialBlockDownload() override {
             return chainman().ActiveChainstate().IsInitialBlockDownload();
         }
         bool getReindex() override { return node::fReindex; }
         bool getImporting() override { return node::fImporting; }
         void setNetworkActive(bool active) override {
             if (m_context->connman) {
                 m_context->connman->SetNetworkActive(active);
             }
         }
         bool getNetworkActive() override {
             return m_context->connman && m_context->connman->GetNetworkActive();
         }
         CFeeRate getDustRelayFee() override { return ::dustRelayFee; }
         UniValue executeRpc(const Config &config, const std::string &command,
                             const UniValue &params,
                             const std::string &uri) override {
             JSONRPCRequest req;
             req.context = m_context;
             req.params = params;
             req.strMethod = command;
             req.URI = uri;
             return ::tableRPC.execute(config, req);
         }
         std::vector<std::string> listRpcCommands() override {
             return ::tableRPC.listCommands();
         }
         void rpcSetTimerInterfaceIfUnset(RPCTimerInterface *iface) override {
             RPCSetTimerInterfaceIfUnset(iface);
         }
         void rpcUnsetTimerInterface(RPCTimerInterface *iface) override {
             RPCUnsetTimerInterface(iface);
         }
         bool getUnspentOutput(const COutPoint &output, Coin &coin) override {
             LOCK(::cs_main);
             return chainman().ActiveChainstate().CoinsTip().GetCoin(output,
                                                                     coin);
         }
         WalletClient &walletClient() override {
             return *Assert(m_context->wallet_client);
         }
         std::unique_ptr<Handler> handleInitMessage(InitMessageFn fn) override {
             return MakeHandler(::uiInterface.InitMessage_connect(fn));
         }
         std::unique_ptr<Handler> handleMessageBox(MessageBoxFn fn) override {
             return MakeHandler(::uiInterface.ThreadSafeMessageBox_connect(fn));
         }
         std::unique_ptr<Handler> handleQuestion(QuestionFn fn) override {
             return MakeHandler(::uiInterface.ThreadSafeQuestion_connect(fn));
         }
         std::unique_ptr<Handler>
         handleShowProgress(ShowProgressFn fn) override {
             return MakeHandler(::uiInterface.ShowProgress_connect(fn));
         }
         std::unique_ptr<Handler> handleNotifyNumConnectionsChanged(
             NotifyNumConnectionsChangedFn fn) override {
             return MakeHandler(
                 ::uiInterface.NotifyNumConnectionsChanged_connect(fn));
         }
         std::unique_ptr<Handler> handleNotifyNetworkActiveChanged(
             NotifyNetworkActiveChangedFn fn) override {
             return MakeHandler(
                 ::uiInterface.NotifyNetworkActiveChanged_connect(fn));
         }
         std::unique_ptr<Handler>
         handleNotifyAlertChanged(NotifyAlertChangedFn fn) override {
             return MakeHandler(::uiInterface.NotifyAlertChanged_connect(fn));
         }
         std::unique_ptr<Handler>
         handleBannedListChanged(BannedListChangedFn fn) override {
             return MakeHandler(::uiInterface.BannedListChanged_connect(fn));
         }
         std::unique_ptr<Handler>
         handleNotifyBlockTip(NotifyBlockTipFn fn) override {
             return MakeHandler(::uiInterface.NotifyBlockTip_connect(
                 [fn](SynchronizationState sync_state,
                      const CBlockIndex *block) {
                     fn(sync_state,
                        BlockTip{block->nHeight, block->GetBlockTime(),
                                 block->GetBlockHash()},
                        GuessVerificationProgress(Params().TxData(), block));
                 }));
         }
         std::unique_ptr<Handler>
         handleNotifyHeaderTip(NotifyHeaderTipFn fn) override {
             /* verification progress is unused when a header was received */
             return MakeHandler(::uiInterface.NotifyHeaderTip_connect(
                 [fn](SynchronizationState sync_state,
                      const CBlockIndex *block) {
                     fn(sync_state,
                        BlockTip{block->nHeight, block->GetBlockTime(),
                                 block->GetBlockHash()},
                        0);
                 }));
         }
         NodeContext *context() override { return m_context; }
         void setContext(NodeContext *context) override { m_context = context; }
         NodeContext *m_context{nullptr};
     };
 
     bool FillBlock(const CBlockIndex *index, const FoundBlock &block,
                    UniqueLock<RecursiveMutex> &lock, const CChain &active) {
         if (!index) {
             return false;
         }
         if (block.m_hash) {
             *block.m_hash = index->GetBlockHash();
         }
         if (block.m_height) {
             *block.m_height = index->nHeight;
         }
         if (block.m_time) {
             *block.m_time = index->GetBlockTime();
         }
         if (block.m_max_time) {
             *block.m_max_time = index->GetBlockTimeMax();
         }
         if (block.m_mtp_time) {
             *block.m_mtp_time = index->GetMedianTimePast();
         }
         if (block.m_in_active_chain) {
             *block.m_in_active_chain = active[index->nHeight] == index;
         }
         if (block.m_next_block) {
             FillBlock(active[index->nHeight] == index
                           ? active[index->nHeight + 1]
                           : nullptr,
                       *block.m_next_block, lock, active);
         }
         if (block.m_data) {
             REVERSE_LOCK(lock);
             if (!ReadBlockFromDisk(*block.m_data, index,
                                    Params().GetConsensus())) {
                 block.m_data->SetNull();
             }
         }
         return true;
     }
 
     class NotificationsProxy : public CValidationInterface {
     public:
         explicit NotificationsProxy(
             std::shared_ptr<Chain::Notifications> notifications)
             : m_notifications(std::move(notifications)) {}
         virtual ~NotificationsProxy() = default;
         void TransactionAddedToMempool(const CTransactionRef &tx,
                                        uint64_t mempool_sequence) override {
             m_notifications->transactionAddedToMempool(tx, mempool_sequence);
         }
         void TransactionRemovedFromMempool(const CTransactionRef &tx,
                                            MemPoolRemovalReason reason,
                                            uint64_t mempool_sequence) override {
             m_notifications->transactionRemovedFromMempool(tx, reason,
                                                            mempool_sequence);
         }
         void BlockConnected(const std::shared_ptr<const CBlock> &block,
                             const CBlockIndex *index) override {
             m_notifications->blockConnected(*block, index->nHeight);
         }
         void BlockDisconnected(const std::shared_ptr<const CBlock> &block,
                                const CBlockIndex *index) override {
             m_notifications->blockDisconnected(*block, index->nHeight);
         }
         void UpdatedBlockTip(const CBlockIndex *index,
                              const CBlockIndex *fork_index,
                              bool is_ibd) override {
             m_notifications->updatedBlockTip();
         }
         void ChainStateFlushed(const CBlockLocator &locator) override {
             m_notifications->chainStateFlushed(locator);
         }
         std::shared_ptr<Chain::Notifications> m_notifications;
     };
 
     class NotificationsHandlerImpl : public Handler {
     public:
         explicit NotificationsHandlerImpl(
             std::shared_ptr<Chain::Notifications> notifications)
             : m_proxy(std::make_shared<NotificationsProxy>(
                   std::move(notifications))) {
             RegisterSharedValidationInterface(m_proxy);
         }
         ~NotificationsHandlerImpl() override { disconnect(); }
         void disconnect() override {
             if (m_proxy) {
                 UnregisterSharedValidationInterface(m_proxy);
                 m_proxy.reset();
             }
         }
         std::shared_ptr<NotificationsProxy> m_proxy;
     };
 
     class RpcHandlerImpl : public Handler {
     public:
         explicit RpcHandlerImpl(const CRPCCommand &command)
             : m_command(command), m_wrapped_command(&command) {
             m_command.actor = [this](const Config &config,
                                      const JSONRPCRequest &request,
                                      UniValue &result, bool last_handler) {
                 if (!m_wrapped_command) {
                     return false;
                 }
                 try {
                     return m_wrapped_command->actor(config, request, result,
                                                     last_handler);
                 } catch (const UniValue &e) {
                     // If this is not the last handler and a wallet not found
                     // exception was thrown, return false so the next handler
                     // can try to handle the request. Otherwise, reraise the
                     // exception.
                     if (!last_handler) {
                         const UniValue &code = e["code"];
                         if (code.isNum() &&
                             code.get_int() == RPC_WALLET_NOT_FOUND) {
                             return false;
                         }
                     }
                     throw;
                 }
             };
             ::tableRPC.appendCommand(m_command.name, &m_command);
         }
 
         void disconnect() final {
             if (m_wrapped_command) {
                 m_wrapped_command = nullptr;
                 ::tableRPC.removeCommand(m_command.name, &m_command);
             }
         }
 
         ~RpcHandlerImpl() override { disconnect(); }
 
         CRPCCommand m_command;
         const CRPCCommand *m_wrapped_command;
     };
 
     class ChainImpl : public Chain {
     private:
         ChainstateManager &chainman() { return *Assert(m_node.chainman); }
 
     public:
         explicit ChainImpl(NodeContext &node, const CChainParams &params)
             : m_node(node), m_params(params) {}
         std::optional<int> getHeight() override {
             LOCK(::cs_main);
             const CChain &active = Assert(m_node.chainman)->ActiveChain();
             int height = active.Height();
             if (height >= 0) {
                 return height;
             }
             return std::nullopt;
         }
         BlockHash getBlockHash(int height) override {
             LOCK(::cs_main);
             const CChain &active = Assert(m_node.chainman)->ActiveChain();
             CBlockIndex *block = active[height];
             assert(block);
             return block->GetBlockHash();
         }
         bool haveBlockOnDisk(int height) override {
             LOCK(cs_main);
             const CChain &active = Assert(m_node.chainman)->ActiveChain();
             CBlockIndex *block = active[height];
             return block && (block->nStatus.hasData() != 0) && block->nTx > 0;
         }
         CBlockLocator getTipLocator() override {
             LOCK(cs_main);
             const CChain &active = Assert(m_node.chainman)->ActiveChain();
             return active.GetLocator();
         }
         std::optional<int>
         findLocatorFork(const CBlockLocator &locator) override {
             LOCK(cs_main);
             const Chainstate &active =
                 Assert(m_node.chainman)->ActiveChainstate();
             if (const CBlockIndex *fork =
                     active.FindForkInGlobalIndex(locator)) {
                 return fork->nHeight;
             }
             return std::nullopt;
         }
         bool findBlock(const BlockHash &hash,
                        const FoundBlock &block) override {
             WAIT_LOCK(cs_main, lock);
             const CChain &active = Assert(m_node.chainman)->ActiveChain();
             return FillBlock(m_node.chainman->m_blockman.LookupBlockIndex(hash),
                              block, lock, active);
         }
         bool findFirstBlockWithTimeAndHeight(int64_t min_time, int min_height,
                                              const FoundBlock &block) override {
             WAIT_LOCK(cs_main, lock);
             const CChain &active = Assert(m_node.chainman)->ActiveChain();
             return FillBlock(active.FindEarliestAtLeast(min_time, min_height),
                              block, lock, active);
         }
         bool findAncestorByHeight(const BlockHash &block_hash,
                                   int ancestor_height,
                                   const FoundBlock &ancestor_out) override {
             WAIT_LOCK(cs_main, lock);
             const CChain &active = Assert(m_node.chainman)->ActiveChain();
             if (const CBlockIndex *block =
                     m_node.chainman->m_blockman.LookupBlockIndex(block_hash)) {
                 if (const CBlockIndex *ancestor =
                         block->GetAncestor(ancestor_height)) {
                     return FillBlock(ancestor, ancestor_out, lock, active);
                 }
             }
             return FillBlock(nullptr, ancestor_out, lock, active);
         }
         bool findAncestorByHash(const BlockHash &block_hash,
                                 const BlockHash &ancestor_hash,
                                 const FoundBlock &ancestor_out) override {
             WAIT_LOCK(cs_main, lock);
             const CChain &active = Assert(m_node.chainman)->ActiveChain();
             const CBlockIndex *block =
                 m_node.chainman->m_blockman.LookupBlockIndex(block_hash);
             const CBlockIndex *ancestor =
                 m_node.chainman->m_blockman.LookupBlockIndex(ancestor_hash);
             if (block && ancestor &&
                 block->GetAncestor(ancestor->nHeight) != ancestor) {
                 ancestor = nullptr;
             }
             return FillBlock(ancestor, ancestor_out, lock, active);
         }
         bool findCommonAncestor(const BlockHash &block_hash1,
                                 const BlockHash &block_hash2,
                                 const FoundBlock &ancestor_out,
                                 const FoundBlock &block1_out,
                                 const FoundBlock &block2_out) override {
             WAIT_LOCK(cs_main, lock);
             const CChain &active = Assert(m_node.chainman)->ActiveChain();
             const CBlockIndex *block1 =
                 m_node.chainman->m_blockman.LookupBlockIndex(block_hash1);
             const CBlockIndex *block2 =
                 m_node.chainman->m_blockman.LookupBlockIndex(block_hash2);
             const CBlockIndex *ancestor =
                 block1 && block2 ? LastCommonAncestor(block1, block2) : nullptr;
             // Using & instead of && below to avoid short circuiting and leaving
             // output uninitialized. Cast bool to int to avoid
             // -Wbitwise-instead-of-logical compiler warnings.
             return int{FillBlock(ancestor, ancestor_out, lock, active)} &
                    int{FillBlock(block1, block1_out, lock, active)} &
                    int{FillBlock(block2, block2_out, lock, active)};
         }
         void findCoins(std::map<COutPoint, Coin> &coins) override {
             return FindCoins(m_node, coins);
         }
         double guessVerificationProgress(const BlockHash &block_hash) override {
             LOCK(cs_main);
             return GuessVerificationProgress(
                 Params().TxData(),
                 chainman().m_blockman.LookupBlockIndex(block_hash));
         }
         bool hasBlocks(const BlockHash &block_hash, int min_height,
                        std::optional<int> max_height) override {
             // hasBlocks returns true if all ancestors of block_hash in
             // specified range have block data (are not pruned), false if any
             // ancestors in specified range are missing data.
             //
             // For simplicity and robustness, min_height and max_height are only
             // used to limit the range, and passing min_height that's too low or
             // max_height that's too high will not crash or change the result.
             LOCK(::cs_main);
             if (const CBlockIndex *block =
                     chainman().m_blockman.LookupBlockIndex(block_hash)) {
                 if (max_height && block->nHeight >= *max_height) {
                     block = block->GetAncestor(*max_height);
                 }
                 for (; block->nStatus.hasData(); block = block->pprev) {
                     // Check pprev to not segfault if min_height is too low
                     if (block->nHeight <= min_height || !block->pprev) {
                         return true;
                     }
                 }
             }
             return false;
         }
         bool hasDescendantsInMempool(const TxId &txid) override {
             if (!m_node.mempool) {
                 return false;
             }
             LOCK(m_node.mempool->cs);
             auto it = m_node.mempool->GetIter(txid);
             return it && (*it)->GetCountWithDescendants() > 1;
         }
         bool broadcastTransaction(const Config &config,
                                   const CTransactionRef &tx,
                                   const Amount &max_tx_fee, bool relay,
                                   std::string &err_string) override {
             const TransactionError err = BroadcastTransaction(
                 m_node, config, tx, err_string, max_tx_fee, relay,
                 /*wait_callback=*/false);
             // Chain clients only care about failures to accept the tx to the
             // mempool. Disregard non-mempool related failures. Note: this will
             // need to be updated if BroadcastTransactions() is updated to
             // return other non-mempool failures that Chain clients do not need
             // to know about.
             return err == TransactionError::OK;
         }
-        void getTransactionAncestry(const TxId &txid, size_t &ancestors,
-                                    size_t &descendants, size_t *ancestorsize,
-                                    Amount *ancestorfees) override {
-            ancestors = descendants = 0;
-            // After wellington this stat will no longer exist
-            if (!m_node.mempool || m_node.mempool->wellingtonLatched) {
-                return;
-            }
-            m_node.mempool->GetTransactionAncestry(txid, ancestors, descendants,
-                                                   ancestorsize, ancestorfees);
-        }
         void getPackageLimits(size_t &limit_ancestor_count,
                               size_t &limit_descendant_count) override {
             limit_ancestor_count = size_t(
                 std::max<int64_t>(1, gArgs.GetIntArg("-limitancestorcount",
                                                      DEFAULT_ANCESTOR_LIMIT)));
             limit_descendant_count = size_t(std::max<int64_t>(
                 1, gArgs.GetIntArg("-limitdescendantcount",
                                    DEFAULT_DESCENDANT_LIMIT)));
         }
-        bool checkChainLimits(const CTransactionRef &tx) override {
-            // After wellington this limitation will no longer exist
-            if (!m_node.mempool || m_node.mempool->wellingtonLatched) {
-                return true;
-            }
-            LockPoints lp;
-            CTxMemPoolEntry entry(tx, Amount(), 0, 0, false, 0, lp);
-            CTxMemPool::setEntries ancestors;
-            auto limit_ancestor_count =
-                gArgs.GetIntArg("-limitancestorcount", DEFAULT_ANCESTOR_LIMIT);
-            auto limit_ancestor_size =
-                gArgs.GetIntArg("-limitancestorsize",
-                                DEFAULT_ANCESTOR_SIZE_LIMIT) *
-                1000;
-            auto limit_descendant_count = gArgs.GetIntArg(
-                "-limitdescendantcount", DEFAULT_DESCENDANT_LIMIT);
-            auto limit_descendant_size =
-                gArgs.GetIntArg("-limitdescendantsize",
-                                DEFAULT_DESCENDANT_SIZE_LIMIT) *
-                1000;
-            std::string unused_error_string;
-            LOCK(m_node.mempool->cs);
-            return m_node.mempool->CalculateMemPoolAncestors(
-                entry, ancestors, limit_ancestor_count, limit_ancestor_size,
-                limit_descendant_count, limit_descendant_size,
-                unused_error_string);
-        }
         CFeeRate estimateFee() const override {
             if (!m_node.mempool) {
                 return {};
             }
             return m_node.mempool->estimateFee();
         }
         CFeeRate relayMinFee() override { return ::minRelayTxFee; }
         CFeeRate relayDustFee() override { return ::dustRelayFee; }
         bool havePruned() override {
             LOCK(cs_main);
             return m_node.chainman->m_blockman.m_have_pruned;
         }
         bool isReadyToBroadcast() override {
             return !node::fImporting && !node::fReindex &&
                    !isInitialBlockDownload();
         }
         bool isInitialBlockDownload() override {
             return chainman().ActiveChainstate().IsInitialBlockDownload();
         }
         bool shutdownRequested() override { return ShutdownRequested(); }
         int64_t getAdjustedTime() override { return GetAdjustedTime(); }
         void initMessage(const std::string &message) override {
             ::uiInterface.InitMessage(message);
         }
         void initWarning(const bilingual_str &message) override {
             InitWarning(message);
         }
         void initError(const bilingual_str &message) override {
             InitError(message);
         }
         void showProgress(const std::string &title, int progress,
                           bool resume_possible) override {
             ::uiInterface.ShowProgress(title, progress, resume_possible);
         }
         std::unique_ptr<Handler> handleNotifications(
             std::shared_ptr<Notifications> notifications) override {
             return std::make_unique<NotificationsHandlerImpl>(
                 std::move(notifications));
         }
         void
         waitForNotificationsIfTipChanged(const BlockHash &old_tip) override {
             if (!old_tip.IsNull()) {
                 LOCK(::cs_main);
                 const CChain &active = Assert(m_node.chainman)->ActiveChain();
                 if (old_tip == active.Tip()->GetBlockHash()) {
                     return;
                 }
             }
             SyncWithValidationInterfaceQueue();
         }
 
         std::unique_ptr<Handler>
         handleRpc(const CRPCCommand &command) override {
             return std::make_unique<RpcHandlerImpl>(command);
         }
         bool rpcEnableDeprecated(const std::string &method) override {
             return IsDeprecatedRPCEnabled(gArgs, method);
         }
         void rpcRunLater(const std::string &name, std::function<void()> fn,
                          int64_t seconds) override {
             RPCRunLater(name, std::move(fn), seconds);
         }
         int rpcSerializationFlags() override { return RPCSerializationFlags(); }
         util::SettingsValue getRwSetting(const std::string &name) override {
             util::SettingsValue result;
             gArgs.LockSettings([&](const util::Settings &settings) {
                 if (const util::SettingsValue *value =
                         util::FindKey(settings.rw_settings, name)) {
                     result = *value;
                 }
             });
             return result;
         }
         bool updateRwSetting(const std::string &name,
                              const util::SettingsValue &value) override {
             gArgs.LockSettings([&](util::Settings &settings) {
                 if (value.isNull()) {
                     settings.rw_settings.erase(name);
                 } else {
                     settings.rw_settings[name] = value;
                 }
             });
             return gArgs.WriteSettingsFile();
         }
         void requestMempoolTransactions(Notifications &notifications) override {
             if (!m_node.mempool) {
                 return;
             }
             LOCK2(::cs_main, m_node.mempool->cs);
             for (const CTxMemPoolEntry &entry : m_node.mempool->mapTx) {
                 notifications.transactionAddedToMempool(entry.GetSharedTx(),
                                                         /*mempool_sequence=*/0);
             }
         }
         const CChainParams &params() const override { return m_params; }
         NodeContext &m_node;
         const CChainParams &m_params;
     };
 } // namespace
 } // namespace node
 
 namespace interfaces {
 std::unique_ptr<Node> MakeNode(node::NodeContext *context) {
     return std::make_unique<node::NodeImpl>(context);
 }
 std::unique_ptr<Chain> MakeChain(node::NodeContext &node,
                                  const CChainParams &params) {
     return std::make_unique<node::ChainImpl>(node, params);
 }
 } // namespace interfaces
diff --git a/src/test/activation_tests.cpp b/src/test/activation_tests.cpp
index 0ba409e75..b0cda6803 100644
--- a/src/test/activation_tests.cpp
+++ b/src/test/activation_tests.cpp
@@ -1,130 +1,80 @@
 // 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.
 
 #include <chain.h>
 #include <chainparams.h>
 #include <config.h>
 #include <consensus/activation.h>
 #include <script/script.h>
 #include <txmempool.h>
 #include <util/check.h>
 #include <util/system.h>
 #include <validation.h>
 
 #include <test/util/blockindex.h>
 #include <test/util/mining.h>
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 BOOST_FIXTURE_TEST_SUITE(activation_tests, BasicTestingSetup)
 
 static void testPastActivation(
     std::function<bool(const Consensus::Params &, const CBlockIndex *)> func,
     const Consensus::Params &params, int activationHeight) {
     BOOST_CHECK(!func(params, nullptr));
 
     std::array<CBlockIndex, 4> blocks;
     blocks[0].nHeight = activationHeight - 2;
     for (size_t i = 1; i < blocks.size(); ++i) {
         blocks[i].pprev = &blocks[i - 1];
         blocks[i].nHeight = blocks[i - 1].nHeight + 1;
     }
 
     BOOST_CHECK(!func(params, &blocks[0]));
     BOOST_CHECK(!func(params, &blocks[1]));
     BOOST_CHECK(func(params, &blocks[2]));
     BOOST_CHECK(func(params, &blocks[3]));
 }
 
 BOOST_AUTO_TEST_CASE(test_previous_activations_by_height) {
     const auto params = CreateChainParams(CBaseChainParams::MAIN);
     const auto consensus = params->GetConsensus();
 
     testPastActivation(IsGravitonEnabled, consensus, consensus.gravitonHeight);
     testPastActivation(IsPhononEnabled, consensus, consensus.phononHeight);
     testPastActivation(IsAxionEnabled, consensus, consensus.axionHeight);
     testPastActivation(IsGluonEnabled, consensus, consensus.gluonHeight);
 }
 
 BOOST_AUTO_TEST_CASE(iswellingtonenabled) {
     const Consensus::Params &params = Params().GetConsensus();
     const auto activation = gArgs.GetIntArg("-wellingtonactivationtime",
                                             params.wellingtonActivationTime);
     SetMockTime(activation - 1000000);
 
     BOOST_CHECK(!IsWellingtonEnabled(params, nullptr));
 
     std::array<CBlockIndex, 12> blocks;
     for (size_t i = 1; i < blocks.size(); ++i) {
         blocks[i].pprev = &blocks[i - 1];
     }
     BOOST_CHECK(!IsWellingtonEnabled(params, &blocks.back()));
     BOOST_CHECK(
         !IsWellingtonEnabled(params, blocks.back().GetMedianTimePast()));
 
     SetMTP(blocks, activation - 1);
     BOOST_CHECK(!IsWellingtonEnabled(params, &blocks.back()));
     BOOST_CHECK(!IsWellingtonEnabled(params, activation - 1));
 
     SetMTP(blocks, activation);
     BOOST_CHECK(IsWellingtonEnabled(params, &blocks.back()));
     BOOST_CHECK(IsWellingtonEnabled(params, activation));
 
     SetMTP(blocks, activation + 1);
     BOOST_CHECK(IsWellingtonEnabled(params, &blocks.back()));
     BOOST_CHECK(IsWellingtonEnabled(params, activation + 1));
 }
 
-BOOST_FIXTURE_TEST_CASE(wellington_latch, RegTestingSetup) {
-    const Consensus::Params &params = Params().GetConsensus();
-    const auto activation = gArgs.GetIntArg("-wellingtonactivationtime",
-                                            params.wellingtonActivationTime);
-    SetMockTime(activation - 1000000);
-
-    const Config &config = GetConfig();
-    auto &mempool = *Assert(m_node.mempool);
-    auto &chainman = *Assert(m_node.chainman);
-    auto &activeChainstate = chainman.ActiveChainstate();
-
-    std::array<CBlockIndex, 12> blocks;
-    for (size_t i = 1; i < blocks.size() - 1; ++i) {
-        blocks[i].pprev = &blocks[i - 1];
-    }
-    // Hack: we need to call MineBlock to avoid null pointer dereference in
-    // ATMP. Let's make sure it's our tip so SetMTP works as expected.
-    MineBlock(config, m_node, CScript() << OP_TRUE);
-    blocks[11] = *activeChainstate.m_chain.Tip();
-    blocks[11].pprev = &blocks[10];
-    activeChainstate.m_chain.SetTip(&blocks[11]);
-
-    auto submitTxToMemPool = [&config, &activeChainstate]() {
-        LOCK(cs_main);
-        return AcceptToMemoryPool(config, activeChainstate,
-                                  MakeTransactionRef(),
-                                  /*accept_time=*/0,
-                                  /*bypass_limits=*/false);
-    };
-
-    BOOST_CHECK(!IsWellingtonEnabled(params, &blocks.back()));
-    submitTxToMemPool();
-    BOOST_CHECK(!mempool.wellingtonLatched);
-
-    // Activate Wellington
-    SetMTP(blocks, activation);
-    BOOST_CHECK(IsWellingtonEnabled(params, &blocks.back()));
-
-    // Upon first tx submission, the flag is latched
-    BOOST_CHECK(!mempool.wellingtonLatched);
-    submitTxToMemPool();
-    BOOST_CHECK(mempool.wellingtonLatched);
-
-    // Simulate a reorg and check the flag did latch
-    SetMTP(blocks, activation - 1);
-    BOOST_CHECK(mempool.wellingtonLatched);
-    submitTxToMemPool();
-    BOOST_CHECK(mempool.wellingtonLatched);
-}
-
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/mempool_tests.cpp b/src/test/mempool_tests.cpp
index 8a30cbf92..1557bd96e 100644
--- a/src/test/mempool_tests.cpp
+++ b/src/test/mempool_tests.cpp
@@ -1,995 +1,584 @@
 // Copyright (c) 2011-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 <txmempool.h>
 
 #include <policy/settings.h>
 #include <reverse_iterator.h>
 #include <util/system.h>
 #include <util/time.h>
 
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <algorithm>
 #include <vector>
 
 BOOST_FIXTURE_TEST_SUITE(mempool_tests, TestingSetup)
 
-// this test should be removed after wellington is checkpointed
-BOOST_AUTO_TEST_CASE(TestPreAndPostWellingtonAccounting) {
-    for (const bool wellington : {false, true}) {
-        CTxMemPool testPool;
-        // test pre-wellington versus post-wellington behavior
-        testPool.wellingtonLatched = wellington;
-        LOCK2(cs_main, testPool.cs);
-        TestMemPoolEntryHelper entry;
-        CMutableTransaction parentOfAll;
-
-        // Vector to track unspent outputs that are used to construct txs
-        std::vector<CTxIn> outpoints;
-        const size_t maxOutputs = 3;
-
-        // Construct a parent for the rest of the chain
-        parentOfAll.vin.resize(1);
-        parentOfAll.vin[0].scriptSig = CScript();
-        // Give us a couple outpoints so we can spend them
-        for (size_t i = 0; i < maxOutputs; i++) {
-            parentOfAll.vout.emplace_back(10 * SATOSHI, CScript() << OP_TRUE);
-        }
-        TxId parentOfAllId = parentOfAll.GetId();
-        testPool.addUnchecked(entry.SigChecks(0).FromTx(parentOfAll));
-
-        // Add some outpoints to the tracking vector
-        for (size_t i = 0; i < maxOutputs; i++) {
-            outpoints.emplace_back(COutPoint(parentOfAllId, i));
-        }
-
-        Amount totalFee = Amount::zero();
-        size_t totalSize = CTransaction(parentOfAll).GetTotalSize();
-        size_t totalVirtualSize = totalSize;
-        int64_t totalSigChecks = 0;
-
-        // Generate 100 transactions
-        for (size_t totalTransactions = 0; totalTransactions < 100;
-             totalTransactions++) {
-            CMutableTransaction tx;
-
-            uint64_t minAncestors = std::numeric_limits<size_t>::max();
-            uint64_t maxAncestors = 0;
-            Amount minFees = MAX_MONEY;
-            Amount maxFees = Amount::zero();
-            uint64_t minSize = std::numeric_limits<size_t>::max();
-            uint64_t maxSize = 0;
-            uint64_t minVirtualSize = std::numeric_limits<size_t>::max();
-            uint64_t maxVirtualSize = 0;
-            int64_t minSigChecks = std::numeric_limits<int64_t>::max();
-            int64_t maxSigChecks = 0;
-
-            // Consume random inputs, but make sure we don't consume more than
-            // available
-            for (size_t input = std::min(InsecureRandRange(maxOutputs) + 1,
-                                         uint64_t(outpoints.size()));
-                 input > 0; input--) {
-                std::swap(outpoints[InsecureRandRange(outpoints.size())],
-                          outpoints.back());
-                tx.vin.emplace_back(outpoints.back());
-                outpoints.pop_back();
-
-                // We don't know exactly how many ancestors this transaction has
-                // due to possible duplicates.  Calculate a valid range based on
-                // parents.
-
-                const CTxMemPoolEntry &parent =
-                    *testPool.mapTx.find(tx.vin.back().prevout.GetTxId());
-
-                minAncestors =
-                    std::min(minAncestors, parent.GetCountWithAncestors());
-                maxAncestors += parent.GetCountWithAncestors();
-                minFees = std::min(minFees, parent.GetModFeesWithAncestors());
-                maxFees += parent.GetModFeesWithAncestors();
-                minSize = std::min(minSize, parent.GetSizeWithAncestors());
-                maxSize += parent.GetSizeWithAncestors();
-                minVirtualSize =
-                    std::min(minSize, parent.GetVirtualSizeWithAncestors());
-                maxVirtualSize += parent.GetVirtualSizeWithAncestors();
-                minSigChecks =
-                    std::min(minSigChecks, parent.GetSigChecksWithAncestors());
-                maxSigChecks += parent.GetSigChecksWithAncestors();
-            }
-
-            // Produce random number of outputs
-            for (size_t output = InsecureRandRange(maxOutputs) + 1; output > 0;
-                 output--) {
-                tx.vout.emplace_back(10 * SATOSHI, CScript() << OP_TRUE);
-            }
-
-            TxId curId = tx.GetId();
-
-            // Record the outputs
-            for (size_t output = tx.vout.size(); output > 0; output--) {
-                outpoints.emplace_back(COutPoint(curId, output));
-            }
-
-            const Amount randFee = int64_t(InsecureRandRange(300)) * SATOSHI;
-            const int randSigChecks = InsecureRandRange(5);
-
-            testPool.addUnchecked(
-                entry.Fee(randFee).SigChecks(randSigChecks).FromTx(tx));
-
-            // Add this transaction to the totals.
-            minAncestors += 1;
-            maxAncestors += 1;
-            minFees += randFee;
-            maxFees += randFee;
-            minSize += CTransaction(tx).GetTotalSize();
-            maxSize += CTransaction(tx).GetTotalSize();
-            // virtualsize is a nonlinear function of its arguments, so we can't
-            // make as strong guarantees about its range; but assuming
-            // virtualsize is monotonically increasing in each argument, we can
-            // say the following:
-            minVirtualSize += 0;
-            maxVirtualSize += GetVirtualTransactionSize(
-                CTransaction(tx).GetTotalSize(), randSigChecks);
-            minSigChecks += randSigChecks;
-            maxSigChecks += randSigChecks;
-
-            // Calculate overall values
-            totalFee += randFee;
-            totalSize += CTransaction(tx).GetTotalSize();
-            totalVirtualSize += GetVirtualTransactionSize(
-                CTransaction(tx).GetTotalSize(), randSigChecks);
-            totalSigChecks += randSigChecks;
-            const CTxMemPoolEntry &parentEntry =
-                *testPool.mapTx.find(parentOfAllId);
-            const CTxMemPoolEntry &latestEntry = *testPool.mapTx.find(curId);
-
-            // Based on size/sigChecks ranges we can compute more strict bounds
-            // for the virtual size ranges/totals, assuming virtualsize is
-            // monotonic in each argument.
-            uint64_t minVirtualSize_strict =
-                GetVirtualTransactionSize(minSize, minSigChecks);
-            uint64_t maxVirtualSize_strict =
-                GetVirtualTransactionSize(maxSize, maxSigChecks);
-            uint64_t totalVirtualSize_strict =
-                GetVirtualTransactionSize(totalSize, totalSigChecks);
-
-            if (!wellington) {
-                // these are as-good or better than the earlier estimations.
-                BOOST_CHECK(minVirtualSize_strict >= minVirtualSize);
-                BOOST_CHECK(maxVirtualSize_strict <= maxVirtualSize);
-                BOOST_CHECK(totalVirtualSize_strict <= totalVirtualSize);
-
-                // Ensure values are within the expected ranges
-                BOOST_CHECK(latestEntry.GetCountWithAncestors() >=
-                            minAncestors);
-                BOOST_CHECK(latestEntry.GetCountWithAncestors() <=
-                            maxAncestors);
-
-                BOOST_CHECK(latestEntry.GetSizeWithAncestors() >= minSize);
-                BOOST_CHECK(latestEntry.GetSizeWithAncestors() <= maxSize);
-
-                BOOST_CHECK(latestEntry.GetVirtualSizeWithAncestors() >=
-                            minVirtualSize_strict);
-                BOOST_CHECK(latestEntry.GetVirtualSizeWithAncestors() <=
-                            maxVirtualSize_strict);
-
-                BOOST_CHECK(latestEntry.GetSigChecksWithAncestors() >=
-                            minSigChecks);
-                BOOST_CHECK(latestEntry.GetSigChecksWithAncestors() <=
-                            maxSigChecks);
-
-                BOOST_CHECK(latestEntry.GetModFeesWithAncestors() >= minFees);
-                BOOST_CHECK(latestEntry.GetModFeesWithAncestors() <= maxFees);
-
-                BOOST_CHECK_EQUAL(parentEntry.GetCountWithDescendants(),
-                                  testPool.mapTx.size());
-                BOOST_CHECK_EQUAL(parentEntry.GetSizeWithDescendants(),
-                                  totalSize);
-                BOOST_CHECK_EQUAL(parentEntry.GetVirtualSizeWithDescendants(),
-                                  totalVirtualSize_strict);
-                BOOST_CHECK_EQUAL(parentEntry.GetModFeesWithDescendants(),
-                                  totalFee);
-                BOOST_CHECK_EQUAL(parentEntry.GetSigChecksWithDescendants(),
-                                  totalSigChecks);
-            } else {
-                // with wellington latched, we stop tracking these -- they stay
-                // at their defaults
-                BOOST_CHECK_EQUAL(latestEntry.GetCountWithAncestors(), 1);
-                BOOST_CHECK_EQUAL(latestEntry.GetSizeWithAncestors(),
-                                  latestEntry.GetTxSize());
-                BOOST_CHECK_EQUAL(latestEntry.GetVirtualSizeWithAncestors(),
-                                  latestEntry.GetTxVirtualSize());
-                BOOST_CHECK_EQUAL(latestEntry.GetSigChecksWithAncestors(),
-                                  latestEntry.GetSigChecks());
-                BOOST_CHECK_EQUAL(latestEntry.GetModFeesWithAncestors(),
-                                  latestEntry.GetModifiedFee());
-
-                BOOST_CHECK_EQUAL(parentEntry.GetCountWithDescendants(), 1);
-                BOOST_CHECK_EQUAL(parentEntry.GetSizeWithDescendants(),
-                                  parentEntry.GetTxSize());
-                BOOST_CHECK_EQUAL(parentEntry.GetVirtualSizeWithDescendants(),
-                                  parentEntry.GetTxVirtualSize());
-                BOOST_CHECK_EQUAL(parentEntry.GetModFeesWithDescendants(),
-                                  parentEntry.GetModifiedFee());
-                BOOST_CHECK_EQUAL(parentEntry.GetSigChecks(), 0);
-                BOOST_CHECK_EQUAL(parentEntry.GetSigChecksWithDescendants(), 0);
-            }
-            // Verify that wellington activation status didn't accidentally
-            // change during the test.
-            BOOST_CHECK_EQUAL(testPool.wellingtonLatched, wellington);
-        }
-    }
-}
-
 static constexpr auto REMOVAL_REASON_DUMMY = MemPoolRemovalReason::REPLACED;
 
 BOOST_AUTO_TEST_CASE(MempoolRemoveTest) {
     // Test CTxMemPool::remove functionality
 
     TestMemPoolEntryHelper entry;
     // Parent transaction with three children, and three grand-children:
     CMutableTransaction txParent;
     txParent.vin.resize(1);
     txParent.vin[0].scriptSig = CScript() << OP_11;
     txParent.vout.resize(3);
     for (int i = 0; i < 3; i++) {
         txParent.vout[i].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
         txParent.vout[i].nValue = 33000 * SATOSHI;
     }
     CMutableTransaction txChild[3];
     for (int i = 0; i < 3; i++) {
         txChild[i].vin.resize(1);
         txChild[i].vin[0].scriptSig = CScript() << OP_11;
         txChild[i].vin[0].prevout = COutPoint(txParent.GetId(), i);
         txChild[i].vout.resize(1);
         txChild[i].vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
         txChild[i].vout[0].nValue = 11000 * SATOSHI;
     }
     CMutableTransaction txGrandChild[3];
     for (int i = 0; i < 3; i++) {
         txGrandChild[i].vin.resize(1);
         txGrandChild[i].vin[0].scriptSig = CScript() << OP_11;
         txGrandChild[i].vin[0].prevout = COutPoint(txChild[i].GetId(), 0);
         txGrandChild[i].vout.resize(1);
         txGrandChild[i].vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
         txGrandChild[i].vout[0].nValue = 11000 * SATOSHI;
     }
 
     CTxMemPool testPool;
     LOCK2(cs_main, testPool.cs);
 
     // Nothing in pool, remove should do nothing:
     unsigned int poolSize = testPool.size();
     testPool.removeRecursive(CTransaction(txParent), REMOVAL_REASON_DUMMY);
     BOOST_CHECK_EQUAL(testPool.size(), poolSize);
 
     // Just the parent:
     testPool.addUnchecked(entry.FromTx(txParent));
     poolSize = testPool.size();
     testPool.removeRecursive(CTransaction(txParent), REMOVAL_REASON_DUMMY);
     BOOST_CHECK_EQUAL(testPool.size(), poolSize - 1);
 
     // Parent, children, grandchildren:
     testPool.addUnchecked(entry.FromTx(txParent));
     for (int i = 0; i < 3; i++) {
         testPool.addUnchecked(entry.FromTx(txChild[i]));
         testPool.addUnchecked(entry.FromTx(txGrandChild[i]));
     }
     // Remove Child[0], GrandChild[0] should be removed:
     poolSize = testPool.size();
     testPool.removeRecursive(CTransaction(txChild[0]), REMOVAL_REASON_DUMMY);
     BOOST_CHECK_EQUAL(testPool.size(), poolSize - 2);
     // ... make sure grandchild and child are gone:
     poolSize = testPool.size();
     testPool.removeRecursive(CTransaction(txGrandChild[0]),
                              REMOVAL_REASON_DUMMY);
     BOOST_CHECK_EQUAL(testPool.size(), poolSize);
     poolSize = testPool.size();
     testPool.removeRecursive(CTransaction(txChild[0]), REMOVAL_REASON_DUMMY);
     BOOST_CHECK_EQUAL(testPool.size(), poolSize);
     // Remove parent, all children/grandchildren should go:
     poolSize = testPool.size();
     testPool.removeRecursive(CTransaction(txParent), REMOVAL_REASON_DUMMY);
     BOOST_CHECK_EQUAL(testPool.size(), poolSize - 5);
     BOOST_CHECK_EQUAL(testPool.size(), 0UL);
 
     // Add children and grandchildren, but NOT the parent (simulate the parent
     // being in a block)
     for (int i = 0; i < 3; i++) {
         testPool.addUnchecked(entry.FromTx(txChild[i]));
         testPool.addUnchecked(entry.FromTx(txGrandChild[i]));
     }
 
     // Now remove the parent, as might happen if a block-re-org occurs but the
     // parent cannot be put into the mempool (maybe because it is non-standard):
     poolSize = testPool.size();
     testPool.removeRecursive(CTransaction(txParent), REMOVAL_REASON_DUMMY);
     BOOST_CHECK_EQUAL(testPool.size(), poolSize - 6);
     BOOST_CHECK_EQUAL(testPool.size(), 0UL);
 }
 
 BOOST_AUTO_TEST_CASE(MempoolClearTest) {
     // Test CTxMemPool::clear functionality
 
     TestMemPoolEntryHelper entry;
     // Create a transaction
     CMutableTransaction txParent;
     txParent.vin.resize(1);
     txParent.vin[0].scriptSig = CScript() << OP_11;
     txParent.vout.resize(3);
     for (int i = 0; i < 3; i++) {
         txParent.vout[i].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
         txParent.vout[i].nValue = 33000 * SATOSHI;
     }
 
     CTxMemPool testPool;
     LOCK2(cs_main, testPool.cs);
 
     // Nothing in pool, clear should do nothing:
     testPool.clear();
     BOOST_CHECK_EQUAL(testPool.size(), 0UL);
 
     // Add the transaction
     testPool.addUnchecked(entry.FromTx(txParent));
     BOOST_CHECK_EQUAL(testPool.size(), 1UL);
     BOOST_CHECK_EQUAL(testPool.mapTx.size(), 1UL);
     BOOST_CHECK_EQUAL(testPool.mapNextTx.size(), 1UL);
 
     // CTxMemPool's members should be empty after a clear
     testPool.clear();
     BOOST_CHECK_EQUAL(testPool.size(), 0UL);
     BOOST_CHECK_EQUAL(testPool.mapTx.size(), 0UL);
     BOOST_CHECK_EQUAL(testPool.mapNextTx.size(), 0UL);
 }
 
 template <typename name>
 static void CheckSort(CTxMemPool &pool, std::vector<std::string> &sortedOrder,
                       const std::string &testcase)
     EXCLUSIVE_LOCKS_REQUIRED(pool.cs) {
     BOOST_CHECK_EQUAL(pool.size(), sortedOrder.size());
     typename CTxMemPool::indexed_transaction_set::index<name>::type::iterator
         it = pool.mapTx.get<name>().begin();
     int count = 0;
     for (; it != pool.mapTx.get<name>().end(); ++it, ++count) {
         BOOST_CHECK_MESSAGE(it->GetTx().GetId().ToString() ==
                                 sortedOrder[count],
                             it->GetTx().GetId().ToString()
                                 << " != " << sortedOrder[count] << " in test "
                                 << testcase << ":" << count);
     }
 }
 
 BOOST_AUTO_TEST_CASE(MempoolIndexingTest) {
     CTxMemPool pool;
     LOCK2(cs_main, pool.cs);
     TestMemPoolEntryHelper entry;
 
     /**
      * Remove the default nonzero sigChecks, since the below tests are
      * focussing on fee-based ordering and involve some artificially very tiny
      * 21-byte transactions without any inputs.
      */
     entry.SigChecks(0);
 
     /* 3rd highest fee */
     CMutableTransaction tx1 = CMutableTransaction();
     tx1.vout.resize(1);
     tx1.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
     tx1.vout[0].nValue = 10 * COIN;
 
     /* highest fee */
     CMutableTransaction tx2 = CMutableTransaction();
     tx2.vout.resize(1);
     tx2.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
     tx2.vout[0].nValue = 2 * COIN;
     pool.addUnchecked(entry.Fee(20000 * SATOSHI).FromTx(tx2));
 
     /* lowest fee */
     CMutableTransaction tx3 = CMutableTransaction();
     tx3.vout.resize(1);
     tx3.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
     tx3.vout[0].nValue = 5 * COIN;
     pool.addUnchecked(entry.Fee(Amount::zero()).FromTx(tx3));
 
     /* 2nd highest fee */
     CMutableTransaction tx4 = CMutableTransaction();
     tx4.vout.resize(1);
     tx4.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
     tx4.vout[0].nValue = 6 * COIN;
     pool.addUnchecked(entry.Fee(15000 * SATOSHI).FromTx(tx4));
 
     /* equal fee rate to tx1, but arrived later to the mempool */
     CMutableTransaction tx5 = CMutableTransaction();
     tx5.vout.resize(1);
     tx5.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
     tx5.vout[0].nValue = 11 * COIN;
     pool.addUnchecked(entry.Fee(10000 * SATOSHI).Time(100).FromTx(tx1));
     pool.addUnchecked(entry.Fee(10000 * SATOSHI).Time(200).FromTx(tx5));
     BOOST_CHECK_EQUAL(pool.size(), 5UL);
 
     std::vector<std::string> sortedOrder;
     sortedOrder.resize(5);
     sortedOrder[0] = tx2.GetId().ToString(); // 20000
     sortedOrder[1] = tx4.GetId().ToString(); // 15000
     sortedOrder[3] = tx5.GetId().ToString(); // 10000
     sortedOrder[2] = tx1.GetId().ToString(); // 10000
     sortedOrder[4] = tx3.GetId().ToString(); // 0
     CheckSort<modified_feerate>(pool, sortedOrder, "MempoolIndexingTest1");
 }
 
 BOOST_AUTO_TEST_CASE(MempoolSizeLimitTest) {
     CTxMemPool pool;
     LOCK2(cs_main, pool.cs);
     TestMemPoolEntryHelper entry;
     Amount feeIncrement = MEMPOOL_FULL_FEE_INCREMENT.GetFeePerK();
 
     CMutableTransaction tx1 = CMutableTransaction();
     tx1.vin.resize(1);
     tx1.vin[0].scriptSig = CScript() << OP_1;
     tx1.vout.resize(1);
     tx1.vout[0].scriptPubKey = CScript() << OP_1 << OP_EQUAL;
     tx1.vout[0].nValue = 10 * COIN;
     pool.addUnchecked(entry.Fee(20000 * SATOSHI).FromTx(tx1));
 
     CMutableTransaction tx2 = CMutableTransaction();
     tx2.vin.resize(1);
     tx2.vin[0].scriptSig = CScript() << OP_2;
     tx2.vout.resize(1);
     tx2.vout[0].scriptPubKey = CScript() << OP_2 << OP_EQUAL;
     tx2.vout[0].nValue = 10 * COIN;
     pool.addUnchecked(entry.Fee(4000 * SATOSHI).FromTx(tx2));
 
     // should do nothing
     pool.TrimToSize(pool.DynamicMemoryUsage());
     BOOST_CHECK(pool.exists(tx1.GetId()));
     BOOST_CHECK(pool.exists(tx2.GetId()));
 
     // should remove the lower-feerate transaction
     pool.TrimToSize(pool.DynamicMemoryUsage() * 3 / 4);
     BOOST_CHECK(pool.exists(tx1.GetId()));
     BOOST_CHECK(!pool.exists(tx2.GetId()));
 
     pool.addUnchecked(entry.FromTx(tx2));
     CMutableTransaction tx3 = CMutableTransaction();
     tx3.vin.resize(1);
     tx3.vin[0].prevout = COutPoint(tx2.GetId(), 0);
     tx3.vin[0].scriptSig = CScript() << OP_2;
     tx3.vout.resize(1);
     tx3.vout[0].scriptPubKey = CScript() << OP_3 << OP_EQUAL;
     tx3.vout[0].nValue = 10 * COIN;
     pool.addUnchecked(entry.Fee(16000 * SATOSHI).FromTx(tx3));
 
     // tx2 should be removed, tx3 is a child of tx2, so it should be removed
     // even though it has highest fee.
     pool.TrimToSize(pool.DynamicMemoryUsage() * 3 / 4);
     BOOST_CHECK(pool.exists(tx1.GetId()));
     BOOST_CHECK(!pool.exists(tx2.GetId()));
     BOOST_CHECK(!pool.exists(tx3.GetId()));
 
     // mempool is limited to tx1's size in memory usage, so nothing fits
     std::vector<COutPoint> vNoSpendsRemaining;
     pool.TrimToSize(CTransaction(tx1).GetTotalSize(), &vNoSpendsRemaining);
     BOOST_CHECK(!pool.exists(tx1.GetId()));
     BOOST_CHECK(!pool.exists(tx2.GetId()));
     BOOST_CHECK(!pool.exists(tx3.GetId()));
     // This vector should only contain 'root' (not unconfirmed) outpoints
     // Though both tx2 and tx3 were removed, tx3's input came from tx2.
     BOOST_CHECK_EQUAL(vNoSpendsRemaining.size(), 1);
     BOOST_CHECK(vNoSpendsRemaining == std::vector<COutPoint>{COutPoint()});
 
     // maxFeeRateRemoved was set by the transaction with the highest fee,
     // that was not removed because it was a child of another tx.
     CFeeRate maxFeeRateRemoved(20000 * SATOSHI,
                                CTransaction(tx1).GetTotalSize());
     BOOST_CHECK_EQUAL(pool.GetMinFee(1).GetFeePerK(),
                       maxFeeRateRemoved.GetFeePerK() + feeIncrement);
 
     CMutableTransaction tx4 = CMutableTransaction();
     tx4.vin.resize(2);
     tx4.vin[0].prevout = COutPoint();
     tx4.vin[0].scriptSig = CScript() << OP_4;
     tx4.vin[1].prevout = COutPoint();
     tx4.vin[1].scriptSig = CScript() << OP_4;
     tx4.vout.resize(2);
     tx4.vout[0].scriptPubKey = CScript() << OP_4 << OP_EQUAL;
     tx4.vout[0].nValue = 10 * COIN;
     tx4.vout[1].scriptPubKey = CScript() << OP_4 << OP_EQUAL;
     tx4.vout[1].nValue = 10 * COIN;
 
     CMutableTransaction tx5 = CMutableTransaction();
     tx5.vin.resize(2);
     tx5.vin[0].prevout = COutPoint(tx4.GetId(), 0);
     tx5.vin[0].scriptSig = CScript() << OP_4;
     tx5.vin[1].prevout = COutPoint();
     tx5.vin[1].scriptSig = CScript() << OP_5;
     tx5.vout.resize(2);
     tx5.vout[0].scriptPubKey = CScript() << OP_5 << OP_EQUAL;
     tx5.vout[0].nValue = 10 * COIN;
     tx5.vout[1].scriptPubKey = CScript() << OP_5 << OP_EQUAL;
     tx5.vout[1].nValue = 10 * COIN;
 
     CMutableTransaction tx6 = CMutableTransaction();
     tx6.vin.resize(2);
     tx6.vin[0].prevout = COutPoint(tx4.GetId(), 1);
     tx6.vin[0].scriptSig = CScript() << OP_4;
     tx6.vin[1].prevout = COutPoint();
     tx6.vin[1].scriptSig = CScript() << OP_6;
     tx6.vout.resize(2);
     tx6.vout[0].scriptPubKey = CScript() << OP_6 << OP_EQUAL;
     tx6.vout[0].nValue = 10 * COIN;
     tx6.vout[1].scriptPubKey = CScript() << OP_6 << OP_EQUAL;
     tx6.vout[1].nValue = 10 * COIN;
 
     CMutableTransaction tx7 = CMutableTransaction();
     tx7.vin.resize(2);
     tx7.vin[0].prevout = COutPoint(tx5.GetId(), 0);
     tx7.vin[0].scriptSig = CScript() << OP_5;
     tx7.vin[1].prevout = COutPoint(tx6.GetId(), 0);
     tx7.vin[1].scriptSig = CScript() << OP_6;
     tx7.vout.resize(2);
     tx7.vout[0].scriptPubKey = CScript() << OP_7 << OP_EQUAL;
     tx7.vout[0].nValue = 10 * COIN;
     tx7.vout[1].scriptPubKey = CScript() << OP_7 << OP_EQUAL;
     tx7.vout[1].nValue = 10 * COIN;
 
     pool.addUnchecked(entry.Fee(7000 * SATOSHI).FromTx(tx4));
     pool.addUnchecked(entry.Fee(1000 * SATOSHI).FromTx(tx5));
     pool.addUnchecked(entry.Fee(1100 * SATOSHI).FromTx(tx6));
     pool.addUnchecked(entry.Fee(9000 * SATOSHI).FromTx(tx7));
 
     // we only require this to remove, at max, 2 txn, because it's not clear
     // what we're really optimizing for aside from that
     pool.TrimToSize(pool.DynamicMemoryUsage() - 1);
     BOOST_CHECK(pool.exists(tx4.GetId()));
     BOOST_CHECK(pool.exists(tx6.GetId()));
     BOOST_CHECK(!pool.exists(tx7.GetId()));
 
     if (!pool.exists(tx5.GetId())) {
         pool.addUnchecked(entry.Fee(1000 * SATOSHI).FromTx(tx5));
     }
     pool.addUnchecked(entry.Fee(9000 * SATOSHI).FromTx(tx7));
 
     // should maximize mempool size by only removing 5/7
     pool.TrimToSize(pool.DynamicMemoryUsage() / 2);
     BOOST_CHECK(pool.exists(tx4.GetId()));
     BOOST_CHECK(!pool.exists(tx5.GetId()));
     BOOST_CHECK(pool.exists(tx6.GetId()));
     BOOST_CHECK(!pool.exists(tx7.GetId()));
 
     pool.addUnchecked(entry.Fee(1000 * SATOSHI).FromTx(tx5));
     pool.addUnchecked(entry.Fee(9000 * SATOSHI).FromTx(tx7));
 
     std::vector<CTransactionRef> vtx;
     SetMockTime(42);
     SetMockTime(42 + CTxMemPool::ROLLING_FEE_HALFLIFE);
     BOOST_CHECK_EQUAL(pool.GetMinFee(1).GetFeePerK(),
                       maxFeeRateRemoved.GetFeePerK() + feeIncrement);
     // ... we should keep the same min fee until we get a block
     pool.removeForBlock(vtx);
     SetMockTime(42 + 2 * CTxMemPool::ROLLING_FEE_HALFLIFE);
     BOOST_CHECK_EQUAL(pool.GetMinFee(1).GetFeePerK(),
                       (maxFeeRateRemoved.GetFeePerK() + feeIncrement) / 2);
     // ... then feerate should drop 1/2 each halflife
 
     SetMockTime(42 + 2 * CTxMemPool::ROLLING_FEE_HALFLIFE +
                 CTxMemPool::ROLLING_FEE_HALFLIFE / 2);
 
     BOOST_CHECK_EQUAL(
         pool.GetMinFee(pool.DynamicMemoryUsage() * 5 / 2).GetFeePerK(),
         (maxFeeRateRemoved.GetFeePerK() + feeIncrement) / 4);
     // ... with a 1/2 halflife when mempool is < 1/2 its target size
 
     SetMockTime(42 + 2 * CTxMemPool::ROLLING_FEE_HALFLIFE +
                 CTxMemPool::ROLLING_FEE_HALFLIFE / 2 +
                 CTxMemPool::ROLLING_FEE_HALFLIFE / 4);
     BOOST_CHECK_EQUAL(
         pool.GetMinFee(pool.DynamicMemoryUsage() * 9 / 2).GetFeePerK(),
         (maxFeeRateRemoved.GetFeePerK() + feeIncrement) / 8 + SATOSHI);
     // ... with a 1/4 halflife when mempool is < 1/4 its target size
 }
 
 // expectedSize can be smaller than correctlyOrderedIds.size(), since we
 // might be testing intermediary states. Just avoiding some slice operations,
 void CheckDisconnectPoolOrder(DisconnectedBlockTransactions &disconnectPool,
                               std::vector<TxId> correctlyOrderedIds,
                               unsigned int expectedSize) {
     int i = 0;
     BOOST_CHECK_EQUAL(disconnectPool.GetQueuedTx().size(), expectedSize);
     // Txns in queuedTx's insertion_order index are sorted from children to
     // parent txn
     for (const CTransactionRef &tx :
          reverse_iterate(disconnectPool.GetQueuedTx().get<insertion_order>())) {
         BOOST_CHECK(tx->GetId() == correctlyOrderedIds[i]);
         i++;
     }
 }
 
 typedef std::vector<CMutableTransaction *> vecptx;
 
 BOOST_AUTO_TEST_CASE(TestImportMempool) {
     CMutableTransaction chainedTxn[5];
     std::vector<TxId> correctlyOrderedIds;
     COutPoint lastOutpoint;
 
     // Construct a chain of 5 transactions
     for (int i = 0; i < 5; i++) {
         chainedTxn[i].vin.emplace_back(lastOutpoint);
         chainedTxn[i].vout.emplace_back(10 * SATOSHI, CScript() << OP_TRUE);
         correctlyOrderedIds.push_back(chainedTxn[i].GetId());
         lastOutpoint = COutPoint(correctlyOrderedIds[i], 0);
     }
 
     // The first 3 txns simulate once confirmed transactions that have been
     // disconnected. We test 3 different orders: in order, one case of mixed
     // order and inverted order.
     vecptx disconnectedTxnsInOrder = {&chainedTxn[0], &chainedTxn[1],
                                       &chainedTxn[2]};
     vecptx disconnectedTxnsMixedOrder = {&chainedTxn[1], &chainedTxn[2],
                                          &chainedTxn[0]};
     vecptx disconnectedTxnsInvertedOrder = {&chainedTxn[2], &chainedTxn[1],
                                             &chainedTxn[0]};
 
     // The last 2 txns simulate a chain of unconfirmed transactions in the
     // mempool. We test 2 different orders: in and out of order.
     vecptx unconfTxnsInOrder = {&chainedTxn[3], &chainedTxn[4]};
     vecptx unconfTxnsOutOfOrder = {&chainedTxn[4], &chainedTxn[3]};
 
     // Now we test all combinations of the previously defined orders for
     // disconnected and unconfirmed txns. The expected outcome is to have these
     // transactions in the correct order in queuedTx, as defined in
     // correctlyOrderedIds.
     for (auto &disconnectedTxns :
          {disconnectedTxnsInOrder, disconnectedTxnsMixedOrder,
           disconnectedTxnsInvertedOrder}) {
         for (auto &unconfTxns : {unconfTxnsInOrder, unconfTxnsOutOfOrder}) {
             CTxMemPool testPool;
             // addForBlock inserts disconnectTxns in disconnectPool. They
             // simulate transactions that were once confirmed in a block
             std::vector<CTransactionRef> vtx;
             for (auto tx : disconnectedTxns) {
                 vtx.push_back(MakeTransactionRef(*tx));
             }
             DisconnectedBlockTransactions disconnectPool;
             LOCK(testPool.cs);
             {
                 disconnectPool.addForBlock(vtx, testPool);
                 CheckDisconnectPoolOrder(disconnectPool, correctlyOrderedIds,
                                          disconnectedTxns.size());
 
                 // If the mempool is empty, importMempool doesn't change
                 // disconnectPool
                 disconnectPool.importMempool(testPool);
                 CheckDisconnectPoolOrder(disconnectPool, correctlyOrderedIds,
                                          disconnectedTxns.size());
 
                 {
                     LOCK(cs_main);
                     // Add all unconfirmed transactions in testPool
                     for (auto tx : unconfTxns) {
                         TestMemPoolEntryHelper entry;
                         testPool.addUnchecked(entry.FromTx(*tx));
                     }
                 }
 
                 // Now we test importMempool with a non empty mempool
                 disconnectPool.importMempool(testPool);
             }
             CheckDisconnectPoolOrder(disconnectPool, correctlyOrderedIds,
                                      disconnectedTxns.size() +
                                          unconfTxns.size());
             // We must clear disconnectPool to not trigger the assert in its
             // destructor
             disconnectPool.clear();
         }
     }
 }
 
 inline CTransactionRef
 make_tx(std::vector<Amount> &&output_values,
         std::vector<CTransactionRef> &&inputs = std::vector<CTransactionRef>(),
         std::vector<uint32_t> &&input_indices = std::vector<uint32_t>()) {
     CMutableTransaction tx = CMutableTransaction();
     tx.vin.resize(inputs.size());
     tx.vout.resize(output_values.size());
     for (size_t i = 0; i < inputs.size(); ++i) {
         tx.vin[i].prevout =
             COutPoint(inputs[i]->GetId(),
                       input_indices.size() > i ? input_indices[i] : 0);
     }
     for (size_t i = 0; i < output_values.size(); ++i) {
         tx.vout[i].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
         tx.vout[i].nValue = output_values[i];
     }
     return MakeTransactionRef(tx);
 }
 
-BOOST_AUTO_TEST_CASE(MempoolAncestryTests) {
-    size_t ancestors, descendants;
-
-    CTxMemPool pool;
-    LOCK2(cs_main, pool.cs);
-    TestMemPoolEntryHelper entry;
-
-    /* Base transaction */
-    //
-    // [tx1]
-    //
-    CTransactionRef tx1 = make_tx(/* output_values */ {10 * COIN});
-    pool.addUnchecked(entry.Fee(10000 * SATOSHI).FromTx(tx1));
-
-    // Ancestors / descendants should be 1 / 1 (itself / itself)
-    pool.GetTransactionAncestry(tx1->GetId(), ancestors, descendants);
-    BOOST_CHECK_EQUAL(ancestors, 1ULL);
-    BOOST_CHECK_EQUAL(descendants, 1ULL);
-
-    /* Child transaction */
-    //
-    // [tx1].0 <- [tx2]
-    //
-    CTransactionRef tx2 =
-        make_tx(/* output_values */ {495 * CENT, 5 * COIN}, /* inputs */ {tx1});
-    pool.addUnchecked(entry.Fee(10000 * SATOSHI).FromTx(tx2));
-
-    // Ancestors / descendants should be:
-    // transaction  ancestors   descendants
-    // ============ =========== ===========
-    // tx1          1 (tx1)     2 (tx1,2)
-    // tx2          2 (tx1,2)   2 (tx1,2)
-    pool.GetTransactionAncestry(tx1->GetId(), ancestors, descendants);
-    BOOST_CHECK_EQUAL(ancestors, 1ULL);
-    BOOST_CHECK_EQUAL(descendants, 2ULL);
-    pool.GetTransactionAncestry(tx2->GetId(), ancestors, descendants);
-    BOOST_CHECK_EQUAL(ancestors, 2ULL);
-    BOOST_CHECK_EQUAL(descendants, 2ULL);
-
-    /* Grand-child 1 */
-    //
-    // [tx1].0 <- [tx2].0 <- [tx3]
-    //
-    CTransactionRef tx3 = make_tx(/* output_values */ {290 * CENT, 200 * CENT},
-                                  /* inputs */ {tx2});
-    pool.addUnchecked(entry.Fee(10000 * SATOSHI).FromTx(tx3));
-
-    // Ancestors / descendants should be:
-    // transaction  ancestors   descendants
-    // ============ =========== ===========
-    // tx1          1 (tx1)     3 (tx1,2,3)
-    // tx2          2 (tx1,2)   3 (tx1,2,3)
-    // tx3          3 (tx1,2,3) 3 (tx1,2,3)
-    pool.GetTransactionAncestry(tx1->GetId(), ancestors, descendants);
-    BOOST_CHECK_EQUAL(ancestors, 1ULL);
-    BOOST_CHECK_EQUAL(descendants, 3ULL);
-    pool.GetTransactionAncestry(tx2->GetId(), ancestors, descendants);
-    BOOST_CHECK_EQUAL(ancestors, 2ULL);
-    BOOST_CHECK_EQUAL(descendants, 3ULL);
-    pool.GetTransactionAncestry(tx3->GetId(), ancestors, descendants);
-    BOOST_CHECK_EQUAL(ancestors, 3ULL);
-    BOOST_CHECK_EQUAL(descendants, 3ULL);
-
-    /* Grand-child 2 */
-    //
-    // [tx1].0 <- [tx2].0 <- [tx3]
-    //              |
-    //              \---1 <- [tx4]
-    //
-    CTransactionRef tx4 = make_tx(/* output_values */ {290 * CENT, 250 * CENT},
-                                  /* inputs */ {tx2}, /* input_indices */ {1});
-    pool.addUnchecked(entry.Fee(10000 * SATOSHI).FromTx(tx4));
-
-    // Ancestors / descendants should be:
-    // transaction  ancestors   descendants
-    // ============ =========== ===========
-    // tx1          1 (tx1)     4 (tx1,2,3,4)
-    // tx2          2 (tx1,2)   4 (tx1,2,3,4)
-    // tx3          3 (tx1,2,3) 4 (tx1,2,3,4)
-    // tx4          3 (tx1,2,4) 4 (tx1,2,3,4)
-    pool.GetTransactionAncestry(tx1->GetId(), ancestors, descendants);
-    BOOST_CHECK_EQUAL(ancestors, 1ULL);
-    BOOST_CHECK_EQUAL(descendants, 4ULL);
-    pool.GetTransactionAncestry(tx2->GetId(), ancestors, descendants);
-    BOOST_CHECK_EQUAL(ancestors, 2ULL);
-    BOOST_CHECK_EQUAL(descendants, 4ULL);
-    pool.GetTransactionAncestry(tx3->GetId(), ancestors, descendants);
-    BOOST_CHECK_EQUAL(ancestors, 3ULL);
-    BOOST_CHECK_EQUAL(descendants, 4ULL);
-    pool.GetTransactionAncestry(tx4->GetId(), ancestors, descendants);
-    BOOST_CHECK_EQUAL(ancestors, 3ULL);
-    BOOST_CHECK_EQUAL(descendants, 4ULL);
-
-    /* Make an alternate branch that is longer and connect it to tx3 */
-    //
-    // [ty1].0 <- [ty2].0 <- [ty3].0 <- [ty4].0 <- [ty5].0
-    //                                              |
-    // [tx1].0 <- [tx2].0 <- [tx3].0 <- [ty6] --->--/
-    //              |
-    //              \---1 <- [tx4]
-    //
-    CTransactionRef ty1, ty2, ty3, ty4, ty5;
-    CTransactionRef *ty[5] = {&ty1, &ty2, &ty3, &ty4, &ty5};
-    Amount v = 5 * COIN;
-    for (uint64_t i = 0; i < 5; i++) {
-        CTransactionRef &tyi = *ty[i];
-        tyi = make_tx(/* output_values */ {v},
-                      /* inputs */ i > 0
-                          ? std::vector<CTransactionRef>{*ty[i - 1]}
-                          : std::vector<CTransactionRef>{});
-        v -= 50 * CENT;
-        pool.addUnchecked(entry.Fee(10000 * SATOSHI).FromTx(tyi));
-        pool.GetTransactionAncestry(tyi->GetId(), ancestors, descendants);
-        BOOST_CHECK_EQUAL(ancestors, i + 1);
-        BOOST_CHECK_EQUAL(descendants, i + 1);
-    }
-    CTransactionRef ty6 =
-        make_tx(/* output_values */ {5 * COIN}, /* inputs */ {tx3, ty5});
-    pool.addUnchecked(entry.Fee(10000 * SATOSHI).FromTx(ty6));
-
-    // Ancestors / descendants should be:
-    // transaction  ancestors           descendants
-    // ============ =================== ===========
-    // tx1          1 (tx1)             5 (tx1,2,3,4, ty6)
-    // tx2          2 (tx1,2)           5 (tx1,2,3,4, ty6)
-    // tx3          3 (tx1,2,3)         5 (tx1,2,3,4, ty6)
-    // tx4          3 (tx1,2,4)         5 (tx1,2,3,4, ty6)
-    // ty1          1 (ty1)             6 (ty1,2,3,4,5,6)
-    // ty2          2 (ty1,2)           6 (ty1,2,3,4,5,6)
-    // ty3          3 (ty1,2,3)         6 (ty1,2,3,4,5,6)
-    // ty4          4 (y1234)           6 (ty1,2,3,4,5,6)
-    // ty5          5 (y12345)          6 (ty1,2,3,4,5,6)
-    // ty6          9 (tx123, ty123456) 6 (ty1,2,3,4,5,6)
-    pool.GetTransactionAncestry(tx1->GetId(), ancestors, descendants);
-    BOOST_CHECK_EQUAL(ancestors, 1ULL);
-    BOOST_CHECK_EQUAL(descendants, 5ULL);
-    pool.GetTransactionAncestry(tx2->GetId(), ancestors, descendants);
-    BOOST_CHECK_EQUAL(ancestors, 2ULL);
-    BOOST_CHECK_EQUAL(descendants, 5ULL);
-    pool.GetTransactionAncestry(tx3->GetId(), ancestors, descendants);
-    BOOST_CHECK_EQUAL(ancestors, 3ULL);
-    BOOST_CHECK_EQUAL(descendants, 5ULL);
-    pool.GetTransactionAncestry(tx4->GetId(), ancestors, descendants);
-    BOOST_CHECK_EQUAL(ancestors, 3ULL);
-    BOOST_CHECK_EQUAL(descendants, 5ULL);
-    pool.GetTransactionAncestry(ty1->GetId(), ancestors, descendants);
-    BOOST_CHECK_EQUAL(ancestors, 1ULL);
-    BOOST_CHECK_EQUAL(descendants, 6ULL);
-    pool.GetTransactionAncestry(ty2->GetId(), ancestors, descendants);
-    BOOST_CHECK_EQUAL(ancestors, 2ULL);
-    BOOST_CHECK_EQUAL(descendants, 6ULL);
-    pool.GetTransactionAncestry(ty3->GetId(), ancestors, descendants);
-    BOOST_CHECK_EQUAL(ancestors, 3ULL);
-    BOOST_CHECK_EQUAL(descendants, 6ULL);
-    pool.GetTransactionAncestry(ty4->GetId(), ancestors, descendants);
-    BOOST_CHECK_EQUAL(ancestors, 4ULL);
-    BOOST_CHECK_EQUAL(descendants, 6ULL);
-    pool.GetTransactionAncestry(ty5->GetId(), ancestors, descendants);
-    BOOST_CHECK_EQUAL(ancestors, 5ULL);
-    BOOST_CHECK_EQUAL(descendants, 6ULL);
-    pool.GetTransactionAncestry(ty6->GetId(), ancestors, descendants);
-    BOOST_CHECK_EQUAL(ancestors, 9ULL);
-    BOOST_CHECK_EQUAL(descendants, 6ULL);
-
-    /* Ancestors represented more than once ("diamond") */
-    //
-    // [ta].0 <- [tb].0 -----<------- [td].0
-    //            |                    |
-    //            \---1 <- [tc].0 --<--/
-    //
-    CTransactionRef ta, tb, tc, td;
-    ta = make_tx(/* output_values */ {10 * COIN});
-    tb = make_tx(/* output_values */ {5 * COIN, 3 * COIN}, /* inputs */ {ta});
-    tc = make_tx(/* output_values */ {2 * COIN}, /* inputs */ {tb},
-                 /* input_indices */ {1});
-    td = make_tx(/* output_values */ {6 * COIN}, /* inputs */ {tb, tc},
-                 /* input_indices */ {0, 0});
-    pool.clear();
-    pool.addUnchecked(entry.Fee(10000 * SATOSHI).FromTx(ta));
-    pool.addUnchecked(entry.Fee(10000 * SATOSHI).FromTx(tb));
-    pool.addUnchecked(entry.Fee(10000 * SATOSHI).FromTx(tc));
-    pool.addUnchecked(entry.Fee(10000 * SATOSHI).FromTx(td));
-
-    // Ancestors / descendants should be:
-    // transaction  ancestors           descendants
-    // ============ =================== ===========
-    // ta           1 (ta               4 (ta,tb,tc,td)
-    // tb           2 (ta,tb)           4 (ta,tb,tc,td)
-    // tc           3 (ta,tb,tc)        4 (ta,tb,tc,td)
-    // td           4 (ta,tb,tc,td)     4 (ta,tb,tc,td)
-
-    pool.GetTransactionAncestry(ta->GetId(), ancestors, descendants);
-    BOOST_CHECK_EQUAL(ancestors, 1ULL);
-    BOOST_CHECK_EQUAL(descendants, 4ULL);
-    pool.GetTransactionAncestry(tb->GetId(), ancestors, descendants);
-    BOOST_CHECK_EQUAL(ancestors, 2ULL);
-    BOOST_CHECK_EQUAL(descendants, 4ULL);
-    pool.GetTransactionAncestry(tc->GetId(), ancestors, descendants);
-    BOOST_CHECK_EQUAL(ancestors, 3ULL);
-    BOOST_CHECK_EQUAL(descendants, 4ULL);
-    pool.GetTransactionAncestry(td->GetId(), ancestors, descendants);
-    BOOST_CHECK_EQUAL(ancestors, 4ULL);
-    BOOST_CHECK_EQUAL(descendants, 4ULL);
-}
-
 BOOST_AUTO_TEST_CASE(GetModifiedFeeRateTest) {
     CMutableTransaction tx = CMutableTransaction();
     tx.vin.resize(1);
 
     // Make tx exactly 1000 bytes.
     const size_t dummyDataSize =
         1000 -
         (GetSerializeSize(tx, PROTOCOL_VERSION) + 5 /* OP_PUSHDATA2 and ?? */);
 
     tx.vin[0].scriptSig << std::vector<uint8_t>(dummyDataSize);
     assert(GetSerializeSize(tx, PROTOCOL_VERSION) == 1000);
 
     TestMemPoolEntryHelper entry;
 
     auto entryNormal = entry.Fee(1000 * SATOSHI).FromTx(tx);
     BOOST_CHECK_EQUAL(1000 * SATOSHI,
                       entryNormal.GetModifiedFeeRate().GetFee(1000));
 
     // Add modified fee
     CTxMemPoolEntry entryFeeModified = entry.Fee(1000 * SATOSHI).FromTx(tx);
     entryFeeModified.UpdateFeeDelta(1000 * SATOSHI);
     BOOST_CHECK_EQUAL(2000 * SATOSHI,
                       entryFeeModified.GetModifiedFeeRate().GetFee(1000));
 
     // Excessive sigop count "modifies" size
     CTxMemPoolEntry entrySizeModified =
         entry.Fee(1000 * SATOSHI)
             .SigChecks(2000 / DEFAULT_BYTES_PER_SIGCHECK)
             .FromTx(tx);
     BOOST_CHECK_EQUAL(500 * SATOSHI,
                       entrySizeModified.GetModifiedFeeRate().GetFee(1000));
 }
 
 BOOST_AUTO_TEST_CASE(CompareTxMemPoolEntryByModifiedFeeRateTest) {
     CTransactionRef a = make_tx(/* output_values */ {1 * COIN});
     CTransactionRef b = make_tx(/* output_values */ {2 * COIN});
 
     // For this test, we want b to have lower txid.
     if (a->GetId() < b->GetId()) {
         std::swap(a, b);
     }
     BOOST_CHECK_GT(a->GetId(), b->GetId());
 
     TestMemPoolEntryHelper entry;
     CompareTxMemPoolEntryByModifiedFeeRate compare;
 
     auto checkOrdering = [&compare](const auto &a, const auto &b) {
         BOOST_CHECK(compare(a, b));
         BOOST_CHECK(!compare(b, a));
     };
 
     // If the fees and entryId are the same, lower TxId should sort before
     checkOrdering(entry.Fee(100 * SATOSHI).FromTx(b),
                   entry.Fee(100 * SATOSHI).FromTx(a));
     // Earlier entryId, same fee, should sort before
     checkOrdering(entry.Fee(100 * SATOSHI).EntryId(1).FromTx(a),
                   entry.Fee(100 * SATOSHI).EntryId(2).FromTx(b));
     // Higher fee, earlier entryId should sort before
     checkOrdering(entry.Fee(101 * SATOSHI).EntryId(1).FromTx(a),
                   entry.Fee(100 * SATOSHI).EntryId(2).FromTx(b));
     // Higher fee, same entryId should sort before
     checkOrdering(entry.Fee(101 * SATOSHI).FromTx(a),
                   entry.Fee(100 * SATOSHI).FromTx(b));
 
     // Same with fee delta.
     {
         CTxMemPoolEntry entryA = entry.Fee(100 * SATOSHI).FromTx(a);
         CTxMemPoolEntry entryB = entry.Fee(200 * SATOSHI).FromTx(b);
         // .. A and B have same modified fee, ordering is by lowest txid
         entryA.UpdateFeeDelta(100 * SATOSHI);
         checkOrdering(entryB, entryA);
     }
     // .. A is first entering the mempool
     CTxMemPoolEntry entryA = entry.Fee(100 * SATOSHI).EntryId(1).FromTx(a);
     CTxMemPoolEntry entryB = entry.Fee(100 * SATOSHI).EntryId(2).FromTx(b);
     checkOrdering(entryA, entryB);
     // .. B has higher modified fee.
     entryB.UpdateFeeDelta(1 * SATOSHI);
     checkOrdering(entryB, entryA);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index 8847cdf33..fdd30c3e8 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -1,1387 +1,1209 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 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 <txmempool.h>
 
 #include <chain.h>
 #include <chainparams.h> // for GetConsensus.
 #include <clientversion.h>
 #include <coins.h>
 #include <config.h>
 #include <consensus/consensus.h>
 #include <consensus/tx_verify.h>
 #include <consensus/validation.h>
 #include <policy/fees.h>
 #include <policy/mempool.h>
 #include <policy/policy.h>
 #include <policy/settings.h>
 #include <reverse_iterator.h>
 #include <undo.h>
 #include <util/moneystr.h>
 #include <util/system.h>
 #include <util/time.h>
 #include <validation.h>
 #include <validationinterface.h>
 #include <version.h>
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 
 /// Used in various places in this file to signify "no limit" for
 /// CalculateMemPoolAncestors
 inline constexpr uint64_t nNoLimit = std::numeric_limits<uint64_t>::max();
 
 // Helpers for modifying CTxMemPool::mapTx, which is a boost multi_index.
 // Remove after Wellington
 struct update_descendant_state {
     update_descendant_state(int64_t _modifySize, Amount _modifyFee,
                             int64_t _modifyCount, int64_t _modifySigChecks)
         : modifySize(_modifySize), modifyFee(_modifyFee),
           modifyCount(_modifyCount), modifySigChecks(_modifySigChecks) {}
 
     void operator()(CTxMemPoolEntry &e) {
         e.UpdateDescendantState(modifySize, modifyFee, modifyCount,
                                 modifySigChecks);
     }
 
 private:
     int64_t modifySize;
     Amount modifyFee;
     int64_t modifyCount;
     int64_t modifySigChecks;
 };
 
 struct update_ancestor_state {
     update_ancestor_state(int64_t _modifySize, Amount _modifyFee,
                           int64_t _modifyCount, int64_t _modifySigChecks)
         : modifySize(_modifySize), modifyFee(_modifyFee),
           modifyCount(_modifyCount), modifySigChecks(_modifySigChecks) {}
 
     void operator()(CTxMemPoolEntry &e) {
         e.UpdateAncestorState(modifySize, modifyFee, modifyCount,
                               modifySigChecks);
     }
 
 private:
     int64_t modifySize;
     Amount modifyFee;
     int64_t modifyCount;
     int64_t modifySigChecks;
 };
 
 bool TestLockPointValidity(const CChain &active_chain, const LockPoints &lp) {
     AssertLockHeld(cs_main);
     // If there are relative lock times then the maxInputBlock will be set
     // If there are no relative lock times, the LockPoints don't depend on the
     // chain
     if (lp.maxInputBlock) {
         // Check whether active_chain is an extension of the block at which the
         // LockPoints calculation was valid.  If not LockPoints are no longer
         // valid
         if (!active_chain.Contains(lp.maxInputBlock)) {
             return false;
         }
     }
 
     // LockPoints still valid
     return true;
 }
 
 CTxMemPoolEntry::CTxMemPoolEntry(const CTransactionRef &_tx, const Amount fee,
                                  int64_t time, unsigned int entry_height,
                                  bool spends_coinbase, int64_t _sigChecks,
                                  LockPoints lp)
     : tx{_tx}, nFee{fee},
       nTxSize(tx->GetTotalSize()), nUsageSize{RecursiveDynamicUsage(tx)},
       nTime(time), entryHeight{entry_height}, spendsCoinbase(spends_coinbase),
       sigChecks(_sigChecks), lockPoints(lp), nSizeWithDescendants{GetTxSize()},
       nModFeesWithDescendants{nFee}, nSigChecksWithDescendants{sigChecks},
       nSizeWithAncestors{GetTxSize()}, nModFeesWithAncestors{nFee},
       nSigChecksWithAncestors{sigChecks} {}
 
 size_t CTxMemPoolEntry::GetTxVirtualSize() const {
     return GetVirtualTransactionSize(nTxSize, sigChecks);
 }
 
 // Remove after wellinggton
 uint64_t CTxMemPoolEntry::GetVirtualSizeWithDescendants() const {
     // note this is distinct from the sum of descendants' individual virtual
     // sizes, and may be smaller.
     return GetVirtualTransactionSize(nSizeWithDescendants,
                                      nSigChecksWithDescendants);
 }
 
 // Remove after wellinggton
 uint64_t CTxMemPoolEntry::GetVirtualSizeWithAncestors() const {
     // note this is distinct from the sum of ancestors' individual virtual
     // sizes, and may be smaller.
     return GetVirtualTransactionSize(nSizeWithAncestors,
                                      nSigChecksWithAncestors);
 }
 
 void CTxMemPoolEntry::UpdateFeeDelta(Amount newFeeDelta) {
     // Remove after wellington; this stat is unused after wellington
     nModFeesWithDescendants += newFeeDelta - feeDelta;
     nModFeesWithAncestors += newFeeDelta - feeDelta;
     feeDelta = newFeeDelta;
 }
 
 void CTxMemPoolEntry::UpdateLockPoints(const LockPoints &lp) {
     lockPoints = lp;
 }
 
 bool CTxMemPool::CalculateAncestorsAndCheckLimits(
     size_t entry_size, size_t entry_count, setEntries &setAncestors,
     CTxMemPoolEntry::Parents &staged_ancestors, uint64_t limitAncestorCount,
     uint64_t limitAncestorSize, uint64_t limitDescendantCount,
     uint64_t limitDescendantSize, std::string &errString) const {
     size_t totalSizeWithAncestors = entry_size;
 
     while (!staged_ancestors.empty()) {
         const CTxMemPoolEntry &stage = staged_ancestors.begin()->get();
         txiter stageit = mapTx.iterator_to(stage);
 
         setAncestors.insert(stageit);
         staged_ancestors.erase(staged_ancestors.begin());
         totalSizeWithAncestors += stageit->GetTxSize();
 
         if (stageit->GetSizeWithDescendants() + entry_size >
             limitDescendantSize) {
             errString = strprintf(
                 "exceeds descendant size limit for tx %s [limit: %u]",
                 stageit->GetTx().GetId().ToString(), limitDescendantSize);
             return false;
         }
 
         if (stageit->GetCountWithDescendants() + entry_count >
             limitDescendantCount) {
             errString = strprintf("too many descendants for tx %s [limit: %u]",
                                   stageit->GetTx().GetId().ToString(),
                                   limitDescendantCount);
             return false;
         }
 
         if (totalSizeWithAncestors > limitAncestorSize) {
             errString = strprintf("exceeds ancestor size limit [limit: %u]",
                                   limitAncestorSize);
             return false;
         }
 
         const CTxMemPoolEntry::Parents &parents =
             stageit->GetMemPoolParentsConst();
         for (const CTxMemPoolEntry &parent : parents) {
             txiter parent_it = mapTx.iterator_to(parent);
 
             // If this is a new ancestor, add it.
             if (setAncestors.count(parent_it) == 0) {
                 staged_ancestors.insert(parent);
             }
             if (staged_ancestors.size() + setAncestors.size() + entry_count >
                 limitAncestorCount) {
                 errString =
                     strprintf("too many unconfirmed ancestors [limit: %u]",
                               limitAncestorCount);
                 return false;
             }
         }
     }
 
     return true;
 }
 
 bool CTxMemPool::CheckPackageLimits(const Package &package,
                                     uint64_t limitAncestorCount,
                                     uint64_t limitAncestorSize,
                                     uint64_t limitDescendantCount,
                                     uint64_t limitDescendantSize,
                                     std::string &errString) const {
     CTxMemPoolEntry::Parents staged_ancestors;
     size_t total_size = 0;
     for (const auto &tx : package) {
         total_size += GetVirtualTransactionSize(*tx);
         for (const auto &input : tx->vin) {
             std::optional<txiter> piter = GetIter(input.prevout.GetTxId());
             if (piter) {
                 staged_ancestors.insert(**piter);
                 if (staged_ancestors.size() + package.size() >
                     limitAncestorCount) {
                     errString =
                         strprintf("too many unconfirmed parents [limit: %u]",
                                   limitAncestorCount);
                     return false;
                 }
             }
         }
     }
     // When multiple transactions are passed in, the ancestors and descendants
     // of all transactions considered together must be within limits even if
     // they are not interdependent. This may be stricter than the limits for
     // each individual transaction.
     setEntries setAncestors;
     const auto ret = CalculateAncestorsAndCheckLimits(
         total_size, package.size(), setAncestors, staged_ancestors,
         limitAncestorCount, limitAncestorSize, limitDescendantCount,
         limitDescendantSize, errString);
     // It's possible to overestimate the ancestor/descendant totals.
     if (!ret) {
         errString.insert(0, "possibly ");
     }
     return ret;
 }
 
 bool CTxMemPool::CalculateMemPoolAncestors(
     const CTxMemPoolEntry &entry, setEntries &setAncestors,
     uint64_t limitAncestorCount, uint64_t limitAncestorSize,
     uint64_t limitDescendantCount, uint64_t limitDescendantSize,
     std::string &errString, bool fSearchForParents /* = true */) const {
     CTxMemPoolEntry::Parents staged_ancestors;
     const CTransaction &tx = entry.GetTx();
 
     if (fSearchForParents) {
         // Get parents of this transaction that are in the mempool
         // GetMemPoolParents() is only valid for entries in the mempool, so we
         // iterate mapTx to find parents.
         for (const CTxIn &in : tx.vin) {
             std::optional<txiter> piter = GetIter(in.prevout.GetTxId());
             if (!piter) {
                 continue;
             }
             staged_ancestors.insert(**piter);
             if (staged_ancestors.size() + 1 > limitAncestorCount) {
                 errString =
                     strprintf("too many unconfirmed parents [limit: %u]",
                               limitAncestorCount);
                 return false;
             }
         }
     } else {
         // If we're not searching for parents, we require this to be an entry in
         // the mempool already.
         staged_ancestors = entry.GetMemPoolParentsConst();
     }
 
     return CalculateAncestorsAndCheckLimits(
         entry.GetTxSize(), /* entry_count */ 1, setAncestors, staged_ancestors,
         limitAncestorCount, limitAncestorSize, limitDescendantCount,
         limitDescendantSize, errString);
 }
 
-void CTxMemPool::UpdateParentsOf(bool add, txiter it,
-                                 const setEntries *setAncestors) {
+void CTxMemPool::UpdateParentsOf(bool add, txiter it) {
     // add or remove this tx as a child of each parent
     for (const CTxMemPoolEntry &parent : it->GetMemPoolParentsConst()) {
         UpdateChild(mapTx.iterator_to(parent), it, add);
     }
-
-    // Remove this after wellington
-    if (setAncestors && !wellingtonLatched) {
-        const int64_t updateCount = (add ? 1 : -1);
-        const int64_t updateSize = updateCount * it->GetTxSize();
-        const int64_t updateSigChecks = updateCount * it->GetSigChecks();
-        const Amount updateFee = updateCount * it->GetModifiedFee();
-        for (txiter ancestorIt : *setAncestors) {
-            mapTx.modify(ancestorIt,
-                         update_descendant_state(updateSize, updateFee,
-                                                 updateCount, updateSigChecks));
-        }
-    }
-}
-
-void CTxMemPool::UpdateEntryForAncestors(txiter it,
-                                         const setEntries *setAncestors) {
-    if (!setAncestors || wellingtonLatched) {
-        return;
-    }
-
-    int64_t updateCount = setAncestors->size();
-    int64_t updateSize = 0;
-    int64_t updateSigChecks = 0;
-    Amount updateFee = Amount::zero();
-
-    for (txiter ancestorIt : *setAncestors) {
-        updateSize += ancestorIt->GetTxSize();
-        updateFee += ancestorIt->GetModifiedFee();
-        updateSigChecks += ancestorIt->GetSigChecks();
-    }
-    mapTx.modify(it, update_ancestor_state(updateSize, updateFee, updateCount,
-                                           updateSigChecks));
 }
 
 void CTxMemPool::UpdateChildrenForRemoval(txiter it) {
     const CTxMemPoolEntry::Children &children = it->GetMemPoolChildrenConst();
     for (const CTxMemPoolEntry &updateIt : children) {
         UpdateParent(mapTx.iterator_to(updateIt), it, false);
     }
 }
 
 void CTxMemPool::UpdateForRemoveFromMempool(const setEntries &entriesToRemove,
                                             bool updateDescendants) {
-    if (!wellingtonLatched) {
-        // remove this branch after wellington
-        // slow quadratic branch, only for pre-activation compatibility
-
-        // For each entry, walk back all ancestors and decrement size associated
-        // with this transaction.
-        if (updateDescendants) {
-            // updateDescendants should be true whenever we're not recursively
-            // removing a tx and all its descendants, eg when a transaction is
-            // confirmed in a block.
-            // Here we only update statistics and not data in
-            // CTxMemPool::Parents and CTxMemPoolEntry::Children (which we need
-            // to preserve until we're finished with all operations that need to
-            // traverse the mempool).
-            for (txiter removeIt : entriesToRemove) {
-                setEntries setDescendants;
-                CalculateDescendants(removeIt, setDescendants);
-                setDescendants.erase(removeIt); // don't update state for self
-                int64_t modifySize = -int64_t(removeIt->GetTxSize());
-                Amount modifyFee = -1 * removeIt->GetModifiedFee();
-                int modifySigChecks = -removeIt->GetSigChecks();
-                for (txiter dit : setDescendants) {
-                    mapTx.modify(dit,
-                                 update_ancestor_state(modifySize, modifyFee,
-                                                       -1, modifySigChecks));
-                }
-            }
-        }
-
-        for (txiter removeIt : entriesToRemove) {
-            setEntries setAncestors;
-            const CTxMemPoolEntry &entry = *removeIt;
-            std::string dummy;
-            // Since this is a tx that is already in the mempool, we can call
-            // CMPA with fSearchForParents = false.  If the mempool is in a
-            // consistent state, then using true or false should both be
-            // correct, though false should be a bit faster.
-            CalculateMemPoolAncestors(entry, setAncestors, nNoLimit, nNoLimit,
-                                      nNoLimit, nNoLimit, dummy, false);
-            // Note that UpdateParentsOf severs the child links that point to
-            // removeIt in the entries for the parents of removeIt.
-            UpdateParentsOf(false, removeIt, &setAncestors);
-        }
-    } else {
-        for (txiter removeIt : entriesToRemove) {
-            // Note that UpdateParentsOf severs the child links that point to
-            // removeIt in the entries for the parents of removeIt.
-            UpdateParentsOf(false, removeIt);
-        }
+    for (txiter removeIt : entriesToRemove) {
+        // Note that UpdateParentsOf severs the child links that point to
+        // removeIt in the entries for the parents of removeIt.
+        UpdateParentsOf(false, removeIt);
     }
+
     // After updating all the parent links, we can now sever the link between
     // each transaction being removed and any mempool children (ie, update
     // CTxMemPoolEntry::m_parents for each direct child of a transaction being
     // removed).
     for (txiter removeIt : entriesToRemove) {
         UpdateChildrenForRemoval(removeIt);
     }
 }
 
 void CTxMemPoolEntry::UpdateDescendantState(int64_t modifySize,
                                             Amount modifyFee,
                                             int64_t modifyCount,
                                             int64_t modifySigChecks) {
     nSizeWithDescendants += modifySize;
     assert(int64_t(nSizeWithDescendants) > 0);
     nModFeesWithDescendants += modifyFee;
     nCountWithDescendants += modifyCount;
     assert(int64_t(nCountWithDescendants) > 0);
     nSigChecksWithDescendants += modifySigChecks;
     assert(nSigChecksWithDescendants >= 0);
 }
 
 void CTxMemPoolEntry::UpdateAncestorState(int64_t modifySize, Amount modifyFee,
                                           int64_t modifyCount,
                                           int64_t modifySigChecks) {
     nSizeWithAncestors += modifySize;
     assert(int64_t(nSizeWithAncestors) > 0);
     nModFeesWithAncestors += modifyFee;
     nCountWithAncestors += modifyCount;
     assert(int64_t(nCountWithAncestors) > 0);
     nSigChecksWithAncestors += modifySigChecks;
     assert(nSigChecksWithAncestors >= 0);
 }
 
 CTxMemPool::CTxMemPool(int check_ratio) : m_check_ratio(check_ratio) {
     // lock free clear
     _clear();
 }
 
 CTxMemPool::~CTxMemPool() {}
 
 bool CTxMemPool::isSpent(const COutPoint &outpoint) const {
     LOCK(cs);
     return mapNextTx.count(outpoint);
 }
 
 unsigned int CTxMemPool::GetTransactionsUpdated() const {
     return nTransactionsUpdated;
 }
 
 void CTxMemPool::AddTransactionsUpdated(unsigned int n) {
     nTransactionsUpdated += n;
 }
 
 void CTxMemPool::addUnchecked(const CTxMemPoolEntry &entryIn,
                               const setEntries &setAncestors) {
     CTxMemPoolEntry entry{entryIn};
     // get a guaranteed unique id (in case tests re-use the same object)
     entry.SetEntryId(nextEntryId++);
 
     // Update transaction for any feeDelta created by PrioritiseTransaction
     {
         Amount feeDelta = Amount::zero();
         ApplyDelta(entry.GetTx().GetId(), feeDelta);
         entry.UpdateFeeDelta(feeDelta);
     }
 
     // Add to memory pool without checking anything.
     // Used by AcceptToMemoryPool(), which DOES do all the appropriate checks.
     auto [newit, inserted] = mapTx.insert(entry);
     // Sanity check: It is a programming error if insertion fails (uniqueness
     // invariants in mapTx are violated, etc)
     assert(inserted);
     // Sanity check: We should always end up inserting at the end of the
     // entry_id index
     assert(&*mapTx.get<entry_id>().rbegin() == &*newit);
 
     // Update cachedInnerUsage to include contained transaction's usage.
     // (When we update the entry for in-mempool parents, memory usage will be
     // further updated.)
     cachedInnerUsage += entry.DynamicMemoryUsage();
 
     const CTransaction &tx = newit->GetTx();
     std::set<TxId> setParentTransactions;
     for (const CTxIn &in : tx.vin) {
         mapNextTx.insert(std::make_pair(&in.prevout, &tx));
         setParentTransactions.insert(in.prevout.GetTxId());
     }
     // Don't bother worrying about child transactions of this one. It is
     // guaranteed that a new transaction arriving will not have any children,
     // because such children would be orphans.
 
     // Update ancestors with information about this tx
     for (const auto &pit : GetIterSet(setParentTransactions)) {
         UpdateParent(newit, pit, true);
     }
 
-    const setEntries *pSetEntries = wellingtonLatched ? nullptr : &setAncestors;
-    UpdateParentsOf(true, newit, pSetEntries);
-    UpdateEntryForAncestors(newit, pSetEntries);
+    UpdateParentsOf(true, newit);
 
     nTransactionsUpdated++;
     totalTxSize += entry.GetTxSize();
     m_total_fee += entry.GetFee();
 }
 
 void CTxMemPool::removeUnchecked(txiter it, MemPoolRemovalReason reason) {
     // We increment mempool sequence value no matter removal reason
     // even if not directly reported below.
     uint64_t mempool_sequence = GetAndIncrementSequence();
 
     if (reason != MemPoolRemovalReason::BLOCK) {
         // Notify clients that a transaction has been removed from the mempool
         // for any reason except being included in a block. Clients interested
         // in transactions included in blocks can subscribe to the
         // BlockConnected notification.
         GetMainSignals().TransactionRemovedFromMempool(
             it->GetSharedTx(), reason, mempool_sequence);
     }
 
     for (const CTxIn &txin : it->GetTx().vin) {
         mapNextTx.erase(txin.prevout);
     }
 
     /* add logging because unchecked */
     RemoveUnbroadcastTx(it->GetTx().GetId(), true);
 
     totalTxSize -= it->GetTxSize();
     m_total_fee -= it->GetFee();
     cachedInnerUsage -= it->DynamicMemoryUsage();
     cachedInnerUsage -= memusage::DynamicUsage(it->GetMemPoolParentsConst()) +
                         memusage::DynamicUsage(it->GetMemPoolChildrenConst());
     mapTx.erase(it);
     nTransactionsUpdated++;
 }
 
 // Calculates descendants of entry that are not already in setDescendants, and
 // adds to setDescendants. Assumes entryit is already a tx in the mempool and
 // CTxMemPoolEntry::m_children is correct for tx and all descendants. Also
 // assumes that if an entry is in setDescendants already, then all in-mempool
 // descendants of it are already in setDescendants as well, so that we can save
 // time by not iterating over those entries.
 void CTxMemPool::CalculateDescendants(txiter entryit,
                                       setEntries &setDescendants) const {
     setEntries stage;
     if (setDescendants.count(entryit) == 0) {
         stage.insert(entryit);
     }
     // Traverse down the children of entry, only adding children that are not
     // accounted for in setDescendants already (because those children have
     // either already been walked, or will be walked in this iteration).
     while (!stage.empty()) {
         txiter it = *stage.begin();
         setDescendants.insert(it);
         stage.erase(stage.begin());
 
         const CTxMemPoolEntry::Children &children =
             it->GetMemPoolChildrenConst();
         for (const CTxMemPoolEntry &child : children) {
             txiter childiter = mapTx.iterator_to(child);
             if (!setDescendants.count(childiter)) {
                 stage.insert(childiter);
             }
         }
     }
 }
 
 void CTxMemPool::removeRecursive(const CTransaction &origTx,
                                  MemPoolRemovalReason reason) {
     // Remove transaction from memory pool.
     AssertLockHeld(cs);
     setEntries txToRemove;
     txiter origit = mapTx.find(origTx.GetId());
     if (origit != mapTx.end()) {
         txToRemove.insert(origit);
     } else {
         // When recursively removing but origTx isn't in the mempool be sure to
         // remove any children that are in the pool. This can happen during
         // chain re-orgs if origTx isn't re-accepted into the mempool for any
         // reason.
         auto it = mapNextTx.lower_bound(COutPoint(origTx.GetId(), 0));
         while (it != mapNextTx.end() &&
                it->first->GetTxId() == origTx.GetId()) {
             txiter nextit = mapTx.find(it->second->GetId());
             assert(nextit != mapTx.end());
             txToRemove.insert(nextit);
             ++it;
         }
     }
 
     setEntries setAllRemoves;
     for (txiter it : txToRemove) {
         CalculateDescendants(it, setAllRemoves);
     }
 
     RemoveStaged(setAllRemoves, false, reason);
 }
 
 void CTxMemPool::removeConflicts(const CTransaction &tx) {
     // Remove transactions which depend on inputs of tx, recursively
     AssertLockHeld(cs);
     for (const CTxIn &txin : tx.vin) {
         auto it = mapNextTx.find(txin.prevout);
         if (it != mapNextTx.end()) {
             const CTransaction &txConflict = *it->second;
             if (txConflict != tx) {
                 ClearPrioritisation(txConflict.GetId());
                 removeRecursive(txConflict, MemPoolRemovalReason::CONFLICT);
             }
         }
     }
 }
 
 /**
  * Called when a block is connected. Removes from mempool and updates the miner
  * fee estimator.
  */
 void CTxMemPool::removeForBlock(const std::vector<CTransactionRef> &vtx) {
     AssertLockHeld(cs);
 
     if (mapTx.empty() && mapDeltas.empty()) {
         // fast-path for IBD and/or when mempool is empty; there is no need to
         // do any of the set-up work below which eats precious cycles.
         // Note that this also skips updating the rolling fee udpate, which is
         // fine: it is only recomputed when the mempool has to be trimmed down
         // because it is full which is contradictory with this condition.
         return;
     }
 
     DisconnectedBlockTransactions disconnectpool;
     disconnectpool.addForBlock(vtx, *this);
 
     for (const CTransactionRef &tx :
          reverse_iterate(disconnectpool.GetQueuedTx().get<insertion_order>())) {
         txiter it = mapTx.find(tx->GetId());
         if (it != mapTx.end()) {
             setEntries stage;
             stage.insert(it);
             RemoveStaged(stage, true, MemPoolRemovalReason::BLOCK);
         } else {
             // Conflicting txs can only exist if the tx was not in the mempool
             removeConflicts(*tx);
         }
         ClearPrioritisation(tx->GetId());
     }
 
     disconnectpool.clear();
 
     lastRollingFeeUpdate = GetTime();
     blockSinceLastRollingFeeBump = true;
 }
 
 void CTxMemPool::_clear() {
     mapTx.clear();
     mapNextTx.clear();
     totalTxSize = 0;
     m_total_fee = Amount::zero();
     cachedInnerUsage = 0;
     lastRollingFeeUpdate = GetTime();
     blockSinceLastRollingFeeBump = false;
     rollingMinimumFeeRate = 0;
     ++nTransactionsUpdated;
 }
 
 void CTxMemPool::clear() {
     LOCK(cs);
     _clear();
 }
 
 void CTxMemPool::check(const CCoinsViewCache &active_coins_tip,
                        int64_t spendheight) const {
     if (m_check_ratio == 0) {
         return;
     }
 
     if (GetRand(m_check_ratio) >= 1) {
         return;
     }
 
     AssertLockHeld(::cs_main);
     LOCK(cs);
     LogPrint(BCLog::MEMPOOL,
              "Checking mempool with %u transactions and %u inputs\n",
              (unsigned int)mapTx.size(), (unsigned int)mapNextTx.size());
 
     uint64_t checkTotal = 0;
     Amount check_total_fee{Amount::zero()};
     uint64_t innerUsage = 0;
 
     CCoinsViewCache mempoolDuplicate(
         const_cast<CCoinsViewCache *>(&active_coins_tip));
 
     for (const CTxMemPoolEntry &entry : mapTx.get<entry_id>()) {
         checkTotal += entry.GetTxSize();
         check_total_fee += entry.GetFee();
         innerUsage += entry.DynamicMemoryUsage();
         const CTransaction &tx = entry.GetTx();
         innerUsage += memusage::DynamicUsage(entry.GetMemPoolParentsConst()) +
                       memusage::DynamicUsage(entry.GetMemPoolChildrenConst());
 
         CTxMemPoolEntry::Parents setParentCheck;
         for (const CTxIn &txin : tx.vin) {
             // Check that every mempool transaction's inputs refer to available
             // coins, or other mempool tx's.
             txiter parentIt = mapTx.find(txin.prevout.GetTxId());
             if (parentIt != mapTx.end()) {
                 const CTransaction &parentTx = parentIt->GetTx();
                 assert(parentTx.vout.size() > txin.prevout.GetN() &&
                        !parentTx.vout[txin.prevout.GetN()].IsNull());
                 setParentCheck.insert(*parentIt);
                 // also check that parents have a topological ordering before
                 // their children
                 assert(parentIt->GetEntryId() < entry.GetEntryId());
             }
             // We are iterating through the mempool entries sorted
             // topologically.
             // All parents must have been checked before their children and
             // their coins added to the mempoolDuplicate coins cache.
             assert(mempoolDuplicate.HaveCoin(txin.prevout));
             // Check whether its inputs are marked in mapNextTx.
             auto prevoutNextIt = mapNextTx.find(txin.prevout);
             assert(prevoutNextIt != mapNextTx.end());
             assert(prevoutNextIt->first == &txin.prevout);
             assert(prevoutNextIt->second == &tx);
         }
         auto comp = [](const CTxMemPoolEntry &a,
                        const CTxMemPoolEntry &b) -> bool {
             return a.GetTx().GetId() == b.GetTx().GetId();
         };
         assert(setParentCheck.size() == entry.GetMemPoolParentsConst().size());
         assert(std::equal(setParentCheck.begin(), setParentCheck.end(),
                           entry.GetMemPoolParentsConst().begin(), comp));
 
         // Verify ancestor state is correct.
         setEntries setAncestors;
         std::string dummy;
 
         const bool ok = CalculateMemPoolAncestors(
             entry, setAncestors, nNoLimit, nNoLimit, nNoLimit, nNoLimit, dummy);
         assert(ok);
 
-        if (!wellingtonLatched) {
-            uint64_t nCountCheck = setAncestors.size() + 1;
-            uint64_t nSizeCheck = entry.GetTxSize();
-            Amount nFeesCheck = entry.GetModifiedFee();
-            int64_t nSigChecksCheck = entry.GetSigChecks();
-
-            for (txiter ancestorIt : setAncestors) {
-                nSizeCheck += ancestorIt->GetTxSize();
-                nFeesCheck += ancestorIt->GetModifiedFee();
-                nSigChecksCheck += ancestorIt->GetSigChecks();
-            }
-
-            assert(entry.GetCountWithAncestors() == nCountCheck);
-            assert(entry.GetSizeWithAncestors() == nSizeCheck);
-            assert(entry.GetSigChecksWithAncestors() == nSigChecksCheck);
-            assert(entry.GetModFeesWithAncestors() == nFeesCheck);
-        }
-
         // all ancestors should have entryId < this tx's entryId
         for (const auto &ancestor : setAncestors) {
             assert(ancestor->GetEntryId() < entry.GetEntryId());
         }
 
         // Check children against mapNextTx
         CTxMemPoolEntry::Children setChildrenCheck;
         auto iter = mapNextTx.lower_bound(COutPoint(entry.GetTx().GetId(), 0));
         uint64_t child_sizes = 0;
         int64_t child_sigChecks = 0;
         for (; iter != mapNextTx.end() &&
                iter->first->GetTxId() == entry.GetTx().GetId();
              ++iter) {
             txiter childIt = mapTx.find(iter->second->GetId());
             // mapNextTx points to in-mempool transactions
             assert(childIt != mapTx.end());
             if (setChildrenCheck.insert(*childIt).second) {
                 child_sizes += childIt->GetTxSize();
                 child_sigChecks += childIt->GetSigChecks();
             }
         }
         assert(setChildrenCheck.size() ==
                entry.GetMemPoolChildrenConst().size());
         assert(std::equal(setChildrenCheck.begin(), setChildrenCheck.end(),
                           entry.GetMemPoolChildrenConst().begin(), comp));
-        if (!wellingtonLatched) {
-            // Also check to make sure size is greater than sum with immediate
-            // children. Just a sanity check, not definitive that this calc is
-            // correct...
-            assert(entry.GetSizeWithDescendants() >=
-                   child_sizes + entry.GetTxSize());
-            assert(entry.GetSigChecksWithDescendants() >=
-                   child_sigChecks + entry.GetSigChecks());
-        }
 
         // Not used. CheckTxInputs() should always pass
         TxValidationState dummy_state;
         Amount txfee{Amount::zero()};
         assert(!tx.IsCoinBase());
         assert(Consensus::CheckTxInputs(tx, dummy_state, mempoolDuplicate,
                                         spendheight, txfee));
         for (const auto &input : tx.vin) {
             mempoolDuplicate.SpendCoin(input.prevout);
         }
         AddCoins(mempoolDuplicate, tx, std::numeric_limits<int>::max());
     }
 
     for (auto &[_, nextTx] : mapNextTx) {
         txiter it = mapTx.find(nextTx->GetId());
         assert(it != mapTx.end());
         assert(&it->GetTx() == nextTx);
     }
 
     assert(totalTxSize == checkTotal);
     assert(m_total_fee == check_total_fee);
     assert(innerUsage == cachedInnerUsage);
 }
 
 bool CTxMemPool::CompareTopologically(const TxId &txida,
                                       const TxId &txidb) const {
     LOCK(cs);
     auto it1 = mapTx.find(txida);
     if (it1 == mapTx.end()) {
         return false;
     }
     auto it2 = mapTx.find(txidb);
     if (it2 == mapTx.end()) {
         return true;
     }
     return it1->GetEntryId() < it2->GetEntryId();
 }
 
 void CTxMemPool::getAllTxIds(std::vector<TxId> &vtxid) const {
     LOCK(cs);
 
     vtxid.clear();
     vtxid.reserve(mapTx.size());
 
     for (const auto &entry : mapTx.get<entry_id>()) {
         vtxid.push_back(entry.GetTx().GetId());
     }
 }
 
 static TxMempoolInfo
 GetInfo(CTxMemPool::indexed_transaction_set::const_iterator it) {
     return TxMempoolInfo{it->GetSharedTx(), it->GetTime(), it->GetFee(),
                          it->GetTxSize(), it->GetModifiedFee() - it->GetFee()};
 }
 
 std::vector<TxMempoolInfo> CTxMemPool::infoAll() const {
     LOCK(cs);
 
     std::vector<TxMempoolInfo> ret;
     ret.reserve(mapTx.size());
 
     const auto &index = mapTx.get<entry_id>();
     for (auto it = index.begin(); it != index.end(); ++it) {
         ret.push_back(GetInfo(mapTx.project<0>(it)));
     }
 
     return ret;
 }
 
 CTransactionRef CTxMemPool::get(const TxId &txid) const {
     LOCK(cs);
     indexed_transaction_set::const_iterator i = mapTx.find(txid);
     if (i == mapTx.end()) {
         return nullptr;
     }
 
     return i->GetSharedTx();
 }
 
 TxMempoolInfo CTxMemPool::info(const TxId &txid) const {
     LOCK(cs);
     indexed_transaction_set::const_iterator i = mapTx.find(txid);
     if (i == mapTx.end()) {
         return TxMempoolInfo();
     }
 
     return GetInfo(i);
 }
 
 CFeeRate CTxMemPool::estimateFee() const {
     LOCK(cs);
 
     uint64_t maxMempoolSize =
         gArgs.GetIntArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000;
     // minerPolicy uses recent blocks to figure out a reasonable fee.  This
     // may disagree with the rollingMinimumFeerate under certain scenarios
     // where the mempool  increases rapidly, or blocks are being mined which
     // do not contain propagated transactions.
     return std::max(::minRelayTxFee, GetMinFee(maxMempoolSize));
 }
 
 void CTxMemPool::PrioritiseTransaction(const TxId &txid,
                                        const Amount nFeeDelta) {
     {
         LOCK(cs);
         Amount &delta = mapDeltas[txid];
         delta += nFeeDelta;
         txiter it = mapTx.find(txid);
         if (it != mapTx.end()) {
             mapTx.modify(
                 it, [&delta](CTxMemPoolEntry &e) { e.UpdateFeeDelta(delta); });
-            // Remove after wellington
-            if (!wellingtonLatched) {
-                // Now update all ancestors' modified fees with descendants
-                setEntries setAncestors;
-                std::string dummy;
-                CalculateMemPoolAncestors(*it, setAncestors, nNoLimit, nNoLimit,
-                                          nNoLimit, nNoLimit, dummy, false);
-                for (txiter ancestorIt : setAncestors) {
-                    mapTx.modify(ancestorIt,
-                                 update_descendant_state(0, nFeeDelta, 0, 0));
-                }
-
-                // Now update all descendants' modified fees with ancestors
-                setEntries setDescendants;
-                CalculateDescendants(it, setDescendants);
-                setDescendants.erase(it);
-                for (txiter descendantIt : setDescendants) {
-                    mapTx.modify(descendantIt,
-                                 update_ancestor_state(0, nFeeDelta, 0, 0));
-                }
-            }
             ++nTransactionsUpdated;
         }
     }
     LogPrintf("PrioritiseTransaction: %s fee += %s\n", txid.ToString(),
               FormatMoney(nFeeDelta));
 }
 
 void CTxMemPool::ApplyDelta(const TxId &txid, Amount &nFeeDelta) const {
     AssertLockHeld(cs);
     std::map<TxId, Amount>::const_iterator pos = mapDeltas.find(txid);
     if (pos == mapDeltas.end()) {
         return;
     }
 
     nFeeDelta += pos->second;
 }
 
 void CTxMemPool::ClearPrioritisation(const TxId &txid) {
     AssertLockHeld(cs);
     mapDeltas.erase(txid);
 }
 
 const CTransaction *CTxMemPool::GetConflictTx(const COutPoint &prevout) const {
     const auto it = mapNextTx.find(prevout);
     return it == mapNextTx.end() ? nullptr : it->second;
 }
 
 std::optional<CTxMemPool::txiter> CTxMemPool::GetIter(const TxId &txid) const {
     auto it = mapTx.find(txid);
     if (it != mapTx.end()) {
         return it;
     }
     return std::nullopt;
 }
 
 CTxMemPool::setEntries
 CTxMemPool::GetIterSet(const std::set<TxId> &txids) const {
     CTxMemPool::setEntries ret;
     for (const auto &txid : txids) {
         const auto mi = GetIter(txid);
         if (mi) {
             ret.insert(*mi);
         }
     }
     return ret;
 }
 
 bool CTxMemPool::HasNoInputsOf(const CTransaction &tx) const {
     for (const CTxIn &in : tx.vin) {
         if (exists(in.prevout.GetTxId())) {
             return false;
         }
     }
 
     return true;
 }
 
 CCoinsViewMemPool::CCoinsViewMemPool(CCoinsView *baseIn,
                                      const CTxMemPool &mempoolIn)
     : CCoinsViewBacked(baseIn), mempool(mempoolIn) {}
 
 bool CCoinsViewMemPool::GetCoin(const COutPoint &outpoint, Coin &coin) const {
     // Check to see if the inputs are made available by another tx in the
     // package. These Coins would not be available in the underlying CoinsView.
     if (auto it = m_temp_added.find(outpoint); it != m_temp_added.end()) {
         coin = it->second;
         return true;
     }
 
     // If an entry in the mempool exists, always return that one, as it's
     // guaranteed to never conflict with the underlying cache, and it cannot
     // have pruned entries (as it contains full) transactions. First checking
     // the underlying cache risks returning a pruned entry instead.
     CTransactionRef ptx = mempool.get(outpoint.GetTxId());
     if (ptx) {
         if (outpoint.GetN() < ptx->vout.size()) {
             coin = Coin(ptx->vout[outpoint.GetN()], MEMPOOL_HEIGHT, false);
             return true;
         }
         return false;
     }
     return base->GetCoin(outpoint, coin);
 }
 
 void CCoinsViewMemPool::PackageAddTransaction(const CTransactionRef &tx) {
     for (uint32_t n = 0; n < tx->vout.size(); ++n) {
         m_temp_added.emplace(COutPoint(tx->GetId(), n),
                              Coin(tx->vout[n], MEMPOOL_HEIGHT, false));
     }
 }
 
 size_t CTxMemPool::DynamicMemoryUsage() const {
     LOCK(cs);
     // Estimate the overhead of mapTx to be 12 pointers + an allocation, as no
     // exact formula for boost::multi_index_contained is implemented.
     return memusage::MallocUsage(sizeof(CTxMemPoolEntry) +
                                  12 * sizeof(void *)) *
                mapTx.size() +
            memusage::DynamicUsage(mapNextTx) +
            memusage::DynamicUsage(mapDeltas) + cachedInnerUsage;
 }
 
 void CTxMemPool::RemoveUnbroadcastTx(const TxId &txid, const bool unchecked) {
     LOCK(cs);
 
     if (m_unbroadcast_txids.erase(txid)) {
         LogPrint(
             BCLog::MEMPOOL, "Removed %i from set of unbroadcast txns%s\n",
             txid.GetHex(),
             (unchecked ? " before confirmation that txn was sent out" : ""));
     }
 }
 
 void CTxMemPool::RemoveStaged(const setEntries &stage, bool updateDescendants,
                               MemPoolRemovalReason reason) {
     AssertLockHeld(cs);
     UpdateForRemoveFromMempool(stage, updateDescendants);
     for (txiter it : stage) {
         removeUnchecked(it, reason);
     }
 }
 
 int CTxMemPool::Expire(std::chrono::seconds time) {
     AssertLockHeld(cs);
     indexed_transaction_set::index<entry_time>::type::iterator it =
         mapTx.get<entry_time>().begin();
     setEntries toremove;
     while (it != mapTx.get<entry_time>().end() && it->GetTime() < time) {
         toremove.insert(mapTx.project<0>(it));
         it++;
     }
 
     setEntries stage;
     for (txiter removeit : toremove) {
         CalculateDescendants(removeit, stage);
     }
 
     RemoveStaged(stage, false, MemPoolRemovalReason::EXPIRY);
     return stage.size();
 }
 
 void CTxMemPool::LimitSize(CCoinsViewCache &coins_cache, size_t limit,
                            std::chrono::seconds age) {
     AssertLockHeld(::cs_main);
     AssertLockHeld(cs);
     int expired = Expire(GetTime<std::chrono::seconds>() - age);
     if (expired != 0) {
         LogPrint(BCLog::MEMPOOL,
                  "Expired %i transactions from the memory pool\n", expired);
     }
 
     std::vector<COutPoint> vNoSpendsRemaining;
     TrimToSize(limit, &vNoSpendsRemaining);
     for (const COutPoint &removed : vNoSpendsRemaining) {
         coins_cache.Uncache(removed);
     }
 }
 
 void CTxMemPool::addUnchecked(const CTxMemPoolEntry &entry) {
     setEntries setAncestors;
-    if (!wellingtonLatched) {
-        std::string dummy;
-        CalculateMemPoolAncestors(entry, setAncestors, nNoLimit, nNoLimit,
-                                  nNoLimit, nNoLimit, dummy);
-    }
     return addUnchecked(entry, setAncestors);
 }
 
 void CTxMemPool::UpdateChild(txiter entry, txiter child, bool add) {
     AssertLockHeld(cs);
     CTxMemPoolEntry::Children s;
     if (add && entry->GetMemPoolChildren().insert(*child).second) {
         cachedInnerUsage += memusage::IncrementalDynamicUsage(s);
     } else if (!add && entry->GetMemPoolChildren().erase(*child)) {
         cachedInnerUsage -= memusage::IncrementalDynamicUsage(s);
     }
 }
 
 void CTxMemPool::UpdateParent(txiter entry, txiter parent, bool add) {
     AssertLockHeld(cs);
     CTxMemPoolEntry::Parents s;
     if (add && entry->GetMemPoolParents().insert(*parent).second) {
         cachedInnerUsage += memusage::IncrementalDynamicUsage(s);
     } else if (!add && entry->GetMemPoolParents().erase(*parent)) {
         cachedInnerUsage -= memusage::IncrementalDynamicUsage(s);
     }
 }
 
 CFeeRate CTxMemPool::GetMinFee(size_t sizelimit) const {
     LOCK(cs);
     if (!blockSinceLastRollingFeeBump || rollingMinimumFeeRate == 0) {
         return CFeeRate(int64_t(ceill(rollingMinimumFeeRate)) * SATOSHI);
     }
 
     int64_t time = GetTime();
     if (time > lastRollingFeeUpdate + 10) {
         double halflife = ROLLING_FEE_HALFLIFE;
         if (DynamicMemoryUsage() < sizelimit / 4) {
             halflife /= 4;
         } else if (DynamicMemoryUsage() < sizelimit / 2) {
             halflife /= 2;
         }
 
         rollingMinimumFeeRate =
             rollingMinimumFeeRate /
             pow(2.0, (time - lastRollingFeeUpdate) / halflife);
         lastRollingFeeUpdate = time;
     }
     return CFeeRate(int64_t(ceill(rollingMinimumFeeRate)) * SATOSHI);
 }
 
 void CTxMemPool::trackPackageRemoved(const CFeeRate &rate) {
     AssertLockHeld(cs);
     if ((rate.GetFeePerK() / SATOSHI) > rollingMinimumFeeRate) {
         rollingMinimumFeeRate = rate.GetFeePerK() / SATOSHI;
         blockSinceLastRollingFeeBump = false;
     }
 }
 
 void CTxMemPool::TrimToSize(size_t sizelimit,
                             std::vector<COutPoint> *pvNoSpendsRemaining) {
     AssertLockHeld(cs);
 
     unsigned nTxnRemoved = 0;
     CFeeRate maxFeeRateRemoved(Amount::zero());
     while (!mapTx.empty() && DynamicMemoryUsage() > sizelimit) {
         auto it = mapTx.get<modified_feerate>().end();
         --it;
 
         // We set the new mempool min fee to the feerate of the removed
         // transaction, plus the "minimum reasonable fee rate" (ie some value
         // under which we consider txn to have 0 fee). This way, we don't allow
         // txn to enter mempool with feerate equal to txn which were removed
         // with no block in between.
         CFeeRate removed = it->GetModifiedFeeRate();
         removed += MEMPOOL_FULL_FEE_INCREMENT;
 
         trackPackageRemoved(removed);
         maxFeeRateRemoved = std::max(maxFeeRateRemoved, removed);
 
         setEntries stage;
         CalculateDescendants(mapTx.project<0>(it), stage);
         nTxnRemoved += stage.size();
 
         if (pvNoSpendsRemaining) {
             for (const txiter &iter : stage) {
                 for (const CTxIn &txin : iter->GetTx().vin) {
                     if (!exists(txin.prevout.GetTxId())) {
                         pvNoSpendsRemaining->push_back(txin.prevout);
                     }
                 }
             }
         }
 
         RemoveStaged(stage, false, MemPoolRemovalReason::SIZELIMIT);
     }
 
     if (maxFeeRateRemoved > CFeeRate(Amount::zero())) {
         LogPrint(BCLog::MEMPOOL,
                  "Removed %u txn, rolling minimum fee bumped to %s\n",
                  nTxnRemoved, maxFeeRateRemoved.ToString());
     }
 }
 
-/// Remove after wellington; after wellington activates this will be inaccurate
-uint64_t CTxMemPool::CalculateDescendantMaximum(txiter entry) const {
-    // find parent with highest descendant count
-    std::vector<txiter> candidates;
-    setEntries counted;
-    candidates.push_back(entry);
-    uint64_t maximum = 0;
-    while (candidates.size()) {
-        txiter candidate = candidates.back();
-        candidates.pop_back();
-        if (!counted.insert(candidate).second) {
-            continue;
-        }
-        const CTxMemPoolEntry::Parents &parents =
-            candidate->GetMemPoolParentsConst();
-        if (parents.size() == 0) {
-            maximum = std::max(maximum, candidate->GetCountWithDescendants());
-        } else {
-            for (const CTxMemPoolEntry &i : parents) {
-                candidates.push_back(mapTx.iterator_to(i));
-            }
-        }
-    }
-    return maximum;
-}
-
-void CTxMemPool::GetTransactionAncestry(const TxId &txid, size_t &ancestors,
-                                        size_t &descendants,
-                                        size_t *const ancestorsize,
-                                        Amount *const ancestorfees) const {
-    LOCK(cs);
-    auto it = mapTx.find(txid);
-    ancestors = descendants = 0;
-    if (it != mapTx.end()) {
-        ancestors = it->GetCountWithAncestors();
-        if (ancestorsize) {
-            *ancestorsize = it->GetSizeWithAncestors();
-        }
-        if (ancestorfees) {
-            *ancestorfees = it->GetModFeesWithAncestors();
-        }
-        descendants = CalculateDescendantMaximum(it);
-    }
-}
-
 bool CTxMemPool::IsLoaded() const {
     LOCK(cs);
     return m_is_loaded;
 }
 
 void CTxMemPool::SetIsLoaded(bool loaded) {
     LOCK(cs);
     m_is_loaded = loaded;
 }
 
 /** Maximum bytes for transactions to store for processing during reorg */
 static const size_t MAX_DISCONNECTED_TX_POOL_SIZE = 20 * DEFAULT_MAX_BLOCK_SIZE;
 
 void DisconnectedBlockTransactions::addForBlock(
     const std::vector<CTransactionRef> &vtx, CTxMemPool &pool) {
     AssertLockHeld(pool.cs);
     for (const auto &tx : reverse_iterate(vtx)) {
         // If we already added it, just skip.
         auto it = queuedTx.find(tx->GetId());
         if (it != queuedTx.end()) {
             continue;
         }
 
         // Insert the transaction into the pool.
         addTransaction(tx);
 
         // Fill in the set of parents.
         std::unordered_set<TxId, SaltedTxIdHasher> parents;
         for (const CTxIn &in : tx->vin) {
             parents.insert(in.prevout.GetTxId());
         }
 
         // In order to make sure we keep things in topological order, we check
         // if we already know of the parent of the current transaction. If so,
         // we remove them from the set and then add them back.
         while (parents.size() > 0) {
             std::unordered_set<TxId, SaltedTxIdHasher> worklist(
                 std::move(parents));
             parents.clear();
 
             for (const TxId &txid : worklist) {
                 // If we do not have that txid in the set, nothing needs to be
                 // done.
                 auto pit = queuedTx.find(txid);
                 if (pit == queuedTx.end()) {
                     continue;
                 }
 
                 // We have parent in our set, we reinsert them at the right
                 // position.
                 const CTransactionRef ptx = *pit;
                 queuedTx.erase(pit);
                 queuedTx.insert(ptx);
 
                 // And we make sure ancestors are covered.
                 for (const CTxIn &in : ptx->vin) {
                     parents.insert(in.prevout.GetTxId());
                 }
             }
         }
     }
 
     // Keep the size under control.
     while (DynamicMemoryUsage() > MAX_DISCONNECTED_TX_POOL_SIZE) {
         // Drop the earliest entry, and remove its children from the
         // mempool.
         auto it = queuedTx.get<insertion_order>().begin();
         pool.removeRecursive(**it, MemPoolRemovalReason::REORG);
         removeEntry(it);
     }
 }
 
 void DisconnectedBlockTransactions::importMempool(CTxMemPool &pool) {
     AssertLockHeld(pool.cs);
     // addForBlock's algorithm sorts a vector of transactions back into
     // topological order. We use it in a separate object to create a valid
     // ordering of all mempool transactions, which we then splice in front of
     // the current queuedTx. This results in a valid sequence of transactions to
     // be reprocessed in updateMempoolForReorg.
 
     // We create vtx in order of the entry_id index to facilitate for
     // addForBlocks (which iterates in reverse order), as vtx probably end in
     // the correct ordering for queuedTx.
     std::vector<CTransactionRef> vtx;
 
     vtx.reserve(pool.mapTx.size());
     txInfo.reserve(pool.mapTx.size());
     for (const CTxMemPoolEntry &e : pool.mapTx.get<entry_id>()) {
         vtx.push_back(e.GetSharedTx());
         // save entry time, feeDelta, and height for use in
         // updateMempoolForReorg()
         txInfo.try_emplace(e.GetTx().GetId(), e.GetTime(),
                            e.GetModifiedFee() - e.GetFee(), e.GetHeight());
         // Notify all observers of this (possibly temporary) removal. This is
         // necessary for tracking the transactions that are removed from the
         // mempool during a reorg and can't be added back due to missing parent.
         // Transactions that are added back to the mempool will trigger another
         // notification.
         GetMainSignals().TransactionRemovedFromMempool(
             e.GetSharedTx(), MemPoolRemovalReason::REORG,
             pool.GetAndIncrementSequence());
     }
     pool.clear();
 
     // Use addForBlocks to sort the transactions and then splice them in front
     // of queuedTx
     DisconnectedBlockTransactions orderedTxnPool;
     orderedTxnPool.addForBlock(vtx, pool);
     cachedInnerUsage += orderedTxnPool.cachedInnerUsage;
     queuedTx.get<insertion_order>().splice(
         queuedTx.get<insertion_order>().begin(),
         orderedTxnPool.queuedTx.get<insertion_order>());
 
     // We limit memory usage because we can't know if more blocks will be
     // disconnected
     while (DynamicMemoryUsage() > MAX_DISCONNECTED_TX_POOL_SIZE) {
         // Drop the earliest entry which, by definition, has no children
         removeEntry(queuedTx.get<insertion_order>().begin());
     }
 }
 
 auto DisconnectedBlockTransactions::getTxInfo(const CTransactionRef &tx) const
     -> const TxInfo * {
     if (auto it = txInfo.find(tx->GetId()); it != txInfo.end()) {
         return &it->second;
     }
 
     return nullptr;
 }
 
 void DisconnectedBlockTransactions::updateMempoolForReorg(
     const Config &config, Chainstate &active_chainstate, bool fAddToMempool,
     CTxMemPool &pool) {
     AssertLockHeld(cs_main);
     AssertLockHeld(pool.cs);
 
     if (fAddToMempool) {
         // disconnectpool's insertion_order index sorts the entries from oldest
         // to newest, but the oldest entry will be the last tx from the latest
         // mined block that was disconnected.
         // Iterate disconnectpool in reverse, so that we add transactions back
         // to the mempool starting with the earliest transaction that had been
         // previously seen in a block.
         for (const CTransactionRef &tx :
              reverse_iterate(queuedTx.get<insertion_order>())) {
             if (tx->IsCoinBase()) {
                 continue;
             }
             // restore saved PrioritiseTransaction state and nAcceptTime
             const auto ptxInfo = getTxInfo(tx);
             bool hasFeeDelta = false;
             if (ptxInfo && ptxInfo->feeDelta != Amount::zero()) {
                 // manipulate mapDeltas directly (faster than calling
                 // PrioritiseTransaction)
                 pool.mapDeltas[tx->GetId()] = ptxInfo->feeDelta;
                 hasFeeDelta = true;
             }
             // ignore validation errors in resurrected transactions
             auto result = AcceptToMemoryPool(
                 config, active_chainstate, tx,
                 /*accept_time=*/ptxInfo ? ptxInfo->time.count() : GetTime(),
                 /*bypass_limits=*/true, /*test_accept=*/false,
                 /*heightOverride=*/ptxInfo ? ptxInfo->height : 0);
             if (result.m_result_type !=
                     MempoolAcceptResult::ResultType::VALID &&
                 hasFeeDelta) {
                 // tx not accepted: undo mapDelta insertion from above
                 pool.mapDeltas.erase(tx->GetId());
             }
         }
     }
 
     queuedTx.clear();
     txInfo.clear();
 
     // Re-limit mempool size, in case we added any transactions
     pool.LimitSize(active_chainstate.CoinsTip(),
                    gArgs.GetIntArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) *
                        1000000,
                    std::chrono::hours{gArgs.GetIntArg("-mempoolexpiry",
                                                       DEFAULT_MEMPOOL_EXPIRY)});
 }
diff --git a/src/txmempool.h b/src/txmempool.h
index cc1004d2a..c95abf3d7 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -1,970 +1,937 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_TXMEMPOOL_H
 #define BITCOIN_TXMEMPOOL_H
 
 #include <coins.h>
 #include <consensus/amount.h>
 #include <core_memusage.h>
 #include <indirectmap.h>
 #include <policy/packages.h>
 #include <primitives/transaction.h>
 #include <sync.h>
 #include <util/hasher.h>
 
 #include <boost/multi_index/hashed_index.hpp>
 #include <boost/multi_index/ordered_index.hpp>
 #include <boost/multi_index/sequenced_index.hpp>
 #include <boost/multi_index_container.hpp>
 
 #include <atomic>
 #include <map>
 #include <optional>
 #include <set>
 #include <string>
 #include <unordered_map>
 #include <utility>
 #include <vector>
 
 class CBlockIndex;
 class CChain;
 class Chainstate;
 class Config;
 
 extern RecursiveMutex cs_main;
 
 /**
  * Fake height value used in Coins to signify they are only in the memory
  * pool(since 0.8)
  */
 static const uint32_t MEMPOOL_HEIGHT = 0x7FFFFFFF;
 
 struct LockPoints {
     // Will be set to the blockchain height and median time past values that
     // would be necessary to satisfy all relative locktime constraints (BIP68)
     // of this tx given our view of block chain history
     int height{0};
     int64_t time{0};
     // As long as the current chain descends from the highest height block
     // containing one of the inputs used in the calculation, then the cached
     // values are still valid even after a reorg.
     CBlockIndex *maxInputBlock{nullptr};
 };
 
 /**
  * Test whether the LockPoints height and time are still valid on the current
  * chain.
  */
 bool TestLockPointValidity(const CChain &active_chain, const LockPoints &lp)
     EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
 struct CompareIteratorById {
     // SFINAE for T where T is either a pointer type (e.g., a txiter) or a
     // reference_wrapper<T> (e.g. a wrapped CTxMemPoolEntry&)
     template <typename T>
     bool operator()(const std::reference_wrapper<T> &a,
                     const std::reference_wrapper<T> &b) const {
         return a.get().GetTx().GetId() < b.get().GetTx().GetId();
     }
     template <typename T> bool operator()(const T &a, const T &b) const {
         return a->GetTx().GetId() < b->GetTx().GetId();
     }
 };
 
 /** \class CTxMemPoolEntry
  *
  * CTxMemPoolEntry stores data about the corresponding transaction, as well as
  * data about all in-mempool transactions that depend on the transaction
  * ("descendant" transactions).
  *
  * When a new entry is added to the mempool, we update the descendant state
  * (nCountWithDescendants, nSizeWithDescendants, and nModFeesWithDescendants)
  * for all ancestors of the newly added transaction.
  */
 
 class CTxMemPoolEntry {
 public:
     typedef std::reference_wrapper<const CTxMemPoolEntry> CTxMemPoolEntryRef;
     // two aliases, should the types ever diverge
     typedef std::set<CTxMemPoolEntryRef, CompareIteratorById> Parents;
     typedef std::set<CTxMemPoolEntryRef, CompareIteratorById> Children;
 
 private:
     //! Unique identifier -- used for topological sorting
     uint64_t entryId = 0;
 
     const CTransactionRef tx;
     mutable Parents m_parents;
     mutable Children m_children;
     //! Cached to avoid expensive parent-transaction lookups
     const Amount nFee;
     //! ... and avoid recomputing tx size
     const size_t nTxSize;
     //! ... and total memory usage
     const size_t nUsageSize;
     //! Local time when entering the mempool
     const int64_t nTime;
     //! Chain height when entering the mempool
     const unsigned int entryHeight;
     //! keep track of transactions that spend a coinbase
     const bool spendsCoinbase;
     //! Total sigChecks
     const int64_t sigChecks;
     //! Used for determining the priority of the transaction for mining in a
     //! block
     Amount feeDelta{Amount::zero()};
     //! Track the height and time at which tx was final
     LockPoints lockPoints;
 
     // NOTE:
     // The below members will stop being updated after Wellington activation,
     // and should be removed in the release after Wellington is checkpointed.
     //
     // Information about descendants of this transaction that are in the
     // mempool; if we remove this transaction we must remove all of these
     // descendants as well.
     //! number of descendant transactions
     uint64_t nCountWithDescendants{1};
     //! ... and size
     uint64_t nSizeWithDescendants;
     //! ... and total fees (all including us)
     Amount nModFeesWithDescendants;
     //! ... and sichecks
     int64_t nSigChecksWithDescendants;
 
     // Analogous statistics for ancestor transactions
     uint64_t nCountWithAncestors{1};
     uint64_t nSizeWithAncestors;
     Amount nModFeesWithAncestors;
     int64_t nSigChecksWithAncestors;
 
 public:
     CTxMemPoolEntry(const CTransactionRef &_tx, const Amount fee, int64_t time,
                     unsigned int entry_height, bool spends_coinbase,
                     int64_t sigchecks, LockPoints lp);
 
     uint64_t GetEntryId() const { return entryId; }
     //! This should only be set by addUnchecked() before entry insertion into
     //! mempool
     void SetEntryId(uint64_t eid) { entryId = eid; }
 
     const CTransaction &GetTx() const { return *this->tx; }
     CTransactionRef GetSharedTx() const { return this->tx; }
     Amount GetFee() const { return nFee; }
     size_t GetTxSize() const { return nTxSize; }
     size_t GetTxVirtualSize() const;
 
     std::chrono::seconds GetTime() const { return std::chrono::seconds{nTime}; }
     unsigned int GetHeight() const { return entryHeight; }
     int64_t GetSigChecks() const { return sigChecks; }
     Amount GetModifiedFee() const { return nFee + feeDelta; }
     CFeeRate GetModifiedFeeRate() const {
         return CFeeRate(GetModifiedFee(), GetTxVirtualSize());
     }
     size_t DynamicMemoryUsage() const { return nUsageSize; }
     const LockPoints &GetLockPoints() const { return lockPoints; }
 
     // Adjusts the descendant state. -- To be removed after Wellington
     void UpdateDescendantState(int64_t modifySize, Amount modifyFee,
                                int64_t modifyCount, int64_t modifySigChecks);
     // Adjusts the ancestor state -- To be removed after Wellington
     void UpdateAncestorState(int64_t modifySize, Amount modifyFee,
                              int64_t modifyCount, int64_t modifySigChecks);
 
     // Updates the fee delta used for mining priority score, and the
     // modified fees with descendants.
     void UpdateFeeDelta(Amount feeDelta);
     // Update the LockPoints after a reorg
     void UpdateLockPoints(const LockPoints &lp);
 
     uint64_t GetCountWithDescendants() const { return nCountWithDescendants; }
     uint64_t GetSizeWithDescendants() const { return nSizeWithDescendants; }
     uint64_t GetVirtualSizeWithDescendants() const;
     Amount GetModFeesWithDescendants() const { return nModFeesWithDescendants; }
     int64_t GetSigChecksWithDescendants() const {
         return nSigChecksWithDescendants;
     }
 
     bool GetSpendsCoinbase() const { return spendsCoinbase; }
 
     uint64_t GetCountWithAncestors() const { return nCountWithAncestors; }
     uint64_t GetSizeWithAncestors() const { return nSizeWithAncestors; }
     uint64_t GetVirtualSizeWithAncestors() const;
     Amount GetModFeesWithAncestors() const { return nModFeesWithAncestors; }
     int64_t GetSigChecksWithAncestors() const {
         return nSigChecksWithAncestors;
     }
 
     const Parents &GetMemPoolParentsConst() const { return m_parents; }
     const Children &GetMemPoolChildrenConst() const { return m_children; }
     Parents &GetMemPoolParents() const { return m_parents; }
     Children &GetMemPoolChildren() const { return m_children; }
 };
 
 // extracts a transaction id from CTxMemPoolEntry or CTransactionRef
 struct mempoolentry_txid {
     typedef TxId result_type;
     result_type operator()(const CTxMemPoolEntry &entry) const {
         return entry.GetTx().GetId();
     }
 
     result_type operator()(const CTransactionRef &tx) const {
         return tx->GetId();
     }
 };
 
 // used by the entry_time index
 struct CompareTxMemPoolEntryByEntryTime {
     bool operator()(const CTxMemPoolEntry &a, const CTxMemPoolEntry &b) const {
         return a.GetTime() < b.GetTime();
     }
 };
 
 // used by the entry_id index
 struct CompareTxMemPoolEntryByEntryId {
     bool operator()(const CTxMemPoolEntry &a, const CTxMemPoolEntry &b) const {
         return a.GetEntryId() < b.GetEntryId();
     }
 };
 
 /**
  * \class CompareTxMemPoolEntryByModifiedFeeRate
  *
  *  Sort by feerate of entry (modfee/vsize) in descending order.
  *  This is used by the block assembler (mining).
  */
 struct CompareTxMemPoolEntryByModifiedFeeRate {
     bool operator()(const CTxMemPoolEntry &a, const CTxMemPoolEntry &b) const {
         const CFeeRate frA = a.GetModifiedFeeRate();
         const CFeeRate frB = b.GetModifiedFeeRate();
 
         // Sort by modified fee rate first
         if (frA != frB) {
             return frA > frB;
         }
 
         // Ties are broken by whichever is topologically earlier
         // (this helps mining code avoid some backtracking).
         if (a.GetEntryId() != b.GetEntryId()) {
             return a.GetEntryId() < b.GetEntryId();
         }
 
         // If nothing else, sort by txid (this should never happen as entryID is
         // expected to be unique).
         return a.GetSharedTx()->GetId() < b.GetSharedTx()->GetId();
     }
 };
 
 // Multi_index tag names
 struct entry_time {};
 struct modified_feerate {};
 struct entry_id {};
 
 /**
  * Information about a mempool transaction.
  */
 struct TxMempoolInfo {
     /** The transaction itself */
     CTransactionRef tx;
 
     /** Time the transaction entered the mempool. */
     std::chrono::seconds m_time;
 
     /** Fee of the transaction. */
     Amount fee;
 
     /** Virtual size of the transaction. */
     size_t vsize;
 
     /** The fee delta. */
     Amount nFeeDelta;
 };
 
 /**
  * Reason why a transaction was removed from the mempool, this is passed to the
  * notification signal.
  */
 enum class MemPoolRemovalReason {
     //! Expired from mempool
     EXPIRY,
     //! Removed in size limiting
     SIZELIMIT,
     //! Removed for reorganization
     REORG,
     //! Removed for block
     BLOCK,
     //! Removed for conflict with in-block transaction
     CONFLICT,
     //! Removed for replacement
     REPLACED
 };
 
 /**
  * CTxMemPool stores valid-according-to-the-current-best-chain transactions that
  * may be included in the next block.
  *
  * Transactions are added when they are seen on the network (or created by the
  * local node), but not all transactions seen are added to the pool. For
  * example, the following new transactions will not be added to the mempool:
  * - a transaction which doesn't meet the minimum fee requirements.
  * - a new transaction that double-spends an input of a transaction already in
  * the pool.
  * - a non-standard transaction.
  *
  * CTxMemPool::mapTx, and CTxMemPoolEntry bookkeeping:
  *
  * mapTx is a boost::multi_index that sorts the mempool on 3 criteria:
  * - transaction hash
  * - time in mempool
  * - entry id (this is a topological index)
  *
  * Note: the term "descendant" refers to in-mempool transactions that depend on
  * this one, while "ancestor" refers to in-mempool transactions that a given
  * transaction depends on.
  *
  * When a new transaction is added to the mempool, it has no in-mempool children
  * (because any such children would be an orphan). So in addUnchecked(), we:
  * - update a new entry's setMemPoolParents to include all in-mempool parents
  * - update the new entry's direct parents to include the new tx as a child
  *
  * When a transaction is removed from the mempool, we must:
  * - update all in-mempool parents to not track the tx in setMemPoolChildren
  * - update all in-mempool children to not include it as a parent
  *
  * These happen in UpdateForRemoveFromMempool(). (Note that when removing a
  * transaction along with its descendants, we must calculate that set of
  * transactions to be removed before doing the removal, or else the mempool can
  * be in an inconsistent state where it's impossible to walk the ancestors of a
  * transaction.)
  *
  * In the event of a reorg, the invariant that all newly-added tx's have no
  * in-mempool children must be maintained.  On top of this, we use a topological
  * index (GetEntryId).  As such, we always dump mempool tx's into a disconnect
  * pool on reorg, and simply add them one by one, along with tx's from
  * disconnected blocks, when the reorg is complete.
  *
  * Computational limits:
  *
  * Updating all in-mempool ancestors of a newly added transaction before
  * wellington activates can be slow. After wellington, no bound exists on how
  * many in-mempool ancestors there may be.
  */
 class CTxMemPool {
 private:
     //! Value n means that 1 times in n we check.
     const int m_check_ratio;
     //! Used by getblocktemplate to trigger CreateNewBlock() invocation
     std::atomic<uint32_t> nTransactionsUpdated{0};
 
     //! sum of all mempool tx's sizes.
     uint64_t totalTxSize GUARDED_BY(cs);
     //! sum of all mempool tx's fees (NOT modified fee)
     Amount m_total_fee GUARDED_BY(cs);
     //! sum of dynamic memory usage of all the map elements (NOT the maps
     //! themselves)
     uint64_t cachedInnerUsage GUARDED_BY(cs);
 
     mutable int64_t lastRollingFeeUpdate GUARDED_BY(cs);
     mutable bool blockSinceLastRollingFeeBump GUARDED_BY(cs);
     //! minimum fee to get into the pool, decreases exponentially
     mutable double rollingMinimumFeeRate GUARDED_BY(cs);
 
     // In-memory counter for external mempool tracking purposes.
     // This number is incremented once every time a transaction
     // is added or removed from the mempool for any reason.
     mutable uint64_t m_sequence_number GUARDED_BY(cs){1};
 
     void trackPackageRemoved(const CFeeRate &rate) EXCLUSIVE_LOCKS_REQUIRED(cs);
 
     bool m_is_loaded GUARDED_BY(cs){false};
 
     //! Used by addUnchecked to generate ever-increasing
     //! CTxMemPoolEntry::entryId's
     uint64_t nextEntryId GUARDED_BY(cs) = 1;
 
 public:
     // public only for testing
     static const int ROLLING_FEE_HALFLIFE = 60 * 60 * 12;
 
     typedef boost::multi_index_container<
         CTxMemPoolEntry, boost::multi_index::indexed_by<
                              // indexed by txid
                              boost::multi_index::hashed_unique<
                                  mempoolentry_txid, SaltedTxIdHasher>,
                              // sorted by fee rate
                              boost::multi_index::ordered_non_unique<
                                  boost::multi_index::tag<modified_feerate>,
                                  boost::multi_index::identity<CTxMemPoolEntry>,
                                  CompareTxMemPoolEntryByModifiedFeeRate>,
                              // sorted by entry time
                              boost::multi_index::ordered_non_unique<
                                  boost::multi_index::tag<entry_time>,
                                  boost::multi_index::identity<CTxMemPoolEntry>,
                                  CompareTxMemPoolEntryByEntryTime>,
                              // sorted topologically (insertion order)
                              boost::multi_index::ordered_unique<
                                  boost::multi_index::tag<entry_id>,
                                  boost::multi_index::identity<CTxMemPoolEntry>,
                                  CompareTxMemPoolEntryByEntryId>>>
         indexed_transaction_set;
 
     /**
      * This mutex needs to be locked when accessing `mapTx` or other members
      * that are guarded by it.
      *
      * @par Consistency guarantees
      *
      * By design, it is guaranteed that:
      *
      * 1. Locking both `cs_main` and `mempool.cs` will give a view of mempool
      *    that is consistent with current chain tip (`ActiveChain()` and
      *    `CoinsTip()`) and is fully populated. Fully populated means that if
      *    the current active chain is missing transactions that were present in
      *    a previously active chain, all the missing transactions will have been
      *    re-added to the mempool and should be present if they meet size and
      *    consistency constraints.
      *
      * 2. Locking `mempool.cs` without `cs_main` will give a view of a mempool
      *    consistent with some chain that was active since `cs_main` was last
      *    locked, and that is fully populated as described above. It is ok for
      *    code that only needs to query or remove transactions from the mempool
      *    to lock just `mempool.cs` without `cs_main`.
      *
      * To provide these guarantees, it is necessary to lock both `cs_main` and
      * `mempool.cs` whenever adding transactions to the mempool and whenever
      * changing the chain tip. It's necessary to keep both mutexes locked until
      * the mempool is consistent with the new chain tip and fully populated.
      */
     mutable RecursiveMutex cs;
     indexed_transaction_set mapTx GUARDED_BY(cs);
 
     using txiter = indexed_transaction_set::nth_index<0>::type::const_iterator;
     typedef std::set<txiter, CompareIteratorById> setEntries;
 
-    /// Remove after wellington activates as this will be inaccurate
-    uint64_t CalculateDescendantMaximum(txiter entry) const
-        EXCLUSIVE_LOCKS_REQUIRED(cs);
-
 private:
     void UpdateParent(txiter entry, txiter parent, bool add)
         EXCLUSIVE_LOCKS_REQUIRED(cs);
     void UpdateChild(txiter entry, txiter child, bool add)
         EXCLUSIVE_LOCKS_REQUIRED(cs);
 
     /**
      * Track locally submitted transactions to periodically retry initial
      * broadcast
      */
     std::set<TxId> m_unbroadcast_txids GUARDED_BY(cs);
 
     /**
      * Helper function to calculate all in-mempool ancestors of staged_ancestors
      * and apply ancestor and descendant limits (including staged_ancestors
      * themselves, entry_size and entry_count).
      * param@[in]   entry_size          Virtual size to include in the limits.
      * param@[in]   entry_count         How many entries to include in the
      *                                  limits.
      * param@[in]   staged_ancestors    Should contain entries in the mempool.
      * param@[out]  setAncestors        Will be populated with all mempool
      *                                  ancestors.
      */
     bool CalculateAncestorsAndCheckLimits(
         size_t entry_size, size_t entry_count, setEntries &setAncestors,
         CTxMemPoolEntry::Parents &staged_ancestors, uint64_t limitAncestorCount,
         uint64_t limitAncestorSize, uint64_t limitDescendantCount,
         uint64_t limitDescendantSize, std::string &errString) const
         EXCLUSIVE_LOCKS_REQUIRED(cs);
 
 public:
     indirectmap<COutPoint, const CTransaction *> mapNextTx GUARDED_BY(cs);
     std::map<TxId, Amount> mapDeltas GUARDED_BY(cs);
 
-    /**
-     * Wellington activation latch. This is latched permanently to true in
-     * AcceptToMemoryPool the first time a tx arrives and
-     * IsWellingtonActivated() returns true. This should be removed after
-     * wellington is checkpointed and its mempool-accept/relay rules become
-     * retroactively permanent.
-     */
-    std::atomic<bool> wellingtonLatched{false};
-
     /**
      * Create a new CTxMemPool.
      * Sanity checks will be off by default for performance, because otherwise
      * accepting transactions becomes O(N^2) where N is the number of
      * transactions in the pool.
      *
      * @param[in] check_ratio is the ratio used to determine how often sanity
      *     checks will run.
      */
     CTxMemPool(int check_ratio = 0);
     ~CTxMemPool();
 
     /**
      * If sanity-checking is turned on, check makes sure the pool is consistent
      * (does not contain two transactions that spend the same inputs, all inputs
      * are in the mapNextTx array). If sanity-checking is turned off, check does
      * nothing.
      */
     void check(const CCoinsViewCache &active_coins_tip,
                int64_t spendheight) const EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
     // addUnchecked must update state for all parents of a given transaction,
     // updating child links as necessary.
     // Pre-wellington: automatically calculates setAncestors, calls
     // addUnchecked(entry, setAncestors)
     // Post-wellington: identical to just calling addUnchecked(entry, {})
     // These 2 overloads should be collapsed down into 1 post-wellington (just a
     // single-argument version).
     void addUnchecked(const CTxMemPoolEntry &entry)
         EXCLUSIVE_LOCKS_REQUIRED(cs, cs_main);
     void
     addUnchecked(const CTxMemPoolEntry &entry,
                  const setEntries &setAncestors /* only used pre-wellington */)
         EXCLUSIVE_LOCKS_REQUIRED(cs, cs_main);
 
     void removeRecursive(const CTransaction &tx, MemPoolRemovalReason reason)
         EXCLUSIVE_LOCKS_REQUIRED(cs);
     void removeConflicts(const CTransaction &tx) EXCLUSIVE_LOCKS_REQUIRED(cs);
     void removeForBlock(const std::vector<CTransactionRef> &vtx)
         EXCLUSIVE_LOCKS_REQUIRED(cs);
 
     void clear();
     // lock free
     void _clear() EXCLUSIVE_LOCKS_REQUIRED(cs);
     bool CompareTopologically(const TxId &txida, const TxId &txidb) const;
     void getAllTxIds(std::vector<TxId> &vtxid) const;
     bool isSpent(const COutPoint &outpoint) const;
     unsigned int GetTransactionsUpdated() const;
     void AddTransactionsUpdated(unsigned int n);
     /**
      * Check that none of this transactions inputs are in the mempool, and thus
      * the tx is not dependent on other mempool transactions to be included in a
      * block.
      */
     bool HasNoInputsOf(const CTransaction &tx) const
         EXCLUSIVE_LOCKS_REQUIRED(cs);
 
     /** Affect CreateNewBlock prioritisation of transactions */
     void PrioritiseTransaction(const TxId &txid, const Amount nFeeDelta);
     void ApplyDelta(const TxId &txid, Amount &nFeeDelta) const
         EXCLUSIVE_LOCKS_REQUIRED(cs);
     void ClearPrioritisation(const TxId &txid) EXCLUSIVE_LOCKS_REQUIRED(cs);
 
     /** Get the transaction in the pool that spends the same prevout */
     const CTransaction *GetConflictTx(const COutPoint &prevout) const
         EXCLUSIVE_LOCKS_REQUIRED(cs);
 
     /** Returns an iterator to the given txid, if found */
     std::optional<txiter> GetIter(const TxId &txid) const
         EXCLUSIVE_LOCKS_REQUIRED(cs);
 
     /**
      * Translate a set of txids into a set of pool iterators to avoid repeated
      * lookups.
      */
     setEntries GetIterSet(const std::set<TxId> &txids) const
         EXCLUSIVE_LOCKS_REQUIRED(cs);
 
     /**
      * Remove a set of transactions from the mempool. If a transaction is in
      * this set, then all in-mempool descendants must also be in the set, unless
      * this transaction is being removed for being in a block. Set
      * updateDescendants to true when removing a tx that was in a block, so that
      * any in-mempool descendants have their ancestor state updated (only
      * evaluated before wellington activation).
      */
     void RemoveStaged(const setEntries &stage, bool updateDescendants,
                       MemPoolRemovalReason reason) EXCLUSIVE_LOCKS_REQUIRED(cs);
 
     /**
      * Try to calculate all in-mempool ancestors of entry.
      *  (these are all calculated including the tx itself)
      *  limitAncestorCount = max number of ancestors
      *  limitAncestorSize = max size of ancestors
      *  limitDescendantCount = max number of descendants any ancestor can have
      *  limitDescendantSize = max size of descendants any ancestor can have
      *  errString = populated with error reason if any limits are hit
      * fSearchForParents = whether to search a tx's vin for in-mempool parents,
      * or look up parents from m_parents. Must be true for entries not in the
      * mempool
      */
     bool CalculateMemPoolAncestors(
         const CTxMemPoolEntry &entry, setEntries &setAncestors,
         uint64_t limitAncestorCount, uint64_t limitAncestorSize,
         uint64_t limitDescendantCount, uint64_t limitDescendantSize,
         std::string &errString, bool fSearchForParents = true) const
         EXCLUSIVE_LOCKS_REQUIRED(cs);
 
     /**
      * Calculate all in-mempool ancestors of a set of transactions not already
      * in the mempool and check ancestor and descendant limits. Heuristics are
      * used to estimate the ancestor and descendant count of all entries if the
      * package were to be added to the mempool.  The limits are applied to the
      * union of all package transactions. For example, if the package has 3
      * transactions and limitAncestorCount = 50, the union of all 3 sets of
      * ancestors (including the transactions themselves) must be <= 47.
      * @param[in]       package                 Transaction package being
      *     evaluated for acceptance to mempool. The transactions need not be
      *     direct ancestors/descendants of each other.
      * @param[in]       limitAncestorCount      Max number of txns including
      *     ancestors.
      * @param[in]       limitAncestorSize       Max size including ancestors.
      * @param[in]       limitDescendantCount    Max number of txns including
      *     descendants.
      * @param[in]       limitDescendantSize     Max size including descendants.
      * @param[out]      errString               Populated with error reason if
      *     a limit is hit.
      */
     bool CheckPackageLimits(const Package &package, uint64_t limitAncestorCount,
                             uint64_t limitAncestorSize,
                             uint64_t limitDescendantCount,
                             uint64_t limitDescendantSize,
                             std::string &errString) const
         EXCLUSIVE_LOCKS_REQUIRED(cs);
 
     /**
      * Populate setDescendants with all in-mempool descendants of hash.
      * Assumes that setDescendants includes all in-mempool descendants of
      * anything already in it.
      */
     void CalculateDescendants(txiter it, setEntries &setDescendants) const
         EXCLUSIVE_LOCKS_REQUIRED(cs);
 
     /**
      * The minimum fee to get into the mempool, which may itself not be enough
      * for larger-sized transactions. The incrementalRelayFee policy variable is
      * used to bound the time it takes the fee rate to go back down all the way
      * to 0. When the feerate would otherwise be half of this, it is set to 0
      * instead.
      */
     CFeeRate GetMinFee(size_t sizelimit) const;
 
     /**
      * Remove transactions from the mempool until its dynamic size is <=
      * sizelimit. pvNoSpendsRemaining, if set, will be populated with the list
      * of outpoints which are not in mempool which no longer have any spends in
      * this mempool.
      */
     void TrimToSize(size_t sizelimit,
                     std::vector<COutPoint> *pvNoSpendsRemaining = nullptr)
         EXCLUSIVE_LOCKS_REQUIRED(cs);
 
     /**
      * Expire all transaction (and their dependencies) in the mempool older than
      * time. Return the number of removed transactions.
      */
     int Expire(std::chrono::seconds time) EXCLUSIVE_LOCKS_REQUIRED(cs);
 
     /**
      * Reduce the size of the mempool by expiring and then trimming the mempool.
      */
     void LimitSize(CCoinsViewCache &coins_cache, size_t limit,
                    std::chrono::seconds age)
         EXCLUSIVE_LOCKS_REQUIRED(cs, ::cs_main);
 
-    /**
-     * Calculate the ancestor and descendant count for the given transaction.
-     * The counts include the transaction itself.
-     * When ancestors is non-zero (ie, the transaction itself is in the
-     * mempool), ancestorsize and ancestorfees will also be set to the
-     * appropriate values.
-     *
-     * NOTE: Since we are removing the unconf. ancestor limits after wellington,
-     *       this function's existence is a potential DoS. It should not be
-     *       called after wellington since it relies on calculating quadratic
-     *       stats.
-     */
-    void GetTransactionAncestry(const TxId &txid, size_t &ancestors,
-                                size_t &descendants,
-                                size_t *ancestorsize = nullptr,
-                                Amount *ancestorfees = nullptr) const;
-
     /** @returns true if the mempool is fully loaded */
     bool IsLoaded() const;
 
     /** Sets the current loaded state */
     void SetIsLoaded(bool loaded);
 
     unsigned long size() const {
         LOCK(cs);
         return mapTx.size();
     }
 
     uint64_t GetTotalTxSize() const EXCLUSIVE_LOCKS_REQUIRED(cs) {
         AssertLockHeld(cs);
         return totalTxSize;
     }
 
     Amount GetTotalFee() const EXCLUSIVE_LOCKS_REQUIRED(cs) {
         AssertLockHeld(cs);
         return m_total_fee;
     }
 
     bool exists(const TxId &txid) const {
         LOCK(cs);
         return mapTx.count(txid) != 0;
     }
 
     CTransactionRef get(const TxId &txid) const;
     TxMempoolInfo info(const TxId &txid) const;
     std::vector<TxMempoolInfo> infoAll() const;
 
     CFeeRate estimateFee() const;
 
     size_t DynamicMemoryUsage() const;
 
     /** Adds a transaction to the unbroadcast set */
     void AddUnbroadcastTx(const TxId &txid) {
         LOCK(cs);
         // Sanity check the transaction is in the mempool & insert into
         // unbroadcast set.
         if (exists(txid)) {
             m_unbroadcast_txids.insert(txid);
         }
     }
 
     /** Removes a transaction from the unbroadcast set */
     void RemoveUnbroadcastTx(const TxId &txid, const bool unchecked = false);
 
     /** Returns transactions in unbroadcast set */
     std::set<TxId> GetUnbroadcastTxs() const {
         LOCK(cs);
         return m_unbroadcast_txids;
     }
 
     /** Returns whether a txid is in the unbroadcast set */
     bool IsUnbroadcastTx(const TxId &txid) const EXCLUSIVE_LOCKS_REQUIRED(cs) {
         AssertLockHeld(cs);
         return (m_unbroadcast_txids.count(txid) != 0);
     }
 
     /** Guards this internal counter for external reporting */
     uint64_t GetAndIncrementSequence() const EXCLUSIVE_LOCKS_REQUIRED(cs) {
         return m_sequence_number++;
     }
 
     uint64_t GetSequence() const EXCLUSIVE_LOCKS_REQUIRED(cs) {
         return m_sequence_number;
     }
 
 private:
     /** Set ancestor state for an entry */
     void UpdateEntryForAncestors(txiter it, const setEntries *setAncestors)
         EXCLUSIVE_LOCKS_REQUIRED(cs);
     /**
      * Update parents of `it` to add/remove it as a child transaction.
      */
-    void UpdateParentsOf(
-        bool add, txiter it,
-        const setEntries *setAncestors = nullptr /* only used pre-wellington */)
-        EXCLUSIVE_LOCKS_REQUIRED(cs);
+    void UpdateParentsOf(bool add, txiter it) EXCLUSIVE_LOCKS_REQUIRED(cs);
     /**
      * For each transaction being removed, update ancestors and any direct
      * children. If updateDescendants is true, then also update in-mempool
      * descendants' ancestor state. Note that ancestors are only updated before
      * wellington activation.
      */
     void UpdateForRemoveFromMempool(const setEntries &entriesToRemove,
                                     bool updateDescendants)
         EXCLUSIVE_LOCKS_REQUIRED(cs);
     /** Sever link between specified transaction and direct children. */
     void UpdateChildrenForRemoval(txiter entry) EXCLUSIVE_LOCKS_REQUIRED(cs);
 
     /**
      * Before calling removeUnchecked for a given transaction,
      * UpdateForRemoveFromMempool must be called on the entire (dependent) set
      * of transactions being removed at the same time. We use each
      * CTxMemPoolEntry's setMemPoolParents in order to walk ancestors of a given
      * transaction that is removed, so we can't remove intermediate transactions
      * in a chain before we've updated all the state for the removal.
      */
     void removeUnchecked(txiter entry, MemPoolRemovalReason reason)
         EXCLUSIVE_LOCKS_REQUIRED(cs);
 };
 
 /**
  * CCoinsView that brings transactions from a mempool into view.
  * It does not check for spendings by memory pool transactions.
  * Instead, it provides access to all Coins which are either unspent in the
  * base CCoinsView, are outputs from any mempool transaction, or are
  * tracked temporarily to allow transaction dependencies in package validation.
  * This allows transaction replacement to work as expected, as you want to
  * have all inputs "available" to check signatures, and any cycles in the
  * dependency graph are checked directly in AcceptToMemoryPool.
  * It also allows you to sign a double-spend directly in
  * signrawtransactionwithkey and signrawtransactionwithwallet,
  * as long as the conflicting transaction is not yet confirmed.
  */
 class CCoinsViewMemPool : public CCoinsViewBacked {
     /**
      * Coins made available by transactions being validated. Tracking these
      * allows for package validation, since we can access transaction outputs
      * without submitting them to mempool.
      */
     std::unordered_map<COutPoint, Coin, SaltedOutpointHasher> m_temp_added;
 
 protected:
     const CTxMemPool &mempool;
 
 public:
     CCoinsViewMemPool(CCoinsView *baseIn, const CTxMemPool &mempoolIn);
     bool GetCoin(const COutPoint &outpoint, Coin &coin) const override;
     /**
      * Add the coins created by this transaction. These coins are only
      * temporarily stored in m_temp_added and cannot be flushed to the back end.
      * Only used for package validation.
      */
     void PackageAddTransaction(const CTransactionRef &tx);
 };
 
 /**
  * DisconnectedBlockTransactions
  *
  * During the reorg, it's desirable to re-add previously confirmed transactions
  * to the mempool, so that anything not re-confirmed in the new chain is
  * available to be mined. However, it's more efficient to wait until the reorg
  * is complete and process all still-unconfirmed transactions at that time,
  * since we expect most confirmed transactions to (typically) still be
  * confirmed in the new chain, and re-accepting to the memory pool is expensive
  * (and therefore better to not do in the middle of reorg-processing).
  * Instead, store the disconnected transactions (in order!) as we go, remove any
  * that are included in blocks in the new chain, and then process the remaining
  * still-unconfirmed transactions at the end.
  *
  * It also enables efficient reprocessing of current mempool entries, useful
  * when (de)activating forks that result in in-mempool transactions becoming
  * invalid
  */
 // multi_index tag names
 struct txid_index {};
 struct insertion_order {};
 
 class DisconnectedBlockTransactions {
 private:
     typedef boost::multi_index_container<
         CTransactionRef, boost::multi_index::indexed_by<
                              // hashed by txid
                              boost::multi_index::hashed_unique<
                                  boost::multi_index::tag<txid_index>,
                                  mempoolentry_txid, SaltedTxIdHasher>,
                              // sorted by order in the blockchain
                              boost::multi_index::sequenced<
                                  boost::multi_index::tag<insertion_order>>>>
         indexed_disconnected_transactions;
 
     indexed_disconnected_transactions queuedTx;
     uint64_t cachedInnerUsage = 0;
 
     struct TxInfo {
         const std::chrono::seconds time;
         const Amount feeDelta;
         const unsigned height;
         TxInfo(const std::chrono::seconds &time_, Amount feeDelta_,
                unsigned height_) noexcept
             : time(time_), feeDelta(feeDelta_), height(height_) {}
     };
 
     using TxInfoMap = std::unordered_map<TxId, TxInfo, SaltedTxIdHasher>;
     /// populated by importMempool(); the original tx entry times and feeDeltas
     TxInfoMap txInfo;
 
     void addTransaction(const CTransactionRef &tx) {
         queuedTx.insert(tx);
         cachedInnerUsage += RecursiveDynamicUsage(tx);
     }
 
     /// @returns a pointer into the txInfo map if tx->GetId() exists in the map,
     /// or nullptr otherwise. Note that the returned pointer is only valid for
     /// as long as its underlying map node is valid.
     const TxInfo *getTxInfo(const CTransactionRef &tx) const;
 
 public:
     // It's almost certainly a logic bug if we don't clear out queuedTx before
     // destruction, as we add to it while disconnecting blocks, and then we
     // need to re-process remaining transactions to ensure mempool consistency.
     // For now, assert() that we've emptied out this object on destruction.
     // This assert() can always be removed if the reorg-processing code were
     // to be refactored such that this assumption is no longer true (for
     // instance if there was some other way we cleaned up the mempool after a
     // reorg, besides draining this object).
     ~DisconnectedBlockTransactions() { assert(queuedTx.empty()); }
 
     // Estimate the overhead of queuedTx to be 6 pointers + an allocation, as
     // no exact formula for boost::multi_index_contained is implemented.
     size_t DynamicMemoryUsage() const {
         return memusage::MallocUsage(sizeof(CTransactionRef) +
                                      6 * sizeof(void *)) *
                    queuedTx.size() +
                memusage::DynamicUsage(txInfo) + cachedInnerUsage;
     }
 
     const indexed_disconnected_transactions &GetQueuedTx() const {
         return queuedTx;
     }
 
     // Import mempool entries in topological order into queuedTx and clear the
     // mempool. Caller should call updateMempoolForReorg to reprocess these
     // transactions
     void importMempool(CTxMemPool &pool) EXCLUSIVE_LOCKS_REQUIRED(pool.cs);
 
     // Add entries for a block while reconstructing the topological ordering so
     // they can be added back to the mempool simply.
     void addForBlock(const std::vector<CTransactionRef> &vtx, CTxMemPool &pool)
         EXCLUSIVE_LOCKS_REQUIRED(pool.cs);
 
     // Remove entries based on txid_index, and update memory usage.
     void removeForBlock(const std::vector<CTransactionRef> &vtx) {
         // Short-circuit in the common case of a block being added to the tip
         if (queuedTx.empty()) {
             return;
         }
         for (auto const &tx : vtx) {
             auto it = queuedTx.find(tx->GetId());
             if (it != queuedTx.end()) {
                 cachedInnerUsage -= RecursiveDynamicUsage(*it);
                 queuedTx.erase(it);
                 txInfo.erase(tx->GetId());
             }
         }
     }
 
     // Remove an entry by insertion_order index, and update memory usage.
     void removeEntry(indexed_disconnected_transactions::index<
                      insertion_order>::type::iterator entry) {
         cachedInnerUsage -= RecursiveDynamicUsage(*entry);
         txInfo.erase((*entry)->GetId());
         queuedTx.get<insertion_order>().erase(entry);
     }
 
     bool isEmpty() const { return queuedTx.empty(); }
 
     void clear() {
         cachedInnerUsage = 0;
         queuedTx.clear();
         txInfo.clear();
     }
 
     /**
      * Make mempool consistent after a reorg, by re-adding or recursively
      * erasing disconnected block transactions from the mempool, and also
      * removing any other transactions from the mempool that are no longer valid
      * given the new tip/height.
      *
      * Note: we assume that disconnectpool only contains transactions that are
      * NOT confirmed in the current chain nor already in the mempool (otherwise,
      * in-mempool descendants of such transactions would be removed).
      *
      * Passing fAddToMempool=false will skip trying to add the transactions
      * back, and instead just erase from the mempool as needed.
      */
     void updateMempoolForReorg(const Config &config,
                                Chainstate &active_chainstate,
                                bool fAddToMempool, CTxMemPool &pool)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main, pool.cs);
 };
 
 #endif // BITCOIN_TXMEMPOOL_H
diff --git a/src/validation.cpp b/src/validation.cpp
index 22520e87f..367515baa 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -1,6240 +1,6218 @@
 // 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/block/minerfund.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/string.h>
 #include <util/system.h>
 #include <util/trace.h>
 #include <util/translation.h>
 #include <validationinterface.h>
 #include <warnings.h>
 
 #include <algorithm>
 #include <atomic>
 #include <deque>
 #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 *
 Chainstate::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);
                 }
             }
             // tip->GetAncestor(maxInputHeight) should never return a nullptr
             // because maxInputHeight is always less than the tip height.
             // It would, however, be a bad bug to continue execution, since a
             // LockPoints object with the maxInputBlock member set to nullptr
             // signifies no relative lock time.
             lp->maxInputBlock = Assert(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.cowperthwaiteActivationTime);
 }
 
 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, Chainstate &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;
         const unsigned int m_heightOverride;
         /**
          * 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,
                                      unsigned int heightOverride) {
             return ATMPArgs{config,
                             accept_time,
                             bypass_limits,
                             coins_to_uncache,
                             test_accept,
                             heightOverride,
                             /*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,
                             /*m_heightOverride=*/0,
                             // 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_heightOverride=*/0,
                             /*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;
 
     Chainstate &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;
     const unsigned int heightOverride = args.m_heightOverride;
 
     // 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,
         heightOverride ? heightOverride : 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));
     }
 
-    // Remove after wellington
-    if (!m_pool.wellingtonLatched) {
-        // 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);
 
     const Consensus::Params &consensusParams =
         args.m_config.GetChainParams().GetConsensus();
     const CBlockIndex *tip = m_active_chainstate.m_chain.Tip();
 
-    // After wellington we will stop computing the ancestors and descendant
-    // limits, and stop enforcing them. Because the mempool has no idea what the
-    // current tip is (and it should not), we will use an activation latch so it
-    // knows when the statistics can be skipped. This also makes an hypothetical
-    // reorg event easier to handle.
-    // Note that |= operator is not defined for atomic bool !
-    m_pool.wellingtonLatched =
-        m_pool.wellingtonLatched || IsWellingtonEnabled(consensusParams, tip);
-
     Workspace ws(ptx, GetNextBlockScriptFlags(consensusParams, 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);
     }
 
     const TxId txid = ptx->GetId();
 
     // Mempool sanity check -- in our new mempool no tx can be added if its
     // outputs are already spent in the mempool (that is, no children before
     // parents allowed; the mempool must be consistent at all times).
     //
     // This means that on reorg, the disconnectpool *must* always import
     // the existing mempool tx's, clear the mempool, and then re-add
     // remaining tx's in topological order via this function. Our new mempool
     // has fast adds, so this is ok.
     if (auto it = m_pool.mapNextTx.lower_bound(COutPoint{txid, 0});
         it != m_pool.mapNextTx.end() && it->first->GetTxId() == txid) {
         LogPrintf("%s: BUG! PLEASE REPORT THIS! Attempt to add txid %s, but "
                   "its outputs are already spent in the "
                   "mempool\n",
                   __func__, txid.ToString());
         ws.m_state.Invalid(TxValidationResult::TX_CONFLICT,
                            "txn-mempool-conflict");
         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,
                                        Chainstate &active_chainstate,
                                        const CTransactionRef &tx,
                                        int64_t accept_time, bool bypass_limits,
                                        bool test_accept,
                                        unsigned int heightOverride) {
     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,
         heightOverride);
     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, Chainstate &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);
 }
 
 Chainstate::Chainstate(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 Chainstate::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 Chainstate::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 Chainstate*`) can call it.
 //
 bool Chainstate::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 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;
     ReplaceAll(strCmd, "%s", safeStatus);
 
     std::thread t(runCommand, strCmd);
     // thread runs free
     t.detach();
 #endif
 }
 
 void Chainstate::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, or if it is back on the active chain, drop it
     if (m_best_fork_tip && (m_chain.Height() - m_best_fork_tip->nHeight >= 72 ||
                             m_chain.Contains(m_best_fork_tip))) {
         m_best_fork_tip = nullptr;
     }
 
     if (m_best_fork_tip ||
         (m_chainman.m_best_invalid &&
          m_chainman.m_best_invalid->nChainWork >
              m_chain.Tip()->nChainWork + (GetBlockProof(*m_chain.Tip()) * 6))) {
         if (!GetfLargeWorkForkFound() && m_best_fork_base) {
             std::string warning =
                 std::string("'Warning: Large-work fork detected, forking after "
                             "block ") +
                 m_best_fork_base->phashBlock->ToString() + std::string("'");
             AlertNotify(warning);
         }
 
         if (m_best_fork_tip && m_best_fork_base) {
             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__, m_best_fork_base->nHeight,
                       m_best_fork_base->phashBlock->ToString(),
                       m_best_fork_tip->nHeight,
                       m_best_fork_tip->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 Chainstate::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 &&
         (!m_best_fork_tip ||
          pindexNewForkTip->nHeight > m_best_fork_tip->nHeight) &&
         pindexNewForkTip->nChainWork - pfork->nChainWork >
             (GetBlockProof(*pfork) * 7) &&
         m_chain.Height() - pindexNewForkTip->nHeight < 72) {
         m_best_fork_tip = pindexNewForkTip;
         m_best_fork_base = pfork;
     }
 
     CheckForkWarningConditions();
 }
 
 // Called both upon regular invalid block discovery *and* InvalidateBlock
 void Chainstate::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 (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 Chainstate::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 Chainstate::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 Chainstate::ConnectBlock(const CBlock &block, BlockValidationState &state,
                               CBlockIndex *pindex, CCoinsViewCache &view,
                               BlockValidationOptions options, Amount *blockFees,
                               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");
     }
 
     if (blockFees) {
         *blockFees = nFees;
     }
 
     if (!IsWellingtonEnabled(consensusParams, pindex->pprev) &&
         !CheckMinerFund(consensusParams, pindex->pprev, block.vtx[0]->vout,
                         blockReward)) {
         return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
                              "bad-cb-minerfund");
     }
 
     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 Chainstate::GetCoinsCacheSizeState() {
     AssertLockHeld(::cs_main);
     return this->GetCoinsCacheSizeState(
         m_coinstip_cache_size_bytes,
         gArgs.GetIntArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000);
 }
 
 CoinsCacheSizeState
 Chainstate::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 Chainstate::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 Chainstate::ForceFlushStateToDisk() {
     BlockValidationState state;
     if (!this->FlushStateToDisk(state, FlushStateMode::ALWAYS)) {
         LogPrintf("%s: failed to flush state (%s)\n", __func__,
                   state.ToString());
     }
 }
 
 void Chainstate::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 Chainstate::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 Chainstate::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);
         }
     }
 
     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;
     }
 };
 
 /**
  * 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 added to connectTrace if connection succeeds.
  */
 bool Chainstate::ConnectTip(const Config &config, BlockValidationState &state,
                             BlockPolicyValidationState &blockPolicyState,
                             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);
     {
         Amount blockFees{Amount::zero()};
         CCoinsViewCache view(&CoinsTip());
         bool rv = ConnectBlock(blockConnecting, state, pindexNew, view,
                                BlockValidationOptions(config), &blockFees);
         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());
         }
 
         /**
          * The block is valid by consensus rules so now we check if the block
          * passes all block policy checks. If not, then park the block and bail.
          *
          * We check block parking policies before flushing changes to the UTXO
          * set. This allows us to avoid rewinding everything immediately after.
          *
          * Only check block parking policies the first time the block is
          * connected. Avalanche voting can override the parking decision made by
          * these policies.
          */
         const BlockHash blockhash = pindexNew->GetBlockHash();
         if (!IsInitialBlockDownload() &&
             !m_filterParkingPoliciesApplied.contains(blockhash)) {
             m_filterParkingPoliciesApplied.insert(blockhash);
 
             const Amount blockReward =
                 blockFees +
                 GetBlockSubsidy(pindexNew->nHeight, consensusParams);
 
             std::vector<std::unique_ptr<ParkingPolicy>> parkingPolicies;
             parkingPolicies.emplace_back(std::make_unique<MinerFundPolicy>(
                 consensusParams, *pindexNew, blockConnecting, blockReward));
 
             // If any block policy is violated, bail on the first one found
             if (std::find_if_not(parkingPolicies.begin(), parkingPolicies.end(),
                                  [&](const auto &policy) {
                                      bool ret = (*policy)(blockPolicyState);
                                      if (!ret) {
                                          LogPrintf(
                                              "Park block because it "
                                              "violated a block policy: %s\n",
                                              blockPolicyState.ToString());
                                      }
                                      return ret;
                                  }) != parkingPolicies.end()) {
                 pindexNew->nStatus = pindexNew->nStatus.withParked();
                 m_blockman.m_dirty_blockindex.insert(pindexNew);
                 return false;
             }
         }
 
         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);
         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 *Chainstate::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 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 Chainstate::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 Chainstate::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 (!fBlocksDisconnected) {
             // Import and clear mempool; we must do this to preserve
             // topological ordering in the mempool index. This is ok since
             // inserts into the mempool are very fast now in our new
             // implementation.
             disconnectpool.importMempool(*m_mempool);
         }
 
         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)) {
             BlockPolicyValidationState blockPolicyState;
             if (!ConnectTip(config, state, blockPolicyState, 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;
                 }
 
                 if (blockPolicyState.IsInvalid()) {
                     // The block violates a policy rule.
                     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(Chainstate &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 Chainstate::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 ||
                     (pindexMostWork && pindexMostWork->nStatus.isParked())) {
                     // 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 Chainstate::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);
 }
 
 namespace {
 // Leverage RAII to run a functor at scope end
 template <typename Func> struct Defer {
     Func func;
     Defer(Func &&f) : func(std::move(f)) {}
     ~Defer() { func(); }
 };
 } // namespace
 
 bool Chainstate::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));
             }
         }
     }
 
     {
         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());
 
         constexpr int maxDisconnectPoolBlocks = 10;
         bool ret = false;
         DisconnectedBlockTransactions disconnectpool;
         // After 10 blocks this becomes nullptr, so that DisconnectTip will
         // stop giving us unwound block txs if we are doing a deep unwind.
         DisconnectedBlockTransactions *optDisconnectPool = &disconnectpool;
 
         // Disable thread safety analysis because we can't require m_mempool->cs
         // as m_mempool can be null. We keep the runtime analysis though.
         Defer deferred([&]() NO_THREAD_SAFETY_ANALYSIS {
             AssertLockHeld(cs_main);
             if (m_mempool && !disconnectpool.isEmpty()) {
                 AssertLockHeld(m_mempool->cs);
                 // DisconnectTip will add transactions to disconnectpool.
                 // When all unwinding is done and we are on a new tip, we must
                 // add all transactions back to the mempool against the new tip.
                 disconnectpool.updateMempoolForReorg(config, *this,
                                                      /* fAddToMempool = */ ret,
                                                      *m_mempool);
             }
         });
 
         // Disconnect (descendants of) pindex, and mark them invalid.
         while (true) {
             if (ShutdownRequested()) {
                 break;
             }
 
             // Make sure the queue of validation callbacks doesn't grow
             // unboundedly.
             // FIXME this commented code is a regression and could cause OOM if
             // a very old block is invalidated via the invalidateblock RPC.
             // This can be uncommented if the main signals are moved away from
             // cs_main or this code is refactored so that cs_main can be
             // released at this point.
             //
             // LimitValidationInterfaceQueue();
 
             if (!m_chain.Contains(pindex)) {
                 break;
             }
 
             if (m_mempool && disconnected == 0) {
                 // On first iteration, we grab all the mempool txs to preserve
                 // topological ordering. This has the side-effect of temporarily
                 // clearing the mempool, but we will re-add later in
                 // updateMempoolForReorg() (above). This technique guarantees
                 // mempool consistency as well as ensures that our topological
                 // entry_id index is always correct.
                 disconnectpool.importMempool(*m_mempool);
             }
 
             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.
 
             ret = DisconnectTip(state, optDisconnectPool);
             ++disconnected;
 
             if (optDisconnectPool && disconnected > maxDisconnectPoolBlocks) {
                 // Stop using the disconnect pool after 10 blocks. After 10
                 // blocks we no longer add block tx's to the disconnectpool.
                 // However, when this scope ends we will reconcile what's
                 // in the pool with the new tip (in the deferred d'tor above).
                 optDisconnectPool = nullptr;
             }
 
             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 Chainstate::InvalidateBlock(const Config &config,
                                  BlockValidationState &state,
                                  CBlockIndex *pindex) {
     AssertLockNotHeld(m_chainstate_mutex);
     AssertLockNotHeld(::cs_main);
     // See 'Note for backport of Core PR16849' in Chainstate::UnwindBlock
     LOCK(m_chainstate_mutex);
 
     return UnwindBlock(config, state, pindex, true);
 }
 
 bool Chainstate::ParkBlock(const Config &config, BlockValidationState &state,
                            CBlockIndex *pindex) {
     AssertLockNotHeld(m_chainstate_mutex);
     AssertLockNotHeld(::cs_main);
     // See 'Note for backport of Core PR16849' in Chainstate::UnwindBlock
     LOCK(m_chainstate_mutex);
 
     return UnwindBlock(config, state, pindex, false);
 }
 
 template <typename F>
 bool Chainstate::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 Chainstate::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 Chainstate::ResetBlockFailureFlags(CBlockIndex *pindex) {
     AssertLockHeld(cs_main);
 
     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 Chainstate::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 Chainstate::UnparkBlockAndChildren(CBlockIndex *pindex) {
     return UnparkBlockImpl(pindex, true);
 }
 
 void Chainstate::UnparkBlock(CBlockIndex *pindex) {
     return UnparkBlockImpl(pindex, false);
 }
 
 bool Chainstate::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 Chainstate::ClearAvalancheFinalizedBlock() {
     LOCK(cs_avalancheFinalizedBlockIndex);
     m_avalancheFinalizedBlockIndex = nullptr;
 }
 
 bool Chainstate::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 Chainstate::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().
     // This time can also be used for consensus upgrades.
     const int64_t nMedianTimePast{active_chain_tip->GetMedianTimePast()};
 
     return ContextualCheckTransaction(params, tx, state, nBlockHeight,
                                       nMedianTimePast);
 }
 
 /**
  * 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 Chainstate::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);
     Chainstate &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,
                        Chainstate &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, nullptr, true)) {
         return false;
     }
 
     assert(state.IsValid());
     return true;
 }
 
 /* This function is called from the RPC code for pruneblockchain */
 void PruneBlockFilesManual(Chainstate &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 Chainstate::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 Chainstate::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(Chainstate &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 Chainstate::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 Chainstate::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{*Assert(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 Chainstate::UnloadBlockIndex() {
     AssertLockHeld(::cs_main);
     nBlockSequenceId = 1;
     m_best_fork_tip = nullptr;
     m_best_fork_base = nullptr;
     setBlockIndexCandidates.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 (Chainstate *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 Chainstate::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 Chainstate::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 Chainstate::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 Chainstate::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 Chainstate::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,
                  Chainstate &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<Chainstate *> ChainstateManager::GetAll() {
     LOCK(::cs_main);
     std::vector<Chainstate *> 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;
 }
 
 Chainstate &ChainstateManager::InitializeChainstate(
     CTxMemPool *mempool, const std::optional<BlockHash> &snapshot_blockhash) {
     AssertLockHeld(::cs_main);
     bool is_snapshot = snapshot_blockhash.has_value();
     std::unique_ptr<Chainstate> &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 Chainstate(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<Chainstate>(
                                  /* 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(
     Chainstate &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 Chainstate 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;
 }
 
 Chainstate &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::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/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
index 7594aba16..f7f830e94 100644
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -1,4990 +1,4974 @@
 // 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 <chainparams.h> // for GetConsensus.
 #include <coins.h>
 #include <config.h>
 #include <consensus/amount.h>
 #include <consensus/validation.h>
 #include <core_io.h>
 #include <interfaces/chain.h>
 #include <key_io.h>
 #include <node/context.h>
 #include <outputtype.h>
 #include <policy/fees.h>
 #include <policy/policy.h>
 #include <rpc/rawtransaction_util.h>
 #include <rpc/server.h>
 #include <rpc/util.h>
 #include <script/descriptor.h>
 #include <util/bip32.h>
 #include <util/error.h>
 #include <util/moneystr.h>
 #include <util/string.h>
 #include <util/system.h>
 #include <util/translation.h>
 #include <util/url.h>
 #include <util/vector.h>
 #include <wallet/coincontrol.h>
 #include <wallet/context.h>
 #include <wallet/load.h>
 #include <wallet/receive.h>
 #include <wallet/rpc/util.h>
 #include <wallet/rpcwallet.h>
 #include <wallet/spend.h>
 #include <wallet/wallet.h>
 #include <wallet/walletdb.h>
 #include <wallet/walletutil.h>
 
 #include <univalue.h>
 
 #include <event2/http.h>
 
 #include <optional>
 
 using interfaces::FoundBlock;
 
 /**
  * Checks if a CKey is in the given CWallet compressed or otherwise
  */
 bool HaveKey(const SigningProvider &wallet, const CKey &key) {
     CKey key2;
     key2.Set(key.begin(), key.end(), !key.IsCompressed());
     return wallet.HaveKey(key.GetPubKey().GetID()) ||
            wallet.HaveKey(key2.GetPubKey().GetID());
 }
 
 static void WalletTxToJSON(const CWallet &wallet, const CWalletTx &wtx,
                            UniValue &entry)
     EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet) {
     interfaces::Chain &chain = wallet.chain();
     int confirms = wallet.GetTxDepthInMainChain(wtx);
     entry.pushKV("confirmations", confirms);
     if (wtx.IsCoinBase()) {
         entry.pushKV("generated", true);
     }
     if (confirms > 0) {
         entry.pushKV("blockhash", wtx.m_confirm.hashBlock.GetHex());
         entry.pushKV("blockheight", wtx.m_confirm.block_height);
         entry.pushKV("blockindex", wtx.m_confirm.nIndex);
         int64_t block_time;
         CHECK_NONFATAL(chain.findBlock(wtx.m_confirm.hashBlock,
                                        FoundBlock().time(block_time)));
         entry.pushKV("blocktime", block_time);
     } else {
         entry.pushKV("trusted", CachedTxIsTrusted(wallet, wtx));
     }
     uint256 hash = wtx.GetId();
     entry.pushKV("txid", hash.GetHex());
     UniValue conflicts(UniValue::VARR);
     for (const uint256 &conflict : wallet.GetTxConflicts(wtx)) {
         conflicts.push_back(conflict.GetHex());
     }
     entry.pushKV("walletconflicts", conflicts);
     entry.pushKV("time", wtx.GetTxTime());
     entry.pushKV("timereceived", (int64_t)wtx.nTimeReceived);
 
     for (const std::pair<const std::string, std::string> &item : wtx.mapValue) {
         entry.pushKV(item.first, item.second);
     }
 }
 
 static RPCHelpMan getnewaddress() {
     return RPCHelpMan{
         "getnewaddress",
         "Returns a new Bitcoin address for receiving payments.\n"
         "If 'label' is specified, it is added to the address book \n"
         "so payments received with the address will be associated with "
         "'label'.\n",
         {
             {"label", RPCArg::Type::STR, /* default */ "null",
              "The label name for the address to be linked to. If not provided, "
              "the default label \"\" is used. It can also be set to the empty "
              "string \"\" to represent the default label. The label does not "
              "need to exist, it will be created if there is no label by the "
              "given name."},
             {"address_type", RPCArg::Type::STR,
              /* default */ "set by -addresstype",
              "The address type to use. Options are \"legacy\"."},
         },
         RPCResult{RPCResult::Type::STR, "address", "The new bitcoin address"},
         RPCExamples{HelpExampleCli("getnewaddress", "") +
                     HelpExampleRpc("getnewaddress", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             LOCK(pwallet->cs_wallet);
 
             if (!pwallet->CanGetAddresses()) {
                 throw JSONRPCError(RPC_WALLET_ERROR,
                                    "Error: This wallet has no available keys");
             }
 
             // Parse the label first so we don't generate a key if there's an
             // error
             std::string label;
             if (!request.params[0].isNull()) {
                 label = LabelFromValue(request.params[0]);
             }
 
             OutputType output_type = pwallet->m_default_address_type;
             if (!request.params[1].isNull()) {
                 if (!ParseOutputType(request.params[1].get_str(),
                                      output_type)) {
                     throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                        strprintf("Unknown address type '%s'",
                                                  request.params[1].get_str()));
                 }
             }
 
             CTxDestination dest;
             std::string error;
             if (!pwallet->GetNewDestination(output_type, label, dest, error)) {
                 throw JSONRPCError(RPC_WALLET_KEYPOOL_RAN_OUT, error);
             }
 
             return EncodeDestination(dest, config);
         },
     };
 }
 
 static RPCHelpMan getrawchangeaddress() {
     return RPCHelpMan{
         "getrawchangeaddress",
         "Returns a new Bitcoin address, for receiving change.\n"
         "This is for use with raw transactions, NOT normal use.\n",
         {},
         RPCResult{RPCResult::Type::STR, "address", "The address"},
         RPCExamples{HelpExampleCli("getrawchangeaddress", "") +
                     HelpExampleRpc("getrawchangeaddress", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             LOCK(pwallet->cs_wallet);
 
             if (!pwallet->CanGetAddresses(true)) {
                 throw JSONRPCError(RPC_WALLET_ERROR,
                                    "Error: This wallet has no available keys");
             }
 
             OutputType output_type = pwallet->m_default_change_type.value_or(
                 pwallet->m_default_address_type);
             if (!request.params[0].isNull()) {
                 if (!ParseOutputType(request.params[0].get_str(),
                                      output_type)) {
                     throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                        strprintf("Unknown address type '%s'",
                                                  request.params[0].get_str()));
                 }
             }
 
             CTxDestination dest;
             std::string error;
             if (!pwallet->GetNewChangeDestination(output_type, dest, error)) {
                 throw JSONRPCError(RPC_WALLET_KEYPOOL_RAN_OUT, error);
             }
             return EncodeDestination(dest, config);
         },
     };
 }
 
 static RPCHelpMan setlabel() {
     return RPCHelpMan{
         "setlabel",
         "Sets the label associated with the given address.\n",
         {
             {"address", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The bitcoin address to be associated with a label."},
             {"label", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The label to assign to the address."},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{
             HelpExampleCli("setlabel",
                            "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\" \"tabby\"") +
             HelpExampleRpc(
                 "setlabel",
                 "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\", \"tabby\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             LOCK(pwallet->cs_wallet);
 
             CTxDestination dest = DecodeDestination(request.params[0].get_str(),
                                                     wallet->GetChainParams());
             if (!IsValidDestination(dest)) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                    "Invalid Bitcoin address");
             }
 
             std::string label = LabelFromValue(request.params[1]);
 
             if (pwallet->IsMine(dest)) {
                 pwallet->SetAddressBook(dest, label, "receive");
             } else {
                 pwallet->SetAddressBook(dest, label, "send");
             }
 
             return NullUniValue;
         },
     };
 }
 
 void ParseRecipients(const UniValue &address_amounts,
                      const UniValue &subtract_fee_outputs,
                      std::vector<CRecipient> &recipients,
                      const CChainParams &chainParams) {
     std::set<CTxDestination> destinations;
     int i = 0;
     for (const std::string &address : address_amounts.getKeys()) {
         CTxDestination dest = DecodeDestination(address, chainParams);
         if (!IsValidDestination(dest)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                std::string("Invalid Bitcoin address: ") +
                                    address);
         }
 
         if (destinations.count(dest)) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 std::string("Invalid parameter, duplicated address: ") +
                     address);
         }
         destinations.insert(dest);
 
         CScript script_pub_key = GetScriptForDestination(dest);
         Amount amount = AmountFromValue(address_amounts[i++]);
 
         bool subtract_fee = false;
         for (unsigned int idx = 0; idx < subtract_fee_outputs.size(); idx++) {
             const UniValue &addr = subtract_fee_outputs[idx];
             if (addr.get_str() == address) {
                 subtract_fee = true;
             }
         }
 
         CRecipient recipient = {script_pub_key, amount, subtract_fee};
         recipients.push_back(recipient);
     }
 }
 
 UniValue SendMoney(CWallet *const pwallet, const CCoinControl &coin_control,
                    std::vector<CRecipient> &recipients, mapValue_t map_value,
                    bool broadcast = true) {
     EnsureWalletIsUnlocked(pwallet);
 
     // Shuffle recipient list
     std::shuffle(recipients.begin(), recipients.end(), FastRandomContext());
 
     // Send
     Amount nFeeRequired = Amount::zero();
     int nChangePosRet = -1;
     bilingual_str error;
     CTransactionRef tx;
     bool fCreated = CreateTransaction(
         *pwallet, recipients, tx, nFeeRequired, nChangePosRet, error,
         coin_control,
         !pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS));
     if (!fCreated) {
         throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS, error.original);
     }
     pwallet->CommitTransaction(tx, std::move(map_value), {} /* orderForm */,
                                broadcast);
     return tx->GetId().GetHex();
 }
 
 static RPCHelpMan sendtoaddress() {
     return RPCHelpMan{
         "sendtoaddress",
         "Send an amount to a given address.\n" + HELP_REQUIRING_PASSPHRASE,
         {
             {"address", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The bitcoin address to send to."},
             {"amount", RPCArg::Type::AMOUNT, RPCArg::Optional::NO,
              "The amount in " + Currency::get().ticker + " to send. eg 0.1"},
             {"comment", RPCArg::Type::STR, RPCArg::Optional::OMITTED_NAMED_ARG,
              "A comment used to store what the transaction is for.\n"
              "                             This is not part of the "
              "transaction, just kept in your wallet."},
             {"comment_to", RPCArg::Type::STR,
              RPCArg::Optional::OMITTED_NAMED_ARG,
              "A comment to store the name of the person or organization\n"
              "                             to which you're sending the "
              "transaction. This is not part of the \n"
              "                             transaction, just kept in "
              "your wallet."},
             {"subtractfeefromamount", RPCArg::Type::BOOL,
              /* default */ "false",
              "The fee will be deducted from the amount being sent.\n"
              "                             The recipient will receive "
              "less bitcoins than you enter in the amount field."},
             {"avoid_reuse", RPCArg::Type::BOOL,
              /* default */ "true",
              "(only available if avoid_reuse wallet flag is set) Avoid "
              "spending from dirty addresses; addresses are considered\n"
              "                             dirty if they have previously "
              "been used in a transaction."},
         },
         RPCResult{RPCResult::Type::STR_HEX, "txid", "The transaction id."},
         RPCExamples{
             HelpExampleCli("sendtoaddress",
                            "\"1M72Sfpbz1BPpXFHz9m3CdqATR44Jvaydd\" 100000") +
             HelpExampleCli("sendtoaddress", "\"1M72Sfpbz1BPpXFHz9m3CdqATR44Jvay"
                                             "dd\" 100000 \"donation\" \"seans "
                                             "outpost\"") +
             HelpExampleCli("sendtoaddress", "\"1M72Sfpbz1BPpXFHz9m3CdqATR44"
                                             "Jvaydd\" 100000 \"\" \"\" true") +
             HelpExampleRpc("sendtoaddress",
                            "\"1M72Sfpbz1BPpXFHz9m3CdqATR44Jvay"
                            "dd\", 100000, \"donation\", \"seans "
                            "outpost\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             // Make sure the results are valid at least up to the most recent
             // block the user could have gotten from another RPC command prior
             // to now
             pwallet->BlockUntilSyncedToCurrentChain();
 
             LOCK(pwallet->cs_wallet);
 
             // Wallet comments
             mapValue_t mapValue;
             if (!request.params[2].isNull() &&
                 !request.params[2].get_str().empty()) {
                 mapValue["comment"] = request.params[2].get_str();
             }
             if (!request.params[3].isNull() &&
                 !request.params[3].get_str().empty()) {
                 mapValue["to"] = request.params[3].get_str();
             }
 
             bool fSubtractFeeFromAmount = false;
             if (!request.params[4].isNull()) {
                 fSubtractFeeFromAmount = request.params[4].get_bool();
             }
 
             CCoinControl coin_control;
             coin_control.m_avoid_address_reuse =
                 GetAvoidReuseFlag(pwallet, request.params[5]);
             // We also enable partial spend avoidance if reuse avoidance is set.
             coin_control.m_avoid_partial_spends |=
                 coin_control.m_avoid_address_reuse;
 
             EnsureWalletIsUnlocked(pwallet);
 
             UniValue address_amounts(UniValue::VOBJ);
             const std::string address = request.params[0].get_str();
             address_amounts.pushKV(address, request.params[1]);
             UniValue subtractFeeFromAmount(UniValue::VARR);
             if (fSubtractFeeFromAmount) {
                 subtractFeeFromAmount.push_back(address);
             }
 
             std::vector<CRecipient> recipients;
             ParseRecipients(address_amounts, subtractFeeFromAmount, recipients,
                             wallet->GetChainParams());
 
             return SendMoney(pwallet, coin_control, recipients, mapValue);
         },
     };
 }
 
 static RPCHelpMan listaddressgroupings() {
     return RPCHelpMan{
         "listaddressgroupings",
         "Lists groups of addresses which have had their common ownership\n"
         "made public by common use as inputs or as the resulting change\n"
         "in past transactions\n",
         {},
         RPCResult{RPCResult::Type::ARR,
                   "",
                   "",
                   {
                       {RPCResult::Type::ARR,
                        "",
                        "",
                        {
                            {RPCResult::Type::ARR,
                             "",
                             "",
                             {
                                 {RPCResult::Type::STR, "address",
                                  "The bitcoin address"},
                                 {RPCResult::Type::STR_AMOUNT, "amount",
                                  "The amount in " + Currency::get().ticker},
                                 {RPCResult::Type::STR, "label",
                                  /* optional */ true, "The label"},
                             }},
                        }},
                   }},
         RPCExamples{HelpExampleCli("listaddressgroupings", "") +
                     HelpExampleRpc("listaddressgroupings", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             const CWallet *const pwallet = wallet.get();
 
             // Make sure the results are valid at least up to the most recent
             // block the user could have gotten from another RPC command prior
             // to now
             pwallet->BlockUntilSyncedToCurrentChain();
 
             LOCK(pwallet->cs_wallet);
 
             UniValue jsonGroupings(UniValue::VARR);
             std::map<CTxDestination, Amount> balances =
                 GetAddressBalances(*pwallet);
             for (const std::set<CTxDestination> &grouping :
                  GetAddressGroupings(*pwallet)) {
                 UniValue jsonGrouping(UniValue::VARR);
                 for (const CTxDestination &address : grouping) {
                     UniValue addressInfo(UniValue::VARR);
                     addressInfo.push_back(EncodeDestination(address, config));
                     addressInfo.push_back(balances[address]);
 
                     const auto *address_book_entry =
                         pwallet->FindAddressBookEntry(address);
                     if (address_book_entry) {
                         addressInfo.push_back(address_book_entry->GetLabel());
                     }
                     jsonGrouping.push_back(addressInfo);
                 }
                 jsonGroupings.push_back(jsonGrouping);
             }
 
             return jsonGroupings;
         },
     };
 }
 
 static Amount GetReceived(const CWallet &wallet, const UniValue &params,
                           bool by_label)
     EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet) {
     std::set<CTxDestination> address_set;
 
     if (by_label) {
         // Get the set of addresses assigned to label
         std::string label = LabelFromValue(params[0]);
         address_set = wallet.GetLabelAddresses(label);
     } else {
         // Get the address
         CTxDestination dest =
             DecodeDestination(params[0].get_str(), wallet.GetChainParams());
         if (!IsValidDestination(dest)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Invalid Bitcoin address");
         }
         CScript script_pub_key = GetScriptForDestination(dest);
         if (!wallet.IsMine(script_pub_key)) {
             throw JSONRPCError(RPC_WALLET_ERROR, "Address not found in wallet");
         }
         address_set.insert(dest);
     }
 
     // Minimum confirmations
     int min_depth = 1;
     if (!params[1].isNull()) {
         min_depth = params[1].get_int();
     }
 
     // Tally
     Amount amount = Amount::zero();
     for (const std::pair<const TxId, CWalletTx> &wtx_pair : wallet.mapWallet) {
         const CWalletTx &wtx = wtx_pair.second;
         if (wtx.IsCoinBase() || wallet.GetTxDepthInMainChain(wtx) < min_depth) {
             continue;
         }
 
         for (const CTxOut &txout : wtx.tx->vout) {
             CTxDestination address;
             if (ExtractDestination(txout.scriptPubKey, address) &&
                 wallet.IsMine(address) && address_set.count(address)) {
                 amount += txout.nValue;
             }
         }
     }
 
     return amount;
 }
 
 static RPCHelpMan getreceivedbyaddress() {
     return RPCHelpMan{
         "getreceivedbyaddress",
         "Returns the total amount received by the given address in "
         "transactions with at least minconf confirmations.\n",
         {
             {"address", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The bitcoin address for transactions."},
             {"minconf", RPCArg::Type::NUM, /* default */ "1",
              "Only include transactions confirmed at least this many times."},
         },
         RPCResult{RPCResult::Type::STR_AMOUNT, "amount",
                   "The total amount in " + Currency::get().ticker +
                       " received at this address."},
         RPCExamples{
             "\nThe amount from transactions with at least 1 confirmation\n" +
             HelpExampleCli("getreceivedbyaddress",
                            "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\"") +
             "\nThe amount including unconfirmed transactions, zero "
             "confirmations\n" +
             HelpExampleCli("getreceivedbyaddress",
                            "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\" 0") +
             "\nThe amount with at least 6 confirmations\n" +
             HelpExampleCli("getreceivedbyaddress",
                            "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\" 6") +
             "\nAs a JSON-RPC call\n" +
             HelpExampleRpc("getreceivedbyaddress",
                            "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\", 6")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             const CWallet *const pwallet = wallet.get();
 
             // Make sure the results are valid at least up to the most recent
             // block the user could have gotten from another RPC command prior
             // to now
             pwallet->BlockUntilSyncedToCurrentChain();
 
             LOCK(pwallet->cs_wallet);
 
             return GetReceived(*pwallet, request.params,
                                /* by_label */ false);
         },
     };
 }
 
 static RPCHelpMan getreceivedbylabel() {
     return RPCHelpMan{
         "getreceivedbylabel",
         "Returns the total amount received by addresses with <label> in "
         "transactions with at least [minconf] confirmations.\n",
         {
             {"label", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The selected label, may be the default label using \"\"."},
             {"minconf", RPCArg::Type::NUM, /* default */ "1",
              "Only include transactions confirmed at least this many times."},
         },
         RPCResult{RPCResult::Type::STR_AMOUNT, "amount",
                   "The total amount in " + Currency::get().ticker +
                       " received for this label."},
         RPCExamples{"\nAmount received by the default label with at least 1 "
                     "confirmation\n" +
                     HelpExampleCli("getreceivedbylabel", "\"\"") +
                     "\nAmount received at the tabby label including "
                     "unconfirmed amounts with zero confirmations\n" +
                     HelpExampleCli("getreceivedbylabel", "\"tabby\" 0") +
                     "\nThe amount with at least 6 confirmations\n" +
                     HelpExampleCli("getreceivedbylabel", "\"tabby\" 6") +
                     "\nAs a JSON-RPC call\n" +
                     HelpExampleRpc("getreceivedbylabel", "\"tabby\", 6")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             // Make sure the results are valid at least up to the most recent
             // block the user could have gotten from another RPC command prior
             // to now
             pwallet->BlockUntilSyncedToCurrentChain();
 
             LOCK(pwallet->cs_wallet);
 
             return GetReceived(*pwallet, request.params,
                                /* by_label */ true);
         },
     };
 }
 
 static RPCHelpMan getbalance() {
     return RPCHelpMan{
         "getbalance",
         "Returns the total available balance.\n"
         "The available balance is what the wallet considers currently "
         "spendable, and is\n"
         "thus affected by options which limit spendability such as "
         "-spendzeroconfchange.\n",
         {
             {"dummy", RPCArg::Type::STR, RPCArg::Optional::OMITTED_NAMED_ARG,
              "Remains for backward compatibility. Must be excluded or set to "
              "\"*\"."},
             {"minconf", RPCArg::Type::NUM, /* default */ "0",
              "Only include transactions confirmed at least this many times."},
             {"include_watchonly", RPCArg::Type::BOOL,
              /* default */ "true for watch-only wallets, otherwise false",
              "Also include balance in watch-only addresses (see "
              "'importaddress')"},
             {"avoid_reuse", RPCArg::Type::BOOL,
              /* default */ "true",
              "(only available if avoid_reuse wallet flag is set) Do not "
              "include balance in dirty outputs; addresses are considered dirty "
              "if they have previously been used in a transaction."},
         },
         RPCResult{RPCResult::Type::STR_AMOUNT, "amount",
                   "The total amount in " + Currency::get().ticker +
                       " received for this wallet."},
         RPCExamples{
             "\nThe total amount in the wallet with 0 or more confirmations\n" +
             HelpExampleCli("getbalance", "") +
             "\nThe total amount in the wallet with at least 6 confirmations\n" +
             HelpExampleCli("getbalance", "\"*\" 6") + "\nAs a JSON-RPC call\n" +
             HelpExampleRpc("getbalance", "\"*\", 6")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             const CWallet *const pwallet = wallet.get();
 
             // Make sure the results are valid at least up to the most recent
             // block the user could have gotten from another RPC command prior
             // to now
             pwallet->BlockUntilSyncedToCurrentChain();
 
             LOCK(pwallet->cs_wallet);
 
             const UniValue &dummy_value = request.params[0];
             if (!dummy_value.isNull() && dummy_value.get_str() != "*") {
                 throw JSONRPCError(
                     RPC_METHOD_DEPRECATED,
                     "dummy first argument must be excluded or set to \"*\".");
             }
 
             int min_depth = 0;
             if (!request.params[1].isNull()) {
                 min_depth = request.params[1].get_int();
             }
 
             bool include_watchonly =
                 ParseIncludeWatchonly(request.params[2], *pwallet);
 
             bool avoid_reuse = GetAvoidReuseFlag(pwallet, request.params[3]);
 
             const auto bal = GetBalance(*pwallet, min_depth, avoid_reuse);
 
             return bal.m_mine_trusted + (include_watchonly
                                              ? bal.m_watchonly_trusted
                                              : Amount::zero());
         },
     };
 }
 
 static RPCHelpMan getunconfirmedbalance() {
     return RPCHelpMan{
         "getunconfirmedbalance",
         "DEPRECATED\nIdentical to getbalances().mine.untrusted_pending\n",
         {},
         RPCResult{RPCResult::Type::NUM, "", "The balance"},
         RPCExamples{""},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             const CWallet *const pwallet = wallet.get();
 
             // Make sure the results are valid at least up to the most recent
             // block the user could have gotten from another RPC command prior
             // to now
             pwallet->BlockUntilSyncedToCurrentChain();
 
             LOCK(pwallet->cs_wallet);
 
             return GetBalance(*pwallet).m_mine_untrusted_pending;
         },
     };
 }
 
 static RPCHelpMan sendmany() {
     return RPCHelpMan{
         "sendmany",
         "Send multiple times. Amounts are double-precision "
         "floating point numbers." +
             HELP_REQUIRING_PASSPHRASE,
         {
             {"dummy", RPCArg::Type::STR, RPCArg::Optional::NO,
              "Must be set to \"\" for backwards compatibility.", "\"\""},
             {
                 "amounts",
                 RPCArg::Type::OBJ,
                 RPCArg::Optional::NO,
                 "The addresses and amounts",
                 {
                     {"address", RPCArg::Type::AMOUNT, RPCArg::Optional::NO,
                      "The bitcoin address is the key, the numeric amount (can "
                      "be string) in " +
                          Currency::get().ticker + " is the value"},
                 },
             },
             {"minconf", RPCArg::Type::NUM, /* default */ "1",
              "Only use the balance confirmed at least this many times."},
             {"comment", RPCArg::Type::STR, RPCArg::Optional::OMITTED_NAMED_ARG,
              "A comment"},
             {
                 "subtractfeefrom",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::OMITTED_NAMED_ARG,
                 "The addresses.\n"
                 "                           The fee will be equally deducted "
                 "from the amount of each selected address.\n"
                 "                           Those recipients will receive less "
                 "bitcoins than you enter in their corresponding amount field.\n"
                 "                           If no addresses are specified "
                 "here, the sender pays the fee.",
                 {
                     {"address", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
                      "Subtract fee from this address"},
                 },
             },
         },
         RPCResult{RPCResult::Type::STR_HEX, "txid",
                   "The transaction id for the send. Only 1 transaction is "
                   "created regardless of the number of addresses."},
         RPCExamples{
             "\nSend two amounts to two different addresses:\n" +
             HelpExampleCli(
                 "sendmany",
                 "\"\" "
                 "\"{\\\"bchtest:qplljx455cznj2yrtdhj0jcm7syxlzqnaqt0ku5kjl\\\":"
                 "0.01,"
                 "\\\"bchtest:qzmnuh8t24yrxq4mvjakt84r7j3f9tunlvm2p7qef9\\\":0."
                 "02}\"") +
             "\nSend two amounts to two different addresses setting the "
             "confirmation and comment:\n" +
             HelpExampleCli(
                 "sendmany",
                 "\"\" "
                 "\"{\\\"bchtest:qplljx455cznj2yrtdhj0jcm7syxlzqnaqt0ku5kjl\\\":"
                 "0.01,"
                 "\\\"bchtest:qzmnuh8t24yrxq4mvjakt84r7j3f9tunlvm2p7qef9\\\":0."
                 "02}\" "
                 "6 \"testing\"") +
             "\nSend two amounts to two different addresses, subtract fee "
             "from amount:\n" +
             HelpExampleCli(
                 "sendmany",
                 "\"\" "
                 "\"{\\\"bchtest:qplljx455cznj2yrtdhj0jcm7syxlzqnaqt0ku5kjl\\\":"
                 "0.01,"
                 "\\\"bchtest:qzmnuh8t24yrxq4mvjakt84r7j3f9tunlvm2p7qef9\\\":0."
                 "02}\" 1 \"\" "
                 "\"[\\\"bchtest:qplljx455cznj2yrtdhj0jcm7syxlzqnaqt0ku5kjl\\\","
                 "\\\"bchtest:qzmnuh8t24yrxq4mvjakt84r7j3f9tunlvm2p7qef9\\\"]"
                 "\"") +
             "\nAs a JSON-RPC call\n" +
             HelpExampleRpc(
                 "sendmany",
                 "\"\", "
                 "{\"bchtest:qplljx455cznj2yrtdhj0jcm7syxlzqnaqt0ku5kjl\":0.01,"
                 "\"bchtest:qzmnuh8t24yrxq4mvjakt84r7j3f9tunlvm2p7qef9\":0.02}, "
                 "6, "
                 "\"testing\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             // Make sure the results are valid at least up to the most recent
             // block the user could have gotten from another RPC command prior
             // to now
             pwallet->BlockUntilSyncedToCurrentChain();
 
             LOCK(pwallet->cs_wallet);
 
             if (!request.params[0].isNull() &&
                 !request.params[0].get_str().empty()) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    "Dummy value must be set to \"\"");
             }
             UniValue sendTo = request.params[1].get_obj();
 
             mapValue_t mapValue;
             if (!request.params[3].isNull() &&
                 !request.params[3].get_str().empty()) {
                 mapValue["comment"] = request.params[3].get_str();
             }
 
             UniValue subtractFeeFromAmount(UniValue::VARR);
             if (!request.params[4].isNull()) {
                 subtractFeeFromAmount = request.params[4].get_array();
             }
 
             std::vector<CRecipient> recipients;
             ParseRecipients(sendTo, subtractFeeFromAmount, recipients,
                             wallet->GetChainParams());
 
             CCoinControl coin_control;
             return SendMoney(pwallet, coin_control, recipients,
                              std::move(mapValue));
         },
     };
 }
 
 static RPCHelpMan addmultisigaddress() {
     return RPCHelpMan{
         "addmultisigaddress",
         "Add an nrequired-to-sign multisignature address to the wallet. "
         "Requires a new wallet backup.\n"
         "Each key is a Bitcoin address or hex-encoded public key.\n"
         "This functionality is only intended for use with non-watchonly "
         "addresses.\n"
         "See `importaddress` for watchonly p2sh address support.\n"
         "If 'label' is specified (DEPRECATED), assign address to that label.\n",
         {
             {"nrequired", RPCArg::Type::NUM, RPCArg::Optional::NO,
              "The number of required signatures out of the n keys or "
              "addresses."},
             {
                 "keys",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::NO,
                 "The bitcoin addresses or hex-encoded public keys",
                 {
                     {"key", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
                      "bitcoin address or hex-encoded public key"},
                 },
             },
             {"label", RPCArg::Type::STR, RPCArg::Optional::OMITTED_NAMED_ARG,
              "A label to assign the addresses to."},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR, "address",
                        "The value of the new multisig address"},
                       {RPCResult::Type::STR_HEX, "redeemScript",
                        "The string value of the hex-encoded redemption script"},
                       {RPCResult::Type::STR, "descriptor",
                        "The descriptor for this multisig"},
                   }},
         RPCExamples{
             "\nAdd a multisig address from 2 addresses\n" +
             HelpExampleCli("addmultisigaddress",
                            "2 "
                            "\"[\\\"16sSauSf5pF2UkUwvKGq4qjNRzBZYqgEL5\\\","
                            "\\\"171sgjn4YtPu27adkKGrdDwzRTxnRkBfKV\\\"]\"") +
             "\nAs a JSON-RPC call\n" +
             HelpExampleRpc("addmultisigaddress",
                            "2, "
                            "\"[\\\"16sSauSf5pF2UkUwvKGq4qjNRzBZYqgEL5\\\","
                            "\\\"171sgjn4YtPu27adkKGrdDwzRTxnRkBfKV\\\"]\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             LegacyScriptPubKeyMan &spk_man =
                 EnsureLegacyScriptPubKeyMan(*pwallet);
 
             LOCK2(pwallet->cs_wallet, spk_man.cs_KeyStore);
 
             std::string label;
             if (!request.params[2].isNull()) {
                 label = LabelFromValue(request.params[2]);
             }
 
             int required = request.params[0].get_int();
 
             // Get the public keys
             const UniValue &keys_or_addrs = request.params[1].get_array();
             std::vector<CPubKey> pubkeys;
             for (size_t i = 0; i < keys_or_addrs.size(); ++i) {
                 if (IsHex(keys_or_addrs[i].get_str()) &&
                     (keys_or_addrs[i].get_str().length() == 66 ||
                      keys_or_addrs[i].get_str().length() == 130)) {
                     pubkeys.push_back(HexToPubKey(keys_or_addrs[i].get_str()));
                 } else {
                     pubkeys.push_back(AddrToPubKey(wallet->GetChainParams(),
                                                    spk_man,
                                                    keys_or_addrs[i].get_str()));
                 }
             }
 
             OutputType output_type = pwallet->m_default_address_type;
 
             // Construct using pay-to-script-hash:
             CScript inner;
             CTxDestination dest = AddAndGetMultisigDestination(
                 required, pubkeys, output_type, spk_man, inner);
             pwallet->SetAddressBook(dest, label, "send");
 
             // Make the descriptor
             std::unique_ptr<Descriptor> descriptor =
                 InferDescriptor(GetScriptForDestination(dest), spk_man);
 
             UniValue result(UniValue::VOBJ);
             result.pushKV("address", EncodeDestination(dest, config));
             result.pushKV("redeemScript", HexStr(inner));
             result.pushKV("descriptor", descriptor->ToString());
             return result;
         },
     };
 }
 
 struct tallyitem {
     Amount nAmount{Amount::zero()};
     int nConf{std::numeric_limits<int>::max()};
     std::vector<uint256> txids;
     bool fIsWatchonly{false};
     tallyitem() {}
 };
 
 static UniValue ListReceived(const Config &config, const CWallet *const pwallet,
                              const UniValue &params, bool by_label)
     EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
     // Minimum confirmations
     int nMinDepth = 1;
     if (!params[0].isNull()) {
         nMinDepth = params[0].get_int();
     }
 
     // Whether to include empty labels
     bool fIncludeEmpty = false;
     if (!params[1].isNull()) {
         fIncludeEmpty = params[1].get_bool();
     }
 
     isminefilter filter = ISMINE_SPENDABLE;
     if (ParseIncludeWatchonly(params[2], *pwallet)) {
         filter |= ISMINE_WATCH_ONLY;
     }
 
     bool has_filtered_address = false;
     CTxDestination filtered_address = CNoDestination();
     if (!by_label && params.size() > 3) {
         if (!IsValidDestinationString(params[3].get_str(),
                                       pwallet->GetChainParams())) {
             throw JSONRPCError(RPC_WALLET_ERROR,
                                "address_filter parameter was invalid");
         }
         filtered_address =
             DecodeDestination(params[3].get_str(), pwallet->GetChainParams());
         has_filtered_address = true;
     }
 
     // Tally
     std::map<CTxDestination, tallyitem> mapTally;
     for (const std::pair<const TxId, CWalletTx> &pairWtx : pwallet->mapWallet) {
         const CWalletTx &wtx = pairWtx.second;
 
         if (wtx.IsCoinBase()) {
             continue;
         }
 
         int nDepth = pwallet->GetTxDepthInMainChain(wtx);
         if (nDepth < nMinDepth) {
             continue;
         }
 
         for (const CTxOut &txout : wtx.tx->vout) {
             CTxDestination address;
             if (!ExtractDestination(txout.scriptPubKey, address)) {
                 continue;
             }
 
             if (has_filtered_address && !(filtered_address == address)) {
                 continue;
             }
 
             isminefilter mine = pwallet->IsMine(address);
             if (!(mine & filter)) {
                 continue;
             }
 
             tallyitem &item = mapTally[address];
             item.nAmount += txout.nValue;
             item.nConf = std::min(item.nConf, nDepth);
             item.txids.push_back(wtx.GetId());
             if (mine & ISMINE_WATCH_ONLY) {
                 item.fIsWatchonly = true;
             }
         }
     }
 
     // Reply
     UniValue ret(UniValue::VARR);
     std::map<std::string, tallyitem> label_tally;
 
     // Create m_address_book iterator
     // If we aren't filtering, go from begin() to end()
     auto start = pwallet->m_address_book.begin();
     auto end = pwallet->m_address_book.end();
     // If we are filtering, find() the applicable entry
     if (has_filtered_address) {
         start = pwallet->m_address_book.find(filtered_address);
         if (start != end) {
             end = std::next(start);
         }
     }
 
     for (auto item_it = start; item_it != end; ++item_it) {
         if (item_it->second.IsChange()) {
             continue;
         }
         const CTxDestination &address = item_it->first;
         const std::string &label = item_it->second.GetLabel();
         std::map<CTxDestination, tallyitem>::iterator it =
             mapTally.find(address);
         if (it == mapTally.end() && !fIncludeEmpty) {
             continue;
         }
 
         Amount nAmount = Amount::zero();
         int nConf = std::numeric_limits<int>::max();
         bool fIsWatchonly = false;
         if (it != mapTally.end()) {
             nAmount = (*it).second.nAmount;
             nConf = (*it).second.nConf;
             fIsWatchonly = (*it).second.fIsWatchonly;
         }
 
         if (by_label) {
             tallyitem &_item = label_tally[label];
             _item.nAmount += nAmount;
             _item.nConf = std::min(_item.nConf, nConf);
             _item.fIsWatchonly = fIsWatchonly;
         } else {
             UniValue obj(UniValue::VOBJ);
             if (fIsWatchonly) {
                 obj.pushKV("involvesWatchonly", true);
             }
             obj.pushKV("address", EncodeDestination(address, config));
             obj.pushKV("amount", nAmount);
             obj.pushKV("confirmations",
                        (nConf == std::numeric_limits<int>::max() ? 0 : nConf));
             obj.pushKV("label", label);
             UniValue transactions(UniValue::VARR);
             if (it != mapTally.end()) {
                 for (const uint256 &_item : (*it).second.txids) {
                     transactions.push_back(_item.GetHex());
                 }
             }
             obj.pushKV("txids", transactions);
             ret.push_back(obj);
         }
     }
 
     if (by_label) {
         for (const auto &entry : label_tally) {
             Amount nAmount = entry.second.nAmount;
             int nConf = entry.second.nConf;
             UniValue obj(UniValue::VOBJ);
             if (entry.second.fIsWatchonly) {
                 obj.pushKV("involvesWatchonly", true);
             }
             obj.pushKV("amount", nAmount);
             obj.pushKV("confirmations",
                        (nConf == std::numeric_limits<int>::max() ? 0 : nConf));
             obj.pushKV("label", entry.first);
             ret.push_back(obj);
         }
     }
 
     return ret;
 }
 
 static RPCHelpMan listreceivedbyaddress() {
     return RPCHelpMan{
         "listreceivedbyaddress",
         "List balances by receiving address.\n",
         {
             {"minconf", RPCArg::Type::NUM, /* default */ "1",
              "The minimum number of confirmations before payments are "
              "included."},
             {"include_empty", RPCArg::Type::BOOL, /* default */ "false",
              "Whether to include addresses that haven't received any "
              "payments."},
             {"include_watchonly", RPCArg::Type::BOOL,
              /* default */ "true for watch-only wallets, otherwise false",
              "Whether to include watch-only addresses (see 'importaddress')."},
             {"address_filter", RPCArg::Type::STR,
              RPCArg::Optional::OMITTED_NAMED_ARG,
              "If present, only return information on this address."},
         },
         RPCResult{
             RPCResult::Type::ARR,
             "",
             "",
             {
                 {RPCResult::Type::OBJ,
                  "",
                  "",
                  {
                      {RPCResult::Type::BOOL, "involvesWatchonly",
                       "Only returns true if imported addresses were involved "
                       "in transaction"},
                      {RPCResult::Type::STR, "address", "The receiving address"},
                      {RPCResult::Type::STR_AMOUNT, "amount",
                       "The total amount in " + Currency::get().ticker +
                           " received by the address"},
                      {RPCResult::Type::NUM, "confirmations",
                       "The number of confirmations of the most recent "
                       "transaction included"},
                      {RPCResult::Type::STR, "label",
                       "The label of the receiving address. The default label "
                       "is \"\""},
                      {RPCResult::Type::ARR,
                       "txids",
                       "",
                       {
                           {RPCResult::Type::STR_HEX, "txid",
                            "The ids of transactions received with the address"},
                       }},
                  }},
             }},
         RPCExamples{
             HelpExampleCli("listreceivedbyaddress", "") +
             HelpExampleCli("listreceivedbyaddress", "6 true") +
             HelpExampleRpc("listreceivedbyaddress", "6, true, true") +
             HelpExampleRpc(
                 "listreceivedbyaddress",
                 "6, true, true, \"1M72Sfpbz1BPpXFHz9m3CdqATR44Jvaydd\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             const CWallet *const pwallet = wallet.get();
 
             // Make sure the results are valid at least up to the most recent
             // block the user could have gotten from another RPC command prior
             // to now
             pwallet->BlockUntilSyncedToCurrentChain();
 
             LOCK(pwallet->cs_wallet);
 
             return ListReceived(config, pwallet, request.params, false);
         },
     };
 }
 
 static RPCHelpMan listreceivedbylabel() {
     return RPCHelpMan{
         "listreceivedbylabel",
         "List received transactions by label.\n",
         {
             {"minconf", RPCArg::Type::NUM, /* default */ "1",
              "The minimum number of confirmations before payments are "
              "included."},
             {"include_empty", RPCArg::Type::BOOL, /* default */ "false",
              "Whether to include labels that haven't received any payments."},
             {"include_watchonly", RPCArg::Type::BOOL,
              /* default */ "true for watch-only wallets, otherwise false",
              "Whether to include watch-only addresses (see 'importaddress')."},
         },
         RPCResult{
             RPCResult::Type::ARR,
             "",
             "",
             {
                 {RPCResult::Type::OBJ,
                  "",
                  "",
                  {
                      {RPCResult::Type::BOOL, "involvesWatchonly",
                       "Only returns true if imported addresses were involved "
                       "in transaction"},
                      {RPCResult::Type::STR_AMOUNT, "amount",
                       "The total amount received by addresses with this label"},
                      {RPCResult::Type::NUM, "confirmations",
                       "The number of confirmations of the most recent "
                       "transaction included"},
                      {RPCResult::Type::STR, "label",
                       "The label of the receiving address. The default label "
                       "is \"\""},
                  }},
             }},
         RPCExamples{HelpExampleCli("listreceivedbylabel", "") +
                     HelpExampleCli("listreceivedbylabel", "6 true") +
                     HelpExampleRpc("listreceivedbylabel", "6, true, true")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             const CWallet *const pwallet = wallet.get();
 
             // Make sure the results are valid at least up to the most recent
             // block the user could have gotten from another RPC command prior
             // to now
             pwallet->BlockUntilSyncedToCurrentChain();
 
             LOCK(pwallet->cs_wallet);
 
             return ListReceived(config, pwallet, request.params, true);
         },
     };
 }
 
 static void MaybePushAddress(UniValue &entry, const CTxDestination &dest) {
     if (IsValidDestination(dest)) {
         entry.pushKV("address", EncodeDestination(dest, GetConfig()));
     }
 }
 
 /**
  * List transactions based on the given criteria.
  *
  * @param  pwallet        The wallet.
  * @param  wtx            The wallet transaction.
  * @param  nMinDepth      The minimum confirmation depth.
  * @param  fLong          Whether to include the JSON version of the
  * transaction.
  * @param  ret            The UniValue into which the result is stored.
  * @param  filter_ismine  The "is mine" filter flags.
  * @param  filter_label   Optional label string to filter incoming transactions.
  */
 static void ListTransactions(const CWallet *const pwallet, const CWalletTx &wtx,
                              int nMinDepth, bool fLong, UniValue &ret,
                              const isminefilter &filter_ismine,
                              const std::string *filter_label)
     EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
     Amount nFee;
     std::list<COutputEntry> listReceived;
     std::list<COutputEntry> listSent;
 
     CachedTxGetAmounts(*pwallet, wtx, listReceived, listSent, nFee,
                        filter_ismine);
 
     bool involvesWatchonly = CachedTxIsFromMe(*pwallet, wtx, ISMINE_WATCH_ONLY);
 
     // Sent
     if (!filter_label) {
         for (const COutputEntry &s : listSent) {
             UniValue entry(UniValue::VOBJ);
             if (involvesWatchonly ||
                 (pwallet->IsMine(s.destination) & ISMINE_WATCH_ONLY)) {
                 entry.pushKV("involvesWatchonly", true);
             }
             MaybePushAddress(entry, s.destination);
             entry.pushKV("category", "send");
             entry.pushKV("amount", -s.amount);
             const auto *address_book_entry =
                 pwallet->FindAddressBookEntry(s.destination);
             if (address_book_entry) {
                 entry.pushKV("label", address_book_entry->GetLabel());
             }
             entry.pushKV("vout", s.vout);
             entry.pushKV("fee", -1 * nFee);
             if (fLong) {
                 WalletTxToJSON(*pwallet, wtx, entry);
             }
             entry.pushKV("abandoned", wtx.isAbandoned());
             ret.push_back(entry);
         }
     }
 
     // Received
     if (listReceived.size() > 0 &&
         pwallet->GetTxDepthInMainChain(wtx) >= nMinDepth) {
         for (const COutputEntry &r : listReceived) {
             std::string label;
             const auto *address_book_entry =
                 pwallet->FindAddressBookEntry(r.destination);
             if (address_book_entry) {
                 label = address_book_entry->GetLabel();
             }
             if (filter_label && label != *filter_label) {
                 continue;
             }
             UniValue entry(UniValue::VOBJ);
             if (involvesWatchonly ||
                 (pwallet->IsMine(r.destination) & ISMINE_WATCH_ONLY)) {
                 entry.pushKV("involvesWatchonly", true);
             }
             MaybePushAddress(entry, r.destination);
             if (wtx.IsCoinBase()) {
                 if (pwallet->GetTxDepthInMainChain(wtx) < 1) {
                     entry.pushKV("category", "orphan");
                 } else if (pwallet->IsTxImmatureCoinBase(wtx)) {
                     entry.pushKV("category", "immature");
                 } else {
                     entry.pushKV("category", "generate");
                 }
             } else {
                 entry.pushKV("category", "receive");
             }
             entry.pushKV("amount", r.amount);
             if (address_book_entry) {
                 entry.pushKV("label", label);
             }
             entry.pushKV("vout", r.vout);
             if (fLong) {
                 WalletTxToJSON(*pwallet, wtx, entry);
             }
             ret.push_back(entry);
         }
     }
 }
 
 static const std::vector<RPCResult> TransactionDescriptionString() {
     return {
         {RPCResult::Type::NUM, "confirmations",
          "The number of confirmations for the transaction. Negative "
          "confirmations means the\n"
          "transaction conflicted that many blocks ago."},
         {RPCResult::Type::BOOL, "generated",
          "Only present if transaction only input is a coinbase one."},
         {RPCResult::Type::BOOL, "trusted",
          "Only present if we consider transaction to be trusted and so safe to "
          "spend from."},
         {RPCResult::Type::STR_HEX, "blockhash",
          "The block hash containing the transaction."},
         {RPCResult::Type::NUM, "blockheight",
          "The block height containing the transaction."},
         {RPCResult::Type::NUM, "blockindex",
          "The index of the transaction in the block that includes it."},
         {RPCResult::Type::NUM_TIME, "blocktime",
          "The block time expressed in " + UNIX_EPOCH_TIME + "."},
         {RPCResult::Type::STR_HEX, "txid", "The transaction id."},
         {RPCResult::Type::ARR,
          "walletconflicts",
          "Conflicting transaction ids.",
          {
              {RPCResult::Type::STR_HEX, "txid", "The transaction id."},
          }},
         {RPCResult::Type::NUM_TIME, "time",
          "The transaction time expressed in " + UNIX_EPOCH_TIME + "."},
         {RPCResult::Type::NUM_TIME, "timereceived",
          "The time received expressed in " + UNIX_EPOCH_TIME + "."},
         {RPCResult::Type::STR, "comment",
          "If a comment is associated with the transaction, only present if not "
          "empty."},
     };
 }
 
 RPCHelpMan listtransactions() {
     const auto &ticker = Currency::get().ticker;
     return RPCHelpMan{
         "listtransactions",
         "If a label name is provided, this will return only incoming "
         "transactions paying to addresses with the specified label.\n"
         "\nReturns up to 'count' most recent transactions skipping the first "
         "'from' transactions.\n",
         {
             {"label|dummy", RPCArg::Type::STR,
              RPCArg::Optional::OMITTED_NAMED_ARG,
              "If set, should be a valid label name to return only incoming "
              "transactions with the specified label, or \"*\" to disable "
              "filtering and return all transactions."},
             {"count", RPCArg::Type::NUM, /* default */ "10",
              "The number of transactions to return"},
             {"skip", RPCArg::Type::NUM, /* default */ "0",
              "The number of transactions to skip"},
             {"include_watchonly", RPCArg::Type::BOOL,
              /* default */ "true for watch-only wallets, otherwise false",
              "Include transactions to watch-only addresses (see "
              "'importaddress')"},
         },
         RPCResult{
             RPCResult::Type::ARR,
             "",
             "",
             {
                 {RPCResult::Type::OBJ, "", "",
                  Cat(Cat<std::vector<RPCResult>>(
                          {
                              {RPCResult::Type::BOOL, "involvesWatchonly",
                               "Only returns true if imported addresses were "
                               "involved in transaction."},
                              {RPCResult::Type::STR, "address",
                               "The bitcoin address of the transaction."},
                              {RPCResult::Type::STR, "category",
                               "The transaction category.\n"
                               "\"send\"                  Transactions sent.\n"
                               "\"receive\"               Non-coinbase "
                               "transactions received.\n"
                               "\"generate\"              Coinbase transactions "
                               "received with more than 100 confirmations.\n"
                               "\"immature\"              Coinbase transactions "
                               "received with 100 or fewer confirmations.\n"
                               "\"orphan\"                Orphaned coinbase "
                               "transactions received."},
                              {RPCResult::Type::STR_AMOUNT, "amount",
                               "The amount in " + ticker +
                                   ". This is negative for the 'send' category, "
                                   "and is positive\n"
                                   "for all other categories"},
                              {RPCResult::Type::STR, "label",
                               "A comment for the address/transaction, if any"},
                              {RPCResult::Type::NUM, "vout", "the vout value"},
                              {RPCResult::Type::STR_AMOUNT, "fee",
                               "The amount of the fee in " + ticker +
                                   ". This is negative and only available for "
                                   "the\n"
                                   "'send' category of transactions."},
                          },
                          TransactionDescriptionString()),
                      {
                          {RPCResult::Type::BOOL, "abandoned",
                           "'true' if the transaction has been abandoned "
                           "(inputs are respendable). Only available for the \n"
                           "'send' category of transactions."},
                      })},
             }},
         RPCExamples{"\nList the most recent 10 transactions in the systems\n" +
                     HelpExampleCli("listtransactions", "") +
                     "\nList transactions 100 to 120\n" +
                     HelpExampleCli("listtransactions", "\"*\" 20 100") +
                     "\nAs a JSON-RPC call\n" +
                     HelpExampleRpc("listtransactions", "\"*\", 20, 100")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             const CWallet *const pwallet = wallet.get();
 
             // Make sure the results are valid at least up to the most recent
             // block the user could have gotten from another RPC command prior
             // to now
             pwallet->BlockUntilSyncedToCurrentChain();
 
             const std::string *filter_label = nullptr;
             if (!request.params[0].isNull() &&
                 request.params[0].get_str() != "*") {
                 filter_label = &request.params[0].get_str();
                 if (filter_label->empty()) {
                     throw JSONRPCError(
                         RPC_INVALID_PARAMETER,
                         "Label argument must be a valid label name or \"*\".");
                 }
             }
             int nCount = 10;
             if (!request.params[1].isNull()) {
                 nCount = request.params[1].get_int();
             }
 
             int nFrom = 0;
             if (!request.params[2].isNull()) {
                 nFrom = request.params[2].get_int();
             }
 
             isminefilter filter = ISMINE_SPENDABLE;
             if (ParseIncludeWatchonly(request.params[3], *pwallet)) {
                 filter |= ISMINE_WATCH_ONLY;
             }
 
             if (nCount < 0) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER, "Negative count");
             }
             if (nFrom < 0) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER, "Negative from");
             }
             UniValue ret(UniValue::VARR);
 
             {
                 LOCK(pwallet->cs_wallet);
 
                 const CWallet::TxItems &txOrdered = pwallet->wtxOrdered;
 
                 // iterate backwards until we have nCount items to return:
                 for (CWallet::TxItems::const_reverse_iterator it =
                          txOrdered.rbegin();
                      it != txOrdered.rend(); ++it) {
                     CWalletTx *const pwtx = (*it).second;
                     ListTransactions(pwallet, *pwtx, 0, true, ret, filter,
                                      filter_label);
                     if (int(ret.size()) >= (nCount + nFrom)) {
                         break;
                     }
                 }
             }
 
             // ret is newest to oldest
 
             if (nFrom > (int)ret.size()) {
                 nFrom = ret.size();
             }
             if ((nFrom + nCount) > (int)ret.size()) {
                 nCount = ret.size() - nFrom;
             }
 
             const std::vector<UniValue> &txs = ret.getValues();
             UniValue result{UniValue::VARR};
             // Return oldest to newest
             result.push_backV(
                 {txs.rend() - nFrom - nCount, txs.rend() - nFrom});
             return result;
         },
     };
 }
 
 static RPCHelpMan listsinceblock() {
     const auto &ticker = Currency::get().ticker;
     return RPCHelpMan{
         "listsinceblock",
         "Get all transactions in blocks since block [blockhash], or all "
         "transactions if omitted.\n"
         "If \"blockhash\" is no longer a part of the main chain, transactions "
         "from the fork point onward are included.\n"
         "Additionally, if include_removed is set, transactions affecting the "
         "wallet which were removed are returned in the \"removed\" array.\n",
         {
             {"blockhash", RPCArg::Type::STR,
              RPCArg::Optional::OMITTED_NAMED_ARG,
              "If set, the block hash to list transactions since, otherwise "
              "list all transactions."},
             {"target_confirmations", RPCArg::Type::NUM, /* default */ "1",
              "Return the nth block hash from the main chain. e.g. 1 would mean "
              "the best block hash. Note: this is not used as a filter, but "
              "only affects [lastblock] in the return value"},
             {"include_watchonly", RPCArg::Type::BOOL,
              /* default */ "true for watch-only wallets, otherwise false",
              "Include transactions to watch-only addresses (see "
              "'importaddress')"},
             {"include_removed", RPCArg::Type::BOOL, /* default */ "true",
              "Show transactions that were removed due to a reorg in the "
              "\"removed\" array\n"
              "                                                           (not "
              "guaranteed to work on pruned nodes)"},
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::ARR,
                  "transactions",
                  "",
                  {
                      {RPCResult::Type::OBJ, "", "",
                       Cat(Cat<std::vector<RPCResult>>(
                               {
                                   {RPCResult::Type::BOOL, "involvesWatchonly",
                                    "Only returns true if imported addresses "
                                    "were involved in transaction."},
                                   {RPCResult::Type::STR, "address",
                                    "The bitcoin address of the transaction."},
                                   {RPCResult::Type::STR, "category",
                                    "The transaction category.\n"
                                    "\"send\"                  Transactions "
                                    "sent.\n"
                                    "\"receive\"               Non-coinbase "
                                    "transactions received.\n"
                                    "\"generate\"              Coinbase "
                                    "transactions received with more than 100 "
                                    "confirmations.\n"
                                    "\"immature\"              Coinbase "
                                    "transactions received with 100 or fewer "
                                    "confirmations.\n"
                                    "\"orphan\"                Orphaned "
                                    "coinbase transactions received."},
                                   {RPCResult::Type::STR_AMOUNT, "amount",
                                    "The amount in " + ticker +
                                        ". This is negative for the 'send' "
                                        "category, and is positive\n"
                                        "for all other categories"},
                                   {RPCResult::Type::NUM, "vout",
                                    "the vout value"},
                                   {RPCResult::Type::STR_AMOUNT, "fee",
                                    "The amount of the fee in " + ticker +
                                        ". This is negative and only available "
                                        "for the\n"
                                        "'send' category of transactions."},
                               },
                               TransactionDescriptionString()),
                           {
                               {RPCResult::Type::BOOL, "abandoned",
                                "'true' if the transaction has been abandoned "
                                "(inputs are respendable). Only available for "
                                "the \n"
                                "'send' category of transactions."},
                               {RPCResult::Type::STR, "comment",
                                "If a comment is associated with the "
                                "transaction."},
                               {RPCResult::Type::STR, "label",
                                "A comment for the address/transaction, if any"},
                               {RPCResult::Type::STR, "to",
                                "If a comment to is associated with the "
                                "transaction."},
                           })},
                  }},
                 {RPCResult::Type::ARR,
                  "removed",
                  "<structure is the same as \"transactions\" above, only "
                  "present if include_removed=true>\n"
                  "Note: transactions that were re-added in the active chain "
                  "will appear as-is in this array, and may thus have a "
                  "positive confirmation count.",
                  {
                      {RPCResult::Type::ELISION, "", ""},
                  }},
                 {RPCResult::Type::STR_HEX, "lastblock",
                  "The hash of the block (target_confirmations-1) from the best "
                  "block on the main chain, or the genesis hash if the "
                  "referenced block does not exist yet. This is typically used "
                  "to feed back into listsinceblock the next time you call it. "
                  "So you would generally use a target_confirmations of say 6, "
                  "so you will be continually re-notified of transactions until "
                  "they've reached 6 confirmations plus any new ones"},
             }},
         RPCExamples{HelpExampleCli("listsinceblock", "") +
                     HelpExampleCli("listsinceblock",
                                    "\"000000000000000bacf66f7497b7dc45ef753ee9a"
                                    "7d38571037cdb1a57f663ad\" 6") +
                     HelpExampleRpc("listsinceblock",
                                    "\"000000000000000bacf66f7497b7dc45ef753ee9a"
                                    "7d38571037cdb1a57f663ad\", 6")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const pwallet =
                 GetWalletForJSONRPCRequest(request);
 
             if (!pwallet) {
                 return NullUniValue;
             }
 
             const CWallet &wallet = *pwallet;
             // Make sure the results are valid at least up to the most recent
             // block the user could have gotten from another RPC command prior
             // to now
             wallet.BlockUntilSyncedToCurrentChain();
 
             LOCK(wallet.cs_wallet);
 
             // Height of the specified block or the common ancestor, if the
             // block provided was in a deactivated chain.
             std::optional<int> height;
 
             // Height of the specified block, even if it's in a deactivated
             // chain.
             std::optional<int> altheight;
             int target_confirms = 1;
             isminefilter filter = ISMINE_SPENDABLE;
 
             BlockHash blockId;
             if (!request.params[0].isNull() &&
                 !request.params[0].get_str().empty()) {
                 blockId = BlockHash(ParseHashV(request.params[0], "blockhash"));
                 height = int{};
                 altheight = int{};
                 if (!wallet.chain().findCommonAncestor(
                         blockId, wallet.GetLastBlockHash(),
                         /* ancestor out */ FoundBlock().height(*height),
                         /* blockId out */ FoundBlock().height(*altheight))) {
                     throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                        "Block not found");
                 }
             }
 
             if (!request.params[1].isNull()) {
                 target_confirms = request.params[1].get_int();
 
                 if (target_confirms < 1) {
                     throw JSONRPCError(RPC_INVALID_PARAMETER,
                                        "Invalid parameter");
                 }
             }
 
             if (ParseIncludeWatchonly(request.params[2], wallet)) {
                 filter |= ISMINE_WATCH_ONLY;
             }
 
             bool include_removed =
                 (request.params[3].isNull() || request.params[3].get_bool());
 
             int depth = height ? wallet.GetLastBlockHeight() + 1 - *height : -1;
 
             UniValue transactions(UniValue::VARR);
 
             for (const std::pair<const TxId, CWalletTx> &pairWtx :
                  wallet.mapWallet) {
                 const CWalletTx &tx = pairWtx.second;
 
                 if (depth == -1 || wallet.GetTxDepthInMainChain(tx) < depth) {
                     ListTransactions(&wallet, tx, 0, true, transactions, filter,
                                      nullptr /* filter_label */);
                 }
             }
 
             // when a reorg'd block is requested, we also list any relevant
             // transactions in the blocks of the chain that was detached
             UniValue removed(UniValue::VARR);
             while (include_removed && altheight && *altheight > *height) {
                 CBlock block;
                 if (!wallet.chain().findBlock(blockId,
                                               FoundBlock().data(block)) ||
                     block.IsNull()) {
                     throw JSONRPCError(RPC_INTERNAL_ERROR,
                                        "Can't read block from disk");
                 }
                 for (const CTransactionRef &tx : block.vtx) {
                     auto it = wallet.mapWallet.find(tx->GetId());
                     if (it != wallet.mapWallet.end()) {
                         // We want all transactions regardless of confirmation
                         // count to appear here, even negative confirmation
                         // ones, hence the big negative.
                         ListTransactions(&wallet, it->second, -100000000, true,
                                          removed, filter,
                                          nullptr /* filter_label */);
                     }
                 }
                 blockId = block.hashPrevBlock;
                 --*altheight;
             }
 
             BlockHash lastblock;
             target_confirms =
                 std::min(target_confirms, wallet.GetLastBlockHeight() + 1);
             CHECK_NONFATAL(wallet.chain().findAncestorByHeight(
                 wallet.GetLastBlockHash(),
                 wallet.GetLastBlockHeight() + 1 - target_confirms,
                 FoundBlock().hash(lastblock)));
 
             UniValue ret(UniValue::VOBJ);
             ret.pushKV("transactions", transactions);
             if (include_removed) {
                 ret.pushKV("removed", removed);
             }
             ret.pushKV("lastblock", lastblock.GetHex());
 
             return ret;
         },
     };
 }
 
 static RPCHelpMan gettransaction() {
     const auto &ticker = Currency::get().ticker;
     return RPCHelpMan{
         "gettransaction",
         "Get detailed information about in-wallet transaction <txid>\n",
         {
             {"txid", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The transaction id"},
             {"include_watchonly", RPCArg::Type::BOOL,
              /* default */ "true for watch-only wallets, otherwise false",
              "Whether to include watch-only addresses in balance calculation "
              "and details[]"},
             {"verbose", RPCArg::Type::BOOL, /* default */ "false",
              "Whether to include a `decoded` field containing the decoded "
              "transaction (equivalent to RPC decoderawtransaction)"},
         },
         RPCResult{
             RPCResult::Type::OBJ, "", "",
             Cat(Cat<std::vector<RPCResult>>(
                     {
                         {RPCResult::Type::STR_AMOUNT, "amount",
                          "The amount in " + ticker},
                         {RPCResult::Type::STR_AMOUNT, "fee",
                          "The amount of the fee in " + ticker +
                              ". This is negative and only available for the\n"
                              "'send' category of transactions."},
                     },
                     TransactionDescriptionString()),
                 {
                     {RPCResult::Type::ARR,
                      "details",
                      "",
                      {
                          {RPCResult::Type::OBJ,
                           "",
                           "",
                           {
                               {RPCResult::Type::BOOL, "involvesWatchonly",
                                "Only returns true if imported addresses were "
                                "involved in transaction."},
                               {RPCResult::Type::STR, "address",
                                "The bitcoin address involved in the "
                                "transaction."},
                               {RPCResult::Type::STR, "category",
                                "The transaction category.\n"
                                "\"send\"                  Transactions sent.\n"
                                "\"receive\"               Non-coinbase "
                                "transactions received.\n"
                                "\"generate\"              Coinbase "
                                "transactions received with more than 100 "
                                "confirmations.\n"
                                "\"immature\"              Coinbase "
                                "transactions received with 100 or fewer "
                                "confirmations.\n"
                                "\"orphan\"                Orphaned coinbase "
                                "transactions received."},
                               {RPCResult::Type::STR_AMOUNT, "amount",
                                "The amount in " + ticker},
                               {RPCResult::Type::STR, "label",
                                "A comment for the address/transaction, if any"},
                               {RPCResult::Type::NUM, "vout", "the vout value"},
                               {RPCResult::Type::STR_AMOUNT, "fee",
                                "The amount of the fee in " + ticker +
                                    ". This is negative and only available for "
                                    "the \n"
                                    "'send' category of transactions."},
                               {RPCResult::Type::BOOL, "abandoned",
                                "'true' if the transaction has been abandoned "
                                "(inputs are respendable). Only available for "
                                "the \n"
                                "'send' category of transactions."},
                           }},
                      }},
                     {RPCResult::Type::STR_HEX, "hex",
                      "Raw data for transaction"},
                     {RPCResult::Type::OBJ,
                      "decoded",
                      "Optional, the decoded transaction (only present when "
                      "`verbose` is passed)",
                      {
                          {RPCResult::Type::ELISION, "",
                           "Equivalent to the RPC decoderawtransaction method, "
                           "or the RPC getrawtransaction method when `verbose` "
                           "is passed."},
                      }},
                 })},
         RPCExamples{HelpExampleCli("gettransaction",
                                    "\"1075db55d416d3ca199f55b6084e2115b9345e16c"
                                    "5cf302fc80e9d5fbf5d48d\"") +
                     HelpExampleCli("gettransaction",
                                    "\"1075db55d416d3ca199f55b6084e2115b9345e16c"
                                    "5cf302fc80e9d5fbf5d48d\" true") +
                     HelpExampleCli("gettransaction",
                                    "\"1075db55d416d3ca199f55b6084e2115b9345e16c"
                                    "5cf302fc80e9d5fbf5d48d\" false true") +
                     HelpExampleRpc("gettransaction",
                                    "\"1075db55d416d3ca199f55b6084e2115b9345e16c"
                                    "5cf302fc80e9d5fbf5d48d\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             const CWallet *const pwallet = wallet.get();
 
             // Make sure the results are valid at least up to the most recent
             // block the user could have gotten from another RPC command prior
             // to now
             pwallet->BlockUntilSyncedToCurrentChain();
 
             LOCK(pwallet->cs_wallet);
 
             TxId txid(ParseHashV(request.params[0], "txid"));
 
             isminefilter filter = ISMINE_SPENDABLE;
             if (ParseIncludeWatchonly(request.params[1], *pwallet)) {
                 filter |= ISMINE_WATCH_ONLY;
             }
 
             bool verbose = request.params[2].isNull()
                                ? false
                                : request.params[2].get_bool();
 
             UniValue entry(UniValue::VOBJ);
             auto it = pwallet->mapWallet.find(txid);
             if (it == pwallet->mapWallet.end()) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                    "Invalid or non-wallet transaction id");
             }
             const CWalletTx &wtx = it->second;
 
             Amount nCredit = CachedTxGetCredit(*pwallet, wtx, filter);
             Amount nDebit = CachedTxGetDebit(*pwallet, wtx, filter);
             Amount nNet = nCredit - nDebit;
             Amount nFee = (CachedTxIsFromMe(*pwallet, wtx, filter)
                                ? wtx.tx->GetValueOut() - nDebit
                                : Amount::zero());
 
             entry.pushKV("amount", nNet - nFee);
             if (CachedTxIsFromMe(*pwallet, wtx, filter)) {
                 entry.pushKV("fee", nFee);
             }
 
             WalletTxToJSON(*pwallet, wtx, entry);
 
             UniValue details(UniValue::VARR);
             ListTransactions(pwallet, wtx, 0, false, details, filter,
                              nullptr /* filter_label */);
             entry.pushKV("details", details);
 
             std::string strHex =
                 EncodeHexTx(*wtx.tx, pwallet->chain().rpcSerializationFlags());
             entry.pushKV("hex", strHex);
 
             if (verbose) {
                 UniValue decoded(UniValue::VOBJ);
                 TxToUniv(*wtx.tx, BlockHash(), decoded, false);
                 entry.pushKV("decoded", decoded);
             }
 
             return entry;
         },
     };
 }
 
 static RPCHelpMan abandontransaction() {
     return RPCHelpMan{
         "abandontransaction",
         "Mark in-wallet transaction <txid> as abandoned\n"
         "This will mark this transaction and all its in-wallet descendants as "
         "abandoned which will allow\n"
         "for their inputs to be respent.  It can be used to replace \"stuck\" "
         "or evicted transactions.\n"
         "It only works on transactions which are not included in a block and "
         "are not currently in the mempool.\n"
         "It has no effect on transactions which are already abandoned.\n",
         {
             {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The transaction id"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("abandontransaction",
                                    "\"1075db55d416d3ca199f55b6084e2115b9345e16c"
                                    "5cf302fc80e9d5fbf5d48d\"") +
                     HelpExampleRpc("abandontransaction",
                                    "\"1075db55d416d3ca199f55b6084e2115b9345e16c"
                                    "5cf302fc80e9d5fbf5d48d\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             // Make sure the results are valid at least up to the most recent
             // block the user could have gotten from another RPC command prior
             // to now
             pwallet->BlockUntilSyncedToCurrentChain();
 
             LOCK(pwallet->cs_wallet);
 
             TxId txid(ParseHashV(request.params[0], "txid"));
 
             if (!pwallet->mapWallet.count(txid)) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                    "Invalid or non-wallet transaction id");
             }
 
             if (!pwallet->AbandonTransaction(txid)) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                    "Transaction not eligible for abandonment");
             }
 
             return NullUniValue;
         },
     };
 }
 
 static RPCHelpMan keypoolrefill() {
     return RPCHelpMan{
         "keypoolrefill",
         "Fills the keypool." + HELP_REQUIRING_PASSPHRASE,
         {
             {"newsize", RPCArg::Type::NUM, /* default */ "100",
              "The new keypool size"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("keypoolrefill", "") +
                     HelpExampleRpc("keypoolrefill", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             if (pwallet->IsLegacy() &&
                 pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
                 throw JSONRPCError(
                     RPC_WALLET_ERROR,
                     "Error: Private keys are disabled for this wallet");
             }
 
             LOCK(pwallet->cs_wallet);
 
             // 0 is interpreted by TopUpKeyPool() as the default keypool size
             // given by -keypool
             unsigned int kpSize = 0;
             if (!request.params[0].isNull()) {
                 if (request.params[0].get_int() < 0) {
                     throw JSONRPCError(
                         RPC_INVALID_PARAMETER,
                         "Invalid parameter, expected valid size.");
                 }
                 kpSize = (unsigned int)request.params[0].get_int();
             }
 
             EnsureWalletIsUnlocked(pwallet);
             pwallet->TopUpKeyPool(kpSize);
 
             if (pwallet->GetKeyPoolSize() < kpSize) {
                 throw JSONRPCError(RPC_WALLET_ERROR,
                                    "Error refreshing keypool.");
             }
 
             return NullUniValue;
         },
     };
 }
 
 static RPCHelpMan lockunspent() {
     return RPCHelpMan{
         "lockunspent",
         "Updates list of temporarily unspendable outputs.\n"
         "Temporarily lock (unlock=false) or unlock (unlock=true) specified "
         "transaction outputs.\n"
         "If no transaction outputs are specified when unlocking then all "
         "current locked transaction outputs are unlocked.\n"
         "A locked transaction output will not be chosen by automatic coin "
         "selection, when spending bitcoins.\n"
         "Manually selected coins are automatically unlocked.\n"
         "Locks are stored in memory only. Nodes start with zero locked "
         "outputs, and the locked output list\n"
         "is always cleared (by virtue of process exit) when a node stops or "
         "fails.\n"
         "Also see the listunspent call\n",
         {
             {"unlock", RPCArg::Type::BOOL, RPCArg::Optional::NO,
              "Whether to unlock (true) or lock (false) the specified "
              "transactions"},
             {
                 "transactions",
                 RPCArg::Type::ARR,
                 /* default */ "empty array",
                 "The transaction outputs and within each, txid (string) vout "
                 "(numeric).",
                 {
                     {
                         "",
                         RPCArg::Type::OBJ,
                         RPCArg::Optional::OMITTED,
                         "",
                         {
                             {"txid", RPCArg::Type::STR_HEX,
                              RPCArg::Optional::NO, "The transaction id"},
                             {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO,
                              "The output number"},
                         },
                     },
                 },
             },
         },
         RPCResult{RPCResult::Type::BOOL, "",
                   "Whether the command was successful or not"},
         RPCExamples{
             "\nList the unspent transactions\n" +
             HelpExampleCli("listunspent", "") +
             "\nLock an unspent transaction\n" +
             HelpExampleCli("lockunspent", "false "
                                           "\"[{\\\"txid\\\":"
                                           "\\\"a08e6907dbbd3d809776dbfc5d82e371"
                                           "b764ed838b5655e72f463568df1aadf0\\\""
                                           ",\\\"vout\\\":1}]\"") +
             "\nList the locked transactions\n" +
             HelpExampleCli("listlockunspent", "") +
             "\nUnlock the transaction again\n" +
             HelpExampleCli("lockunspent", "true "
                                           "\"[{\\\"txid\\\":"
                                           "\\\"a08e6907dbbd3d809776dbfc5d82e371"
                                           "b764ed838b5655e72f463568df1aadf0\\\""
                                           ",\\\"vout\\\":1}]\"") +
             "\nAs a JSON-RPC call\n" +
             HelpExampleRpc("lockunspent", "false, "
                                           "\"[{\\\"txid\\\":"
                                           "\\\"a08e6907dbbd3d809776dbfc5d82e371"
                                           "b764ed838b5655e72f463568df1aadf0\\\""
                                           ",\\\"vout\\\":1}]\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             // Make sure the results are valid at least up to the most recent
             // block the user could have gotten from another RPC command prior
             // to now
             pwallet->BlockUntilSyncedToCurrentChain();
 
             LOCK(pwallet->cs_wallet);
 
             RPCTypeCheckArgument(request.params[0], UniValue::VBOOL);
 
             bool fUnlock = request.params[0].get_bool();
 
             if (request.params[1].isNull()) {
                 if (fUnlock) {
                     pwallet->UnlockAllCoins();
                 }
                 return true;
             }
 
             RPCTypeCheckArgument(request.params[1], UniValue::VARR);
 
             const UniValue &output_params = request.params[1];
 
             // Create and validate the COutPoints first.
 
             std::vector<COutPoint> outputs;
             outputs.reserve(output_params.size());
 
             for (size_t idx = 0; idx < output_params.size(); idx++) {
                 const UniValue &o = output_params[idx].get_obj();
 
                 RPCTypeCheckObj(o, {
                                        {"txid", UniValueType(UniValue::VSTR)},
                                        {"vout", UniValueType(UniValue::VNUM)},
                                    });
 
                 const int nOutput = find_value(o, "vout").get_int();
                 if (nOutput < 0) {
                     throw JSONRPCError(
                         RPC_INVALID_PARAMETER,
                         "Invalid parameter, vout cannot be negative");
                 }
 
                 const TxId txid(ParseHashO(o, "txid"));
                 const auto it = pwallet->mapWallet.find(txid);
                 if (it == pwallet->mapWallet.end()) {
                     throw JSONRPCError(
                         RPC_INVALID_PARAMETER,
                         "Invalid parameter, unknown transaction");
                 }
 
                 const COutPoint output(txid, nOutput);
                 const CWalletTx &trans = it->second;
                 if (output.GetN() >= trans.tx->vout.size()) {
                     throw JSONRPCError(
                         RPC_INVALID_PARAMETER,
                         "Invalid parameter, vout index out of bounds");
                 }
 
                 if (pwallet->IsSpent(output)) {
                     throw JSONRPCError(
                         RPC_INVALID_PARAMETER,
                         "Invalid parameter, expected unspent output");
                 }
 
                 const bool is_locked = pwallet->IsLockedCoin(output);
                 if (fUnlock && !is_locked) {
                     throw JSONRPCError(
                         RPC_INVALID_PARAMETER,
                         "Invalid parameter, expected locked output");
                 }
 
                 if (!fUnlock && is_locked) {
                     throw JSONRPCError(
                         RPC_INVALID_PARAMETER,
                         "Invalid parameter, output already locked");
                 }
 
                 outputs.push_back(output);
             }
 
             // Atomically set (un)locked status for the outputs.
             for (const COutPoint &output : outputs) {
                 if (fUnlock) {
                     pwallet->UnlockCoin(output);
                 } else {
                     pwallet->LockCoin(output);
                 }
             }
 
             return true;
         },
     };
 }
 
 static RPCHelpMan listlockunspent() {
     return RPCHelpMan{
         "listlockunspent",
         "Returns list of temporarily unspendable outputs.\n"
         "See the lockunspent call to lock and unlock transactions for "
         "spending.\n",
         {},
         RPCResult{RPCResult::Type::ARR,
                   "",
                   "",
                   {
                       {RPCResult::Type::OBJ,
                        "",
                        "",
                        {
                            {RPCResult::Type::STR_HEX, "txid",
                             "The transaction id locked"},
                            {RPCResult::Type::NUM, "vout", "The vout value"},
                        }},
                   }},
         RPCExamples{
             "\nList the unspent transactions\n" +
             HelpExampleCli("listunspent", "") +
             "\nLock an unspent transaction\n" +
             HelpExampleCli("lockunspent", "false "
                                           "\"[{\\\"txid\\\":"
                                           "\\\"a08e6907dbbd3d809776dbfc5d82e371"
                                           "b764ed838b5655e72f463568df1aadf0\\\""
                                           ",\\\"vout\\\":1}]\"") +
             "\nList the locked transactions\n" +
             HelpExampleCli("listlockunspent", "") +
             "\nUnlock the transaction again\n" +
             HelpExampleCli("lockunspent", "true "
                                           "\"[{\\\"txid\\\":"
                                           "\\\"a08e6907dbbd3d809776dbfc5d82e371"
                                           "b764ed838b5655e72f463568df1aadf0\\\""
                                           ",\\\"vout\\\":1}]\"") +
             "\nAs a JSON-RPC call\n" + HelpExampleRpc("listlockunspent", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             const CWallet *const pwallet = wallet.get();
 
             LOCK(pwallet->cs_wallet);
 
             std::vector<COutPoint> vOutpts;
             pwallet->ListLockedCoins(vOutpts);
 
             UniValue ret(UniValue::VARR);
 
             for (const COutPoint &output : vOutpts) {
                 UniValue o(UniValue::VOBJ);
 
                 o.pushKV("txid", output.GetTxId().GetHex());
                 o.pushKV("vout", int(output.GetN()));
                 ret.push_back(o);
             }
 
             return ret;
         },
     };
 }
 
 static RPCHelpMan settxfee() {
     return RPCHelpMan{
         "settxfee",
         "Set the transaction fee per kB for this wallet. Overrides the "
         "global -paytxfee command line parameter.\n"
         "Can be deactivated by passing 0 as the fee. In that case automatic "
         "fee selection will be used by default.\n",
         {
             {"amount", RPCArg::Type::AMOUNT, RPCArg::Optional::NO,
              "The transaction fee in " + Currency::get().ticker + "/kB"},
         },
         RPCResult{RPCResult::Type::BOOL, "", "Returns true if successful"},
         RPCExamples{HelpExampleCli("settxfee", "0.00001") +
                     HelpExampleRpc("settxfee", "0.00001")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             LOCK(pwallet->cs_wallet);
 
             Amount nAmount = AmountFromValue(request.params[0]);
             CFeeRate tx_fee_rate(nAmount, 1000);
             CFeeRate max_tx_fee_rate(pwallet->m_default_max_tx_fee, 1000);
             if (tx_fee_rate == CFeeRate()) {
                 // automatic selection
             } else if (tx_fee_rate < pwallet->chain().relayMinFee()) {
                 throw JSONRPCError(
                     RPC_INVALID_PARAMETER,
                     strprintf("txfee cannot be less than min relay tx fee (%s)",
                               pwallet->chain().relayMinFee().ToString()));
             } else if (tx_fee_rate < pwallet->m_min_fee) {
                 throw JSONRPCError(
                     RPC_INVALID_PARAMETER,
                     strprintf("txfee cannot be less than wallet min fee (%s)",
                               pwallet->m_min_fee.ToString()));
             } else if (tx_fee_rate > max_tx_fee_rate) {
                 throw JSONRPCError(
                     RPC_INVALID_PARAMETER,
                     strprintf(
                         "txfee cannot be more than wallet max tx fee (%s)",
                         max_tx_fee_rate.ToString()));
             }
 
             pwallet->m_pay_tx_fee = tx_fee_rate;
             return true;
         },
     };
 }
 
 static RPCHelpMan getbalances() {
     return RPCHelpMan{
         "getbalances",
         "Returns an object with all balances in " + Currency::get().ticker +
             ".\n",
         {},
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::OBJ,
                        "mine",
                        "balances from outputs that the wallet can sign",
                        {
                            {RPCResult::Type::STR_AMOUNT, "trusted",
                             "trusted balance (outputs created by the wallet or "
                             "confirmed outputs)"},
                            {RPCResult::Type::STR_AMOUNT, "untrusted_pending",
                             "untrusted pending balance (outputs created by "
                             "others that are in the mempool)"},
                            {RPCResult::Type::STR_AMOUNT, "immature",
                             "balance from immature coinbase outputs"},
                            {RPCResult::Type::STR_AMOUNT, "used",
                             "(only present if avoid_reuse is set) balance from "
                             "coins sent to addresses that were previously "
                             "spent from (potentially privacy violating)"},
                        }},
                       {RPCResult::Type::OBJ,
                        "watchonly",
                        "watchonly balances (not present if wallet does not "
                        "watch anything)",
                        {
                            {RPCResult::Type::STR_AMOUNT, "trusted",
                             "trusted balance (outputs created by the wallet or "
                             "confirmed outputs)"},
                            {RPCResult::Type::STR_AMOUNT, "untrusted_pending",
                             "untrusted pending balance (outputs created by "
                             "others that are in the mempool)"},
                            {RPCResult::Type::STR_AMOUNT, "immature",
                             "balance from immature coinbase outputs"},
                        }},
                   }},
         RPCExamples{HelpExampleCli("getbalances", "") +
                     HelpExampleRpc("getbalances", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const rpc_wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!rpc_wallet) {
                 return NullUniValue;
             }
             CWallet &wallet = *rpc_wallet;
 
             // Make sure the results are valid at least up to the most recent
             // block the user could have gotten from another RPC command prior
             // to now
             wallet.BlockUntilSyncedToCurrentChain();
 
             LOCK(wallet.cs_wallet);
 
             const auto bal = GetBalance(wallet);
             UniValue balances{UniValue::VOBJ};
             {
                 UniValue balances_mine{UniValue::VOBJ};
                 balances_mine.pushKV("trusted", bal.m_mine_trusted);
                 balances_mine.pushKV("untrusted_pending",
                                      bal.m_mine_untrusted_pending);
                 balances_mine.pushKV("immature", bal.m_mine_immature);
                 if (wallet.IsWalletFlagSet(WALLET_FLAG_AVOID_REUSE)) {
                     // If the AVOID_REUSE flag is set, bal has been set to just
                     // the un-reused address balance. Get the total balance, and
                     // then subtract bal to get the reused address balance.
                     const auto full_bal = GetBalance(wallet, 0, false);
                     balances_mine.pushKV("used",
                                          full_bal.m_mine_trusted +
                                              full_bal.m_mine_untrusted_pending -
                                              bal.m_mine_trusted -
                                              bal.m_mine_untrusted_pending);
                 }
                 balances.pushKV("mine", balances_mine);
             }
             auto spk_man = wallet.GetLegacyScriptPubKeyMan();
             if (spk_man && spk_man->HaveWatchOnly()) {
                 UniValue balances_watchonly{UniValue::VOBJ};
                 balances_watchonly.pushKV("trusted", bal.m_watchonly_trusted);
                 balances_watchonly.pushKV("untrusted_pending",
                                           bal.m_watchonly_untrusted_pending);
                 balances_watchonly.pushKV("immature", bal.m_watchonly_immature);
                 balances.pushKV("watchonly", balances_watchonly);
             }
             return balances;
         },
     };
 }
 
 static RPCHelpMan getwalletinfo() {
     return RPCHelpMan{
         "getwalletinfo",
         "Returns an object containing various wallet state info.\n",
         {},
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {{
                 {RPCResult::Type::STR, "walletname", "the wallet name"},
                 {RPCResult::Type::NUM, "walletversion", "the wallet version"},
                 {RPCResult::Type::STR_AMOUNT, "balance",
                  "DEPRECATED. Identical to getbalances().mine.trusted"},
                 {RPCResult::Type::STR_AMOUNT, "unconfirmed_balance",
                  "DEPRECATED. Identical to "
                  "getbalances().mine.untrusted_pending"},
                 {RPCResult::Type::STR_AMOUNT, "immature_balance",
                  "DEPRECATED. Identical to getbalances().mine.immature"},
                 {RPCResult::Type::NUM, "txcount",
                  "the total number of transactions in the wallet"},
                 {RPCResult::Type::NUM_TIME, "keypoololdest",
                  "the " + UNIX_EPOCH_TIME +
                      " of the oldest pre-generated key in the key pool. Legacy "
                      "wallets only."},
                 {RPCResult::Type::NUM, "keypoolsize",
                  "how many new keys are pre-generated (only counts external "
                  "keys)"},
                 {RPCResult::Type::NUM, "keypoolsize_hd_internal",
                  "how many new keys are pre-generated for internal use (used "
                  "for change outputs, only appears if the wallet is using this "
                  "feature, otherwise external keys are used)"},
                 {RPCResult::Type::NUM_TIME, "unlocked_until",
                  /* optional */ true,
                  "the " + UNIX_EPOCH_TIME +
                      " until which the wallet is unlocked for transfers, or 0 "
                      "if the wallet is locked (only present for "
                      "passphrase-encrypted wallets)"},
                 {RPCResult::Type::STR_AMOUNT, "paytxfee",
                  "the transaction fee configuration, set in " +
                      Currency::get().ticker + "/kB"},
                 {RPCResult::Type::STR_HEX, "hdseedid", /* optional */ true,
                  "the Hash160 of the HD seed (only present when HD is "
                  "enabled)"},
                 {RPCResult::Type::BOOL, "private_keys_enabled",
                  "false if privatekeys are disabled for this wallet (enforced "
                  "watch-only wallet)"},
                 {RPCResult::Type::OBJ,
                  "scanning",
                  "current scanning details, or false if no scan is in progress",
                  {
                      {RPCResult::Type::NUM, "duration",
                       "elapsed seconds since scan start"},
                      {RPCResult::Type::NUM, "progress",
                       "scanning progress percentage [0.0, 1.0]"},
                  }},
                 {RPCResult::Type::BOOL, "avoid_reuse",
                  "whether this wallet tracks clean/dirty coins in terms of "
                  "reuse"},
                 {RPCResult::Type::BOOL, "descriptors",
                  "whether this wallet uses descriptors for scriptPubKey "
                  "management"},
             }},
         },
         RPCExamples{HelpExampleCli("getwalletinfo", "") +
                     HelpExampleRpc("getwalletinfo", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             const CWallet *const pwallet = wallet.get();
 
             // Make sure the results are valid at least up to the most recent
             // block the user could have gotten from another RPC command prior
             // to now
             pwallet->BlockUntilSyncedToCurrentChain();
 
             LOCK(pwallet->cs_wallet);
 
             UniValue obj(UniValue::VOBJ);
 
             size_t kpExternalSize = pwallet->KeypoolCountExternalKeys();
             const auto bal = GetBalance(*pwallet);
             int64_t kp_oldest = pwallet->GetOldestKeyPoolTime();
             obj.pushKV("walletname", pwallet->GetName());
             obj.pushKV("walletversion", pwallet->GetVersion());
             obj.pushKV("balance", bal.m_mine_trusted);
             obj.pushKV("unconfirmed_balance", bal.m_mine_untrusted_pending);
             obj.pushKV("immature_balance", bal.m_mine_immature);
             obj.pushKV("txcount", (int)pwallet->mapWallet.size());
             if (kp_oldest > 0) {
                 obj.pushKV("keypoololdest", kp_oldest);
             }
             obj.pushKV("keypoolsize", (int64_t)kpExternalSize);
 
             LegacyScriptPubKeyMan *spk_man =
                 pwallet->GetLegacyScriptPubKeyMan();
             if (spk_man) {
                 CKeyID seed_id = spk_man->GetHDChain().seed_id;
                 if (!seed_id.IsNull()) {
                     obj.pushKV("hdseedid", seed_id.GetHex());
                 }
             }
 
             if (pwallet->CanSupportFeature(FEATURE_HD_SPLIT)) {
                 obj.pushKV("keypoolsize_hd_internal",
                            int64_t(pwallet->GetKeyPoolSize() - kpExternalSize));
             }
             if (pwallet->IsCrypted()) {
                 obj.pushKV("unlocked_until", pwallet->nRelockTime);
             }
             obj.pushKV("paytxfee", pwallet->m_pay_tx_fee.GetFeePerK());
             obj.pushKV(
                 "private_keys_enabled",
                 !pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS));
             if (pwallet->IsScanning()) {
                 UniValue scanning(UniValue::VOBJ);
                 scanning.pushKV("duration", pwallet->ScanningDuration() / 1000);
                 scanning.pushKV("progress", pwallet->ScanningProgress());
                 obj.pushKV("scanning", scanning);
             } else {
                 obj.pushKV("scanning", false);
             }
             obj.pushKV("avoid_reuse",
                        pwallet->IsWalletFlagSet(WALLET_FLAG_AVOID_REUSE));
             obj.pushKV("descriptors",
                        pwallet->IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS));
             return obj;
         },
     };
 }
 
 static RPCHelpMan listwalletdir() {
     return RPCHelpMan{
         "listwalletdir",
         "Returns a list of wallets in the wallet directory.\n",
         {},
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::ARR,
                  "wallets",
                  "",
                  {
                      {RPCResult::Type::OBJ,
                       "",
                       "",
                       {
                           {RPCResult::Type::STR, "name", "The wallet name"},
                       }},
                  }},
             }},
         RPCExamples{HelpExampleCli("listwalletdir", "") +
                     HelpExampleRpc("listwalletdir", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             UniValue wallets(UniValue::VARR);
             for (const auto &path : ListWalletDir()) {
                 UniValue wallet(UniValue::VOBJ);
                 wallet.pushKV("name", path.u8string());
                 wallets.push_back(wallet);
             }
 
             UniValue result(UniValue::VOBJ);
             result.pushKV("wallets", wallets);
             return result;
         },
     };
 }
 
 static RPCHelpMan listwallets() {
     return RPCHelpMan{
         "listwallets",
         "Returns a list of currently loaded wallets.\n"
         "For full information on the wallet, use \"getwalletinfo\"\n",
         {},
         RPCResult{RPCResult::Type::ARR,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR, "walletname", "the wallet name"},
                   }},
         RPCExamples{HelpExampleCli("listwallets", "") +
                     HelpExampleRpc("listwallets", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             UniValue obj(UniValue::VARR);
 
             for (const std::shared_ptr<CWallet> &wallet : GetWallets()) {
                 LOCK(wallet->cs_wallet);
                 obj.push_back(wallet->GetName());
             }
 
             return obj;
         },
     };
 }
 
 static RPCHelpMan loadwallet() {
     return RPCHelpMan{
         "loadwallet",
         "Loads a wallet from a wallet file or directory."
         "\nNote that all wallet command-line options used when starting "
         "bitcoind will be"
         "\napplied to the new wallet (eg -rescan, etc).\n",
         {
             {"filename", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The wallet directory or .dat file."},
             {"load_on_startup", RPCArg::Type::BOOL, /* default */ "null",
              "Save wallet name to persistent settings and load on startup. "
              "True to add wallet to startup list, false to remove, null to "
              "leave unchanged."},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR, "name",
                        "The wallet name if loaded successfully."},
                       {RPCResult::Type::STR, "warning",
                        "Warning message if wallet was not loaded cleanly."},
                   }},
         RPCExamples{HelpExampleCli("loadwallet", "\"test.dat\"") +
                     HelpExampleRpc("loadwallet", "\"test.dat\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             WalletContext &context = EnsureWalletContext(request.context);
             const std::string name(request.params[0].get_str());
 
             auto [wallet, warnings] =
                 LoadWalletHelper(context, request.params[1], name);
 
             UniValue obj(UniValue::VOBJ);
             obj.pushKV("name", wallet->GetName());
             obj.pushKV("warning", Join(warnings, Untranslated("\n")).original);
 
             return obj;
         },
     };
 }
 
 static RPCHelpMan setwalletflag() {
     std::string flags = "";
     for (auto &it : WALLET_FLAG_MAP) {
         if (it.second & MUTABLE_WALLET_FLAGS) {
             flags += (flags == "" ? "" : ", ") + it.first;
         }
     }
     return RPCHelpMan{
         "setwalletflag",
         "Change the state of the given wallet flag for a wallet.\n",
         {
             {"flag", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The name of the flag to change. Current available flags: " +
                  flags},
             {"value", RPCArg::Type::BOOL, /* default */ "true",
              "The new state."},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR, "flag_name",
                        "The name of the flag that was modified"},
                       {RPCResult::Type::BOOL, "flag_state",
                        "The new state of the flag"},
                       {RPCResult::Type::STR, "warnings",
                        "Any warnings associated with the change"},
                   }},
         RPCExamples{HelpExampleCli("setwalletflag", "avoid_reuse") +
                     HelpExampleRpc("setwalletflag", "\"avoid_reuse\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             std::string flag_str = request.params[0].get_str();
             bool value =
                 request.params[1].isNull() || request.params[1].get_bool();
 
             if (!WALLET_FLAG_MAP.count(flag_str)) {
                 throw JSONRPCError(
                     RPC_INVALID_PARAMETER,
                     strprintf("Unknown wallet flag: %s", flag_str));
             }
 
             auto flag = WALLET_FLAG_MAP.at(flag_str);
 
             if (!(flag & MUTABLE_WALLET_FLAGS)) {
                 throw JSONRPCError(
                     RPC_INVALID_PARAMETER,
                     strprintf("Wallet flag is immutable: %s", flag_str));
             }
 
             UniValue res(UniValue::VOBJ);
 
             if (pwallet->IsWalletFlagSet(flag) == value) {
                 throw JSONRPCError(
                     RPC_INVALID_PARAMETER,
                     strprintf("Wallet flag is already set to %s: %s",
                               value ? "true" : "false", flag_str));
             }
 
             res.pushKV("flag_name", flag_str);
             res.pushKV("flag_state", value);
 
             if (value) {
                 pwallet->SetWalletFlag(flag);
             } else {
                 pwallet->UnsetWalletFlag(flag);
             }
 
             if (flag && value && WALLET_FLAG_CAVEATS.count(flag)) {
                 res.pushKV("warnings", WALLET_FLAG_CAVEATS.at(flag));
             }
 
             return res;
         },
     };
 }
 
 static RPCHelpMan createwallet() {
     return RPCHelpMan{
         "createwallet",
         "Creates and loads a new wallet.\n",
         {
             {"wallet_name", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The name for the new wallet. If this is a path, the wallet will "
              "be created at the path location."},
             {"disable_private_keys", RPCArg::Type::BOOL, /* default */ "false",
              "Disable the possibility of private keys (only watchonlys are "
              "possible in this mode)."},
             {"blank", RPCArg::Type::BOOL, /* default */ "false",
              "Create a blank wallet. A blank wallet has no keys or HD seed. "
              "One can be set using sethdseed."},
             {"passphrase", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
              "Encrypt the wallet with this passphrase."},
             {"avoid_reuse", RPCArg::Type::BOOL, /* default */ "false",
              "Keep track of coin reuse, and treat dirty and clean coins "
              "differently with privacy considerations in mind."},
             {"descriptors", RPCArg::Type::BOOL, /* default */ "false",
              "Create a native descriptor wallet. The wallet will use "
              "descriptors internally to handle address creation"},
             {"load_on_startup", RPCArg::Type::BOOL, /* default */ "null",
              "Save wallet name to persistent settings and load on startup. "
              "True to add wallet to startup list, false to remove, null to "
              "leave unchanged."},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR, "name",
                        "The wallet name if created successfully. If the wallet "
                        "was created using a full path, the wallet_name will be "
                        "the full path."},
                       {RPCResult::Type::STR, "warning",
                        "Warning message if wallet was not loaded cleanly."},
                   }},
         RPCExamples{
             HelpExampleCli("createwallet", "\"testwallet\"") +
             HelpExampleRpc("createwallet", "\"testwallet\"") +
             HelpExampleCliNamed("createwallet", {{"wallet_name", "descriptors"},
                                                  {"avoid_reuse", true},
                                                  {"descriptors", true},
                                                  {"load_on_startup", true}}) +
             HelpExampleRpcNamed("createwallet", {{"wallet_name", "descriptors"},
                                                  {"avoid_reuse", true},
                                                  {"descriptors", true},
                                                  {"load_on_startup", true}})},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             WalletContext &context = EnsureWalletContext(request.context);
             uint64_t flags = 0;
             if (!request.params[1].isNull() && request.params[1].get_bool()) {
                 flags |= WALLET_FLAG_DISABLE_PRIVATE_KEYS;
             }
 
             if (!request.params[2].isNull() && request.params[2].get_bool()) {
                 flags |= WALLET_FLAG_BLANK_WALLET;
             }
 
             SecureString passphrase;
             passphrase.reserve(100);
             std::vector<bilingual_str> warnings;
             if (!request.params[3].isNull()) {
                 passphrase = request.params[3].get_str().c_str();
                 if (passphrase.empty()) {
                     // Empty string means unencrypted
                     warnings.emplace_back(Untranslated(
                         "Empty string given as passphrase, wallet will "
                         "not be encrypted."));
                 }
             }
 
             if (!request.params[4].isNull() && request.params[4].get_bool()) {
                 flags |= WALLET_FLAG_AVOID_REUSE;
             }
             if (!request.params[5].isNull() && request.params[5].get_bool()) {
                 flags |= WALLET_FLAG_DESCRIPTORS;
                 warnings.emplace_back(Untranslated(
                     "Wallet is an experimental descriptor wallet"));
             }
 
             DatabaseOptions options;
             DatabaseStatus status;
             options.require_create = true;
             options.create_flags = flags;
             options.create_passphrase = passphrase;
             bilingual_str error;
             std::optional<bool> load_on_start =
                 request.params[6].isNull()
                     ? std::nullopt
                     : std::make_optional<bool>(request.params[6].get_bool());
             std::shared_ptr<CWallet> wallet =
                 CreateWallet(*context.chain, request.params[0].get_str(),
                              load_on_start, options, status, error, warnings);
             if (!wallet) {
                 RPCErrorCode code = status == DatabaseStatus::FAILED_ENCRYPT
                                         ? RPC_WALLET_ENCRYPTION_FAILED
                                         : RPC_WALLET_ERROR;
                 throw JSONRPCError(code, error.original);
             }
 
             UniValue obj(UniValue::VOBJ);
             obj.pushKV("name", wallet->GetName());
             obj.pushKV("warning", Join(warnings, Untranslated("\n")).original);
 
             return obj;
         },
     };
 }
 
 static RPCHelpMan unloadwallet() {
     return RPCHelpMan{
         "unloadwallet",
         "Unloads the wallet referenced by the request endpoint otherwise "
         "unloads the wallet specified in the argument.\n"
         "Specifying the wallet name on a wallet endpoint is invalid.",
         {
             {"wallet_name", RPCArg::Type::STR,
              /* default */ "the wallet name from the RPC request",
              "The name of the wallet to unload."},
             {"load_on_startup", RPCArg::Type::BOOL, /* default */ "null",
              "Save wallet name to persistent settings and load on startup. "
              "True to add wallet to startup list, false to remove, null to "
              "leave unchanged."},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR, "warning",
                        "Warning message if wallet was not unloaded cleanly."},
                   }},
         RPCExamples{HelpExampleCli("unloadwallet", "wallet_name") +
                     HelpExampleRpc("unloadwallet", "wallet_name")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::string wallet_name;
             if (GetWalletNameFromJSONRPCRequest(request, wallet_name)) {
                 if (!request.params[0].isNull()) {
                     throw JSONRPCError(RPC_INVALID_PARAMETER,
                                        "Cannot unload the requested wallet");
                 }
             } else {
                 wallet_name = request.params[0].get_str();
             }
 
             std::shared_ptr<CWallet> wallet = GetWallet(wallet_name);
             if (!wallet) {
                 throw JSONRPCError(
                     RPC_WALLET_NOT_FOUND,
                     "Requested wallet does not exist or is not loaded");
             }
 
             // Release the "main" shared pointer and prevent further
             // notifications. Note that any attempt to load the same wallet
             // would fail until the wallet is destroyed (see CheckUniqueFileid).
             std::vector<bilingual_str> warnings;
             std::optional<bool> load_on_start =
                 request.params[1].isNull()
                     ? std::nullopt
                     : std::make_optional<bool>(request.params[1].get_bool());
             if (!RemoveWallet(wallet, load_on_start, warnings)) {
                 throw JSONRPCError(RPC_MISC_ERROR,
                                    "Requested wallet already unloaded");
             }
 
             UnloadWallet(std::move(wallet));
 
             UniValue result(UniValue::VOBJ);
             result.pushKV("warning",
                           Join(warnings, Untranslated("\n")).original);
             return result;
         },
     };
 }
 
 static RPCHelpMan listunspent() {
     const auto &ticker = Currency::get().ticker;
     return RPCHelpMan{
         "listunspent",
         "Returns array of unspent transaction outputs\n"
         "with between minconf and maxconf (inclusive) confirmations.\n"
         "Optionally filter to only include txouts paid to specified "
         "addresses.\n",
         {
             {"minconf", RPCArg::Type::NUM, /* default */ "1",
              "The minimum confirmations to filter"},
             {"maxconf", RPCArg::Type::NUM, /* default */ "9999999",
              "The maximum confirmations to filter"},
             {
                 "addresses",
                 RPCArg::Type::ARR,
                 /* default */ "empty array",
                 "The bitcoin addresses to filter",
                 {
                     {"address", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
                      "bitcoin address"},
                 },
             },
             {"include_unsafe", RPCArg::Type::BOOL, /* default */ "true",
              "Include outputs that are not safe to spend\n"
              "                  See description of \"safe\" attribute below."},
             {"query_options",
              RPCArg::Type::OBJ,
              RPCArg::Optional::OMITTED_NAMED_ARG,
              "JSON with query options",
              {
                  {"minimumAmount", RPCArg::Type::AMOUNT, /* default */ "0",
                   "Minimum value of each UTXO in " + ticker + ""},
                  {"maximumAmount", RPCArg::Type::AMOUNT,
                   /* default */ "unlimited",
                   "Maximum value of each UTXO in " + ticker + ""},
                  {"maximumCount", RPCArg::Type::NUM, /* default */ "unlimited",
                   "Maximum number of UTXOs"},
                  {"minimumSumAmount", RPCArg::Type::AMOUNT,
                   /* default */ "unlimited",
                   "Minimum sum value of all UTXOs in " + ticker + ""},
              },
              "query_options"},
         },
         RPCResult{
             RPCResult::Type::ARR,
             "",
             "",
             {
                 {RPCResult::Type::OBJ,
                  "",
                  "",
                  {
                      {RPCResult::Type::STR_HEX, "txid", "the transaction id"},
                      {RPCResult::Type::NUM, "vout", "the vout value"},
                      {RPCResult::Type::STR, "address", "the bitcoin address"},
                      {RPCResult::Type::STR, "label",
                       "The associated label, or \"\" for the default label"},
                      {RPCResult::Type::STR, "scriptPubKey", "the script key"},
                      {RPCResult::Type::STR_AMOUNT, "amount",
                       "the transaction output amount in " + ticker},
                      {RPCResult::Type::NUM, "confirmations",
                       "The number of confirmations"},
                      {RPCResult::Type::NUM, "ancestorcount",
                       /* optional */ true,
                       "DEPRECATED: The number of in-mempool ancestor "
                       "transactions, including this one (if transaction is in "
                       "the mempool). Only displayed if the "
                       "-deprecatedrpc=mempool_ancestors_descendants option is "
                       "set"},
                      {RPCResult::Type::NUM, "ancestorsize", /* optional */ true,
                       "DEPRECATED: The virtual transaction size of in-mempool "
                       " ancestors, including this one (if transaction is in "
                       "the mempool). Only displayed if the "
                       "-deprecatedrpc=mempool_ancestors_descendants option is "
                       "set"},
                      {RPCResult::Type::STR_AMOUNT, "ancestorfees",
                       /* optional */ true,
                       "DEPRECATED: The total fees of in-mempool ancestors "
                       "(including this one) with fee deltas used for mining "
                       "priority in " +
                           ticker +
                           " (if transaction is in the mempool). Only "
                           "displayed if the "
                           "-deprecatedrpc=mempool_ancestors_descendants option "
                           "is "
                           "set"},
                      {RPCResult::Type::STR_HEX, "redeemScript",
                       "The redeemScript if scriptPubKey is P2SH"},
                      {RPCResult::Type::BOOL, "spendable",
                       "Whether we have the private keys to spend this output"},
                      {RPCResult::Type::BOOL, "solvable",
                       "Whether we know how to spend this output, ignoring the "
                       "lack of keys"},
                      {RPCResult::Type::BOOL, "reused",
                       "(only present if avoid_reuse is set) Whether this "
                       "output is reused/dirty (sent to an address that was "
                       "previously spent from)"},
                      {RPCResult::Type::STR, "desc",
                       "(only when solvable) A descriptor for spending this "
                       "output"},
                      {RPCResult::Type::BOOL, "safe",
                       "Whether this output is considered safe to spend. "
                       "Unconfirmed transactions\n"
                       "from outside keys and unconfirmed replacement "
                       "transactions are considered unsafe\n"
                       "and are not eligible for spending by fundrawtransaction "
                       "and sendtoaddress."},
                  }},
             }},
         RPCExamples{
             HelpExampleCli("listunspent", "") +
             HelpExampleCli("listunspent",
                            "6 9999999 "
                            "\"[\\\"1PGFqEzfmQch1gKD3ra4k18PNj3tTUUSqg\\\","
                            "\\\"1LtvqCaApEdUGFkpKMM4MstjcaL4dKg8SP\\\"]\"") +
             HelpExampleRpc("listunspent",
                            "6, 9999999 "
                            "\"[\\\"1PGFqEzfmQch1gKD3ra4k18PNj3tTUUSqg\\\","
                            "\\\"1LtvqCaApEdUGFkpKMM4MstjcaL4dKg8SP\\\"]\"") +
             HelpExampleCli(
                 "listunspent",
                 "6 9999999 '[]' true '{ \"minimumAmount\": 0.005 }'") +
             HelpExampleRpc(
                 "listunspent",
                 "6, 9999999, [] , true, { \"minimumAmount\": 0.005 } ")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             const CWallet *const pwallet = wallet.get();
 
             int nMinDepth = 1;
             if (!request.params[0].isNull()) {
                 RPCTypeCheckArgument(request.params[0], UniValue::VNUM);
                 nMinDepth = request.params[0].get_int();
             }
 
             int nMaxDepth = 9999999;
             if (!request.params[1].isNull()) {
                 RPCTypeCheckArgument(request.params[1], UniValue::VNUM);
                 nMaxDepth = request.params[1].get_int();
             }
 
             std::set<CTxDestination> destinations;
             if (!request.params[2].isNull()) {
                 RPCTypeCheckArgument(request.params[2], UniValue::VARR);
                 UniValue inputs = request.params[2].get_array();
                 for (size_t idx = 0; idx < inputs.size(); idx++) {
                     const UniValue &input = inputs[idx];
                     CTxDestination dest = DecodeDestination(
                         input.get_str(), wallet->GetChainParams());
                     if (!IsValidDestination(dest)) {
                         throw JSONRPCError(
                             RPC_INVALID_ADDRESS_OR_KEY,
                             std::string("Invalid Bitcoin address: ") +
                                 input.get_str());
                     }
                     if (!destinations.insert(dest).second) {
                         throw JSONRPCError(
                             RPC_INVALID_PARAMETER,
                             std::string(
                                 "Invalid parameter, duplicated address: ") +
                                 input.get_str());
                     }
                 }
             }
 
             bool include_unsafe = true;
             if (!request.params[3].isNull()) {
                 RPCTypeCheckArgument(request.params[3], UniValue::VBOOL);
                 include_unsafe = request.params[3].get_bool();
             }
 
             Amount nMinimumAmount = Amount::zero();
             Amount nMaximumAmount = MAX_MONEY;
             Amount nMinimumSumAmount = MAX_MONEY;
             uint64_t nMaximumCount = 0;
 
             if (!request.params[4].isNull()) {
                 const UniValue &options = request.params[4].get_obj();
 
                 RPCTypeCheckObj(
                     options,
                     {
                         {"minimumAmount", UniValueType()},
                         {"maximumAmount", UniValueType()},
                         {"minimumSumAmount", UniValueType()},
                         {"maximumCount", UniValueType(UniValue::VNUM)},
                     },
                     true, true);
 
                 if (options.exists("minimumAmount")) {
                     nMinimumAmount = AmountFromValue(options["minimumAmount"]);
                 }
 
                 if (options.exists("maximumAmount")) {
                     nMaximumAmount = AmountFromValue(options["maximumAmount"]);
                 }
 
                 if (options.exists("minimumSumAmount")) {
                     nMinimumSumAmount =
                         AmountFromValue(options["minimumSumAmount"]);
                 }
 
                 if (options.exists("maximumCount")) {
                     nMaximumCount = options["maximumCount"].get_int64();
                 }
             }
 
             // Make sure the results are valid at least up to the most recent
             // block the user could have gotten from another RPC command prior
             // to now
             pwallet->BlockUntilSyncedToCurrentChain();
 
             UniValue results(UniValue::VARR);
             std::vector<COutput> vecOutputs;
             {
                 CCoinControl cctl;
                 cctl.m_avoid_address_reuse = false;
                 cctl.m_min_depth = nMinDepth;
                 cctl.m_max_depth = nMaxDepth;
                 LOCK(pwallet->cs_wallet);
                 AvailableCoins(*pwallet, vecOutputs, !include_unsafe, &cctl,
                                nMinimumAmount, nMaximumAmount,
                                nMinimumSumAmount, nMaximumCount);
             }
 
             LOCK(pwallet->cs_wallet);
 
             const bool avoid_reuse =
                 pwallet->IsWalletFlagSet(WALLET_FLAG_AVOID_REUSE);
 
             for (const COutput &out : vecOutputs) {
                 CTxDestination address;
                 const CScript &scriptPubKey =
                     out.tx->tx->vout[out.i].scriptPubKey;
                 bool fValidAddress = ExtractDestination(scriptPubKey, address);
                 bool reused =
                     avoid_reuse && pwallet->IsSpentKey(out.tx->GetId(), out.i);
 
                 if (destinations.size() &&
                     (!fValidAddress || !destinations.count(address))) {
                     continue;
                 }
 
                 UniValue entry(UniValue::VOBJ);
                 entry.pushKV("txid", out.tx->GetId().GetHex());
                 entry.pushKV("vout", out.i);
 
                 if (fValidAddress) {
                     entry.pushKV("address", EncodeDestination(address, config));
 
                     const auto *address_book_entry =
                         pwallet->FindAddressBookEntry(address);
                     if (address_book_entry) {
                         entry.pushKV("label", address_book_entry->GetLabel());
                     }
 
                     std::unique_ptr<SigningProvider> provider =
                         pwallet->GetSolvingProvider(scriptPubKey);
                     if (provider) {
                         if (scriptPubKey.IsPayToScriptHash()) {
                             const CScriptID &hash =
                                 CScriptID(boost::get<ScriptHash>(address));
                             CScript redeemScript;
                             if (provider->GetCScript(hash, redeemScript)) {
                                 entry.pushKV("redeemScript",
                                              HexStr(redeemScript));
                             }
                         }
                     }
                 }
 
                 entry.pushKV("scriptPubKey", HexStr(scriptPubKey));
                 entry.pushKV("amount", out.tx->tx->vout[out.i].nValue);
                 entry.pushKV("confirmations", out.nDepth);
-
-                // Deprecated in v0.27.0
-                if (!out.nDepth &&
-                    IsDeprecatedRPCEnabled(gArgs,
-                                           "mempool_ancestors_descendants")) {
-                    size_t ancestor_count, descendant_count, ancestor_size;
-                    Amount ancestor_fees;
-                    pwallet->chain().getTransactionAncestry(
-                        out.tx->GetId(), ancestor_count, descendant_count,
-                        &ancestor_size, &ancestor_fees);
-                    if (ancestor_count) {
-                        entry.pushKV("ancestorcount", uint64_t(ancestor_count));
-                        entry.pushKV("ancestorsize", uint64_t(ancestor_size));
-                        entry.pushKV("ancestorfees", ancestor_fees);
-                    }
-                }
                 entry.pushKV("spendable", out.fSpendable);
                 entry.pushKV("solvable", out.fSolvable);
                 if (out.fSolvable) {
                     std::unique_ptr<SigningProvider> provider =
                         pwallet->GetSolvingProvider(scriptPubKey);
                     if (provider) {
                         auto descriptor =
                             InferDescriptor(scriptPubKey, *provider);
                         entry.pushKV("desc", descriptor->ToString());
                     }
                 }
                 if (avoid_reuse) {
                     entry.pushKV("reused", reused);
                 }
                 entry.pushKV("safe", out.fSafe);
                 results.push_back(entry);
             }
 
             return results;
         },
     };
 }
 
 void FundTransaction(CWallet *const pwallet, CMutableTransaction &tx,
                      Amount &fee_out, int &change_position,
                      const UniValue &options, CCoinControl &coinControl) {
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
 
     change_position = -1;
     bool lockUnspents = false;
     UniValue subtractFeeFromOutputs;
     std::set<int> setSubtractFeeFromOutputs;
 
     if (!options.isNull()) {
         if (options.type() == UniValue::VBOOL) {
             // backward compatibility bool only fallback
             coinControl.fAllowWatchOnly = options.get_bool();
         } else {
             RPCTypeCheckArgument(options, UniValue::VOBJ);
             RPCTypeCheckObj(
                 options,
                 {
                     {"add_inputs", UniValueType(UniValue::VBOOL)},
                     {"add_to_wallet", UniValueType(UniValue::VBOOL)},
                     {"changeAddress", UniValueType(UniValue::VSTR)},
                     {"change_address", UniValueType(UniValue::VSTR)},
                     {"changePosition", UniValueType(UniValue::VNUM)},
                     {"change_position", UniValueType(UniValue::VNUM)},
                     {"includeWatching", UniValueType(UniValue::VBOOL)},
                     {"include_watching", UniValueType(UniValue::VBOOL)},
                     {"inputs", UniValueType(UniValue::VARR)},
                     {"lockUnspents", UniValueType(UniValue::VBOOL)},
                     {"lock_unspents", UniValueType(UniValue::VBOOL)},
                     {"locktime", UniValueType(UniValue::VNUM)},
                     // will be checked below
                     {"feeRate", UniValueType()},
                     {"fee_rate", UniValueType()},
                     {"psbt", UniValueType(UniValue::VBOOL)},
                     {"subtractFeeFromOutputs", UniValueType(UniValue::VARR)},
                     {"subtract_fee_from_outputs", UniValueType(UniValue::VARR)},
                 },
                 true, true);
 
             if (options.exists("add_inputs")) {
                 coinControl.m_add_inputs = options["add_inputs"].get_bool();
             }
 
             if (options.exists("changeAddress") ||
                 options.exists("change_address")) {
                 const std::string change_address_str =
                     (options.exists("change_address")
                          ? options["change_address"]
                          : options["changeAddress"])
                         .get_str();
                 CTxDestination dest = DecodeDestination(
                     change_address_str, pwallet->GetChainParams());
 
                 if (!IsValidDestination(dest)) {
                     throw JSONRPCError(
                         RPC_INVALID_ADDRESS_OR_KEY,
                         "Change address must be a valid bitcoin address");
                 }
 
                 coinControl.destChange = dest;
             }
 
             if (options.exists("changePosition") ||
                 options.exists("change_position")) {
                 change_position = (options.exists("change_position")
                                        ? options["change_position"]
                                        : options["changePosition"])
                                       .get_int();
             }
 
             const UniValue include_watching_option =
                 options.exists("include_watching") ? options["include_watching"]
                                                    : options["includeWatching"];
             coinControl.fAllowWatchOnly =
                 ParseIncludeWatchonly(include_watching_option, *pwallet);
 
             if (options.exists("lockUnspents") ||
                 options.exists("lock_unspents")) {
                 lockUnspents =
                     (options.exists("lock_unspents") ? options["lock_unspents"]
                                                      : options["lockUnspents"])
                         .get_bool();
             }
 
             if (options.exists("feeRate") || options.exists("fee_rate")) {
                 coinControl.m_feerate = CFeeRate(AmountFromValue(
                     options.exists("fee_rate") ? options["fee_rate"]
                                                : options["feeRate"]));
                 coinControl.fOverrideFeeRate = true;
             }
 
             if (options.exists("subtractFeeFromOutputs") ||
                 options.exists("subtract_fee_from_outputs")) {
                 subtractFeeFromOutputs =
                     (options.exists("subtract_fee_from_outputs")
                          ? options["subtract_fee_from_outputs"]
                          : options["subtractFeeFromOutputs"])
                         .get_array();
             }
         }
     } else {
         // if options is null and not a bool
         coinControl.fAllowWatchOnly =
             ParseIncludeWatchonly(NullUniValue, *pwallet);
     }
 
     if (tx.vout.size() == 0) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "TX must have at least one output");
     }
 
     if (change_position != -1 &&
         (change_position < 0 ||
          (unsigned int)change_position > tx.vout.size())) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "changePosition out of bounds");
     }
 
     for (size_t idx = 0; idx < subtractFeeFromOutputs.size(); idx++) {
         int pos = subtractFeeFromOutputs[idx].get_int();
         if (setSubtractFeeFromOutputs.count(pos)) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 strprintf("Invalid parameter, duplicated position: %d", pos));
         }
         if (pos < 0) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 strprintf("Invalid parameter, negative position: %d", pos));
         }
         if (pos >= int(tx.vout.size())) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 strprintf("Invalid parameter, position too large: %d", pos));
         }
         setSubtractFeeFromOutputs.insert(pos);
     }
 
     bilingual_str error;
 
     if (!FundTransaction(*pwallet, tx, fee_out, change_position, error,
                          lockUnspents, setSubtractFeeFromOutputs,
                          coinControl)) {
         throw JSONRPCError(RPC_WALLET_ERROR, error.original);
     }
 }
 
 static RPCHelpMan fundrawtransaction() {
     const auto &ticker = Currency::get().ticker;
     return RPCHelpMan{
         "fundrawtransaction",
         "If the transaction has no inputs, they will be automatically selected "
         "to meet its out value.\n"
         "It will add at most one change output to the outputs.\n"
         "No existing outputs will be modified unless "
         "\"subtractFeeFromOutputs\" is specified.\n"
         "Note that inputs which were signed may need to be resigned after "
         "completion since in/outputs have been added.\n"
         "The inputs added will not be signed, use signrawtransactionwithkey or "
         "signrawtransactionwithwallet for that.\n"
         "Note that all existing inputs must have their previous output "
         "transaction be in the wallet.\n"
         "Note that all inputs selected must be of standard form and P2SH "
         "scripts must be\n"
         "in the wallet using importaddress or addmultisigaddress (to calculate "
         "fees).\n"
         "You can see whether this is the case by checking the \"solvable\" "
         "field in the listunspent output.\n"
         "Only pay-to-pubkey, multisig, and P2SH versions thereof are currently "
         "supported for watch-only\n",
         {
             {"hexstring", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The hex string of the raw transaction"},
             {"options",
              RPCArg::Type::OBJ,
              RPCArg::Optional::OMITTED_NAMED_ARG,
              "for backward compatibility: passing in a true instead of an "
              "object will result in {\"includeWatching\":true}",
              {
                  {"add_inputs", RPCArg::Type::BOOL, /* default */ "true",
                   "For a transaction with existing inputs, automatically "
                   "include more if they are not enough."},
                  {"changeAddress", RPCArg::Type::STR,
                   /* default */ "pool address",
                   "The bitcoin address to receive the change"},
                  {"changePosition", RPCArg::Type::NUM, /* default */ "",
                   "The index of the change output"},
                  {"includeWatching", RPCArg::Type::BOOL,
                   /* default */ "true for watch-only wallets, otherwise false",
                   "Also select inputs which are watch only.\n"
                   "Only solvable inputs can be used. Watch-only destinations "
                   "are solvable if the public key and/or output script was "
                   "imported,\n"
                   "e.g. with 'importpubkey' or 'importmulti' with the "
                   "'pubkeys' or 'desc' field."},
                  {"lockUnspents", RPCArg::Type::BOOL, /* default */ "false",
                   "Lock selected unspent outputs"},
                  {"feeRate", RPCArg::Type::AMOUNT, /* default */
                   "not set: makes wallet determine the fee",
                   "Set a specific fee rate in " + ticker + "/kB"},
                  {
                      "subtractFeeFromOutputs",
                      RPCArg::Type::ARR,
                      /* default */ "empty array",
                      "The integers.\n"
                      "                              The fee will be equally "
                      "deducted from the amount of each specified output.\n"
                      "                              Those recipients will "
                      "receive less bitcoins than you enter in their "
                      "corresponding amount field.\n"
                      "                              If no outputs are "
                      "specified here, the sender pays the fee.",
                      {
                          {"vout_index", RPCArg::Type::NUM,
                           RPCArg::Optional::OMITTED,
                           "The zero-based output index, before a change output "
                           "is added."},
                      },
                  },
              },
              "options"},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR_HEX, "hex",
                        "The resulting raw transaction (hex-encoded string)"},
                       {RPCResult::Type::STR_AMOUNT, "fee",
                        "Fee in " + ticker + " the resulting transaction pays"},
                       {RPCResult::Type::NUM, "changepos",
                        "The position of the added change output, or -1"},
                   }},
         RPCExamples{
             "\nCreate a transaction with no inputs\n" +
             HelpExampleCli("createrawtransaction",
                            "\"[]\" \"{\\\"myaddress\\\":10000}\"") +
             "\nAdd sufficient unsigned inputs to meet the output value\n" +
             HelpExampleCli("fundrawtransaction", "\"rawtransactionhex\"") +
             "\nSign the transaction\n" +
             HelpExampleCli("signrawtransactionwithwallet",
                            "\"fundedtransactionhex\"") +
             "\nSend the transaction\n" +
             HelpExampleCli("sendrawtransaction", "\"signedtransactionhex\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             RPCTypeCheck(request.params, {UniValue::VSTR, UniValueType()});
 
             // parse hex string from parameter
             CMutableTransaction tx;
             if (!DecodeHexTx(tx, request.params[0].get_str())) {
                 throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                                    "TX decode failed");
             }
 
             Amount fee;
             int change_position;
             CCoinControl coin_control;
             // Automatically select (additional) coins. Can be overridden by
             // options.add_inputs.
             coin_control.m_add_inputs = true;
             FundTransaction(pwallet, tx, fee, change_position,
                             request.params[1], coin_control);
 
             UniValue result(UniValue::VOBJ);
             result.pushKV("hex", EncodeHexTx(CTransaction(tx)));
             result.pushKV("fee", fee);
             result.pushKV("changepos", change_position);
 
             return result;
         },
     };
 }
 
 RPCHelpMan signrawtransactionwithwallet() {
     return RPCHelpMan{
         "signrawtransactionwithwallet",
         "Sign inputs for raw transaction (serialized, hex-encoded).\n"
         "The second optional argument (may be null) is an array of previous "
         "transaction outputs that\n"
         "this transaction depends on but may not yet be in the block chain.\n" +
             HELP_REQUIRING_PASSPHRASE,
         {
             {"hexstring", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The transaction hex string"},
             {
                 "prevtxs",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::OMITTED_NAMED_ARG,
                 "The previous dependent transaction outputs",
                 {
                     {
                         "",
                         RPCArg::Type::OBJ,
                         RPCArg::Optional::OMITTED,
                         "",
                         {
                             {"txid", RPCArg::Type::STR_HEX,
                              RPCArg::Optional::NO, "The transaction id"},
                             {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO,
                              "The output number"},
                             {"scriptPubKey", RPCArg::Type::STR_HEX,
                              RPCArg::Optional::NO, "script key"},
                             {"redeemScript", RPCArg::Type::STR_HEX,
                              RPCArg::Optional::OMITTED, "(required for P2SH)"},
                             {"amount", RPCArg::Type::AMOUNT,
                              RPCArg::Optional::NO, "The amount spent"},
                         },
                     },
                 },
             },
             {"sighashtype", RPCArg::Type::STR, /* default */ "ALL|FORKID",
              "The signature hash type. Must be one of\n"
              "       \"ALL|FORKID\"\n"
              "       \"NONE|FORKID\"\n"
              "       \"SINGLE|FORKID\"\n"
              "       \"ALL|FORKID|ANYONECANPAY\"\n"
              "       \"NONE|FORKID|ANYONECANPAY\"\n"
              "       \"SINGLE|FORKID|ANYONECANPAY\""},
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::STR_HEX, "hex",
                  "The hex-encoded raw transaction with signature(s)"},
                 {RPCResult::Type::BOOL, "complete",
                  "If the transaction has a complete set of signatures"},
                 {RPCResult::Type::ARR,
                  "errors",
                  /* optional */ true,
                  "Script verification errors (if there are any)",
                  {
                      {RPCResult::Type::OBJ,
                       "",
                       "",
                       {
                           {RPCResult::Type::STR_HEX, "txid",
                            "The hash of the referenced, previous transaction"},
                           {RPCResult::Type::NUM, "vout",
                            "The index of the output to spent and used as "
                            "input"},
                           {RPCResult::Type::STR_HEX, "scriptSig",
                            "The hex-encoded signature script"},
                           {RPCResult::Type::NUM, "sequence",
                            "Script sequence number"},
                           {RPCResult::Type::STR, "error",
                            "Verification or signing error related to the "
                            "input"},
                       }},
                  }},
             }},
         RPCExamples{
             HelpExampleCli("signrawtransactionwithwallet", "\"myhex\"") +
             HelpExampleRpc("signrawtransactionwithwallet", "\"myhex\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             const CWallet *const pwallet = wallet.get();
 
             RPCTypeCheck(request.params,
                          {UniValue::VSTR, UniValue::VARR, UniValue::VSTR},
                          true);
 
             CMutableTransaction mtx;
             if (!DecodeHexTx(mtx, request.params[0].get_str())) {
                 throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                                    "TX decode failed");
             }
 
             // Sign the transaction
             LOCK(pwallet->cs_wallet);
             EnsureWalletIsUnlocked(pwallet);
 
             // Fetch previous transactions (inputs):
             std::map<COutPoint, Coin> coins;
             for (const CTxIn &txin : mtx.vin) {
                 // Create empty map entry keyed by prevout.
                 coins[txin.prevout];
             }
             pwallet->chain().findCoins(coins);
 
             // Parse the prevtxs array
             ParsePrevouts(request.params[1], nullptr, coins);
 
             SigHashType nHashType = ParseSighashString(request.params[2]);
             if (!nHashType.hasForkId()) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    "Signature must use SIGHASH_FORKID");
             }
 
             // Script verification errors
             std::map<int, std::string> input_errors;
 
             bool complete =
                 pwallet->SignTransaction(mtx, coins, nHashType, input_errors);
             UniValue result(UniValue::VOBJ);
             SignTransactionResultToJSON(mtx, complete, coins, input_errors,
                                         result);
             return result;
         },
     };
 }
 
 RPCHelpMan rescanblockchain() {
     return RPCHelpMan{
         "rescanblockchain",
         "Rescan the local blockchain for wallet related transactions.\n"
         "Note: Use \"getwalletinfo\" to query the scanning progress.\n",
         {
             {"start_height", RPCArg::Type::NUM, /* default */ "0",
              "block height where the rescan should start"},
             {"stop_height", RPCArg::Type::NUM,
              RPCArg::Optional::OMITTED_NAMED_ARG,
              "the last block height that should be scanned"},
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::NUM, "start_height",
                  "The block height where the rescan started (the requested "
                  "height or 0)"},
                 {RPCResult::Type::NUM, "stop_height",
                  "The height of the last rescanned block. May be null in rare "
                  "cases if there was a reorg and the call didn't scan any "
                  "blocks because they were already scanned in the background."},
             }},
         RPCExamples{HelpExampleCli("rescanblockchain", "100000 120000") +
                     HelpExampleRpc("rescanblockchain", "100000, 120000")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             WalletRescanReserver reserver(*pwallet);
             if (!reserver.reserve()) {
                 throw JSONRPCError(RPC_WALLET_ERROR,
                                    "Wallet is currently rescanning. Abort "
                                    "existing rescan or wait.");
             }
 
             int start_height = 0;
             std::optional<int> stop_height;
             BlockHash start_block;
             {
                 LOCK(pwallet->cs_wallet);
                 int tip_height = pwallet->GetLastBlockHeight();
 
                 if (!request.params[0].isNull()) {
                     start_height = request.params[0].get_int();
                     if (start_height < 0 || start_height > tip_height) {
                         throw JSONRPCError(RPC_INVALID_PARAMETER,
                                            "Invalid start_height");
                     }
                 }
 
                 if (!request.params[1].isNull()) {
                     stop_height = request.params[1].get_int();
                     if (*stop_height < 0 || *stop_height > tip_height) {
                         throw JSONRPCError(RPC_INVALID_PARAMETER,
                                            "Invalid stop_height");
                     } else if (*stop_height < start_height) {
                         throw JSONRPCError(
                             RPC_INVALID_PARAMETER,
                             "stop_height must be greater than start_height");
                     }
                 }
 
                 // We can't rescan beyond non-pruned blocks, stop and throw an
                 // error
                 if (!pwallet->chain().hasBlocks(pwallet->GetLastBlockHash(),
                                                 start_height, stop_height)) {
                     throw JSONRPCError(
                         RPC_MISC_ERROR,
                         "Can't rescan beyond pruned data. Use RPC call "
                         "getblockchaininfo to determine your pruned height.");
                 }
 
                 CHECK_NONFATAL(pwallet->chain().findAncestorByHeight(
                     pwallet->GetLastBlockHash(), start_height,
                     FoundBlock().hash(start_block)));
             }
 
             CWallet::ScanResult result = pwallet->ScanForWalletTransactions(
                 start_block, start_height, stop_height, reserver,
                 true /* fUpdate */);
             switch (result.status) {
                 case CWallet::ScanResult::SUCCESS:
                     break;
                 case CWallet::ScanResult::FAILURE:
                     throw JSONRPCError(
                         RPC_MISC_ERROR,
                         "Rescan failed. Potentially corrupted data files.");
                 case CWallet::ScanResult::USER_ABORT:
                     throw JSONRPCError(RPC_MISC_ERROR, "Rescan aborted.");
                     // no default case, so the compiler can warn about missing
                     // cases
             }
             UniValue response(UniValue::VOBJ);
             response.pushKV("start_height", start_height);
             response.pushKV("stop_height", result.last_scanned_height
                                                ? *result.last_scanned_height
                                                : UniValue());
             return response;
         },
     };
 }
 
 class DescribeWalletAddressVisitor : public boost::static_visitor<UniValue> {
 public:
     const SigningProvider *const provider;
 
     void ProcessSubScript(const CScript &subscript, UniValue &obj) const {
         // Always present: script type and redeemscript
         std::vector<std::vector<uint8_t>> solutions_data;
         TxoutType which_type = Solver(subscript, solutions_data);
         obj.pushKV("script", GetTxnOutputType(which_type));
         obj.pushKV("hex", HexStr(subscript));
 
         CTxDestination embedded;
         if (ExtractDestination(subscript, embedded)) {
             // Only when the script corresponds to an address.
             UniValue subobj(UniValue::VOBJ);
             UniValue detail = DescribeAddress(embedded);
             subobj.pushKVs(detail);
             UniValue wallet_detail = boost::apply_visitor(*this, embedded);
             subobj.pushKVs(wallet_detail);
             subobj.pushKV("address", EncodeDestination(embedded, GetConfig()));
             subobj.pushKV("scriptPubKey", HexStr(subscript));
             // Always report the pubkey at the top level, so that
             // `getnewaddress()['pubkey']` always works.
             if (subobj.exists("pubkey")) {
                 obj.pushKV("pubkey", subobj["pubkey"]);
             }
             obj.pushKV("embedded", std::move(subobj));
         } else if (which_type == TxoutType::MULTISIG) {
             // Also report some information on multisig scripts (which do not
             // have a corresponding address).
             // TODO: abstract out the common functionality between this logic
             // and ExtractDestinations.
             obj.pushKV("sigsrequired", solutions_data[0][0]);
             UniValue pubkeys(UniValue::VARR);
             for (size_t i = 1; i < solutions_data.size() - 1; ++i) {
                 CPubKey key(solutions_data[i].begin(), solutions_data[i].end());
                 pubkeys.push_back(HexStr(key));
             }
             obj.pushKV("pubkeys", std::move(pubkeys));
         }
     }
 
     explicit DescribeWalletAddressVisitor(const SigningProvider *_provider)
         : provider(_provider) {}
 
     UniValue operator()(const CNoDestination &dest) const {
         return UniValue(UniValue::VOBJ);
     }
 
     UniValue operator()(const PKHash &pkhash) const {
         CKeyID keyID(ToKeyID(pkhash));
         UniValue obj(UniValue::VOBJ);
         CPubKey vchPubKey;
         if (provider && provider->GetPubKey(keyID, vchPubKey)) {
             obj.pushKV("pubkey", HexStr(vchPubKey));
             obj.pushKV("iscompressed", vchPubKey.IsCompressed());
         }
         return obj;
     }
 
     UniValue operator()(const ScriptHash &scripthash) const {
         CScriptID scriptID(scripthash);
         UniValue obj(UniValue::VOBJ);
         CScript subscript;
         if (provider && provider->GetCScript(scriptID, subscript)) {
             ProcessSubScript(subscript, obj);
         }
         return obj;
     }
 };
 
 static UniValue DescribeWalletAddress(const CWallet *const pwallet,
                                       const CTxDestination &dest) {
     UniValue ret(UniValue::VOBJ);
     UniValue detail = DescribeAddress(dest);
     CScript script = GetScriptForDestination(dest);
     std::unique_ptr<SigningProvider> provider = nullptr;
     if (pwallet) {
         provider = pwallet->GetSolvingProvider(script);
     }
     ret.pushKVs(detail);
     ret.pushKVs(boost::apply_visitor(
         DescribeWalletAddressVisitor(provider.get()), dest));
     return ret;
 }
 
 /** Convert CAddressBookData to JSON record.  */
 static UniValue AddressBookDataToJSON(const CAddressBookData &data,
                                       const bool verbose) {
     UniValue ret(UniValue::VOBJ);
     if (verbose) {
         ret.pushKV("name", data.GetLabel());
     }
     ret.pushKV("purpose", data.purpose);
     return ret;
 }
 
 RPCHelpMan getaddressinfo() {
     return RPCHelpMan{
         "getaddressinfo",
         "Return information about the given bitcoin address.\n"
         "Some of the information will only be present if the address is in the "
         "active wallet.\n",
         {
             {"address", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The bitcoin address for which to get information."},
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::STR, "address",
                  "The bitcoin address validated."},
                 {RPCResult::Type::STR_HEX, "scriptPubKey",
                  "The hex-encoded scriptPubKey generated by the address."},
                 {RPCResult::Type::BOOL, "ismine", "If the address is yours."},
                 {RPCResult::Type::BOOL, "iswatchonly",
                  "If the address is watchonly."},
                 {RPCResult::Type::BOOL, "solvable",
                  "If we know how to spend coins sent to this address, ignoring "
                  "the possible lack of private keys."},
                 {RPCResult::Type::STR, "desc", /* optional */ true,
                  "A descriptor for spending coins sent to this address (only "
                  "when solvable)."},
                 {RPCResult::Type::BOOL, "isscript", "If the key is a script."},
                 {RPCResult::Type::BOOL, "ischange",
                  "If the address was used for change output."},
                 {RPCResult::Type::STR, "script", /* optional */ true,
                  "The output script type. Only if isscript is true and the "
                  "redeemscript is known. Possible\n"
                  "                                                         "
                  "types: nonstandard, pubkey, pubkeyhash, scripthash, "
                  "multisig, nulldata."},
                 {RPCResult::Type::STR_HEX, "hex", /* optional */ true,
                  "The redeemscript for the p2sh address."},
                 {RPCResult::Type::ARR,
                  "pubkeys",
                  /* optional */ true,
                  "Array of pubkeys associated with the known redeemscript "
                  "(only if script is multisig).",
                  {
                      {RPCResult::Type::STR, "pubkey", ""},
                  }},
                 {RPCResult::Type::NUM, "sigsrequired", /* optional */ true,
                  "The number of signatures required to spend multisig output "
                  "(only if script is multisig)."},
                 {RPCResult::Type::STR_HEX, "pubkey", /* optional */ true,
                  "The hex value of the raw public key for single-key addresses "
                  "(possibly embedded in P2SH)."},
                 {RPCResult::Type::OBJ,
                  "embedded",
                  /* optional */ true,
                  "Information about the address embedded in P2SH, if "
                  "relevant and known.",
                  {
                      {RPCResult::Type::ELISION, "",
                       "Includes all getaddressinfo output fields for the "
                       "embedded address excluding metadata (timestamp, "
                       "hdkeypath, hdseedid)\n"
                       "and relation to the wallet (ismine, iswatchonly)."},
                  }},
                 {RPCResult::Type::BOOL, "iscompressed", /* optional */ true,
                  "If the pubkey is compressed."},
                 {RPCResult::Type::NUM_TIME, "timestamp", /* optional */ true,
                  "The creation time of the key, if available, expressed in " +
                      UNIX_EPOCH_TIME + "."},
                 {RPCResult::Type::STR, "hdkeypath", /* optional */ true,
                  "The HD keypath, if the key is HD and available."},
                 {RPCResult::Type::STR_HEX, "hdseedid", /* optional */ true,
                  "The Hash160 of the HD seed."},
                 {RPCResult::Type::STR_HEX, "hdmasterfingerprint",
                  /* optional */ true, "The fingerprint of the master key."},
                 {RPCResult::Type::ARR,
                  "labels",
                  "Array of labels associated with the address. Currently "
                  "limited to one label but returned\n"
                  "as an array to keep the API stable if multiple labels are "
                  "enabled in the future.",
                  {
                      {RPCResult::Type::STR, "label name",
                       "Label name (defaults to \"\")."},
                  }},
             }},
         RPCExamples{HelpExampleCli("getaddressinfo", EXAMPLE_ADDRESS) +
                     HelpExampleRpc("getaddressinfo", EXAMPLE_ADDRESS)},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             const CWallet *const pwallet = wallet.get();
 
             LOCK(pwallet->cs_wallet);
 
             UniValue ret(UniValue::VOBJ);
             CTxDestination dest = DecodeDestination(request.params[0].get_str(),
                                                     wallet->GetChainParams());
             // Make sure the destination is valid
             if (!IsValidDestination(dest)) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                    "Invalid address");
             }
 
             std::string currentAddress = EncodeDestination(dest, config);
             ret.pushKV("address", currentAddress);
 
             CScript scriptPubKey = GetScriptForDestination(dest);
             ret.pushKV("scriptPubKey", HexStr(scriptPubKey));
 
             std::unique_ptr<SigningProvider> provider =
                 pwallet->GetSolvingProvider(scriptPubKey);
 
             isminetype mine = pwallet->IsMine(dest);
             ret.pushKV("ismine", bool(mine & ISMINE_SPENDABLE));
 
             bool solvable = provider && IsSolvable(*provider, scriptPubKey);
             ret.pushKV("solvable", solvable);
 
             if (solvable) {
                 ret.pushKV(
                     "desc",
                     InferDescriptor(scriptPubKey, *provider)->ToString());
             }
 
             ret.pushKV("iswatchonly", bool(mine & ISMINE_WATCH_ONLY));
 
             UniValue detail = DescribeWalletAddress(pwallet, dest);
             ret.pushKVs(detail);
 
             ret.pushKV("ischange", ScriptIsChange(*pwallet, scriptPubKey));
 
             ScriptPubKeyMan *spk_man =
                 pwallet->GetScriptPubKeyMan(scriptPubKey);
             if (spk_man) {
                 if (const std::unique_ptr<CKeyMetadata> meta =
                         spk_man->GetMetadata(dest)) {
                     ret.pushKV("timestamp", meta->nCreateTime);
                     if (meta->has_key_origin) {
                         ret.pushKV("hdkeypath",
                                    WriteHDKeypath(meta->key_origin.path));
                         ret.pushKV("hdseedid", meta->hd_seed_id.GetHex());
                         ret.pushKV("hdmasterfingerprint",
                                    HexStr(meta->key_origin.fingerprint));
                     }
                 }
             }
 
             // Return a `labels` array containing the label associated with the
             // address, equivalent to the `label` field above. Currently only
             // one label can be associated with an address, but we return an
             // array so the API remains stable if we allow multiple labels to be
             // associated with an address in the future.
             UniValue labels(UniValue::VARR);
             const auto *address_book_entry =
                 pwallet->FindAddressBookEntry(dest);
             if (address_book_entry) {
                 labels.push_back(address_book_entry->GetLabel());
             }
             ret.pushKV("labels", std::move(labels));
 
             return ret;
         },
     };
 }
 
 RPCHelpMan getaddressesbylabel() {
     return RPCHelpMan{
         "getaddressesbylabel",
         "Returns the list of addresses assigned the specified label.\n",
         {
             {"label", RPCArg::Type::STR, RPCArg::Optional::NO, "The label."},
         },
         RPCResult{RPCResult::Type::OBJ_DYN,
                   "",
                   "json object with addresses as keys",
                   {
                       {RPCResult::Type::OBJ,
                        "address",
                        "Information about address",
                        {
                            {RPCResult::Type::STR, "purpose",
                             "Purpose of address (\"send\" for sending address, "
                             "\"receive\" for receiving address)"},
                        }},
                   }},
         RPCExamples{HelpExampleCli("getaddressesbylabel", "\"tabby\"") +
                     HelpExampleRpc("getaddressesbylabel", "\"tabby\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             const CWallet *const pwallet = wallet.get();
 
             LOCK(pwallet->cs_wallet);
 
             std::string label = LabelFromValue(request.params[0]);
 
             // Find all addresses that have the given label
             UniValue ret(UniValue::VOBJ);
             std::set<std::string> addresses;
             for (const std::pair<const CTxDestination, CAddressBookData> &item :
                  pwallet->m_address_book) {
                 if (item.second.IsChange()) {
                     continue;
                 }
                 if (item.second.GetLabel() == label) {
                     std::string address = EncodeDestination(item.first, config);
                     // CWallet::m_address_book is not expected to contain
                     // duplicate address strings, but build a separate set as a
                     // precaution just in case it does.
                     CHECK_NONFATAL(addresses.emplace(address).second);
                     // UniValue::pushKV checks if the key exists in O(N)
                     // and since duplicate addresses are unexpected (checked
                     // with std::set in O(log(N))), UniValue::__pushKV is used
                     // instead, which currently is O(1).
                     ret.__pushKV(address,
                                  AddressBookDataToJSON(item.second, false));
                 }
             }
 
             if (ret.empty()) {
                 throw JSONRPCError(
                     RPC_WALLET_INVALID_LABEL_NAME,
                     std::string("No addresses with label " + label));
             }
 
             return ret;
         },
     };
 }
 
 RPCHelpMan listlabels() {
     return RPCHelpMan{
         "listlabels",
         "Returns the list of all labels, or labels that are assigned to "
         "addresses with a specific purpose.\n",
         {
             {"purpose", RPCArg::Type::STR, RPCArg::Optional::OMITTED_NAMED_ARG,
              "Address purpose to list labels for ('send','receive'). An empty "
              "string is the same as not providing this argument."},
         },
         RPCResult{RPCResult::Type::ARR,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR, "label", "Label name"},
                   }},
         RPCExamples{"\nList all labels\n" + HelpExampleCli("listlabels", "") +
                     "\nList labels that have receiving addresses\n" +
                     HelpExampleCli("listlabels", "receive") +
                     "\nList labels that have sending addresses\n" +
                     HelpExampleCli("listlabels", "send") +
                     "\nAs a JSON-RPC call\n" +
                     HelpExampleRpc("listlabels", "receive")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             const CWallet *const pwallet = wallet.get();
 
             LOCK(pwallet->cs_wallet);
 
             std::string purpose;
             if (!request.params[0].isNull()) {
                 purpose = request.params[0].get_str();
             }
 
             // Add to a set to sort by label name, then insert into Univalue
             // array
             std::set<std::string> label_set;
             for (const std::pair<const CTxDestination, CAddressBookData>
                      &entry : pwallet->m_address_book) {
                 if (entry.second.IsChange()) {
                     continue;
                 }
                 if (purpose.empty() || entry.second.purpose == purpose) {
                     label_set.insert(entry.second.GetLabel());
                 }
             }
 
             UniValue ret(UniValue::VARR);
             for (const std::string &name : label_set) {
                 ret.push_back(name);
             }
 
             return ret;
         },
     };
 }
 
 static RPCHelpMan send() {
     return RPCHelpMan{
         "send",
         "EXPERIMENTAL warning: this call may be changed in future releases.\n"
         "\nSend a transaction.\n",
         {
             {
                 "outputs",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::NO,
                 "A JSON array with outputs (key-value pairs), where none of "
                 "the keys are duplicated.\n"
                 "That is, each address can only appear once and there can only "
                 "be one 'data' object.\n"
                 "For convenience, a dictionary, which holds the key-value "
                 "pairs directly, is also accepted.",
                 {
                     {
                         "",
                         RPCArg::Type::OBJ,
                         RPCArg::Optional::OMITTED,
                         "",
                         {
                             {"address", RPCArg::Type::AMOUNT,
                              RPCArg::Optional::NO,
                              "A key-value pair. The key (string) is the "
                              "bitcoin address, the value (float or string) is "
                              "the amount in " +
                                  Currency::get().ticker + ""},
                         },
                     },
                     {
                         "",
                         RPCArg::Type::OBJ,
                         RPCArg::Optional::OMITTED,
                         "",
                         {
                             {"data", RPCArg::Type::STR_HEX,
                              RPCArg::Optional::NO,
                              "A key-value pair. The key must be \"data\", the "
                              "value is hex-encoded data"},
                         },
                     },
                 },
             },
             {"options",
              RPCArg::Type::OBJ,
              RPCArg::Optional::OMITTED_NAMED_ARG,
              "",
              {
                  {"add_inputs", RPCArg::Type::BOOL, /* default */ "false",
                   "If inputs are specified, automatically include more if they "
                   "are not enough."},
                  {"add_to_wallet", RPCArg::Type::BOOL, /* default */ "true",
                   "When false, returns a serialized transaction which will not "
                   "be added to the wallet or broadcast"},
                  {"change_address", RPCArg::Type::STR_HEX,
                   /* default */ "pool address",
                   "The bitcoin address to receive the change"},
                  {"change_position", RPCArg::Type::NUM, /* default */ "random",
                   "The index of the change output"},
                  {"fee_rate", RPCArg::Type::AMOUNT, /* default */
                   "not set: makes wallet determine the fee",
                   "Set a specific fee rate in " + Currency::get().ticker +
                       "/kB"},
                  {"include_watching", RPCArg::Type::BOOL,
                   /* default */ "true for watch-only wallets, otherwise false",
                   "Also select inputs which are watch only.\n"
                   "Only solvable inputs can be used. Watch-only destinations "
                   "are solvable if the public key and/or output script was "
                   "imported,\n"
                   "e.g. with 'importpubkey' or 'importmulti' with the "
                   "'pubkeys' or 'desc' field."},
                  {
                      "inputs",
                      RPCArg::Type::ARR,
                      /* default */ "empty array",
                      "Specify inputs instead of adding them automatically. A "
                      "JSON array of JSON objects",
                      {
                          {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
                           "The transaction id"},
                          {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO,
                           "The output number"},
                          {"sequence", RPCArg::Type::NUM, RPCArg::Optional::NO,
                           "The sequence number"},
                      },
                  },
                  {"locktime", RPCArg::Type::NUM, /* default */ "0",
                   "Raw locktime. Non-0 value also locktime-activates inputs"},
                  {"lock_unspents", RPCArg::Type::BOOL, /* default */ "false",
                   "Lock selected unspent outputs"},
                  {"psbt", RPCArg::Type::BOOL, /* default */ "automatic",
                   "Always return a PSBT, implies add_to_wallet=false."},
                  {
                      "subtract_fee_from_outputs",
                      RPCArg::Type::ARR,
                      /* default */ "empty array",
                      "Outputs to subtract the fee from, specified as integer "
                      "indices.\n"
                      "The fee will be equally deducted from the amount of each "
                      "specified output.\n"
                      "Those recipients will receive less bitcoins than you "
                      "enter in their corresponding amount field.\n"
                      "If no outputs are specified here, the sender pays the "
                      "fee.",
                      {
                          {"vout_index", RPCArg::Type::NUM,
                           RPCArg::Optional::OMITTED,
                           "The zero-based output index, before a change output "
                           "is added."},
                      },
                  },
              },
              "options"},
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {{RPCResult::Type::BOOL, "complete",
               "If the transaction has a complete set of signatures"},
              {RPCResult::Type::STR_HEX, "txid",
               "The transaction id for the send. Only 1 transaction is created "
               "regardless of the number of addresses."},
              {RPCResult::Type::STR_HEX, "hex",
               "If add_to_wallet is false, the hex-encoded raw transaction with "
               "signature(s)"},
              {RPCResult::Type::STR, "psbt",
               "If more signatures are needed, or if add_to_wallet is false, "
               "the base64-encoded (partially) signed transaction"}}},
         RPCExamples{
             ""
             "\nSend with a fee rate of 10 XEC/kB\n" +
             HelpExampleCli("send", "'{\"" + EXAMPLE_ADDRESS +
                                        "\": 100000}' '{\"fee_rate\": 10}'\n") +
             "\nCreate a transaction with a specific input, and return "
             "result without adding to wallet or broadcasting to the "
             "network\n" +
             HelpExampleCli("send",
                            "'{\"" + EXAMPLE_ADDRESS +
                                "\": 100000}' '{\"add_to_wallet\": "
                                "false, \"inputs\": "
                                "[{\"txid\":"
                                "\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b565"
                                "5e72f463568df1aadf0\", \"vout\":1}]}'")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             RPCTypeCheck(request.params,
                          {// ARR or OBJ, checked later
                           UniValueType(), UniValue::VOBJ},
                          true);
 
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             UniValue options = request.params[1];
             if (options.exists("changeAddress")) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER, "Use change_address");
             }
             if (options.exists("changePosition")) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    "Use change_position");
             }
             if (options.exists("includeWatching")) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    "Use include_watching");
             }
             if (options.exists("lockUnspents")) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER, "Use lock_unspents");
             }
             if (options.exists("subtractFeeFromOutputs")) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    "Use subtract_fee_from_outputs");
             }
             if (options.exists("feeRate")) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER, "Use fee_rate");
             }
 
             const bool psbt_opt_in =
                 options.exists("psbt") && options["psbt"].get_bool();
 
             Amount fee;
             int change_position;
             CMutableTransaction rawTx = ConstructTransaction(
                 wallet->GetChainParams(), options["inputs"], request.params[0],
                 options["locktime"]);
             CCoinControl coin_control;
             // Automatically select coins, unless at least one is manually
             // selected. Can be overridden by options.add_inputs.
             coin_control.m_add_inputs = rawTx.vin.size() == 0;
             FundTransaction(pwallet, rawTx, fee, change_position, options,
                             coin_control);
 
             bool add_to_wallet = true;
             if (options.exists("add_to_wallet")) {
                 add_to_wallet = options["add_to_wallet"].get_bool();
             }
 
             // Make a blank psbt
             PartiallySignedTransaction psbtx(rawTx);
 
             // Fill transaction with our data and sign
             bool complete = true;
             const TransactionError err = pwallet->FillPSBT(
                 psbtx, complete, SigHashType().withForkId(), true, false);
             if (err != TransactionError::OK) {
                 throw JSONRPCTransactionError(err);
             }
 
             CMutableTransaction mtx;
             complete = FinalizeAndExtractPSBT(psbtx, mtx);
 
             UniValue result(UniValue::VOBJ);
 
             if (psbt_opt_in || !complete || !add_to_wallet) {
                 // Serialize the PSBT
                 CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
                 ssTx << psbtx;
                 result.pushKV("psbt", EncodeBase64(ssTx.str()));
             }
 
             if (complete) {
                 std::string err_string;
                 std::string hex = EncodeHexTx(CTransaction(mtx));
                 CTransactionRef tx(MakeTransactionRef(std::move(mtx)));
                 result.pushKV("txid", tx->GetHash().GetHex());
                 if (add_to_wallet && !psbt_opt_in) {
                     pwallet->CommitTransaction(tx, {}, {} /* orderForm */);
                 } else {
                     result.pushKV("hex", hex);
                 }
             }
             result.pushKV("complete", complete);
 
             return result;
         }};
 }
 
 static RPCHelpMan sethdseed() {
     return RPCHelpMan{
         "sethdseed",
         "Set or generate a new HD wallet seed. Non-HD wallets will not be "
         "upgraded to being a HD wallet. Wallets that are already\n"
         "HD will have a new HD seed set so that new keys added to the keypool "
         "will be derived from this new seed.\n"
         "\nNote that you will need to MAKE A NEW BACKUP of your wallet after "
         "setting the HD wallet seed.\n" +
             HELP_REQUIRING_PASSPHRASE,
         {
             {"newkeypool", RPCArg::Type::BOOL, /* default */ "true",
              "Whether to flush old unused addresses, including change "
              "addresses, from the keypool and regenerate it.\n"
              "                             If true, the next address from "
              "getnewaddress and change address from getrawchangeaddress will "
              "be from this new seed.\n"
              "                             If false, addresses (including "
              "change addresses if the wallet already had HD Chain Split "
              "enabled) from the existing\n"
              "                             keypool will be used until it has "
              "been depleted."},
             {"seed", RPCArg::Type::STR, /* default */ "random seed",
              "The WIF private key to use as the new HD seed.\n"
              "                             The seed value can be retrieved "
              "using the dumpwallet command. It is the private key marked "
              "hdseed=1"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("sethdseed", "") +
                     HelpExampleCli("sethdseed", "false") +
                     HelpExampleCli("sethdseed", "true \"wifkey\"") +
                     HelpExampleRpc("sethdseed", "true, \"wifkey\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             LegacyScriptPubKeyMan &spk_man =
                 EnsureLegacyScriptPubKeyMan(*pwallet, true);
 
             if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
                 throw JSONRPCError(RPC_WALLET_ERROR,
                                    "Cannot set a HD seed to a wallet with "
                                    "private keys disabled");
             }
 
             LOCK2(pwallet->cs_wallet, spk_man.cs_KeyStore);
 
             // Do not do anything to non-HD wallets
             if (!pwallet->CanSupportFeature(FEATURE_HD)) {
                 throw JSONRPCError(
                     RPC_WALLET_ERROR,
                     "Cannot set a HD seed on a non-HD wallet. Use the "
                     "upgradewallet RPC in order to upgrade a non-HD wallet "
                     "to HD");
             }
 
             EnsureWalletIsUnlocked(pwallet);
 
             bool flush_key_pool = true;
             if (!request.params[0].isNull()) {
                 flush_key_pool = request.params[0].get_bool();
             }
 
             CPubKey master_pub_key;
             if (request.params[1].isNull()) {
                 master_pub_key = spk_man.GenerateNewSeed();
             } else {
                 CKey key = DecodeSecret(request.params[1].get_str());
                 if (!key.IsValid()) {
                     throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                        "Invalid private key");
                 }
 
                 if (HaveKey(spk_man, key)) {
                     throw JSONRPCError(
                         RPC_INVALID_ADDRESS_OR_KEY,
                         "Already have this key (either as an HD seed or "
                         "as a loose private key)");
                 }
 
                 master_pub_key = spk_man.DeriveNewSeed(key);
             }
 
             spk_man.SetHDSeed(master_pub_key);
             if (flush_key_pool) {
                 spk_man.NewKeyPool();
             }
 
             return NullUniValue;
         },
     };
 }
 
 static RPCHelpMan walletprocesspsbt() {
     return RPCHelpMan{
         "walletprocesspsbt",
         "Update a PSBT with input information from our wallet and then sign "
         "inputs that we can sign for." +
             HELP_REQUIRING_PASSPHRASE,
         {
             {"psbt", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The transaction base64 string"},
             {"sign", RPCArg::Type::BOOL, /* default */ "true",
              "Also sign the transaction when updating"},
             {"sighashtype", RPCArg::Type::STR, /* default */ "ALL|FORKID",
              "The signature hash type to sign with if not specified by "
              "the PSBT. Must be one of\n"
              "       \"ALL|FORKID\"\n"
              "       \"NONE|FORKID\"\n"
              "       \"SINGLE|FORKID\"\n"
              "       \"ALL|FORKID|ANYONECANPAY\"\n"
              "       \"NONE|FORKID|ANYONECANPAY\"\n"
              "       \"SINGLE|FORKID|ANYONECANPAY\""},
             {"bip32derivs", RPCArg::Type::BOOL, /* default */ "true",
              "Includes the BIP 32 derivation paths for public keys if we know "
              "them"},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR, "psbt",
                        "The base64-encoded partially signed transaction"},
                       {RPCResult::Type::BOOL, "complete",
                        "If the transaction has a complete set of signatures"},
                   }},
         RPCExamples{HelpExampleCli("walletprocesspsbt", "\"psbt\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             const CWallet *const pwallet = wallet.get();
 
             RPCTypeCheck(request.params,
                          {UniValue::VSTR, UniValue::VBOOL, UniValue::VSTR});
 
             // Unserialize the transaction
             PartiallySignedTransaction psbtx;
             std::string error;
             if (!DecodeBase64PSBT(psbtx, request.params[0].get_str(), error)) {
                 throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                                    strprintf("TX decode failed %s", error));
             }
 
             // Get the sighash type
             SigHashType nHashType = ParseSighashString(request.params[2]);
             if (!nHashType.hasForkId()) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    "Signature must use SIGHASH_FORKID");
             }
 
             // Fill transaction with our data and also sign
             bool sign = request.params[1].isNull()
                             ? true
                             : request.params[1].get_bool();
             bool bip32derivs = request.params[3].isNull()
                                    ? true
                                    : request.params[3].get_bool();
             bool complete = true;
             const TransactionError err = pwallet->FillPSBT(
                 psbtx, complete, nHashType, sign, bip32derivs);
             if (err != TransactionError::OK) {
                 throw JSONRPCTransactionError(err);
             }
 
             UniValue result(UniValue::VOBJ);
             CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
             ssTx << psbtx;
             result.pushKV("psbt", EncodeBase64(ssTx.str()));
             result.pushKV("complete", complete);
 
             return result;
         },
     };
 }
 
 static RPCHelpMan walletcreatefundedpsbt() {
     const auto &ticker = Currency::get().ticker;
     return RPCHelpMan{
         "walletcreatefundedpsbt",
         "Creates and funds a transaction in the Partially Signed Transaction "
         "format.\n"
         "Implements the Creator and Updater roles.\n",
         {
             {
                 "inputs",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::OMITTED_NAMED_ARG,
                 "Leave empty to add inputs automatically. See add_inputs "
                 "option.",
                 {
                     {
                         "",
                         RPCArg::Type::OBJ,
                         RPCArg::Optional::OMITTED,
                         "",
                         {
                             {"txid", RPCArg::Type::STR_HEX,
                              RPCArg::Optional::NO, "The transaction id"},
                             {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO,
                              "The output number"},
                             {"sequence", RPCArg::Type::NUM,
                              /* default */
                              "depends on the value of the 'locktime' and "
                              "'options.replaceable' arguments",
                              "The sequence number"},
                         },
                     },
                 },
             },
             {
                 "outputs",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::NO,
                 "The outputs (key-value pairs), where none of "
                 "the keys are duplicated.\n"
                 "That is, each address can only appear once and there can only "
                 "be one 'data' object.\n"
                 "For compatibility reasons, a dictionary, which holds the "
                 "key-value pairs directly, is also\n"
                 "                             accepted as second parameter.",
                 {
                     {
                         "",
                         RPCArg::Type::OBJ,
                         RPCArg::Optional::OMITTED,
                         "",
                         {
                             {"address", RPCArg::Type::AMOUNT,
                              RPCArg::Optional::NO,
                              "A key-value pair. The key (string) is the "
                              "bitcoin address, the value (float or string) is "
                              "the amount in " +
                                  ticker + ""},
                         },
                     },
                     {
                         "",
                         RPCArg::Type::OBJ,
                         RPCArg::Optional::OMITTED,
                         "",
                         {
                             {"data", RPCArg::Type::STR_HEX,
                              RPCArg::Optional::NO,
                              "A key-value pair. The key must be \"data\", the "
                              "value is hex-encoded data"},
                         },
                     },
                 },
             },
             {"locktime", RPCArg::Type::NUM, /* default */ "0",
              "Raw locktime. Non-0 value also locktime-activates inputs\n"
              "                             Allows this transaction to be "
              "replaced by a transaction with higher fees. If provided, it is "
              "an error if explicit sequence numbers are incompatible."},
             {"options",
              RPCArg::Type::OBJ,
              RPCArg::Optional::OMITTED_NAMED_ARG,
              "",
              {
                  {"add_inputs", RPCArg::Type::BOOL, /* default */ "false",
                   "If inputs are specified, automatically include more if they "
                   "are not enough."},
                  {"changeAddress", RPCArg::Type::STR_HEX,
                   /* default */ "pool address",
                   "The bitcoin address to receive the change"},
                  {"changePosition", RPCArg::Type::NUM,
                   /* default */ "random", "The index of the change output"},
                  {"includeWatching", RPCArg::Type::BOOL,
                   /* default */ "true for watch-only wallets, otherwise false",
                   "Also select inputs which are watch only"},
                  {"lockUnspents", RPCArg::Type::BOOL, /* default */ "false",
                   "Lock selected unspent outputs"},
                  {"feeRate", RPCArg::Type::AMOUNT, /* default */
                   "not set: makes wallet determine the fee",
                   "Set a specific fee rate in " + ticker + "/kB"},
                  {
                      "subtractFeeFromOutputs",
                      RPCArg::Type::ARR,
                      /* default */ "empty array",
                      "The outputs to subtract the fee from.\n"
                      "                              The fee will be equally "
                      "deducted from the amount of each specified output.\n"
                      "                              Those recipients will "
                      "receive less bitcoins than you enter in their "
                      "corresponding amount field.\n"
                      "                              If no outputs are "
                      "specified here, the sender pays the fee.",
                      {
                          {"vout_index", RPCArg::Type::NUM,
                           RPCArg::Optional::OMITTED,
                           "The zero-based output index, before a change output "
                           "is added."},
                      },
                  },
              },
              "options"},
             {"bip32derivs", RPCArg::Type::BOOL, /* default */ "true",
              "Includes the BIP 32 derivation paths for public keys if we know "
              "them"},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR, "psbt",
                        "The resulting raw transaction (base64-encoded string)"},
                       {RPCResult::Type::STR_AMOUNT, "fee",
                        "Fee in " + ticker + " the resulting transaction pays"},
                       {RPCResult::Type::NUM, "changepos",
                        "The position of the added change output, or -1"},
                   }},
         RPCExamples{
             "\nCreate a transaction with no inputs\n" +
             HelpExampleCli("walletcreatefundedpsbt",
                            "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\" "
                            "\"[{\\\"data\\\":\\\"00010203\\\"}]\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             RPCTypeCheck(request.params,
                          {UniValue::VARR,
                           UniValueType(), // ARR or OBJ, checked later
                           UniValue::VNUM, UniValue::VOBJ},
                          true);
 
             Amount fee;
             int change_position;
             CMutableTransaction rawTx = ConstructTransaction(
                 wallet->GetChainParams(), request.params[0], request.params[1],
                 request.params[2]);
             CCoinControl coin_control;
             // Automatically select coins, unless at least one is manually
             // selected. Can be overridden by options.add_inputs.
             coin_control.m_add_inputs = rawTx.vin.size() == 0;
             FundTransaction(pwallet, rawTx, fee, change_position,
                             request.params[3], coin_control);
 
             // Make a blank psbt
             PartiallySignedTransaction psbtx(rawTx);
 
             // Fill transaction with out data but don't sign
             bool bip32derivs = request.params[4].isNull()
                                    ? true
                                    : request.params[4].get_bool();
             bool complete = true;
             const TransactionError err =
                 pwallet->FillPSBT(psbtx, complete, SigHashType().withForkId(),
                                   false, bip32derivs);
             if (err != TransactionError::OK) {
                 throw JSONRPCTransactionError(err);
             }
 
             // Serialize the PSBT
             CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
             ssTx << psbtx;
 
             UniValue result(UniValue::VOBJ);
             result.pushKV("psbt", EncodeBase64(ssTx.str()));
             result.pushKV("fee", fee);
             result.pushKV("changepos", change_position);
             return result;
         },
     };
 }
 
 static RPCHelpMan upgradewallet() {
     return RPCHelpMan{
         "upgradewallet",
         "Upgrade the wallet. Upgrades to the latest version if no "
         "version number is specified\n"
         "New keys may be generated and a new wallet backup will need to "
         "be made.",
         {{"version", RPCArg::Type::NUM,
           /* default */ strprintf("%d", FEATURE_LATEST),
           "The version number to upgrade to. Default is the latest "
           "wallet version"}},
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("upgradewallet", "200300") +
                     HelpExampleRpc("upgradewallet", "200300")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             RPCTypeCheck(request.params, {UniValue::VNUM}, true);
 
             EnsureWalletIsUnlocked(pwallet);
 
             int version = 0;
             if (!request.params[0].isNull()) {
                 version = request.params[0].get_int();
             }
             bilingual_str error;
             if (!pwallet->UpgradeWallet(version, error)) {
                 throw JSONRPCError(RPC_WALLET_ERROR, error.original);
             }
             return error.original;
         },
     };
 }
 
 RPCHelpMan signmessage();
 
 static RPCHelpMan createwallettransaction() {
     return RPCHelpMan{
         "createwallettransaction",
         "Create a transaction sending an amount to a given address.\n" +
             HELP_REQUIRING_PASSPHRASE,
         {
             {"address", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The bitcoin address to send to."},
             {"amount", RPCArg::Type::AMOUNT, RPCArg::Optional::NO,
              "The amount in " + Currency::get().ticker + " to send. eg 0.1"},
         },
         RPCResult{RPCResult::Type::STR_HEX, "txid", "The transaction id."},
         RPCExamples{
             HelpExampleCli("createwallettransaction",
                            "\"1M72Sfpbz1BPpXFHz9m3CdqATR44Jvaydd\" 100000") +
             HelpExampleRpc("createwallettransaction",
                            "\"1M72Sfpbz1BPpXFHz9m3CdqATR44Jvaydd\", 100000")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             // Make sure the results are valid at least up to the most recent
             // block the user could have gotten from another RPC command prior
             // to now
             pwallet->BlockUntilSyncedToCurrentChain();
 
             LOCK(pwallet->cs_wallet);
 
             EnsureWalletIsUnlocked(pwallet);
 
             UniValue address_amounts(UniValue::VOBJ);
             const std::string address = request.params[0].get_str();
             address_amounts.pushKV(address, request.params[1]);
             UniValue subtractFeeFromAmount(UniValue::VARR);
 
             std::vector<CRecipient> recipients;
             ParseRecipients(address_amounts, subtractFeeFromAmount, recipients,
                             wallet->GetChainParams());
 
             CCoinControl coin_control;
             return SendMoney(pwallet, coin_control, recipients, {}, false);
         },
     };
 }
 
 Span<const CRPCCommand> GetWalletRPCCommands() {
     // clang-format off
     static const CRPCCommand commands[] = {
         //  category            actor (function)
         //  ------------------  ----------------------
         { "rawtransactions",    fundrawtransaction,            },
         { "wallet",             abandontransaction,            },
         { "wallet",             addmultisigaddress,            },
         { "wallet",             createwallet,                  },
         { "wallet",             getaddressesbylabel,           },
         { "wallet",             getaddressinfo,                },
         { "wallet",             getbalance,                    },
         { "wallet",             getnewaddress,                 },
         { "wallet",             getrawchangeaddress,           },
         { "wallet",             getreceivedbyaddress,          },
         { "wallet",             getreceivedbylabel,            },
         { "wallet",             gettransaction,                },
         { "wallet",             getunconfirmedbalance,         },
         { "wallet",             getbalances,                   },
         { "wallet",             getwalletinfo,                 },
         { "wallet",             keypoolrefill,                 },
         { "wallet",             listaddressgroupings,          },
         { "wallet",             listlabels,                    },
         { "wallet",             listlockunspent,               },
         { "wallet",             listreceivedbyaddress,         },
         { "wallet",             listreceivedbylabel,           },
         { "wallet",             listsinceblock,                },
         { "wallet",             listtransactions,              },
         { "wallet",             listunspent,                   },
         { "wallet",             listwalletdir,                 },
         { "wallet",             listwallets,                   },
         { "wallet",             loadwallet,                    },
         { "wallet",             lockunspent,                   },
         { "wallet",             rescanblockchain,              },
         { "wallet",             send,                          },
         { "wallet",             sendmany,                      },
         { "wallet",             sendtoaddress,                 },
         { "wallet",             sethdseed,                     },
         { "wallet",             setlabel,                      },
         { "wallet",             settxfee,                      },
         { "wallet",             setwalletflag,                 },
         { "wallet",             signmessage,                   },
         { "wallet",             signrawtransactionwithwallet,  },
         { "wallet",             unloadwallet,                  },
         { "wallet",             upgradewallet,                 },
         { "wallet",             walletcreatefundedpsbt,        },
         { "wallet",             walletprocesspsbt,             },
         // For testing purpose
         { "hidden",             createwallettransaction,       },
     };
     // clang-format on
 
     return MakeSpan(commands);
 }
diff --git a/src/wallet/spend.cpp b/src/wallet/spend.cpp
index 50024333d..963d31180 100644
--- a/src/wallet/spend.cpp
+++ b/src/wallet/spend.cpp
@@ -1,1060 +1,1048 @@
 // Copyright (c) 2021 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 <wallet/spend.h>
 
 #include <consensus/validation.h>
 #include <interfaces/chain.h>
 #include <policy/policy.h>
 #include <util/check.h>
 #include <util/moneystr.h>
 #include <util/translation.h>
 #include <wallet/coincontrol.h>
 #include <wallet/fees.h>
 #include <wallet/receive.h>
 #include <wallet/transaction.h>
 #include <wallet/wallet.h>
 
 using interfaces::FoundBlock;
 
 static const size_t OUTPUT_GROUP_MAX_ENTRIES = 10;
 
 int GetTxSpendSize(const CWallet &wallet, const CWalletTx &wtx,
                    unsigned int out, bool use_max_sig) {
     return CalculateMaximumSignedInputSize(wtx.tx->vout[out], &wallet,
                                            use_max_sig);
 }
 std::string COutput::ToString() const {
     return strprintf("COutput(%s, %d, %d) [%s]", tx->GetId().ToString(), i,
                      nDepth, FormatMoney(tx->tx->vout[i].nValue));
 }
 
 int CalculateMaximumSignedInputSize(const CTxOut &txout, const CWallet *wallet,
                                     bool use_max_sig) {
     CMutableTransaction txn;
     txn.vin.push_back(CTxIn(COutPoint()));
     if (!wallet->DummySignInput(txn.vin[0], txout, use_max_sig)) {
         return -1;
     }
     return GetSerializeSize(txn.vin[0], PROTOCOL_VERSION);
 }
 
 // txouts needs to be in the order of tx.vin
 int64_t CalculateMaximumSignedTxSize(const CTransaction &tx,
                                      const CWallet *wallet,
                                      const std::vector<CTxOut> &txouts,
                                      bool use_max_sig) {
     CMutableTransaction txNew(tx);
     if (!wallet->DummySignTx(txNew, txouts, use_max_sig)) {
         return -1;
     }
     return GetSerializeSize(txNew, PROTOCOL_VERSION);
 }
 
 int64_t CalculateMaximumSignedTxSize(const CTransaction &tx,
                                      const CWallet *wallet, bool use_max_sig) {
     std::vector<CTxOut> txouts;
     for (auto &input : tx.vin) {
         const auto mi = wallet->mapWallet.find(input.prevout.GetTxId());
         // Can not estimate size without knowing the input details
         if (mi == wallet->mapWallet.end()) {
             return -1;
         }
         assert(input.prevout.GetN() < mi->second.tx->vout.size());
         txouts.emplace_back(mi->second.tx->vout[input.prevout.GetN()]);
     }
     return CalculateMaximumSignedTxSize(tx, wallet, txouts, use_max_sig);
 }
 
 void AvailableCoins(const CWallet &wallet, std::vector<COutput> &vCoins,
                     bool fOnlySafe, const CCoinControl *coinControl,
                     const Amount nMinimumAmount, const Amount nMaximumAmount,
                     const Amount nMinimumSumAmount,
                     const uint64_t nMaximumCount) {
     AssertLockHeld(wallet.cs_wallet);
 
     vCoins.clear();
     Amount nTotal = Amount::zero();
     // Either the WALLET_FLAG_AVOID_REUSE flag is not set (in which case we
     // always allow), or we default to avoiding, and only in the case where a
     // coin control object is provided, and has the avoid address reuse flag set
     // to false, do we allow already used addresses
     bool allow_used_addresses =
         !wallet.IsWalletFlagSet(WALLET_FLAG_AVOID_REUSE) ||
         (coinControl && !coinControl->m_avoid_address_reuse);
     const int min_depth = {coinControl ? coinControl->m_min_depth
                                        : DEFAULT_MIN_DEPTH};
     const int max_depth = {coinControl ? coinControl->m_max_depth
                                        : DEFAULT_MAX_DEPTH};
 
     std::set<TxId> trusted_parents;
     for (const auto &entry : wallet.mapWallet) {
         const TxId &wtxid = entry.first;
         const CWalletTx &wtx = entry.second;
 
         if (wallet.IsTxImmatureCoinBase(wtx)) {
             continue;
         }
 
         int nDepth = wallet.GetTxDepthInMainChain(wtx);
         if (nDepth < 0) {
             continue;
         }
 
         // We should not consider coins which aren't at least in our mempool.
         // It's possible for these to be conflicted via ancestors which we may
         // never be able to detect.
         if (nDepth == 0 && !wtx.InMempool()) {
             continue;
         }
 
         bool safeTx = CachedTxIsTrusted(wallet, wtx, trusted_parents);
 
         // Bitcoin-ABC: Removed check that prevents consideration of coins from
         // transactions that are replacing other transactions. This check based
         // on wtx.mapValue.count("replaces_txid") which was not being set
         // anywhere.
 
         // Similarly, we should not consider coins from transactions that have
         // been replaced. In the example above, we would want to prevent
         // creation of a transaction A' spending an output of A, because if
         // transaction B were initially confirmed, conflicting with A and A', we
         // wouldn't want to the user to create a transaction D intending to
         // replace A', but potentially resulting in a scenario where A, A', and
         // D could all be accepted (instead of just B and D, or just A and A'
         // like the user would want).
 
         // Bitcoin-ABC: retained this check as 'replaced_by_txid' is still set
         // in the wallet code.
         if (nDepth == 0 && wtx.mapValue.count("replaced_by_txid")) {
             safeTx = false;
         }
 
         if (fOnlySafe && !safeTx) {
             continue;
         }
 
         if (nDepth < min_depth || nDepth > max_depth) {
             continue;
         }
 
         for (uint32_t i = 0; i < wtx.tx->vout.size(); i++) {
             // Only consider selected coins if add_inputs is false
             if (coinControl && !coinControl->m_add_inputs &&
                 !coinControl->IsSelected(COutPoint(entry.first, i))) {
                 continue;
             }
 
             if (wtx.tx->vout[i].nValue < nMinimumAmount ||
                 wtx.tx->vout[i].nValue > nMaximumAmount) {
                 continue;
             }
 
             const COutPoint outpoint(wtxid, i);
 
             if (coinControl && coinControl->HasSelected() &&
                 !coinControl->fAllowOtherInputs &&
                 !coinControl->IsSelected(outpoint)) {
                 continue;
             }
 
             if (wallet.IsLockedCoin(outpoint)) {
                 continue;
             }
 
             if (wallet.IsSpent(outpoint)) {
                 continue;
             }
 
             isminetype mine = wallet.IsMine(wtx.tx->vout[i]);
 
             if (mine == ISMINE_NO) {
                 continue;
             }
 
             if (!allow_used_addresses && wallet.IsSpentKey(wtxid, i)) {
                 continue;
             }
 
             std::unique_ptr<SigningProvider> provider =
                 wallet.GetSolvingProvider(wtx.tx->vout[i].scriptPubKey);
 
             bool solvable =
                 provider ? IsSolvable(*provider, wtx.tx->vout[i].scriptPubKey)
                          : false;
             bool spendable =
                 ((mine & ISMINE_SPENDABLE) != ISMINE_NO) ||
                 (((mine & ISMINE_WATCH_ONLY) != ISMINE_NO) &&
                  (coinControl && coinControl->fAllowWatchOnly && solvable));
 
             vCoins.push_back(
                 COutput(wallet, wtx, i, nDepth, spendable, solvable, safeTx,
                         (coinControl && coinControl->fAllowWatchOnly)));
 
             // Checks the sum amount of all UTXO's.
             if (nMinimumSumAmount != MAX_MONEY) {
                 nTotal += wtx.tx->vout[i].nValue;
 
                 if (nTotal >= nMinimumSumAmount) {
                     return;
                 }
             }
 
             // Checks the maximum number of UTXO's.
             if (nMaximumCount > 0 && vCoins.size() >= nMaximumCount) {
                 return;
             }
         }
     }
 }
 
 Amount GetAvailableBalance(const CWallet &wallet,
                            const CCoinControl *coinControl) {
     LOCK(wallet.cs_wallet);
 
     Amount balance = Amount::zero();
     std::vector<COutput> vCoins;
     AvailableCoins(wallet, vCoins, true, coinControl);
     for (const COutput &out : vCoins) {
         if (out.fSpendable) {
             balance += out.tx->tx->vout[out.i].nValue;
         }
     }
     return balance;
 }
 
 const CTxOut &FindNonChangeParentOutput(const CWallet &wallet,
                                         const CTransaction &tx, int output) {
     AssertLockHeld(wallet.cs_wallet);
     const CTransaction *ptx = &tx;
     int n = output;
     while (OutputIsChange(wallet, ptx->vout[n]) && ptx->vin.size() > 0) {
         const COutPoint &prevout = ptx->vin[0].prevout;
         auto it = wallet.mapWallet.find(prevout.GetTxId());
         if (it == wallet.mapWallet.end() ||
             it->second.tx->vout.size() <= prevout.GetN() ||
             !wallet.IsMine(it->second.tx->vout[prevout.GetN()])) {
             break;
         }
         ptx = it->second.tx.get();
         n = prevout.GetN();
     }
     return ptx->vout[n];
 }
 
 std::map<CTxDestination, std::vector<COutput>>
 ListCoins(const CWallet &wallet) {
     AssertLockHeld(wallet.cs_wallet);
 
     std::map<CTxDestination, std::vector<COutput>> result;
     std::vector<COutput> availableCoins;
 
     AvailableCoins(wallet, availableCoins);
 
     for (const auto &coin : availableCoins) {
         CTxDestination address;
         if ((coin.fSpendable ||
              (wallet.IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS) &&
               coin.fSolvable)) &&
             ExtractDestination(
                 FindNonChangeParentOutput(wallet, *coin.tx->tx, coin.i)
                     .scriptPubKey,
                 address)) {
             result[address].emplace_back(std::move(coin));
         }
     }
 
     std::vector<COutPoint> lockedCoins;
     wallet.ListLockedCoins(lockedCoins);
     // Include watch-only for LegacyScriptPubKeyMan wallets without private keys
     const bool include_watch_only =
         wallet.GetLegacyScriptPubKeyMan() &&
         wallet.IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS);
     const isminetype is_mine_filter =
         include_watch_only ? ISMINE_WATCH_ONLY : ISMINE_SPENDABLE;
     for (const auto &output : lockedCoins) {
         auto it = wallet.mapWallet.find(output.GetTxId());
         if (it != wallet.mapWallet.end()) {
             int depth = wallet.GetTxDepthInMainChain(it->second);
             if (depth >= 0 && output.GetN() < it->second.tx->vout.size() &&
                 wallet.IsMine(it->second.tx->vout[output.GetN()]) ==
                     is_mine_filter) {
                 CTxDestination address;
                 if (ExtractDestination(FindNonChangeParentOutput(wallet,
                                                                  *it->second.tx,
                                                                  output.GetN())
                                            .scriptPubKey,
                                        address)) {
                     result[address].emplace_back(
                         wallet, it->second, output.GetN(), depth,
                         true /* spendable */, true /* solvable */,
                         false /* safe */);
                 }
             }
         }
     }
 
     return result;
 }
 
 std::vector<OutputGroup> GroupOutputs(const CWallet &wallet,
                                       const std::vector<COutput> &outputs,
                                       bool single_coin,
                                       const size_t max_ancestors) {
     std::vector<OutputGroup> groups;
     std::map<CTxDestination, OutputGroup> gmap;
     std::set<CTxDestination> full_groups;
 
     for (const auto &output : outputs) {
         if (output.fSpendable) {
             CTxDestination dst;
             CInputCoin input_coin = output.GetInputCoin();
 
             // deprecated -- after wellington activation these 2 stats should
             // always just be 0 since these stat becomes irrelevant at that
             // point
-            size_t ancestors, descendants;
-            wallet.chain().getTransactionAncestry(output.tx->GetId(), ancestors,
-                                                  descendants);
+            size_t ancestors = 0, descendants = 0;
 
             if (!single_coin &&
                 ExtractDestination(output.tx->tx->vout[output.i].scriptPubKey,
                                    dst)) {
                 auto it = gmap.find(dst);
                 if (it != gmap.end()) {
                     // Limit output groups to no more than
                     // OUTPUT_GROUP_MAX_ENTRIES number of entries, to protect
                     // against inadvertently creating a too-large transaction
                     // when using -avoidpartialspends to prevent breaking
                     // consensus or surprising users with a very high amount of
                     // fees.
                     if (it->second.m_outputs.size() >=
                         OUTPUT_GROUP_MAX_ENTRIES) {
                         groups.push_back(it->second);
                         it->second = OutputGroup{};
                         full_groups.insert(dst);
                     }
                     it->second.Insert(
                         input_coin, output.nDepth,
                         CachedTxIsFromMe(wallet, *output.tx, ISMINE_ALL),
                         ancestors, descendants);
                 } else {
                     gmap[dst].Insert(
                         input_coin, output.nDepth,
                         CachedTxIsFromMe(wallet, *output.tx, ISMINE_ALL),
                         ancestors, descendants);
                 }
             } else {
                 groups.emplace_back(
                     input_coin, output.nDepth,
                     CachedTxIsFromMe(wallet, *output.tx, ISMINE_ALL), ancestors,
                     descendants);
             }
         }
     }
     if (!single_coin) {
         for (auto &it : gmap) {
             auto &group = it.second;
             if (full_groups.count(it.first) > 0) {
                 // Make this unattractive as we want coin selection to avoid it
                 // if possible
                 group.m_ancestors = max_ancestors - 1;
             }
             groups.push_back(group);
         }
     }
     return groups;
 }
 
 bool SelectCoinsMinConf(const CWallet &wallet, const Amount nTargetValue,
                         const CoinEligibilityFilter &eligibility_filter,
                         std::vector<OutputGroup> groups,
                         std::set<CInputCoin> &setCoinsRet, Amount &nValueRet,
                         const CoinSelectionParams &coin_selection_params,
                         bool &bnb_used) {
     setCoinsRet.clear();
     nValueRet = Amount::zero();
 
     std::vector<OutputGroup> utxo_pool;
     if (coin_selection_params.use_bnb) {
         // Get long term estimate
         CCoinControl temp;
         temp.m_confirm_target = 1008;
         CFeeRate long_term_feerate = GetMinimumFeeRate(wallet, temp);
 
         // Calculate cost of change
         Amount cost_of_change = wallet.chain().relayDustFee().GetFee(
                                     coin_selection_params.change_spend_size) +
                                 coin_selection_params.effective_fee.GetFee(
                                     coin_selection_params.change_output_size);
 
         // Filter by the min conf specs and add to utxo_pool and calculate
         // effective value
         for (OutputGroup &group : groups) {
             if (!group.EligibleForSpending(eligibility_filter)) {
                 continue;
             }
 
             if (coin_selection_params.m_subtract_fee_outputs) {
                 // Set the effective feerate to 0 as we don't want to use the
                 // effective value since the fees will be deducted from the
                 // output
                 group.SetFees(CFeeRate(Amount::zero()) /* effective_feerate */,
                               long_term_feerate);
             } else {
                 group.SetFees(coin_selection_params.effective_fee,
                               long_term_feerate);
             }
 
             OutputGroup pos_group = group.GetPositiveOnlyGroup();
             if (pos_group.effective_value > Amount::zero()) {
                 utxo_pool.push_back(pos_group);
             }
         }
         // Calculate the fees for things that aren't inputs
         Amount not_input_fees = coin_selection_params.effective_fee.GetFee(
             coin_selection_params.tx_noinputs_size);
         bnb_used = true;
         return SelectCoinsBnB(utxo_pool, nTargetValue, cost_of_change,
                               setCoinsRet, nValueRet, not_input_fees);
     } else {
         // Filter by the min conf specs and add to utxo_pool
         for (const OutputGroup &group : groups) {
             if (!group.EligibleForSpending(eligibility_filter)) {
                 continue;
             }
             utxo_pool.push_back(group);
         }
         bnb_used = false;
         return KnapsackSolver(nTargetValue, utxo_pool, setCoinsRet, nValueRet);
     }
 }
 
 bool SelectCoins(const CWallet &wallet,
                  const std::vector<COutput> &vAvailableCoins,
                  const Amount nTargetValue, std::set<CInputCoin> &setCoinsRet,
                  Amount &nValueRet, const CCoinControl &coin_control,
                  CoinSelectionParams &coin_selection_params, bool &bnb_used) {
     std::vector<COutput> vCoins(vAvailableCoins);
     Amount value_to_select = nTargetValue;
 
     // Default to bnb was not used. If we use it, we set it later
     bnb_used = false;
 
     // coin control -> return all selected outputs (we want all selected to go
     // into the transaction for sure)
     if (coin_control.HasSelected() && !coin_control.fAllowOtherInputs) {
         for (const COutput &out : vCoins) {
             if (!out.fSpendable) {
                 continue;
             }
 
             nValueRet += out.tx->tx->vout[out.i].nValue;
             setCoinsRet.insert(out.GetInputCoin());
         }
 
         return (nValueRet >= nTargetValue);
     }
 
     // Calculate value from preset inputs and store them.
     std::set<CInputCoin> setPresetCoins;
     Amount nValueFromPresetInputs = Amount::zero();
 
     std::vector<COutPoint> vPresetInputs;
     coin_control.ListSelected(vPresetInputs);
 
     for (const COutPoint &outpoint : vPresetInputs) {
         std::map<TxId, CWalletTx>::const_iterator it =
             wallet.mapWallet.find(outpoint.GetTxId());
         if (it != wallet.mapWallet.end()) {
             const CWalletTx &wtx = it->second;
             // Clearly invalid input, fail
             if (wtx.tx->vout.size() <= outpoint.GetN()) {
                 return false;
             }
             // Just to calculate the marginal byte size
             CInputCoin coin(
                 wtx.tx, outpoint.GetN(),
                 GetTxSpendSize(wallet, wtx, outpoint.GetN(), false));
             nValueFromPresetInputs += coin.txout.nValue;
             if (coin.m_input_bytes <= 0) {
                 // Not solvable, can't estimate size for fee
                 return false;
             }
             coin.effective_value =
                 coin.txout.nValue -
                 coin_selection_params.effective_fee.GetFee(coin.m_input_bytes);
             if (coin_selection_params.use_bnb) {
                 value_to_select -= coin.effective_value;
             } else {
                 value_to_select -= coin.txout.nValue;
             }
             setPresetCoins.insert(coin);
         } else {
             return false; // TODO: Allow non-wallet inputs
         }
     }
 
     // Remove preset inputs from vCoins
     for (std::vector<COutput>::iterator it = vCoins.begin();
          it != vCoins.end() && coin_control.HasSelected();) {
         if (setPresetCoins.count(it->GetInputCoin())) {
             it = vCoins.erase(it);
         } else {
             ++it;
         }
     }
 
     // Note: after wellington the ancestor stats will always be 0, since this
     // limitation becomes irrelevant.
     size_t max_ancestors{0};
     size_t max_descendants{0};
     wallet.chain().getPackageLimits(max_ancestors, max_descendants);
     bool fRejectLongChains = gArgs.GetBoolArg(
         "-walletrejectlongchains", DEFAULT_WALLET_REJECT_LONG_CHAINS);
 
     // form groups from remaining coins; note that preset coins will not
     // automatically have their associated (same address) coins included
     if (coin_control.m_avoid_partial_spends &&
         vCoins.size() > OUTPUT_GROUP_MAX_ENTRIES) {
         // Cases where we have 11+ outputs all pointing to the same destination
         // may result in privacy leaks as they will potentially be
         // deterministically sorted. We solve that by explicitly shuffling the
         // outputs before processing
         Shuffle(vCoins.begin(), vCoins.end(), FastRandomContext());
     }
 
     std::vector<OutputGroup> groups = GroupOutputs(
         wallet, vCoins, !coin_control.m_avoid_partial_spends, max_ancestors);
 
     bool res =
         value_to_select <= Amount::zero() ||
         SelectCoinsMinConf(wallet, value_to_select,
                            CoinEligibilityFilter(1, 6, 0), groups, setCoinsRet,
                            nValueRet, coin_selection_params, bnb_used) ||
         SelectCoinsMinConf(wallet, value_to_select,
                            CoinEligibilityFilter(1, 1, 0), groups, setCoinsRet,
                            nValueRet, coin_selection_params, bnb_used) ||
         (wallet.m_spend_zero_conf_change &&
          SelectCoinsMinConf(wallet, value_to_select,
                             CoinEligibilityFilter(0, 1, 2), groups, setCoinsRet,
                             nValueRet, coin_selection_params, bnb_used)) ||
         (wallet.m_spend_zero_conf_change &&
          SelectCoinsMinConf(
              wallet, value_to_select,
              CoinEligibilityFilter(0, 1, std::min((size_t)4, max_ancestors / 3),
                                    std::min((size_t)4, max_descendants / 3)),
              groups, setCoinsRet, nValueRet, coin_selection_params,
              bnb_used)) ||
         (wallet.m_spend_zero_conf_change &&
          SelectCoinsMinConf(wallet, value_to_select,
                             CoinEligibilityFilter(0, 1, max_ancestors / 2,
                                                   max_descendants / 2),
                             groups, setCoinsRet, nValueRet,
                             coin_selection_params, bnb_used)) ||
         (wallet.m_spend_zero_conf_change &&
          SelectCoinsMinConf(wallet, value_to_select,
                             CoinEligibilityFilter(0, 1, max_ancestors - 1,
                                                   max_descendants - 1),
                             groups, setCoinsRet, nValueRet,
                             coin_selection_params, bnb_used)) ||
         (wallet.m_spend_zero_conf_change && !fRejectLongChains &&
          SelectCoinsMinConf(
              wallet, value_to_select,
              CoinEligibilityFilter(0, 1, std::numeric_limits<uint64_t>::max()),
              groups, setCoinsRet, nValueRet, coin_selection_params, bnb_used));
 
     // Because SelectCoinsMinConf clears the setCoinsRet, we now add the
     // possible inputs to the coinset.
     util::insert(setCoinsRet, setPresetCoins);
 
     // Add preset inputs to the total value selected.
     nValueRet += nValueFromPresetInputs;
 
     return res;
 }
 
 static bool CreateTransactionInternal(
     CWallet &wallet, const std::vector<CRecipient> &vecSend,
     CTransactionRef &tx, Amount &nFeeRet, int &nChangePosInOut,
     bilingual_str &error, const CCoinControl &coin_control, bool sign) {
     // TODO: remember to add the lock annotation when adding AssertLockHeld.
     //       The lock annotation was added by core in PR22100, but due to
     //       other missing backports it was not possible to add it during that
     //       backport.
     Amount nValue = Amount::zero();
     const OutputType change_type = wallet.TransactionChangeType(
         coin_control.m_change_type ? *coin_control.m_change_type
                                    : wallet.m_default_change_type,
         vecSend);
     ReserveDestination reservedest(&wallet, change_type);
     int nChangePosRequest = nChangePosInOut;
     unsigned int nSubtractFeeFromAmount = 0;
     for (const auto &recipient : vecSend) {
         if (nValue < Amount::zero() || recipient.nAmount < Amount::zero()) {
             error = _("Transaction amounts must not be negative");
             return false;
         }
 
         nValue += recipient.nAmount;
 
         if (recipient.fSubtractFeeFromAmount) {
             nSubtractFeeFromAmount++;
         }
     }
 
     if (vecSend.empty()) {
         error = _("Transaction must have at least one recipient");
         return false;
     }
 
     CMutableTransaction txNew;
 
     {
         std::set<CInputCoin> setCoins;
         LOCK(wallet.cs_wallet);
         // Previously the locktime was set to the current block height, to
         // prevent fee-sniping. This is now disabled as fee-sniping is mitigated
         // by avalanche post-consensus. Consistently Using a locktime of 0 for
         // most wallets in the ecosystem improves privacy, as this is the
         // easiest solution to implement for light wallets which are not aware
         // of the current block height.
         txNew.nLockTime = 0;
         std::vector<COutput> vAvailableCoins;
         AvailableCoins(wallet, vAvailableCoins, true, &coin_control);
         // Parameters for coin selection, init with dummy
         CoinSelectionParams coin_selection_params;
 
         // Create change script that will be used if we need change
         // TODO: pass in scriptChange instead of reservedest so
         // change transaction isn't always pay-to-bitcoin-address
         CScript scriptChange;
 
         // coin control: send change to custom address
         if (!boost::get<CNoDestination>(&coin_control.destChange)) {
             scriptChange = GetScriptForDestination(coin_control.destChange);
 
             // no coin control: send change to newly generated address
         } else {
             // Note: We use a new key here to keep it from being obvious
             // which side is the change.
             //  The drawback is that by not reusing a previous key, the
             //  change may be lost if a backup is restored, if the backup
             //  doesn't have the new private key for the change. If we
             //  reused the old key, it would be possible to add code to look
             //  for and rediscover unknown transactions that were written
             //  with keys of ours to recover post-backup change.
 
             // Reserve a new key pair from key pool. If it fails, provide a
             // dummy destination in case we don't need change.
             CTxDestination dest;
             if (!reservedest.GetReservedDestination(dest, true)) {
                 error = _("Transaction needs a change address, but we can't "
                           "generate it. Please call keypoolrefill first.");
             }
 
             scriptChange = GetScriptForDestination(dest);
             // A valid destination implies a change script (and
             // vice-versa). An empty change script will abort later, if the
             // change keypool ran out, but change is required.
             CHECK_NONFATAL(IsValidDestination(dest) != scriptChange.empty());
         }
         CTxOut change_prototype_txout(Amount::zero(), scriptChange);
         coin_selection_params.change_output_size =
             GetSerializeSize(change_prototype_txout);
 
         // Get the fee rate to use effective values in coin selection
         CFeeRate nFeeRateNeeded = GetMinimumFeeRate(wallet, coin_control);
         // Do not, ever, assume that it's fine to change the fee rate if the
         // user has explicitly provided one
         if (coin_control.m_feerate &&
             nFeeRateNeeded > *coin_control.m_feerate) {
             error = strprintf(_("Fee rate (%s) is lower than the minimum fee "
                                 "rate setting (%s)"),
                               coin_control.m_feerate->ToString(),
                               nFeeRateNeeded.ToString());
             return false;
         }
 
         nFeeRet = Amount::zero();
         bool pick_new_inputs = true;
         Amount nValueIn = Amount::zero();
 
         // BnB selector is the only selector used when this is true.
         // That should only happen on the first pass through the loop.
         coin_selection_params.use_bnb = true;
         // If we are doing subtract fee from recipient, don't use effective
         // values
         coin_selection_params.m_subtract_fee_outputs =
             nSubtractFeeFromAmount != 0;
         // Start with no fee and loop until there is enough fee
         while (true) {
             nChangePosInOut = nChangePosRequest;
             txNew.vin.clear();
             txNew.vout.clear();
             bool fFirst = true;
 
             Amount nValueToSelect = nValue;
             if (nSubtractFeeFromAmount == 0) {
                 nValueToSelect += nFeeRet;
             }
 
             // vouts to the payees
             if (!coin_selection_params.m_subtract_fee_outputs) {
                 // Static size overhead + outputs vsize. 4 nVersion, 4
                 // nLocktime, 1 input count, 1 output count
                 coin_selection_params.tx_noinputs_size = 10;
             }
             // vouts to the payees
             for (const auto &recipient : vecSend) {
                 CTxOut txout(recipient.nAmount, recipient.scriptPubKey);
 
                 if (recipient.fSubtractFeeFromAmount) {
                     assert(nSubtractFeeFromAmount != 0);
                     // Subtract fee equally from each selected recipient.
                     txout.nValue -= nFeeRet / int(nSubtractFeeFromAmount);
 
                     // First receiver pays the remainder not divisible by output
                     // count.
                     if (fFirst) {
                         fFirst = false;
                         txout.nValue -= nFeeRet % int(nSubtractFeeFromAmount);
                     }
                 }
 
                 // Include the fee cost for outputs. Note this is only used for
                 // BnB right now
                 if (!coin_selection_params.m_subtract_fee_outputs) {
                     coin_selection_params.tx_noinputs_size +=
                         ::GetSerializeSize(txout, PROTOCOL_VERSION);
                 }
 
                 if (IsDust(txout, wallet.chain().relayDustFee())) {
                     if (recipient.fSubtractFeeFromAmount &&
                         nFeeRet > Amount::zero()) {
                         if (txout.nValue < Amount::zero()) {
                             error = _("The transaction amount is too small to "
                                       "pay the fee");
                         } else {
                             error = _("The transaction amount is too small to "
                                       "send after the fee has been deducted");
                         }
                     } else {
                         error = _("Transaction amount too small");
                     }
 
                     return false;
                 }
 
                 txNew.vout.push_back(txout);
             }
 
             // Choose coins to use
             bool bnb_used = false;
             if (pick_new_inputs) {
                 nValueIn = Amount::zero();
                 setCoins.clear();
                 int change_spend_size = CalculateMaximumSignedInputSize(
                     change_prototype_txout, &wallet);
                 // If the wallet doesn't know how to sign change output, assume
                 // p2pkh as lower-bound to allow BnB to do it's thing
                 if (change_spend_size == -1) {
                     coin_selection_params.change_spend_size =
                         DUMMY_P2PKH_INPUT_SIZE;
                 } else {
                     coin_selection_params.change_spend_size =
                         size_t(change_spend_size);
                 }
                 coin_selection_params.effective_fee = nFeeRateNeeded;
                 if (!SelectCoins(wallet, vAvailableCoins, nValueToSelect,
                                  setCoins, nValueIn, coin_control,
                                  coin_selection_params, bnb_used)) {
                     // If BnB was used, it was the first pass. No longer the
                     // first pass and continue loop with knapsack.
                     if (bnb_used) {
                         coin_selection_params.use_bnb = false;
                         continue;
                     } else {
                         error = _("Insufficient funds");
                         return false;
                     }
                 }
             } else {
                 bnb_used = false;
             }
 
             const Amount nChange = nValueIn - nValueToSelect;
             if (nChange > Amount::zero()) {
                 // Fill a vout to ourself.
                 CTxOut newTxOut(nChange, scriptChange);
 
                 // Never create dust outputs; if we would, just add the dust to
                 // the fee.
                 // The nChange when BnB is used is always going to go to fees.
                 if (IsDust(newTxOut, wallet.chain().relayDustFee()) ||
                     bnb_used) {
                     nChangePosInOut = -1;
                     nFeeRet += nChange;
                 } else {
                     if (nChangePosInOut == -1) {
                         // Insert change txn at random position:
                         nChangePosInOut = GetRandInt(txNew.vout.size() + 1);
                     } else if ((unsigned int)nChangePosInOut >
                                txNew.vout.size()) {
                         error = _("Change index out of range");
                         return false;
                     }
 
                     std::vector<CTxOut>::iterator position =
                         txNew.vout.begin() + nChangePosInOut;
                     txNew.vout.insert(position, newTxOut);
                 }
             } else {
                 nChangePosInOut = -1;
             }
 
             // Dummy fill vin for maximum size estimation
             //
             for (const auto &coin : setCoins) {
                 txNew.vin.push_back(CTxIn(coin.outpoint, CScript()));
             }
 
             CTransaction txNewConst(txNew);
             int nBytes = CalculateMaximumSignedTxSize(
                 txNewConst, &wallet, coin_control.fAllowWatchOnly);
             if (nBytes < 0) {
                 error = _("Signing transaction failed");
                 return false;
             }
 
             Amount nFeeNeeded = GetMinimumFee(wallet, nBytes, coin_control);
 
             if (nFeeRet >= nFeeNeeded) {
                 // Reduce fee to only the needed amount if possible. This
                 // prevents potential overpayment in fees if the coins selected
                 // to meet nFeeNeeded result in a transaction that requires less
                 // fee than the prior iteration.
 
                 // If we have no change and a big enough excess fee, then try to
                 // construct transaction again only without picking new inputs.
                 // We now know we only need the smaller fee (because of reduced
                 // tx size) and so we should add a change output. Only try this
                 // once.
                 if (nChangePosInOut == -1 && nSubtractFeeFromAmount == 0 &&
                     pick_new_inputs) {
                     // Add 2 as a buffer in case increasing # of outputs changes
                     // compact size
                     unsigned int tx_size_with_change =
                         nBytes + coin_selection_params.change_output_size + 2;
                     Amount fee_needed_with_change = GetMinimumFee(
                         wallet, tx_size_with_change, coin_control);
                     Amount minimum_value_for_change = GetDustThreshold(
                         change_prototype_txout, wallet.chain().relayDustFee());
                     if (nFeeRet >=
                         fee_needed_with_change + minimum_value_for_change) {
                         pick_new_inputs = false;
                         nFeeRet = fee_needed_with_change;
                         continue;
                     }
                 }
 
                 // If we have change output already, just increase it
                 if (nFeeRet > nFeeNeeded && nChangePosInOut != -1 &&
                     nSubtractFeeFromAmount == 0) {
                     Amount extraFeePaid = nFeeRet - nFeeNeeded;
                     std::vector<CTxOut>::iterator change_position =
                         txNew.vout.begin() + nChangePosInOut;
                     change_position->nValue += extraFeePaid;
                     nFeeRet -= extraFeePaid;
                 }
 
                 // Done, enough fee included.
                 break;
             } else if (!pick_new_inputs) {
                 // This shouldn't happen, we should have had enough excess fee
                 // to pay for the new output and still meet nFeeNeeded.
                 // Or we should have just subtracted fee from recipients and
                 // nFeeNeeded should not have changed.
                 error = _("Transaction fee and change calculation failed");
                 return false;
             }
 
             // Try to reduce change to include necessary fee.
             if (nChangePosInOut != -1 && nSubtractFeeFromAmount == 0) {
                 Amount additionalFeeNeeded = nFeeNeeded - nFeeRet;
                 std::vector<CTxOut>::iterator change_position =
                     txNew.vout.begin() + nChangePosInOut;
                 // Only reduce change if remaining amount is still a large
                 // enough output.
                 if (change_position->nValue >=
                     MIN_FINAL_CHANGE + additionalFeeNeeded) {
                     change_position->nValue -= additionalFeeNeeded;
                     nFeeRet += additionalFeeNeeded;
                     // Done, able to increase fee from change.
                     break;
                 }
             }
 
             // If subtracting fee from recipients, we now know what fee we
             // need to subtract, we have no reason to reselect inputs.
             if (nSubtractFeeFromAmount > 0) {
                 pick_new_inputs = false;
             }
 
             // Include more fee and try again.
             nFeeRet = nFeeNeeded;
             coin_selection_params.use_bnb = false;
             continue;
         }
 
         // Give up if change keypool ran out and change is required
         if (scriptChange.empty() && nChangePosInOut != -1) {
             return false;
         }
 
         // Shuffle selected coins and fill in final vin
         txNew.vin.clear();
         std::vector<CInputCoin> selected_coins(setCoins.begin(),
                                                setCoins.end());
         Shuffle(selected_coins.begin(), selected_coins.end(),
                 FastRandomContext());
 
         // Note how the sequence number is set to non-maxint so that
         // the nLockTime set above actually works.
         for (const auto &coin : selected_coins) {
             txNew.vin.push_back(
                 CTxIn(coin.outpoint, CScript(),
                       std::numeric_limits<uint32_t>::max() - 1));
         }
 
         if (sign && !wallet.SignTransaction(txNew)) {
             error = _("Signing transaction failed");
             return false;
         }
 
         // Return the constructed transaction data.
         tx = MakeTransactionRef(std::move(txNew));
 
         // Limit size.
         if (tx->GetTotalSize() > MAX_STANDARD_TX_SIZE) {
             error = _("Transaction too large");
             return false;
         }
     }
 
     if (nFeeRet > wallet.m_default_max_tx_fee) {
         error = TransactionErrorString(TransactionError::MAX_FEE_EXCEEDED);
         return false;
     }
 
-    // After wellington this option will no longer exist
-    if (gArgs.GetBoolArg("-walletrejectlongchains",
-                         DEFAULT_WALLET_REJECT_LONG_CHAINS)) {
-        // Lastly, ensure this tx will pass the mempool's chain limits
-        if (!wallet.chain().checkChainLimits(tx)) {
-            error = _("Transaction has too long of a mempool chain");
-            return false;
-        }
-    }
-
     // Before we return success, we assume any change key will be used to
     // prevent accidental re-use.
     reservedest.KeepDestination();
 
     return true;
 }
 
 bool CreateTransaction(CWallet &wallet, const std::vector<CRecipient> &vecSend,
                        CTransactionRef &tx, Amount &nFeeRet,
                        int &nChangePosInOut, bilingual_str &error,
                        const CCoinControl &coin_control, bool sign) {
     int nChangePosIn = nChangePosInOut;
     CTransactionRef tx2 = tx;
     bool res =
         CreateTransactionInternal(wallet, vecSend, tx, nFeeRet, nChangePosInOut,
                                   error, coin_control, sign);
     // try with avoidpartialspends unless it's enabled already
     if (res &&
         nFeeRet >
             Amount::zero() /* 0 means non-functional fee rate estimation */
         && wallet.m_max_aps_fee > (-1 * SATOSHI) &&
         !coin_control.m_avoid_partial_spends) {
         CCoinControl tmp_cc = coin_control;
         tmp_cc.m_avoid_partial_spends = true;
         Amount nFeeRet2;
         int nChangePosInOut2 = nChangePosIn;
         // fired and forgotten; if an error occurs, we discard the results
         bilingual_str error2;
         if (CreateTransactionInternal(wallet, vecSend, tx2, nFeeRet2,
                                       nChangePosInOut2, error2, tmp_cc, sign)) {
             // if fee of this alternative one is within the range of the max
             // fee, we use this one
             const bool use_aps = nFeeRet2 <= nFeeRet + wallet.m_max_aps_fee;
             wallet.WalletLogPrintf(
                 "Fee non-grouped = %lld, grouped = %lld, using %s\n", nFeeRet,
                 nFeeRet2, use_aps ? "grouped" : "non-grouped");
             if (use_aps) {
                 tx = tx2;
                 nFeeRet = nFeeRet2;
                 nChangePosInOut = nChangePosInOut2;
             }
         }
     }
     return res;
 }
 
 bool FundTransaction(CWallet &wallet, CMutableTransaction &tx, Amount &nFeeRet,
                      int &nChangePosInOut, bilingual_str &error,
                      bool lockUnspents,
                      const std::set<int> &setSubtractFeeFromOutputs,
                      CCoinControl coinControl) {
     std::vector<CRecipient> vecSend;
 
     // Turn the txout set into a CRecipient vector.
     for (size_t idx = 0; idx < tx.vout.size(); idx++) {
         const CTxOut &txOut = tx.vout[idx];
         CRecipient recipient = {txOut.scriptPubKey, txOut.nValue,
                                 setSubtractFeeFromOutputs.count(idx) == 1};
         vecSend.push_back(recipient);
     }
 
     coinControl.fAllowOtherInputs = true;
 
     for (const CTxIn &txin : tx.vin) {
         coinControl.Select(txin.prevout);
     }
 
     // Acquire the locks to prevent races to the new locked unspents between the
     // CreateTransaction call and LockCoin calls (when lockUnspents is true).
     LOCK(wallet.cs_wallet);
 
     CTransactionRef tx_new;
     if (!CreateTransaction(wallet, vecSend, tx_new, nFeeRet, nChangePosInOut,
                            error, coinControl, false)) {
         return false;
     }
 
     if (nChangePosInOut != -1) {
         tx.vout.insert(tx.vout.begin() + nChangePosInOut,
                        tx_new->vout[nChangePosInOut]);
     }
 
     // Copy output sizes from new transaction; they may have had the fee
     // subtracted from them.
     for (size_t idx = 0; idx < tx.vout.size(); idx++) {
         tx.vout[idx].nValue = tx_new->vout[idx].nValue;
     }
 
     // Add new txins (keeping original txin scriptSig/order)
     for (const CTxIn &txin : tx_new->vin) {
         if (!coinControl.IsSelected(txin.prevout)) {
             tx.vin.push_back(txin);
         }
         if (lockUnspents) {
             wallet.LockCoin(txin.prevout);
         }
     }
 
     return true;
 }
diff --git a/test/functional/abc_mempool_chainedtx.py b/test/functional/abc_mempool_chainedtx.py
index 6a7e74051..d8aabc10d 100755
--- a/test/functional/abc_mempool_chainedtx.py
+++ b/test/functional/abc_mempool_chainedtx.py
@@ -1,129 +1,59 @@
 #!/usr/bin/env python3
 # Copyright (c) 2023 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 chained txs limit."""
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import (
-    assert_equal,
-    assert_greater_than,
-    assert_raises_rpc_error,
-)
+from test_framework.util import assert_equal
 from test_framework.wallet import create_raw_chain
 
-MAX_CHAINED_TX = 5
-WELLINGTON_ACTIVATION_TIME = 2000000000
+LEGACY_MAX_CHAINED_TX = 5
 
 
 class ChainedTxTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 1
         self.setup_clean_chain = True
-        self.extra_args = [
-            [
-                f"-replayprotectionactivationtime={WELLINGTON_ACTIVATION_TIME + 1000}",
-                f"-wellingtonactivationtime={WELLINGTON_ACTIVATION_TIME}",
-                f"-limitancestorcount={MAX_CHAINED_TX}",
-                f"-limitdescendantcount={MAX_CHAINED_TX + 1}",
-            ]
-        ]
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
     def run_test(self):
         node = self.nodes[0]
-        node.setmocktime(WELLINGTON_ACTIVATION_TIME - 1000)
 
         self.privkeys = [node.get_deterministic_priv_key().key]
         self.address = node.get_deterministic_priv_key().address
         self.coins = []
         # The last 100 coinbase transactions are premature
         for b in self.generatetoaddress(node, 102, self.address)[:2]:
             coinbase = node.getblock(blockhash=b, verbosity=2)["tx"][0]
             self.coins.append(
                 {
                     "txid": coinbase["txid"],
                     "amount": coinbase["vout"][0]["value"],
                     "scriptPubKey": coinbase["vout"][0]["scriptPubKey"],
                 }
             )
 
-        self.log.info("Before Wellington, the chained-tx limit applies")
-
-        assert_greater_than(
-            WELLINGTON_ACTIVATION_TIME, node.getblockchaininfo()["mediantime"]
+        self.log.info(
+            "Since Wellington activation, the chained-tx limit no longer applies"
         )
 
         chain_hex, _ = create_raw_chain(
             node,
             self.coins.pop(),
             self.address,
             self.privkeys,
-            chain_length=MAX_CHAINED_TX + 1,
+            chain_length=LEGACY_MAX_CHAINED_TX * 2,
         )
 
-        for i in range(MAX_CHAINED_TX):
+        for i in range(LEGACY_MAX_CHAINED_TX * 2):
             txid = node.sendrawtransaction(chain_hex[i])
             mempool = node.getrawmempool()
             assert_equal(len(mempool), i + 1)
             assert txid in mempool
 
-        assert_raises_rpc_error(
-            -26,
-            (
-                "too-long-mempool-chain, too many unconfirmed ancestors [limit:"
-                f" {MAX_CHAINED_TX}]"
-            ),
-            node.sendrawtransaction,
-            chain_hex[-1],
-        )
-
-        self.log.info("Activate Wellington")
-
-        node.setmocktime(WELLINGTON_ACTIVATION_TIME)
-        self.generate(node, 6)
-        assert_equal(node.getblockchaininfo()["mediantime"], WELLINGTON_ACTIVATION_TIME)
-
-        self.log.info("After Wellington, the chained-tx limit no longer applies")
-
-        chain_hex, _ = create_raw_chain(
-            node,
-            self.coins.pop(),
-            self.address,
-            self.privkeys,
-            chain_length=MAX_CHAINED_TX * 2,
-        )
-
-        for i in range(MAX_CHAINED_TX * 2):
-            txid = node.sendrawtransaction(chain_hex[i])
-            mempool = node.getrawmempool()
-            assert_equal(len(mempool), i + 1)
-            assert txid in mempool
-
-        self.log.info("Upon reorg the mempool policy is maintained")
-
-        node.invalidateblock(node.getbestblockhash())
-        assert_greater_than(
-            WELLINGTON_ACTIVATION_TIME, node.getblockchaininfo()["mediantime"]
-        )
-
-        # Mempool size should be limited again
-        assert_equal(len(node.getrawmempool()), MAX_CHAINED_TX * 2)
-
-        # Mine an activation block to clear the mempool
-        self.generate(node, 1)
-        assert_equal(len(node.getrawmempool()), 0)
-
-        # Reorg that block, and make sure all the txs are added back to the
-        # mempool
-        node.invalidateblock(node.getbestblockhash())
-        assert_greater_than(
-            WELLINGTON_ACTIVATION_TIME, node.getblockchaininfo()["mediantime"]
-        )
-        assert_equal(len(node.getrawmempool()), MAX_CHAINED_TX * 2)
-
 
 if __name__ == "__main__":
     ChainedTxTest().main()
diff --git a/test/functional/mempool_package_limits.py b/test/functional/mempool_package_limits.py
deleted file mode 100755
index 48f0e08f8..000000000
--- a/test/functional/mempool_package_limits.py
+++ /dev/null
@@ -1,676 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (c) 2021 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 logic for limiting mempool and package ancestors/descendants."""
-
-from decimal import Decimal
-
-from test_framework.address import ADDRESS_ECREG_P2SH_OP_TRUE, SCRIPTSIG_OP_TRUE
-from test_framework.messages import XEC, CTransaction, FromHex, ToHex
-from test_framework.test_framework import BitcoinTestFramework
-from test_framework.txtools import pad_tx
-from test_framework.util import assert_equal
-from test_framework.wallet import (
-    bulk_transaction,
-    create_child_with_parents,
-    make_chain,
-)
-
-FAR_IN_THE_FUTURE = 2000000000
-
-
-class MempoolPackageLimitsTest(BitcoinTestFramework):
-    def set_test_params(self):
-        self.num_nodes = 1
-        self.setup_clean_chain = True
-        self.extra_args = [
-            [
-                # The packages mempool limits are no longer applied after wellington
-                # activation.
-                f"-wellingtonactivationtime={FAR_IN_THE_FUTURE}",
-            ]
-        ]
-
-    def run_test(self):
-        self.log.info("Generate blocks to create UTXOs")
-        node = self.nodes[0]
-        self.privkeys = [node.get_deterministic_priv_key().key]
-        self.address = node.get_deterministic_priv_key().address
-        self.coins = []
-        # The last 100 coinbase transactions are premature
-        for b in self.generatetoaddress(node, 200, self.address)[:100]:
-            coinbase = node.getblock(blockhash=b, verbosity=2)["tx"][0]
-            self.coins.append(
-                {
-                    "txid": coinbase["txid"],
-                    "amount": coinbase["vout"][0]["value"],
-                    "scriptPubKey": coinbase["vout"][0]["scriptPubKey"],
-                }
-            )
-
-        self.test_chain_limits()
-        self.test_desc_count_limits()
-        self.test_desc_count_limits_2()
-        self.test_anc_count_limits()
-        self.test_anc_count_limits_2()
-        self.test_anc_count_limits_bushy()
-
-        # The node will accept our (nonstandard) extra large OP_RETURN outputs
-        self.restart_node(0, extra_args=["-acceptnonstdtxn=1"])
-        self.test_anc_size_limits()
-        self.test_desc_size_limits()
-
-    def test_chain_limits_helper(self, mempool_count, package_count):
-        node = self.nodes[0]
-        assert_equal(0, node.getmempoolinfo()["size"])
-        first_coin = self.coins.pop()
-        spk = None
-        txid = first_coin["txid"]
-        chain_hex = []
-        chain_txns = []
-        value = first_coin["amount"]
-
-        for i in range(mempool_count + package_count):
-            (tx, txhex, value, spk) = make_chain(
-                node, self.address, self.privkeys, txid, value, 0, spk
-            )
-            txid = tx.get_id()
-            if i < mempool_count:
-                node.sendrawtransaction(txhex)
-            else:
-                chain_hex.append(txhex)
-                chain_txns.append(tx)
-        testres_too_long = node.testmempoolaccept(rawtxs=chain_hex)
-        for txres in testres_too_long:
-            assert_equal(txres["package-error"], "package-mempool-limits")
-
-        # Clear mempool and check that the package passes now
-        self.generate(node, 1)
-        assert all(
-            res["allowed"] is True for res in node.testmempoolaccept(rawtxs=chain_hex)
-        )
-
-    def test_chain_limits(self):
-        """Create chains from mempool and package transactions that are longer than 50,
-        but only if both in-mempool and in-package transactions are considered together.
-        This checks that both mempool and in-package transactions are taken into account
-        when calculating ancestors/descendant limits.
-        """
-        self.log.info(
-            "Check that in-package ancestors count for mempool ancestor limits"
-        )
-
-        self.test_chain_limits_helper(mempool_count=49, package_count=2)
-        self.test_chain_limits_helper(mempool_count=2, package_count=49)
-        self.test_chain_limits_helper(mempool_count=26, package_count=26)
-
-    def test_desc_count_limits(self):
-        """Create an 'A' shaped package with 49 transactions in the mempool and 2 in the package:
-                    M1
-                   ^  ^
-                 M2a  M2b
-                .       .
-               .         .
-             M25a        M25b
-            ^              ^
-           Pa              Pb
-        The top ancestor in the package exceeds descendant limits but only if the in-mempool and in-package
-        descendants are all considered together (49 including in-mempool descendants and 51 including both
-        package transactions).
-        """
-        node = self.nodes[0]
-        assert_equal(0, node.getmempoolinfo()["size"])
-        self.log.info(
-            "Check that in-mempool and in-package descendants are calculated properly"
-            " in packages"
-        )
-        # Top parent in mempool, M1
-        first_coin = self.coins.pop()
-        # Deduct reasonable fee and make 2 outputs
-        parent_value = (first_coin["amount"] - Decimal("200.00")) / 2
-        inputs = [{"txid": first_coin["txid"], "vout": 0}]
-        outputs = [
-            {self.address: parent_value},
-            {ADDRESS_ECREG_P2SH_OP_TRUE: parent_value},
-        ]
-        rawtx = node.createrawtransaction(inputs, outputs)
-
-        parent_signed = node.signrawtransactionwithkey(
-            hexstring=rawtx, privkeys=self.privkeys
-        )
-        assert parent_signed["complete"]
-        parent_tx = FromHex(CTransaction(), parent_signed["hex"])
-        parent_txid = parent_tx.rehash()
-        node.sendrawtransaction(parent_signed["hex"])
-
-        package_hex = []
-
-        # Chain A
-        spk = parent_tx.vout[0].scriptPubKey.hex()
-        value = parent_value
-        txid = parent_txid
-        for i in range(25):
-            (tx, txhex, value, spk) = make_chain(
-                node, self.address, self.privkeys, txid, value, 0, spk
-            )
-            txid = tx.get_id()
-            if i < 24:
-                # M2a... M25a
-                node.sendrawtransaction(txhex)
-            else:
-                # Pa
-                package_hex.append(txhex)
-
-        # Chain B
-        value = parent_value - Decimal("100.00")
-        rawtx_b = node.createrawtransaction(
-            [{"txid": parent_txid, "vout": 1}], {self.address: value}
-        )
-        # M2b
-        tx_child_b = FromHex(CTransaction(), rawtx_b)
-        tx_child_b.vin[0].scriptSig = SCRIPTSIG_OP_TRUE
-        pad_tx(tx_child_b)
-        tx_child_b_hex = ToHex(tx_child_b)
-        node.sendrawtransaction(tx_child_b_hex)
-        spk = tx_child_b.vout[0].scriptPubKey.hex()
-        txid = tx_child_b.rehash()
-        for i in range(24):
-            (tx, txhex, value, spk) = make_chain(
-                node, self.address, self.privkeys, txid, value, 0, spk
-            )
-            txid = tx.get_id()
-            if i < 23:
-                # M3b... M25b
-                node.sendrawtransaction(txhex)
-            else:
-                # Pb
-                package_hex.append(txhex)
-
-        assert_equal(49, node.getmempoolinfo()["size"])
-        assert_equal(2, len(package_hex))
-        testres_too_long = node.testmempoolaccept(rawtxs=package_hex)
-        for txres in testres_too_long:
-            assert_equal(txres["package-error"], "package-mempool-limits")
-
-        # Clear mempool and check that the package passes now
-        self.generate(node, 1)
-        assert all(
-            res["allowed"] is True for res in node.testmempoolaccept(rawtxs=package_hex)
-        )
-
-    def test_desc_count_limits_2(self):
-        """Create a Package with 49 transactions in mempool and 2 transactions
-         in package:
-                      M1
-                     ^  ^
-                   M2    ^
-                   .      ^
-                  .        ^
-                 .          ^
-                M49          ^
-                              ^
-                              P1
-                              ^
-                              P2
-        P1 has M1 as a mempool ancestor, P2 has no in-mempool ancestors, but
-        when combined P2 has M1 as an ancestor and M1 exceeds descendant_limits
-        (48 in-mempool descendants + 2 in-package descendants, a total of 51
-        including itself).
-        """
-
-        node = self.nodes[0]
-        package_hex = []
-        # M1
-        first_coin_a = self.coins.pop()
-        # Deduct reasonable fee and make 2 outputs
-        parent_value = (first_coin_a["amount"] - Decimal("200.0")) / 2
-        inputs = [{"txid": first_coin_a["txid"], "vout": 0}]
-        outputs = [
-            {self.address: parent_value},
-            {ADDRESS_ECREG_P2SH_OP_TRUE: parent_value},
-        ]
-        rawtx = node.createrawtransaction(inputs, outputs)
-
-        parent_signed = node.signrawtransactionwithkey(
-            hexstring=rawtx, privkeys=self.privkeys
-        )
-        assert parent_signed["complete"]
-        parent_tx = FromHex(CTransaction(), parent_signed["hex"])
-        pad_tx(parent_tx)
-        parent_txid = parent_tx.rehash()
-        node.sendrawtransaction(parent_signed["hex"])
-
-        # Chain M2...M49
-        spk = parent_tx.vout[0].scriptPubKey.hex()
-        value = parent_value
-        txid = parent_txid
-        for _ in range(48):
-            (tx, txhex, value, spk) = make_chain(
-                node, self.address, self.privkeys, txid, value, 0, spk
-            )
-            pad_tx(tx)
-            txid = tx.hash
-            node.sendrawtransaction(txhex)
-
-        # P1
-        value_p1 = parent_value - Decimal("100")
-        rawtx_p1 = node.createrawtransaction(
-            [{"txid": parent_txid, "vout": 1}], [{self.address: value_p1}]
-        )
-        tx_child_p1 = FromHex(CTransaction(), rawtx_p1)
-        tx_child_p1.vin[0].scriptSig = SCRIPTSIG_OP_TRUE
-        pad_tx(tx_child_p1)
-        tx_child_p1_hex = tx_child_p1.serialize().hex()
-        package_hex.append(tx_child_p1_hex)
-        tx_child_p1_spk = tx_child_p1.vout[0].scriptPubKey.hex()
-
-        # P2
-        (_, tx_child_p2_hex, _, _) = make_chain(
-            node,
-            self.address,
-            self.privkeys,
-            tx_child_p1.hash,
-            value_p1,
-            0,
-            tx_child_p1_spk,
-        )
-        package_hex.append(tx_child_p2_hex)
-
-        assert_equal(49, node.getmempoolinfo()["size"])
-        assert_equal(2, len(package_hex))
-        testres = node.testmempoolaccept(rawtxs=package_hex)
-        assert_equal(len(testres), len(package_hex))
-        for txres in testres:
-            assert_equal(txres["package-error"], "package-mempool-limits")
-
-        # Clear mempool and check that the package passes now
-        self.generate(node, 1)
-        assert all(res["allowed"] for res in node.testmempoolaccept(rawtxs=package_hex))
-
-    def test_anc_count_limits(self):
-        """Create a 'V' shaped chain with 49 transactions in the mempool and 3 in the package:
-        M1a
-         ^                   M1b
-          M2a                ^
-           .                M2b
-            .               .
-             .             .
-             M25a        M24b
-               ^         ^
-                Pa     Pb
-                 ^    ^
-                   Pc
-        The lowest descendant, Pc, exceeds ancestor limits, but only if the in-mempool
-        and in-package ancestors are all considered together.
-        """
-        node = self.nodes[0]
-        assert_equal(0, node.getmempoolinfo()["size"])
-        package_hex = []
-        parents_tx = []
-        values = []
-        scripts = []
-
-        self.log.info(
-            "Check that in-mempool and in-package ancestors are calculated "
-            "properly in packages"
-        )
-
-        # Two chains of 26 & 25 transactions
-        for chain_length in [26, 25]:
-            spk = None
-            top_coin = self.coins.pop()
-            txid = top_coin["txid"]
-            value = top_coin["amount"]
-            for i in range(chain_length):
-                (tx, txhex, value, spk) = make_chain(
-                    node, self.address, self.privkeys, txid, value, 0, spk
-                )
-                txid = tx.get_id()
-                if i < chain_length - 1:
-                    node.sendrawtransaction(txhex)
-                else:
-                    # Save the last transaction for the package
-                    package_hex.append(txhex)
-                    parents_tx.append(tx)
-                    scripts.append(spk)
-                    values.append(value)
-
-        # Child Pc
-        child_hex = create_child_with_parents(
-            node, self.address, self.privkeys, parents_tx, values, scripts
-        )
-        package_hex.append(child_hex)
-
-        assert_equal(49, node.getmempoolinfo()["size"])
-        assert_equal(3, len(package_hex))
-        testres_too_long = node.testmempoolaccept(rawtxs=package_hex)
-        for txres in testres_too_long:
-            assert_equal(txres["package-error"], "package-mempool-limits")
-
-        # Clear mempool and check that the package passes now
-        self.generate(node, 1)
-        assert all(
-            res["allowed"] is True for res in node.testmempoolaccept(rawtxs=package_hex)
-        )
-
-    def test_anc_count_limits_2(self):
-        """Create a 'Y' shaped chain with 49 transactions in the mempool and 2 in the package:
-        M1a
-         ^              M1b
-          M2a           ^
-           .           M2b
-            .          .
-             .        .
-             M25a   M24b
-               ^    ^
-                 Pc
-                 ^
-                 Pd
-        The lowest descendant, Pc, exceeds ancestor limits, but only if the in-mempool
-        and in-package ancestors are all considered together.
-        """
-        node = self.nodes[0]
-        assert_equal(0, node.getmempoolinfo()["size"])
-        parents_tx = []
-        values = []
-        scripts = []
-
-        self.log.info(
-            "Check that in-mempool and in-package ancestors are calculated properly in"
-            " packages"
-        )
-        # Two chains of 25 & 24 transactions
-        for chain_length in [25, 24]:
-            spk = None
-            top_coin = self.coins.pop()
-            txid = top_coin["txid"]
-            value = top_coin["amount"]
-            for i in range(chain_length):
-                (tx, txhex, value, spk) = make_chain(
-                    node, self.address, self.privkeys, txid, value, 0, spk
-                )
-                txid = tx.get_id()
-                node.sendrawtransaction(txhex)
-                if i == chain_length - 1:
-                    # last 2 transactions will be the parents of Pc
-                    parents_tx.append(tx)
-                    values.append(value)
-                    scripts.append(spk)
-
-        # Child Pc
-        pc_hex = create_child_with_parents(
-            node, self.address, self.privkeys, parents_tx, values, scripts
-        )
-        pc_tx = FromHex(CTransaction(), pc_hex)
-        pc_value = sum(values) - Decimal("100.00")
-        pc_spk = pc_tx.vout[0].scriptPubKey.hex()
-
-        # Child Pd
-        (_, pd_hex, _, _) = make_chain(
-            node, self.address, self.privkeys, pc_tx.get_id(), pc_value, 0, pc_spk
-        )
-
-        assert_equal(49, node.getmempoolinfo()["size"])
-        testres_too_long = node.testmempoolaccept(rawtxs=[pc_hex, pd_hex])
-        for txres in testres_too_long:
-            assert_equal(txres["package-error"], "package-mempool-limits")
-
-        # Clear mempool and check that the package passes now
-        self.generate(node, 1)
-        assert all(
-            res["allowed"] is True
-            for res in node.testmempoolaccept(rawtxs=[pc_hex, pd_hex])
-        )
-
-    def test_anc_count_limits_bushy(self):
-        """Create a tree with 45 transactions in the mempool and 6 in the package:
-        M1...M9 M10...M18 M19...M27 M28...M36 M37...M45
-            ^      ^          ^         ^         ^             (each with 9 parents)
-            P0     P1         P2        P3        P4
-             ^     ^          ^         ^         ^              (5 parents)
-                              PC
-        Where M(9i+1)...M+(9i+9) are the parents of Pi and P0, P1, P2, P3, and P4 are the parents of PC.
-        P0... P4 individually only have 9 parents each, and PC has no in-mempool parents. But
-        combined, PC has 50 in-mempool and in-package parents.
-        """
-        node = self.nodes[0]
-        assert_equal(0, node.getmempoolinfo()["size"])
-        package_hex = []
-        parent_txns = []
-        parent_values = []
-        scripts = []
-        # Make package transactions P0 ... P4
-        for _ in range(5):
-            gp_tx = []
-            gp_values = []
-            gp_scripts = []
-            # Make mempool transactions M(9i+1)...M(9i+9)
-            for _ in range(9):
-                parent_coin = self.coins.pop()
-                value = parent_coin["amount"]
-                txid = parent_coin["txid"]
-                (tx, txhex, value, spk) = make_chain(
-                    node, self.address, self.privkeys, txid, value
-                )
-                gp_tx.append(tx)
-                gp_values.append(value)
-                gp_scripts.append(spk)
-                node.sendrawtransaction(txhex)
-            # Package transaction Pi
-            pi_hex = create_child_with_parents(
-                node, self.address, self.privkeys, gp_tx, gp_values, gp_scripts
-            )
-            package_hex.append(pi_hex)
-            pi_tx = FromHex(CTransaction(), pi_hex)
-            parent_txns.append(pi_tx)
-            parent_values.append(Decimal(pi_tx.vout[0].nValue) / XEC)
-            scripts.append(pi_tx.vout[0].scriptPubKey.hex())
-        # Package transaction PC
-        package_hex.append(
-            create_child_with_parents(
-                node, self.address, self.privkeys, parent_txns, parent_values, scripts
-            )
-        )
-
-        assert_equal(45, node.getmempoolinfo()["size"])
-        assert_equal(6, len(package_hex))
-        testres = node.testmempoolaccept(rawtxs=package_hex)
-        for txres in testres:
-            assert_equal(txres["package-error"], "package-mempool-limits")
-
-        # Clear mempool and check that the package passes now
-        self.generate(node, 1)
-        assert all(
-            res["allowed"] is True for res in node.testmempoolaccept(rawtxs=package_hex)
-        )
-
-    def test_anc_size_limits(self):
-        """Test Case with 2 independent transactions in the mempool and a parent + child in the
-        package, where the package parent is the child of both mempool transactions (30KB each):
-              A     B
-               ^   ^
-                 C
-                 ^
-                 D
-        The lowest descendant, D, exceeds ancestor size limits, but only if the in-mempool
-        and in-package ancestors are all considered together.
-        """
-        node = self.nodes[0]
-
-        assert_equal(0, node.getmempoolinfo()["size"])
-        parents_tx = []
-        values = []
-        scripts = []
-        target_size = 30_000
-        # 10 sats/B
-        high_fee = Decimal("3000.00")
-        self.log.info(
-            "Check that in-mempool and in-package ancestor size limits are calculated"
-            " properly in packages"
-        )
-        # Mempool transactions A and B
-        for _ in range(2):
-            spk = None
-            top_coin = self.coins.pop()
-            txid = top_coin["txid"]
-            value = top_coin["amount"]
-            (tx, _, _, _) = make_chain(
-                node, self.address, self.privkeys, txid, value, 0, spk, high_fee
-            )
-            bulked_tx = bulk_transaction(tx, node, target_size, self.privkeys)
-            node.sendrawtransaction(ToHex(bulked_tx))
-            parents_tx.append(bulked_tx)
-            values.append(Decimal(bulked_tx.vout[0].nValue) / XEC)
-            scripts.append(bulked_tx.vout[0].scriptPubKey.hex())
-
-        # Package transaction C
-        small_pc_hex = create_child_with_parents(
-            node, self.address, self.privkeys, parents_tx, values, scripts, high_fee
-        )
-        pc_tx = bulk_transaction(
-            FromHex(CTransaction(), small_pc_hex), node, target_size, self.privkeys
-        )
-        pc_value = Decimal(pc_tx.vout[0].nValue) / XEC
-        pc_spk = pc_tx.vout[0].scriptPubKey.hex()
-        pc_hex = ToHex(pc_tx)
-
-        # Package transaction D
-        (small_pd, _, val, spk) = make_chain(
-            node,
-            self.address,
-            self.privkeys,
-            pc_tx.rehash(),
-            pc_value,
-            0,
-            pc_spk,
-            high_fee,
-        )
-        prevtxs = [
-            {
-                "txid": pc_tx.get_id(),
-                "vout": 0,
-                "scriptPubKey": spk,
-                "amount": pc_value,
-            }
-        ]
-        pd_tx = bulk_transaction(small_pd, node, target_size, self.privkeys, prevtxs)
-        pd_hex = ToHex(pd_tx)
-
-        assert_equal(2, node.getmempoolinfo()["size"])
-        testres_too_heavy = node.testmempoolaccept(rawtxs=[pc_hex, pd_hex])
-        for txres in testres_too_heavy:
-            assert_equal(txres["package-error"], "package-mempool-limits")
-
-        # Clear mempool and check that the package passes now
-        self.generate(node, 1)
-        assert all(
-            res["allowed"] is True
-            for res in node.testmempoolaccept(rawtxs=[pc_hex, pd_hex])
-        )
-
-    def test_desc_size_limits(self):
-        """Create 3 mempool transactions and 2 package transactions (25KB each):
-              Ma
-             ^ ^
-            Mb  Mc
-           ^     ^
-          Pd      Pe
-        The top ancestor in the package exceeds descendant size limits but only if the in-mempool
-        and in-package descendants are all considered together.
-        """
-        node = self.nodes[0]
-        assert_equal(0, node.getmempoolinfo()["size"])
-        target_size = 21_000
-        # 10 sats/vB
-        high_fee = Decimal("2100.00")
-        self.log.info(
-            "Check that in-mempool and in-package descendant sizes are calculated"
-            " properly in packages"
-        )
-        # Top parent in mempool, Ma
-        first_coin = self.coins.pop()
-        # Deduct fee and make 2 outputs
-        parent_value = (first_coin["amount"] - high_fee) / 2
-        inputs = [{"txid": first_coin["txid"], "vout": 0}]
-        outputs = [
-            {self.address: parent_value},
-            {ADDRESS_ECREG_P2SH_OP_TRUE: parent_value},
-        ]
-        rawtx = node.createrawtransaction(inputs, outputs)
-        parent_tx = bulk_transaction(
-            FromHex(CTransaction(), rawtx), node, target_size, self.privkeys
-        )
-        node.sendrawtransaction(ToHex(parent_tx))
-
-        package_hex = []
-        # Two legs (left and right)
-        for j in range(2):
-            # Mempool transaction (Mb and Mc)
-            spk = parent_tx.vout[j].scriptPubKey.hex()
-            value = Decimal(parent_tx.vout[j].nValue) / XEC
-            txid = parent_tx.get_id()
-            prevtxs = [
-                {
-                    "txid": txid,
-                    "vout": j,
-                    "scriptPubKey": spk,
-                    "amount": value,
-                }
-            ]
-            if j == 0:
-                # normal key
-                (tx_small, _, _, _) = make_chain(
-                    node, self.address, self.privkeys, txid, value, j, spk, high_fee
-                )
-                mempool_tx = bulk_transaction(
-                    tx_small, node, target_size, self.privkeys, prevtxs
-                )
-
-            else:
-                # OP_TRUE
-                inputs = [{"txid": txid, "vout": 1}]
-                outputs = {self.address: value - high_fee}
-                small_tx = FromHex(
-                    CTransaction(), node.createrawtransaction(inputs, outputs)
-                )
-                mempool_tx = bulk_transaction(
-                    small_tx, node, target_size, None, prevtxs
-                )
-            node.sendrawtransaction(ToHex(mempool_tx))
-
-            # Package transaction (Pd and Pe)
-            spk = mempool_tx.vout[0].scriptPubKey.hex()
-            value = Decimal(mempool_tx.vout[0].nValue) / XEC
-            txid = mempool_tx.get_id()
-            (tx_small, _, _, _) = make_chain(
-                node, self.address, self.privkeys, txid, value, 0, spk, high_fee
-            )
-            prevtxs = [
-                {
-                    "txid": txid,
-                    "vout": 0,
-                    "scriptPubKey": spk,
-                    "amount": value,
-                }
-            ]
-            package_tx = bulk_transaction(
-                tx_small, node, target_size, self.privkeys, prevtxs
-            )
-            package_hex.append(ToHex(package_tx))
-
-        assert_equal(3, node.getmempoolinfo()["size"])
-        assert_equal(2, len(package_hex))
-        testres_too_heavy = node.testmempoolaccept(rawtxs=package_hex)
-        for txres in testres_too_heavy:
-            assert_equal(txres["package-error"], "package-mempool-limits")
-
-        # Clear mempool and check that the package passes now
-        self.generate(node, 1)
-        assert all(
-            res["allowed"] is True for res in node.testmempoolaccept(rawtxs=package_hex)
-        )
-
-
-if __name__ == "__main__":
-    MempoolPackageLimitsTest().main()
diff --git a/test/functional/mempool_packages.py b/test/functional/mempool_packages.py
index 10ff68ef4..aea0ac503 100755
--- a/test/functional/mempool_packages.py
+++ b/test/functional/mempool_packages.py
@@ -1,393 +1,170 @@
 #!/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 descendant package tracking code."""
 
 from decimal import Decimal
 
 from test_framework.p2p import P2PTxInvStore
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import assert_equal, assert_raises_rpc_error, satoshi_round
+from test_framework.util import assert_equal, satoshi_round
 
-# default limits
 MAX_ANCESTORS = 50
-MAX_DESCENDANTS = 50
-
-# custom limits for node1
-MAX_ANCESTORS_CUSTOM = 5
-
-FAR_IN_THE_FUTURE = 2000000000
 
 
 class MempoolPackagesTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 2
-        common_params = [
-            "-maxorphantx=1000",
-            "-deprecatedrpc=mempool_ancestors_descendants",
-            # This test tests mempool ancestor chain limits, which are no longer
-            # enforced after wellington, so we need to force wellington to
-            # activate in the distant future
-            f"-wellingtonactivationtime={FAR_IN_THE_FUTURE}",
-        ]
-        self.extra_args = [
-            common_params,
-            common_params + [f"-limitancestorcount={MAX_ANCESTORS_CUSTOM}"],
-        ]
+        self.extra_args = [["-maxorphantx=1000"]] * self.num_nodes
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
     # Build a transaction that spends parent_txid:vout
     # Return amount sent
     def chain_transaction(self, node, parent_txid, vout, value, fee, num_outputs):
         send_value = satoshi_round((value - fee) / num_outputs)
         inputs = [{"txid": parent_txid, "vout": vout}]
         outputs = {}
         for _ in range(num_outputs):
             outputs[node.getnewaddress()] = send_value
         rawtx = node.createrawtransaction(inputs, outputs)
         signedtx = node.signrawtransactionwithwallet(rawtx)
         txid = node.sendrawtransaction(signedtx["hex"])
         fulltx = node.getrawtransaction(txid, 1)
         # make sure we didn't generate a change output
         assert len(fulltx["vout"]) == num_outputs
         return (txid, send_value)
 
     def run_test(self):
         # Mine some blocks and have them mature.
         # keep track of invs
         peer_inv_store = self.nodes[0].add_p2p_connection(P2PTxInvStore())
         self.generate(self.nodes[0], 101)
         utxo = self.nodes[0].listunspent(10)
         txid = utxo[0]["txid"]
-        vout = utxo[0]["vout"]
         value = utxo[0]["amount"]
-        assert "ancestorcount" not in utxo[0]
-        assert "ancestorsize" not in utxo[0]
-        assert "ancestorfees" not in utxo[0]
 
         fee = Decimal("100")
         # MAX_ANCESTORS transactions off a confirmed tx should be fine
         chain = []
-        ancestor_size = 0
-        ancestor_fees = Decimal(0)
         for i in range(MAX_ANCESTORS):
             (txid, sent_value) = self.chain_transaction(
                 self.nodes[0], txid, 0, value, fee, 1
             )
             value = sent_value
             chain.append(txid)
 
-            # Check that listunspent ancestor{count, size, fees} yield the
-            # correct results
-            wallet_unspent = self.nodes[0].listunspent(minconf=0)
-            this_unspent = next(
-                utxo_info for utxo_info in wallet_unspent if utxo_info["txid"] == txid
-            )
-            assert_equal(this_unspent["ancestorcount"], i + 1)
-            ancestor_size += self.nodes[0].getrawtransaction(txid=txid, verbose=True)[
-                "size"
-            ]
-            assert_equal(this_unspent["ancestorsize"], ancestor_size)
-            ancestor_fees -= self.nodes[0].gettransaction(txid=txid)["fee"]
-            assert_equal(this_unspent["ancestorfees"], ancestor_fees)
-
         # Wait until mempool transactions have passed initial broadcast
         # (sent inv and received getdata)
         # Otherwise, getrawmempool may be inconsistent with getmempoolentry if
         # unbroadcast changes in between
         peer_inv_store.wait_for_broadcast(chain)
 
-        # Check mempool has MAX_ANCESTORS transactions in it, and descendant and ancestor
-        # count and fees should look correct
+        # Check mempool has MAX_ANCESTORS transactions in it
         mempool = self.nodes[0].getrawmempool(True)
         assert_equal(len(mempool), MAX_ANCESTORS)
         descendant_count = 1
         descendant_fees = 0
         descendant_size = 0
 
-        assert_equal(ancestor_size, sum([mempool[tx]["size"] for tx in mempool]))
+        ancestor_size = sum([mempool[tx]["size"] for tx in mempool])
         ancestor_count = MAX_ANCESTORS
-        assert_equal(
-            ancestor_fees, sum([mempool[tx]["fees"]["base"] for tx in mempool])
-        )
+        ancestor_fees = sum([mempool[tx]["fees"]["base"] for tx in mempool])
 
         descendants = []
         ancestors = list(chain)
         for x in reversed(chain):
             # Check that getmempoolentry is consistent with getrawmempool
             entry = self.nodes[0].getmempoolentry(x)
             assert_equal(entry, mempool[x])
-            # Check that the descendant calculations are correct
-            assert_equal(mempool[x]["descendantcount"], descendant_count)
             descendant_fees += mempool[x]["fees"]["base"]
             assert_equal(mempool[x]["fees"]["modified"], mempool[x]["fees"]["base"])
-            assert_equal(mempool[x]["fees"]["descendant"], descendant_fees)
             descendant_size += mempool[x]["size"]
-            assert_equal(mempool[x]["descendantsize"], descendant_size)
             descendant_count += 1
 
-            # Check that ancestor calculations are correct
-            assert_equal(mempool[x]["ancestorcount"], ancestor_count)
-            assert_equal(mempool[x]["fees"]["ancestor"], ancestor_fees)
-            assert_equal(mempool[x]["ancestorsize"], ancestor_size)
             ancestor_size -= mempool[x]["size"]
             ancestor_fees -= mempool[x]["fees"]["base"]
             ancestor_count -= 1
 
             # Check that parent/child list is correct
             assert_equal(mempool[x]["spentby"], descendants[-1:])
             assert_equal(mempool[x]["depends"], ancestors[-2:-1])
 
             # Check that getmempooldescendants is correct
             assert_equal(
                 sorted(descendants), sorted(self.nodes[0].getmempooldescendants(x))
             )
 
             # Check getmempooldescendants verbose output is correct
             for descendant, dinfo in (
                 self.nodes[0].getmempooldescendants(x, True).items()
             ):
                 assert_equal(dinfo["depends"], [chain[chain.index(descendant) - 1]])
-                if dinfo["descendantcount"] > 1:
-                    assert_equal(dinfo["spentby"], [chain[chain.index(descendant) + 1]])
-                else:
-                    assert_equal(dinfo["spentby"], [])
             descendants.append(x)
 
             # Check that getmempoolancestors is correct
             ancestors.remove(x)
             assert_equal(
                 sorted(ancestors), sorted(self.nodes[0].getmempoolancestors(x))
             )
 
             # Check that getmempoolancestors verbose output is correct
             for ancestor, ainfo in self.nodes[0].getmempoolancestors(x, True).items():
                 assert_equal(ainfo["spentby"], [chain[chain.index(ancestor) + 1]])
-                if ainfo["ancestorcount"] > 1:
-                    assert_equal(ainfo["depends"], [chain[chain.index(ancestor) - 1]])
-                else:
-                    assert_equal(ainfo["depends"], [])
+
+        # Check we covered all the ancestors
+        assert_equal(ancestor_size, 0)
+        assert_equal(ancestor_fees, 0)
 
         # Check that getmempoolancestors/getmempooldescendants correctly handle
         # verbose=true
         v_ancestors = self.nodes[0].getmempoolancestors(chain[-1], True)
         assert_equal(len(v_ancestors), len(chain) - 1)
         for x in v_ancestors.keys():
             assert_equal(mempool[x], v_ancestors[x])
         assert chain[-1] not in v_ancestors.keys()
 
         v_descendants = self.nodes[0].getmempooldescendants(chain[0], True)
         assert_equal(len(v_descendants), len(chain) - 1)
         for x in v_descendants.keys():
             assert_equal(mempool[x], v_descendants[x])
         assert chain[0] not in v_descendants.keys()
 
-        # Check that ancestor modified fees includes fee deltas from
-        # prioritisetransaction
-        self.nodes[0].prioritisetransaction(txid=chain[0], fee_delta=1000)
-        mempool = self.nodes[0].getrawmempool(True)
-        ancestor_fees = 0
-        for x in chain:
-            ancestor_fees += mempool[x]["fees"]["base"]
-            assert_equal(
-                mempool[x]["fees"]["ancestor"], ancestor_fees + Decimal("10.00")
-            )
-
-        # Undo the prioritisetransaction for later tests
-        self.nodes[0].prioritisetransaction(txid=chain[0], fee_delta=-1000)
-
-        # Check that descendant modified fees includes fee deltas from
-        # prioritisetransaction
-        self.nodes[0].prioritisetransaction(txid=chain[-1], fee_delta=1000)
-        mempool = self.nodes[0].getrawmempool(True)
-
-        descendant_fees = 0
-        for x in reversed(chain):
-            descendant_fees += mempool[x]["fees"]["base"]
-            assert_equal(
-                mempool[x]["fees"]["descendant"], descendant_fees + Decimal("10.00")
-            )
-
-        # Adding one more transaction on to the chain should fail.
-        assert_raises_rpc_error(
-            -26,
-            "too-long-mempool-chain",
-            self.chain_transaction,
-            self.nodes[0],
-            txid,
-            vout,
-            value,
-            fee,
-            1,
-        )
-
         # Check that prioritising a tx before it's added to the mempool works
         # First clear the mempool by mining a block.
         self.generate(self.nodes[0], 1)
         assert_equal(len(self.nodes[0].getrawmempool()), 0)
         # Prioritise a transaction that has been mined, then add it back to the
         # mempool by using invalidateblock.
         self.nodes[0].prioritisetransaction(txid=chain[-1], fee_delta=2000)
         self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
         # Keep node1's tip synced with node0
         self.nodes[1].invalidateblock(self.nodes[1].getbestblockhash())
 
         # Now check that the transaction is in the mempool, with the right
         # modified fee
         mempool = self.nodes[0].getrawmempool(True)
 
-        descendant_fees = 0
         for x in reversed(chain):
-            descendant_fees += mempool[x]["fees"]["base"]
             if x == chain[-1]:
                 assert_equal(
                     mempool[x]["fees"]["modified"],
                     mempool[x]["fees"]["base"] + satoshi_round(20.00),
                 )
-            assert_equal(
-                mempool[x]["fees"]["descendant"], descendant_fees + satoshi_round(20.00)
-            )
 
-        # Check that node1's mempool is as expected (-> custom ancestor limit)
+        # Check that node1's mempool is as expected
         mempool0 = self.nodes[0].getrawmempool(False)
         mempool1 = self.nodes[1].getrawmempool(False)
-        assert_equal(len(mempool1), MAX_ANCESTORS_CUSTOM)
-        assert set(mempool1).issubset(set(mempool0))
-        for tx in chain[:MAX_ANCESTORS_CUSTOM]:
-            assert tx in mempool1
+        assert_equal(mempool0, mempool1)
         # TODO: more detailed check of node1's mempool (fees etc.)
         # check transaction unbroadcast info (should be false if in both
         # mempools)
         mempool = self.nodes[0].getrawmempool(True)
         for tx in mempool:
             assert_equal(mempool[tx]["unbroadcast"], False)
 
-        # TODO: test ancestor size limits
-
-        # Now test descendant chain limits
-        txid = utxo[1]["txid"]
-        value = utxo[1]["amount"]
-        vout = utxo[1]["vout"]
-
-        transaction_package = []
-        tx_children = []
-        # First create one parent tx with 10 children
-        (txid, sent_value) = self.chain_transaction(
-            self.nodes[0], txid, vout, value, fee, 10
-        )
-        parent_transaction = txid
-        for i in range(10):
-            transaction_package.append({"txid": txid, "vout": i, "amount": sent_value})
-
-        # Sign and send up to MAX_DESCENDANT transactions chained off the
-        # parent tx
-        for _ in range(MAX_DESCENDANTS - 1):
-            utxo = transaction_package.pop(0)
-            (txid, sent_value) = self.chain_transaction(
-                self.nodes[0], utxo["txid"], utxo["vout"], utxo["amount"], fee, 10
-            )
-            if utxo["txid"] is parent_transaction:
-                tx_children.append(txid)
-            for j in range(10):
-                transaction_package.append(
-                    {"txid": txid, "vout": j, "amount": sent_value}
-                )
-
-        mempool = self.nodes[0].getrawmempool(True)
-        assert_equal(mempool[parent_transaction]["descendantcount"], MAX_DESCENDANTS)
-        assert_equal(
-            sorted(mempool[parent_transaction]["spentby"]), sorted(tx_children)
-        )
-
-        for child in tx_children:
-            assert_equal(mempool[child]["depends"], [parent_transaction])
-
-        # Sending one more chained transaction will fail
-        utxo = transaction_package.pop(0)
-        assert_raises_rpc_error(
-            -26,
-            "too-long-mempool-chain",
-            self.chain_transaction,
-            self.nodes[0],
-            utxo["txid"],
-            utxo["vout"],
-            utxo["amount"],
-            fee,
-            10,
-        )
-
-        # TODO: check that node1's mempool is as expected
-
-        # TODO: test descendant size limits
-
-        # Test reorg handling
-        # First, the basics:
-        self.generate(self.nodes[0], 1)
-        self.nodes[1].invalidateblock(self.nodes[0].getbestblockhash())
-        self.nodes[1].reconsiderblock(self.nodes[0].getbestblockhash())
-
-        # Now test the case where node1 has a transaction T in its mempool that
-        # depends on transactions A and B which are in a mined block, and the
-        # block containing A and B is disconnected, AND B is not accepted back
-        # into node1's mempool because its ancestor count is too high.
-
-        # Create 8 transactions, like so:
-        # Tx0 -> Tx1 (vout0)
-        #   \--> Tx2 (vout1) -> Tx3 -> Tx4 -> Tx5 -> Tx6 -> Tx7
-        #
-        # Mine them in the next block, then generate a new tx8 that spends
-        # Tx1 and Tx7, and add to node1's mempool, then disconnect the
-        # last block.
-
-        # Create tx0 with 2 outputs
-        utxo = self.nodes[0].listunspent()
-        txid = utxo[0]["txid"]
-        value = utxo[0]["amount"]
-        vout = utxo[0]["vout"]
-
-        send_value = satoshi_round((value - fee) / 2)
-        inputs = [{"txid": txid, "vout": vout}]
-        outputs = {}
-        for _ in range(2):
-            outputs[self.nodes[0].getnewaddress()] = send_value
-        rawtx = self.nodes[0].createrawtransaction(inputs, outputs)
-        signedtx = self.nodes[0].signrawtransactionwithwallet(rawtx)
-        txid = self.nodes[0].sendrawtransaction(signedtx["hex"])
-        tx0_id = txid
-        value = send_value
-
-        # Create tx1
-        tx1_id, _ = self.chain_transaction(self.nodes[0], tx0_id, 0, value, fee, 1)
-
-        # Create tx2-7
-        vout = 1
-        txid = tx0_id
-        for _ in range(6):
-            (txid, sent_value) = self.chain_transaction(
-                self.nodes[0], txid, vout, value, fee, 1
-            )
-            vout = 0
-            value = sent_value
-
-        # Mine these in a block
-        self.generate(self.nodes[0], 1)
-
-        # Now generate tx8, with a big fee
-        inputs = [{"txid": tx1_id, "vout": 0}, {"txid": txid, "vout": 0}]
-        outputs = {self.nodes[0].getnewaddress(): send_value + value - 4 * fee}
-        rawtx = self.nodes[0].createrawtransaction(inputs, outputs)
-        signedtx = self.nodes[0].signrawtransactionwithwallet(rawtx)
-        txid = self.nodes[0].sendrawtransaction(signedtx["hex"])
-        self.sync_mempools()
-
-        # Now try to disconnect the tip on each node...
-        self.nodes[1].invalidateblock(self.nodes[1].getbestblockhash())
-        self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
-        self.sync_blocks()
-
 
 if __name__ == "__main__":
     MempoolPackagesTest().main()
diff --git a/test/functional/mempool_updatefromblock.py b/test/functional/mempool_updatefromblock.py
index 99e239baa..8233c051e 100755
--- a/test/functional/mempool_updatefromblock.py
+++ b/test/functional/mempool_updatefromblock.py
@@ -1,173 +1,152 @@
 #!/usr/bin/env python3
 # Copyright (c) 2020 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 mempool descendants/ancestors information update.
 
 Test mempool update of transaction descendants/ancestors information (count, size)
 when transactions have been re-added from a disconnected block to the mempool.
 """
 import time
 from decimal import Decimal
 
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal
 
 
 class MempoolUpdateFromBlockTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 1
-        self.limit_ancestor_descendant_count = 60
-        self.extra_args = [
-            [
-                "-limitdescendantsize=5000",
-                "-limitancestorsize=5000",
-                f"-limitancestorcount={self.limit_ancestor_descendant_count}",
-                f"-limitdescendantcount={self.limit_ancestor_descendant_count}",
-                "-deprecatedrpc=mempool_ancestors_descendants",
-            ],
-        ]
+        self.ancestor_descendant_count = 60
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
     def transaction_graph_test(
         self,
         size,
         n_tx_to_mine=None,
         start_input_txid="",
         end_address="",
         fee=Decimal(1000),
     ):
         """Create an acyclic tournament (a type of directed graph) of
         transactions and use it for testing.
 
         Keyword arguments:
         size -- the order N of the tournament which is equal to the number
                 of the created transactions
         n_tx_to_mine -- the number of transaction that should be mined into a block
 
         If all of the N created transactions tx[0]..tx[N-1] reside in the mempool,
         the following holds:
             the tx[K] transaction:
             - has N-K descendants (including this one), and
             - has K+1 ancestors (including this one)
 
         More details: https://en.wikipedia.org/wiki/Tournament_(graph_theory)
         """
 
         if not start_input_txid:
             start_input_txid = self.nodes[0].getblock(self.nodes[0].getblockhash(1))[
                 "tx"
             ][0]
 
         if not end_address:
             end_address = self.nodes[0].getnewaddress()
 
         first_block_hash = ""
         tx_id = []
         tx_size = []
         self.log.info(f"Creating {size} transactions...")
         for i in range(0, size):
             self.log.debug(f"Preparing transaction #{i}...")
             # Prepare inputs.
             if i == 0:
                 inputs = [{"txid": start_input_txid, "vout": 0}]
                 inputs_value = self.nodes[0].gettxout(start_input_txid, 0)["value"]
             else:
                 inputs = []
                 inputs_value = 0
                 for j, tx in enumerate(tx_id[0:i]):
                     # Transaction tx[K] is a child of each of previous
                     # transactions tx[0]..tx[K-1] at their output K-1.
                     vout = i - j - 1
                     inputs.append({"txid": tx_id[j], "vout": vout})
                     inputs_value += self.nodes[0].gettxout(tx, vout)["value"]
 
             self.log.debug(f"inputs={inputs}")
             self.log.debug(f"inputs_value={inputs_value}")
 
             # Prepare outputs.
             tx_count = i + 1
             if tx_count < size:
                 # Transaction tx[K] is an ancestor of each of subsequent
                 # transactions tx[K+1]..tx[N-1].
                 n_outputs = size - tx_count
                 output_value = ((inputs_value - fee) / Decimal(n_outputs)).quantize(
                     Decimal("0.01")
                 )
                 outputs = {}
                 for _ in range(n_outputs):
                     outputs[self.nodes[0].getnewaddress()] = output_value
             else:
                 output_value = (inputs_value - fee).quantize(Decimal("0.01"))
                 outputs = {end_address: output_value}
 
             self.log.debug(f"output_value={output_value}")
             self.log.debug(f"outputs={outputs}")
 
             # Create a new transaction.
             unsigned_raw_tx = self.nodes[0].createrawtransaction(inputs, outputs)
             signed_raw_tx = self.nodes[0].signrawtransactionwithwallet(unsigned_raw_tx)
             tx_id.append(self.nodes[0].sendrawtransaction(signed_raw_tx["hex"]))
             tx_size.append(self.nodes[0].getmempoolentry(tx_id[-1])["size"])
 
             if tx_count in n_tx_to_mine:
                 # The created transactions are mined into blocks by batches.
                 self.log.info(
                     f"The batch of {len(self.nodes[0].getrawmempool())} transactions "
                     "has been accepted into the mempool."
                 )
                 block_hash = self.generate(self.nodes[0], 1)[0]
                 if not first_block_hash:
                     first_block_hash = block_hash
                 assert_equal(len(self.nodes[0].getrawmempool()), 0)
                 self.log.info(
                     "All of the transactions from the current batch have been"
                     " mined into a block."
                 )
             elif tx_count == size:
                 # At the end all of the mined blocks are invalidated, and all of the created
                 # transactions should be re-added from disconnected blocks to
                 # the mempool.
                 self.log.info(
                     f"The last batch of {len(self.nodes[0].getrawmempool())} "
                     "transactions has been accepted into the mempool."
                 )
                 start = time.time()
                 self.nodes[0].invalidateblock(first_block_hash)
                 end = time.time()
                 assert_equal(len(self.nodes[0].getrawmempool()), size)
                 self.log.info(
                     "All of the recently mined transactions have been re-added into "
                     f"the mempool in {end - start} seconds."
                 )
 
-        self.log.info(
-            "Checking descendants/ancestors properties of all of the"
-            " in-mempool transactions..."
-        )
-        for k, tx in enumerate(tx_id):
-            self.log.debug(f"Check transaction #{k}.")
-            entry = self.nodes[0].getmempoolentry(tx)
-            assert_equal(entry["descendantcount"], size - k)
-            assert_equal(entry["descendantsize"], sum(tx_size[k:size]))
-            assert_equal(entry["ancestorcount"], k + 1)
-            assert_equal(entry["ancestorsize"], sum(tx_size[0 : (k + 1)]))
-
     def run_test(self):
         # Mine the transactions in batches so we get reorg_depth blocks
         # reorg'ed
         reorg_depth = 4
         self.transaction_graph_test(
-            size=self.limit_ancestor_descendant_count,
+            size=self.ancestor_descendant_count,
             n_tx_to_mine=range(
                 0,
-                self.limit_ancestor_descendant_count,
-                self.limit_ancestor_descendant_count // reorg_depth,
+                self.ancestor_descendant_count,
+                self.ancestor_descendant_count // reorg_depth,
             ),
         )
 
 
 if __name__ == "__main__":
     MempoolUpdateFromBlockTest().main()
diff --git a/test/functional/rpc_deprecated.py b/test/functional/rpc_deprecated.py
index 9e521d266..9ba575f4d 100755
--- a/test/functional/rpc_deprecated.py
+++ b/test/functional/rpc_deprecated.py
@@ -1,184 +1,160 @@
 #!/usr/bin/env python3
 # Copyright (c) 2017-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 deprecation of RPC calls."""
 import random
 
 from test_framework.avatools import AvaP2PInterface
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_equal,
     assert_greater_than,
     assert_raises_rpc_error,
     uint256_hex,
 )
 from test_framework.wallet import MiniWallet
 
 QUORUM_NODE_COUNT = 16
 FAR_IN_THE_FUTURE = 2000000000
 
 
 class DeprecatedRpcTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 2
         self.extra_args = [
             [
                 "-avaproofstakeutxodustthreshold=1000000",
                 "-avaproofstakeutxoconfirmations=1",
                 "-avacooldown=0",
                 "-avaminquorumstake=0",
                 "-avaminavaproofsnodecount=0",
                 "-avaminquorumconnectedstakeratio=0",
             ],
             [
                 "-avaproofstakeutxodustthreshold=1000000",
                 "-avaproofstakeutxoconfirmations=1",
                 "-avacooldown=0",
                 "-avaminquorumstake=0",
                 "-avaminavaproofsnodecount=0",
                 "-avaminquorumconnectedstakeratio=0",
                 "-deprecatedrpc=isfinalblock_noerror",
                 "-deprecatedrpc=isfinaltransaction_noerror",
                 "-deprecatedrpc=getblocktemplate_sigops",
                 "-deprecatedrpc=softforks",
-                # This test checks for the presence of the ancestor count in
-                # the listunspent output. However this is only displayed if the
-                # count is non-null, which will no longer be the case after
-                # wellington activation.
-                f"-wellingtonactivationtime={FAR_IN_THE_FUTURE}",
-                "-deprecatedrpc=mempool_ancestors_descendants",
             ],
         ]
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
     def run_test(self):
         # This test should be used to verify correct behaviour of deprecated
         # RPC methods with and without the -deprecatedrpc flags. For example:
         #
         # In set_test_params:
         # self.extra_args = [[], ["-deprecatedrpc=generate"]]
         #
         # In run_test:
         # self.log.info("Test generate RPC")
         # assert_raises_rpc_error(-32, 'The wallet generate rpc method is deprecated', self.nodes[0].rpc.generate, 1)
         # self.nodes[1].generate(1)
         self.log.info(
             "Check isfinaltransaction returns false when looking for unknown"
             " transactions"
         )
         self.sync_all()
         random_txid = uint256_hex(random.randint(0, 2**256 - 1))
         blockhash = self.nodes[0].getbestblockhash()
 
         self.log.info(
             "Check isfinalblock and isfinaltransaction returns false when the quorum is"
             " not established"
         )
         assert_raises_rpc_error(
             -1,
             "Avalanche is not ready to poll yet.",
             self.nodes[0].isfinalblock,
             blockhash,
         )
         assert not self.nodes[1].isfinalblock(blockhash)
 
         cb_txid = self.nodes[0].getblock(blockhash)["tx"][0]
         assert_raises_rpc_error(
             -1,
             "Avalanche is not ready to poll yet.",
             self.nodes[0].isfinaltransaction,
             cb_txid,
             blockhash,
         )
         assert not self.nodes[1].isfinaltransaction(cb_txid, blockhash)
 
         [
             [
                 node.add_p2p_connection(AvaP2PInterface(self, node))
                 for _ in range(0, QUORUM_NODE_COUNT)
             ]
             for node in self.nodes
         ]
 
         self.wait_until(
             lambda: all(
                 node.getavalancheinfo()["ready_to_poll"] is True for node in self.nodes
             )
         )
 
         assert_raises_rpc_error(
             -5,
             "No such transaction found in the provided block.",
             self.nodes[0].isfinaltransaction,
             random_txid,
             blockhash,
         )
         assert not self.nodes[1].isfinaltransaction(random_txid, blockhash)
 
         self.log.info(
             "Check the getblocktemplate output with and without"
             " -deprecatedrpc=getblocktemplate_sigops"
         )
 
         # Add a transaction to both nodes mempool
         wallet = MiniWallet(self.nodes[0])
         self.generate(wallet, 1)
         unconfirmed_tx = wallet.send_self_transfer(from_node=self.nodes[0])
         self.nodes[1].sendrawtransaction(unconfirmed_tx["hex"])
         assert unconfirmed_tx["txid"] in self.nodes[0].getrawmempool()
         assert unconfirmed_tx["txid"] in self.nodes[1].getrawmempool()
 
         block_template = self.nodes[0].getblocktemplate()
         block_template_txs = block_template.get("transactions", [])
         assert_greater_than(len(block_template_txs), 0)
 
         for tx in block_template_txs:
             assert "sigchecks" in tx
             assert "sigops" not in tx
         assert "sigchecklimit" in block_template
         assert "sigoplimit" not in block_template
 
         deprecated_block_template = self.nodes[1].getblocktemplate()
         deprecated_block_template_txs = deprecated_block_template.get(
             "transactions", []
         )
         assert_greater_than(len(deprecated_block_template_txs), 0)
 
         for tx in deprecated_block_template_txs:
             assert "sigchecks" in tx
             assert "sigops" in tx
         assert "sigchecklimit" in deprecated_block_template
         assert "sigoplimit" in deprecated_block_template
 
         self.log.info(
             "Check the getblockchaininfo output with and without"
             " -deprecatedrpc=softforks"
         )
         assert "softforks" not in self.nodes[0].getblockchaininfo()
         res = self.nodes[1].getblockchaininfo()
         assert_equal(res["softforks"], {})
 
-        txid = self.nodes[0].sendtoaddress(
-            self.nodes[0].get_deterministic_priv_key().address, 1000000
-        )
-        assert txid in self.nodes[0].getrawmempool()
-        utxo = self.nodes[0].listunspent(minconf=0, maxconf=0)[0]
-        assert "ancestorcount" not in utxo
-        assert "ancestorsize" not in utxo
-        assert "ancestorfees" not in utxo
-
-        txid = self.nodes[1].sendtoaddress(
-            self.nodes[1].get_deterministic_priv_key().address, 1000000
-        )
-        assert txid in self.nodes[1].getrawmempool()
-        utxo = self.nodes[1].listunspent(minconf=0, maxconf=0)[0]
-        assert "ancestorcount" in utxo
-        assert "ancestorsize" in utxo
-        assert "ancestorfees" in utxo
-
 
 if __name__ == "__main__":
     DeprecatedRpcTest().main()
diff --git a/test/functional/wallet_basic.py b/test/functional/wallet_basic.py
index cf1c6e1ad..8ae1fc06b 100755
--- a/test/functional/wallet_basic.py
+++ b/test/functional/wallet_basic.py
@@ -1,779 +1,695 @@
 #!/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 wallet."""
 from decimal import Decimal
 
 from test_framework.messages import CTransaction, FromHex
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_array_result,
     assert_equal,
     assert_fee_amount,
     assert_raises_rpc_error,
     count_bytes,
 )
 from test_framework.wallet_util import test_address
 
-FAR_IN_THE_FUTURE = 2000000000
-
 
 class WalletTest(BitcoinTestFramework):
-    WELLINGTON_FAR_FUTURE = f"-wellingtonactivationtime={int(9e9)}"
-
     def set_test_params(self):
         self.num_nodes = 4
         self.setup_clean_chain = True
         self.extra_args = [
             [
                 "-acceptnonstdtxn=1",
                 "-whitelist=noban@127.0.0.1",
-                # This test tests mempool ancestor chain limits, which are no
-                # longer enforced after wellington, so we need to force
-                # wellington to activate in the distant future
-                f"-wellingtonactivationtime={FAR_IN_THE_FUTURE}",
             ],
         ] * self.num_nodes
         self.supports_cli = False
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
     def setup_network(self):
         self.setup_nodes()
         # Only need nodes 0-2 running at start of test
         self.stop_node(3)
         self.connect_nodes(0, 1)
         self.connect_nodes(1, 2)
         self.connect_nodes(0, 2)
         self.sync_all(self.nodes[0:3])
 
     def check_fee_amount(self, curr_balance, balance_with_fee, fee_per_byte, tx_size):
         """Return curr_balance after asserting the fee was in range"""
         fee = balance_with_fee - curr_balance
         assert_fee_amount(fee, tx_size, fee_per_byte * 1000)
         return curr_balance
 
     def run_test(self):
         # Check that there's no UTXO on none of the nodes
         assert_equal(len(self.nodes[0].listunspent()), 0)
         assert_equal(len(self.nodes[1].listunspent()), 0)
         assert_equal(len(self.nodes[2].listunspent()), 0)
 
         self.log.info("Mining blocks...")
 
         self.generate(self.nodes[0], 1, sync_fun=self.no_op)
 
         walletinfo = self.nodes[0].getwalletinfo()
         assert_equal(walletinfo["immature_balance"], 50000000)
         assert_equal(walletinfo["balance"], 0)
 
         self.sync_all(self.nodes[0:3])
         self.generate(
             self.nodes[1], 101, sync_fun=lambda: self.sync_all(self.nodes[0:3])
         )
 
         assert_equal(self.nodes[0].getbalance(), 50000000)
         assert_equal(self.nodes[1].getbalance(), 50000000)
         assert_equal(self.nodes[2].getbalance(), 0)
 
         # Check that only first and second nodes have UTXOs
         utxos = self.nodes[0].listunspent()
         assert_equal(len(utxos), 1)
         assert_equal(len(self.nodes[1].listunspent()), 1)
         assert_equal(len(self.nodes[2].listunspent()), 0)
 
         self.log.info("test gettxout")
         confirmed_txid, confirmed_index = utxos[0]["txid"], utxos[0]["vout"]
         # First, outputs that are unspent both in the chain and in the
         # mempool should appear with or without include_mempool
         txout = self.nodes[0].gettxout(
             txid=confirmed_txid, n=confirmed_index, include_mempool=False
         )
         assert_equal(txout["value"], 50000000)
         txout = self.nodes[0].gettxout(
             txid=confirmed_txid, n=confirmed_index, include_mempool=True
         )
         assert_equal(txout["value"], 50000000)
 
         # Send 21,000,000 XEC from 0 to 2 using sendtoaddress call.
         self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 11000000)
         mempool_txid = self.nodes[0].sendtoaddress(
             self.nodes[2].getnewaddress(), 10000000
         )
 
         self.log.info("test gettxout (second part)")
         # utxo spent in mempool should be visible if you exclude mempool
         # but invisible if you include mempool
         txout = self.nodes[0].gettxout(confirmed_txid, confirmed_index, False)
         assert_equal(txout["value"], 50000000)
         txout = self.nodes[0].gettxout(confirmed_txid, confirmed_index, True)
         assert txout is None
         # new utxo from mempool should be invisible if you exclude mempool
         # but visible if you include mempool
         txout = self.nodes[0].gettxout(mempool_txid, 0, False)
         assert txout is None
         txout1 = self.nodes[0].gettxout(mempool_txid, 0, True)
         txout2 = self.nodes[0].gettxout(mempool_txid, 1, True)
         # note the mempool tx will have randomly assigned indices
         # but 10 will go to node2 and the rest will go to node0
         balance = self.nodes[0].getbalance()
         assert_equal({txout1["value"], txout2["value"]}, {10000000, balance})
         walletinfo = self.nodes[0].getwalletinfo()
         assert_equal(walletinfo["immature_balance"], 0)
 
         # Have node0 mine a block, thus it will collect its own fee.
         self.generate(self.nodes[0], 1, sync_fun=lambda: self.sync_all(self.nodes[0:3]))
 
         # Exercise locking of unspent outputs
         unspent_0 = self.nodes[2].listunspent()[0]
         unspent_0 = {"txid": unspent_0["txid"], "vout": unspent_0["vout"]}
         assert_raises_rpc_error(
             -8,
             "Invalid parameter, expected locked output",
             self.nodes[2].lockunspent,
             True,
             [unspent_0],
         )
         self.nodes[2].lockunspent(False, [unspent_0])
         assert_raises_rpc_error(
             -8,
             "Invalid parameter, output already locked",
             self.nodes[2].lockunspent,
             False,
             [unspent_0],
         )
         assert_raises_rpc_error(
             -6,
             "Insufficient funds",
             self.nodes[2].sendtoaddress,
             self.nodes[2].getnewaddress(),
             20000000,
         )
         assert_equal([unspent_0], self.nodes[2].listlockunspent())
         self.nodes[2].lockunspent(True, [unspent_0])
         assert_equal(len(self.nodes[2].listlockunspent()), 0)
         assert_raises_rpc_error(
             -8,
             (
                 "txid must be of length 64 (not 34, for"
                 " '0000000000000000000000000000000000')"
             ),
             self.nodes[2].lockunspent,
             False,
             [{"txid": "0000000000000000000000000000000000", "vout": 0}],
         )
         assert_raises_rpc_error(
             -8,
             (
                 "txid must be hexadecimal string (not"
                 " 'ZZZ0000000000000000000000000000000000000000000000000000000000000')"
             ),
             self.nodes[2].lockunspent,
             False,
             [
                 {
                     "txid": "ZZZ0000000000000000000000000000000000000000000000000000000000000",
                     "vout": 0,
                 }
             ],
         )
         assert_raises_rpc_error(
             -8,
             "Invalid parameter, unknown transaction",
             self.nodes[2].lockunspent,
             False,
             [
                 {
                     "txid": "0000000000000000000000000000000000000000000000000000000000000000",
                     "vout": 0,
                 }
             ],
         )
         assert_raises_rpc_error(
             -8,
             "Invalid parameter, vout index out of bounds",
             self.nodes[2].lockunspent,
             False,
             [{"txid": unspent_0["txid"], "vout": 999}],
         )
 
         # The lock on a manually selected output is ignored
         unspent_0 = self.nodes[1].listunspent()[0]
         self.nodes[1].lockunspent(False, [unspent_0])
         tx = self.nodes[1].createrawtransaction(
             [unspent_0], {self.nodes[1].getnewaddress(): 1000000}
         )
         tx = self.nodes[1].fundrawtransaction(tx)["hex"]
         self.nodes[1].fundrawtransaction(tx, {"lockUnspents": True})
 
         # fundrawtransaction can lock an input
         self.nodes[1].lockunspent(True, [unspent_0])
         assert_equal(len(self.nodes[1].listlockunspent()), 0)
         tx = self.nodes[1].fundrawtransaction(tx, {"lockUnspents": True})["hex"]
         assert_equal(len(self.nodes[1].listlockunspent()), 1)
 
         # Send transaction
         tx = self.nodes[1].signrawtransactionwithwallet(tx)["hex"]
         self.nodes[1].sendrawtransaction(tx)
         assert_equal(len(self.nodes[1].listlockunspent()), 0)
 
         # Have node1 generate 100 blocks (so node0 can recover the fee)
         self.generate(
             self.nodes[1], 100, sync_fun=lambda: self.sync_all(self.nodes[0:3])
         )
 
         # node0 should end up with 100 btc in block rewards plus fees, but
         # minus the 21 plus fees sent to node2
         assert_equal(self.nodes[0].getbalance(), 100000000 - 21000000)
         assert_equal(self.nodes[2].getbalance(), 21000000)
 
         # Node0 should have two unspent outputs.
         # Create a couple of transactions to send them to node2, submit them through
         # node1, and make sure both node0 and node2 pick them up properly:
         node0utxos = self.nodes[0].listunspent(1)
         assert_equal(len(node0utxos), 2)
 
         # create both transactions
         txns_to_send = []
         for utxo in node0utxos:
             inputs = []
             outputs = {}
             inputs.append({"txid": utxo["txid"], "vout": utxo["vout"]})
             outputs[self.nodes[2].getnewaddress()] = utxo["amount"] - 3000000
             raw_tx = self.nodes[0].createrawtransaction(inputs, outputs)
             txns_to_send.append(self.nodes[0].signrawtransactionwithwallet(raw_tx))
 
         # Have node 1 (miner) send the transactions
         self.nodes[1].sendrawtransaction(hexstring=txns_to_send[0]["hex"], maxfeerate=0)
         self.nodes[1].sendrawtransaction(hexstring=txns_to_send[1]["hex"], maxfeerate=0)
 
         # Have node1 mine a block to confirm transactions:
         self.generate(self.nodes[1], 1, sync_fun=lambda: self.sync_all(self.nodes[0:3]))
 
         assert_equal(self.nodes[0].getbalance(), 0)
         assert_equal(self.nodes[2].getbalance(), 94000000)
 
         # Verify that a spent output cannot be locked anymore
         spent_0 = {"txid": node0utxos[0]["txid"], "vout": node0utxos[0]["vout"]}
         assert_raises_rpc_error(
             -8,
             "Invalid parameter, expected unspent output",
             self.nodes[0].lockunspent,
             False,
             [spent_0],
         )
 
         # Send 10,000,000 XEC normal
         old_balance = self.nodes[2].getbalance()
         address = self.nodes[0].getnewaddress("test")
         fee_per_byte = Decimal("1000") / 1000
         self.nodes[2].settxfee(fee_per_byte * 1000)
         txid = self.nodes[2].sendtoaddress(address, 10000000, "", "", False)
         self.generate(self.nodes[2], 1, sync_fun=lambda: self.sync_all(self.nodes[0:3]))
         ctx = FromHex(CTransaction(), self.nodes[2].gettransaction(txid)["hex"])
 
         node_2_bal = self.check_fee_amount(
             self.nodes[2].getbalance(),
             old_balance - Decimal("10000000"),
             fee_per_byte,
             ctx.billable_size(),
         )
         assert_equal(self.nodes[0].getbalance(), Decimal("10000000"))
 
         # Send 10,000,000 XEC with subtract fee from amount
         txid = self.nodes[2].sendtoaddress(address, 10000000, "", "", True)
         self.generate(self.nodes[2], 1, sync_fun=lambda: self.sync_all(self.nodes[0:3]))
         node_2_bal -= Decimal("10000000")
         assert_equal(self.nodes[2].getbalance(), node_2_bal)
         node_0_bal = self.check_fee_amount(
             self.nodes[0].getbalance(),
             Decimal("20000000"),
             fee_per_byte,
             count_bytes(self.nodes[2].gettransaction(txid)["hex"]),
         )
 
         self.log.info("Test sendmany")
 
         # Sendmany 10,000,000 XEC
         txid = self.nodes[2].sendmany("", {address: 10000000}, 0, "", [])
         self.generate(self.nodes[2], 1, sync_fun=lambda: self.sync_all(self.nodes[0:3]))
         node_0_bal += Decimal("10000000")
         ctx = FromHex(CTransaction(), self.nodes[2].gettransaction(txid)["hex"])
         node_2_bal = self.check_fee_amount(
             self.nodes[2].getbalance(),
             node_2_bal - Decimal("10000000"),
             fee_per_byte,
             ctx.billable_size(),
         )
         assert_equal(self.nodes[0].getbalance(), node_0_bal)
 
         # Sendmany 10,000,000 XEC with subtract fee from amount
         txid = self.nodes[2].sendmany("", {address: 10000000}, 0, "", [address])
         self.generate(self.nodes[2], 1, sync_fun=lambda: self.sync_all(self.nodes[0:3]))
         node_2_bal -= Decimal("10000000")
         assert_equal(self.nodes[2].getbalance(), node_2_bal)
         ctx = FromHex(CTransaction(), self.nodes[2].gettransaction(txid)["hex"])
         node_0_bal = self.check_fee_amount(
             self.nodes[0].getbalance(),
             node_0_bal + Decimal("10000000"),
             fee_per_byte,
             ctx.billable_size(),
         )
 
         self.start_node(3, self.extra_args[3])
         self.connect_nodes(0, 3)
         self.sync_all()
 
         # check if we can list zero value tx as available coins
         # 1. create raw_tx
         # 2. hex-changed one output to 0.0
         # 3. sign and send
         # 4. check if recipient (node0) can list the zero value tx
         usp = self.nodes[1].listunspent(query_options={"minimumAmount": "49998000"})[0]
         inputs = [{"txid": usp["txid"], "vout": usp["vout"]}]
         outputs = {
             self.nodes[1].getnewaddress(): 49998000,
             self.nodes[0].getnewaddress(): 11110000,
         }
 
         rawTx = (
             self.nodes[1]
             .createrawtransaction(inputs, outputs)
             .replace("c0833842", "00000000")
         )  # replace 11.11 with 0.0 (int32)
         signed_raw_tx = self.nodes[1].signrawtransactionwithwallet(rawTx)
         decoded_raw_tx = self.nodes[1].decoderawtransaction(signed_raw_tx["hex"])
         zero_value_txid = decoded_raw_tx["txid"]
         self.nodes[1].sendrawtransaction(signed_raw_tx["hex"])
 
         self.sync_all()
         self.generate(self.nodes[1], 1)  # mine a block
 
         # zero value tx must be in listunspents output
         unspent_txs = self.nodes[0].listunspent()
         found = False
         for uTx in unspent_txs:
             if uTx["txid"] == zero_value_txid:
                 found = True
                 assert_equal(uTx["amount"], Decimal("0"))
         assert found
 
         # do some -walletbroadcast tests
         self.stop_nodes()
         self.start_node(0, self.extra_args[0] + ["-walletbroadcast=0"])
         self.start_node(1, self.extra_args[1] + ["-walletbroadcast=0"])
         self.start_node(2, self.extra_args[2] + ["-walletbroadcast=0"])
         self.connect_nodes(0, 1)
         self.connect_nodes(1, 2)
         self.connect_nodes(0, 2)
         self.sync_all(self.nodes[0:3])
 
         txid_not_broadcast = self.nodes[0].sendtoaddress(
             self.nodes[2].getnewaddress(), 2000000
         )
         tx_obj_not_broadcast = self.nodes[0].gettransaction(txid_not_broadcast)
         # mine a block, tx should not be in there
         self.generate(self.nodes[1], 1, sync_fun=lambda: self.sync_all(self.nodes[0:3]))
         # should not be changed because tx was not broadcasted
         assert_equal(self.nodes[2].getbalance(), node_2_bal)
 
         # now broadcast from another node, mine a block, sync, and check the
         # balance
         self.nodes[1].sendrawtransaction(tx_obj_not_broadcast["hex"])
         self.generate(self.nodes[1], 1, sync_fun=lambda: self.sync_all(self.nodes[0:3]))
         node_2_bal += 2000000
         tx_obj_not_broadcast = self.nodes[0].gettransaction(txid_not_broadcast)
         assert_equal(self.nodes[2].getbalance(), node_2_bal)
 
         # create another tx
         txid_not_broadcast = self.nodes[0].sendtoaddress(
             self.nodes[2].getnewaddress(), 2000000
         )
 
         # restart the nodes with -walletbroadcast=1
         self.stop_nodes()
         self.start_node(0, self.extra_args[0])
         self.start_node(1, self.extra_args[1])
         self.start_node(2, self.extra_args[2])
         self.connect_nodes(0, 1)
         self.connect_nodes(1, 2)
         self.connect_nodes(0, 2)
         self.sync_blocks(self.nodes[0:3])
 
         self.generate(
             self.nodes[0], 1, sync_fun=lambda: self.sync_blocks(self.nodes[0:3])
         )
         node_2_bal += 2000000
 
         # tx should be added to balance because after restarting the nodes tx
         # should be broadcasted
         assert_equal(self.nodes[2].getbalance(), node_2_bal)
 
         # send a tx with value in a string (PR#6380 +)
         txid = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), "2000000")
         tx_obj = self.nodes[0].gettransaction(txid)
         assert_equal(tx_obj["amount"], Decimal("-2000000"))
 
         txid = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), "10000")
         tx_obj = self.nodes[0].gettransaction(txid)
         assert_equal(tx_obj["amount"], Decimal("-10000"))
 
         # check if JSON parser can handle scientific notation in strings
         txid = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), "1e3")
         tx_obj = self.nodes[0].gettransaction(txid)
         assert_equal(tx_obj["amount"], Decimal("-1000"))
 
         # General checks for errors from incorrect inputs
         # This will raise an exception because the amount is negative
         assert_raises_rpc_error(
             -3,
             "Amount out of range",
             self.nodes[0].sendtoaddress,
             self.nodes[2].getnewaddress(),
             "-1",
         )
 
         # This will raise an exception because the amount type is wrong
         assert_raises_rpc_error(
             -3,
             "Invalid amount",
             self.nodes[0].sendtoaddress,
             self.nodes[2].getnewaddress(),
             "1f-4",
         )
 
         # This will raise an exception since generate does not accept a string
         assert_raises_rpc_error(-1, "not an integer", self.generate, self.nodes[0], "2")
 
         # This will raise an exception for the invalid private key format
         assert_raises_rpc_error(
             -5, "Invalid private key encoding", self.nodes[0].importprivkey, "invalid"
         )
 
         # This will raise an exception for importing an address with the PS2H
         # flag
         temp_address = self.nodes[1].getnewaddress()
         assert_raises_rpc_error(
             -5,
             "Cannot use the p2sh flag with an address - use a script instead",
             self.nodes[0].importaddress,
             temp_address,
             "label",
             False,
             True,
         )
 
         # This will raise an exception for attempting to dump the private key
         # of an address you do not own
         assert_raises_rpc_error(
             -4, "Private key for address", self.nodes[0].dumpprivkey, temp_address
         )
 
         # This will raise an exception for attempting to get the private key of
         # an invalid Bitcoin address
         assert_raises_rpc_error(
             -5, "Invalid Bitcoin address", self.nodes[0].dumpprivkey, "invalid"
         )
 
         # This will raise an exception for attempting to set a label for an
         # invalid Bitcoin address
         assert_raises_rpc_error(
             -5,
             "Invalid Bitcoin address",
             self.nodes[0].setlabel,
             "invalid address",
             "label",
         )
 
         # This will raise an exception for importing an invalid address
         assert_raises_rpc_error(
             -5,
             "Invalid Bitcoin address or script",
             self.nodes[0].importaddress,
             "invalid",
         )
 
         # This will raise an exception for attempting to import a pubkey that
         # isn't in hex
         assert_raises_rpc_error(
             -5, "Pubkey must be a hex string", self.nodes[0].importpubkey, "not hex"
         )
 
         # This will raise an exception for importing an invalid pubkey
         assert_raises_rpc_error(
             -5,
             "Pubkey is not a valid public key",
             self.nodes[0].importpubkey,
             "5361746f736869204e616b616d6f746f",
         )
 
         # Import address and private key to check correct behavior of spendable unspents
         # 1. Send some coins to generate new UTXO
         address_to_import = self.nodes[2].getnewaddress()
         txid = self.nodes[0].sendtoaddress(address_to_import, 1000000)
         self.generate(self.nodes[0], 1, sync_fun=lambda: self.sync_all(self.nodes[0:3]))
 
         # 2. Import address from node2 to node1
         self.nodes[1].importaddress(address_to_import)
 
         # 3. Validate that the imported address is watch-only on node1
         assert self.nodes[1].getaddressinfo(address_to_import)["iswatchonly"]
 
         # 4. Check that the unspents after import are not spendable
         assert_array_result(
             self.nodes[1].listunspent(),
             {"address": address_to_import},
             {"spendable": False},
         )
 
         # 5. Import private key of the previously imported address on node1
         priv_key = self.nodes[2].dumpprivkey(address_to_import)
         self.nodes[1].importprivkey(priv_key)
 
         # 6. Check that the unspents are now spendable on node1
         assert_array_result(
             self.nodes[1].listunspent(),
             {"address": address_to_import},
             {"spendable": True},
         )
 
         # Mine a block from node0 to an address from node1
         coinbase_addr = self.nodes[1].getnewaddress()
         block_hash = self.generatetoaddress(
             self.nodes[0],
             1,
             coinbase_addr,
             sync_fun=lambda: self.sync_all(self.nodes[0:3]),
         )[0]
         coinbase_txid = self.nodes[0].getblock(block_hash)["tx"][0]
 
         # Check that the txid and balance is found by node1
         self.nodes[1].gettransaction(coinbase_txid)
 
         # check if wallet or blockchain maintenance changes the balance
         self.sync_all(self.nodes[0:3])
         blocks = self.generate(
             self.nodes[0], 2, sync_fun=lambda: self.sync_all(self.nodes[0:3])
         )
         balance_nodes = [self.nodes[i].getbalance() for i in range(3)]
         block_count = self.nodes[0].getblockcount()
 
         # Check modes:
         #   - True: unicode escaped as \u....
         #   - False: unicode directly as UTF-8
         for mode in [True, False]:
             self.nodes[0].rpc.ensure_ascii = mode
             # unicode check: Basic Multilingual Plane, Supplementary Plane
             # respectively
             for label in ["рыба", "𝅘𝅥𝅯"]:
                 addr = self.nodes[0].getnewaddress()
                 self.nodes[0].setlabel(addr, label)
                 test_address(self.nodes[0], addr, labels=[label])
                 assert label in self.nodes[0].listlabels()
         # restore to default
         self.nodes[0].rpc.ensure_ascii = True
 
         # maintenance tests
         maintenance = [
             "-rescan",
             "-reindex",
         ]
         chainlimit = 6
         for m in maintenance:
             self.log.info(f"check {m}")
             self.stop_nodes()
             # set lower ancestor limit for later
             self.start_node(
                 0, self.extra_args[0] + [m, f"-limitancestorcount={str(chainlimit)}"]
             )
             self.start_node(
                 1, self.extra_args[1] + [m, f"-limitancestorcount={str(chainlimit)}"]
             )
             self.start_node(
                 2, self.extra_args[2] + [m, f"-limitancestorcount={str(chainlimit)}"]
             )
             if m == "-reindex":
                 # reindex will leave rpc warm up "early"; Wait for it to finish
                 self.wait_until(
                     lambda: [block_count] * 3
                     == [self.nodes[i].getblockcount() for i in range(3)]
                 )
             assert_equal(balance_nodes, [self.nodes[i].getbalance() for i in range(3)])
 
         # Exercise listsinceblock with the last two blocks
         coinbase_tx_1 = self.nodes[0].listsinceblock(blocks[0])
         assert_equal(coinbase_tx_1["lastblock"], blocks[1])
         assert_equal(len(coinbase_tx_1["transactions"]), 1)
         assert_equal(coinbase_tx_1["transactions"][0]["blockhash"], blocks[1])
         assert_equal(len(self.nodes[0].listsinceblock(blocks[1])["transactions"]), 0)
 
-        # ==Check that wallet prefers to use coins that don't exceed mempool li
-
-        # Get all non-zero utxos together
-        chain_addrs = [self.nodes[0].getnewaddress(), self.nodes[0].getnewaddress()]
-        singletxid = self.nodes[0].sendtoaddress(
-            chain_addrs[0], self.nodes[0].getbalance(), "", "", True
-        )
-        self.generate(self.nodes[0], 1, sync_fun=self.no_op)
-        node0_balance = self.nodes[0].getbalance()
-        # Split into two chains
-        rawtx = self.nodes[0].createrawtransaction(
-            [{"txid": singletxid, "vout": 0}],
-            {
-                chain_addrs[0]: node0_balance / 2 - Decimal("10000"),
-                chain_addrs[1]: node0_balance / 2 - Decimal("10000"),
-            },
-        )
-        signedtx = self.nodes[0].signrawtransactionwithwallet(rawtx)
-        singletxid = self.nodes[0].sendrawtransaction(
-            hexstring=signedtx["hex"], maxfeerate=0
-        )
-        self.generate(self.nodes[0], 1, sync_fun=self.no_op)
-
-        # Make a long chain of unconfirmed payments without hitting mempool limit
-        # Each tx we make leaves only one output of change on a chain 1 longer
-        # Since the amount to send is always much less than the outputs, we only ever need one output
-        # So we should be able to generate exactly chainlimit txs for each
-        # original output
-        sending_addr = self.nodes[1].getnewaddress()
-        txid_list = []
-        for _ in range(chainlimit * 2):
-            txid_list.append(
-                self.nodes[0].sendtoaddress(sending_addr, Decimal("10000"))
-            )
-        assert_equal(self.nodes[0].getmempoolinfo()["size"], chainlimit * 2)
-        assert_equal(len(txid_list), chainlimit * 2)
-
-        # Without walletrejectlongchains, we will still generate a txid
-        # The tx will be stored in the wallet but not accepted to the mempool
-        extra_txid = self.nodes[0].sendtoaddress(sending_addr, Decimal("10000"))
-        assert extra_txid not in self.nodes[0].getrawmempool()
-        assert extra_txid in [tx["txid"] for tx in self.nodes[0].listtransactions()]
-        self.nodes[0].abandontransaction(extra_txid)
-        total_txs = len(self.nodes[0].listtransactions("*", 99999))
-
-        # Try with walletrejectlongchains
-        # Double chain limit but require combining inputs, so we pass
-        # SelectCoinsMinConf
-        self.stop_node(0)
-        self.start_node(
-            0,
-            self.extra_args[0]
-            + ["-walletrejectlongchains", f"-limitancestorcount={str(2 * chainlimit)}"],
-        )
-
-        # wait until the wallet has submitted all transactions to the mempool
-        self.wait_until(lambda: len(self.nodes[0].getrawmempool()) == chainlimit * 2)
-
-        # Prevent potential race condition when calling wallet RPCs right after
-        # restart
-        self.nodes[0].syncwithvalidationinterfacequeue()
-
-        node0_balance = self.nodes[0].getbalance()
-        # With walletrejectlongchains we will not create the tx and store it in
-        # our wallet.
-        assert_raises_rpc_error(
-            -6,
-            "Transaction has too long of a mempool chain",
-            self.nodes[0].sendtoaddress,
-            sending_addr,
-            node0_balance - Decimal("10000"),
-        )
-
-        # Verify nothing new in wallet
-        assert_equal(total_txs, len(self.nodes[0].listtransactions("*", 99999)))
-
         # Test getaddressinfo on external address. Note that these addresses
         # are taken from disablewallet.py
         assert_raises_rpc_error(
             -5,
             "Invalid address",
             self.nodes[0].getaddressinfo,
             "3J98t1WpEZ73CNmQviecrnyiWrnqRhWNLy",
         )
         address_info = self.nodes[0].getaddressinfo(
             "mneYUmWYsuk7kySiURxCi3AGxrAqZxLgPZ"
         )
         assert_equal(
             address_info["address"],
             "ecregtest:qp8rs4qyd3aazk22eyzwg7fmdfzmxm02pyprkfhvm4",
         )
         assert_equal(
             address_info["scriptPubKey"],
             "76a9144e3854046c7bd1594ac904e4793b6a45b36dea0988ac",
         )
         assert not address_info["ismine"]
         assert not address_info["iswatchonly"]
         assert not address_info["isscript"]
         assert not address_info["ischange"]
 
         # Test getaddressinfo 'ischange' field on change address.
         self.generate(self.nodes[0], 1, sync_fun=self.no_op)
         destination = self.nodes[1].getnewaddress()
         txid = self.nodes[0].sendtoaddress(destination, 123000)
         tx = self.nodes[0].gettransaction(txid=txid, verbose=True)["decoded"]
         output_addresses = [vout["scriptPubKey"]["addresses"][0] for vout in tx["vout"]]
         assert len(output_addresses) > 1
         for address in output_addresses:
             ischange = self.nodes[0].getaddressinfo(address)["ischange"]
             assert_equal(ischange, address != destination)
             if ischange:
                 change = address
         self.nodes[0].setlabel(change, "foobar")
         assert_equal(self.nodes[0].getaddressinfo(change)["ischange"], False)
 
         # Test gettransaction response with different arguments.
         self.log.info("Testing gettransaction response with different arguments...")
         self.nodes[0].setlabel(change, "baz")
         baz = self.nodes[0].listtransactions(label="baz", count=1)[0]
         expected_receive_vout = {
             "label": "baz",
             "address": baz["address"],
             "amount": baz["amount"],
             "category": baz["category"],
             "vout": baz["vout"],
         }
         expected_fields = frozenset(
             {
                 "amount",
                 "confirmations",
                 "details",
                 "fee",
                 "hex",
                 "time",
                 "timereceived",
                 "trusted",
                 "txid",
                 "walletconflicts",
             }
         )
         verbose_field = "decoded"
         expected_verbose_fields = expected_fields | {verbose_field}
 
         self.log.debug("Testing gettransaction response without verbose")
         tx = self.nodes[0].gettransaction(txid=txid)
         assert_equal(set(tx), expected_fields)
         assert_array_result(
             tx["details"], {"category": "receive"}, expected_receive_vout
         )
 
         self.log.debug("Testing gettransaction response with verbose set to False")
         tx = self.nodes[0].gettransaction(txid=txid, verbose=False)
         assert_equal(set(tx), expected_fields)
         assert_array_result(
             tx["details"], {"category": "receive"}, expected_receive_vout
         )
 
         self.log.debug("Testing gettransaction response with verbose set to True")
         tx = self.nodes[0].gettransaction(txid=txid, verbose=True)
         assert_equal(set(tx), expected_verbose_fields)
         assert_array_result(
             tx["details"], {"category": "receive"}, expected_receive_vout
         )
         assert_equal(tx[verbose_field], self.nodes[0].decoderawtransaction(tx["hex"]))
 
 
 if __name__ == "__main__":
     WalletTest().main()