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