LCOV - code coverage report
Current view: top level - src/node - interfaces.cpp (source / functions) Coverage Total Hit
Test: total_coverage.info Lines: 57.5 % 557 320
Test Date: 2025-08-01 05:08:13 Functions: 54.7 % 172 94
Branches: 37.0 % 698 258

             Branch data     Line data    Source code
       1                 :             : // Copyright (c) 2018-2022 The Bitcoin Core developers
       2                 :             : // Distributed under the MIT software license, see the accompanying
       3                 :             : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
       4                 :             : 
       5                 :             : #include <addrdb.h>
       6                 :             : #include <banman.h>
       7                 :             : #include <blockfilter.h>
       8                 :             : #include <chain.h>
       9                 :             : #include <chainparams.h>
      10                 :             : #include <common/args.h>
      11                 :             : #include <consensus/merkle.h>
      12                 :             : #include <consensus/validation.h>
      13                 :             : #include <deploymentstatus.h>
      14                 :             : #include <external_signer.h>
      15                 :             : #include <index/blockfilterindex.h>
      16                 :             : #include <init.h>
      17                 :             : #include <interfaces/chain.h>
      18                 :             : #include <interfaces/handler.h>
      19                 :             : #include <interfaces/mining.h>
      20                 :             : #include <interfaces/node.h>
      21                 :             : #include <interfaces/types.h>
      22                 :             : #include <interfaces/wallet.h>
      23                 :             : #include <kernel/chain.h>
      24                 :             : #include <kernel/context.h>
      25                 :             : #include <kernel/mempool_entry.h>
      26                 :             : #include <logging.h>
      27                 :             : #include <mapport.h>
      28                 :             : #include <net.h>
      29                 :             : #include <net_processing.h>
      30                 :             : #include <netaddress.h>
      31                 :             : #include <netbase.h>
      32                 :             : #include <node/blockstorage.h>
      33                 :             : #include <node/coin.h>
      34                 :             : #include <node/context.h>
      35                 :             : #include <node/interface_ui.h>
      36                 :             : #include <node/mini_miner.h>
      37                 :             : #include <node/miner.h>
      38                 :             : #include <node/kernel_notifications.h>
      39                 :             : #include <node/transaction.h>
      40                 :             : #include <node/types.h>
      41                 :             : #include <node/warnings.h>
      42                 :             : #include <policy/feerate.h>
      43                 :             : #include <policy/fees.h>
      44                 :             : #include <policy/policy.h>
      45                 :             : #include <policy/rbf.h>
      46                 :             : #include <policy/settings.h>
      47                 :             : #include <primitives/block.h>
      48                 :             : #include <primitives/transaction.h>
      49                 :             : #include <rpc/blockchain.h>
      50                 :             : #include <rpc/protocol.h>
      51                 :             : #include <rpc/server.h>
      52                 :             : #include <support/allocators/secure.h>
      53                 :             : #include <sync.h>
      54                 :             : #include <txmempool.h>
      55                 :             : #include <uint256.h>
      56                 :             : #include <univalue.h>
      57                 :             : #include <util/check.h>
      58                 :             : #include <util/result.h>
      59                 :             : #include <util/signalinterrupt.h>
      60                 :             : #include <util/string.h>
      61                 :             : #include <util/translation.h>
      62                 :             : #include <validation.h>
      63                 :             : #include <validationinterface.h>
      64                 :             : 
      65                 :             : #include <bitcoin-build-config.h> // IWYU pragma: keep
      66                 :             : 
      67                 :             : #include <any>
      68                 :             : #include <memory>
      69                 :             : #include <optional>
      70                 :             : #include <utility>
      71                 :             : 
      72                 :             : #include <boost/signals2/signal.hpp>
      73                 :             : 
      74                 :             : using interfaces::BlockRef;
      75                 :             : using interfaces::BlockTemplate;
      76                 :             : using interfaces::BlockTip;
      77                 :             : using interfaces::Chain;
      78                 :             : using interfaces::FoundBlock;
      79                 :             : using interfaces::Handler;
      80                 :             : using interfaces::MakeSignalHandler;
      81                 :             : using interfaces::Mining;
      82                 :             : using interfaces::Node;
      83                 :             : using interfaces::WalletLoader;
      84                 :             : using node::BlockAssembler;
      85                 :             : using node::BlockWaitOptions;
      86                 :             : using util::Join;
      87                 :             : 
      88                 :             : namespace node {
      89                 :             : // All members of the classes in this namespace are intentionally public, as the
      90                 :             : // classes themselves are private.
      91                 :             : namespace {
      92                 :             : #ifdef ENABLE_EXTERNAL_SIGNER
      93                 :             : class ExternalSignerImpl : public interfaces::ExternalSigner
      94                 :             : {
      95                 :             : public:
      96                 :           0 :     ExternalSignerImpl(::ExternalSigner signer) : m_signer(std::move(signer)) {}
      97                 :           0 :     std::string getName() override { return m_signer.m_name; }
      98                 :             :     ::ExternalSigner m_signer;
      99                 :             : };
     100                 :             : #endif
     101                 :             : 
     102                 :             : class NodeImpl : public Node
     103                 :             : {
     104                 :             : public:
     105                 :           0 :     explicit NodeImpl(NodeContext& context) { setContext(&context); }
     106                 :           0 :     void initLogging() override { InitLogging(args()); }
     107                 :           0 :     void initParameterInteraction() override { InitParameterInteraction(args()); }
     108   [ #  #  #  #  :           0 :     bilingual_str getWarnings() override { return Join(Assert(m_context->warnings)->GetMessages(), Untranslated("<hr />")); }
             #  #  #  # ]
     109                 :           0 :     int getExitStatus() override { return Assert(m_context)->exit_status.load(); }
     110                 :           0 :     BCLog::CategoryMask getLogCategories() override { return LogInstance().GetCategoryMask(); }
     111                 :           0 :     bool baseInitialize() override
     112                 :             :     {
     113         [ #  # ]:           0 :         if (!AppInitBasicSetup(args(), Assert(context())->exit_status)) return false;
     114         [ #  # ]:           0 :         if (!AppInitParameterInteraction(args())) return false;
     115                 :             : 
     116                 :           0 :         m_context->warnings = std::make_unique<node::Warnings>();
     117                 :           0 :         m_context->kernel = std::make_unique<kernel::Context>();
     118                 :           0 :         m_context->ecc_context = std::make_unique<ECC_Context>();
     119         [ #  # ]:           0 :         if (!AppInitSanityChecks(*m_context->kernel)) return false;
     120                 :             : 
     121         [ #  # ]:           0 :         if (!AppInitLockDirectories()) return false;
     122         [ #  # ]:           0 :         if (!AppInitInterfaces(*m_context)) return false;
     123                 :             : 
     124                 :             :         return true;
     125                 :             :     }
     126                 :           0 :     bool appInitMain(interfaces::BlockAndHeaderTipInfo* tip_info) override
     127                 :             :     {
     128         [ #  # ]:           0 :         if (AppInitMain(*m_context, tip_info)) return true;
     129                 :             :         // Error during initialization, set exit status before continue
     130                 :           0 :         m_context->exit_status.store(EXIT_FAILURE);
     131                 :           0 :         return false;
     132                 :             :     }
     133                 :           0 :     void appShutdown() override
     134                 :             :     {
     135                 :           0 :         Interrupt(*m_context);
     136                 :           0 :         Shutdown(*m_context);
     137                 :           0 :     }
     138                 :           0 :     void startShutdown() override
     139                 :             :     {
     140                 :           0 :         NodeContext& ctx{*Assert(m_context)};
     141         [ #  # ]:           0 :         if (!(Assert(ctx.shutdown_request))()) {
     142                 :           0 :             LogError("Failed to send shutdown signal\n");
     143                 :             :         }
     144                 :             : 
     145                 :             :         // Stop RPC for clean shutdown if any of waitfor* commands is executed.
     146   [ #  #  #  # ]:           0 :         if (args().GetBoolArg("-server", false)) {
     147                 :           0 :             InterruptRPC();
     148                 :           0 :             StopRPC();
     149                 :             :         }
     150                 :           0 :     }
     151                 :           0 :     bool shutdownRequested() override { return ShutdownRequested(*Assert(m_context)); };
     152                 :           0 :     bool isSettingIgnored(const std::string& name) override
     153                 :             :     {
     154                 :           0 :         bool ignored = false;
     155                 :           0 :         args().LockSettings([&](common::Settings& settings) {
     156         [ #  # ]:           0 :             if (auto* options = common::FindKey(settings.command_line_options, name)) {
     157                 :           0 :                 ignored = !options->empty();
     158                 :             :             }
     159                 :           0 :         });
     160                 :           0 :         return ignored;
     161                 :             :     }
     162                 :           0 :     common::SettingsValue getPersistentSetting(const std::string& name) override { return args().GetPersistentSetting(name); }
     163                 :           0 :     void updateRwSetting(const std::string& name, const common::SettingsValue& value) override
     164                 :             :     {
     165                 :           0 :         args().LockSettings([&](common::Settings& settings) {
     166         [ #  # ]:           0 :             if (value.isNull()) {
     167                 :           0 :                 settings.rw_settings.erase(name);
     168                 :             :             } else {
     169                 :           0 :                 settings.rw_settings[name] = value;
     170                 :             :             }
     171                 :           0 :         });
     172                 :           0 :         args().WriteSettingsFile();
     173                 :           0 :     }
     174                 :           0 :     void forceSetting(const std::string& name, const common::SettingsValue& value) override
     175                 :             :     {
     176                 :           0 :         args().LockSettings([&](common::Settings& settings) {
     177         [ #  # ]:           0 :             if (value.isNull()) {
     178                 :           0 :                 settings.forced_settings.erase(name);
     179                 :             :             } else {
     180                 :           0 :                 settings.forced_settings[name] = value;
     181                 :             :             }
     182                 :           0 :         });
     183                 :           0 :     }
     184                 :           0 :     void resetSettings() override
     185                 :             :     {
     186                 :           0 :         args().WriteSettingsFile(/*errors=*/nullptr, /*backup=*/true);
     187                 :           0 :         args().LockSettings([&](common::Settings& settings) {
     188         [ #  # ]:           0 :             settings.rw_settings.clear();
     189                 :             :         });
     190                 :           0 :         args().WriteSettingsFile();
     191                 :           0 :     }
     192                 :           0 :     void mapPort(bool enable) override { StartMapPort(enable); }
     193                 :           0 :     bool getProxy(Network net, Proxy& proxy_info) override { return GetProxy(net, proxy_info); }
     194                 :           0 :     size_t getNodeCount(ConnectionDirection flags) override
     195                 :             :     {
     196         [ #  # ]:           0 :         return m_context->connman ? m_context->connman->GetNodeCount(flags) : 0;
     197                 :             :     }
     198                 :           0 :     bool getNodesStats(NodesStats& stats) override
     199                 :             :     {
     200                 :           0 :         stats.clear();
     201                 :             : 
     202         [ #  # ]:           0 :         if (m_context->connman) {
     203                 :           0 :             std::vector<CNodeStats> stats_temp;
     204         [ #  # ]:           0 :             m_context->connman->GetNodeStats(stats_temp);
     205                 :             : 
     206         [ #  # ]:           0 :             stats.reserve(stats_temp.size());
     207         [ #  # ]:           0 :             for (auto& node_stats_temp : stats_temp) {
     208         [ #  # ]:           0 :                 stats.emplace_back(std::move(node_stats_temp), false, CNodeStateStats());
     209                 :             :             }
     210                 :             : 
     211                 :             :             // Try to retrieve the CNodeStateStats for each node.
     212         [ #  # ]:           0 :             if (m_context->peerman) {
     213         [ #  # ]:           0 :                 TRY_LOCK(::cs_main, lockMain);
     214         [ #  # ]:           0 :                 if (lockMain) {
     215         [ #  # ]:           0 :                     for (auto& node_stats : stats) {
     216                 :           0 :                         std::get<1>(node_stats) =
     217         [ #  # ]:           0 :                             m_context->peerman->GetNodeStateStats(std::get<0>(node_stats).nodeid, std::get<2>(node_stats));
     218                 :             :                     }
     219                 :             :                 }
     220                 :           0 :             }
     221                 :           0 :             return true;
     222                 :           0 :         }
     223                 :             :         return false;
     224                 :             :     }
     225                 :           0 :     bool getBanned(banmap_t& banmap) override
     226                 :             :     {
     227         [ #  # ]:           0 :         if (m_context->banman) {
     228                 :           0 :             m_context->banman->GetBanned(banmap);
     229                 :           0 :             return true;
     230                 :             :         }
     231                 :             :         return false;
     232                 :             :     }
     233                 :           0 :     bool ban(const CNetAddr& net_addr, int64_t ban_time_offset) override
     234                 :             :     {
     235         [ #  # ]:           0 :         if (m_context->banman) {
     236                 :           0 :             m_context->banman->Ban(net_addr, ban_time_offset);
     237                 :           0 :             return true;
     238                 :             :         }
     239                 :             :         return false;
     240                 :             :     }
     241                 :           0 :     bool unban(const CSubNet& ip) override
     242                 :             :     {
     243         [ #  # ]:           0 :         if (m_context->banman) {
     244                 :           0 :             m_context->banman->Unban(ip);
     245                 :           0 :             return true;
     246                 :             :         }
     247                 :             :         return false;
     248                 :             :     }
     249                 :           0 :     bool disconnectByAddress(const CNetAddr& net_addr) override
     250                 :             :     {
     251         [ #  # ]:           0 :         if (m_context->connman) {
     252                 :           0 :             return m_context->connman->DisconnectNode(net_addr);
     253                 :             :         }
     254                 :             :         return false;
     255                 :             :     }
     256                 :           0 :     bool disconnectById(NodeId id) override
     257                 :             :     {
     258         [ #  # ]:           0 :         if (m_context->connman) {
     259                 :           0 :             return m_context->connman->DisconnectNode(id);
     260                 :             :         }
     261                 :             :         return false;
     262                 :             :     }
     263                 :           0 :     std::vector<std::unique_ptr<interfaces::ExternalSigner>> listExternalSigners() override
     264                 :             :     {
     265                 :             : #ifdef ENABLE_EXTERNAL_SIGNER
     266                 :           0 :         std::vector<ExternalSigner> signers = {};
     267   [ #  #  #  #  :           0 :         const std::string command = args().GetArg("-signer", "");
             #  #  #  # ]
     268         [ #  # ]:           0 :         if (command == "") return {};
     269   [ #  #  #  #  :           0 :         ExternalSigner::Enumerate(command, signers, Params().GetChainTypeString());
                   #  # ]
     270                 :           0 :         std::vector<std::unique_ptr<interfaces::ExternalSigner>> result;
     271         [ #  # ]:           0 :         result.reserve(signers.size());
     272         [ #  # ]:           0 :         for (auto& signer : signers) {
     273   [ #  #  #  # ]:           0 :             result.emplace_back(std::make_unique<ExternalSignerImpl>(std::move(signer)));
     274                 :             :         }
     275                 :           0 :         return result;
     276                 :             : #else
     277                 :             :         // This result is indistinguishable from a successful call that returns
     278                 :             :         // no signers. For the current GUI this doesn't matter, because the wallet
     279                 :             :         // creation dialog disables the external signer checkbox in both
     280                 :             :         // cases. The return type could be changed to std::optional<std::vector>
     281                 :             :         // (or something that also includes error messages) if this distinction
     282                 :             :         // becomes important.
     283                 :             :         return {};
     284                 :             : #endif // ENABLE_EXTERNAL_SIGNER
     285                 :           0 :     }
     286         [ #  # ]:           0 :     int64_t getTotalBytesRecv() override { return m_context->connman ? m_context->connman->GetTotalBytesRecv() : 0; }
     287         [ #  # ]:           0 :     int64_t getTotalBytesSent() override { return m_context->connman ? m_context->connman->GetTotalBytesSent() : 0; }
     288         [ #  # ]:           0 :     size_t getMempoolSize() override { return m_context->mempool ? m_context->mempool->size() : 0; }
     289         [ #  # ]:           0 :     size_t getMempoolDynamicUsage() override { return m_context->mempool ? m_context->mempool->DynamicMemoryUsage() : 0; }
     290         [ #  # ]:           0 :     size_t getMempoolMaxUsage() override { return m_context->mempool ? m_context->mempool->m_opts.max_size_bytes : 0; }
     291                 :           0 :     bool getHeaderTip(int& height, int64_t& block_time) override
     292                 :             :     {
     293                 :           0 :         LOCK(::cs_main);
     294         [ #  # ]:           0 :         auto best_header = chainman().m_best_header;
     295         [ #  # ]:           0 :         if (best_header) {
     296                 :           0 :             height = best_header->nHeight;
     297                 :           0 :             block_time = best_header->GetBlockTime();
     298                 :           0 :             return true;
     299                 :             :         }
     300                 :             :         return false;
     301                 :           0 :     }
     302                 :           0 :     std::map<CNetAddr, LocalServiceInfo> getNetLocalAddresses() override
     303                 :             :     {
     304         [ #  # ]:           0 :         if (m_context->connman)
     305                 :           0 :             return m_context->connman->getNetLocalAddresses();
     306                 :             :         else
     307                 :           0 :             return {};
     308                 :             :     }
     309                 :           0 :     int getNumBlocks() override
     310                 :             :     {
     311                 :           0 :         LOCK(::cs_main);
     312   [ #  #  #  #  :           0 :         return chainman().ActiveChain().Height();
                   #  # ]
     313                 :           0 :     }
     314                 :           0 :     uint256 getBestBlockHash() override
     315                 :             :     {
     316   [ #  #  #  #  :           0 :         const CBlockIndex* tip = WITH_LOCK(::cs_main, return chainman().ActiveChain().Tip());
             #  #  #  # ]
     317         [ #  # ]:           0 :         return tip ? tip->GetBlockHash() : chainman().GetParams().GenesisBlock().GetHash();
     318                 :             :     }
     319                 :           0 :     int64_t getLastBlockTime() override
     320                 :             :     {
     321                 :           0 :         LOCK(::cs_main);
     322   [ #  #  #  #  :           0 :         if (chainman().ActiveChain().Tip()) {
             #  #  #  # ]
     323   [ #  #  #  #  :           0 :             return chainman().ActiveChain().Tip()->GetBlockTime();
                   #  # ]
     324                 :             :         }
     325         [ #  # ]:           0 :         return chainman().GetParams().GenesisBlock().GetBlockTime(); // Genesis block's time of current network
     326                 :           0 :     }
     327                 :           0 :     double getVerificationProgress() override
     328                 :             :     {
     329                 :           0 :         LOCK(chainman().GetMutex());
     330   [ #  #  #  #  :           0 :         return chainman().GuessVerificationProgress(chainman().ActiveTip());
          #  #  #  #  #  
                      # ]
     331                 :           0 :     }
     332                 :           0 :     bool isInitialBlockDownload() override
     333                 :             :     {
     334                 :           0 :         return chainman().IsInitialBlockDownload();
     335                 :             :     }
     336                 :           0 :     bool isLoadingBlocks() override { return chainman().m_blockman.LoadingBlocks(); }
     337                 :           0 :     void setNetworkActive(bool active) override
     338                 :             :     {
     339         [ #  # ]:           0 :         if (m_context->connman) {
     340                 :           0 :             m_context->connman->SetNetworkActive(active);
     341                 :             :         }
     342                 :           0 :     }
     343   [ #  #  #  # ]:           0 :     bool getNetworkActive() override { return m_context->connman && m_context->connman->GetNetworkActive(); }
     344                 :           0 :     CFeeRate getDustRelayFee() override
     345                 :             :     {
     346         [ #  # ]:           0 :         if (!m_context->mempool) return CFeeRate{DUST_RELAY_TX_FEE};
     347                 :           0 :         return m_context->mempool->m_opts.dust_relay_feerate;
     348                 :             :     }
     349                 :           0 :     UniValue executeRpc(const std::string& command, const UniValue& params, const std::string& uri) override
     350                 :             :     {
     351                 :           0 :         JSONRPCRequest req;
     352                 :           0 :         req.context = m_context;
     353         [ #  # ]:           0 :         req.params = params;
     354         [ #  # ]:           0 :         req.strMethod = command;
     355         [ #  # ]:           0 :         req.URI = uri;
     356         [ #  # ]:           0 :         return ::tableRPC.execute(req);
     357                 :           0 :     }
     358                 :           0 :     std::vector<std::string> listRpcCommands() override { return ::tableRPC.listCommands(); }
     359                 :           0 :     std::optional<Coin> getUnspentOutput(const COutPoint& output) override
     360                 :             :     {
     361                 :           0 :         LOCK(::cs_main);
     362   [ #  #  #  #  :           0 :         return chainman().ActiveChainstate().CoinsTip().GetCoin(output);
             #  #  #  # ]
     363                 :           0 :     }
     364                 :           0 :     TransactionError broadcastTransaction(CTransactionRef tx, CAmount max_tx_fee, std::string& err_string) override
     365                 :             :     {
     366   [ #  #  #  # ]:           0 :         return BroadcastTransaction(*m_context, std::move(tx), err_string, max_tx_fee, /*relay=*/ true, /*wait_callback=*/ false);
     367                 :             :     }
     368                 :           0 :     WalletLoader& walletLoader() override
     369                 :             :     {
     370                 :           0 :         return *Assert(m_context->wallet_loader);
     371                 :             :     }
     372                 :           0 :     std::unique_ptr<Handler> handleInitMessage(InitMessageFn fn) override
     373                 :             :     {
     374   [ #  #  #  # ]:           0 :         return MakeSignalHandler(::uiInterface.InitMessage_connect(fn));
     375                 :             :     }
     376                 :           0 :     std::unique_ptr<Handler> handleMessageBox(MessageBoxFn fn) override
     377                 :             :     {
     378   [ #  #  #  # ]:           0 :         return MakeSignalHandler(::uiInterface.ThreadSafeMessageBox_connect(fn));
     379                 :             :     }
     380                 :           0 :     std::unique_ptr<Handler> handleQuestion(QuestionFn fn) override
     381                 :             :     {
     382   [ #  #  #  # ]:           0 :         return MakeSignalHandler(::uiInterface.ThreadSafeQuestion_connect(fn));
     383                 :             :     }
     384                 :           0 :     std::unique_ptr<Handler> handleShowProgress(ShowProgressFn fn) override
     385                 :             :     {
     386   [ #  #  #  # ]:           0 :         return MakeSignalHandler(::uiInterface.ShowProgress_connect(fn));
     387                 :             :     }
     388                 :           0 :     std::unique_ptr<Handler> handleInitWallet(InitWalletFn fn) override
     389                 :             :     {
     390   [ #  #  #  # ]:           0 :         return MakeSignalHandler(::uiInterface.InitWallet_connect(fn));
     391                 :             :     }
     392                 :           0 :     std::unique_ptr<Handler> handleNotifyNumConnectionsChanged(NotifyNumConnectionsChangedFn fn) override
     393                 :             :     {
     394   [ #  #  #  # ]:           0 :         return MakeSignalHandler(::uiInterface.NotifyNumConnectionsChanged_connect(fn));
     395                 :             :     }
     396                 :           0 :     std::unique_ptr<Handler> handleNotifyNetworkActiveChanged(NotifyNetworkActiveChangedFn fn) override
     397                 :             :     {
     398   [ #  #  #  # ]:           0 :         return MakeSignalHandler(::uiInterface.NotifyNetworkActiveChanged_connect(fn));
     399                 :             :     }
     400                 :           0 :     std::unique_ptr<Handler> handleNotifyAlertChanged(NotifyAlertChangedFn fn) override
     401                 :             :     {
     402   [ #  #  #  # ]:           0 :         return MakeSignalHandler(::uiInterface.NotifyAlertChanged_connect(fn));
     403                 :             :     }
     404                 :           0 :     std::unique_ptr<Handler> handleBannedListChanged(BannedListChangedFn fn) override
     405                 :             :     {
     406   [ #  #  #  # ]:           0 :         return MakeSignalHandler(::uiInterface.BannedListChanged_connect(fn));
     407                 :             :     }
     408                 :           0 :     std::unique_ptr<Handler> handleNotifyBlockTip(NotifyBlockTipFn fn) override
     409                 :             :     {
     410   [ #  #  #  #  :           0 :         return MakeSignalHandler(::uiInterface.NotifyBlockTip_connect([fn](SynchronizationState sync_state, const CBlockIndex& block, double verification_progress) {
                   #  # ]
     411                 :           0 :             fn(sync_state, BlockTip{block.nHeight, block.GetBlockTime(), block.GetBlockHash()}, verification_progress);
     412         [ #  # ]:           0 :         }));
     413                 :             :     }
     414                 :           0 :     std::unique_ptr<Handler> handleNotifyHeaderTip(NotifyHeaderTipFn fn) override
     415                 :             :     {
     416                 :           0 :         return MakeSignalHandler(
     417   [ #  #  #  #  :           0 :             ::uiInterface.NotifyHeaderTip_connect([fn](SynchronizationState sync_state, int64_t height, int64_t timestamp, bool presync) {
                   #  # ]
     418                 :           0 :                 fn(sync_state, BlockTip{(int)height, timestamp, uint256{}}, presync);
     419         [ #  # ]:           0 :             }));
     420                 :             :     }
     421                 :           0 :     NodeContext* context() override { return m_context; }
     422                 :           0 :     void setContext(NodeContext* context) override
     423                 :             :     {
     424                 :           0 :         m_context = context;
     425                 :           0 :     }
     426                 :           0 :     ArgsManager& args() { return *Assert(Assert(m_context)->args); }
     427                 :           0 :     ChainstateManager& chainman() { return *Assert(m_context->chainman); }
     428                 :             :     NodeContext* m_context{nullptr};
     429                 :             : };
     430                 :             : 
     431                 :             : // NOLINTNEXTLINE(misc-no-recursion)
     432                 :      244960 : bool FillBlock(const CBlockIndex* index, const FoundBlock& block, UniqueLock<RecursiveMutex>& lock, const CChain& active, const BlockManager& blockman) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
     433                 :             : {
     434         [ +  + ]:      244960 :     if (!index) return false;
     435         [ +  + ]:      243817 :     if (block.m_hash) *block.m_hash = index->GetBlockHash();
     436         [ +  + ]:      243817 :     if (block.m_height) *block.m_height = index->nHeight;
     437         [ +  + ]:      243817 :     if (block.m_time) *block.m_time = index->GetBlockTime();
     438         [ +  + ]:      243817 :     if (block.m_max_time) *block.m_max_time = index->GetBlockTimeMax();
     439         [ +  + ]:      243817 :     if (block.m_mtp_time) *block.m_mtp_time = index->GetMedianTimePast();
     440   [ +  +  +  - ]:      383818 :     if (block.m_in_active_chain) *block.m_in_active_chain = active[index->nHeight] == index;
     441         [ +  + ]:      243817 :     if (block.m_locator) { *block.m_locator = GetLocator(index); }
     442   [ +  +  +  -  :      377557 :     if (block.m_next_block) FillBlock(active[index->nHeight] == index ? active[index->nHeight + 1] : nullptr, *block.m_next_block, lock, active, blockman);
             +  -  +  - ]
     443         [ +  + ]:      243817 :     if (block.m_data) {
     444                 :       66328 :         REVERSE_LOCK(lock, cs_main);
     445   [ +  -  +  + ]:       66328 :         if (!blockman.ReadBlock(*block.m_data, *index)) block.m_data->SetNull();
     446                 :       66328 :     }
     447                 :      243817 :     block.found = true;
     448                 :      243817 :     return true;
     449                 :             : }
     450                 :             : 
     451                 :             : class NotificationsProxy : public CValidationInterface
     452                 :             : {
     453                 :             : public:
     454                 :         810 :     explicit NotificationsProxy(std::shared_ptr<Chain::Notifications> notifications)
     455                 :         810 :         : m_notifications(std::move(notifications)) {}
     456         [ +  - ]:         810 :     virtual ~NotificationsProxy() = default;
     457                 :        5043 :     void TransactionAddedToMempool(const NewMempoolTransactionInfo& tx, uint64_t mempool_sequence) override
     458                 :             :     {
     459                 :        5043 :         m_notifications->transactionAddedToMempool(tx.info.m_tx);
     460                 :        5043 :     }
     461                 :         224 :     void TransactionRemovedFromMempool(const CTransactionRef& tx, MemPoolRemovalReason reason, uint64_t mempool_sequence) override
     462                 :             :     {
     463                 :         224 :         m_notifications->transactionRemovedFromMempool(tx, reason);
     464                 :         224 :     }
     465                 :       40071 :     void BlockConnected(ChainstateRole role, const std::shared_ptr<const CBlock>& block, const CBlockIndex* index) override
     466                 :             :     {
     467                 :       40071 :         m_notifications->blockConnected(role, kernel::MakeBlockInfo(index, block.get()));
     468                 :       40071 :     }
     469                 :        3436 :     void BlockDisconnected(const std::shared_ptr<const CBlock>& block, const CBlockIndex* index) override
     470                 :             :     {
     471                 :        3436 :         m_notifications->blockDisconnected(kernel::MakeBlockInfo(index, block.get()));
     472                 :        3436 :     }
     473                 :       37848 :     void UpdatedBlockTip(const CBlockIndex* index, const CBlockIndex* fork_index, bool is_ibd) override
     474                 :             :     {
     475                 :       37848 :         m_notifications->updatedBlockTip();
     476                 :       37848 :     }
     477                 :         586 :     void ChainStateFlushed(ChainstateRole role, const CBlockLocator& locator) override {
     478                 :         586 :         m_notifications->chainStateFlushed(role, locator);
     479                 :         586 :     }
     480                 :             :     std::shared_ptr<Chain::Notifications> m_notifications;
     481                 :             : };
     482                 :             : 
     483                 :             : class NotificationsHandlerImpl : public Handler
     484                 :             : {
     485                 :             : public:
     486                 :         810 :     explicit NotificationsHandlerImpl(ValidationSignals& signals, std::shared_ptr<Chain::Notifications> notifications)
     487         [ +  - ]:         810 :         : m_signals{signals}, m_proxy{std::make_shared<NotificationsProxy>(std::move(notifications))}
     488                 :             :     {
     489   [ +  -  +  - ]:        1620 :         m_signals.RegisterSharedValidationInterface(m_proxy);
     490         [ -  - ]:         810 :     }
     491         [ -  + ]:        1620 :     ~NotificationsHandlerImpl() override { disconnect(); }
     492                 :         810 :     void disconnect() override
     493                 :             :     {
     494         [ +  - ]:         810 :         if (m_proxy) {
     495   [ +  -  +  - ]:        1620 :             m_signals.UnregisterSharedValidationInterface(m_proxy);
     496                 :         810 :             m_proxy.reset();
     497                 :             :         }
     498                 :         810 :     }
     499                 :             :     ValidationSignals& m_signals;
     500                 :             :     std::shared_ptr<NotificationsProxy> m_proxy;
     501                 :             : };
     502                 :             : 
     503                 :             : class RpcHandlerImpl : public Handler
     504                 :             : {
     505                 :             : public:
     506         [ +  - ]:       22971 :     explicit RpcHandlerImpl(const CRPCCommand& command) : m_command(command), m_wrapped_command(&command)
     507                 :             :     {
     508                 :       41880 :         m_command.actor = [this](const JSONRPCRequest& request, UniValue& result, bool last_handler) {
     509         [ +  - ]:       18909 :             if (!m_wrapped_command) return false;
     510                 :       18909 :             try {
     511         [ +  + ]:       18909 :                 return m_wrapped_command->actor(request, result, last_handler);
     512         [ -  + ]:         656 :             } catch (const UniValue& e) {
     513                 :             :                 // If this is not the last handler and a wallet not found
     514                 :             :                 // exception was thrown, return false so the next handler can
     515                 :             :                 // try to handle the request. Otherwise, reraise the exception.
     516         [ -  + ]:         656 :                 if (!last_handler) {
     517   [ -  -  -  - ]:           0 :                     const UniValue& code = e["code"];
     518   [ -  -  -  -  :           0 :                     if (code.isNum() && code.getInt<int>() == RPC_WALLET_NOT_FOUND) {
                   -  - ]
     519                 :           0 :                         return false;
     520                 :             :                     }
     521                 :             :                 }
     522                 :         656 :                 throw;
     523                 :         656 :             }
     524                 :       22971 :         };
     525         [ +  - ]:       22971 :         ::tableRPC.appendCommand(m_command.name, &m_command);
     526                 :       22971 :     }
     527                 :             : 
     528                 :       22971 :     void disconnect() final
     529                 :             :     {
     530         [ +  - ]:       22971 :         if (m_wrapped_command) {
     531                 :       22971 :             m_wrapped_command = nullptr;
     532                 :       22971 :             ::tableRPC.removeCommand(m_command.name, &m_command);
     533                 :             :         }
     534                 :       22971 :     }
     535                 :             : 
     536                 :       45942 :     ~RpcHandlerImpl() override { disconnect(); }
     537                 :             : 
     538                 :             :     CRPCCommand m_command;
     539                 :             :     const CRPCCommand* m_wrapped_command;
     540                 :             : };
     541                 :             : 
     542                 :             : class ChainImpl : public Chain
     543                 :             : {
     544                 :             : public:
     545                 :        1819 :     explicit ChainImpl(NodeContext& node) : m_node(node) {}
     546                 :        2088 :     std::optional<int> getHeight() override
     547                 :             :     {
     548   [ +  -  +  -  :        6264 :         const int height{WITH_LOCK(::cs_main, return chainman().ActiveChain().Height())};
                   +  - ]
     549         [ +  + ]:        2088 :         return height >= 0 ? std::optional{height} : std::nullopt;
     550                 :             :     }
     551                 :        2169 :     uint256 getBlockHash(int height) override
     552                 :             :     {
     553                 :        2169 :         LOCK(::cs_main);
     554   [ +  -  +  -  :        4338 :         return Assert(chainman().ActiveChain()[height])->GetBlockHash();
          +  -  +  -  +  
                      - ]
     555                 :        2169 :     }
     556                 :         705 :     bool haveBlockOnDisk(int height) override
     557                 :             :     {
     558                 :         705 :         LOCK(::cs_main);
     559   [ +  -  +  -  :         706 :         const CBlockIndex* block{chainman().ActiveChain()[height]};
                   +  - ]
     560   [ +  -  +  +  :         706 :         return block && ((block->nStatus & BLOCK_HAVE_DATA) != 0) && block->nTx > 0;
             -  +  +  - ]
     561                 :         705 :     }
     562                 :           0 :     CBlockLocator getTipLocator() override
     563                 :             :     {
     564                 :           0 :         LOCK(::cs_main);
     565   [ #  #  #  #  :           0 :         return chainman().ActiveChain().GetLocator();
                   #  # ]
     566                 :           0 :     }
     567                 :           2 :     CBlockLocator getActiveChainLocator(const uint256& block_hash) override
     568                 :             :     {
     569                 :           2 :         LOCK(::cs_main);
     570   [ +  -  +  - ]:           2 :         const CBlockIndex* index = chainman().m_blockman.LookupBlockIndex(block_hash);
     571         [ +  - ]:           2 :         return GetLocator(index);
     572                 :           2 :     }
     573                 :         792 :     std::optional<int> findLocatorFork(const CBlockLocator& locator) override
     574                 :             :     {
     575                 :         792 :         LOCK(::cs_main);
     576   [ +  -  +  -  :         792 :         if (const CBlockIndex* fork = chainman().ActiveChainstate().FindForkInGlobalIndex(locator)) {
             +  -  +  + ]
     577                 :         784 :             return fork->nHeight;
     578                 :             :         }
     579                 :           8 :         return std::nullopt;
     580                 :         792 :     }
     581                 :         605 :     bool hasBlockFilterIndex(BlockFilterType filter_type) override
     582                 :             :     {
     583                 :         605 :         return GetBlockFilterIndex(filter_type) != nullptr;
     584                 :             :     }
     585                 :         616 :     std::optional<bool> blockFilterMatchesAny(BlockFilterType filter_type, const uint256& block_hash, const GCSFilter::ElementSet& filter_set) override
     586                 :             :     {
     587                 :         616 :         const BlockFilterIndex* block_filter_index{GetBlockFilterIndex(filter_type)};
     588         [ -  + ]:         616 :         if (!block_filter_index) return std::nullopt;
     589                 :             : 
     590                 :         616 :         BlockFilter filter;
     591   [ +  -  +  -  :        1848 :         const CBlockIndex* index{WITH_LOCK(::cs_main, return chainman().m_blockman.LookupBlockIndex(block_hash))};
             +  -  +  - ]
     592   [ +  -  +  -  :         616 :         if (index == nullptr || !block_filter_index->LookupFilter(index, filter)) return std::nullopt;
                   -  + ]
     593         [ +  - ]:         616 :         return filter.GetFilter().MatchAny(filter_set);
     594                 :         616 :     }
     595                 :      177387 :     bool findBlock(const uint256& hash, const FoundBlock& block) override
     596                 :             :     {
     597                 :      177387 :         WAIT_LOCK(cs_main, lock);
     598   [ +  -  +  -  :      177387 :         return FillBlock(chainman().m_blockman.LookupBlockIndex(hash), block, lock, chainman().ActiveChain(), chainman().m_blockman);
          +  -  +  -  +  
             -  +  -  +  
                      - ]
     599                 :      177387 :     }
     600                 :         592 :     bool findFirstBlockWithTimeAndHeight(int64_t min_time, int min_height, const FoundBlock& block) override
     601                 :             :     {
     602                 :         592 :         WAIT_LOCK(cs_main, lock);
     603   [ +  -  +  - ]:         592 :         const CChain& active = chainman().ActiveChain();
     604   [ +  -  +  -  :         592 :         return FillBlock(active.FindEarliestAtLeast(min_time, min_height), block, lock, active, chainman().m_blockman);
             +  -  +  - ]
     605                 :         592 :     }
     606                 :          38 :     bool findAncestorByHeight(const uint256& block_hash, int ancestor_height, const FoundBlock& ancestor_out) override
     607                 :             :     {
     608                 :          38 :         WAIT_LOCK(cs_main, lock);
     609   [ +  -  +  - ]:          38 :         const CChain& active = chainman().ActiveChain();
     610   [ +  -  +  -  :          38 :         if (const CBlockIndex* block = chainman().m_blockman.LookupBlockIndex(block_hash)) {
                   +  - ]
     611   [ +  -  +  + ]:          38 :             if (const CBlockIndex* ancestor = block->GetAncestor(ancestor_height)) {
     612   [ +  -  +  - ]:          37 :                 return FillBlock(ancestor, ancestor_out, lock, active, chainman().m_blockman);
     613                 :             :             }
     614                 :             :         }
     615   [ +  -  +  - ]:           1 :         return FillBlock(nullptr, ancestor_out, lock, active, chainman().m_blockman);
     616                 :          38 :     }
     617                 :           7 :     bool findAncestorByHash(const uint256& block_hash, const uint256& ancestor_hash, const FoundBlock& ancestor_out) override
     618                 :             :     {
     619                 :           7 :         WAIT_LOCK(cs_main, lock);
     620   [ +  -  +  - ]:           7 :         const CBlockIndex* block = chainman().m_blockman.LookupBlockIndex(block_hash);
     621   [ +  -  +  - ]:           7 :         const CBlockIndex* ancestor = chainman().m_blockman.LookupBlockIndex(ancestor_hash);
     622   [ +  +  +  -  :           7 :         if (block && ancestor && block->GetAncestor(ancestor->nHeight) != ancestor) ancestor = nullptr;
                   +  + ]
     623   [ +  -  +  -  :           7 :         return FillBlock(ancestor, ancestor_out, lock, chainman().ActiveChain(), chainman().m_blockman);
          +  -  +  -  +  
                      - ]
     624                 :           7 :     }
     625                 :          22 :     bool findCommonAncestor(const uint256& block_hash1, const uint256& block_hash2, const FoundBlock& ancestor_out, const FoundBlock& block1_out, const FoundBlock& block2_out) override
     626                 :             :     {
     627                 :          22 :         WAIT_LOCK(cs_main, lock);
     628   [ +  -  +  - ]:          22 :         const CChain& active = chainman().ActiveChain();
     629   [ +  -  +  - ]:          22 :         const CBlockIndex* block1 = chainman().m_blockman.LookupBlockIndex(block_hash1);
     630   [ +  -  +  - ]:          22 :         const CBlockIndex* block2 = chainman().m_blockman.LookupBlockIndex(block_hash2);
     631   [ +  +  +  - ]:          22 :         const CBlockIndex* ancestor = block1 && block2 ? LastCommonAncestor(block1, block2) : nullptr;
     632                 :             :         // Using & instead of && below to avoid short circuiting and leaving
     633                 :             :         // output uninitialized. Cast bool to int to avoid -Wbitwise-instead-of-logical
     634                 :             :         // compiler warnings.
     635   [ +  -  +  - ]:          22 :         return int{FillBlock(ancestor, ancestor_out, lock, active, chainman().m_blockman)} &
     636   [ +  -  +  - ]:          22 :                int{FillBlock(block1, block1_out, lock, active, chainman().m_blockman)} &
     637   [ +  -  +  -  :          22 :                int{FillBlock(block2, block2_out, lock, active, chainman().m_blockman)};
                   +  - ]
     638                 :          22 :     }
     639                 :         891 :     void findCoins(std::map<COutPoint, Coin>& coins) override { return FindCoins(m_node, coins); }
     640                 :       67474 :     double guessVerificationProgress(const uint256& block_hash) override
     641                 :             :     {
     642                 :       67474 :         LOCK(chainman().GetMutex());
     643   [ +  -  +  -  :       67474 :         return chainman().GuessVerificationProgress(chainman().m_blockman.LookupBlockIndex(block_hash));
          +  -  +  -  +  
                      - ]
     644                 :       67474 :     }
     645                 :          33 :     bool hasBlocks(const uint256& block_hash, int min_height, std::optional<int> max_height) override
     646                 :             :     {
     647                 :             :         // hasBlocks returns true if all ancestors of block_hash in specified
     648                 :             :         // range have block data (are not pruned), false if any ancestors in
     649                 :             :         // specified range are missing data.
     650                 :             :         //
     651                 :             :         // For simplicity and robustness, min_height and max_height are only
     652                 :             :         // used to limit the range, and passing min_height that's too low or
     653                 :             :         // max_height that's too high will not crash or change the result.
     654                 :          33 :         LOCK(::cs_main);
     655   [ +  -  +  -  :          33 :         if (const CBlockIndex* block = chainman().m_blockman.LookupBlockIndex(block_hash)) {
                   +  - ]
     656   [ +  +  +  +  :          33 :             if (max_height && block->nHeight >= *max_height) block = block->GetAncestor(*max_height);
                   +  - ]
     657         [ +  + ]:        2974 :             for (; block->nStatus & BLOCK_HAVE_DATA; block = block->pprev) {
     658                 :             :                 // Check pprev to not segfault if min_height is too low
     659   [ +  +  +  + ]:        2958 :                 if (block->nHeight <= min_height || !block->pprev) return true;
     660                 :             :             }
     661                 :             :         }
     662                 :             :         return false;
     663                 :          33 :     }
     664                 :         657 :     RBFTransactionState isRBFOptIn(const CTransaction& tx) override
     665                 :             :     {
     666         [ -  + ]:         657 :         if (!m_node.mempool) return IsRBFOptInEmptyMempool(tx);
     667                 :         657 :         LOCK(m_node.mempool->cs);
     668   [ +  -  +  - ]:         657 :         return IsRBFOptIn(tx, *m_node.mempool);
     669                 :         657 :     }
     670                 :       17890 :     bool isInMempool(const Txid& txid) override
     671                 :             :     {
     672         [ +  - ]:       17890 :         if (!m_node.mempool) return false;
     673                 :       17890 :         LOCK(m_node.mempool->cs);
     674   [ +  -  +  - ]:       17890 :         return m_node.mempool->exists(txid);
     675                 :       17890 :     }
     676                 :         223 :     bool hasDescendantsInMempool(const uint256& txid) override
     677                 :             :     {
     678         [ +  - ]:         223 :         if (!m_node.mempool) return false;
     679                 :         223 :         LOCK(m_node.mempool->cs);
     680         [ +  - ]:         223 :         const auto entry{m_node.mempool->GetEntry(Txid::FromUint256(txid))};
     681         [ +  + ]:         223 :         if (entry == nullptr) return false;
     682                 :         222 :         return entry->GetCountWithDescendants() > 1;
     683                 :         223 :     }
     684                 :        1591 :     bool broadcastTransaction(const CTransactionRef& tx,
     685                 :             :         const CAmount& max_tx_fee,
     686                 :             :         bool relay,
     687                 :             :         std::string& err_string) override
     688                 :             :     {
     689   [ +  -  +  -  :        3182 :         const TransactionError err = BroadcastTransaction(m_node, tx, err_string, max_tx_fee, relay, /*wait_callback=*/false);
                   +  - ]
     690                 :             :         // Chain clients only care about failures to accept the tx to the mempool. Disregard non-mempool related failures.
     691                 :             :         // Note: this will need to be updated if BroadcastTransactions() is updated to return other non-mempool failures
     692                 :             :         // that Chain clients do not need to know about.
     693                 :        1591 :         return TransactionError::OK == err;
     694                 :             :     }
     695                 :      578623 :     void getTransactionAncestry(const uint256& txid, size_t& ancestors, size_t& descendants, size_t* ancestorsize, CAmount* ancestorfees) override
     696                 :             :     {
     697                 :      578623 :         ancestors = descendants = 0;
     698         [ +  - ]:      578623 :         if (!m_node.mempool) return;
     699                 :      578623 :         m_node.mempool->GetTransactionAncestry(txid, ancestors, descendants, ancestorsize, ancestorfees);
     700                 :             :     }
     701                 :             : 
     702                 :        3819 :     std::map<COutPoint, CAmount> calculateIndividualBumpFees(const std::vector<COutPoint>& outpoints, const CFeeRate& target_feerate) override
     703                 :             :     {
     704         [ -  + ]:        3819 :         if (!m_node.mempool) {
     705                 :           0 :             std::map<COutPoint, CAmount> bump_fees;
     706         [ #  # ]:           0 :             for (const auto& outpoint : outpoints) {
     707         [ #  # ]:           0 :                 bump_fees.emplace(outpoint, 0);
     708                 :             :             }
     709                 :             :             return bump_fees;
     710                 :           0 :         }
     711         [ +  - ]:        3819 :         return MiniMiner(*m_node.mempool, outpoints).CalculateBumpFees(target_feerate);
     712                 :             :     }
     713                 :             : 
     714                 :        8744 :     std::optional<CAmount> calculateCombinedBumpFee(const std::vector<COutPoint>& outpoints, const CFeeRate& target_feerate) override
     715                 :             :     {
     716         [ -  + ]:        8744 :         if (!m_node.mempool) {
     717                 :           0 :             return 0;
     718                 :             :         }
     719         [ +  - ]:        8744 :         return MiniMiner(*m_node.mempool, outpoints).CalculateTotalBumpFees(target_feerate);
     720                 :             :     }
     721                 :        3098 :     void getPackageLimits(unsigned int& limit_ancestor_count, unsigned int& limit_descendant_count) override
     722                 :             :     {
     723                 :        3098 :         const CTxMemPool::Limits default_limits{};
     724                 :             : 
     725         [ +  - ]:        3098 :         const CTxMemPool::Limits& limits{m_node.mempool ? m_node.mempool->m_opts.limits : default_limits};
     726                 :             : 
     727                 :        3098 :         limit_ancestor_count = limits.ancestor_count;
     728                 :        3098 :         limit_descendant_count = limits.descendant_count;
     729                 :        3098 :     }
     730                 :        3247 :     util::Result<void> checkChainLimits(const CTransactionRef& tx) override
     731                 :             :     {
     732         [ -  + ]:        3247 :         if (!m_node.mempool) return {};
     733                 :        3247 :         LockPoints lp;
     734                 :        3247 :         CTxMemPoolEntry entry(tx, 0, 0, 0, 0, false, 0, lp);
     735         [ +  - ]:        3247 :         LOCK(m_node.mempool->cs);
     736   [ +  -  +  -  :        9741 :         return m_node.mempool->CheckPackageLimits({tx}, entry.GetTxSize());
          +  +  +  -  -  
                -  -  - ]
     737   [ +  -  +  - ]:        9741 :     }
     738                 :        5904 :     CFeeRate estimateSmartFee(int num_blocks, bool conservative, FeeCalculation* calc) override
     739                 :             :     {
     740         [ +  + ]:        5904 :         if (!m_node.fee_estimator) return {};
     741                 :        5882 :         return m_node.fee_estimator->estimateSmartFee(num_blocks, calc, conservative);
     742                 :             :     }
     743                 :        3432 :     unsigned int estimateMaxBlocks() override
     744                 :             :     {
     745         [ +  + ]:        3432 :         if (!m_node.fee_estimator) return 0;
     746                 :        3417 :         return m_node.fee_estimator->HighestTargetTracked(FeeEstimateHorizon::LONG_HALFLIFE);
     747                 :             :     }
     748                 :        2526 :     CFeeRate mempoolMinFee() override
     749                 :             :     {
     750         [ -  + ]:        2526 :         if (!m_node.mempool) return {};
     751                 :        2526 :         return m_node.mempool->GetMinFee();
     752                 :             :     }
     753                 :        4148 :     CFeeRate relayMinFee() override
     754                 :             :     {
     755         [ -  + ]:        4148 :         if (!m_node.mempool) return CFeeRate{DEFAULT_MIN_RELAY_TX_FEE};
     756                 :        4148 :         return m_node.mempool->m_opts.min_relay_feerate;
     757                 :             :     }
     758                 :         121 :     CFeeRate relayIncrementalFee() override
     759                 :             :     {
     760         [ -  + ]:         121 :         if (!m_node.mempool) return CFeeRate{DEFAULT_INCREMENTAL_RELAY_FEE};
     761                 :         121 :         return m_node.mempool->m_opts.incremental_relay_feerate;
     762                 :             :     }
     763                 :       44070 :     CFeeRate relayDustFee() override
     764                 :             :     {
     765         [ -  + ]:       44070 :         if (!m_node.mempool) return CFeeRate{DUST_RELAY_TX_FEE};
     766                 :       44070 :         return m_node.mempool->m_opts.dust_relay_feerate;
     767                 :             :     }
     768                 :          59 :     bool havePruned() override
     769                 :             :     {
     770                 :          59 :         LOCK(::cs_main);
     771   [ +  -  +  - ]:          59 :         return chainman().m_blockman.m_have_pruned;
     772                 :          59 :     }
     773                 :           1 :     std::optional<int> getPruneHeight() override
     774                 :             :     {
     775                 :           1 :         LOCK(chainman().GetMutex());
     776   [ +  -  +  -  :           1 :         return GetPruneHeight(chainman().m_blockman, chainman().ActiveChain());
             +  -  +  - ]
     777                 :           1 :     }
     778   [ +  -  +  + ]:         112 :     bool isReadyToBroadcast() override { return !chainman().m_blockman.LoadingBlocks() && !isInitialBlockDownload(); }
     779                 :        2918 :     bool isInitialBlockDownload() override
     780                 :             :     {
     781                 :        2918 :         return chainman().IsInitialBlockDownload();
     782                 :             :     }
     783                 :       67271 :     bool shutdownRequested() override { return ShutdownRequested(m_node); }
     784                 :        1228 :     void initMessage(const std::string& message) override { ::uiInterface.InitMessage(message); }
     785                 :           4 :     void initWarning(const bilingual_str& message) override { InitWarning(message); }
     786                 :          26 :     void initError(const bilingual_str& message) override { InitError(message); }
     787                 :           0 :     void showProgress(const std::string& title, int progress, bool resume_possible) override
     788                 :             :     {
     789                 :           0 :         ::uiInterface.ShowProgress(title, progress, resume_possible);
     790                 :           0 :     }
     791                 :         810 :     std::unique_ptr<Handler> handleNotifications(std::shared_ptr<Notifications> notifications) override
     792                 :             :     {
     793                 :         810 :         return std::make_unique<NotificationsHandlerImpl>(validation_signals(), std::move(notifications));
     794                 :             :     }
     795                 :        5822 :     void waitForNotificationsIfTipChanged(const uint256& old_tip) override
     796                 :             :     {
     797   [ +  +  +  +  :       23276 :         if (!old_tip.IsNull() && old_tip == WITH_LOCK(::cs_main, return chainman().ActiveChain().Tip()->GetBlockHash())) return;
          +  -  +  -  +  
                -  +  - ]
     798                 :         176 :         validation_signals().SyncWithValidationInterfaceQueue();
     799                 :             :     }
     800                 :       22971 :     std::unique_ptr<Handler> handleRpc(const CRPCCommand& command) override
     801                 :             :     {
     802                 :       22971 :         return std::make_unique<RpcHandlerImpl>(command);
     803                 :             :     }
     804                 :          19 :     bool rpcEnableDeprecated(const std::string& method) override { return IsDeprecatedRPCEnabled(method); }
     805                 :           0 :     common::SettingsValue getSetting(const std::string& name) override
     806                 :             :     {
     807                 :           0 :         return args().GetSetting(name);
     808                 :             :     }
     809                 :         718 :     std::vector<common::SettingsValue> getSettingsList(const std::string& name) override
     810                 :             :     {
     811                 :         718 :         return args().GetSettingsList(name);
     812                 :             :     }
     813                 :           3 :     common::SettingsValue getRwSetting(const std::string& name) override
     814                 :             :     {
     815         [ +  - ]:           3 :         common::SettingsValue result;
     816   [ +  -  +  - ]:           3 :         args().LockSettings([&](const common::Settings& settings) {
     817         [ +  + ]:           3 :             if (const common::SettingsValue* value = common::FindKey(settings.rw_settings, name)) {
     818                 :           2 :                 result = *value;
     819                 :             :             }
     820                 :           3 :         });
     821                 :           3 :         return result;
     822                 :           0 :     }
     823                 :         196 :     bool updateRwSetting(const std::string& name,
     824                 :             :                          const interfaces::SettingsUpdate& update_settings_func) override
     825                 :             :     {
     826                 :         196 :         std::optional<interfaces::SettingsAction> action;
     827                 :         196 :         args().LockSettings([&](common::Settings& settings) {
     828         [ +  + ]:         196 :             if (auto* value = common::FindKey(settings.rw_settings, name)) {
     829                 :          45 :                 action = update_settings_func(*value);
     830         [ -  + ]:          45 :                 if (value->isNull()) settings.rw_settings.erase(name);
     831                 :             :             } else {
     832         [ +  - ]:         151 :                 UniValue new_value;
     833         [ +  - ]:         151 :                 action = update_settings_func(new_value);
     834   [ +  +  +  - ]:         151 :                 if (!new_value.isNull()) settings.rw_settings[name] = std::move(new_value);
     835                 :         151 :             }
     836                 :         196 :         });
     837         [ +  - ]:         196 :         if (!action) return false;
     838                 :             :         // Now dump value to disk if requested
     839   [ +  +  +  - ]:         196 :         return *action != interfaces::SettingsAction::WRITE || args().WriteSettingsFile();
     840                 :             :     }
     841                 :           1 :     bool overwriteRwSetting(const std::string& name, common::SettingsValue value, interfaces::SettingsAction action) override
     842                 :             :     {
     843         [ +  - ]:           1 :         return updateRwSetting(name, [&](common::SettingsValue& settings) {
     844                 :           1 :             settings = std::move(value);
     845                 :           1 :             return action;
     846                 :           1 :         });
     847                 :             :     }
     848                 :           0 :     bool deleteRwSettings(const std::string& name, interfaces::SettingsAction action) override
     849                 :             :     {
     850         [ #  # ]:           0 :         return overwriteRwSetting(name, {}, action);
     851                 :             :     }
     852                 :        1396 :     void requestMempoolTransactions(Notifications& notifications) override
     853                 :             :     {
     854         [ +  - ]:        1396 :         if (!m_node.mempool) return;
     855         [ +  - ]:        1396 :         LOCK2(::cs_main, m_node.mempool->cs);
     856   [ +  -  +  -  :        1732 :         for (const CTxMemPoolEntry& entry : m_node.mempool->entryAll()) {
                   +  + ]
     857   [ +  -  +  - ]:        1008 :             notifications.transactionAddedToMempool(entry.GetSharedTx());
     858         [ +  - ]:        1396 :         }
     859         [ +  - ]:        2792 :     }
     860                 :          56 :     bool hasAssumedValidChain() override
     861                 :             :     {
     862                 :          56 :         return chainman().IsSnapshotActive();
     863                 :             :     }
     864                 :             : 
     865                 :         807 :     NodeContext* context() override { return &m_node; }
     866                 :        1106 :     ArgsManager& args() { return *Assert(m_node.args); }
     867                 :      751412 :     ChainstateManager& chainman() { return *Assert(m_node.chainman); }
     868                 :         986 :     ValidationSignals& validation_signals() { return *Assert(m_node.validation_signals); }
     869                 :             :     NodeContext& m_node;
     870                 :             : };
     871                 :             : 
     872                 :             : class BlockTemplateImpl : public BlockTemplate
     873                 :             : {
     874                 :             : public:
     875                 :       38781 :     explicit BlockTemplateImpl(BlockAssembler::Options assemble_options,
     876                 :             :                                std::unique_ptr<CBlockTemplate> block_template,
     877                 :       38781 :                                NodeContext& node) : m_assemble_options(std::move(assemble_options)),
     878         [ -  + ]:       38781 :                                                     m_block_template(std::move(block_template)),
     879                 :       38781 :                                                     m_node(node)
     880                 :             :     {
     881         [ -  + ]:       38781 :         assert(m_block_template);
     882                 :       38781 :     }
     883                 :             : 
     884                 :           1 :     CBlockHeader getBlockHeader() override
     885                 :             :     {
     886                 :           1 :         return m_block_template->block;
     887                 :             :     }
     888                 :             : 
     889                 :       40783 :     CBlock getBlock() override
     890                 :             :     {
     891                 :       40783 :         return m_block_template->block;
     892                 :             :     }
     893                 :             : 
     894                 :        2075 :     std::vector<CAmount> getTxFees() override
     895                 :             :     {
     896                 :        2075 :         return m_block_template->vTxFees;
     897                 :             :     }
     898                 :             : 
     899                 :        2075 :     std::vector<int64_t> getTxSigops() override
     900                 :             :     {
     901                 :        2075 :         return m_block_template->vTxSigOpsCost;
     902                 :             :     }
     903                 :             : 
     904                 :           0 :     CTransactionRef getCoinbaseTx() override
     905                 :             :     {
     906         [ #  # ]:           0 :         return m_block_template->block.vtx[0];
     907                 :             :     }
     908                 :             : 
     909                 :        4150 :     std::vector<unsigned char> getCoinbaseCommitment() override
     910                 :             :     {
     911                 :        4150 :         return m_block_template->vchCoinbaseCommitment;
     912                 :             :     }
     913                 :             : 
     914                 :           0 :     int getWitnessCommitmentIndex() override
     915                 :             :     {
     916                 :           0 :         return GetWitnessCommitmentIndex(m_block_template->block);
     917                 :             :     }
     918                 :             : 
     919                 :           0 :     std::vector<uint256> getCoinbaseMerklePath() override
     920                 :             :     {
     921                 :           0 :         return TransactionMerklePath(m_block_template->block, 0);
     922                 :             :     }
     923                 :             : 
     924                 :          55 :     bool submitSolution(uint32_t version, uint32_t timestamp, uint32_t nonce, CTransactionRef coinbase) override
     925                 :             :     {
     926         [ +  - ]:          55 :         AddMerkleRootAndCoinbase(m_block_template->block, std::move(coinbase), version, timestamp, nonce);
     927   [ +  -  +  - ]:         110 :         return chainman().ProcessNewBlock(std::make_shared<const CBlock>(m_block_template->block), /*force_processing=*/true, /*min_pow_checked=*/true, /*new_block=*/nullptr);
     928                 :             :     }
     929                 :             : 
     930                 :          60 :     std::unique_ptr<BlockTemplate> waitNext(BlockWaitOptions options) override
     931                 :             :     {
     932                 :          60 :         auto new_template = WaitAndCreateNewBlock(chainman(), notifications(), m_node.mempool.get(), m_block_template, options, m_assemble_options);
     933   [ +  +  +  - ]:          60 :         if (new_template) return std::make_unique<BlockTemplateImpl>(m_assemble_options, std::move(new_template), m_node);
     934                 :           3 :         return nullptr;
     935                 :          60 :     }
     936                 :             : 
     937                 :             :     const BlockAssembler::Options m_assemble_options;
     938                 :             : 
     939                 :             :     const std::unique_ptr<CBlockTemplate> m_block_template;
     940                 :             : 
     941                 :         115 :     ChainstateManager& chainman() { return *Assert(m_node.chainman); }
     942                 :          60 :     KernelNotifications& notifications() { return *Assert(m_node.notifications); }
     943                 :             :     NodeContext& m_node;
     944                 :             : };
     945                 :             : 
     946                 :             : class MinerImpl : public Mining
     947                 :             : {
     948                 :             : public:
     949                 :        1072 :     explicit MinerImpl(NodeContext& node) : m_node(node) {}
     950                 :             : 
     951                 :        2076 :     bool isTestChain() override
     952                 :             :     {
     953                 :        2076 :         return chainman().GetParams().IsTestChain();
     954                 :             :     }
     955                 :             : 
     956                 :           0 :     bool isInitialBlockDownload() override
     957                 :             :     {
     958                 :           0 :         return chainman().IsInitialBlockDownload();
     959                 :             :     }
     960                 :             : 
     961                 :        2531 :     std::optional<BlockRef> getTip() override
     962                 :             :     {
     963                 :        2531 :         return GetTip(chainman());
     964                 :             :     }
     965                 :             : 
     966                 :       38807 :     std::optional<BlockRef> waitTipChanged(uint256 current_tip, MillisecondsDouble timeout) override
     967                 :             :     {
     968                 :       38807 :         return WaitTipChanged(chainman(), notifications(), current_tip, timeout);
     969                 :             :     }
     970                 :             : 
     971                 :       38729 :     std::unique_ptr<BlockTemplate> createNewBlock(const BlockCreateOptions& options) override
     972                 :             :     {
     973                 :             :         // Ensure m_tip_block is set so consumers of BlockTemplate can rely on that.
     974         [ -  + ]:       38729 :         if (!waitTipChanged(uint256::ZERO, MillisecondsDouble::max())) return {};
     975                 :             : 
     976         [ +  - ]:       38729 :         BlockAssembler::Options assemble_options{options};
     977   [ +  -  +  - ]:       38729 :         ApplyArgsManOptions(*Assert(m_node.args), assemble_options);
     978   [ +  -  +  -  :       38729 :         return std::make_unique<BlockTemplateImpl>(assemble_options, BlockAssembler{chainman().ActiveChainstate(), context()->mempool.get(), assemble_options}.CreateNewBlock(), m_node);
          +  -  +  -  +  
                +  +  - ]
     979                 :       38724 :     }
     980                 :             : 
     981                 :           3 :     bool checkBlock(const CBlock& block, const node::BlockCheckOptions& options, std::string& reason, std::string& debug) override
     982                 :             :     {
     983                 :           3 :         LOCK(chainman().GetMutex());
     984   [ +  -  +  -  :           3 :         BlockValidationState state{TestBlockValidity(chainman().ActiveChainstate(), block, /*check_pow=*/options.check_pow, /*=check_merkle_root=*/options.check_merkle_root)};
                   +  - ]
     985         [ +  - ]:           3 :         reason = state.GetRejectReason();
     986         [ +  - ]:           3 :         debug = state.GetDebugMessage();
     987                 :           3 :         return state.IsValid();
     988         [ +  - ]:           6 :     }
     989                 :             : 
     990                 :       38729 :     NodeContext* context() override { return &m_node; }
     991                 :       82149 :     ChainstateManager& chainman() { return *Assert(m_node.chainman); }
     992                 :       38807 :     KernelNotifications& notifications() { return *Assert(m_node.notifications); }
     993                 :             :     NodeContext& m_node;
     994                 :             : };
     995                 :             : } // namespace
     996                 :             : } // namespace node
     997                 :             : 
     998                 :             : namespace interfaces {
     999                 :           0 : std::unique_ptr<Node> MakeNode(node::NodeContext& context) { return std::make_unique<node::NodeImpl>(context); }
    1000                 :        1819 : std::unique_ptr<Chain> MakeChain(node::NodeContext& context) { return std::make_unique<node::ChainImpl>(context); }
    1001                 :        1072 : std::unique_ptr<Mining> MakeMining(node::NodeContext& context) { return std::make_unique<node::MinerImpl>(context); }
    1002                 :             : } // namespace interfaces
        

Generated by: LCOV version 2.0-1