diff --git a/doc/release-notes.md b/doc/release-notes.md
index 9c5cf81be..ea5c492f6 100644
--- a/doc/release-notes.md
+++ b/doc/release-notes.md
@@ -1,7 +1,10 @@
 # Bitcoin ABC 0.27.7 Release Notes
 
 Bitcoin ABC version 0.27.7 is now available from:
 
   <https://download.bitcoinabc.org/0.27.7/>
 
-This is a maintenance release with no user-visible change.
+This release includes the following features and fixes:
+ - The `fees.ancestor` and `fees.descendant` fields from the `getrawmempool`,
+   `getmempoolentry`, `getmempoolancestors` and `getmempooldescendants` were
+   deprecated since v0.27.0 and have been completely removed.
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index ec563a7cf..3b8bd90aa 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -1,3357 +1,3337 @@
 // Copyright (c) 2010 Satoshi Nakamoto
 // Copyright (c) 2009-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <rpc/blockchain.h>
 
 #include <blockfilter.h>
 #include <chain.h>
 #include <chainparams.h>
 #include <coins.h>
 #include <config.h>
 #include <consensus/amount.h>
 #include <consensus/params.h>
 #include <consensus/validation.h>
 #include <core_io.h>
 #include <hash.h>
 #include <index/blockfilterindex.h>
 #include <index/coinstatsindex.h>
 #include <net.h>
 #include <net_processing.h>
 #include <node/blockstorage.h>
 #include <node/coinstats.h>
 #include <node/context.h>
 #include <node/utxo_snapshot.h>
 #include <policy/policy.h>
 #include <primitives/transaction.h>
 #include <rpc/server.h>
 #include <rpc/server_util.h>
 #include <rpc/util.h>
 #include <script/descriptor.h>
 #include <streams.h>
 #include <txdb.h>
 #include <txmempool.h>
 #include <undo.h>
 #include <util/check.h>
 #include <util/strencodings.h>
 #include <util/translation.h>
 #include <validation.h>
 #include <validationinterface.h>
 #include <warnings.h>
 
 #include <condition_variable>
 #include <cstdint>
 #include <memory>
 #include <mutex>
 
 using node::BlockManager;
 using node::CCoinsStats;
 using node::CoinStatsHashType;
 using node::GetUTXOStats;
 using node::NodeContext;
 using node::ReadBlockFromDisk;
 using node::SnapshotMetadata;
 using node::UndoReadFromDisk;
 
 struct CUpdatedBlock {
     BlockHash hash;
     int height;
 };
 
 static Mutex cs_blockchange;
 static std::condition_variable cond_blockchange;
 static CUpdatedBlock latestblock GUARDED_BY(cs_blockchange);
 
 /**
  * Calculate the difficulty for a given block index.
  */
 double GetDifficulty(const CBlockIndex *blockindex) {
     CHECK_NONFATAL(blockindex);
 
     int nShift = (blockindex->nBits >> 24) & 0xff;
     double dDiff = double(0x0000ffff) / double(blockindex->nBits & 0x00ffffff);
 
     while (nShift < 29) {
         dDiff *= 256.0;
         nShift++;
     }
     while (nShift > 29) {
         dDiff /= 256.0;
         nShift--;
     }
 
     return dDiff;
 }
 
 static int ComputeNextBlockAndDepth(const CBlockIndex *tip,
                                     const CBlockIndex *blockindex,
                                     const CBlockIndex *&next) {
     next = tip->GetAncestor(blockindex->nHeight + 1);
     if (next && next->pprev == blockindex) {
         return tip->nHeight - blockindex->nHeight + 1;
     }
     next = nullptr;
     return blockindex == tip ? 1 : -1;
 }
 
 static const CBlockIndex *ParseHashOrHeight(const UniValue &param,
                                             ChainstateManager &chainman) {
     LOCK(::cs_main);
     CChain &active_chain = chainman.ActiveChain();
 
     if (param.isNum()) {
         const int height{param.get_int()};
         if (height < 0) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 strprintf("Target block height %d is negative", height));
         }
         const int current_tip{active_chain.Height()};
         if (height > current_tip) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 strprintf("Target block height %d after current tip %d", height,
                           current_tip));
         }
 
         return active_chain[height];
     } else {
         const BlockHash hash{ParseHashV(param, "hash_or_height")};
         const CBlockIndex *pindex = chainman.m_blockman.LookupBlockIndex(hash);
 
         if (!pindex) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
         }
 
         return pindex;
     }
 }
 UniValue blockheaderToJSON(const CBlockIndex *tip,
                            const CBlockIndex *blockindex) {
     // Serialize passed information without accessing chain state of the active
     // chain!
     // For performance reasons
     AssertLockNotHeld(cs_main);
 
     UniValue result(UniValue::VOBJ);
     result.pushKV("hash", blockindex->GetBlockHash().GetHex());
     const CBlockIndex *pnext;
     int confirmations = ComputeNextBlockAndDepth(tip, blockindex, pnext);
     result.pushKV("confirmations", confirmations);
     result.pushKV("height", blockindex->nHeight);
     result.pushKV("version", blockindex->nVersion);
     result.pushKV("versionHex", strprintf("%08x", blockindex->nVersion));
     result.pushKV("merkleroot", blockindex->hashMerkleRoot.GetHex());
     result.pushKV("time", int64_t(blockindex->nTime));
     result.pushKV("mediantime", int64_t(blockindex->GetMedianTimePast()));
     result.pushKV("nonce", uint64_t(blockindex->nNonce));
     result.pushKV("bits", strprintf("%08x", blockindex->nBits));
     result.pushKV("difficulty", GetDifficulty(blockindex));
     result.pushKV("chainwork", blockindex->nChainWork.GetHex());
     result.pushKV("nTx", uint64_t(blockindex->nTx));
 
     if (blockindex->pprev) {
         result.pushKV("previousblockhash",
                       blockindex->pprev->GetBlockHash().GetHex());
     }
     if (pnext) {
         result.pushKV("nextblockhash", pnext->GetBlockHash().GetHex());
     }
     return result;
 }
 
 UniValue blockToJSON(BlockManager &blockman, const CBlock &block,
                      const CBlockIndex *tip, const CBlockIndex *blockindex,
                      bool txDetails) {
     UniValue result = blockheaderToJSON(tip, blockindex);
 
     result.pushKV("size", (int)::GetSerializeSize(block, PROTOCOL_VERSION));
     UniValue txs(UniValue::VARR);
     if (txDetails) {
         CBlockUndo blockUndo;
         const bool is_not_pruned{
             WITH_LOCK(::cs_main, return !blockman.IsBlockPruned(blockindex))};
         const bool have_undo{is_not_pruned &&
                              UndoReadFromDisk(blockUndo, blockindex)};
         for (size_t i = 0; i < block.vtx.size(); ++i) {
             const CTransactionRef &tx = block.vtx.at(i);
             // coinbase transaction (i == 0) doesn't have undo data
             const CTxUndo *txundo =
                 (have_undo && i) ? &blockUndo.vtxundo.at(i - 1) : nullptr;
             UniValue objTx(UniValue::VOBJ);
             TxToUniv(*tx, BlockHash(), objTx, true, RPCSerializationFlags(),
                      txundo);
             txs.push_back(objTx);
         }
     } else {
         for (const CTransactionRef &tx : block.vtx) {
             txs.push_back(tx->GetId().GetHex());
         }
     }
     result.pushKV("tx", txs);
 
     return result;
 }
 
 static RPCHelpMan getblockcount() {
     return RPCHelpMan{
         "getblockcount",
         "Returns the height of the most-work fully-validated chain.\n"
         "The genesis block has height 0.\n",
         {},
         RPCResult{RPCResult::Type::NUM, "", "The current block count"},
         RPCExamples{HelpExampleCli("getblockcount", "") +
                     HelpExampleRpc("getblockcount", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             ChainstateManager &chainman = EnsureAnyChainman(request.context);
             LOCK(cs_main);
             return chainman.ActiveHeight();
         },
     };
 }
 
 static RPCHelpMan getbestblockhash() {
     return RPCHelpMan{
         "getbestblockhash",
         "Returns the hash of the best (tip) block in the "
         "most-work fully-validated chain.\n",
         {},
         RPCResult{RPCResult::Type::STR_HEX, "", "the block hash, hex-encoded"},
         RPCExamples{HelpExampleCli("getbestblockhash", "") +
                     HelpExampleRpc("getbestblockhash", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             ChainstateManager &chainman = EnsureAnyChainman(request.context);
             LOCK(cs_main);
             return chainman.ActiveTip()->GetBlockHash().GetHex();
         },
     };
 }
 
 void RPCNotifyBlockChange(const CBlockIndex *pindex) {
     if (pindex) {
         LOCK(cs_blockchange);
         latestblock.hash = pindex->GetBlockHash();
         latestblock.height = pindex->nHeight;
     }
     cond_blockchange.notify_all();
 }
 
 static RPCHelpMan waitfornewblock() {
     return RPCHelpMan{
         "waitfornewblock",
         "Waits for a specific new block and returns useful info about it.\n"
         "\nReturns the current block on timeout or exit.\n",
         {
             {"timeout", RPCArg::Type::NUM, /* default */ "0",
              "Time in milliseconds to wait for a response. 0 indicates no "
              "timeout."},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR_HEX, "hash", "The blockhash"},
                       {RPCResult::Type::NUM, "height", "Block height"},
                   }},
         RPCExamples{HelpExampleCli("waitfornewblock", "1000") +
                     HelpExampleRpc("waitfornewblock", "1000")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             int timeout = 0;
             if (!request.params[0].isNull()) {
                 timeout = request.params[0].get_int();
             }
 
             CUpdatedBlock block;
             {
                 WAIT_LOCK(cs_blockchange, lock);
                 block = latestblock;
                 if (timeout) {
                     cond_blockchange.wait_for(
                         lock, std::chrono::milliseconds(timeout),
                         [&block]() EXCLUSIVE_LOCKS_REQUIRED(cs_blockchange) {
                             return latestblock.height != block.height ||
                                    latestblock.hash != block.hash ||
                                    !IsRPCRunning();
                         });
                 } else {
                     cond_blockchange.wait(
                         lock,
                         [&block]() EXCLUSIVE_LOCKS_REQUIRED(cs_blockchange) {
                             return latestblock.height != block.height ||
                                    latestblock.hash != block.hash ||
                                    !IsRPCRunning();
                         });
                 }
                 block = latestblock;
             }
             UniValue ret(UniValue::VOBJ);
             ret.pushKV("hash", block.hash.GetHex());
             ret.pushKV("height", block.height);
             return ret;
         },
     };
 }
 
 static RPCHelpMan waitforblock() {
     return RPCHelpMan{
         "waitforblock",
         "Waits for a specific new block and returns useful info about it.\n"
         "\nReturns the current block on timeout or exit.\n",
         {
             {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "Block hash to wait for."},
             {"timeout", RPCArg::Type::NUM, /* default */ "0",
              "Time in milliseconds to wait for a response. 0 indicates no "
              "timeout."},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR_HEX, "hash", "The blockhash"},
                       {RPCResult::Type::NUM, "height", "Block height"},
                   }},
         RPCExamples{HelpExampleCli("waitforblock",
                                    "\"0000000000079f8ef3d2c688c244eb7a4570b24c9"
                                    "ed7b4a8c619eb02596f8862\" 1000") +
                     HelpExampleRpc("waitforblock",
                                    "\"0000000000079f8ef3d2c688c244eb7a4570b24c9"
                                    "ed7b4a8c619eb02596f8862\", 1000")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             int timeout = 0;
 
             BlockHash hash(ParseHashV(request.params[0], "blockhash"));
 
             if (!request.params[1].isNull()) {
                 timeout = request.params[1].get_int();
             }
 
             CUpdatedBlock block;
             {
                 WAIT_LOCK(cs_blockchange, lock);
                 if (timeout) {
                     cond_blockchange.wait_for(
                         lock, std::chrono::milliseconds(timeout),
                         [&hash]() EXCLUSIVE_LOCKS_REQUIRED(cs_blockchange) {
                             return latestblock.hash == hash || !IsRPCRunning();
                         });
                 } else {
                     cond_blockchange.wait(
                         lock,
                         [&hash]() EXCLUSIVE_LOCKS_REQUIRED(cs_blockchange) {
                             return latestblock.hash == hash || !IsRPCRunning();
                         });
                 }
                 block = latestblock;
             }
 
             UniValue ret(UniValue::VOBJ);
             ret.pushKV("hash", block.hash.GetHex());
             ret.pushKV("height", block.height);
             return ret;
         },
     };
 }
 
 static RPCHelpMan waitforblockheight() {
     return RPCHelpMan{
         "waitforblockheight",
         "Waits for (at least) block height and returns the height and "
         "hash\nof the current tip.\n"
         "\nReturns the current block on timeout or exit.\n",
         {
             {"height", RPCArg::Type::NUM, RPCArg::Optional::NO,
              "Block height to wait for."},
             {"timeout", RPCArg::Type::NUM, /* default */ "0",
              "Time in milliseconds to wait for a response. 0 indicates no "
              "timeout."},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR_HEX, "hash", "The blockhash"},
                       {RPCResult::Type::NUM, "height", "Block height"},
                   }},
         RPCExamples{HelpExampleCli("waitforblockheight", "100 1000") +
                     HelpExampleRpc("waitforblockheight", "100, 1000")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             int timeout = 0;
 
             int height = request.params[0].get_int();
 
             if (!request.params[1].isNull()) {
                 timeout = request.params[1].get_int();
             }
 
             CUpdatedBlock block;
             {
                 WAIT_LOCK(cs_blockchange, lock);
                 if (timeout) {
                     cond_blockchange.wait_for(
                         lock, std::chrono::milliseconds(timeout),
                         [&height]() EXCLUSIVE_LOCKS_REQUIRED(cs_blockchange) {
                             return latestblock.height >= height ||
                                    !IsRPCRunning();
                         });
                 } else {
                     cond_blockchange.wait(
                         lock,
                         [&height]() EXCLUSIVE_LOCKS_REQUIRED(cs_blockchange) {
                             return latestblock.height >= height ||
                                    !IsRPCRunning();
                         });
                 }
                 block = latestblock;
             }
             UniValue ret(UniValue::VOBJ);
             ret.pushKV("hash", block.hash.GetHex());
             ret.pushKV("height", block.height);
             return ret;
         },
     };
 }
 
 static RPCHelpMan syncwithvalidationinterfacequeue() {
     return RPCHelpMan{
         "syncwithvalidationinterfacequeue",
         "Waits for the validation interface queue to catch up on everything "
         "that was there when we entered this function.\n",
         {},
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("syncwithvalidationinterfacequeue", "") +
                     HelpExampleRpc("syncwithvalidationinterfacequeue", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             SyncWithValidationInterfaceQueue();
             return NullUniValue;
         },
     };
 }
 
 static RPCHelpMan getdifficulty() {
     return RPCHelpMan{
         "getdifficulty",
         "Returns the proof-of-work difficulty as a multiple of the minimum "
         "difficulty.\n",
         {},
         RPCResult{RPCResult::Type::NUM, "",
                   "the proof-of-work difficulty as a multiple of the minimum "
                   "difficulty."},
         RPCExamples{HelpExampleCli("getdifficulty", "") +
                     HelpExampleRpc("getdifficulty", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             ChainstateManager &chainman = EnsureAnyChainman(request.context);
             LOCK(cs_main);
             return GetDifficulty(chainman.ActiveTip());
         },
     };
 }
 
 static std::vector<RPCResult> MempoolEntryDescription() {
     const auto &ticker = Currency::get().ticker;
     // Deprecated in v0.27.0
     if (IsDeprecatedRPCEnabled(gArgs, "mempool_ancestors_descendants")) {
         return {
             RPCResult{RPCResult::Type::NUM, "size", "transaction size."},
             RPCResult{
                 RPCResult::Type::NUM_TIME, "time",
                 "local time transaction entered pool in seconds since 1 Jan "
                 "1970 GMT"},
             RPCResult{RPCResult::Type::NUM, "height",
                       "block height when transaction entered pool"},
             RPCResult{
                 RPCResult::Type::NUM, "descendantcount",
                 "DEPRECATED: number of in-mempool descendant transactions "
                 "(including this one). Only displayed if the "
                 "-deprecatedrpc=mempool_ancestors_descendants option is set"},
             RPCResult{
                 RPCResult::Type::NUM, "descendantsize",
                 "DEPRECATED: transaction size of in-mempool descendants "
                 "(including this one). Only displayed if the "
                 "-deprecatedrpc=mempool_ancestors_descendants option is set"},
             RPCResult{
                 RPCResult::Type::NUM, "ancestorcount",
                 "DEPRECATED: number of in-mempool ancestor transactions "
                 "(including this one). Only displayed if the "
                 "-deprecatedrpc=mempool_ancestors_descendants option is set"},
             RPCResult{
                 RPCResult::Type::NUM, "ancestorsize",
                 "DEPRECATED: transaction size of in-mempool ancestors "
                 "(including this one). Only displayed if the "
                 "-deprecatedrpc=mempool_ancestors_descendants option is set"},
             RPCResult{
                 RPCResult::Type::OBJ,
                 "fees",
                 "",
                 {
                     RPCResult{RPCResult::Type::STR_AMOUNT, "base",
                               "transaction fee in " + ticker},
                     RPCResult{RPCResult::Type::STR_AMOUNT, "modified",
                               "transaction fee with fee deltas used for "
                               "mining priority in " +
                                   ticker},
-                    RPCResult{
-                        RPCResult::Type::STR_AMOUNT, "ancestor",
-                        "DEPRECATED: modified fees (see above) of in-mempool "
-                        "ancestors (including this one) in " +
-                            ticker +
-                            ". Only displayed if the "
-                            "-deprecatedrpc=mempool_ancestors_descendants "
-                            "option is set"},
-                    RPCResult{
-                        RPCResult::Type::STR_AMOUNT, "descendant",
-                        "DEPRECATED: modified fees (see above) of in-mempool "
-                        "descendants (including this one) in " +
-                            ticker +
-                            ". Only displayed if the "
-                            "-deprecatedrpc=mempool_ancestors_descendants "
-                            "option is set"},
                 }},
             RPCResult{
                 RPCResult::Type::ARR,
                 "depends",
                 "unconfirmed transactions used as inputs for this transaction",
                 {RPCResult{RPCResult::Type::STR_HEX, "transactionid",
                            "parent transaction id"}}},
             RPCResult{RPCResult::Type::ARR,
                       "spentby",
                       "unconfirmed transactions spending outputs from this "
                       "transaction",
                       {RPCResult{RPCResult::Type::STR_HEX, "transactionid",
                                  "child transaction id"}}},
             RPCResult{
                 RPCResult::Type::BOOL, "unbroadcast",
                 "Whether this transaction is currently unbroadcast (initial "
                 "broadcast not yet acknowledged by any peers)"},
         };
     }
 
     return {
         RPCResult{RPCResult::Type::NUM, "size", "transaction size."},
         RPCResult{RPCResult::Type::NUM_TIME, "time",
                   "local time transaction entered pool in seconds since 1 Jan "
                   "1970 GMT"},
         RPCResult{RPCResult::Type::NUM, "height",
                   "block height when transaction entered pool"},
         RPCResult{RPCResult::Type::OBJ,
                   "fees",
                   "",
                   {{
                       RPCResult{RPCResult::Type::STR_AMOUNT, "base",
                                 "transaction fee in " + ticker},
                       RPCResult{RPCResult::Type::STR_AMOUNT, "modified",
                                 "transaction fee with fee deltas used for "
                                 "mining priority in " +
                                     ticker},
                   }}},
         RPCResult{
             RPCResult::Type::ARR,
             "depends",
             "unconfirmed transactions used as inputs for this transaction",
             {RPCResult{RPCResult::Type::STR_HEX, "transactionid",
                        "parent transaction id"}}},
         RPCResult{
             RPCResult::Type::ARR,
             "spentby",
             "unconfirmed transactions spending outputs from this transaction",
             {RPCResult{RPCResult::Type::STR_HEX, "transactionid",
                        "child transaction id"}}},
         RPCResult{RPCResult::Type::BOOL, "unbroadcast",
                   "Whether this transaction is currently unbroadcast (initial "
                   "broadcast not yet acknowledged by any peers)"},
     };
 }
 
 static void entryToJSON(const CTxMemPool &pool, UniValue &info,
                         const CTxMemPoolEntry &e)
     EXCLUSIVE_LOCKS_REQUIRED(pool.cs) {
     AssertLockHeld(pool.cs);
 
     const bool deprecated_ancestors_descendants =
         IsDeprecatedRPCEnabled(gArgs, "mempool_ancestors_descendants");
 
     UniValue fees(UniValue::VOBJ);
     fees.pushKV("base", e.GetFee());
     fees.pushKV("modified", e.GetModifiedFee());
-    if (deprecated_ancestors_descendants) {
-        fees.pushKV("ancestor", e.GetModFeesWithAncestors());
-        fees.pushKV("descendant", e.GetModFeesWithDescendants());
-    }
     info.pushKV("fees", fees);
 
     info.pushKV("size", (int)e.GetTxSize());
     info.pushKV("time", count_seconds(e.GetTime()));
     info.pushKV("height", (int)e.GetHeight());
     if (deprecated_ancestors_descendants) {
         info.pushKV("descendantcount", e.GetCountWithDescendants());
         info.pushKV("descendantsize", e.GetSizeWithDescendants());
         info.pushKV("ancestorcount", e.GetCountWithAncestors());
         info.pushKV("ancestorsize", e.GetSizeWithAncestors());
     }
     const CTransaction &tx = e.GetTx();
     std::set<std::string> setDepends;
     for (const CTxIn &txin : tx.vin) {
         if (pool.exists(txin.prevout.GetTxId())) {
             setDepends.insert(txin.prevout.GetTxId().ToString());
         }
     }
 
     UniValue depends(UniValue::VARR);
     for (const std::string &dep : setDepends) {
         depends.push_back(dep);
     }
 
     info.pushKV("depends", depends);
 
     UniValue spent(UniValue::VARR);
     for (const CTxMemPoolEntry &child : e.GetMemPoolChildrenConst()) {
         spent.push_back(child.GetTx().GetId().ToString());
     }
 
     info.pushKV("spentby", spent);
     info.pushKV("unbroadcast", pool.IsUnbroadcastTx(tx.GetId()));
 }
 
 UniValue MempoolToJSON(const CTxMemPool &pool, bool verbose,
                        bool include_mempool_sequence) {
     if (verbose) {
         if (include_mempool_sequence) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 "Verbose results cannot contain mempool sequence values.");
         }
         LOCK(pool.cs);
         UniValue o(UniValue::VOBJ);
         for (const CTxMemPoolEntry &e : pool.mapTx) {
             const TxId &txid = e.GetTx().GetId();
             UniValue info(UniValue::VOBJ);
             entryToJSON(pool, info, e);
             // Mempool has unique entries so there is no advantage in using
             // UniValue::pushKV, which checks if the key already exists in O(N).
             // UniValue::__pushKV is used instead which currently is O(1).
             o.__pushKV(txid.ToString(), info);
         }
         return o;
     } else {
         uint64_t mempool_sequence;
         std::vector<TxId> vtxids;
         {
             LOCK(pool.cs);
             pool.getAllTxIds(vtxids);
             mempool_sequence = pool.GetSequence();
         }
         UniValue a(UniValue::VARR);
         for (const TxId &txid : vtxids) {
             a.push_back(txid.ToString());
         }
 
         if (!include_mempool_sequence) {
             return a;
         } else {
             UniValue o(UniValue::VOBJ);
             o.pushKV("txids", a);
             o.pushKV("mempool_sequence", mempool_sequence);
             return o;
         }
     }
 }
 
 static RPCHelpMan getrawmempool() {
     return RPCHelpMan{
         "getrawmempool",
         "Returns all transaction ids in memory pool as a json array of "
         "string transaction ids.\n"
         "\nHint: use getmempoolentry to fetch a specific transaction from the "
         "mempool.\n",
         {
             {"verbose", RPCArg::Type::BOOL, /* default */ "false",
              "True for a json object, false for array of transaction ids"},
             {"mempool_sequence", RPCArg::Type::BOOL, /* default */ "false",
              "If verbose=false, returns a json object with transaction list "
              "and mempool sequence number attached."},
         },
         {
             RPCResult{"for verbose = false",
                       RPCResult::Type::ARR,
                       "",
                       "",
                       {
                           {RPCResult::Type::STR_HEX, "", "The transaction id"},
                       }},
             RPCResult{"for verbose = true",
                       RPCResult::Type::OBJ_DYN,
                       "",
                       "",
                       {
                           {RPCResult::Type::OBJ, "transactionid", "",
                            MempoolEntryDescription()},
                       }},
             RPCResult{
                 "for verbose = false and mempool_sequence = true",
                 RPCResult::Type::OBJ,
                 "",
                 "",
                 {
                     {RPCResult::Type::ARR,
                      "txids",
                      "",
                      {
                          {RPCResult::Type::STR_HEX, "", "The transaction id"},
                      }},
                     {RPCResult::Type::NUM, "mempool_sequence",
                      "The mempool sequence value."},
                 }},
         },
         RPCExamples{HelpExampleCli("getrawmempool", "true") +
                     HelpExampleRpc("getrawmempool", "true")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             bool fVerbose = false;
             if (!request.params[0].isNull()) {
                 fVerbose = request.params[0].get_bool();
             }
 
             bool include_mempool_sequence = false;
             if (!request.params[1].isNull()) {
                 include_mempool_sequence = request.params[1].get_bool();
             }
 
             return MempoolToJSON(EnsureAnyMemPool(request.context), fVerbose,
                                  include_mempool_sequence);
         },
     };
 }
 
 static RPCHelpMan getmempoolancestors() {
     return RPCHelpMan{
         "getmempoolancestors",
         "If txid is in the mempool, returns all in-mempool ancestors.\n",
         {
             {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The transaction id (must be in mempool)"},
             {"verbose", RPCArg::Type::BOOL, /* default */ "false",
              "True for a json object, false for array of transaction ids"},
         },
         {
             RPCResult{
                 "for verbose = false",
                 RPCResult::Type::ARR,
                 "",
                 "",
                 {{RPCResult::Type::STR_HEX, "",
                   "The transaction id of an in-mempool ancestor transaction"}}},
             RPCResult{"for verbose = true",
                       RPCResult::Type::OBJ_DYN,
                       "",
                       "",
                       {
                           {RPCResult::Type::OBJ, "transactionid", "",
                            MempoolEntryDescription()},
                       }},
         },
         RPCExamples{HelpExampleCli("getmempoolancestors", "\"mytxid\"") +
                     HelpExampleRpc("getmempoolancestors", "\"mytxid\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             bool fVerbose = false;
             if (!request.params[1].isNull()) {
                 fVerbose = request.params[1].get_bool();
             }
 
             TxId txid(ParseHashV(request.params[0], "parameter 1"));
 
             const CTxMemPool &mempool = EnsureAnyMemPool(request.context);
             LOCK(mempool.cs);
 
             CTxMemPool::txiter it = mempool.mapTx.find(txid);
             if (it == mempool.mapTx.end()) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                    "Transaction not in mempool");
             }
 
             CTxMemPool::setEntries setAncestors;
             mempool.CalculateMemPoolAncestors(*it, setAncestors, false);
 
             if (!fVerbose) {
                 UniValue o(UniValue::VARR);
                 for (CTxMemPool::txiter ancestorIt : setAncestors) {
                     o.push_back(ancestorIt->GetTx().GetId().ToString());
                 }
                 return o;
             } else {
                 UniValue o(UniValue::VOBJ);
                 for (CTxMemPool::txiter ancestorIt : setAncestors) {
                     const CTxMemPoolEntry &e = *ancestorIt;
                     const TxId &_txid = e.GetTx().GetId();
                     UniValue info(UniValue::VOBJ);
                     entryToJSON(mempool, info, e);
                     o.pushKV(_txid.ToString(), info);
                 }
                 return o;
             }
         },
     };
 }
 
 static RPCHelpMan getmempooldescendants() {
     return RPCHelpMan{
         "getmempooldescendants",
         "If txid is in the mempool, returns all in-mempool descendants.\n",
         {
             {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The transaction id (must be in mempool)"},
             {"verbose", RPCArg::Type::BOOL, /* default */ "false",
              "True for a json object, false for array of transaction ids"},
         },
         {
             RPCResult{"for verbose = false",
                       RPCResult::Type::ARR,
                       "",
                       "",
                       {{RPCResult::Type::STR_HEX, "",
                         "The transaction id of an in-mempool descendant "
                         "transaction"}}},
             RPCResult{"for verbose = true",
                       RPCResult::Type::OBJ_DYN,
                       "",
                       "",
                       {
                           {RPCResult::Type::OBJ, "transactionid", "",
                            MempoolEntryDescription()},
                       }},
         },
         RPCExamples{HelpExampleCli("getmempooldescendants", "\"mytxid\"") +
                     HelpExampleRpc("getmempooldescendants", "\"mytxid\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             bool fVerbose = false;
             if (!request.params[1].isNull()) {
                 fVerbose = request.params[1].get_bool();
             }
 
             TxId txid(ParseHashV(request.params[0], "parameter 1"));
 
             const CTxMemPool &mempool = EnsureAnyMemPool(request.context);
             LOCK(mempool.cs);
 
             CTxMemPool::txiter it = mempool.mapTx.find(txid);
             if (it == mempool.mapTx.end()) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                    "Transaction not in mempool");
             }
 
             CTxMemPool::setEntries setDescendants;
             mempool.CalculateDescendants(it, setDescendants);
             // CTxMemPool::CalculateDescendants will include the given tx
             setDescendants.erase(it);
 
             if (!fVerbose) {
                 UniValue o(UniValue::VARR);
                 for (CTxMemPool::txiter descendantIt : setDescendants) {
                     o.push_back(descendantIt->GetTx().GetId().ToString());
                 }
 
                 return o;
             } else {
                 UniValue o(UniValue::VOBJ);
                 for (CTxMemPool::txiter descendantIt : setDescendants) {
                     const CTxMemPoolEntry &e = *descendantIt;
                     const TxId &_txid = e.GetTx().GetId();
                     UniValue info(UniValue::VOBJ);
                     entryToJSON(mempool, info, e);
                     o.pushKV(_txid.ToString(), info);
                 }
                 return o;
             }
         },
     };
 }
 
 static RPCHelpMan getmempoolentry() {
     return RPCHelpMan{
         "getmempoolentry",
         "Returns mempool data for given transaction\n",
         {
             {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The transaction id (must be in mempool)"},
         },
         RPCResult{RPCResult::Type::OBJ, "", "", MempoolEntryDescription()},
         RPCExamples{HelpExampleCli("getmempoolentry", "\"mytxid\"") +
                     HelpExampleRpc("getmempoolentry", "\"mytxid\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             TxId txid(ParseHashV(request.params[0], "parameter 1"));
 
             const CTxMemPool &mempool = EnsureAnyMemPool(request.context);
             LOCK(mempool.cs);
 
             CTxMemPool::txiter it = mempool.mapTx.find(txid);
             if (it == mempool.mapTx.end()) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                    "Transaction not in mempool");
             }
 
             const CTxMemPoolEntry &e = *it;
             UniValue info(UniValue::VOBJ);
             entryToJSON(mempool, info, e);
             return info;
         },
     };
 }
 
 static RPCHelpMan getblockfrompeer() {
     return RPCHelpMan{
         "getblockfrompeer",
         "\nAttempt to fetch block from a given peer.\n"
         "\nWe must have the header for this block, e.g. using submitheader.\n"
         "Subsequent calls for the same block and a new peer will cause the "
         "response from the previous peer to be ignored.\n"
         "\nReturns an empty JSON object if the request was successfully "
         "scheduled.",
         {
             {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The block hash to try to fetch"},
             {"peer_id", RPCArg::Type::NUM, RPCArg::Optional::NO,
              "The peer to fetch it from (see getpeerinfo for peer IDs)"},
         },
         RPCResult{RPCResult::Type::OBJ_EMPTY, "", /*optional=*/false, "", {}},
         RPCExamples{HelpExampleCli("getblockfrompeer",
                                    "\"00000000c937983704a73af28acdec37b049d214a"
                                    "dbda81d7e2a3dd146f6ed09\" 0") +
                     HelpExampleRpc("getblockfrompeer",
                                    "\"00000000c937983704a73af28acdec37b049d214a"
                                    "dbda81d7e2a3dd146f6ed09\" 0")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             const NodeContext &node = EnsureAnyNodeContext(request.context);
             ChainstateManager &chainman = EnsureChainman(node);
             PeerManager &peerman = EnsurePeerman(node);
 
             const BlockHash block_hash{
                 ParseHashV(request.params[0], "blockhash")};
             const NodeId peer_id{request.params[1].get_int64()};
 
             const CBlockIndex *const index = WITH_LOCK(
                 cs_main,
                 return chainman.m_blockman.LookupBlockIndex(block_hash););
 
             if (!index) {
                 throw JSONRPCError(RPC_MISC_ERROR, "Block header missing");
             }
 
             if (WITH_LOCK(::cs_main, return index->nStatus.hasData())) {
                 throw JSONRPCError(RPC_MISC_ERROR, "Block already downloaded");
             }
 
             if (const auto err{peerman.FetchBlock(config, peer_id, *index)}) {
                 throw JSONRPCError(RPC_MISC_ERROR, err.value());
             }
             return UniValue::VOBJ;
         },
     };
 }
 
 static RPCHelpMan getblockhash() {
     return RPCHelpMan{
         "getblockhash",
         "Returns hash of block in best-block-chain at height provided.\n",
         {
             {"height", RPCArg::Type::NUM, RPCArg::Optional::NO,
              "The height index"},
         },
         RPCResult{RPCResult::Type::STR_HEX, "", "The block hash"},
         RPCExamples{HelpExampleCli("getblockhash", "1000") +
                     HelpExampleRpc("getblockhash", "1000")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             ChainstateManager &chainman = EnsureAnyChainman(request.context);
             LOCK(cs_main);
             const CChain &active_chain = chainman.ActiveChain();
 
             int nHeight = request.params[0].get_int();
             if (nHeight < 0 || nHeight > active_chain.Height()) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    "Block height out of range");
             }
 
             const CBlockIndex *pblockindex = active_chain[nHeight];
             return pblockindex->GetBlockHash().GetHex();
         },
     };
 }
 
 static RPCHelpMan getblockheader() {
     return RPCHelpMan{
         "getblockheader",
         "If verbose is false, returns a string that is serialized, hex-encoded "
         "data for blockheader 'hash'.\n"
         "If verbose is true, returns an Object with information about "
         "blockheader <hash>.\n",
         {
             {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The block hash"},
             {"verbose", RPCArg::Type::BOOL, /* default */ "true",
              "true for a json object, false for the hex-encoded data"},
         },
         {
             RPCResult{
                 "for verbose = true",
                 RPCResult::Type::OBJ,
                 "",
                 "",
                 {
                     {RPCResult::Type::STR_HEX, "hash",
                      "the block hash (same as provided)"},
                     {RPCResult::Type::NUM, "confirmations",
                      "The number of confirmations, or -1 if the block is not "
                      "on the main chain"},
                     {RPCResult::Type::NUM, "height",
                      "The block height or index"},
                     {RPCResult::Type::NUM, "version", "The block version"},
                     {RPCResult::Type::STR_HEX, "versionHex",
                      "The block version formatted in hexadecimal"},
                     {RPCResult::Type::STR_HEX, "merkleroot", "The merkle root"},
                     {RPCResult::Type::NUM_TIME, "time",
                      "The block time expressed in " + UNIX_EPOCH_TIME},
                     {RPCResult::Type::NUM_TIME, "mediantime",
                      "The median block time expressed in " + UNIX_EPOCH_TIME},
                     {RPCResult::Type::NUM, "nonce", "The nonce"},
                     {RPCResult::Type::STR_HEX, "bits", "The bits"},
                     {RPCResult::Type::NUM, "difficulty", "The difficulty"},
                     {RPCResult::Type::STR_HEX, "chainwork",
                      "Expected number of hashes required to produce the "
                      "current chain"},
                     {RPCResult::Type::NUM, "nTx",
                      "The number of transactions in the block"},
                     {RPCResult::Type::STR_HEX, "previousblockhash",
                      /* optional */ true,
                      "The hash of the previous block (if available)"},
                     {RPCResult::Type::STR_HEX, "nextblockhash",
                      /* optional */ true,
                      "The hash of the next block (if available)"},
                 }},
             RPCResult{"for verbose=false", RPCResult::Type::STR_HEX, "",
                       "A string that is serialized, hex-encoded data for block "
                       "'hash'"},
         },
         RPCExamples{HelpExampleCli("getblockheader",
                                    "\"00000000c937983704a73af28acdec37b049d214a"
                                    "dbda81d7e2a3dd146f6ed09\"") +
                     HelpExampleRpc("getblockheader",
                                    "\"00000000c937983704a73af28acdec37b049d214a"
                                    "dbda81d7e2a3dd146f6ed09\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             BlockHash hash(ParseHashV(request.params[0], "hash"));
 
             bool fVerbose = true;
             if (!request.params[1].isNull()) {
                 fVerbose = request.params[1].get_bool();
             }
 
             const CBlockIndex *pblockindex;
             const CBlockIndex *tip;
             {
                 ChainstateManager &chainman =
                     EnsureAnyChainman(request.context);
                 LOCK(cs_main);
                 pblockindex = chainman.m_blockman.LookupBlockIndex(hash);
                 tip = chainman.ActiveTip();
             }
 
             if (!pblockindex) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                    "Block not found");
             }
 
             if (!fVerbose) {
                 CDataStream ssBlock(SER_NETWORK, PROTOCOL_VERSION);
                 ssBlock << pblockindex->GetBlockHeader();
                 std::string strHex = HexStr(ssBlock);
                 return strHex;
             }
 
             return blockheaderToJSON(tip, pblockindex);
         },
     };
 }
 
 static CBlock GetBlockChecked(const Config &config, BlockManager &blockman,
                               const CBlockIndex *pblockindex) {
     CBlock block;
     {
         LOCK(cs_main);
         if (blockman.IsBlockPruned(pblockindex)) {
             throw JSONRPCError(RPC_MISC_ERROR,
                                "Block not available (pruned data)");
         }
     }
 
     if (!ReadBlockFromDisk(block, pblockindex,
                            config.GetChainParams().GetConsensus())) {
         // Block not found on disk. This could be because we have the block
         // header in our index but not yet have the block or did not accept the
         // block. Or if the block was pruned right after we released the lock
         // above.
         throw JSONRPCError(RPC_MISC_ERROR, "Block not found on disk");
     }
 
     return block;
 }
 
 static CBlockUndo GetUndoChecked(BlockManager &blockman,
                                  const CBlockIndex *pblockindex) {
     CBlockUndo blockUndo;
 
     {
         LOCK(cs_main);
         if (blockman.IsBlockPruned(pblockindex)) {
             throw JSONRPCError(RPC_MISC_ERROR,
                                "Undo data not available (pruned data)");
         }
     }
 
     if (!UndoReadFromDisk(blockUndo, pblockindex)) {
         throw JSONRPCError(RPC_MISC_ERROR, "Can't read undo data from disk");
     }
 
     return blockUndo;
 }
 
 static RPCHelpMan getblock() {
     return RPCHelpMan{
         "getblock",
         "If verbosity is 0 or false, returns a string that is serialized, "
         "hex-encoded data for block 'hash'.\n"
         "If verbosity is 1 or true, returns an Object with information about "
         "block <hash>.\n"
         "If verbosity is 2, returns an Object with information about block "
         "<hash> and information about each transaction.\n",
         {
             {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The block hash"},
             {"verbosity|verbose", RPCArg::Type::NUM, /* default */ "1",
              "0 for hex-encoded data, 1 for a json object, and 2 for json "
              "object with transaction data"},
         },
         {
             RPCResult{"for verbosity = 0", RPCResult::Type::STR_HEX, "",
                       "A string that is serialized, hex-encoded data for block "
                       "'hash'"},
             RPCResult{
                 "for verbosity = 1",
                 RPCResult::Type::OBJ,
                 "",
                 "",
                 {
                     {RPCResult::Type::STR_HEX, "hash",
                      "the block hash (same as provided)"},
                     {RPCResult::Type::NUM, "confirmations",
                      "The number of confirmations, or -1 if the block is not "
                      "on the main chain"},
                     {RPCResult::Type::NUM, "size", "The block size"},
                     {RPCResult::Type::NUM, "height",
                      "The block height or index"},
                     {RPCResult::Type::NUM, "version", "The block version"},
                     {RPCResult::Type::STR_HEX, "versionHex",
                      "The block version formatted in hexadecimal"},
                     {RPCResult::Type::STR_HEX, "merkleroot", "The merkle root"},
                     {RPCResult::Type::ARR,
                      "tx",
                      "The transaction ids",
                      {{RPCResult::Type::STR_HEX, "", "The transaction id"}}},
                     {RPCResult::Type::NUM_TIME, "time",
                      "The block time expressed in " + UNIX_EPOCH_TIME},
                     {RPCResult::Type::NUM_TIME, "mediantime",
                      "The median block time expressed in " + UNIX_EPOCH_TIME},
                     {RPCResult::Type::NUM, "nonce", "The nonce"},
                     {RPCResult::Type::STR_HEX, "bits", "The bits"},
                     {RPCResult::Type::NUM, "difficulty", "The difficulty"},
                     {RPCResult::Type::STR_HEX, "chainwork",
                      "Expected number of hashes required to produce the chain "
                      "up to this block (in hex)"},
                     {RPCResult::Type::NUM, "nTx",
                      "The number of transactions in the block"},
                     {RPCResult::Type::STR_HEX, "previousblockhash",
                      /* optional */ true,
                      "The hash of the previous block (if available)"},
                     {RPCResult::Type::STR_HEX, "nextblockhash",
                      /* optional */ true,
                      "The hash of the next block (if available)"},
                 }},
             RPCResult{"for verbosity = 2",
                       RPCResult::Type::OBJ,
                       "",
                       "",
                       {
                           {RPCResult::Type::ELISION, "",
                            "Same output as verbosity = 1"},
                           {RPCResult::Type::ARR,
                            "tx",
                            "",
                            {
                                {RPCResult::Type::OBJ,
                                 "",
                                 "",
                                 {
                                     {RPCResult::Type::ELISION, "",
                                      "The transactions in the format of the "
                                      "getrawtransaction RPC. Different from "
                                      "verbosity = 1 \"tx\" result"},
                                     {RPCResult::Type::STR_AMOUNT, "fee",
                                      "The transaction fee in " +
                                          Currency::get().ticker +
                                          ", omitted if block undo data is not "
                                          "available"},
                                 }},
                            }},
                       }},
         },
         RPCExamples{
             HelpExampleCli("getblock", "\"00000000c937983704a73af28acdec37b049d"
                                        "214adbda81d7e2a3dd146f6ed09\"") +
             HelpExampleRpc("getblock", "\"00000000c937983704a73af28acdec37b049d"
                                        "214adbda81d7e2a3dd146f6ed09\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             BlockHash hash(ParseHashV(request.params[0], "blockhash"));
 
             int verbosity = 1;
             if (!request.params[1].isNull()) {
                 if (request.params[1].isNum()) {
                     verbosity = request.params[1].get_int();
                 } else {
                     verbosity = request.params[1].get_bool() ? 1 : 0;
                 }
             }
 
             const CBlockIndex *pblockindex;
             const CBlockIndex *tip;
             ChainstateManager &chainman = EnsureAnyChainman(request.context);
             {
                 LOCK(cs_main);
                 pblockindex = chainman.m_blockman.LookupBlockIndex(hash);
                 tip = chainman.ActiveTip();
 
                 if (!pblockindex) {
                     throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                        "Block not found");
                 }
             }
 
             const CBlock block =
                 GetBlockChecked(config, chainman.m_blockman, pblockindex);
 
             if (verbosity <= 0) {
                 CDataStream ssBlock(SER_NETWORK,
                                     PROTOCOL_VERSION | RPCSerializationFlags());
                 ssBlock << block;
                 std::string strHex = HexStr(ssBlock);
                 return strHex;
             }
 
             return blockToJSON(chainman.m_blockman, block, tip, pblockindex,
                                verbosity >= 2);
         },
     };
 }
 
 static RPCHelpMan pruneblockchain() {
     return RPCHelpMan{
         "pruneblockchain",
         "",
         {
             {"height", RPCArg::Type::NUM, RPCArg::Optional::NO,
              "The block height to prune up to. May be set to a discrete "
              "height, or to a " +
                  UNIX_EPOCH_TIME +
                  "\n"
                  "                  to prune blocks whose block time is at "
                  "least 2 hours older than the provided timestamp."},
         },
         RPCResult{RPCResult::Type::NUM, "", "Height of the last block pruned"},
         RPCExamples{HelpExampleCli("pruneblockchain", "1000") +
                     HelpExampleRpc("pruneblockchain", "1000")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             if (!node::fPruneMode) {
                 throw JSONRPCError(
                     RPC_MISC_ERROR,
                     "Cannot prune blocks because node is not in prune mode.");
             }
 
             ChainstateManager &chainman = EnsureAnyChainman(request.context);
             LOCK(cs_main);
             Chainstate &active_chainstate = chainman.ActiveChainstate();
             CChain &active_chain = active_chainstate.m_chain;
 
             int heightParam = request.params[0].get_int();
             if (heightParam < 0) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    "Negative block height.");
             }
 
             // Height value more than a billion is too high to be a block
             // height, and too low to be a block time (corresponds to timestamp
             // from Sep 2001).
             if (heightParam > 1000000000) {
                 // Add a 2 hour buffer to include blocks which might have had
                 // old timestamps
                 const CBlockIndex *pindex = active_chain.FindEarliestAtLeast(
                     heightParam - TIMESTAMP_WINDOW, 0);
                 if (!pindex) {
                     throw JSONRPCError(RPC_INVALID_PARAMETER,
                                        "Could not find block with at least the "
                                        "specified timestamp.");
                 }
                 heightParam = pindex->nHeight;
             }
 
             unsigned int height = (unsigned int)heightParam;
             unsigned int chainHeight = (unsigned int)active_chain.Height();
             if (chainHeight < config.GetChainParams().PruneAfterHeight()) {
                 throw JSONRPCError(RPC_MISC_ERROR,
                                    "Blockchain is too short for pruning.");
             } else if (height > chainHeight) {
                 throw JSONRPCError(
                     RPC_INVALID_PARAMETER,
                     "Blockchain is shorter than the attempted prune height.");
             } else if (height > chainHeight - MIN_BLOCKS_TO_KEEP) {
                 LogPrint(BCLog::RPC,
                          "Attempt to prune blocks close to the tip. "
                          "Retaining the minimum number of blocks.\n");
                 height = chainHeight - MIN_BLOCKS_TO_KEEP;
             }
 
             PruneBlockFilesManual(active_chainstate, height);
             const CBlockIndex *block = CHECK_NONFATAL(active_chain.Tip());
             const CBlockIndex *last_block = node::GetFirstStoredBlock(block);
 
             return static_cast<uint64_t>(last_block->nHeight);
         },
     };
 }
 
 static CoinStatsHashType ParseHashType(const std::string &hash_type_input) {
     if (hash_type_input == "hash_serialized") {
         return CoinStatsHashType::HASH_SERIALIZED;
     } else if (hash_type_input == "muhash") {
         return CoinStatsHashType::MUHASH;
     } else if (hash_type_input == "none") {
         return CoinStatsHashType::NONE;
     } else {
         throw JSONRPCError(
             RPC_INVALID_PARAMETER,
             strprintf("%s is not a valid hash_type", hash_type_input));
     }
 }
 
 static RPCHelpMan gettxoutsetinfo() {
     return RPCHelpMan{
         "gettxoutsetinfo",
         "Returns statistics about the unspent transaction output set.\n"
         "Note this call may take some time if you are not using "
         "coinstatsindex.\n",
         {
             {"hash_type", RPCArg::Type::STR, /* default */ "hash_serialized",
              "Which UTXO set hash should be calculated. Options: "
              "'hash_serialized' (the legacy algorithm), 'muhash', 'none'."},
             {"hash_or_height",
              RPCArg::Type::NUM,
              RPCArg::Optional::OMITTED,
              "The block hash or height of the target height (only available "
              "with coinstatsindex).",
              "",
              {"", "string or numeric"}},
             {"use_index", RPCArg::Type::BOOL, /* default */ "true",
              "Use coinstatsindex, if available."},
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::NUM, "height",
                  "The current block height (index)"},
                 {RPCResult::Type::STR_HEX, "bestblock",
                  "The hash of the block at the tip of the chain"},
                 {RPCResult::Type::NUM, "txouts",
                  "The number of unspent transaction outputs"},
                 {RPCResult::Type::NUM, "bogosize",
                  "Database-independent, meaningless metric indicating "
                  "the UTXO set size"},
                 {RPCResult::Type::STR_HEX, "hash_serialized",
                  /* optional */ true,
                  "The serialized hash (only present if 'hash_serialized' "
                  "hash_type is chosen)"},
                 {RPCResult::Type::STR_HEX, "muhash", /* optional */ true,
                  "The serialized hash (only present if 'muhash' "
                  "hash_type is chosen)"},
                 {RPCResult::Type::NUM, "transactions",
                  "The number of transactions with unspent outputs (not "
                  "available when coinstatsindex is used)"},
                 {RPCResult::Type::NUM, "disk_size",
                  "The estimated size of the chainstate on disk (not "
                  "available when coinstatsindex is used)"},
                 {RPCResult::Type::STR_AMOUNT, "total_amount",
                  "The total amount"},
                 {RPCResult::Type::STR_AMOUNT, "total_unspendable_amount",
                  "The total amount of coins permanently excluded from the UTXO "
                  "set (only available if coinstatsindex is used)"},
                 {RPCResult::Type::OBJ,
                  "block_info",
                  "Info on amounts in the block at this block height (only "
                  "available if coinstatsindex is used)",
                  {{RPCResult::Type::STR_AMOUNT, "prevout_spent",
                    "Total amount of all prevouts spent in this block"},
                   {RPCResult::Type::STR_AMOUNT, "coinbase",
                    "Coinbase subsidy amount of this block"},
                   {RPCResult::Type::STR_AMOUNT, "new_outputs_ex_coinbase",
                    "Total amount of new outputs created by this block"},
                   {RPCResult::Type::STR_AMOUNT, "unspendable",
                    "Total amount of unspendable outputs created in this block"},
                   {RPCResult::Type::OBJ,
                    "unspendables",
                    "Detailed view of the unspendable categories",
                    {
                        {RPCResult::Type::STR_AMOUNT, "genesis_block",
                         "The unspendable amount of the Genesis block subsidy"},
                        {RPCResult::Type::STR_AMOUNT, "bip30",
                         "Transactions overridden by duplicates (no longer "
                         "possible with BIP30)"},
                        {RPCResult::Type::STR_AMOUNT, "scripts",
                         "Amounts sent to scripts that are unspendable (for "
                         "example OP_RETURN outputs)"},
                        {RPCResult::Type::STR_AMOUNT, "unclaimed_rewards",
                         "Fee rewards that miners did not claim in their "
                         "coinbase transaction"},
                    }}}},
             }},
         RPCExamples{
             HelpExampleCli("gettxoutsetinfo", "") +
             HelpExampleCli("gettxoutsetinfo", R"("none")") +
             HelpExampleCli("gettxoutsetinfo", R"("none" 1000)") +
             HelpExampleCli(
                 "gettxoutsetinfo",
                 R"("none" '"00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09"')") +
             HelpExampleRpc("gettxoutsetinfo", "") +
             HelpExampleRpc("gettxoutsetinfo", R"("none")") +
             HelpExampleRpc("gettxoutsetinfo", R"("none", 1000)") +
             HelpExampleRpc(
                 "gettxoutsetinfo",
                 R"("none", "00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09")")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             UniValue ret(UniValue::VOBJ);
 
             const CBlockIndex *pindex{nullptr};
             const CoinStatsHashType hash_type{
                 request.params[0].isNull()
                     ? CoinStatsHashType::HASH_SERIALIZED
                     : ParseHashType(request.params[0].get_str())};
             CCoinsStats stats{hash_type};
             stats.index_requested =
                 request.params[2].isNull() || request.params[2].get_bool();
 
             NodeContext &node = EnsureAnyNodeContext(request.context);
             ChainstateManager &chainman = EnsureChainman(node);
             Chainstate &active_chainstate = chainman.ActiveChainstate();
             active_chainstate.ForceFlushStateToDisk();
 
             CCoinsView *coins_view;
             BlockManager *blockman;
             {
                 LOCK(::cs_main);
                 coins_view = &active_chainstate.CoinsDB();
                 blockman = &active_chainstate.m_blockman;
                 pindex = blockman->LookupBlockIndex(coins_view->GetBestBlock());
             }
 
             if (!request.params[1].isNull()) {
                 if (!g_coin_stats_index) {
                     throw JSONRPCError(RPC_INVALID_PARAMETER,
                                        "Querying specific block heights "
                                        "requires coinstatsindex");
                 }
 
                 if (stats.m_hash_type == CoinStatsHashType::HASH_SERIALIZED) {
                     throw JSONRPCError(RPC_INVALID_PARAMETER,
                                        "hash_serialized hash type cannot be "
                                        "queried for a specific block");
                 }
 
                 pindex = ParseHashOrHeight(request.params[1], chainman);
             }
 
             if (stats.index_requested && g_coin_stats_index) {
                 if (!g_coin_stats_index->BlockUntilSyncedToCurrentChain()) {
                     const IndexSummary summary{
                         g_coin_stats_index->GetSummary()};
 
                     // If a specific block was requested and the index has
                     // already synced past that height, we can return the data
                     // already even though the index is not fully synced yet.
                     if (pindex->nHeight > summary.best_block_height) {
                         throw JSONRPCError(
                             RPC_INTERNAL_ERROR,
                             strprintf(
                                 "Unable to get data because coinstatsindex is "
                                 "still syncing. Current height: %d",
                                 summary.best_block_height));
                     }
                 }
             }
 
             if (GetUTXOStats(coins_view, *blockman, stats,
                              node.rpc_interruption_point, pindex)) {
                 ret.pushKV("height", int64_t(stats.nHeight));
                 ret.pushKV("bestblock", stats.hashBlock.GetHex());
                 ret.pushKV("txouts", int64_t(stats.nTransactionOutputs));
                 ret.pushKV("bogosize", int64_t(stats.nBogoSize));
                 if (hash_type == CoinStatsHashType::HASH_SERIALIZED) {
                     ret.pushKV("hash_serialized",
                                stats.hashSerialized.GetHex());
                 }
                 if (hash_type == CoinStatsHashType::MUHASH) {
                     ret.pushKV("muhash", stats.hashSerialized.GetHex());
                 }
                 ret.pushKV("total_amount", stats.nTotalAmount);
                 if (!stats.index_used) {
                     ret.pushKV("transactions",
                                static_cast<int64_t>(stats.nTransactions));
                     ret.pushKV("disk_size", stats.nDiskSize);
                 } else {
                     ret.pushKV("total_unspendable_amount",
                                stats.total_unspendable_amount);
 
                     CCoinsStats prev_stats{hash_type};
 
                     if (pindex->nHeight > 0) {
                         GetUTXOStats(coins_view, *blockman, prev_stats,
                                      node.rpc_interruption_point,
                                      pindex->pprev);
                     }
 
                     UniValue block_info(UniValue::VOBJ);
                     block_info.pushKV(
                         "prevout_spent",
                         stats.total_prevout_spent_amount -
                             prev_stats.total_prevout_spent_amount);
                     block_info.pushKV("coinbase",
                                       stats.total_coinbase_amount -
                                           prev_stats.total_coinbase_amount);
                     block_info.pushKV(
                         "new_outputs_ex_coinbase",
                         stats.total_new_outputs_ex_coinbase_amount -
                             prev_stats.total_new_outputs_ex_coinbase_amount);
                     block_info.pushKV("unspendable",
                                       stats.total_unspendable_amount -
                                           prev_stats.total_unspendable_amount);
 
                     UniValue unspendables(UniValue::VOBJ);
                     unspendables.pushKV(
                         "genesis_block",
                         stats.total_unspendables_genesis_block -
                             prev_stats.total_unspendables_genesis_block);
                     unspendables.pushKV(
                         "bip30", stats.total_unspendables_bip30 -
                                      prev_stats.total_unspendables_bip30);
                     unspendables.pushKV(
                         "scripts", stats.total_unspendables_scripts -
                                        prev_stats.total_unspendables_scripts);
                     unspendables.pushKV(
                         "unclaimed_rewards",
                         stats.total_unspendables_unclaimed_rewards -
                             prev_stats.total_unspendables_unclaimed_rewards);
                     block_info.pushKV("unspendables", unspendables);
 
                     ret.pushKV("block_info", block_info);
                 }
             } else {
                 throw JSONRPCError(RPC_INTERNAL_ERROR,
                                    "Unable to read UTXO set");
             }
             return ret;
         },
     };
 }
 
 RPCHelpMan gettxout() {
     return RPCHelpMan{
         "gettxout",
         "Returns details about an unspent transaction output.\n",
         {
             {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The transaction id"},
             {"n", RPCArg::Type::NUM, RPCArg::Optional::NO, "vout number"},
             {"include_mempool", RPCArg::Type::BOOL, /* default */ "true",
              "Whether to include the mempool. Note that an unspent output that "
              "is spent in the mempool won't appear."},
         },
         {
             RPCResult{"If the UTXO was not found", RPCResult::Type::NONE, "",
                       ""},
             RPCResult{
                 "Otherwise",
                 RPCResult::Type::OBJ,
                 "",
                 "",
                 {
                     {RPCResult::Type::STR_HEX, "bestblock",
                      "The hash of the block at the tip of the chain"},
                     {RPCResult::Type::NUM, "confirmations",
                      "The number of confirmations"},
                     {RPCResult::Type::STR_AMOUNT, "value",
                      "The transaction value in " + Currency::get().ticker},
                     {RPCResult::Type::OBJ,
                      "scriptPubKey",
                      "",
                      {
                          {RPCResult::Type::STR_HEX, "asm", ""},
                          {RPCResult::Type::STR_HEX, "hex", ""},
                          {RPCResult::Type::NUM, "reqSigs",
                           "Number of required signatures"},
                          {RPCResult::Type::STR_HEX, "type",
                           "The type, eg pubkeyhash"},
                          {RPCResult::Type::ARR,
                           "addresses",
                           "array of eCash addresses",
                           {{RPCResult::Type::STR, "address", "eCash address"}}},
                      }},
                     {RPCResult::Type::BOOL, "coinbase", "Coinbase or not"},
                 }},
         },
         RPCExamples{"\nGet unspent transactions\n" +
                     HelpExampleCli("listunspent", "") + "\nView the details\n" +
                     HelpExampleCli("gettxout", "\"txid\" 1") +
                     "\nAs a JSON-RPC call\n" +
                     HelpExampleRpc("gettxout", "\"txid\", 1")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             NodeContext &node = EnsureAnyNodeContext(request.context);
             ChainstateManager &chainman = EnsureChainman(node);
             LOCK(cs_main);
 
             UniValue ret(UniValue::VOBJ);
 
             TxId txid(ParseHashV(request.params[0], "txid"));
             int n = request.params[1].get_int();
             COutPoint out(txid, n);
             bool fMempool = true;
             if (!request.params[2].isNull()) {
                 fMempool = request.params[2].get_bool();
             }
 
             Coin coin;
             Chainstate &active_chainstate = chainman.ActiveChainstate();
             CCoinsViewCache *coins_view = &active_chainstate.CoinsTip();
 
             if (fMempool) {
                 const CTxMemPool &mempool = EnsureMemPool(node);
                 LOCK(mempool.cs);
                 CCoinsViewMemPool view(coins_view, mempool);
                 if (!view.GetCoin(out, coin) || mempool.isSpent(out)) {
                     return NullUniValue;
                 }
             } else {
                 if (!coins_view->GetCoin(out, coin)) {
                     return NullUniValue;
                 }
             }
 
             const CBlockIndex *pindex =
                 active_chainstate.m_blockman.LookupBlockIndex(
                     coins_view->GetBestBlock());
             ret.pushKV("bestblock", pindex->GetBlockHash().GetHex());
             if (coin.GetHeight() == MEMPOOL_HEIGHT) {
                 ret.pushKV("confirmations", 0);
             } else {
                 ret.pushKV("confirmations",
                            int64_t(pindex->nHeight - coin.GetHeight() + 1));
             }
             ret.pushKV("value", coin.GetTxOut().nValue);
             UniValue o(UniValue::VOBJ);
             ScriptPubKeyToUniv(coin.GetTxOut().scriptPubKey, o, true);
             ret.pushKV("scriptPubKey", o);
             ret.pushKV("coinbase", coin.IsCoinBase());
 
             return ret;
         },
     };
 }
 
 static RPCHelpMan verifychain() {
     return RPCHelpMan{
         "verifychain",
         "Verifies blockchain database.\n",
         {
             {"checklevel", RPCArg::Type::NUM,
              /* default */ strprintf("%d, range=0-4", DEFAULT_CHECKLEVEL),
              strprintf("How thorough the block verification is:\n - %s",
                        Join(CHECKLEVEL_DOC, "\n- "))},
             {"nblocks", RPCArg::Type::NUM,
              /* default */ strprintf("%d, 0=all", DEFAULT_CHECKBLOCKS),
              "The number of blocks to check."},
         },
         RPCResult{RPCResult::Type::BOOL, "", "Verified or not"},
         RPCExamples{HelpExampleCli("verifychain", "") +
                     HelpExampleRpc("verifychain", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             const int check_level(request.params[0].isNull()
                                       ? DEFAULT_CHECKLEVEL
                                       : request.params[0].get_int());
             const int check_depth{request.params[1].isNull()
                                       ? DEFAULT_CHECKBLOCKS
                                       : request.params[1].get_int()};
 
             ChainstateManager &chainman = EnsureAnyChainman(request.context);
             LOCK(cs_main);
 
             Chainstate &active_chainstate = chainman.ActiveChainstate();
             return CVerifyDB().VerifyDB(active_chainstate, config,
                                         active_chainstate.CoinsTip(),
                                         check_level, check_depth);
         },
     };
 }
 
 RPCHelpMan getblockchaininfo() {
     return RPCHelpMan{
         "getblockchaininfo",
         "Returns an object containing various state info regarding blockchain "
         "processing.\n",
         {},
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::STR, "chain",
                  "current network name (main, test, regtest)"},
                 {RPCResult::Type::NUM, "blocks",
                  "the height of the most-work fully-validated chain. The "
                  "genesis block has height 0"},
                 {RPCResult::Type::NUM, "headers",
                  "the current number of headers we have validated"},
                 {RPCResult::Type::STR, "bestblockhash",
                  "the hash of the currently best block"},
                 {RPCResult::Type::NUM, "difficulty", "the current difficulty"},
                 {RPCResult::Type::NUM_TIME, "time",
                  "The block time expressed in " + UNIX_EPOCH_TIME},
                 {RPCResult::Type::NUM_TIME, "mediantime",
                  "The median block time expressed in " + UNIX_EPOCH_TIME},
                 {RPCResult::Type::NUM, "verificationprogress",
                  "estimate of verification progress [0..1]"},
                 {RPCResult::Type::BOOL, "initialblockdownload",
                  "(debug information) estimate of whether this node is in "
                  "Initial Block Download mode"},
                 {RPCResult::Type::STR_HEX, "chainwork",
                  "total amount of work in active chain, in hexadecimal"},
                 {RPCResult::Type::NUM, "size_on_disk",
                  "the estimated size of the block and undo files on disk"},
                 {RPCResult::Type::BOOL, "pruned",
                  "if the blocks are subject to pruning"},
                 {RPCResult::Type::NUM, "pruneheight",
                  "lowest-height complete block stored (only present if pruning "
                  "is enabled)"},
                 {RPCResult::Type::BOOL, "automatic_pruning",
                  "whether automatic pruning is enabled (only present if "
                  "pruning is enabled)"},
                 {RPCResult::Type::NUM, "prune_target_size",
                  "the target size used by pruning (only present if automatic "
                  "pruning is enabled)"},
                 {RPCResult::Type::OBJ_DYN,
                  "softforks",
                  "status of softforks. DEPRECATED: Only displayed if the "
                  "-deprecatedrpc=softforks "
                  "option is set",
                  {
                      {RPCResult::Type::OBJ,
                       "xxxx",
                       "name of the softfork",
                       {
                           {RPCResult::Type::STR, "type",
                            "one of \"buried\", \"bip9\""},
                           {RPCResult::Type::OBJ,
                            "bip9",
                            "status of bip9 softforks (only for \"bip9\" type)",
                            {
                                {RPCResult::Type::STR, "status",
                                 "one of \"defined\", \"started\", "
                                 "\"locked_in\", \"active\", \"failed\""},
                                {RPCResult::Type::NUM, "bit",
                                 "the bit (0-28) in the block version field "
                                 "used to signal this softfork (only for "
                                 "\"started\" status)"},
                                {RPCResult::Type::NUM_TIME, "start_time",
                                 "the minimum median time past of a block at "
                                 "which the bit gains its meaning"},
                                {RPCResult::Type::NUM_TIME, "timeout",
                                 "the median time past of a block at which the "
                                 "deployment is considered failed if not yet "
                                 "locked in"},
                                {RPCResult::Type::NUM, "since",
                                 "height of the first block to which the status "
                                 "applies"},
                                {RPCResult::Type::OBJ,
                                 "statistics",
                                 "numeric statistics about BIP9 signalling for "
                                 "a softfork",
                                 {
                                     {RPCResult::Type::NUM, "period",
                                      "the length in blocks of the BIP9 "
                                      "signalling period"},
                                     {RPCResult::Type::NUM, "threshold",
                                      "the number of blocks with the version "
                                      "bit set required to activate the "
                                      "feature"},
                                     {RPCResult::Type::NUM, "elapsed",
                                      "the number of blocks elapsed since the "
                                      "beginning of the current period"},
                                     {RPCResult::Type::NUM, "count",
                                      "the number of blocks with the version "
                                      "bit set in the current period"},
                                     {RPCResult::Type::BOOL, "possible",
                                      "returns false if there are not enough "
                                      "blocks left in this period to pass "
                                      "activation threshold"},
                                 }},
                            }},
                           {RPCResult::Type::NUM, "height",
                            "height of the first block which the rules are or "
                            "will be enforced (only for \"buried\" type, or "
                            "\"bip9\" type with \"active\" status)"},
                           {RPCResult::Type::BOOL, "active",
                            "true if the rules are enforced for the mempool and "
                            "the next block"},
                       }},
                  }},
                 {RPCResult::Type::STR, "warnings",
                  "any network and blockchain warnings"},
             }},
         RPCExamples{HelpExampleCli("getblockchaininfo", "") +
                     HelpExampleRpc("getblockchaininfo", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             const CChainParams &chainparams = config.GetChainParams();
 
             ChainstateManager &chainman = EnsureAnyChainman(request.context);
             LOCK(cs_main);
             Chainstate &active_chainstate = chainman.ActiveChainstate();
 
             const CBlockIndex &tip{
                 *CHECK_NONFATAL(active_chainstate.m_chain.Tip())};
             const int height{tip.nHeight};
 
             UniValue obj(UniValue::VOBJ);
             obj.pushKV("chain", chainparams.NetworkIDString());
             obj.pushKV("blocks", height);
             obj.pushKV("headers", chainman.m_best_header
                                       ? chainman.m_best_header->nHeight
                                       : -1);
             obj.pushKV("bestblockhash", tip.GetBlockHash().GetHex());
             obj.pushKV("difficulty", GetDifficulty(&tip));
             obj.pushKV("time", tip.GetBlockTime());
             obj.pushKV("mediantime", tip.GetMedianTimePast());
             obj.pushKV("verificationprogress",
                        GuessVerificationProgress(Params().TxData(), &tip));
             obj.pushKV("initialblockdownload",
                        active_chainstate.IsInitialBlockDownload());
             obj.pushKV("chainwork", tip.nChainWork.GetHex());
             obj.pushKV("size_on_disk",
                        chainman.m_blockman.CalculateCurrentUsage());
             obj.pushKV("pruned", node::fPruneMode);
 
             if (node::fPruneMode) {
                 obj.pushKV("pruneheight",
                            node::GetFirstStoredBlock(&tip)->nHeight);
 
                 // if 0, execution bypasses the whole if block.
                 bool automatic_pruning = (gArgs.GetIntArg("-prune", 0) != 1);
                 obj.pushKV("automatic_pruning", automatic_pruning);
                 if (automatic_pruning) {
                     obj.pushKV("prune_target_size", node::nPruneTarget);
                 }
             }
 
             // Deprecated in v0.27.0
             if (IsDeprecatedRPCEnabled(gArgs, "softforks")) {
                 // This field has been empty for a long while and the associated
                 // code has already been removed, as there is no plan to use
                 // BIP9 again.
                 UniValue softforks(UniValue::VOBJ);
                 obj.pushKV("softforks", softforks);
             }
 
             obj.pushKV("warnings", GetWarnings(false).original);
             return obj;
         },
     };
 }
 
 /** Comparison function for sorting the getchaintips heads.  */
 struct CompareBlocksByHeight {
     bool operator()(const CBlockIndex *a, const CBlockIndex *b) const {
         // Make sure that unequal blocks with the same height do not compare
         // equal. Use the pointers themselves to make a distinction.
         if (a->nHeight != b->nHeight) {
             return (a->nHeight > b->nHeight);
         }
 
         return a < b;
     }
 };
 
 static RPCHelpMan getchaintips() {
     return RPCHelpMan{
         "getchaintips",
         "Return information about all known tips in the block tree, including "
         "the main chain as well as orphaned branches.\n",
         {},
         RPCResult{
             RPCResult::Type::ARR,
             "",
             "",
             {{RPCResult::Type::OBJ,
               "",
               "",
               {
                   {RPCResult::Type::NUM, "height", "height of the chain tip"},
                   {RPCResult::Type::STR_HEX, "hash", "block hash of the tip"},
                   {RPCResult::Type::NUM, "branchlen",
                    "zero for main chain, otherwise length of branch connecting "
                    "the tip to the main chain"},
                   {RPCResult::Type::STR, "status",
                    "status of the chain, \"active\" for the main chain\n"
                    "Possible values for status:\n"
                    "1.  \"invalid\"               This branch contains at "
                    "least one invalid block\n"
                    "2.  \"parked\"                This branch contains at "
                    "least one parked block\n"
                    "3.  \"headers-only\"          Not all blocks for this "
                    "branch are available, but the headers are valid\n"
                    "4.  \"valid-headers\"         All blocks are available for "
                    "this branch, but they were never fully validated\n"
                    "5.  \"valid-fork\"            This branch is not part of "
                    "the active chain, but is fully validated\n"
                    "6.  \"active\"                This is the tip of the "
                    "active main chain, which is certainly valid"},
               }}}},
         RPCExamples{HelpExampleCli("getchaintips", "") +
                     HelpExampleRpc("getchaintips", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             ChainstateManager &chainman = EnsureAnyChainman(request.context);
             LOCK(cs_main);
             CChain &active_chain = chainman.ActiveChain();
 
             /**
              * Idea: The set of chain tips is the active chain tip, plus orphan
              * blocks which do not have another orphan building off of them.
              * Algorithm:
              *  - Make one pass through BlockIndex(), picking out the orphan
              * blocks, and also storing a set of the orphan block's pprev
              * pointers.
              *  - Iterate through the orphan blocks. If the block isn't pointed
              * to by another orphan, it is a chain tip.
              *  - Add the active chain tip
              */
             std::set<const CBlockIndex *, CompareBlocksByHeight> setTips;
             std::set<const CBlockIndex *> setOrphans;
             std::set<const CBlockIndex *> setPrevs;
 
             for (const auto &[_, block_index] : chainman.BlockIndex()) {
                 if (!active_chain.Contains(&block_index)) {
                     setOrphans.insert(&block_index);
                     setPrevs.insert(block_index.pprev);
                 }
             }
 
             for (std::set<const CBlockIndex *>::iterator it =
                      setOrphans.begin();
                  it != setOrphans.end(); ++it) {
                 if (setPrevs.erase(*it) == 0) {
                     setTips.insert(*it);
                 }
             }
 
             // Always report the currently active tip.
             setTips.insert(active_chain.Tip());
 
             /* Construct the output array.  */
             UniValue res(UniValue::VARR);
             for (const CBlockIndex *block : setTips) {
                 UniValue obj(UniValue::VOBJ);
                 obj.pushKV("height", block->nHeight);
                 obj.pushKV("hash", block->phashBlock->GetHex());
 
                 const int branchLen =
                     block->nHeight - active_chain.FindFork(block)->nHeight;
                 obj.pushKV("branchlen", branchLen);
 
                 std::string status;
                 if (active_chain.Contains(block)) {
                     // This block is part of the currently active chain.
                     status = "active";
                 } else if (block->nStatus.isInvalid()) {
                     // This block or one of its ancestors is invalid.
                     status = "invalid";
                 } else if (block->nStatus.isOnParkedChain()) {
                     // This block or one of its ancestors is parked.
                     status = "parked";
                 } else if (!block->HaveTxsDownloaded()) {
                     // This block cannot be connected because full block data
                     // for it or one of its parents is missing.
                     status = "headers-only";
                 } else if (block->IsValid(BlockValidity::SCRIPTS)) {
                     // This block is fully validated, but no longer part of the
                     // active chain. It was probably the active block once, but
                     // was reorganized.
                     status = "valid-fork";
                 } else if (block->IsValid(BlockValidity::TREE)) {
                     // The headers for this block are valid, but it has not been
                     // validated. It was probably never part of the most-work
                     // chain.
                     status = "valid-headers";
                 } else {
                     // No clue.
                     status = "unknown";
                 }
                 obj.pushKV("status", status);
 
                 res.push_back(obj);
             }
 
             return res;
         },
     };
 }
 
 UniValue MempoolInfoToJSON(const CTxMemPool &pool) {
     // Make sure this call is atomic in the pool.
     LOCK(pool.cs);
     UniValue ret(UniValue::VOBJ);
     ret.pushKV("loaded", pool.IsLoaded());
     ret.pushKV("size", (int64_t)pool.size());
     ret.pushKV("bytes", (int64_t)pool.GetTotalTxSize());
     ret.pushKV("usage", (int64_t)pool.DynamicMemoryUsage());
     ret.pushKV("total_fee", pool.GetTotalFee());
     size_t maxmempool =
         gArgs.GetIntArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000;
     ret.pushKV("maxmempool", (int64_t)maxmempool);
     ret.pushKV(
         "mempoolminfee",
         std::max(pool.GetMinFee(maxmempool), ::minRelayTxFee).GetFeePerK());
     ret.pushKV("minrelaytxfee", ::minRelayTxFee.GetFeePerK());
     ret.pushKV("unbroadcastcount", uint64_t{pool.GetUnbroadcastTxs().size()});
     return ret;
 }
 
 static RPCHelpMan getmempoolinfo() {
     const auto &ticker = Currency::get().ticker;
     return RPCHelpMan{
         "getmempoolinfo",
         "Returns details on the active state of the TX memory pool.\n",
         {},
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::BOOL, "loaded",
                  "True if the mempool is fully loaded"},
                 {RPCResult::Type::NUM, "size", "Current tx count"},
                 {RPCResult::Type::NUM, "bytes", "Sum of all transaction sizes"},
                 {RPCResult::Type::NUM, "usage",
                  "Total memory usage for the mempool"},
                 {RPCResult::Type::NUM, "maxmempool",
                  "Maximum memory usage for the mempool"},
                 {RPCResult::Type::STR_AMOUNT, "total_fee",
                  "Total fees for the mempool in " + ticker +
                      ", ignoring modified fees through prioritizetransaction"},
                 {RPCResult::Type::STR_AMOUNT, "mempoolminfee",
                  "Minimum fee rate in " + ticker +
                      "/kB for tx to be accepted. Is the maximum of "
                      "minrelaytxfee and minimum mempool fee"},
                 {RPCResult::Type::STR_AMOUNT, "minrelaytxfee",
                  "Current minimum relay fee for transactions"},
                 {RPCResult::Type::NUM, "unbroadcastcount",
                  "Current number of transactions that haven't passed initial "
                  "broadcast yet"},
             }},
         RPCExamples{HelpExampleCli("getmempoolinfo", "") +
                     HelpExampleRpc("getmempoolinfo", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             return MempoolInfoToJSON(EnsureAnyMemPool(request.context));
         },
     };
 }
 
 static RPCHelpMan preciousblock() {
     return RPCHelpMan{
         "preciousblock",
         "Treats a block as if it were received before others with the same "
         "work.\n"
         "\nA later preciousblock call can override the effect of an earlier "
         "one.\n"
         "\nThe effects of preciousblock are not retained across restarts.\n",
         {
             {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "the hash of the block to mark as precious"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("preciousblock", "\"blockhash\"") +
                     HelpExampleRpc("preciousblock", "\"blockhash\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             BlockHash hash(ParseHashV(request.params[0], "blockhash"));
             CBlockIndex *pblockindex;
 
             ChainstateManager &chainman = EnsureAnyChainman(request.context);
             {
                 LOCK(cs_main);
                 pblockindex = chainman.m_blockman.LookupBlockIndex(hash);
                 if (!pblockindex) {
                     throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                        "Block not found");
                 }
             }
 
             BlockValidationState state;
             chainman.ActiveChainstate().PreciousBlock(config, state,
                                                       pblockindex);
 
             if (!state.IsValid()) {
                 throw JSONRPCError(RPC_DATABASE_ERROR, state.GetRejectReason());
             }
 
             // Block to make sure wallet/indexers sync before returning
             SyncWithValidationInterfaceQueue();
 
             return NullUniValue;
         },
     };
 }
 
 static RPCHelpMan invalidateblock() {
     return RPCHelpMan{
         "invalidateblock",
         "Permanently marks a block as invalid, as if it violated a consensus "
         "rule.\n",
         {
             {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "the hash of the block to mark as invalid"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("invalidateblock", "\"blockhash\"") +
                     HelpExampleRpc("invalidateblock", "\"blockhash\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             const BlockHash hash(ParseHashV(request.params[0], "blockhash"));
             BlockValidationState state;
 
             ChainstateManager &chainman = EnsureAnyChainman(request.context);
             CBlockIndex *pblockindex;
             {
                 LOCK(cs_main);
                 pblockindex = chainman.m_blockman.LookupBlockIndex(hash);
                 if (!pblockindex) {
                     throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                        "Block not found");
                 }
             }
             chainman.ActiveChainstate().InvalidateBlock(config, state,
                                                         pblockindex);
 
             if (state.IsValid()) {
                 chainman.ActiveChainstate().ActivateBestChain(config, state);
             }
 
             if (!state.IsValid()) {
                 throw JSONRPCError(RPC_DATABASE_ERROR, state.ToString());
             }
 
             // Block to make sure wallet/indexers sync before returning
             SyncWithValidationInterfaceQueue();
 
             return NullUniValue;
         },
     };
 }
 
 RPCHelpMan parkblock() {
     return RPCHelpMan{
         "parkblock",
         "Marks a block as parked.\n",
         {
             {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "the hash of the block to park"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("parkblock", "\"blockhash\"") +
                     HelpExampleRpc("parkblock", "\"blockhash\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             const std::string strHash = request.params[0].get_str();
             const BlockHash hash(uint256S(strHash));
             BlockValidationState state;
 
             ChainstateManager &chainman = EnsureAnyChainman(request.context);
             Chainstate &active_chainstate = chainman.ActiveChainstate();
             CBlockIndex *pblockindex = nullptr;
             {
                 LOCK(cs_main);
                 pblockindex = chainman.m_blockman.LookupBlockIndex(hash);
                 if (!pblockindex) {
                     throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                        "Block not found");
                 }
 
                 if (active_chainstate.IsBlockAvalancheFinalized(pblockindex)) {
                     // Reset avalanche finalization if we park a finalized
                     // block.
                     active_chainstate.ClearAvalancheFinalizedBlock();
                 }
             }
 
             active_chainstate.ParkBlock(config, state, pblockindex);
 
             if (state.IsValid()) {
                 active_chainstate.ActivateBestChain(config, state);
             }
 
             if (!state.IsValid()) {
                 throw JSONRPCError(RPC_DATABASE_ERROR, state.GetRejectReason());
             }
 
             // Block to make sure wallet/indexers sync before returning
             SyncWithValidationInterfaceQueue();
 
             return NullUniValue;
         },
     };
 }
 
 static RPCHelpMan reconsiderblock() {
     return RPCHelpMan{
         "reconsiderblock",
         "Removes invalidity status of a block, its ancestors and its"
         "descendants, reconsider them for activation.\n"
         "This can be used to undo the effects of invalidateblock.\n",
         {
             {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "the hash of the block to reconsider"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("reconsiderblock", "\"blockhash\"") +
                     HelpExampleRpc("reconsiderblock", "\"blockhash\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             ChainstateManager &chainman = EnsureAnyChainman(request.context);
             const BlockHash hash(ParseHashV(request.params[0], "blockhash"));
 
             {
                 LOCK(cs_main);
                 CBlockIndex *pblockindex =
                     chainman.m_blockman.LookupBlockIndex(hash);
                 if (!pblockindex) {
                     throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                        "Block not found");
                 }
 
                 chainman.ActiveChainstate().ResetBlockFailureFlags(pblockindex);
             }
 
             BlockValidationState state;
             chainman.ActiveChainstate().ActivateBestChain(config, state);
 
             if (!state.IsValid()) {
                 throw JSONRPCError(RPC_DATABASE_ERROR, state.ToString());
             }
 
             // Block to make sure wallet/indexers sync before returning
             SyncWithValidationInterfaceQueue();
 
             return NullUniValue;
         },
     };
 }
 
 RPCHelpMan unparkblock() {
     return RPCHelpMan{
         "unparkblock",
         "Removes parked status of a block and its descendants, reconsider "
         "them for activation.\n"
         "This can be used to undo the effects of parkblock.\n",
         {
             {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "the hash of the block to unpark"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("unparkblock", "\"blockhash\"") +
                     HelpExampleRpc("unparkblock", "\"blockhash\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             const std::string strHash = request.params[0].get_str();
             ChainstateManager &chainman = EnsureAnyChainman(request.context);
             const BlockHash hash(uint256S(strHash));
             Chainstate &active_chainstate = chainman.ActiveChainstate();
 
             {
                 LOCK(cs_main);
 
                 CBlockIndex *pblockindex =
                     chainman.m_blockman.LookupBlockIndex(hash);
                 if (!pblockindex) {
                     throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                        "Block not found");
                 }
 
                 if (!pblockindex->nStatus.isOnParkedChain()) {
                     // Block to unpark is not parked so there is nothing to do.
                     return NullUniValue;
                 }
 
                 const CBlockIndex *tip = active_chainstate.m_chain.Tip();
                 if (tip) {
                     const CBlockIndex *ancestor =
                         LastCommonAncestor(tip, pblockindex);
                     if (active_chainstate.IsBlockAvalancheFinalized(ancestor)) {
                         // Only reset avalanche finalization if we unpark a
                         // block that might conflict with avalanche finalized
                         // blocks.
                         active_chainstate.ClearAvalancheFinalizedBlock();
                     }
                 }
 
                 active_chainstate.UnparkBlockAndChildren(pblockindex);
             }
 
             BlockValidationState state;
             active_chainstate.ActivateBestChain(config, state);
 
             if (!state.IsValid()) {
                 throw JSONRPCError(RPC_DATABASE_ERROR, state.GetRejectReason());
             }
 
             // Block to make sure wallet/indexers sync before returning
             SyncWithValidationInterfaceQueue();
 
             return NullUniValue;
         },
     };
 }
 
 static RPCHelpMan getchaintxstats() {
     return RPCHelpMan{
         "getchaintxstats",
         "Compute statistics about the total number and rate of transactions "
         "in the chain.\n",
         {
             {"nblocks", RPCArg::Type::NUM, /* default */ "one month",
              "Size of the window in number of blocks"},
             {"blockhash", RPCArg::Type::STR_HEX, /* default */ "chain tip",
              "The hash of the block that ends the window."},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::NUM_TIME, "time",
                        "The timestamp for the final block in the window, "
                        "expressed in " +
                            UNIX_EPOCH_TIME},
                       {RPCResult::Type::NUM, "txcount",
                        "The total number of transactions in the chain up to "
                        "that point"},
                       {RPCResult::Type::STR_HEX, "window_final_block_hash",
                        "The hash of the final block in the window"},
                       {RPCResult::Type::NUM, "window_final_block_height",
                        "The height of the final block in the window."},
                       {RPCResult::Type::NUM, "window_block_count",
                        "Size of the window in number of blocks"},
                       {RPCResult::Type::NUM, "window_tx_count",
                        "The number of transactions in the window. Only "
                        "returned if \"window_block_count\" is > 0"},
                       {RPCResult::Type::NUM, "window_interval",
                        "The elapsed time in the window in seconds. Only "
                        "returned if \"window_block_count\" is > 0"},
                       {RPCResult::Type::NUM, "txrate",
                        "The average rate of transactions per second in the "
                        "window. Only returned if \"window_interval\" is > 0"},
                   }},
         RPCExamples{HelpExampleCli("getchaintxstats", "") +
                     HelpExampleRpc("getchaintxstats", "2016")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             ChainstateManager &chainman = EnsureAnyChainman(request.context);
             const CBlockIndex *pindex;
 
             // By default: 1 month
             int blockcount =
                 30 * 24 * 60 * 60 /
                 config.GetChainParams().GetConsensus().nPowTargetSpacing;
 
             if (request.params[1].isNull()) {
                 LOCK(cs_main);
                 pindex = chainman.ActiveTip();
             } else {
                 BlockHash hash(ParseHashV(request.params[1], "blockhash"));
                 LOCK(cs_main);
                 pindex = chainman.m_blockman.LookupBlockIndex(hash);
                 if (!pindex) {
                     throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                        "Block not found");
                 }
                 if (!chainman.ActiveChain().Contains(pindex)) {
                     throw JSONRPCError(RPC_INVALID_PARAMETER,
                                        "Block is not in main chain");
                 }
             }
 
             CHECK_NONFATAL(pindex != nullptr);
 
             if (request.params[0].isNull()) {
                 blockcount =
                     std::max(0, std::min(blockcount, pindex->nHeight - 1));
             } else {
                 blockcount = request.params[0].get_int();
 
                 if (blockcount < 0 ||
                     (blockcount > 0 && blockcount >= pindex->nHeight)) {
                     throw JSONRPCError(RPC_INVALID_PARAMETER,
                                        "Invalid block count: "
                                        "should be between 0 and "
                                        "the block's height - 1");
                 }
             }
 
             const CBlockIndex &past_block{*CHECK_NONFATAL(
                 pindex->GetAncestor(pindex->nHeight - blockcount))};
             const int64_t nTimeDiff{pindex->GetMedianTimePast() -
                                     past_block.GetMedianTimePast()};
             const int nTxDiff =
                 pindex->GetChainTxCount() - past_block.GetChainTxCount();
 
             UniValue ret(UniValue::VOBJ);
             ret.pushKV("time", pindex->GetBlockTime());
             ret.pushKV("txcount", pindex->GetChainTxCount());
             ret.pushKV("window_final_block_hash",
                        pindex->GetBlockHash().GetHex());
             ret.pushKV("window_final_block_height", pindex->nHeight);
             ret.pushKV("window_block_count", blockcount);
             if (blockcount > 0) {
                 ret.pushKV("window_tx_count", nTxDiff);
                 ret.pushKV("window_interval", nTimeDiff);
                 if (nTimeDiff > 0) {
                     ret.pushKV("txrate", double(nTxDiff) / nTimeDiff);
                 }
             }
 
             return ret;
         },
     };
 }
 
 template <typename T>
 static T CalculateTruncatedMedian(std::vector<T> &scores) {
     size_t size = scores.size();
     if (size == 0) {
         return T();
     }
 
     std::sort(scores.begin(), scores.end());
     if (size % 2 == 0) {
         return (scores[size / 2 - 1] + scores[size / 2]) / 2;
     } else {
         return scores[size / 2];
     }
 }
 
 template <typename T> static inline bool SetHasKeys(const std::set<T> &set) {
     return false;
 }
 template <typename T, typename Tk, typename... Args>
 static inline bool SetHasKeys(const std::set<T> &set, const Tk &key,
                               const Args &...args) {
     return (set.count(key) != 0) || SetHasKeys(set, args...);
 }
 
 // outpoint (needed for the utxo index) + nHeight + fCoinBase
 static constexpr size_t PER_UTXO_OVERHEAD =
     sizeof(COutPoint) + sizeof(uint32_t) + sizeof(bool);
 
 static RPCHelpMan getblockstats() {
     const auto &ticker = Currency::get().ticker;
     return RPCHelpMan{
         "getblockstats",
         "Compute per block statistics for a given window. All amounts are "
         "in " +
             ticker +
             ".\n"
             "It won't work for some heights with pruning.\n",
         {
             {"hash_or_height",
              RPCArg::Type::NUM,
              RPCArg::Optional::NO,
              "The block hash or height of the target block",
              "",
              {"", "string or numeric"}},
             {"stats",
              RPCArg::Type::ARR,
              /* default */ "all values",
              "Values to plot (see result below)",
              {
                  {"height", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
                   "Selected statistic"},
                  {"time", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
                   "Selected statistic"},
              },
              "stats"},
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::NUM, "avgfee", "Average fee in the block"},
                 {RPCResult::Type::NUM, "avgfeerate",
                  "Average feerate (in satoshis per virtual byte)"},
                 {RPCResult::Type::NUM, "avgtxsize", "Average transaction size"},
                 {RPCResult::Type::STR_HEX, "blockhash",
                  "The block hash (to check for potential reorgs)"},
                 {RPCResult::Type::NUM, "height", "The height of the block"},
                 {RPCResult::Type::NUM, "ins",
                  "The number of inputs (excluding coinbase)"},
                 {RPCResult::Type::NUM, "maxfee", "Maximum fee in the block"},
                 {RPCResult::Type::NUM, "maxfeerate",
                  "Maximum feerate (in satoshis per virtual byte)"},
                 {RPCResult::Type::NUM, "maxtxsize", "Maximum transaction size"},
                 {RPCResult::Type::NUM, "medianfee",
                  "Truncated median fee in the block"},
                 {RPCResult::Type::NUM, "medianfeerate",
                  "Truncated median feerate (in " + ticker + " per byte)"},
                 {RPCResult::Type::NUM, "mediantime",
                  "The block median time past"},
                 {RPCResult::Type::NUM, "mediantxsize",
                  "Truncated median transaction size"},
                 {RPCResult::Type::NUM, "minfee", "Minimum fee in the block"},
                 {RPCResult::Type::NUM, "minfeerate",
                  "Minimum feerate (in satoshis per virtual byte)"},
                 {RPCResult::Type::NUM, "mintxsize", "Minimum transaction size"},
                 {RPCResult::Type::NUM, "outs", "The number of outputs"},
                 {RPCResult::Type::NUM, "subsidy", "The block subsidy"},
                 {RPCResult::Type::NUM, "time", "The block time"},
                 {RPCResult::Type::NUM, "total_out",
                  "Total amount in all outputs (excluding coinbase and thus "
                  "reward [ie subsidy + totalfee])"},
                 {RPCResult::Type::NUM, "total_size",
                  "Total size of all non-coinbase transactions"},
                 {RPCResult::Type::NUM, "totalfee", "The fee total"},
                 {RPCResult::Type::NUM, "txs",
                  "The number of transactions (including coinbase)"},
                 {RPCResult::Type::NUM, "utxo_increase",
                  "The increase/decrease in the number of unspent outputs"},
                 {RPCResult::Type::NUM, "utxo_size_inc",
                  "The increase/decrease in size for the utxo index (not "
                  "discounting op_return and similar)"},
             }},
         RPCExamples{
             HelpExampleCli(
                 "getblockstats",
                 R"('"00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09"' '["minfeerate","avgfeerate"]')") +
             HelpExampleCli("getblockstats",
                            R"(1000 '["minfeerate","avgfeerate"]')") +
             HelpExampleRpc(
                 "getblockstats",
                 R"("00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09", ["minfeerate","avgfeerate"])") +
             HelpExampleRpc("getblockstats",
                            R"(1000, ["minfeerate","avgfeerate"])")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             ChainstateManager &chainman = EnsureAnyChainman(request.context);
             const CBlockIndex &pindex{*CHECK_NONFATAL(
                 ParseHashOrHeight(request.params[0], chainman))};
 
             std::set<std::string> stats;
             if (!request.params[1].isNull()) {
                 const UniValue stats_univalue = request.params[1].get_array();
                 for (unsigned int i = 0; i < stats_univalue.size(); i++) {
                     const std::string stat = stats_univalue[i].get_str();
                     stats.insert(stat);
                 }
             }
 
             const CBlock &block =
                 GetBlockChecked(config, chainman.m_blockman, &pindex);
             const CBlockUndo &blockUndo =
                 GetUndoChecked(chainman.m_blockman, &pindex);
 
             // Calculate everything if nothing selected (default)
             const bool do_all = stats.size() == 0;
             const bool do_mediantxsize =
                 do_all || stats.count("mediantxsize") != 0;
             const bool do_medianfee = do_all || stats.count("medianfee") != 0;
             const bool do_medianfeerate =
                 do_all || stats.count("medianfeerate") != 0;
             const bool loop_inputs =
                 do_all || do_medianfee || do_medianfeerate ||
                 SetHasKeys(stats, "utxo_size_inc", "totalfee", "avgfee",
                            "avgfeerate", "minfee", "maxfee", "minfeerate",
                            "maxfeerate");
             const bool loop_outputs =
                 do_all || loop_inputs || stats.count("total_out");
             const bool do_calculate_size =
                 do_mediantxsize || loop_inputs ||
                 SetHasKeys(stats, "total_size", "avgtxsize", "mintxsize",
                            "maxtxsize");
 
             const int64_t blockMaxSize = config.GetMaxBlockSize();
             Amount maxfee = Amount::zero();
             Amount maxfeerate = Amount::zero();
             Amount minfee = MAX_MONEY;
             Amount minfeerate = MAX_MONEY;
             Amount total_out = Amount::zero();
             Amount totalfee = Amount::zero();
             int64_t inputs = 0;
             int64_t maxtxsize = 0;
             int64_t mintxsize = blockMaxSize;
             int64_t outputs = 0;
             int64_t total_size = 0;
             int64_t utxo_size_inc = 0;
             std::vector<Amount> fee_array;
             std::vector<Amount> feerate_array;
             std::vector<int64_t> txsize_array;
 
             for (size_t i = 0; i < block.vtx.size(); ++i) {
                 const auto &tx = block.vtx.at(i);
                 outputs += tx->vout.size();
                 Amount tx_total_out = Amount::zero();
                 if (loop_outputs) {
                     for (const CTxOut &out : tx->vout) {
                         tx_total_out += out.nValue;
                         utxo_size_inc +=
                             GetSerializeSize(out, PROTOCOL_VERSION) +
                             PER_UTXO_OVERHEAD;
                     }
                 }
 
                 if (tx->IsCoinBase()) {
                     continue;
                 }
 
                 // Don't count coinbase's fake input
                 inputs += tx->vin.size();
                 // Don't count coinbase reward
                 total_out += tx_total_out;
 
                 int64_t tx_size = 0;
                 if (do_calculate_size) {
                     tx_size = tx->GetTotalSize();
                     if (do_mediantxsize) {
                         txsize_array.push_back(tx_size);
                     }
                     maxtxsize = std::max(maxtxsize, tx_size);
                     mintxsize = std::min(mintxsize, tx_size);
                     total_size += tx_size;
                 }
 
                 if (loop_inputs) {
                     Amount tx_total_in = Amount::zero();
                     const auto &txundo = blockUndo.vtxundo.at(i - 1);
                     for (const Coin &coin : txundo.vprevout) {
                         const CTxOut &prevoutput = coin.GetTxOut();
 
                         tx_total_in += prevoutput.nValue;
                         utxo_size_inc -=
                             GetSerializeSize(prevoutput, PROTOCOL_VERSION) +
                             PER_UTXO_OVERHEAD;
                     }
 
                     Amount txfee = tx_total_in - tx_total_out;
                     CHECK_NONFATAL(MoneyRange(txfee));
                     if (do_medianfee) {
                         fee_array.push_back(txfee);
                     }
                     maxfee = std::max(maxfee, txfee);
                     minfee = std::min(minfee, txfee);
                     totalfee += txfee;
 
                     Amount feerate = txfee / tx_size;
                     if (do_medianfeerate) {
                         feerate_array.push_back(feerate);
                     }
                     maxfeerate = std::max(maxfeerate, feerate);
                     minfeerate = std::min(minfeerate, feerate);
                 }
             }
 
             UniValue ret_all(UniValue::VOBJ);
             ret_all.pushKV("avgfee",
                            block.vtx.size() > 1
                                ? (totalfee / int((block.vtx.size() - 1)))
                                : Amount::zero());
             ret_all.pushKV("avgfeerate", total_size > 0
                                              ? (totalfee / total_size)
                                              : Amount::zero());
             ret_all.pushKV("avgtxsize",
                            (block.vtx.size() > 1)
                                ? total_size / (block.vtx.size() - 1)
                                : 0);
             ret_all.pushKV("blockhash", pindex.GetBlockHash().GetHex());
             ret_all.pushKV("height", (int64_t)pindex.nHeight);
             ret_all.pushKV("ins", inputs);
             ret_all.pushKV("maxfee", maxfee);
             ret_all.pushKV("maxfeerate", maxfeerate);
             ret_all.pushKV("maxtxsize", maxtxsize);
             ret_all.pushKV("medianfee", CalculateTruncatedMedian(fee_array));
             ret_all.pushKV("medianfeerate",
                            CalculateTruncatedMedian(feerate_array));
             ret_all.pushKV("mediantime", pindex.GetMedianTimePast());
             ret_all.pushKV("mediantxsize",
                            CalculateTruncatedMedian(txsize_array));
             ret_all.pushKV("minfee",
                            minfee == MAX_MONEY ? Amount::zero() : minfee);
             ret_all.pushKV("minfeerate", minfeerate == MAX_MONEY
                                              ? Amount::zero()
                                              : minfeerate);
             ret_all.pushKV("mintxsize",
                            mintxsize == blockMaxSize ? 0 : mintxsize);
             ret_all.pushKV("outs", outputs);
             ret_all.pushKV("subsidy", GetBlockSubsidy(pindex.nHeight,
                                                       Params().GetConsensus()));
             ret_all.pushKV("time", pindex.GetBlockTime());
             ret_all.pushKV("total_out", total_out);
             ret_all.pushKV("total_size", total_size);
             ret_all.pushKV("totalfee", totalfee);
             ret_all.pushKV("txs", (int64_t)block.vtx.size());
             ret_all.pushKV("utxo_increase", outputs - inputs);
             ret_all.pushKV("utxo_size_inc", utxo_size_inc);
 
             if (do_all) {
                 return ret_all;
             }
 
             UniValue ret(UniValue::VOBJ);
             for (const std::string &stat : stats) {
                 const UniValue &value = ret_all[stat];
                 if (value.isNull()) {
                     throw JSONRPCError(
                         RPC_INVALID_PARAMETER,
                         strprintf("Invalid selected statistic %s", stat));
                 }
                 ret.pushKV(stat, value);
             }
             return ret;
         },
     };
 }
 
 static RPCHelpMan savemempool() {
     return RPCHelpMan{
         "savemempool",
         "Dumps the mempool to disk. It will fail until the previous dump is "
         "fully loaded.\n",
         {},
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR, "filename",
                        "the directory and file where the mempool was saved"},
                   }},
         RPCExamples{HelpExampleCli("savemempool", "") +
                     HelpExampleRpc("savemempool", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             const CTxMemPool &mempool = EnsureAnyMemPool(request.context);
 
             const NodeContext &node = EnsureAnyNodeContext(request.context);
 
             if (!mempool.IsLoaded()) {
                 throw JSONRPCError(RPC_MISC_ERROR,
                                    "The mempool was not loaded yet");
             }
 
             if (!DumpMempool(mempool)) {
                 throw JSONRPCError(RPC_MISC_ERROR,
                                    "Unable to dump mempool to disk");
             }
 
             UniValue ret(UniValue::VOBJ);
             ret.pushKV("filename",
                        fs::path((node.args->GetDataDirNet() / "mempool.dat"))
                            .u8string());
 
             return ret;
         },
     };
 }
 
 namespace {
 //! Search for a given set of pubkey scripts
 static bool FindScriptPubKey(std::atomic<int> &scan_progress,
                              const std::atomic<bool> &should_abort,
                              int64_t &count, CCoinsViewCursor *cursor,
                              const std::set<CScript> &needles,
                              std::map<COutPoint, Coin> &out_results,
                              std::function<void()> &interruption_point) {
     scan_progress = 0;
     count = 0;
     while (cursor->Valid()) {
         COutPoint key;
         Coin coin;
         if (!cursor->GetKey(key) || !cursor->GetValue(coin)) {
             return false;
         }
         if (++count % 8192 == 0) {
             interruption_point();
             if (should_abort) {
                 // allow to abort the scan via the abort reference
                 return false;
             }
         }
         if (count % 256 == 0) {
             // update progress reference every 256 item
             const TxId &txid = key.GetTxId();
             uint32_t high = 0x100 * *txid.begin() + *(txid.begin() + 1);
             scan_progress = int(high * 100.0 / 65536.0 + 0.5);
         }
         if (needles.count(coin.GetTxOut().scriptPubKey)) {
             out_results.emplace(key, coin);
         }
         cursor->Next();
     }
     scan_progress = 100;
     return true;
 }
 } // namespace
 
 /** RAII object to prevent concurrency issue when scanning the txout set */
 static std::atomic<int> g_scan_progress;
 static std::atomic<bool> g_scan_in_progress;
 static std::atomic<bool> g_should_abort_scan;
 class CoinsViewScanReserver {
 private:
     bool m_could_reserve;
 
 public:
     explicit CoinsViewScanReserver() : m_could_reserve(false) {}
 
     bool reserve() {
         CHECK_NONFATAL(!m_could_reserve);
         if (g_scan_in_progress.exchange(true)) {
             return false;
         }
         m_could_reserve = true;
         return true;
     }
 
     ~CoinsViewScanReserver() {
         if (m_could_reserve) {
             g_scan_in_progress = false;
         }
     }
 };
 
 static RPCHelpMan scantxoutset() {
     const auto &ticker = Currency::get().ticker;
     return RPCHelpMan{
         "scantxoutset",
         "Scans the unspent transaction output set for entries that match "
         "certain output descriptors.\n"
         "Examples of output descriptors are:\n"
         "    addr(<address>)                      Outputs whose scriptPubKey "
         "corresponds to the specified address (does not include P2PK)\n"
         "    raw(<hex script>)                    Outputs whose scriptPubKey "
         "equals the specified hex scripts\n"
         "    combo(<pubkey>)                      P2PK and P2PKH outputs for "
         "the given pubkey\n"
         "    pkh(<pubkey>)                        P2PKH outputs for the given "
         "pubkey\n"
         "    sh(multi(<n>,<pubkey>,<pubkey>,...)) P2SH-multisig outputs for "
         "the given threshold and pubkeys\n"
         "\nIn the above, <pubkey> either refers to a fixed public key in "
         "hexadecimal notation, or to an xpub/xprv optionally followed by one\n"
         "or more path elements separated by \"/\", and optionally ending in "
         "\"/*\" (unhardened), or \"/*'\" or \"/*h\" (hardened) to specify all\n"
         "unhardened or hardened child keys.\n"
         "In the latter case, a range needs to be specified by below if "
         "different from 1000.\n"
         "For more information on output descriptors, see the documentation in "
         "the doc/descriptors.md file.\n",
         {
             {"action", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The action to execute\n"
              "                                      \"start\" for starting a "
              "scan\n"
              "                                      \"abort\" for aborting the "
              "current scan (returns true when abort was successful)\n"
              "                                      \"status\" for "
              "progress report (in %) of the current scan"},
             {"scanobjects",
              RPCArg::Type::ARR,
              RPCArg::Optional::OMITTED,
              "Array of scan objects. Required for \"start\" action\n"
              "                                  Every scan object is either a "
              "string descriptor or an object:",
              {
                  {"descriptor", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
                   "An output descriptor"},
                  {
                      "",
                      RPCArg::Type::OBJ,
                      RPCArg::Optional::OMITTED,
                      "An object with output descriptor and metadata",
                      {
                          {"desc", RPCArg::Type::STR, RPCArg::Optional::NO,
                           "An output descriptor"},
                          {"range", RPCArg::Type::RANGE, /* default */ "1000",
                           "The range of HD chain indexes to explore (either "
                           "end or [begin,end])"},
                      },
                  },
              },
              "[scanobjects,...]"},
         },
         {
             RPCResult{"When action=='abort'", RPCResult::Type::BOOL, "", ""},
             RPCResult{"When action=='status' and no scan is in progress",
                       RPCResult::Type::NONE, "", ""},
             RPCResult{
                 "When action=='status' and scan is in progress",
                 RPCResult::Type::OBJ,
                 "",
                 "",
                 {
                     {RPCResult::Type::NUM, "progress", "The scan progress"},
                 }},
             RPCResult{
                 "When action=='start'",
                 RPCResult::Type::OBJ,
                 "",
                 "",
                 {
                     {RPCResult::Type::BOOL, "success",
                      "Whether the scan was completed"},
                     {RPCResult::Type::NUM, "txouts",
                      "The number of unspent transaction outputs scanned"},
                     {RPCResult::Type::NUM, "height",
                      "The current block height (index)"},
                     {RPCResult::Type::STR_HEX, "bestblock",
                      "The hash of the block at the tip of the chain"},
                     {RPCResult::Type::ARR,
                      "unspents",
                      "",
                      {
                          {RPCResult::Type::OBJ,
                           "",
                           "",
                           {
                               {RPCResult::Type::STR_HEX, "txid",
                                "The transaction id"},
                               {RPCResult::Type::NUM, "vout", "The vout value"},
                               {RPCResult::Type::STR_HEX, "scriptPubKey",
                                "The script key"},
                               {RPCResult::Type::STR, "desc",
                                "A specialized descriptor for the matched "
                                "scriptPubKey"},
                               {RPCResult::Type::STR_AMOUNT, "amount",
                                "The total amount in " + ticker +
                                    " of the unspent output"},
                               {RPCResult::Type::NUM, "height",
                                "Height of the unspent transaction output"},
                           }},
                      }},
                     {RPCResult::Type::STR_AMOUNT, "total_amount",
                      "The total amount of all found unspent outputs in " +
                          ticker},
                 }},
         },
         RPCExamples{""},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             RPCTypeCheck(request.params, {UniValue::VSTR, UniValue::VARR});
 
             UniValue result(UniValue::VOBJ);
             if (request.params[0].get_str() == "status") {
                 CoinsViewScanReserver reserver;
                 if (reserver.reserve()) {
                     // no scan in progress
                     return NullUniValue;
                 }
                 result.pushKV("progress", g_scan_progress.load());
                 return result;
             } else if (request.params[0].get_str() == "abort") {
                 CoinsViewScanReserver reserver;
                 if (reserver.reserve()) {
                     // reserve was possible which means no scan was running
                     return false;
                 }
                 // set the abort flag
                 g_should_abort_scan = true;
                 return true;
             } else if (request.params[0].get_str() == "start") {
                 CoinsViewScanReserver reserver;
                 if (!reserver.reserve()) {
                     throw JSONRPCError(RPC_INVALID_PARAMETER,
                                        "Scan already in progress, use action "
                                        "\"abort\" or \"status\"");
                 }
 
                 if (request.params.size() < 2) {
                     throw JSONRPCError(RPC_MISC_ERROR,
                                        "scanobjects argument is required for "
                                        "the start action");
                 }
 
                 std::set<CScript> needles;
                 std::map<CScript, std::string> descriptors;
                 Amount total_in = Amount::zero();
 
                 // loop through the scan objects
                 for (const UniValue &scanobject :
                      request.params[1].get_array().getValues()) {
                     FlatSigningProvider provider;
                     auto scripts =
                         EvalDescriptorStringOrObject(scanobject, provider);
                     for (const auto &script : scripts) {
                         std::string inferred =
                             InferDescriptor(script, provider)->ToString();
                         needles.emplace(script);
                         descriptors.emplace(std::move(script),
                                             std::move(inferred));
                     }
                 }
 
                 // Scan the unspent transaction output set for inputs
                 UniValue unspents(UniValue::VARR);
                 std::vector<CTxOut> input_txos;
                 std::map<COutPoint, Coin> coins;
                 g_should_abort_scan = false;
                 g_scan_progress = 0;
                 int64_t count = 0;
                 std::unique_ptr<CCoinsViewCursor> pcursor;
                 const CBlockIndex *tip;
                 NodeContext &node = EnsureAnyNodeContext(request.context);
                 {
                     ChainstateManager &chainman = EnsureChainman(node);
                     LOCK(cs_main);
                     Chainstate &active_chainstate = chainman.ActiveChainstate();
                     active_chainstate.ForceFlushStateToDisk();
                     pcursor = CHECK_NONFATAL(std::unique_ptr<CCoinsViewCursor>(
                         active_chainstate.CoinsDB().Cursor()));
                     tip = CHECK_NONFATAL(active_chainstate.m_chain.Tip());
                 }
                 bool res = FindScriptPubKey(
                     g_scan_progress, g_should_abort_scan, count, pcursor.get(),
                     needles, coins, node.rpc_interruption_point);
                 result.pushKV("success", res);
                 result.pushKV("txouts", count);
                 result.pushKV("height", tip->nHeight);
                 result.pushKV("bestblock", tip->GetBlockHash().GetHex());
 
                 for (const auto &it : coins) {
                     const COutPoint &outpoint = it.first;
                     const Coin &coin = it.second;
                     const CTxOut &txo = coin.GetTxOut();
                     input_txos.push_back(txo);
                     total_in += txo.nValue;
 
                     UniValue unspent(UniValue::VOBJ);
                     unspent.pushKV("txid", outpoint.GetTxId().GetHex());
                     unspent.pushKV("vout", int32_t(outpoint.GetN()));
                     unspent.pushKV("scriptPubKey", HexStr(txo.scriptPubKey));
                     unspent.pushKV("desc", descriptors[txo.scriptPubKey]);
                     unspent.pushKV("amount", txo.nValue);
                     unspent.pushKV("height", int32_t(coin.GetHeight()));
 
                     unspents.push_back(unspent);
                 }
                 result.pushKV("unspents", unspents);
                 result.pushKV("total_amount", total_in);
             } else {
                 throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid command");
             }
             return result;
         },
     };
 }
 
 static RPCHelpMan getblockfilter() {
     return RPCHelpMan{
         "getblockfilter",
         "Retrieve a BIP 157 content filter for a particular block.\n",
         {
             {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The hash of the block"},
             {"filtertype", RPCArg::Type::STR, /*default*/ "basic",
              "The type name of the filter"},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR_HEX, "filter",
                        "the hex-encoded filter data"},
                       {RPCResult::Type::STR_HEX, "header",
                        "the hex-encoded filter header"},
                   }},
         RPCExamples{
             HelpExampleCli("getblockfilter",
                            "\"00000000c937983704a73af28acdec37b049d214a"
                            "dbda81d7e2a3dd146f6ed09\" \"basic\"") +
             HelpExampleRpc("getblockfilter",
                            "\"00000000c937983704a73af28acdec37b049d214adbda81d7"
                            "e2a3dd146f6ed09\", \"basic\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             const BlockHash block_hash(
                 ParseHashV(request.params[0], "blockhash"));
             std::string filtertype_name = "basic";
             if (!request.params[1].isNull()) {
                 filtertype_name = request.params[1].get_str();
             }
 
             BlockFilterType filtertype;
             if (!BlockFilterTypeByName(filtertype_name, filtertype)) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                    "Unknown filtertype");
             }
 
             BlockFilterIndex *index = GetBlockFilterIndex(filtertype);
             if (!index) {
                 throw JSONRPCError(RPC_MISC_ERROR,
                                    "Index is not enabled for filtertype " +
                                        filtertype_name);
             }
 
             const CBlockIndex *block_index;
             bool block_was_connected;
             {
                 ChainstateManager &chainman =
                     EnsureAnyChainman(request.context);
                 LOCK(cs_main);
                 block_index = chainman.m_blockman.LookupBlockIndex(block_hash);
                 if (!block_index) {
                     throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                        "Block not found");
                 }
                 block_was_connected =
                     block_index->IsValid(BlockValidity::SCRIPTS);
             }
 
             bool index_ready = index->BlockUntilSyncedToCurrentChain();
 
             BlockFilter filter;
             uint256 filter_header;
             if (!index->LookupFilter(block_index, filter) ||
                 !index->LookupFilterHeader(block_index, filter_header)) {
                 int err_code;
                 std::string errmsg = "Filter not found.";
 
                 if (!block_was_connected) {
                     err_code = RPC_INVALID_ADDRESS_OR_KEY;
                     errmsg += " Block was not connected to active chain.";
                 } else if (!index_ready) {
                     err_code = RPC_MISC_ERROR;
                     errmsg += " Block filters are still in the process of "
                               "being indexed.";
                 } else {
                     err_code = RPC_INTERNAL_ERROR;
                     errmsg += " This error is unexpected and indicates index "
                               "corruption.";
                 }
 
                 throw JSONRPCError(err_code, errmsg);
             }
 
             UniValue ret(UniValue::VOBJ);
             ret.pushKV("filter", HexStr(filter.GetEncodedFilter()));
             ret.pushKV("header", filter_header.GetHex());
             return ret;
         },
     };
 }
 
 /**
  * Serialize the UTXO set to a file for loading elsewhere.
  *
  * @see SnapshotMetadata
  */
 static RPCHelpMan dumptxoutset() {
     return RPCHelpMan{
         "dumptxoutset",
         "Write the serialized UTXO set to disk.\n",
         {
             {"path", RPCArg::Type::STR, RPCArg::Optional::NO,
              "path to the output file. If relative, will be prefixed by "
              "datadir."},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::NUM, "coins_written",
                        "the number of coins written in the snapshot"},
                       {RPCResult::Type::STR_HEX, "base_hash",
                        "the hash of the base of the snapshot"},
                       {RPCResult::Type::NUM, "base_height",
                        "the height of the base of the snapshot"},
                       {RPCResult::Type::STR, "path",
                        "the absolute path that the snapshot was written to"},
                   }},
         RPCExamples{HelpExampleCli("dumptxoutset", "utxo.dat")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             const fs::path path = fsbridge::AbsPathJoin(
                 gArgs.GetDataDirNet(), fs::u8path(request.params[0].get_str()));
             // Write to a temporary path and then move into `path` on completion
             // to avoid confusion due to an interruption.
             const fs::path temppath = fsbridge::AbsPathJoin(
                 gArgs.GetDataDirNet(),
                 fs::u8path(request.params[0].get_str() + ".incomplete"));
 
             if (fs::exists(path)) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    path.u8string() +
                                        " already exists. If you are sure this "
                                        "is what you want, "
                                        "move it out of the way first");
             }
 
             FILE *file{fsbridge::fopen(temppath, "wb")};
             CAutoFile afile{file, SER_DISK, CLIENT_VERSION};
             NodeContext &node = EnsureAnyNodeContext(request.context);
             UniValue result = CreateUTXOSnapshot(
                 node, node.chainman->ActiveChainstate(), afile);
             fs::rename(temppath, path);
 
             result.pushKV("path", path.u8string());
             return result;
         },
     };
 }
 
 UniValue CreateUTXOSnapshot(NodeContext &node, Chainstate &chainstate,
                             CAutoFile &afile) {
     std::unique_ptr<CCoinsViewCursor> pcursor;
     CCoinsStats stats{CoinStatsHashType::NONE};
     const CBlockIndex *tip;
 
     {
         // We need to lock cs_main to ensure that the coinsdb isn't
         // written to between (i) flushing coins cache to disk
         // (coinsdb), (ii) getting stats based upon the coinsdb, and
         // (iii) constructing a cursor to the coinsdb for use below this
         // block.
         //
         // Cursors returned by leveldb iterate over snapshots, so the
         // contents of the pcursor will not be affected by simultaneous
         // writes during use below this block.
         //
         // See discussion here:
         //   https://github.com/bitcoin/bitcoin/pull/15606#discussion_r274479369
         //
         LOCK(::cs_main);
 
         chainstate.ForceFlushStateToDisk();
 
         if (!GetUTXOStats(&chainstate.CoinsDB(), chainstate.m_blockman, stats,
                           node.rpc_interruption_point)) {
             throw JSONRPCError(RPC_INTERNAL_ERROR, "Unable to read UTXO set");
         }
 
         pcursor =
             std::unique_ptr<CCoinsViewCursor>(chainstate.CoinsDB().Cursor());
         tip = CHECK_NONFATAL(
             chainstate.m_blockman.LookupBlockIndex(stats.hashBlock));
     }
 
     SnapshotMetadata metadata{tip->GetBlockHash(), stats.coins_count,
                               uint64_t(tip->GetChainTxCount())};
 
     afile << metadata;
 
     COutPoint key;
     Coin coin;
     unsigned int iter{0};
 
     while (pcursor->Valid()) {
         if (iter % 5000 == 0) {
             node.rpc_interruption_point();
         }
         ++iter;
         if (pcursor->GetKey(key) && pcursor->GetValue(coin)) {
             afile << key;
             afile << coin;
         }
 
         pcursor->Next();
     }
 
     afile.fclose();
 
     UniValue result(UniValue::VOBJ);
     result.pushKV("coins_written", stats.coins_count);
     result.pushKV("base_hash", tip->GetBlockHash().ToString());
     result.pushKV("base_height", tip->nHeight);
     return result;
 }
 
 void RegisterBlockchainRPCCommands(CRPCTable &t) {
     // clang-format off
     static const CRPCCommand commands[] = {
         //  category            actor (function)
         //  ------------------  ----------------------
         { "blockchain",         getbestblockhash,                  },
         { "blockchain",         getblock,                          },
         { "blockchain",         getblockfrompeer,                  },
         { "blockchain",         getblockchaininfo,                 },
         { "blockchain",         getblockcount,                     },
         { "blockchain",         getblockhash,                      },
         { "blockchain",         getblockheader,                    },
         { "blockchain",         getblockstats,                     },
         { "blockchain",         getchaintips,                      },
         { "blockchain",         getchaintxstats,                   },
         { "blockchain",         getdifficulty,                     },
         { "blockchain",         getmempoolancestors,               },
         { "blockchain",         getmempooldescendants,             },
         { "blockchain",         getmempoolentry,                   },
         { "blockchain",         getmempoolinfo,                    },
         { "blockchain",         getrawmempool,                     },
         { "blockchain",         gettxout,                          },
         { "blockchain",         gettxoutsetinfo,                   },
         { "blockchain",         pruneblockchain,                   },
         { "blockchain",         savemempool,                       },
         { "blockchain",         verifychain,                       },
         { "blockchain",         preciousblock,                     },
         { "blockchain",         scantxoutset,                      },
         { "blockchain",         getblockfilter,                    },
 
         /* Not shown in help */
         { "hidden",             invalidateblock,                   },
         { "hidden",             parkblock,                         },
         { "hidden",             reconsiderblock,                   },
         { "hidden",             syncwithvalidationinterfacequeue,  },
         { "hidden",             dumptxoutset,                      },
         { "hidden",             unparkblock,                       },
         { "hidden",             waitfornewblock,                   },
         { "hidden",             waitforblock,                      },
         { "hidden",             waitforblockheight,                },
     };
     // clang-format on
     for (const auto &c : commands) {
         t.appendCommand(c.name, &c);
     }
 }
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index d1c604e1b..12b41284b 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -1,1055 +1,1051 @@
 // 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/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>
 
 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},
+      nSigChecksWithDescendants{sigChecks}, nSizeWithAncestors{GetTxSize()},
       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::CalculateAncestors(
     setEntries &setAncestors,
     CTxMemPoolEntry::Parents &staged_ancestors) const {
     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());
 
         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);
             }
         }
     }
 
     return true;
 }
 
 bool CTxMemPool::CalculateMemPoolAncestors(
     const CTxMemPoolEntry &entry, setEntries &setAncestors,
     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);
         }
     } else {
         // If we're not searching for parents, we require this to be an entry in
         // the mempool already.
         staged_ancestors = entry.GetMemPoolParentsConst();
     }
 
     return CalculateAncestors(setAncestors, staged_ancestors);
 }
 
 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);
     }
 }
 
 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) {
     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);
     }
 }
 
 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);
     }
 
     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);
         assert(ok);
 
         // 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));
 
         // 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); });
             ++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;
     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());
     }
 }
 
 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 784403a37..ad7b47b6d 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -1,915 +1,909 @@
 // 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; }
 
-    // Updates the fee delta used for mining priority score, and the
-    // modified fees with descendants.
+    // Updates the fee delta used for mining priority score
     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;
 
 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
      * param@[in]   staged_ancestors    Should contain entries in the mempool.
      * param@[out]  setAncestors        Will be populated with all mempool
      *                                  ancestors.
      */
     bool CalculateAncestors(setEntries &setAncestors,
                             CTxMemPoolEntry::Parents &staged_ancestors) const
         EXCLUSIVE_LOCKS_REQUIRED(cs);
 
 public:
     indirectmap<COutPoint, const CTransaction *> mapNextTx GUARDED_BY(cs);
     std::map<TxId, Amount> mapDeltas GUARDED_BY(cs);
 
     /**
      * 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)
      * 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,
                                    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);
 
     /** @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) 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