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