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 : return chainman().GuessVerificationProgress(WITH_LOCK(chainman().GetMutex(), return chainman().ActiveChain().Tip()));
# # # # ]
330 : : }
331 : 0 : bool isInitialBlockDownload() override
332 : : {
333 : 0 : return chainman().IsInitialBlockDownload();
334 : : }
335 : 0 : bool isLoadingBlocks() override { return chainman().m_blockman.LoadingBlocks(); }
336 : 0 : void setNetworkActive(bool active) override
337 : : {
338 [ # # ]: 0 : if (m_context->connman) {
339 : 0 : m_context->connman->SetNetworkActive(active);
340 : : }
341 : 0 : }
342 [ # # # # ]: 0 : bool getNetworkActive() override { return m_context->connman && m_context->connman->GetNetworkActive(); }
343 : 0 : CFeeRate getDustRelayFee() override
344 : : {
345 [ # # ]: 0 : if (!m_context->mempool) return CFeeRate{DUST_RELAY_TX_FEE};
346 : 0 : return m_context->mempool->m_opts.dust_relay_feerate;
347 : : }
348 : 0 : UniValue executeRpc(const std::string& command, const UniValue& params, const std::string& uri) override
349 : : {
350 : 0 : JSONRPCRequest req;
351 : 0 : req.context = m_context;
352 [ # # ]: 0 : req.params = params;
353 [ # # ]: 0 : req.strMethod = command;
354 [ # # ]: 0 : req.URI = uri;
355 [ # # ]: 0 : return ::tableRPC.execute(req);
356 : 0 : }
357 : 0 : std::vector<std::string> listRpcCommands() override { return ::tableRPC.listCommands(); }
358 : 0 : void rpcSetTimerInterfaceIfUnset(RPCTimerInterface* iface) override { RPCSetTimerInterfaceIfUnset(iface); }
359 : 0 : void rpcUnsetTimerInterface(RPCTimerInterface* iface) override { RPCUnsetTimerInterface(iface); }
360 : 0 : std::optional<Coin> getUnspentOutput(const COutPoint& output) override
361 : : {
362 : 0 : LOCK(::cs_main);
363 [ # # # # : 0 : return chainman().ActiveChainstate().CoinsTip().GetCoin(output);
# # # # ]
364 : 0 : }
365 : 0 : TransactionError broadcastTransaction(CTransactionRef tx, CAmount max_tx_fee, std::string& err_string) override
366 : : {
367 [ # # # # ]: 0 : return BroadcastTransaction(*m_context, std::move(tx), err_string, max_tx_fee, /*relay=*/ true, /*wait_callback=*/ false);
368 : : }
369 : 0 : WalletLoader& walletLoader() override
370 : : {
371 : 0 : return *Assert(m_context->wallet_loader);
372 : : }
373 : 0 : std::unique_ptr<Handler> handleInitMessage(InitMessageFn fn) override
374 : : {
375 [ # # # # ]: 0 : return MakeSignalHandler(::uiInterface.InitMessage_connect(fn));
376 : : }
377 : 0 : std::unique_ptr<Handler> handleMessageBox(MessageBoxFn fn) override
378 : : {
379 [ # # # # ]: 0 : return MakeSignalHandler(::uiInterface.ThreadSafeMessageBox_connect(fn));
380 : : }
381 : 0 : std::unique_ptr<Handler> handleQuestion(QuestionFn fn) override
382 : : {
383 [ # # # # ]: 0 : return MakeSignalHandler(::uiInterface.ThreadSafeQuestion_connect(fn));
384 : : }
385 : 0 : std::unique_ptr<Handler> handleShowProgress(ShowProgressFn fn) override
386 : : {
387 [ # # # # ]: 0 : return MakeSignalHandler(::uiInterface.ShowProgress_connect(fn));
388 : : }
389 : 0 : std::unique_ptr<Handler> handleInitWallet(InitWalletFn fn) override
390 : : {
391 [ # # # # ]: 0 : return MakeSignalHandler(::uiInterface.InitWallet_connect(fn));
392 : : }
393 : 0 : std::unique_ptr<Handler> handleNotifyNumConnectionsChanged(NotifyNumConnectionsChangedFn fn) override
394 : : {
395 [ # # # # ]: 0 : return MakeSignalHandler(::uiInterface.NotifyNumConnectionsChanged_connect(fn));
396 : : }
397 : 0 : std::unique_ptr<Handler> handleNotifyNetworkActiveChanged(NotifyNetworkActiveChangedFn fn) override
398 : : {
399 [ # # # # ]: 0 : return MakeSignalHandler(::uiInterface.NotifyNetworkActiveChanged_connect(fn));
400 : : }
401 : 0 : std::unique_ptr<Handler> handleNotifyAlertChanged(NotifyAlertChangedFn fn) override
402 : : {
403 [ # # # # ]: 0 : return MakeSignalHandler(::uiInterface.NotifyAlertChanged_connect(fn));
404 : : }
405 : 0 : std::unique_ptr<Handler> handleBannedListChanged(BannedListChangedFn fn) override
406 : : {
407 [ # # # # ]: 0 : return MakeSignalHandler(::uiInterface.BannedListChanged_connect(fn));
408 : : }
409 : 0 : std::unique_ptr<Handler> handleNotifyBlockTip(NotifyBlockTipFn fn) override
410 : : {
411 [ # # # # : 0 : return MakeSignalHandler(::uiInterface.NotifyBlockTip_connect([fn, this](SynchronizationState sync_state, const CBlockIndex* block) {
# # ]
412 : 0 : fn(sync_state, BlockTip{block->nHeight, block->GetBlockTime(), block->GetBlockHash()},
413 : 0 : chainman().GuessVerificationProgress(block));
414 [ # # ]: 0 : }));
415 : : }
416 : 0 : std::unique_ptr<Handler> handleNotifyHeaderTip(NotifyHeaderTipFn fn) override
417 : : {
418 : 0 : return MakeSignalHandler(
419 [ # # # # : 0 : ::uiInterface.NotifyHeaderTip_connect([fn](SynchronizationState sync_state, int64_t height, int64_t timestamp, bool presync) {
# # ]
420 : 0 : fn(sync_state, BlockTip{(int)height, timestamp, uint256{}}, presync);
421 [ # # ]: 0 : }));
422 : : }
423 : 0 : NodeContext* context() override { return m_context; }
424 : 0 : void setContext(NodeContext* context) override
425 : : {
426 : 0 : m_context = context;
427 : 0 : }
428 : 0 : ArgsManager& args() { return *Assert(Assert(m_context)->args); }
429 : 0 : ChainstateManager& chainman() { return *Assert(m_context->chainman); }
430 : : NodeContext* m_context{nullptr};
431 : : };
432 : :
433 : : // NOLINTNEXTLINE(misc-no-recursion)
434 : 248671 : bool FillBlock(const CBlockIndex* index, const FoundBlock& block, UniqueLock<RecursiveMutex>& lock, const CChain& active, const BlockManager& blockman)
435 : : {
436 [ + + ]: 248671 : if (!index) return false;
437 [ + + ]: 247485 : if (block.m_hash) *block.m_hash = index->GetBlockHash();
438 [ + + ]: 247485 : if (block.m_height) *block.m_height = index->nHeight;
439 [ + + ]: 247485 : if (block.m_time) *block.m_time = index->GetBlockTime();
440 [ + + ]: 247485 : if (block.m_max_time) *block.m_max_time = index->GetBlockTimeMax();
441 [ + + ]: 247485 : if (block.m_mtp_time) *block.m_mtp_time = index->GetMedianTimePast();
442 [ + + + - ]: 401290 : if (block.m_in_active_chain) *block.m_in_active_chain = active[index->nHeight] == index;
443 [ + + ]: 247485 : if (block.m_locator) { *block.m_locator = GetLocator(index); }
444 [ + + + - : 395117 : if (block.m_next_block) FillBlock(active[index->nHeight] == index ? active[index->nHeight + 1] : nullptr, *block.m_next_block, lock, active, blockman);
+ - + - ]
445 [ + + ]: 247485 : if (block.m_data) {
446 : 73274 : REVERSE_LOCK(lock);
447 [ + - + + ]: 73274 : if (!blockman.ReadBlock(*block.m_data, *index)) block.m_data->SetNull();
448 : 73274 : }
449 : 247485 : block.found = true;
450 : 247485 : return true;
451 : : }
452 : :
453 : : class NotificationsProxy : public CValidationInterface
454 : : {
455 : : public:
456 : 797 : explicit NotificationsProxy(std::shared_ptr<Chain::Notifications> notifications)
457 : 797 : : m_notifications(std::move(notifications)) {}
458 [ + - ]: 797 : virtual ~NotificationsProxy() = default;
459 : 4938 : void TransactionAddedToMempool(const NewMempoolTransactionInfo& tx, uint64_t mempool_sequence) override
460 : : {
461 : 4938 : m_notifications->transactionAddedToMempool(tx.info.m_tx);
462 : 4938 : }
463 : 225 : void TransactionRemovedFromMempool(const CTransactionRef& tx, MemPoolRemovalReason reason, uint64_t mempool_sequence) override
464 : : {
465 : 225 : m_notifications->transactionRemovedFromMempool(tx, reason);
466 : 225 : }
467 : 39616 : void BlockConnected(ChainstateRole role, const std::shared_ptr<const CBlock>& block, const CBlockIndex* index) override
468 : : {
469 : 39616 : m_notifications->blockConnected(role, kernel::MakeBlockInfo(index, block.get()));
470 : 39616 : }
471 : 2824 : void BlockDisconnected(const std::shared_ptr<const CBlock>& block, const CBlockIndex* index) override
472 : : {
473 : 2824 : m_notifications->blockDisconnected(kernel::MakeBlockInfo(index, block.get()));
474 : 2824 : }
475 : 37992 : void UpdatedBlockTip(const CBlockIndex* index, const CBlockIndex* fork_index, bool is_ibd) override
476 : : {
477 : 37992 : m_notifications->updatedBlockTip();
478 : 37992 : }
479 : 537 : void ChainStateFlushed(ChainstateRole role, const CBlockLocator& locator) override {
480 : 537 : m_notifications->chainStateFlushed(role, locator);
481 : 537 : }
482 : : std::shared_ptr<Chain::Notifications> m_notifications;
483 : : };
484 : :
485 : : class NotificationsHandlerImpl : public Handler
486 : : {
487 : : public:
488 : 797 : explicit NotificationsHandlerImpl(ValidationSignals& signals, std::shared_ptr<Chain::Notifications> notifications)
489 [ + - ]: 797 : : m_signals{signals}, m_proxy{std::make_shared<NotificationsProxy>(std::move(notifications))}
490 : : {
491 [ + - + - ]: 1594 : m_signals.RegisterSharedValidationInterface(m_proxy);
492 [ - - ]: 797 : }
493 [ - + ]: 1594 : ~NotificationsHandlerImpl() override { disconnect(); }
494 : 797 : void disconnect() override
495 : : {
496 [ + - ]: 797 : if (m_proxy) {
497 [ + - + - ]: 1594 : m_signals.UnregisterSharedValidationInterface(m_proxy);
498 : 797 : m_proxy.reset();
499 : : }
500 : 797 : }
501 : : ValidationSignals& m_signals;
502 : : std::shared_ptr<NotificationsProxy> m_proxy;
503 : : };
504 : :
505 : : class RpcHandlerImpl : public Handler
506 : : {
507 : : public:
508 [ + - ]: 28359 : explicit RpcHandlerImpl(const CRPCCommand& command) : m_command(command), m_wrapped_command(&command)
509 : : {
510 : 47386 : m_command.actor = [this](const JSONRPCRequest& request, UniValue& result, bool last_handler) {
511 [ + - ]: 19027 : if (!m_wrapped_command) return false;
512 : 19027 : try {
513 [ + + ]: 19027 : return m_wrapped_command->actor(request, result, last_handler);
514 [ - + ]: 655 : } catch (const UniValue& e) {
515 : : // If this is not the last handler and a wallet not found
516 : : // exception was thrown, return false so the next handler can
517 : : // try to handle the request. Otherwise, reraise the exception.
518 [ - + ]: 655 : if (!last_handler) {
519 [ - - - - ]: 0 : const UniValue& code = e["code"];
520 [ - - - - : 0 : if (code.isNum() && code.getInt<int>() == RPC_WALLET_NOT_FOUND) {
- - ]
521 : 0 : return false;
522 : : }
523 : : }
524 : 655 : throw;
525 : 655 : }
526 : 28359 : };
527 [ + - ]: 28359 : ::tableRPC.appendCommand(m_command.name, &m_command);
528 : 28359 : }
529 : :
530 : 28359 : void disconnect() final
531 : : {
532 [ + - ]: 28359 : if (m_wrapped_command) {
533 : 28359 : m_wrapped_command = nullptr;
534 : 28359 : ::tableRPC.removeCommand(m_command.name, &m_command);
535 : : }
536 : 28359 : }
537 : :
538 : 56718 : ~RpcHandlerImpl() override { disconnect(); }
539 : :
540 : : CRPCCommand m_command;
541 : : const CRPCCommand* m_wrapped_command;
542 : : };
543 : :
544 : : class ChainImpl : public Chain
545 : : {
546 : : public:
547 : 1777 : explicit ChainImpl(NodeContext& node) : m_node(node) {}
548 : 1557 : std::optional<int> getHeight() override
549 : : {
550 [ + - + - : 4671 : const int height{WITH_LOCK(::cs_main, return chainman().ActiveChain().Height())};
+ - ]
551 [ + + ]: 1557 : return height >= 0 ? std::optional{height} : std::nullopt;
552 : : }
553 : 1631 : uint256 getBlockHash(int height) override
554 : : {
555 : 1631 : LOCK(::cs_main);
556 [ + - + - : 3262 : return Assert(chainman().ActiveChain()[height])->GetBlockHash();
+ - + - +
- ]
557 : 1631 : }
558 : 705 : bool haveBlockOnDisk(int height) override
559 : : {
560 : 705 : LOCK(::cs_main);
561 [ + - + - : 706 : const CBlockIndex* block{chainman().ActiveChain()[height]};
+ - ]
562 [ + - + + : 706 : return block && ((block->nStatus & BLOCK_HAVE_DATA) != 0) && block->nTx > 0;
- + + - ]
563 : 705 : }
564 : 550 : CBlockLocator getTipLocator() override
565 : : {
566 : 550 : LOCK(::cs_main);
567 [ + - + - : 550 : return chainman().ActiveChain().GetLocator();
+ - ]
568 : 550 : }
569 : 2 : CBlockLocator getActiveChainLocator(const uint256& block_hash) override
570 : : {
571 : 2 : LOCK(::cs_main);
572 [ + - + - ]: 2 : const CBlockIndex* index = chainman().m_blockman.LookupBlockIndex(block_hash);
573 [ + - ]: 2 : return GetLocator(index);
574 : 2 : }
575 : 778 : std::optional<int> findLocatorFork(const CBlockLocator& locator) override
576 : : {
577 : 778 : LOCK(::cs_main);
578 [ + - + - : 778 : if (const CBlockIndex* fork = chainman().ActiveChainstate().FindForkInGlobalIndex(locator)) {
+ - + + ]
579 : 770 : return fork->nHeight;
580 : : }
581 : 8 : return std::nullopt;
582 : 778 : }
583 : 646 : bool hasBlockFilterIndex(BlockFilterType filter_type) override
584 : : {
585 : 646 : return GetBlockFilterIndex(filter_type) != nullptr;
586 : : }
587 : 616 : std::optional<bool> blockFilterMatchesAny(BlockFilterType filter_type, const uint256& block_hash, const GCSFilter::ElementSet& filter_set) override
588 : : {
589 : 616 : const BlockFilterIndex* block_filter_index{GetBlockFilterIndex(filter_type)};
590 [ - + ]: 616 : if (!block_filter_index) return std::nullopt;
591 : :
592 : 616 : BlockFilter filter;
593 [ + - + - : 1848 : const CBlockIndex* index{WITH_LOCK(::cs_main, return chainman().m_blockman.LookupBlockIndex(block_hash))};
+ - + - ]
594 [ + - + - : 616 : if (index == nullptr || !block_filter_index->LookupFilter(index, filter)) return std::nullopt;
- + ]
595 [ + - ]: 616 : return filter.GetFilter().MatchAny(filter_set);
596 : 616 : }
597 : 174112 : bool findBlock(const uint256& hash, const FoundBlock& block) override
598 : : {
599 : 174112 : WAIT_LOCK(cs_main, lock);
600 [ + - + - : 174112 : return FillBlock(chainman().m_blockman.LookupBlockIndex(hash), block, lock, chainman().ActiveChain(), chainman().m_blockman);
+ - + - +
- + - +
- ]
601 : 174112 : }
602 : 635 : bool findFirstBlockWithTimeAndHeight(int64_t min_time, int min_height, const FoundBlock& block) override
603 : : {
604 : 635 : WAIT_LOCK(cs_main, lock);
605 [ + - + - ]: 635 : const CChain& active = chainman().ActiveChain();
606 [ + - + - : 635 : return FillBlock(active.FindEarliestAtLeast(min_time, min_height), block, lock, active, chainman().m_blockman);
+ - + - ]
607 : 635 : }
608 : 38 : bool findAncestorByHeight(const uint256& block_hash, int ancestor_height, const FoundBlock& ancestor_out) override
609 : : {
610 : 38 : WAIT_LOCK(cs_main, lock);
611 [ + - + - ]: 38 : const CChain& active = chainman().ActiveChain();
612 [ + - + - : 38 : if (const CBlockIndex* block = chainman().m_blockman.LookupBlockIndex(block_hash)) {
+ - ]
613 [ + - + + ]: 38 : if (const CBlockIndex* ancestor = block->GetAncestor(ancestor_height)) {
614 [ + - + - ]: 37 : return FillBlock(ancestor, ancestor_out, lock, active, chainman().m_blockman);
615 : : }
616 : : }
617 [ + - + - ]: 1 : return FillBlock(nullptr, ancestor_out, lock, active, chainman().m_blockman);
618 : 38 : }
619 : 7 : bool findAncestorByHash(const uint256& block_hash, const uint256& ancestor_hash, const FoundBlock& ancestor_out) override
620 : : {
621 : 7 : WAIT_LOCK(cs_main, lock);
622 [ + - + - ]: 7 : const CBlockIndex* block = chainman().m_blockman.LookupBlockIndex(block_hash);
623 [ + - + - ]: 7 : const CBlockIndex* ancestor = chainman().m_blockman.LookupBlockIndex(ancestor_hash);
624 [ + + + - : 7 : if (block && ancestor && block->GetAncestor(ancestor->nHeight) != ancestor) ancestor = nullptr;
+ + ]
625 [ + - + - : 7 : return FillBlock(ancestor, ancestor_out, lock, chainman().ActiveChain(), chainman().m_blockman);
+ - + - +
- ]
626 : 7 : }
627 : 21 : bool findCommonAncestor(const uint256& block_hash1, const uint256& block_hash2, const FoundBlock& ancestor_out, const FoundBlock& block1_out, const FoundBlock& block2_out) override
628 : : {
629 : 21 : WAIT_LOCK(cs_main, lock);
630 [ + - + - ]: 21 : const CChain& active = chainman().ActiveChain();
631 [ + - + - ]: 21 : const CBlockIndex* block1 = chainman().m_blockman.LookupBlockIndex(block_hash1);
632 [ + - + - ]: 21 : const CBlockIndex* block2 = chainman().m_blockman.LookupBlockIndex(block_hash2);
633 [ + + + - ]: 21 : const CBlockIndex* ancestor = block1 && block2 ? LastCommonAncestor(block1, block2) : nullptr;
634 : : // Using & instead of && below to avoid short circuiting and leaving
635 : : // output uninitialized. Cast bool to int to avoid -Wbitwise-instead-of-logical
636 : : // compiler warnings.
637 [ + - + - ]: 21 : return int{FillBlock(ancestor, ancestor_out, lock, active, chainman().m_blockman)} &
638 [ + - + - ]: 21 : int{FillBlock(block1, block1_out, lock, active, chainman().m_blockman)} &
639 [ + - + - : 21 : int{FillBlock(block2, block2_out, lock, active, chainman().m_blockman)};
+ - ]
640 : 21 : }
641 : 881 : void findCoins(std::map<COutPoint, Coin>& coins) override { return FindCoins(m_node, coins); }
642 : 74463 : double guessVerificationProgress(const uint256& block_hash) override
643 : : {
644 : 74463 : LOCK(chainman().GetMutex());
645 [ + - + - : 74463 : return chainman().GuessVerificationProgress(chainman().m_blockman.LookupBlockIndex(block_hash));
+ - + - +
- ]
646 : 74463 : }
647 : 33 : bool hasBlocks(const uint256& block_hash, int min_height, std::optional<int> max_height) override
648 : : {
649 : : // hasBlocks returns true if all ancestors of block_hash in specified
650 : : // range have block data (are not pruned), false if any ancestors in
651 : : // specified range are missing data.
652 : : //
653 : : // For simplicity and robustness, min_height and max_height are only
654 : : // used to limit the range, and passing min_height that's too low or
655 : : // max_height that's too high will not crash or change the result.
656 : 33 : LOCK(::cs_main);
657 [ + - + - : 33 : if (const CBlockIndex* block = chainman().m_blockman.LookupBlockIndex(block_hash)) {
+ - ]
658 [ + + + + : 33 : if (max_height && block->nHeight >= *max_height) block = block->GetAncestor(*max_height);
+ - ]
659 [ + + ]: 2974 : for (; block->nStatus & BLOCK_HAVE_DATA; block = block->pprev) {
660 : : // Check pprev to not segfault if min_height is too low
661 [ + + + + ]: 2958 : if (block->nHeight <= min_height || !block->pprev) return true;
662 : : }
663 : : }
664 : : return false;
665 : 33 : }
666 : 643 : RBFTransactionState isRBFOptIn(const CTransaction& tx) override
667 : : {
668 [ - + ]: 643 : if (!m_node.mempool) return IsRBFOptInEmptyMempool(tx);
669 : 643 : LOCK(m_node.mempool->cs);
670 [ + - + - ]: 643 : return IsRBFOptIn(tx, *m_node.mempool);
671 : 643 : }
672 : 17805 : bool isInMempool(const uint256& txid) override
673 : : {
674 [ + - ]: 17805 : if (!m_node.mempool) return false;
675 : 17805 : LOCK(m_node.mempool->cs);
676 [ + - + - ]: 17805 : return m_node.mempool->exists(GenTxid::Txid(txid));
677 : 17805 : }
678 : 221 : bool hasDescendantsInMempool(const uint256& txid) override
679 : : {
680 [ + - ]: 221 : if (!m_node.mempool) return false;
681 : 221 : LOCK(m_node.mempool->cs);
682 [ + - ]: 221 : const auto entry{m_node.mempool->GetEntry(Txid::FromUint256(txid))};
683 [ + + ]: 221 : if (entry == nullptr) return false;
684 : 220 : return entry->GetCountWithDescendants() > 1;
685 : 221 : }
686 : 1575 : bool broadcastTransaction(const CTransactionRef& tx,
687 : : const CAmount& max_tx_fee,
688 : : bool relay,
689 : : std::string& err_string) override
690 : : {
691 [ + - + - : 3150 : const TransactionError err = BroadcastTransaction(m_node, tx, err_string, max_tx_fee, relay, /*wait_callback=*/false);
+ - ]
692 : : // Chain clients only care about failures to accept the tx to the mempool. Disregard non-mempool related failures.
693 : : // Note: this will need to be updated if BroadcastTransactions() is updated to return other non-mempool failures
694 : : // that Chain clients do not need to know about.
695 : 1575 : return TransactionError::OK == err;
696 : : }
697 : 576653 : void getTransactionAncestry(const uint256& txid, size_t& ancestors, size_t& descendants, size_t* ancestorsize, CAmount* ancestorfees) override
698 : : {
699 : 576653 : ancestors = descendants = 0;
700 [ + - ]: 576653 : if (!m_node.mempool) return;
701 : 576653 : m_node.mempool->GetTransactionAncestry(txid, ancestors, descendants, ancestorsize, ancestorfees);
702 : : }
703 : :
704 : 3771 : std::map<COutPoint, CAmount> calculateIndividualBumpFees(const std::vector<COutPoint>& outpoints, const CFeeRate& target_feerate) override
705 : : {
706 [ - + ]: 3771 : if (!m_node.mempool) {
707 : 0 : std::map<COutPoint, CAmount> bump_fees;
708 [ # # ]: 0 : for (const auto& outpoint : outpoints) {
709 [ # # ]: 0 : bump_fees.emplace(outpoint, 0);
710 : : }
711 : : return bump_fees;
712 : 0 : }
713 [ + - ]: 3771 : return MiniMiner(*m_node.mempool, outpoints).CalculateBumpFees(target_feerate);
714 : : }
715 : :
716 : 8654 : std::optional<CAmount> calculateCombinedBumpFee(const std::vector<COutPoint>& outpoints, const CFeeRate& target_feerate) override
717 : : {
718 [ - + ]: 8654 : if (!m_node.mempool) {
719 : 0 : return 0;
720 : : }
721 [ + - ]: 8654 : return MiniMiner(*m_node.mempool, outpoints).CalculateTotalBumpFees(target_feerate);
722 : : }
723 : 3064 : void getPackageLimits(unsigned int& limit_ancestor_count, unsigned int& limit_descendant_count) override
724 : : {
725 : 3064 : const CTxMemPool::Limits default_limits{};
726 : :
727 [ + - ]: 3064 : const CTxMemPool::Limits& limits{m_node.mempool ? m_node.mempool->m_opts.limits : default_limits};
728 : :
729 : 3064 : limit_ancestor_count = limits.ancestor_count;
730 : 3064 : limit_descendant_count = limits.descendant_count;
731 : 3064 : }
732 : 3207 : util::Result<void> checkChainLimits(const CTransactionRef& tx) override
733 : : {
734 [ - + ]: 3207 : if (!m_node.mempool) return {};
735 : 3207 : LockPoints lp;
736 : 3207 : CTxMemPoolEntry entry(tx, 0, 0, 0, 0, false, 0, lp);
737 [ + - ]: 3207 : LOCK(m_node.mempool->cs);
738 [ + - + - : 9621 : return m_node.mempool->CheckPackageLimits({tx}, entry.GetTxSize());
+ + + - -
- - - ]
739 [ + - + - ]: 9621 : }
740 : 5824 : CFeeRate estimateSmartFee(int num_blocks, bool conservative, FeeCalculation* calc) override
741 : : {
742 [ + + ]: 5824 : if (!m_node.fee_estimator) return {};
743 : 5802 : return m_node.fee_estimator->estimateSmartFee(num_blocks, calc, conservative);
744 : : }
745 : 3390 : unsigned int estimateMaxBlocks() override
746 : : {
747 [ + + ]: 3390 : if (!m_node.fee_estimator) return 0;
748 : 3375 : return m_node.fee_estimator->HighestTargetTracked(FeeEstimateHorizon::LONG_HALFLIFE);
749 : : }
750 : 2487 : CFeeRate mempoolMinFee() override
751 : : {
752 [ - + ]: 2487 : if (!m_node.mempool) return {};
753 : 2487 : return m_node.mempool->GetMinFee();
754 : : }
755 : 4090 : CFeeRate relayMinFee() override
756 : : {
757 [ - + ]: 4090 : if (!m_node.mempool) return CFeeRate{DEFAULT_MIN_RELAY_TX_FEE};
758 : 4090 : return m_node.mempool->m_opts.min_relay_feerate;
759 : : }
760 : 119 : CFeeRate relayIncrementalFee() override
761 : : {
762 [ - + ]: 119 : if (!m_node.mempool) return CFeeRate{DEFAULT_INCREMENTAL_RELAY_FEE};
763 : 119 : return m_node.mempool->m_opts.incremental_relay_feerate;
764 : : }
765 : 43979 : CFeeRate relayDustFee() override
766 : : {
767 [ - + ]: 43979 : if (!m_node.mempool) return CFeeRate{DUST_RELAY_TX_FEE};
768 : 43979 : return m_node.mempool->m_opts.dust_relay_feerate;
769 : : }
770 : 62 : bool havePruned() override
771 : : {
772 : 62 : LOCK(::cs_main);
773 [ + - + - ]: 62 : return chainman().m_blockman.m_have_pruned;
774 : 62 : }
775 : 1 : std::optional<int> getPruneHeight() override
776 : : {
777 : 1 : LOCK(chainman().GetMutex());
778 [ + - + - : 1 : return GetPruneHeight(chainman().m_blockman, chainman().ActiveChain());
+ - + - ]
779 : 1 : }
780 [ + - + + ]: 171 : bool isReadyToBroadcast() override { return !chainman().m_blockman.LoadingBlocks() && !isInitialBlockDownload(); }
781 : 2761 : bool isInitialBlockDownload() override
782 : : {
783 : 2761 : return chainman().IsInitialBlockDownload();
784 : : }
785 : 74261 : bool shutdownRequested() override { return ShutdownRequested(m_node); }
786 : 1221 : void initMessage(const std::string& message) override { ::uiInterface.InitMessage(message); }
787 : 3 : void initWarning(const bilingual_str& message) override { InitWarning(message); }
788 : 26 : void initError(const bilingual_str& message) override { InitError(message); }
789 : 16 : void showProgress(const std::string& title, int progress, bool resume_possible) override
790 : : {
791 : 16 : ::uiInterface.ShowProgress(title, progress, resume_possible);
792 : 16 : }
793 : 797 : std::unique_ptr<Handler> handleNotifications(std::shared_ptr<Notifications> notifications) override
794 : : {
795 : 797 : return std::make_unique<NotificationsHandlerImpl>(validation_signals(), std::move(notifications));
796 : : }
797 : 5958 : void waitForNotificationsIfTipChanged(const uint256& old_tip) override
798 : : {
799 [ + + + + : 23820 : if (!old_tip.IsNull() && old_tip == WITH_LOCK(::cs_main, return chainman().ActiveChain().Tip()->GetBlockHash())) return;
+ - + - +
- + - ]
800 : 334 : validation_signals().SyncWithValidationInterfaceQueue();
801 : : }
802 : 28359 : std::unique_ptr<Handler> handleRpc(const CRPCCommand& command) override
803 : : {
804 : 28359 : return std::make_unique<RpcHandlerImpl>(command);
805 : : }
806 : 20 : bool rpcEnableDeprecated(const std::string& method) override { return IsDeprecatedRPCEnabled(method); }
807 : 44 : void rpcRunLater(const std::string& name, std::function<void()> fn, int64_t seconds) override
808 : : {
809 [ + - ]: 44 : RPCRunLater(name, std::move(fn), seconds);
810 : 44 : }
811 : 0 : common::SettingsValue getSetting(const std::string& name) override
812 : : {
813 : 0 : return args().GetSetting(name);
814 : : }
815 : 731 : std::vector<common::SettingsValue> getSettingsList(const std::string& name) override
816 : : {
817 : 731 : return args().GetSettingsList(name);
818 : : }
819 : 3 : common::SettingsValue getRwSetting(const std::string& name) override
820 : : {
821 [ + - ]: 3 : common::SettingsValue result;
822 [ + - + - ]: 3 : args().LockSettings([&](const common::Settings& settings) {
823 [ + + ]: 3 : if (const common::SettingsValue* value = common::FindKey(settings.rw_settings, name)) {
824 : 2 : result = *value;
825 : : }
826 : 3 : });
827 : 3 : return result;
828 : 0 : }
829 : 194 : bool updateRwSetting(const std::string& name,
830 : : const interfaces::SettingsUpdate& update_settings_func) override
831 : : {
832 : 194 : std::optional<interfaces::SettingsAction> action;
833 : 194 : args().LockSettings([&](common::Settings& settings) {
834 [ + + ]: 194 : if (auto* value = common::FindKey(settings.rw_settings, name)) {
835 : 44 : action = update_settings_func(*value);
836 [ - + ]: 44 : if (value->isNull()) settings.rw_settings.erase(name);
837 : : } else {
838 [ + - ]: 150 : UniValue new_value;
839 [ + - ]: 150 : action = update_settings_func(new_value);
840 [ + + + - ]: 150 : if (!new_value.isNull()) settings.rw_settings[name] = std::move(new_value);
841 : 150 : }
842 : 194 : });
843 [ + - ]: 194 : if (!action) return false;
844 : : // Now dump value to disk if requested
845 [ + + + - ]: 194 : return *action != interfaces::SettingsAction::WRITE || args().WriteSettingsFile();
846 : : }
847 : 1 : bool overwriteRwSetting(const std::string& name, common::SettingsValue value, interfaces::SettingsAction action) override
848 : : {
849 [ + - ]: 1 : return updateRwSetting(name, [&](common::SettingsValue& settings) {
850 : 1 : settings = std::move(value);
851 : 1 : return action;
852 : 1 : });
853 : : }
854 : 0 : bool deleteRwSettings(const std::string& name, interfaces::SettingsAction action) override
855 : : {
856 [ # # ]: 0 : return overwriteRwSetting(name, {}, action);
857 : : }
858 : 1425 : void requestMempoolTransactions(Notifications& notifications) override
859 : : {
860 [ + - ]: 1425 : if (!m_node.mempool) return;
861 [ + - ]: 1425 : LOCK2(::cs_main, m_node.mempool->cs);
862 [ + - + - : 1759 : for (const CTxMemPoolEntry& entry : m_node.mempool->entryAll()) {
+ + ]
863 [ + - + - ]: 1002 : notifications.transactionAddedToMempool(entry.GetSharedTx());
864 [ + - ]: 1425 : }
865 [ + - ]: 2850 : }
866 : 58 : bool hasAssumedValidChain() override
867 : : {
868 : 58 : return chainman().IsSnapshotActive();
869 : : }
870 : :
871 : 721 : NodeContext* context() override { return &m_node; }
872 : 1115 : ArgsManager& args() { return *Assert(m_node.args); }
873 : 762144 : ChainstateManager& chainman() { return *Assert(m_node.chainman); }
874 : 1131 : ValidationSignals& validation_signals() { return *Assert(m_node.validation_signals); }
875 : : NodeContext& m_node;
876 : : };
877 : :
878 : : class BlockTemplateImpl : public BlockTemplate
879 : : {
880 : : public:
881 : 38468 : explicit BlockTemplateImpl(BlockAssembler::Options assemble_options,
882 : : std::unique_ptr<CBlockTemplate> block_template,
883 : 38468 : NodeContext& node) : m_assemble_options(std::move(assemble_options)),
884 [ - + ]: 38468 : m_block_template(std::move(block_template)),
885 : 38468 : m_node(node)
886 : : {
887 [ - + ]: 38468 : assert(m_block_template);
888 : 38468 : }
889 : :
890 : 1 : CBlockHeader getBlockHeader() override
891 : : {
892 : 1 : return m_block_template->block;
893 : : }
894 : :
895 : 40467 : CBlock getBlock() override
896 : : {
897 : 40467 : return m_block_template->block;
898 : : }
899 : :
900 : 2070 : std::vector<CAmount> getTxFees() override
901 : : {
902 : 2070 : return m_block_template->vTxFees;
903 : : }
904 : :
905 : 2070 : std::vector<int64_t> getTxSigops() override
906 : : {
907 : 2070 : return m_block_template->vTxSigOpsCost;
908 : : }
909 : :
910 : 0 : CTransactionRef getCoinbaseTx() override
911 : : {
912 [ # # ]: 0 : return m_block_template->block.vtx[0];
913 : : }
914 : :
915 : 4140 : std::vector<unsigned char> getCoinbaseCommitment() override
916 : : {
917 : 4140 : return m_block_template->vchCoinbaseCommitment;
918 : : }
919 : :
920 : 0 : int getWitnessCommitmentIndex() override
921 : : {
922 : 0 : return GetWitnessCommitmentIndex(m_block_template->block);
923 : : }
924 : :
925 : 0 : std::vector<uint256> getCoinbaseMerklePath() override
926 : : {
927 : 0 : return TransactionMerklePath(m_block_template->block, 0);
928 : : }
929 : :
930 : 55 : bool submitSolution(uint32_t version, uint32_t timestamp, uint32_t nonce, CTransactionRef coinbase) override
931 : : {
932 : 55 : CBlock block{m_block_template->block};
933 : :
934 [ - + ]: 55 : if (block.vtx.size() == 0) {
935 [ # # ]: 0 : block.vtx.push_back(coinbase);
936 : : } else {
937 : 55 : block.vtx[0] = coinbase;
938 : : }
939 : :
940 : 55 : block.nVersion = version;
941 : 55 : block.nTime = timestamp;
942 : 55 : block.nNonce = nonce;
943 : :
944 [ + - ]: 55 : block.hashMerkleRoot = BlockMerkleRoot(block);
945 : :
946 [ + - ]: 55 : auto block_ptr = std::make_shared<const CBlock>(block);
947 [ + - + - : 55 : return chainman().ProcessNewBlock(block_ptr, /*force_processing=*/true, /*min_pow_checked=*/true, /*new_block=*/nullptr);
+ - ]
948 : 55 : }
949 : :
950 : 60 : std::unique_ptr<BlockTemplate> waitNext(BlockWaitOptions options) override
951 : : {
952 : : // Delay calculating the current template fees, just in case a new block
953 : : // comes in before the next tick.
954 : 60 : CAmount current_fees = -1;
955 : :
956 : : // Alternate waiting for a new tip and checking if fees have risen.
957 : : // The latter check is expensive so we only run it once per second.
958 : 60 : auto now{NodeClock::now()};
959 : 60 : const auto deadline = now + options.timeout;
960 : 60 : const MillisecondsDouble tick{1000};
961 : 60 : const bool allow_min_difficulty{chainman().GetParams().GetConsensus().fPowAllowMinDifficultyBlocks};
962 : :
963 : 60 : do {
964 : 60 : bool tip_changed{false};
965 : 60 : {
966 : 60 : WAIT_LOCK(notifications().m_tip_block_mutex, lock);
967 : : // Note that wait_until() checks the predicate before waiting
968 [ + - + - ]: 60 : notifications().m_tip_block_cv.wait_until(lock, std::min(now + tick, deadline), [&]() EXCLUSIVE_LOCKS_REQUIRED(notifications().m_tip_block_mutex) {
969 : 65 : AssertLockHeld(notifications().m_tip_block_mutex);
970 : 65 : const auto tip_block{notifications().TipBlock()};
971 : : // We assume tip_block is set, because this is an instance
972 : : // method on BlockTemplate and no template could have been
973 : : // generated before a tip exists.
974 [ + - + + ]: 65 : tip_changed = Assume(tip_block) && tip_block != m_block_template->block.hashPrevBlock;
975 [ + + - + ]: 65 : return tip_changed || chainman().m_interrupt;
976 : : });
977 : 0 : }
978 : :
979 [ - + ]: 60 : if (chainman().m_interrupt) return nullptr;
980 : : // At this point the tip changed, a full tick went by or we reached
981 : : // the deadline.
982 : :
983 : : // Must release m_tip_block_mutex before locking cs_main, to avoid deadlocks.
984 : 60 : LOCK(::cs_main);
985 : :
986 : : // On test networks return a minimum difficulty block after 20 minutes
987 [ + + + + ]: 60 : if (!tip_changed && allow_min_difficulty) {
988 [ + - + - : 6 : const NodeClock::time_point tip_time{std::chrono::seconds{chainman().ActiveChain().Tip()->GetBlockTime()}};
+ - ]
989 [ + + ]: 3 : if (now > tip_time + 20min) {
990 : 1 : tip_changed = true;
991 : : }
992 : : }
993 : :
994 : : /**
995 : : * We determine if fees increased compared to the previous template by generating
996 : : * a fresh template. There may be more efficient ways to determine how much
997 : : * (approximate) fees for the next block increased, perhaps more so after
998 : : * Cluster Mempool.
999 : : *
1000 : : * We'll also create a new template if the tip changed during this iteration.
1001 : : */
1002 [ + + + - ]: 60 : if (options.fee_threshold < MAX_MONEY || tip_changed) {
1003 : 60 : auto tmpl{std::make_unique<BlockTemplateImpl>(m_assemble_options,
1004 : 60 : BlockAssembler{
1005 : 60 : chainman().ActiveChainstate(),
1006 : 60 : context()->mempool.get(),
1007 [ + - ]: 60 : m_assemble_options}
1008 [ + - ]: 120 : .CreateNewBlock(),
1009 [ + - + - ]: 120 : m_node)};
1010 : :
1011 : : // If the tip changed, return the new template regardless of its fees.
1012 [ + + ]: 60 : if (tip_changed) return tmpl;
1013 : :
1014 : : // Calculate the original template total fees if we haven't already
1015 [ + - ]: 4 : if (current_fees == -1) {
1016 : 4 : current_fees = 0;
1017 [ + + ]: 10 : for (CAmount fee : m_block_template->vTxFees) {
1018 : : // Skip coinbase
1019 [ - + ]: 6 : if (fee < 0) continue;
1020 : 6 : current_fees += fee;
1021 : : }
1022 : : }
1023 : :
1024 : 4 : CAmount new_fees = 0;
1025 [ + + ]: 11 : for (CAmount fee : tmpl->m_block_template->vTxFees) {
1026 : : // Skip coinbase
1027 [ - + ]: 8 : if (fee < 0) continue;
1028 : 8 : new_fees += fee;
1029 : 8 : Assume(options.fee_threshold != MAX_MONEY);
1030 [ + + ]: 8 : if (new_fees >= current_fees + options.fee_threshold) return tmpl;
1031 : : }
1032 [ + - ]: 60 : }
1033 : :
1034 [ + - ]: 3 : now = NodeClock::now();
1035 [ - + ]: 60 : } while (now < deadline);
1036 : :
1037 : 3 : return nullptr;
1038 : : }
1039 : :
1040 : : const BlockAssembler::Options m_assemble_options;
1041 : :
1042 : : const std::unique_ptr<CBlockTemplate> m_block_template;
1043 : :
1044 [ + - ]: 60 : NodeContext* context() { return &m_node; }
1045 : 248 : ChainstateManager& chainman() { return *Assert(m_node.chainman); }
1046 : 250 : KernelNotifications& notifications() { return *Assert(m_node.notifications); }
1047 : : NodeContext& m_node;
1048 : : };
1049 : :
1050 : : class MinerImpl : public Mining
1051 : : {
1052 : : public:
1053 : 1046 : explicit MinerImpl(NodeContext& node) : m_node(node) {}
1054 : :
1055 : 2071 : bool isTestChain() override
1056 : : {
1057 : 2071 : return chainman().GetParams().IsTestChain();
1058 : : }
1059 : :
1060 : 0 : bool isInitialBlockDownload() override
1061 : : {
1062 : 0 : return chainman().IsInitialBlockDownload();
1063 : : }
1064 : :
1065 : 40704 : std::optional<BlockRef> getTip() override
1066 : : {
1067 : 40704 : LOCK(::cs_main);
1068 [ + - + - : 40704 : CBlockIndex* tip{chainman().ActiveChain().Tip()};
+ - ]
1069 [ - + ]: 40704 : if (!tip) return {};
1070 : 40704 : return BlockRef{tip->GetBlockHash(), tip->nHeight};
1071 : 40704 : }
1072 : :
1073 : 38489 : std::optional<BlockRef> waitTipChanged(uint256 current_tip, MillisecondsDouble timeout) override
1074 : : {
1075 : 38489 : Assume(timeout >= 0ms); // No internal callers should use a negative timeout
1076 [ - + ]: 38489 : if (timeout < 0ms) timeout = 0ms;
1077 [ + + ]: 38489 : if (timeout > std::chrono::years{100}) timeout = std::chrono::years{100}; // Upper bound to avoid UB in std::chrono
1078 : 38489 : auto deadline{std::chrono::steady_clock::now() + timeout};
1079 : 38489 : {
1080 : 38489 : WAIT_LOCK(notifications().m_tip_block_mutex, lock);
1081 : : // For callers convenience, wait longer than the provided timeout
1082 : : // during startup for the tip to be non-null. That way this function
1083 : : // always returns valid tip information when possible and only
1084 : : // returns null when shutting down, not when timing out.
1085 [ + - + - ]: 38489 : notifications().m_tip_block_cv.wait(lock, [&]() EXCLUSIVE_LOCKS_REQUIRED(notifications().m_tip_block_mutex) {
1086 [ - + - - ]: 38489 : return notifications().TipBlock() || chainman().m_interrupt;
1087 : : });
1088 [ + - + - : 38489 : if (chainman().m_interrupt) return {};
- + - - ]
1089 : : // At this point TipBlock is set, so continue to wait until it is
1090 : : // different then `current_tip` provided by caller.
1091 [ + - + - ]: 38489 : notifications().m_tip_block_cv.wait_until(lock, deadline, [&]() EXCLUSIVE_LOCKS_REQUIRED(notifications().m_tip_block_mutex) {
1092 [ + + + + ]: 38510 : return Assume(notifications().TipBlock()) != current_tip || chainman().m_interrupt;
1093 : : });
1094 : 0 : }
1095 : :
1096 [ + + ]: 38489 : if (chainman().m_interrupt) return {};
1097 : :
1098 : : // Must release m_tip_block_mutex before getTip() locks cs_main, to
1099 : : // avoid deadlocks.
1100 : 38488 : return getTip();
1101 : : }
1102 : :
1103 : 38413 : std::unique_ptr<BlockTemplate> createNewBlock(const BlockCreateOptions& options) override
1104 : : {
1105 : : // Ensure m_tip_block is set so consumers of BlockTemplate can rely on that.
1106 [ - + ]: 38413 : if (!waitTipChanged(uint256::ZERO, MillisecondsDouble::max())) return {};
1107 : :
1108 [ + - ]: 38413 : BlockAssembler::Options assemble_options{options};
1109 [ + - + - ]: 38413 : ApplyArgsManOptions(*Assert(m_node.args), assemble_options);
1110 [ + - + - : 38413 : return std::make_unique<BlockTemplateImpl>(assemble_options, BlockAssembler{chainman().ActiveChainstate(), context()->mempool.get(), assemble_options}.CreateNewBlock(), m_node);
+ - + - +
+ + - ]
1111 : 38408 : }
1112 : :
1113 : 38413 : NodeContext* context() override { return &m_node; }
1114 : 158197 : ChainstateManager& chainman() { return *Assert(m_node.chainman); }
1115 : 192466 : KernelNotifications& notifications() { return *Assert(m_node.notifications); }
1116 : : NodeContext& m_node;
1117 : : };
1118 : : } // namespace
1119 : : } // namespace node
1120 : :
1121 : : namespace interfaces {
1122 : 0 : std::unique_ptr<Node> MakeNode(node::NodeContext& context) { return std::make_unique<node::NodeImpl>(context); }
1123 : 1777 : std::unique_ptr<Chain> MakeChain(node::NodeContext& context) { return std::make_unique<node::ChainImpl>(context); }
1124 : 1046 : std::unique_ptr<Mining> MakeMining(node::NodeContext& context) { return std::make_unique<node::MinerImpl>(context); }
1125 : : } // namespace interfaces
|
