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/protocol.h>
50 : : #include <rpc/server.h>
51 : : #include <support/allocators/secure.h>
52 : : #include <sync.h>
53 : : #include <txmempool.h>
54 : : #include <uint256.h>
55 : : #include <univalue.h>
56 : : #include <util/check.h>
57 : : #include <util/result.h>
58 : : #include <util/signalinterrupt.h>
59 : : #include <util/string.h>
60 : : #include <util/translation.h>
61 : : #include <validation.h>
62 : : #include <validationinterface.h>
63 : :
64 : : #include <bitcoin-build-config.h> // IWYU pragma: keep
65 : :
66 : : #include <any>
67 : : #include <memory>
68 : : #include <optional>
69 : : #include <utility>
70 : :
71 : : #include <boost/signals2/signal.hpp>
72 : :
73 : : using interfaces::BlockRef;
74 : : using interfaces::BlockTemplate;
75 : : using interfaces::BlockTip;
76 : : using interfaces::Chain;
77 : : using interfaces::FoundBlock;
78 : : using interfaces::Handler;
79 : : using interfaces::MakeSignalHandler;
80 : : using interfaces::Mining;
81 : : using interfaces::Node;
82 : : using interfaces::WalletLoader;
83 : : using node::BlockAssembler;
84 : : using util::Join;
85 : :
86 : : namespace node {
87 : : // All members of the classes in this namespace are intentionally public, as the
88 : : // classes themselves are private.
89 : : namespace {
90 : : #ifdef ENABLE_EXTERNAL_SIGNER
91 : : class ExternalSignerImpl : public interfaces::ExternalSigner
92 : : {
93 : : public:
94 : 0 : ExternalSignerImpl(::ExternalSigner signer) : m_signer(std::move(signer)) {}
95 : 0 : std::string getName() override { return m_signer.m_name; }
96 : : ::ExternalSigner m_signer;
97 : : };
98 : : #endif
99 : :
100 : : class NodeImpl : public Node
101 : : {
102 : : public:
103 : 0 : explicit NodeImpl(NodeContext& context) { setContext(&context); }
104 : 0 : void initLogging() override { InitLogging(args()); }
105 : 0 : void initParameterInteraction() override { InitParameterInteraction(args()); }
106 [ # # # # : 0 : bilingual_str getWarnings() override { return Join(Assert(m_context->warnings)->GetMessages(), Untranslated("<hr />")); }
# # # # ]
107 : 0 : int getExitStatus() override { return Assert(m_context)->exit_status.load(); }
108 : 0 : BCLog::CategoryMask getLogCategories() override { return LogInstance().GetCategoryMask(); }
109 : 0 : bool baseInitialize() override
110 : : {
111 [ # # ]: 0 : if (!AppInitBasicSetup(args(), Assert(context())->exit_status)) return false;
112 [ # # ]: 0 : if (!AppInitParameterInteraction(args())) return false;
113 : :
114 : 0 : m_context->warnings = std::make_unique<node::Warnings>();
115 : 0 : m_context->kernel = std::make_unique<kernel::Context>();
116 : 0 : m_context->ecc_context = std::make_unique<ECC_Context>();
117 [ # # ]: 0 : if (!AppInitSanityChecks(*m_context->kernel)) return false;
118 : :
119 [ # # ]: 0 : if (!AppInitLockDataDirectory()) return false;
120 [ # # ]: 0 : if (!AppInitInterfaces(*m_context)) return false;
121 : :
122 : : return true;
123 : : }
124 : 0 : bool appInitMain(interfaces::BlockAndHeaderTipInfo* tip_info) override
125 : : {
126 [ # # ]: 0 : if (AppInitMain(*m_context, tip_info)) return true;
127 : : // Error during initialization, set exit status before continue
128 : 0 : m_context->exit_status.store(EXIT_FAILURE);
129 : 0 : return false;
130 : : }
131 : 0 : void appShutdown() override
132 : : {
133 : 0 : Interrupt(*m_context);
134 : 0 : Shutdown(*m_context);
135 : 0 : }
136 : 0 : void startShutdown() override
137 : : {
138 : 0 : NodeContext& ctx{*Assert(m_context)};
139 [ # # ]: 0 : if (!(Assert(ctx.shutdown_request))()) {
140 : 0 : LogError("Failed to send shutdown signal\n");
141 : : }
142 : :
143 : : // Stop RPC for clean shutdown if any of waitfor* commands is executed.
144 [ # # # # ]: 0 : if (args().GetBoolArg("-server", false)) {
145 : 0 : InterruptRPC();
146 : 0 : StopRPC();
147 : : }
148 : 0 : }
149 : 0 : bool shutdownRequested() override { return ShutdownRequested(*Assert(m_context)); };
150 : 0 : bool isSettingIgnored(const std::string& name) override
151 : : {
152 : 0 : bool ignored = false;
153 : 0 : args().LockSettings([&](common::Settings& settings) {
154 [ # # ]: 0 : if (auto* options = common::FindKey(settings.command_line_options, name)) {
155 : 0 : ignored = !options->empty();
156 : : }
157 : 0 : });
158 : 0 : return ignored;
159 : : }
160 : 0 : common::SettingsValue getPersistentSetting(const std::string& name) override { return args().GetPersistentSetting(name); }
161 : 0 : void updateRwSetting(const std::string& name, const common::SettingsValue& value) override
162 : : {
163 : 0 : args().LockSettings([&](common::Settings& settings) {
164 [ # # ]: 0 : if (value.isNull()) {
165 : 0 : settings.rw_settings.erase(name);
166 : : } else {
167 : 0 : settings.rw_settings[name] = value;
168 : : }
169 : 0 : });
170 : 0 : args().WriteSettingsFile();
171 : 0 : }
172 : 0 : void forceSetting(const std::string& name, const common::SettingsValue& value) override
173 : : {
174 : 0 : args().LockSettings([&](common::Settings& settings) {
175 [ # # ]: 0 : if (value.isNull()) {
176 : 0 : settings.forced_settings.erase(name);
177 : : } else {
178 : 0 : settings.forced_settings[name] = value;
179 : : }
180 : 0 : });
181 : 0 : }
182 : 0 : void resetSettings() override
183 : : {
184 : 0 : args().WriteSettingsFile(/*errors=*/nullptr, /*backup=*/true);
185 : 0 : args().LockSettings([&](common::Settings& settings) {
186 [ # # ]: 0 : settings.rw_settings.clear();
187 : : });
188 : 0 : args().WriteSettingsFile();
189 : 0 : }
190 : 0 : void mapPort(bool use_pcp) override { StartMapPort(use_pcp); }
191 : 0 : bool getProxy(Network net, Proxy& proxy_info) override { return GetProxy(net, proxy_info); }
192 : 0 : size_t getNodeCount(ConnectionDirection flags) override
193 : : {
194 [ # # ]: 0 : return m_context->connman ? m_context->connman->GetNodeCount(flags) : 0;
195 : : }
196 : 0 : bool getNodesStats(NodesStats& stats) override
197 : : {
198 : 0 : stats.clear();
199 : :
200 [ # # ]: 0 : if (m_context->connman) {
201 : 0 : std::vector<CNodeStats> stats_temp;
202 [ # # ]: 0 : m_context->connman->GetNodeStats(stats_temp);
203 : :
204 [ # # ]: 0 : stats.reserve(stats_temp.size());
205 [ # # ]: 0 : for (auto& node_stats_temp : stats_temp) {
206 [ # # ]: 0 : stats.emplace_back(std::move(node_stats_temp), false, CNodeStateStats());
207 : : }
208 : :
209 : : // Try to retrieve the CNodeStateStats for each node.
210 [ # # ]: 0 : if (m_context->peerman) {
211 [ # # ]: 0 : TRY_LOCK(::cs_main, lockMain);
212 [ # # ]: 0 : if (lockMain) {
213 [ # # ]: 0 : for (auto& node_stats : stats) {
214 : 0 : std::get<1>(node_stats) =
215 [ # # ]: 0 : m_context->peerman->GetNodeStateStats(std::get<0>(node_stats).nodeid, std::get<2>(node_stats));
216 : : }
217 : : }
218 : 0 : }
219 : 0 : return true;
220 : 0 : }
221 : : return false;
222 : : }
223 : 0 : bool getBanned(banmap_t& banmap) override
224 : : {
225 [ # # ]: 0 : if (m_context->banman) {
226 : 0 : m_context->banman->GetBanned(banmap);
227 : 0 : return true;
228 : : }
229 : : return false;
230 : : }
231 : 0 : bool ban(const CNetAddr& net_addr, int64_t ban_time_offset) override
232 : : {
233 [ # # ]: 0 : if (m_context->banman) {
234 : 0 : m_context->banman->Ban(net_addr, ban_time_offset);
235 : 0 : return true;
236 : : }
237 : : return false;
238 : : }
239 : 0 : bool unban(const CSubNet& ip) override
240 : : {
241 [ # # ]: 0 : if (m_context->banman) {
242 : 0 : m_context->banman->Unban(ip);
243 : 0 : return true;
244 : : }
245 : : return false;
246 : : }
247 : 0 : bool disconnectByAddress(const CNetAddr& net_addr) override
248 : : {
249 [ # # ]: 0 : if (m_context->connman) {
250 : 0 : return m_context->connman->DisconnectNode(net_addr);
251 : : }
252 : : return false;
253 : : }
254 : 0 : bool disconnectById(NodeId id) override
255 : : {
256 [ # # ]: 0 : if (m_context->connman) {
257 : 0 : return m_context->connman->DisconnectNode(id);
258 : : }
259 : : return false;
260 : : }
261 : 0 : std::vector<std::unique_ptr<interfaces::ExternalSigner>> listExternalSigners() override
262 : : {
263 : : #ifdef ENABLE_EXTERNAL_SIGNER
264 : 0 : std::vector<ExternalSigner> signers = {};
265 [ # # # # : 0 : const std::string command = args().GetArg("-signer", "");
# # # # ]
266 [ # # ]: 0 : if (command == "") return {};
267 [ # # # # : 0 : ExternalSigner::Enumerate(command, signers, Params().GetChainTypeString());
# # ]
268 : 0 : std::vector<std::unique_ptr<interfaces::ExternalSigner>> result;
269 [ # # ]: 0 : result.reserve(signers.size());
270 [ # # ]: 0 : for (auto& signer : signers) {
271 [ # # # # ]: 0 : result.emplace_back(std::make_unique<ExternalSignerImpl>(std::move(signer)));
272 : : }
273 : 0 : return result;
274 : : #else
275 : : // This result is indistinguishable from a successful call that returns
276 : : // no signers. For the current GUI this doesn't matter, because the wallet
277 : : // creation dialog disables the external signer checkbox in both
278 : : // cases. The return type could be changed to std::optional<std::vector>
279 : : // (or something that also includes error messages) if this distinction
280 : : // becomes important.
281 : : return {};
282 : : #endif // ENABLE_EXTERNAL_SIGNER
283 : 0 : }
284 [ # # ]: 0 : int64_t getTotalBytesRecv() override { return m_context->connman ? m_context->connman->GetTotalBytesRecv() : 0; }
285 [ # # ]: 0 : int64_t getTotalBytesSent() override { return m_context->connman ? m_context->connman->GetTotalBytesSent() : 0; }
286 [ # # ]: 0 : size_t getMempoolSize() override { return m_context->mempool ? m_context->mempool->size() : 0; }
287 [ # # ]: 0 : size_t getMempoolDynamicUsage() override { return m_context->mempool ? m_context->mempool->DynamicMemoryUsage() : 0; }
288 [ # # ]: 0 : size_t getMempoolMaxUsage() override { return m_context->mempool ? m_context->mempool->m_opts.max_size_bytes : 0; }
289 : 0 : bool getHeaderTip(int& height, int64_t& block_time) override
290 : : {
291 : 0 : LOCK(::cs_main);
292 [ # # ]: 0 : auto best_header = chainman().m_best_header;
293 [ # # ]: 0 : if (best_header) {
294 : 0 : height = best_header->nHeight;
295 : 0 : block_time = best_header->GetBlockTime();
296 : 0 : return true;
297 : : }
298 : : return false;
299 : 0 : }
300 : 0 : std::map<CNetAddr, LocalServiceInfo> getNetLocalAddresses() override
301 : : {
302 [ # # ]: 0 : if (m_context->connman)
303 : 0 : return m_context->connman->getNetLocalAddresses();
304 : : else
305 : 0 : return {};
306 : : }
307 : 0 : int getNumBlocks() override
308 : : {
309 : 0 : LOCK(::cs_main);
310 [ # # # # : 0 : return chainman().ActiveChain().Height();
# # ]
311 : 0 : }
312 : 0 : uint256 getBestBlockHash() override
313 : : {
314 [ # # # # : 0 : const CBlockIndex* tip = WITH_LOCK(::cs_main, return chainman().ActiveChain().Tip());
# # # # ]
315 [ # # ]: 0 : return tip ? tip->GetBlockHash() : chainman().GetParams().GenesisBlock().GetHash();
316 : : }
317 : 0 : int64_t getLastBlockTime() override
318 : : {
319 : 0 : LOCK(::cs_main);
320 [ # # # # : 0 : if (chainman().ActiveChain().Tip()) {
# # # # ]
321 [ # # # # : 0 : return chainman().ActiveChain().Tip()->GetBlockTime();
# # ]
322 : : }
323 [ # # ]: 0 : return chainman().GetParams().GenesisBlock().GetBlockTime(); // Genesis block's time of current network
324 : 0 : }
325 : 0 : double getVerificationProgress() override
326 : : {
327 [ # # # # : 0 : return GuessVerificationProgress(chainman().GetParams().TxData(), WITH_LOCK(::cs_main, return chainman().ActiveChain().Tip()));
# # # # ]
328 : : }
329 : 0 : bool isInitialBlockDownload() override
330 : : {
331 : 0 : return chainman().IsInitialBlockDownload();
332 : : }
333 : 0 : bool isLoadingBlocks() override { return chainman().m_blockman.LoadingBlocks(); }
334 : 0 : void setNetworkActive(bool active) override
335 : : {
336 [ # # ]: 0 : if (m_context->connman) {
337 : 0 : m_context->connman->SetNetworkActive(active);
338 : : }
339 : 0 : }
340 [ # # # # ]: 0 : bool getNetworkActive() override { return m_context->connman && m_context->connman->GetNetworkActive(); }
341 : 0 : CFeeRate getDustRelayFee() override
342 : : {
343 [ # # ]: 0 : if (!m_context->mempool) return CFeeRate{DUST_RELAY_TX_FEE};
344 : 0 : return m_context->mempool->m_opts.dust_relay_feerate;
345 : : }
346 : 0 : UniValue executeRpc(const std::string& command, const UniValue& params, const std::string& uri) override
347 : : {
348 : 0 : JSONRPCRequest req;
349 : 0 : req.context = m_context;
350 [ # # ]: 0 : req.params = params;
351 [ # # ]: 0 : req.strMethod = command;
352 [ # # ]: 0 : req.URI = uri;
353 [ # # ]: 0 : return ::tableRPC.execute(req);
354 : 0 : }
355 : 0 : std::vector<std::string> listRpcCommands() override { return ::tableRPC.listCommands(); }
356 : 0 : void rpcSetTimerInterfaceIfUnset(RPCTimerInterface* iface) override { RPCSetTimerInterfaceIfUnset(iface); }
357 : 0 : void rpcUnsetTimerInterface(RPCTimerInterface* iface) override { RPCUnsetTimerInterface(iface); }
358 : 0 : std::optional<Coin> getUnspentOutput(const COutPoint& output) override
359 : : {
360 : 0 : LOCK(::cs_main);
361 [ # # # # : 0 : return chainman().ActiveChainstate().CoinsTip().GetCoin(output);
# # # # ]
362 : 0 : }
363 : 0 : TransactionError broadcastTransaction(CTransactionRef tx, CAmount max_tx_fee, std::string& err_string) override
364 : : {
365 [ # # # # ]: 0 : return BroadcastTransaction(*m_context, std::move(tx), err_string, max_tx_fee, /*relay=*/ true, /*wait_callback=*/ false);
366 : : }
367 : 0 : WalletLoader& walletLoader() override
368 : : {
369 : 0 : return *Assert(m_context->wallet_loader);
370 : : }
371 : 0 : std::unique_ptr<Handler> handleInitMessage(InitMessageFn fn) override
372 : : {
373 [ # # # # ]: 0 : return MakeSignalHandler(::uiInterface.InitMessage_connect(fn));
374 : : }
375 : 0 : std::unique_ptr<Handler> handleMessageBox(MessageBoxFn fn) override
376 : : {
377 [ # # # # ]: 0 : return MakeSignalHandler(::uiInterface.ThreadSafeMessageBox_connect(fn));
378 : : }
379 : 0 : std::unique_ptr<Handler> handleQuestion(QuestionFn fn) override
380 : : {
381 [ # # # # ]: 0 : return MakeSignalHandler(::uiInterface.ThreadSafeQuestion_connect(fn));
382 : : }
383 : 0 : std::unique_ptr<Handler> handleShowProgress(ShowProgressFn fn) override
384 : : {
385 [ # # # # ]: 0 : return MakeSignalHandler(::uiInterface.ShowProgress_connect(fn));
386 : : }
387 : 0 : std::unique_ptr<Handler> handleInitWallet(InitWalletFn fn) override
388 : : {
389 [ # # # # ]: 0 : return MakeSignalHandler(::uiInterface.InitWallet_connect(fn));
390 : : }
391 : 0 : std::unique_ptr<Handler> handleNotifyNumConnectionsChanged(NotifyNumConnectionsChangedFn fn) override
392 : : {
393 [ # # # # ]: 0 : return MakeSignalHandler(::uiInterface.NotifyNumConnectionsChanged_connect(fn));
394 : : }
395 : 0 : std::unique_ptr<Handler> handleNotifyNetworkActiveChanged(NotifyNetworkActiveChangedFn fn) override
396 : : {
397 [ # # # # ]: 0 : return MakeSignalHandler(::uiInterface.NotifyNetworkActiveChanged_connect(fn));
398 : : }
399 : 0 : std::unique_ptr<Handler> handleNotifyAlertChanged(NotifyAlertChangedFn fn) override
400 : : {
401 [ # # # # ]: 0 : return MakeSignalHandler(::uiInterface.NotifyAlertChanged_connect(fn));
402 : : }
403 : 0 : std::unique_ptr<Handler> handleBannedListChanged(BannedListChangedFn fn) override
404 : : {
405 [ # # # # ]: 0 : return MakeSignalHandler(::uiInterface.BannedListChanged_connect(fn));
406 : : }
407 : 0 : std::unique_ptr<Handler> handleNotifyBlockTip(NotifyBlockTipFn fn) override
408 : : {
409 [ # # # # : 0 : return MakeSignalHandler(::uiInterface.NotifyBlockTip_connect([fn](SynchronizationState sync_state, const CBlockIndex* block) {
# # ]
410 : 0 : fn(sync_state, BlockTip{block->nHeight, block->GetBlockTime(), block->GetBlockHash()},
411 : 0 : GuessVerificationProgress(Params().TxData(), block));
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 : 245232 : bool FillBlock(const CBlockIndex* index, const FoundBlock& block, UniqueLock<RecursiveMutex>& lock, const CChain& active, const BlockManager& blockman)
433 : : {
434 [ + + ]: 245232 : if (!index) return false;
435 [ + + ]: 244156 : if (block.m_hash) *block.m_hash = index->GetBlockHash();
436 [ + + ]: 244156 : if (block.m_height) *block.m_height = index->nHeight;
437 [ + + ]: 244156 : if (block.m_time) *block.m_time = index->GetBlockTime();
438 [ + + ]: 244156 : if (block.m_max_time) *block.m_max_time = index->GetBlockTimeMax();
439 [ + + ]: 244156 : if (block.m_mtp_time) *block.m_mtp_time = index->GetMedianTimePast();
440 [ + + + - ]: 396022 : if (block.m_in_active_chain) *block.m_in_active_chain = active[index->nHeight] == index;
441 [ + + ]: 244156 : if (block.m_locator) { *block.m_locator = GetLocator(index); }
442 [ + + + - : 390076 : if (block.m_next_block) FillBlock(active[index->nHeight] == index ? active[index->nHeight + 1] : nullptr, *block.m_next_block, lock, active, blockman);
+ - + - ]
443 [ + + ]: 244156 : if (block.m_data) {
444 : 72418 : REVERSE_LOCK(lock);
445 [ + - + + ]: 72418 : if (!blockman.ReadBlockFromDisk(*block.m_data, *index)) block.m_data->SetNull();
446 : 72418 : }
447 : 244156 : block.found = true;
448 : 244156 : return true;
449 : : }
450 : :
451 : : class NotificationsProxy : public CValidationInterface
452 : : {
453 : : public:
454 : 726 : explicit NotificationsProxy(std::shared_ptr<Chain::Notifications> notifications)
455 : 726 : : m_notifications(std::move(notifications)) {}
456 [ + - ]: 726 : virtual ~NotificationsProxy() = default;
457 : 4340 : void TransactionAddedToMempool(const NewMempoolTransactionInfo& tx, uint64_t mempool_sequence) override
458 : : {
459 : 4340 : m_notifications->transactionAddedToMempool(tx.info.m_tx);
460 : 4340 : }
461 : 210 : void TransactionRemovedFromMempool(const CTransactionRef& tx, MemPoolRemovalReason reason, uint64_t mempool_sequence) override
462 : : {
463 : 210 : m_notifications->transactionRemovedFromMempool(tx, reason);
464 : 210 : }
465 : 36905 : void BlockConnected(ChainstateRole role, const std::shared_ptr<const CBlock>& block, const CBlockIndex* index) override
466 : : {
467 : 36905 : m_notifications->blockConnected(role, kernel::MakeBlockInfo(index, block.get()));
468 : 36905 : }
469 : 2810 : void BlockDisconnected(const std::shared_ptr<const CBlock>& block, const CBlockIndex* index) override
470 : : {
471 : 2810 : m_notifications->blockDisconnected(kernel::MakeBlockInfo(index, block.get()));
472 : 2810 : }
473 : 35392 : void UpdatedBlockTip(const CBlockIndex* index, const CBlockIndex* fork_index, bool is_ibd) override
474 : : {
475 : 35392 : m_notifications->updatedBlockTip();
476 : 35392 : }
477 : 477 : void ChainStateFlushed(ChainstateRole role, const CBlockLocator& locator) override {
478 : 477 : m_notifications->chainStateFlushed(role, locator);
479 : 477 : }
480 : : std::shared_ptr<Chain::Notifications> m_notifications;
481 : : };
482 : :
483 : : class NotificationsHandlerImpl : public Handler
484 : : {
485 : : public:
486 : 726 : explicit NotificationsHandlerImpl(ValidationSignals& signals, std::shared_ptr<Chain::Notifications> notifications)
487 [ + - ]: 726 : : m_signals{signals}, m_proxy{std::make_shared<NotificationsProxy>(std::move(notifications))}
488 : : {
489 [ + - + - ]: 1452 : m_signals.RegisterSharedValidationInterface(m_proxy);
490 [ - - ]: 726 : }
491 [ - + ]: 1452 : ~NotificationsHandlerImpl() override { disconnect(); }
492 : 726 : void disconnect() override
493 : : {
494 [ + - ]: 726 : if (m_proxy) {
495 [ + - + - ]: 1452 : m_signals.UnregisterSharedValidationInterface(m_proxy);
496 : 726 : m_proxy.reset();
497 : : }
498 : 726 : }
499 : : ValidationSignals& m_signals;
500 : : std::shared_ptr<NotificationsProxy> m_proxy;
501 : : };
502 : :
503 : : class RpcHandlerImpl : public Handler
504 : : {
505 : : public:
506 [ + - ]: 27186 : explicit RpcHandlerImpl(const CRPCCommand& command) : m_command(command), m_wrapped_command(&command)
507 : : {
508 : 45786 : m_command.actor = [this](const JSONRPCRequest& request, UniValue& result, bool last_handler) {
509 [ + - ]: 18600 : if (!m_wrapped_command) return false;
510 : 18600 : try {
511 [ + + ]: 18600 : return m_wrapped_command->actor(request, result, last_handler);
512 [ - + ]: 636 : } 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 [ - + ]: 636 : 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 : 636 : throw;
523 : 636 : }
524 : 27186 : };
525 [ + - ]: 27186 : ::tableRPC.appendCommand(m_command.name, &m_command);
526 : 27186 : }
527 : :
528 : 27186 : void disconnect() final
529 : : {
530 [ + - ]: 27186 : if (m_wrapped_command) {
531 : 27186 : m_wrapped_command = nullptr;
532 : 27186 : ::tableRPC.removeCommand(m_command.name, &m_command);
533 : : }
534 : 27186 : }
535 : :
536 : 54372 : ~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 : 1691 : explicit ChainImpl(NodeContext& node) : m_node(node) {}
546 : 1415 : std::optional<int> getHeight() override
547 : : {
548 [ + - + - : 4245 : const int height{WITH_LOCK(::cs_main, return chainman().ActiveChain().Height())};
+ - ]
549 [ + + ]: 1415 : return height >= 0 ? std::optional{height} : std::nullopt;
550 : : }
551 : 1489 : uint256 getBlockHash(int height) override
552 : : {
553 : 1489 : LOCK(::cs_main);
554 [ + - + - : 2978 : return Assert(chainman().ActiveChain()[height])->GetBlockHash();
+ - + - +
- ]
555 : 1489 : }
556 : 604 : bool haveBlockOnDisk(int height) override
557 : : {
558 : 604 : LOCK(::cs_main);
559 [ + - + - : 605 : const CBlockIndex* block{chainman().ActiveChain()[height]};
+ - ]
560 [ + - + + : 605 : return block && ((block->nStatus & BLOCK_HAVE_DATA) != 0) && block->nTx > 0;
- + + - ]
561 : 604 : }
562 : 534 : CBlockLocator getTipLocator() override
563 : : {
564 : 534 : LOCK(::cs_main);
565 [ + - + - : 534 : return chainman().ActiveChain().GetLocator();
+ - ]
566 : 534 : }
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 : 707 : std::optional<int> findLocatorFork(const CBlockLocator& locator) override
574 : : {
575 : 707 : LOCK(::cs_main);
576 [ + - + - : 707 : if (const CBlockIndex* fork = chainman().ActiveChainstate().FindForkInGlobalIndex(locator)) {
+ - + + ]
577 : 699 : return fork->nHeight;
578 : : }
579 : 8 : return std::nullopt;
580 : 707 : }
581 : 638 : bool hasBlockFilterIndex(BlockFilterType filter_type) override
582 : : {
583 : 638 : 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 : 171537 : bool findBlock(const uint256& hash, const FoundBlock& block) override
596 : : {
597 : 171537 : WAIT_LOCK(cs_main, lock);
598 [ + - + - : 171537 : return FillBlock(chainman().m_blockman.LookupBlockIndex(hash), block, lock, chainman().ActiveChain(), chainman().m_blockman);
+ - + - +
- + - +
- ]
599 : 171537 : }
600 : 627 : bool findFirstBlockWithTimeAndHeight(int64_t min_time, int min_height, const FoundBlock& block) override
601 : : {
602 : 627 : WAIT_LOCK(cs_main, lock);
603 [ + - + - ]: 627 : const CChain& active = chainman().ActiveChain();
604 [ + - + - : 627 : return FillBlock(active.FindEarliestAtLeast(min_time, min_height), block, lock, active, chainman().m_blockman);
+ - + - ]
605 : 627 : }
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 : 21 : 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 : 21 : WAIT_LOCK(cs_main, lock);
628 [ + - + - ]: 21 : const CChain& active = chainman().ActiveChain();
629 [ + - + - ]: 21 : const CBlockIndex* block1 = chainman().m_blockman.LookupBlockIndex(block_hash1);
630 [ + - + - ]: 21 : const CBlockIndex* block2 = chainman().m_blockman.LookupBlockIndex(block_hash2);
631 [ + + + - ]: 21 : 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 [ + - + - ]: 21 : return int{FillBlock(ancestor, ancestor_out, lock, active, chainman().m_blockman)} &
636 [ + - + - ]: 21 : int{FillBlock(block1, block1_out, lock, active, chainman().m_blockman)} &
637 [ + - + - : 21 : int{FillBlock(block2, block2_out, lock, active, chainman().m_blockman)};
+ - ]
638 : 21 : }
639 : 870 : void findCoins(std::map<COutPoint, Coin>& coins) override { return FindCoins(m_node, coins); }
640 : 73599 : double guessVerificationProgress(const uint256& block_hash) override
641 : : {
642 : 73599 : LOCK(::cs_main);
643 [ + - + - : 73599 : return GuessVerificationProgress(chainman().GetParams().TxData(), chainman().m_blockman.LookupBlockIndex(block_hash));
+ - + - +
- ]
644 : 73599 : }
645 : 32 : 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 : 32 : LOCK(::cs_main);
655 [ + - + - : 32 : if (const CBlockIndex* block = chainman().m_blockman.LookupBlockIndex(block_hash)) {
+ - ]
656 [ + + + + : 32 : if (max_height && block->nHeight >= *max_height) block = block->GetAncestor(*max_height);
+ - ]
657 [ + + ]: 2973 : 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 : 32 : }
664 : 624 : RBFTransactionState isRBFOptIn(const CTransaction& tx) override
665 : : {
666 [ - + ]: 624 : if (!m_node.mempool) return IsRBFOptInEmptyMempool(tx);
667 : 624 : LOCK(m_node.mempool->cs);
668 [ + - + - ]: 624 : return IsRBFOptIn(tx, *m_node.mempool);
669 : 624 : }
670 : 17246 : bool isInMempool(const uint256& txid) override
671 : : {
672 [ + - ]: 17246 : if (!m_node.mempool) return false;
673 : 17246 : LOCK(m_node.mempool->cs);
674 [ + - + - ]: 17246 : return m_node.mempool->exists(GenTxid::Txid(txid));
675 : 17246 : }
676 : 221 : bool hasDescendantsInMempool(const uint256& txid) override
677 : : {
678 [ + - ]: 221 : if (!m_node.mempool) return false;
679 : 221 : LOCK(m_node.mempool->cs);
680 [ + - ]: 221 : const auto entry{m_node.mempool->GetEntry(Txid::FromUint256(txid))};
681 [ + + ]: 221 : if (entry == nullptr) return false;
682 : 220 : return entry->GetCountWithDescendants() > 1;
683 : 221 : }
684 : 1540 : bool broadcastTransaction(const CTransactionRef& tx,
685 : : const CAmount& max_tx_fee,
686 : : bool relay,
687 : : std::string& err_string) override
688 : : {
689 [ + - + - : 3080 : 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 : 1540 : return TransactionError::OK == err;
694 : : }
695 : 576365 : void getTransactionAncestry(const uint256& txid, size_t& ancestors, size_t& descendants, size_t* ancestorsize, CAmount* ancestorfees) override
696 : : {
697 : 576365 : ancestors = descendants = 0;
698 [ + - ]: 576365 : if (!m_node.mempool) return;
699 : 576365 : m_node.mempool->GetTransactionAncestry(txid, ancestors, descendants, ancestorsize, ancestorfees);
700 : : }
701 : :
702 : 3695 : std::map<COutPoint, CAmount> calculateIndividualBumpFees(const std::vector<COutPoint>& outpoints, const CFeeRate& target_feerate) override
703 : : {
704 [ - + ]: 3695 : 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 [ + - ]: 3695 : return MiniMiner(*m_node.mempool, outpoints).CalculateBumpFees(target_feerate);
712 : : }
713 : :
714 : 8352 : std::optional<CAmount> calculateCombinedBumpFee(const std::vector<COutPoint>& outpoints, const CFeeRate& target_feerate) override
715 : : {
716 [ - + ]: 8352 : if (!m_node.mempool) {
717 : 0 : return 0;
718 : : }
719 [ + - ]: 8352 : return MiniMiner(*m_node.mempool, outpoints).CalculateTotalBumpFees(target_feerate);
720 : : }
721 : 2988 : void getPackageLimits(unsigned int& limit_ancestor_count, unsigned int& limit_descendant_count) override
722 : : {
723 : 2988 : const CTxMemPool::Limits default_limits{};
724 : :
725 [ + - ]: 2988 : const CTxMemPool::Limits& limits{m_node.mempool ? m_node.mempool->m_opts.limits : default_limits};
726 : :
727 : 2988 : limit_ancestor_count = limits.ancestor_count;
728 : 2988 : limit_descendant_count = limits.descendant_count;
729 : 2988 : }
730 : 3131 : util::Result<void> checkChainLimits(const CTransactionRef& tx) override
731 : : {
732 [ - + ]: 3131 : if (!m_node.mempool) return {};
733 : 3131 : LockPoints lp;
734 : 3131 : CTxMemPoolEntry entry(tx, 0, 0, 0, 0, false, 0, lp);
735 [ + - ]: 3131 : LOCK(m_node.mempool->cs);
736 [ + - + - : 9393 : return m_node.mempool->CheckPackageLimits({tx}, entry.GetTxSize());
+ + + - -
- - - ]
737 [ + - + - ]: 9393 : }
738 : 5678 : CFeeRate estimateSmartFee(int num_blocks, bool conservative, FeeCalculation* calc) override
739 : : {
740 [ + + ]: 5678 : if (!m_node.fee_estimator) return {};
741 : 5656 : return m_node.fee_estimator->estimateSmartFee(num_blocks, calc, conservative);
742 : : }
743 : 3314 : unsigned int estimateMaxBlocks() override
744 : : {
745 [ + + ]: 3314 : if (!m_node.fee_estimator) return 0;
746 : 3299 : return m_node.fee_estimator->HighestTargetTracked(FeeEstimateHorizon::LONG_HALFLIFE);
747 : : }
748 : 2417 : CFeeRate mempoolMinFee() override
749 : : {
750 [ - + ]: 2417 : if (!m_node.mempool) return {};
751 : 2417 : return m_node.mempool->GetMinFee();
752 : : }
753 : 3949 : CFeeRate relayMinFee() override
754 : : {
755 [ - + ]: 3949 : if (!m_node.mempool) return CFeeRate{DEFAULT_MIN_RELAY_TX_FEE};
756 : 3949 : return m_node.mempool->m_opts.min_relay_feerate;
757 : : }
758 : 119 : CFeeRate relayIncrementalFee() override
759 : : {
760 [ - + ]: 119 : if (!m_node.mempool) return CFeeRate{DEFAULT_INCREMENTAL_RELAY_FEE};
761 : 119 : return m_node.mempool->m_opts.incremental_relay_feerate;
762 : : }
763 : 43813 : CFeeRate relayDustFee() override
764 : : {
765 [ - + ]: 43813 : if (!m_node.mempool) return CFeeRate{DUST_RELAY_TX_FEE};
766 : 43813 : return m_node.mempool->m_opts.dust_relay_feerate;
767 : : }
768 : 55 : bool havePruned() override
769 : : {
770 : 55 : LOCK(::cs_main);
771 [ + - + - ]: 55 : return chainman().m_blockman.m_have_pruned;
772 : 55 : }
773 [ + - + + ]: 130 : bool isReadyToBroadcast() override { return !chainman().m_blockman.LoadingBlocks() && !isInitialBlockDownload(); }
774 : 2664 : bool isInitialBlockDownload() override
775 : : {
776 : 2664 : return chainman().IsInitialBlockDownload();
777 : : }
778 : 73399 : bool shutdownRequested() override { return ShutdownRequested(m_node); }
779 : 1129 : void initMessage(const std::string& message) override { ::uiInterface.InitMessage(message); }
780 : 2 : void initWarning(const bilingual_str& message) override { InitWarning(message); }
781 : 26 : void initError(const bilingual_str& message) override { InitError(message); }
782 : 16 : void showProgress(const std::string& title, int progress, bool resume_possible) override
783 : : {
784 : 16 : ::uiInterface.ShowProgress(title, progress, resume_possible);
785 : 16 : }
786 : 726 : std::unique_ptr<Handler> handleNotifications(std::shared_ptr<Notifications> notifications) override
787 : : {
788 : 726 : return std::make_unique<NotificationsHandlerImpl>(validation_signals(), std::move(notifications));
789 : : }
790 : 5747 : void waitForNotificationsIfTipChanged(const uint256& old_tip) override
791 : : {
792 [ + + + + : 22976 : if (!old_tip.IsNull() && old_tip == WITH_LOCK(::cs_main, return chainman().ActiveChain().Tip()->GetBlockHash())) return;
+ - + - +
- + - ]
793 : 337 : validation_signals().SyncWithValidationInterfaceQueue();
794 : : }
795 : 27186 : std::unique_ptr<Handler> handleRpc(const CRPCCommand& command) override
796 : : {
797 : 27186 : return std::make_unique<RpcHandlerImpl>(command);
798 : : }
799 : 1 : bool rpcEnableDeprecated(const std::string& method) override { return IsDeprecatedRPCEnabled(method); }
800 : 44 : void rpcRunLater(const std::string& name, std::function<void()> fn, int64_t seconds) override
801 : : {
802 [ + - ]: 44 : RPCRunLater(name, std::move(fn), seconds);
803 : 44 : }
804 : 0 : common::SettingsValue getSetting(const std::string& name) override
805 : : {
806 : 0 : return args().GetSetting(name);
807 : : }
808 : 702 : std::vector<common::SettingsValue> getSettingsList(const std::string& name) override
809 : : {
810 : 702 : return args().GetSettingsList(name);
811 : : }
812 : 3 : common::SettingsValue getRwSetting(const std::string& name) override
813 : : {
814 [ + - ]: 3 : common::SettingsValue result;
815 [ + - + - ]: 3 : args().LockSettings([&](const common::Settings& settings) {
816 [ + + ]: 3 : if (const common::SettingsValue* value = common::FindKey(settings.rw_settings, name)) {
817 : 2 : result = *value;
818 : : }
819 : 3 : });
820 : 3 : return result;
821 : 0 : }
822 : 174 : bool updateRwSetting(const std::string& name,
823 : : const interfaces::SettingsUpdate& update_settings_func) override
824 : : {
825 : 174 : std::optional<interfaces::SettingsAction> action;
826 : 174 : args().LockSettings([&](common::Settings& settings) {
827 [ + + ]: 174 : if (auto* value = common::FindKey(settings.rw_settings, name)) {
828 : 25 : action = update_settings_func(*value);
829 [ - + ]: 25 : if (value->isNull()) settings.rw_settings.erase(name);
830 : : } else {
831 [ + - ]: 149 : UniValue new_value;
832 [ + - ]: 149 : action = update_settings_func(new_value);
833 [ + + + - ]: 149 : if (!new_value.isNull()) settings.rw_settings[name] = std::move(new_value);
834 : 149 : }
835 : 174 : });
836 [ + - ]: 174 : if (!action) return false;
837 : : // Now dump value to disk if requested
838 [ + + + - ]: 174 : return *action != interfaces::SettingsAction::WRITE || args().WriteSettingsFile();
839 : : }
840 : 1 : bool overwriteRwSetting(const std::string& name, common::SettingsValue value, interfaces::SettingsAction action) override
841 : : {
842 [ + - ]: 1 : return updateRwSetting(name, [&](common::SettingsValue& settings) {
843 : 1 : settings = std::move(value);
844 : 1 : return action;
845 : 1 : });
846 : : }
847 : 0 : bool deleteRwSettings(const std::string& name, interfaces::SettingsAction action) override
848 : : {
849 [ # # ]: 0 : return overwriteRwSetting(name, {}, action);
850 : : }
851 : 1346 : void requestMempoolTransactions(Notifications& notifications) override
852 : : {
853 [ + - ]: 1346 : if (!m_node.mempool) return;
854 [ + - ]: 1346 : LOCK2(::cs_main, m_node.mempool->cs);
855 [ + - + - : 1656 : for (const CTxMemPoolEntry& entry : m_node.mempool->entryAll()) {
+ + ]
856 [ + - + - ]: 930 : notifications.transactionAddedToMempool(entry.GetSharedTx());
857 [ + - ]: 1346 : }
858 [ + - ]: 2692 : }
859 : 52 : bool hasAssumedValidChain() override
860 : : {
861 : 52 : return chainman().IsSnapshotActive();
862 : : }
863 : :
864 : 713 : NodeContext* context() override { return &m_node; }
865 : 1046 : ArgsManager& args() { return *Assert(m_node.args); }
866 : 677374 : ChainstateManager& chainman() { return *Assert(m_node.chainman); }
867 : 1063 : ValidationSignals& validation_signals() { return *Assert(m_node.validation_signals); }
868 : : NodeContext& m_node;
869 : : };
870 : :
871 : : class BlockTemplateImpl : public BlockTemplate
872 : : {
873 : : public:
874 [ - + ]: 36730 : explicit BlockTemplateImpl(std::unique_ptr<CBlockTemplate> block_template, NodeContext& node) : m_block_template(std::move(block_template)), m_node(node)
875 : : {
876 [ - + ]: 36730 : assert(m_block_template);
877 : 36730 : }
878 : :
879 : 0 : CBlockHeader getBlockHeader() override
880 : : {
881 : 0 : return m_block_template->block;
882 : : }
883 : :
884 : 38738 : CBlock getBlock() override
885 : : {
886 : 38738 : return m_block_template->block;
887 : : }
888 : :
889 : 2065 : std::vector<CAmount> getTxFees() override
890 : : {
891 : 2065 : return m_block_template->vTxFees;
892 : : }
893 : :
894 : 2065 : std::vector<int64_t> getTxSigops() override
895 : : {
896 : 2065 : return m_block_template->vTxSigOpsCost;
897 : : }
898 : :
899 : 0 : CTransactionRef getCoinbaseTx() override
900 : : {
901 [ # # ]: 0 : return m_block_template->block.vtx[0];
902 : : }
903 : :
904 : 4130 : std::vector<unsigned char> getCoinbaseCommitment() override
905 : : {
906 : 4130 : return m_block_template->vchCoinbaseCommitment;
907 : : }
908 : :
909 : 0 : int getWitnessCommitmentIndex() override
910 : : {
911 : 0 : return GetWitnessCommitmentIndex(m_block_template->block);
912 : : }
913 : :
914 : 0 : std::vector<uint256> getCoinbaseMerklePath() override
915 : : {
916 : 0 : return BlockMerkleBranch(m_block_template->block);
917 : : }
918 : :
919 : 0 : bool submitSolution(uint32_t version, uint32_t timestamp, uint32_t nonce, CMutableTransaction coinbase) override
920 : : {
921 : 0 : CBlock block{m_block_template->block};
922 : :
923 [ # # ]: 0 : auto cb = MakeTransactionRef(std::move(coinbase));
924 : :
925 [ # # ]: 0 : if (block.vtx.size() == 0) {
926 [ # # ]: 0 : block.vtx.push_back(cb);
927 : : } else {
928 : 0 : block.vtx[0] = cb;
929 : : }
930 : :
931 : 0 : block.nVersion = version;
932 : 0 : block.nTime = timestamp;
933 : 0 : block.nNonce = nonce;
934 : :
935 [ # # ]: 0 : block.hashMerkleRoot = BlockMerkleRoot(block);
936 : :
937 [ # # ]: 0 : auto block_ptr = std::make_shared<const CBlock>(block);
938 [ # # # # : 0 : return chainman().ProcessNewBlock(block_ptr, /*force_processing=*/true, /*min_pow_checked=*/true, /*new_block=*/nullptr);
# # ]
939 [ # # ]: 0 : }
940 : :
941 : : const std::unique_ptr<CBlockTemplate> m_block_template;
942 : :
943 : 0 : ChainstateManager& chainman() { return *Assert(m_node.chainman); }
944 : : NodeContext& m_node;
945 : : };
946 : :
947 : : class MinerImpl : public Mining
948 : : {
949 : : public:
950 : 989 : explicit MinerImpl(NodeContext& node) : m_node(node) {}
951 : :
952 : 2066 : bool isTestChain() override
953 : : {
954 : 2066 : return chainman().GetParams().IsTestChain();
955 : : }
956 : :
957 : 0 : bool isInitialBlockDownload() override
958 : : {
959 : 0 : return chainman().IsInitialBlockDownload();
960 : : }
961 : :
962 : 2101 : std::optional<BlockRef> getTip() override
963 : : {
964 : 2101 : LOCK(::cs_main);
965 [ + - + - : 2101 : CBlockIndex* tip{chainman().ActiveChain().Tip()};
+ - ]
966 [ - + ]: 2101 : if (!tip) return {};
967 : 2101 : return BlockRef{tip->GetBlockHash(), tip->nHeight};
968 : 2101 : }
969 : :
970 : 22 : BlockRef waitTipChanged(uint256 current_tip, MillisecondsDouble timeout) override
971 : : {
972 [ + + ]: 22 : if (timeout > std::chrono::years{100}) timeout = std::chrono::years{100}; // Upper bound to avoid UB in std::chrono
973 : 22 : {
974 : 22 : WAIT_LOCK(notifications().m_tip_block_mutex, lock);
975 [ + - + - ]: 22 : notifications().m_tip_block_cv.wait_for(lock, timeout, [&]() EXCLUSIVE_LOCKS_REQUIRED(notifications().m_tip_block_mutex) {
976 [ + + + + : 44 : return (notifications().m_tip_block != current_tip && notifications().m_tip_block != uint256::ZERO) || chainman().m_interrupt;
+ + ]
977 : : });
978 : 0 : }
979 : : // Must release m_tip_block_mutex before locking cs_main, to avoid deadlocks.
980 : 22 : LOCK(::cs_main);
981 [ + - + - : 66 : return BlockRef{chainman().ActiveChain().Tip()->GetBlockHash(), chainman().ActiveChain().Tip()->nHeight};
+ - + - +
- + - +
- ]
982 : 22 : }
983 : :
984 : 42257 : bool processNewBlock(const std::shared_ptr<const CBlock>& block, bool* new_block) override
985 : : {
986 : 42257 : return chainman().ProcessNewBlock(block, /*force_processing=*/true, /*min_pow_checked=*/true, /*new_block=*/new_block);
987 : : }
988 : :
989 : 2070 : unsigned int getTransactionsUpdated() override
990 : : {
991 : 2070 : return context()->mempool->GetTransactionsUpdated();
992 : : }
993 : :
994 : 43 : bool testBlockValidity(const CBlock& block, bool check_merkle_root, BlockValidationState& state) override
995 : : {
996 : 43 : LOCK(cs_main);
997 [ + - + - : 43 : CBlockIndex* tip{chainman().ActiveChain().Tip()};
+ - ]
998 : : // Fail if the tip updated before the lock was taken
999 [ - + ]: 43 : if (block.hashPrevBlock != tip->GetBlockHash()) {
1000 [ # # ]: 0 : state.Error("Block does not connect to current chain tip.");
1001 : 0 : return false;
1002 : : }
1003 : :
1004 [ + - + - : 43 : return TestBlockValidity(state, chainman().GetParams(), chainman().ActiveChainstate(), block, tip, /*fCheckPOW=*/false, check_merkle_root);
+ - + - ]
1005 : 43 : }
1006 : :
1007 : 36730 : std::unique_ptr<BlockTemplate> createNewBlock(const CScript& script_pub_key, const BlockCreateOptions& options) override
1008 : : {
1009 : 36730 : BlockAssembler::Options assemble_options{options};
1010 : 36730 : ApplyArgsManOptions(*Assert(m_node.args), assemble_options);
1011 [ + - + - ]: 73460 : return std::make_unique<BlockTemplateImpl>(BlockAssembler{chainman().ActiveChainstate(), context()->mempool.get(), assemble_options}.CreateNewBlock(script_pub_key), m_node);
1012 : : }
1013 : :
1014 : 38800 : NodeContext* context() override { return &m_node; }
1015 : 83359 : ChainstateManager& chainman() { return *Assert(m_node.chainman); }
1016 : 104 : KernelNotifications& notifications() { return *Assert(m_node.notifications); }
1017 : : NodeContext& m_node;
1018 : : };
1019 : : } // namespace
1020 : : } // namespace node
1021 : :
1022 : : namespace interfaces {
1023 : 0 : std::unique_ptr<Node> MakeNode(node::NodeContext& context) { return std::make_unique<node::NodeImpl>(context); }
1024 : 1691 : std::unique_ptr<Chain> MakeChain(node::NodeContext& context) { return std::make_unique<node::ChainImpl>(context); }
1025 : 989 : std::unique_ptr<Mining> MakeMining(node::NodeContext& context) { return std::make_unique<node::MinerImpl>(context); }
1026 : : } // namespace interfaces
|
