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