Bitcoin Core  23.99.0
P2P Digital Currency
interfaces.cpp
Go to the documentation of this file.
1 // Copyright (c) 2018-2021 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 <chain.h>
8 #include <chainparams.h>
9 #include <deploymentstatus.h>
10 #include <external_signer.h>
11 #include <init.h>
12 #include <interfaces/chain.h>
13 #include <interfaces/handler.h>
14 #include <interfaces/node.h>
15 #include <interfaces/wallet.h>
16 #include <mapport.h>
17 #include <net.h>
18 #include <net_processing.h>
19 #include <netaddress.h>
20 #include <netbase.h>
21 #include <node/blockstorage.h>
22 #include <kernel/chain.h>
23 #include <node/coin.h>
24 #include <node/context.h>
25 #include <node/transaction.h>
26 #include <node/interface_ui.h>
27 #include <policy/feerate.h>
28 #include <policy/fees.h>
29 #include <policy/policy.h>
30 #include <policy/rbf.h>
31 #include <policy/settings.h>
32 #include <primitives/block.h>
33 #include <primitives/transaction.h>
34 #include <rpc/protocol.h>
35 #include <rpc/server.h>
36 #include <shutdown.h>
38 #include <sync.h>
39 #include <txmempool.h>
40 #include <uint256.h>
41 #include <univalue.h>
42 #include <util/check.h>
43 #include <util/system.h>
44 #include <util/translation.h>
45 #include <validation.h>
46 #include <validationinterface.h>
47 #include <warnings.h>
48 
49 #if defined(HAVE_CONFIG_H)
50 #include <config/bitcoin-config.h>
51 #endif
52 
53 #include <any>
54 #include <memory>
55 #include <optional>
56 #include <utility>
57 
58 #include <boost/signals2/signal.hpp>
59 
61 using interfaces::Chain;
65 using interfaces::Node;
67 
68 namespace node {
69 // All members of the classes in this namespace are intentionally public, as the
70 // classes themselves are private.
71 namespace {
72 #ifdef ENABLE_EXTERNAL_SIGNER
73 class ExternalSignerImpl : public interfaces::ExternalSigner
74 {
75 public:
76  ExternalSignerImpl(::ExternalSigner signer) : m_signer(std::move(signer)) {}
77  std::string getName() override { return m_signer.m_name; }
79 };
80 #endif
81 
82 class NodeImpl : public Node
83 {
84 public:
85  explicit NodeImpl(NodeContext& context) { setContext(&context); }
86  void initLogging() override { InitLogging(*Assert(m_context->args)); }
87  void initParameterInteraction() override { InitParameterInteraction(*Assert(m_context->args)); }
88  bilingual_str getWarnings() override { return GetWarnings(true); }
89  uint32_t getLogCategories() override { return LogInstance().GetCategoryMask(); }
90  bool baseInitialize() override
91  {
92  if (!AppInitBasicSetup(gArgs)) return false;
93  if (!AppInitParameterInteraction(gArgs, /*use_syscall_sandbox=*/false)) return false;
94 
95  m_context->kernel = std::make_unique<kernel::Context>();
96  if (!AppInitSanityChecks(*m_context->kernel)) return false;
97 
98  if (!AppInitLockDataDirectory()) return false;
99  if (!AppInitInterfaces(*m_context)) return false;
100 
101  return true;
102  }
103  bool appInitMain(interfaces::BlockAndHeaderTipInfo* tip_info) override
104  {
105  return AppInitMain(*m_context, tip_info);
106  }
107  void appShutdown() override
108  {
111  }
112  void startShutdown() override
113  {
114  StartShutdown();
115  // Stop RPC for clean shutdown if any of waitfor* commands is executed.
116  if (gArgs.GetBoolArg("-server", false)) {
117  InterruptRPC();
118  StopRPC();
119  }
120  }
121  bool shutdownRequested() override { return ShutdownRequested(); }
122  bool isSettingIgnored(const std::string& name) override
123  {
124  bool ignored = false;
125  gArgs.LockSettings([&](util::Settings& settings) {
126  if (auto* options = util::FindKey(settings.command_line_options, name)) {
127  ignored = !options->empty();
128  }
129  });
130  return ignored;
131  }
132  util::SettingsValue getPersistentSetting(const std::string& name) override { return gArgs.GetPersistentSetting(name); }
133  void updateRwSetting(const std::string& name, const util::SettingsValue& value) override
134  {
135  gArgs.LockSettings([&](util::Settings& settings) {
136  if (value.isNull()) {
137  settings.rw_settings.erase(name);
138  } else {
139  settings.rw_settings[name] = value;
140  }
141  });
143  }
144  void forceSetting(const std::string& name, const util::SettingsValue& value) override
145  {
146  gArgs.LockSettings([&](util::Settings& settings) {
147  if (value.isNull()) {
148  settings.forced_settings.erase(name);
149  } else {
150  settings.forced_settings[name] = value;
151  }
152  });
153  }
154  void resetSettings() override
155  {
156  gArgs.WriteSettingsFile(/*errors=*/nullptr, /*backup=*/true);
157  gArgs.LockSettings([&](util::Settings& settings) {
158  settings.rw_settings.clear();
159  });
161  }
162  void mapPort(bool use_upnp, bool use_natpmp) override { StartMapPort(use_upnp, use_natpmp); }
163  bool getProxy(Network net, Proxy& proxy_info) override { return GetProxy(net, proxy_info); }
164  size_t getNodeCount(ConnectionDirection flags) override
165  {
166  return m_context->connman ? m_context->connman->GetNodeCount(flags) : 0;
167  }
168  bool getNodesStats(NodesStats& stats) override
169  {
170  stats.clear();
171 
172  if (m_context->connman) {
173  std::vector<CNodeStats> stats_temp;
174  m_context->connman->GetNodeStats(stats_temp);
175 
176  stats.reserve(stats_temp.size());
177  for (auto& node_stats_temp : stats_temp) {
178  stats.emplace_back(std::move(node_stats_temp), false, CNodeStateStats());
179  }
180 
181  // Try to retrieve the CNodeStateStats for each node.
182  if (m_context->peerman) {
183  TRY_LOCK(::cs_main, lockMain);
184  if (lockMain) {
185  for (auto& node_stats : stats) {
186  std::get<1>(node_stats) =
187  m_context->peerman->GetNodeStateStats(std::get<0>(node_stats).nodeid, std::get<2>(node_stats));
188  }
189  }
190  }
191  return true;
192  }
193  return false;
194  }
195  bool getBanned(banmap_t& banmap) override
196  {
197  if (m_context->banman) {
198  m_context->banman->GetBanned(banmap);
199  return true;
200  }
201  return false;
202  }
203  bool ban(const CNetAddr& net_addr, int64_t ban_time_offset) override
204  {
205  if (m_context->banman) {
206  m_context->banman->Ban(net_addr, ban_time_offset);
207  return true;
208  }
209  return false;
210  }
211  bool unban(const CSubNet& ip) override
212  {
213  if (m_context->banman) {
214  m_context->banman->Unban(ip);
215  return true;
216  }
217  return false;
218  }
219  bool disconnectByAddress(const CNetAddr& net_addr) override
220  {
221  if (m_context->connman) {
222  return m_context->connman->DisconnectNode(net_addr);
223  }
224  return false;
225  }
226  bool disconnectById(NodeId id) override
227  {
228  if (m_context->connman) {
229  return m_context->connman->DisconnectNode(id);
230  }
231  return false;
232  }
233  std::vector<std::unique_ptr<interfaces::ExternalSigner>> listExternalSigners() override
234  {
235 #ifdef ENABLE_EXTERNAL_SIGNER
236  std::vector<ExternalSigner> signers = {};
237  const std::string command = gArgs.GetArg("-signer", "");
238  if (command == "") return {};
239  ExternalSigner::Enumerate(command, signers, Params().NetworkIDString());
240  std::vector<std::unique_ptr<interfaces::ExternalSigner>> result;
241  for (auto& signer : signers) {
242  result.emplace_back(std::make_unique<ExternalSignerImpl>(std::move(signer)));
243  }
244  return result;
245 #else
246  // This result is indistinguishable from a successful call that returns
247  // no signers. For the current GUI this doesn't matter, because the wallet
248  // creation dialog disables the external signer checkbox in both
249  // cases. The return type could be changed to std::optional<std::vector>
250  // (or something that also includes error messages) if this distinction
251  // becomes important.
252  return {};
253 #endif // ENABLE_EXTERNAL_SIGNER
254  }
255  int64_t getTotalBytesRecv() override { return m_context->connman ? m_context->connman->GetTotalBytesRecv() : 0; }
256  int64_t getTotalBytesSent() override { return m_context->connman ? m_context->connman->GetTotalBytesSent() : 0; }
257  size_t getMempoolSize() override { return m_context->mempool ? m_context->mempool->size() : 0; }
258  size_t getMempoolDynamicUsage() override { return m_context->mempool ? m_context->mempool->DynamicMemoryUsage() : 0; }
259  bool getHeaderTip(int& height, int64_t& block_time) override
260  {
261  LOCK(::cs_main);
262  auto best_header = chainman().m_best_header;
263  if (best_header) {
264  height = best_header->nHeight;
265  block_time = best_header->GetBlockTime();
266  return true;
267  }
268  return false;
269  }
270  int getNumBlocks() override
271  {
272  LOCK(::cs_main);
273  return chainman().ActiveChain().Height();
274  }
275  uint256 getBestBlockHash() override
276  {
277  const CBlockIndex* tip = WITH_LOCK(::cs_main, return chainman().ActiveChain().Tip());
278  return tip ? tip->GetBlockHash() : chainman().GetParams().GenesisBlock().GetHash();
279  }
280  int64_t getLastBlockTime() override
281  {
282  LOCK(::cs_main);
283  if (chainman().ActiveChain().Tip()) {
284  return chainman().ActiveChain().Tip()->GetBlockTime();
285  }
286  return chainman().GetParams().GenesisBlock().GetBlockTime(); // Genesis block's time of current network
287  }
288  double getVerificationProgress() override
289  {
290  return GuessVerificationProgress(chainman().GetParams().TxData(), WITH_LOCK(::cs_main, return chainman().ActiveChain().Tip()));
291  }
292  bool isInitialBlockDownload() override {
293  return chainman().ActiveChainstate().IsInitialBlockDownload();
294  }
295  bool getReindex() override { return node::fReindex; }
296  bool getImporting() override { return node::fImporting; }
297  void setNetworkActive(bool active) override
298  {
299  if (m_context->connman) {
300  m_context->connman->SetNetworkActive(active);
301  }
302  }
303  bool getNetworkActive() override { return m_context->connman && m_context->connman->GetNetworkActive(); }
304  CFeeRate getDustRelayFee() override
305  {
306  if (!m_context->mempool) return CFeeRate{DUST_RELAY_TX_FEE};
307  return m_context->mempool->m_dust_relay_feerate;
308  }
309  UniValue executeRpc(const std::string& command, const UniValue& params, const std::string& uri) override
310  {
311  JSONRPCRequest req;
312  req.context = m_context;
313  req.params = params;
314  req.strMethod = command;
315  req.URI = uri;
317  }
318  std::vector<std::string> listRpcCommands() override { return ::tableRPC.listCommands(); }
319  void rpcSetTimerInterfaceIfUnset(RPCTimerInterface* iface) override { RPCSetTimerInterfaceIfUnset(iface); }
320  void rpcUnsetTimerInterface(RPCTimerInterface* iface) override { RPCUnsetTimerInterface(iface); }
321  bool getUnspentOutput(const COutPoint& output, Coin& coin) override
322  {
323  LOCK(::cs_main);
324  return chainman().ActiveChainstate().CoinsTip().GetCoin(output, coin);
325  }
326  TransactionError broadcastTransaction(CTransactionRef tx, CAmount max_tx_fee, std::string& err_string) override
327  {
328  return BroadcastTransaction(*m_context, std::move(tx), err_string, max_tx_fee, /*relay=*/ true, /*wait_callback=*/ false);
329  }
330  WalletLoader& walletLoader() override
331  {
332  return *Assert(m_context->wallet_loader);
333  }
334  std::unique_ptr<Handler> handleInitMessage(InitMessageFn fn) override
335  {
336  return MakeHandler(::uiInterface.InitMessage_connect(fn));
337  }
338  std::unique_ptr<Handler> handleMessageBox(MessageBoxFn fn) override
339  {
340  return MakeHandler(::uiInterface.ThreadSafeMessageBox_connect(fn));
341  }
342  std::unique_ptr<Handler> handleQuestion(QuestionFn fn) override
343  {
344  return MakeHandler(::uiInterface.ThreadSafeQuestion_connect(fn));
345  }
346  std::unique_ptr<Handler> handleShowProgress(ShowProgressFn fn) override
347  {
348  return MakeHandler(::uiInterface.ShowProgress_connect(fn));
349  }
350  std::unique_ptr<Handler> handleInitWallet(InitWalletFn fn) override
351  {
352  return MakeHandler(::uiInterface.InitWallet_connect(fn));
353  }
354  std::unique_ptr<Handler> handleNotifyNumConnectionsChanged(NotifyNumConnectionsChangedFn fn) override
355  {
356  return MakeHandler(::uiInterface.NotifyNumConnectionsChanged_connect(fn));
357  }
358  std::unique_ptr<Handler> handleNotifyNetworkActiveChanged(NotifyNetworkActiveChangedFn fn) override
359  {
360  return MakeHandler(::uiInterface.NotifyNetworkActiveChanged_connect(fn));
361  }
362  std::unique_ptr<Handler> handleNotifyAlertChanged(NotifyAlertChangedFn fn) override
363  {
364  return MakeHandler(::uiInterface.NotifyAlertChanged_connect(fn));
365  }
366  std::unique_ptr<Handler> handleBannedListChanged(BannedListChangedFn fn) override
367  {
368  return MakeHandler(::uiInterface.BannedListChanged_connect(fn));
369  }
370  std::unique_ptr<Handler> handleNotifyBlockTip(NotifyBlockTipFn fn) override
371  {
372  return MakeHandler(::uiInterface.NotifyBlockTip_connect([fn](SynchronizationState sync_state, const CBlockIndex* block) {
373  fn(sync_state, BlockTip{block->nHeight, block->GetBlockTime(), block->GetBlockHash()},
374  GuessVerificationProgress(Params().TxData(), block));
375  }));
376  }
377  std::unique_ptr<Handler> handleNotifyHeaderTip(NotifyHeaderTipFn fn) override
378  {
379  return MakeHandler(
380  ::uiInterface.NotifyHeaderTip_connect([fn](SynchronizationState sync_state, const CBlockIndex* block) {
381  fn(sync_state, BlockTip{block->nHeight, block->GetBlockTime(), block->GetBlockHash()},
382  /* verification progress is unused when a header was received */ 0);
383  }));
384  }
385  NodeContext* context() override { return m_context; }
386  void setContext(NodeContext* context) override
387  {
388  m_context = context;
389  }
390  ChainstateManager& chainman() { return *Assert(m_context->chainman); }
391  NodeContext* m_context{nullptr};
392 };
393 
394 bool FillBlock(const CBlockIndex* index, const FoundBlock& block, UniqueLock<RecursiveMutex>& lock, const CChain& active)
395 {
396  if (!index) return false;
397  if (block.m_hash) *block.m_hash = index->GetBlockHash();
398  if (block.m_height) *block.m_height = index->nHeight;
399  if (block.m_time) *block.m_time = index->GetBlockTime();
400  if (block.m_max_time) *block.m_max_time = index->GetBlockTimeMax();
401  if (block.m_mtp_time) *block.m_mtp_time = index->GetMedianTimePast();
402  if (block.m_in_active_chain) *block.m_in_active_chain = active[index->nHeight] == index;
403  if (block.m_locator) { *block.m_locator = active.GetLocator(index); }
404  if (block.m_next_block) FillBlock(active[index->nHeight] == index ? active[index->nHeight + 1] : nullptr, *block.m_next_block, lock, active);
405  if (block.m_data) {
406  REVERSE_LOCK(lock);
407  if (!ReadBlockFromDisk(*block.m_data, index, Params().GetConsensus())) block.m_data->SetNull();
408  }
409  block.found = true;
410  return true;
411 }
412 
413 class NotificationsProxy : public CValidationInterface
414 {
415 public:
416  explicit NotificationsProxy(std::shared_ptr<Chain::Notifications> notifications)
417  : m_notifications(std::move(notifications)) {}
418  virtual ~NotificationsProxy() = default;
419  void TransactionAddedToMempool(const CTransactionRef& tx, uint64_t mempool_sequence) override
420  {
421  m_notifications->transactionAddedToMempool(tx, mempool_sequence);
422  }
423  void TransactionRemovedFromMempool(const CTransactionRef& tx, MemPoolRemovalReason reason, uint64_t mempool_sequence) override
424  {
425  m_notifications->transactionRemovedFromMempool(tx, reason, mempool_sequence);
426  }
427  void BlockConnected(const std::shared_ptr<const CBlock>& block, const CBlockIndex* index) override
428  {
429  m_notifications->blockConnected(kernel::MakeBlockInfo(index, block.get()));
430  }
431  void BlockDisconnected(const std::shared_ptr<const CBlock>& block, const CBlockIndex* index) override
432  {
433  m_notifications->blockDisconnected(kernel::MakeBlockInfo(index, block.get()));
434  }
435  void UpdatedBlockTip(const CBlockIndex* index, const CBlockIndex* fork_index, bool is_ibd) override
436  {
437  m_notifications->updatedBlockTip();
438  }
439  void ChainStateFlushed(const CBlockLocator& locator) override { m_notifications->chainStateFlushed(locator); }
440  std::shared_ptr<Chain::Notifications> m_notifications;
441 };
442 
443 class NotificationsHandlerImpl : public Handler
444 {
445 public:
446  explicit NotificationsHandlerImpl(std::shared_ptr<Chain::Notifications> notifications)
447  : m_proxy(std::make_shared<NotificationsProxy>(std::move(notifications)))
448  {
450  }
451  ~NotificationsHandlerImpl() override { disconnect(); }
452  void disconnect() override
453  {
454  if (m_proxy) {
456  m_proxy.reset();
457  }
458  }
459  std::shared_ptr<NotificationsProxy> m_proxy;
460 };
461 
462 class RpcHandlerImpl : public Handler
463 {
464 public:
465  explicit RpcHandlerImpl(const CRPCCommand& command) : m_command(command), m_wrapped_command(&command)
466  {
467  m_command.actor = [this](const JSONRPCRequest& request, UniValue& result, bool last_handler) {
468  if (!m_wrapped_command) return false;
469  try {
470  return m_wrapped_command->actor(request, result, last_handler);
471  } catch (const UniValue& e) {
472  // If this is not the last handler and a wallet not found
473  // exception was thrown, return false so the next handler can
474  // try to handle the request. Otherwise, reraise the exception.
475  if (!last_handler) {
476  const UniValue& code = e["code"];
477  if (code.isNum() && code.getInt<int>() == RPC_WALLET_NOT_FOUND) {
478  return false;
479  }
480  }
481  throw;
482  }
483  };
485  }
486 
487  void disconnect() final
488  {
489  if (m_wrapped_command) {
490  m_wrapped_command = nullptr;
492  }
493  }
494 
495  ~RpcHandlerImpl() override { disconnect(); }
496 
499 };
500 
501 class ChainImpl : public Chain
502 {
503 public:
504  explicit ChainImpl(NodeContext& node) : m_node(node) {}
505  std::optional<int> getHeight() override
506  {
507  const int height{WITH_LOCK(::cs_main, return chainman().ActiveChain().Height())};
508  return height >= 0 ? std::optional{height} : std::nullopt;
509  }
510  uint256 getBlockHash(int height) override
511  {
512  LOCK(::cs_main);
513  return Assert(chainman().ActiveChain()[height])->GetBlockHash();
514  }
515  bool haveBlockOnDisk(int height) override
516  {
517  LOCK(::cs_main);
518  const CBlockIndex* block{chainman().ActiveChain()[height]};
519  return block && ((block->nStatus & BLOCK_HAVE_DATA) != 0) && block->nTx > 0;
520  }
521  CBlockLocator getTipLocator() override
522  {
523  LOCK(::cs_main);
524  return chainman().ActiveChain().GetLocator();
525  }
526  CBlockLocator getActiveChainLocator(const uint256& block_hash) override
527  {
528  LOCK(::cs_main);
529  const CBlockIndex* index = chainman().m_blockman.LookupBlockIndex(block_hash);
530  if (!index) return {};
531  return chainman().ActiveChain().GetLocator(index);
532  }
533  std::optional<int> findLocatorFork(const CBlockLocator& locator) override
534  {
535  LOCK(::cs_main);
536  if (const CBlockIndex* fork = chainman().ActiveChainstate().FindForkInGlobalIndex(locator)) {
537  return fork->nHeight;
538  }
539  return std::nullopt;
540  }
541  bool findBlock(const uint256& hash, const FoundBlock& block) override
542  {
543  WAIT_LOCK(cs_main, lock);
544  return FillBlock(chainman().m_blockman.LookupBlockIndex(hash), block, lock, chainman().ActiveChain());
545  }
546  bool findFirstBlockWithTimeAndHeight(int64_t min_time, int min_height, const FoundBlock& block) override
547  {
548  WAIT_LOCK(cs_main, lock);
549  const CChain& active = chainman().ActiveChain();
550  return FillBlock(active.FindEarliestAtLeast(min_time, min_height), block, lock, active);
551  }
552  bool findAncestorByHeight(const uint256& block_hash, int ancestor_height, const FoundBlock& ancestor_out) override
553  {
554  WAIT_LOCK(cs_main, lock);
555  const CChain& active = chainman().ActiveChain();
556  if (const CBlockIndex* block = chainman().m_blockman.LookupBlockIndex(block_hash)) {
557  if (const CBlockIndex* ancestor = block->GetAncestor(ancestor_height)) {
558  return FillBlock(ancestor, ancestor_out, lock, active);
559  }
560  }
561  return FillBlock(nullptr, ancestor_out, lock, active);
562  }
563  bool findAncestorByHash(const uint256& block_hash, const uint256& ancestor_hash, const FoundBlock& ancestor_out) override
564  {
565  WAIT_LOCK(cs_main, lock);
566  const CBlockIndex* block = chainman().m_blockman.LookupBlockIndex(block_hash);
567  const CBlockIndex* ancestor = chainman().m_blockman.LookupBlockIndex(ancestor_hash);
568  if (block && ancestor && block->GetAncestor(ancestor->nHeight) != ancestor) ancestor = nullptr;
569  return FillBlock(ancestor, ancestor_out, lock, chainman().ActiveChain());
570  }
571  bool findCommonAncestor(const uint256& block_hash1, const uint256& block_hash2, const FoundBlock& ancestor_out, const FoundBlock& block1_out, const FoundBlock& block2_out) override
572  {
573  WAIT_LOCK(cs_main, lock);
574  const CChain& active = chainman().ActiveChain();
575  const CBlockIndex* block1 = chainman().m_blockman.LookupBlockIndex(block_hash1);
576  const CBlockIndex* block2 = chainman().m_blockman.LookupBlockIndex(block_hash2);
577  const CBlockIndex* ancestor = block1 && block2 ? LastCommonAncestor(block1, block2) : nullptr;
578  // Using & instead of && below to avoid short circuiting and leaving
579  // output uninitialized. Cast bool to int to avoid -Wbitwise-instead-of-logical
580  // compiler warnings.
581  return int{FillBlock(ancestor, ancestor_out, lock, active)} &
582  int{FillBlock(block1, block1_out, lock, active)} &
583  int{FillBlock(block2, block2_out, lock, active)};
584  }
585  void findCoins(std::map<COutPoint, Coin>& coins) override { return FindCoins(m_node, coins); }
586  double guessVerificationProgress(const uint256& block_hash) override
587  {
588  LOCK(::cs_main);
589  return GuessVerificationProgress(chainman().GetParams().TxData(), chainman().m_blockman.LookupBlockIndex(block_hash));
590  }
591  bool hasBlocks(const uint256& block_hash, int min_height, std::optional<int> max_height) override
592  {
593  // hasBlocks returns true if all ancestors of block_hash in specified
594  // range have block data (are not pruned), false if any ancestors in
595  // specified range are missing data.
596  //
597  // For simplicity and robustness, min_height and max_height are only
598  // used to limit the range, and passing min_height that's too low or
599  // max_height that's too high will not crash or change the result.
600  LOCK(::cs_main);
601  if (const CBlockIndex* block = chainman().m_blockman.LookupBlockIndex(block_hash)) {
602  if (max_height && block->nHeight >= *max_height) block = block->GetAncestor(*max_height);
603  for (; block->nStatus & BLOCK_HAVE_DATA; block = block->pprev) {
604  // Check pprev to not segfault if min_height is too low
605  if (block->nHeight <= min_height || !block->pprev) return true;
606  }
607  }
608  return false;
609  }
610  RBFTransactionState isRBFOptIn(const CTransaction& tx) override
611  {
612  if (!m_node.mempool) return IsRBFOptInEmptyMempool(tx);
613  LOCK(m_node.mempool->cs);
614  return IsRBFOptIn(tx, *m_node.mempool);
615  }
616  bool isInMempool(const uint256& txid) override
617  {
618  if (!m_node.mempool) return false;
619  LOCK(m_node.mempool->cs);
620  return m_node.mempool->exists(GenTxid::Txid(txid));
621  }
622  bool hasDescendantsInMempool(const uint256& txid) override
623  {
624  if (!m_node.mempool) return false;
625  LOCK(m_node.mempool->cs);
626  auto it = m_node.mempool->GetIter(txid);
627  return it && (*it)->GetCountWithDescendants() > 1;
628  }
629  bool broadcastTransaction(const CTransactionRef& tx,
630  const CAmount& max_tx_fee,
631  bool relay,
632  std::string& err_string) override
633  {
634  const TransactionError err = BroadcastTransaction(m_node, tx, err_string, max_tx_fee, relay, /*wait_callback=*/false);
635  // Chain clients only care about failures to accept the tx to the mempool. Disregard non-mempool related failures.
636  // Note: this will need to be updated if BroadcastTransactions() is updated to return other non-mempool failures
637  // that Chain clients do not need to know about.
638  return TransactionError::OK == err;
639  }
640  void getTransactionAncestry(const uint256& txid, size_t& ancestors, size_t& descendants, size_t* ancestorsize, CAmount* ancestorfees) override
641  {
642  ancestors = descendants = 0;
643  if (!m_node.mempool) return;
644  m_node.mempool->GetTransactionAncestry(txid, ancestors, descendants, ancestorsize, ancestorfees);
645  }
646  void getPackageLimits(unsigned int& limit_ancestor_count, unsigned int& limit_descendant_count) override
647  {
648  const CTxMemPool::Limits default_limits{};
649 
650  const CTxMemPool::Limits& limits{m_node.mempool ? m_node.mempool->m_limits : default_limits};
651 
652  limit_ancestor_count = limits.ancestor_count;
653  limit_descendant_count = limits.descendant_count;
654  }
655  bool checkChainLimits(const CTransactionRef& tx) override
656  {
657  if (!m_node.mempool) return true;
658  LockPoints lp;
659  CTxMemPoolEntry entry(tx, 0, 0, 0, false, 0, lp);
660  CTxMemPool::setEntries ancestors;
661  const CTxMemPool::Limits& limits{m_node.mempool->m_limits};
662  std::string unused_error_string;
663  LOCK(m_node.mempool->cs);
664  return m_node.mempool->CalculateMemPoolAncestors(
665  entry, ancestors, limits.ancestor_count, limits.ancestor_size_vbytes,
666  limits.descendant_count, limits.descendant_size_vbytes, unused_error_string);
667  }
668  CFeeRate estimateSmartFee(int num_blocks, bool conservative, FeeCalculation* calc) override
669  {
670  if (!m_node.fee_estimator) return {};
671  return m_node.fee_estimator->estimateSmartFee(num_blocks, calc, conservative);
672  }
673  unsigned int estimateMaxBlocks() override
674  {
675  if (!m_node.fee_estimator) return 0;
676  return m_node.fee_estimator->HighestTargetTracked(FeeEstimateHorizon::LONG_HALFLIFE);
677  }
678  CFeeRate mempoolMinFee() override
679  {
680  if (!m_node.mempool) return {};
681  return m_node.mempool->GetMinFee();
682  }
683  CFeeRate relayMinFee() override
684  {
685  if (!m_node.mempool) return CFeeRate{DEFAULT_MIN_RELAY_TX_FEE};
686  return m_node.mempool->m_min_relay_feerate;
687  }
688  CFeeRate relayIncrementalFee() override
689  {
690  if (!m_node.mempool) return CFeeRate{DEFAULT_INCREMENTAL_RELAY_FEE};
691  return m_node.mempool->m_incremental_relay_feerate;
692  }
693  CFeeRate relayDustFee() override
694  {
695  if (!m_node.mempool) return CFeeRate{DUST_RELAY_TX_FEE};
696  return m_node.mempool->m_dust_relay_feerate;
697  }
698  bool havePruned() override
699  {
700  LOCK(::cs_main);
701  return chainman().m_blockman.m_have_pruned;
702  }
703  bool isReadyToBroadcast() override { return !node::fImporting && !node::fReindex && !isInitialBlockDownload(); }
704  bool isInitialBlockDownload() override {
705  return chainman().ActiveChainstate().IsInitialBlockDownload();
706  }
707  bool shutdownRequested() override { return ShutdownRequested(); }
708  void initMessage(const std::string& message) override { ::uiInterface.InitMessage(message); }
709  void initWarning(const bilingual_str& message) override { InitWarning(message); }
710  void initError(const bilingual_str& message) override { InitError(message); }
711  void showProgress(const std::string& title, int progress, bool resume_possible) override
712  {
713  ::uiInterface.ShowProgress(title, progress, resume_possible);
714  }
715  std::unique_ptr<Handler> handleNotifications(std::shared_ptr<Notifications> notifications) override
716  {
717  return std::make_unique<NotificationsHandlerImpl>(std::move(notifications));
718  }
719  void waitForNotificationsIfTipChanged(const uint256& old_tip) override
720  {
721  if (!old_tip.IsNull() && old_tip == WITH_LOCK(::cs_main, return chainman().ActiveChain().Tip()->GetBlockHash())) return;
723  }
724  std::unique_ptr<Handler> handleRpc(const CRPCCommand& command) override
725  {
726  return std::make_unique<RpcHandlerImpl>(command);
727  }
728  bool rpcEnableDeprecated(const std::string& method) override { return IsDeprecatedRPCEnabled(method); }
729  void rpcRunLater(const std::string& name, std::function<void()> fn, int64_t seconds) override
730  {
731  RPCRunLater(name, std::move(fn), seconds);
732  }
733  int rpcSerializationFlags() override { return RPCSerializationFlags(); }
734  util::SettingsValue getSetting(const std::string& name) override
735  {
736  return gArgs.GetSetting(name);
737  }
738  std::vector<util::SettingsValue> getSettingsList(const std::string& name) override
739  {
740  return gArgs.GetSettingsList(name);
741  }
742  util::SettingsValue getRwSetting(const std::string& name) override
743  {
744  util::SettingsValue result;
745  gArgs.LockSettings([&](const util::Settings& settings) {
746  if (const util::SettingsValue* value = util::FindKey(settings.rw_settings, name)) {
747  result = *value;
748  }
749  });
750  return result;
751  }
752  bool updateRwSetting(const std::string& name, const util::SettingsValue& value, bool write) override
753  {
754  gArgs.LockSettings([&](util::Settings& settings) {
755  if (value.isNull()) {
756  settings.rw_settings.erase(name);
757  } else {
758  settings.rw_settings[name] = value;
759  }
760  });
761  return !write || gArgs.WriteSettingsFile();
762  }
763  void requestMempoolTransactions(Notifications& notifications) override
764  {
765  if (!m_node.mempool) return;
766  LOCK2(::cs_main, m_node.mempool->cs);
767  for (const CTxMemPoolEntry& entry : m_node.mempool->mapTx) {
768  notifications.transactionAddedToMempool(entry.GetSharedTx(), 0 /* mempool_sequence */);
769  }
770  }
771  bool hasAssumedValidChain() override
772  {
773  return chainman().IsSnapshotActive();
774  }
775 
776  NodeContext* context() override { return &m_node; }
777  ChainstateManager& chainman() { return *Assert(m_node.chainman); }
778  NodeContext& m_node;
779 };
780 } // namespace
781 } // namespace node
782 
783 namespace interfaces {
784 std::unique_ptr<Node> MakeNode(node::NodeContext& context) { return std::make_unique<node::NodeImpl>(context); }
785 std::unique_ptr<Chain> MakeChain(node::NodeContext& context) { return std::make_unique<node::ChainImpl>(context); }
786 } // namespace interfaces
CValidationInterface
Implement this to subscribe to events generated in validation.
Definition: validationinterface.h:76
CBlockIndex::GetBlockTime
int64_t GetBlockTime() const
Definition: chain.h:278
interfaces::MakeChain
std::unique_ptr< Chain > MakeChain(node::NodeContext &node)
Return implementation of Chain interface.
Definition: interfaces.cpp:785
CValidationInterface::TransactionRemovedFromMempool
virtual void TransactionRemovedFromMempool(const CTransactionRef &tx, MemPoolRemovalReason reason, uint64_t mempool_sequence)
Notifies listeners of a transaction leaving mempool.
Definition: validationinterface.h:132
NodeId
int64_t NodeId
Definition: net.h:92
interfaces
Definition: dummywallet.cpp:10
AppInitInterfaces
bool AppInitInterfaces(NodeContext &node)
Initialize node and wallet interface pointers.
Definition: init.cpp:1085
block.h
LOCK2
#define LOCK2(cs1, cs2)
Definition: sync.h:262
ShutdownRequested
bool ShutdownRequested()
Returns true if a shutdown is requested, false otherwise.
Definition: shutdown.cpp:89
CTxMemPool::setEntries
std::set< txiter, CompareIteratorByHash > setEntries
Definition: txmempool.h:527
policy.h
DUST_RELAY_TX_FEE
static constexpr unsigned int DUST_RELAY_TX_FEE
Min feerate for defining dust.
Definition: policy.h:55
interfaces::Chain::findAncestorByHash
virtual bool findAncestorByHash(const uint256 &block_hash, const uint256 &ancestor_hash, const FoundBlock &ancestor_out={})=0
Return whether block descends from a specified ancestor, and optionally return ancestor information.
m_proxy
std::shared_ptr< NotificationsProxy > m_proxy
Definition: interfaces.cpp:459
feerate.h
ArgsManager::GetBoolArg
bool GetBoolArg(const std::string &strArg, bool fDefault) const
Return boolean argument or default value.
Definition: system.cpp:654
interfaces::Chain::guessVerificationProgress
virtual double guessVerificationProgress(const uint256 &block_hash)=0
Estimate fraction of total transactions verified if blocks up to the specified block hash are verifie...
StartMapPort
void StartMapPort(bool use_upnp, bool use_natpmp)
Definition: mapport.cpp:327
RegisterSharedValidationInterface
void RegisterSharedValidationInterface(std::shared_ptr< CValidationInterface > callbacks)
Register subscriber.
Definition: validationinterface.cpp:124
CBlockIndex::GetAncestor
CBlockIndex * GetAncestor(int height)
Efficiently find an ancestor of this block.
Definition: chain.cpp:119
interfaces::Chain::rpcSerializationFlags
virtual int rpcSerializationFlags()=0
Current RPC serialization flags.
check.h
util::Settings
Stored settings.
Definition: settings.h:31
mapport.h
m_context
NodeContext * m_context
Definition: interfaces.cpp:391
settings.h
interfaces::FoundBlock::m_data
CBlock * m_data
Definition: chain.h:76
InitParameterInteraction
void InitParameterInteraction(ArgsManager &args)
Parameter interaction: change current parameters depending on various rules.
Definition: init.cpp:655
interfaces::Chain::findCoins
virtual void findCoins(std::map< COutPoint, Coin > &coins)=0
Look up unspent output information.
JSONRPCRequest::context
std::any context
Definition: request.h:38
flags
int flags
Definition: bitcoin-tx.cpp:526
ArgsManager::GetSetting
util::SettingsValue GetSetting(const std::string &arg) const
Get setting value.
Definition: system.cpp:1093
RPCTimerInterface
RPC timer "driver".
Definition: server.h:59
CBlockIndex::nTx
unsigned int nTx
Number of transactions in this block.
Definition: chain.h:182
InitLogging
void InitLogging(const ArgsManager &args)
Initialize global loggers.
Definition: init.cpp:734
GetWarnings
bilingual_str GetWarnings(bool verbose)
Format a string that describes several potential problems detected by the core.
Definition: warnings.cpp:31
REVERSE_LOCK
#define REVERSE_LOCK(g)
Definition: sync.h:242
sync.h
transaction.h
CValidationInterface::BlockDisconnected
virtual void BlockDisconnected(const std::shared_ptr< const CBlock > &block, const CBlockIndex *pindex)
Notifies listeners of a block being disconnected.
Definition: validationinterface.h:145
RPCUnsetTimerInterface
void RPCUnsetTimerInterface(RPCTimerInterface *iface)
Unset factory function for timers.
Definition: server.cpp:522
interfaces::Chain::hasAssumedValidChain
virtual bool hasAssumedValidChain()=0
Return true if an assumed-valid chain is in use.
RBFTransactionState
RBFTransactionState
The rbf state of unconfirmed transactions.
Definition: rbf.h:27
InterruptRPC
void InterruptRPC()
Definition: server.cpp:296
bilingual_str
Bilingual messages:
Definition: translation.h:18
interfaces::Chain::isInitialBlockDownload
virtual bool isInitialBlockDownload()=0
Check if in IBD.
CNetAddr
Network address.
Definition: netaddress.h:117
uint256.h
CBlockIndex::pprev
CBlockIndex * pprev
pointer to the index of the predecessor of this block
Definition: chain.h:157
interfaces::FoundBlock::m_in_active_chain
bool * m_in_active_chain
Definition: chain.h:73
CBlockIndex::nHeight
int nHeight
height of the entry in the chain. The genesis block has height 0
Definition: chain.h:163
node::NodeContext
NodeContext struct containing references to chain state and connection state.
Definition: context.h:43
node::FindCoins
void FindCoins(const NodeContext &node, std::map< COutPoint, Coin > &coins)
Look up unspent output information.
Definition: coin.cpp:12
validationinterface.h
handler.h
IsRBFOptInEmptyMempool
RBFTransactionState IsRBFOptInEmptyMempool(const CTransaction &tx)
Definition: rbf.cpp:52
CTxMemPoolEntry::GetSharedTx
CTransactionRef GetSharedTx() const
Definition: txmempool.h:130
ArgsManager::GetPersistentSetting
util::SettingsValue GetPersistentSetting(const std::string &name) const
Get current setting from config file or read/write settings file, ignoring nonpersistent command line...
Definition: system.cpp:592
interfaces::Chain::handleNotifications
virtual std::unique_ptr< Handler > handleNotifications(std::shared_ptr< Notifications > notifications)=0
Register handler for notifications.
interfaces::Chain::getSettingsList
virtual std::vector< util::SettingsValue > getSettingsList(const std::string &arg)=0
Get list of settings values.
interfaces::Handler::disconnect
virtual void disconnect()=0
Disconnect the handler.
interfaces::Chain::hasDescendantsInMempool
virtual bool hasDescendantsInMempool(const uint256 &txid)=0
Check if transaction has descendants in mempool.
RPCRunLater
void RPCRunLater(const std::string &name, std::function< void()> func, int64_t nSeconds)
Run func nSeconds from now.
Definition: server.cpp:528
LastCommonAncestor
const CBlockIndex * LastCommonAncestor(const CBlockIndex *pa, const CBlockIndex *pb)
Find the last common ancestor two blocks have.
Definition: chain.cpp:164
WITH_LOCK
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
Definition: sync.h:305
interfaces::FoundBlock::found
bool found
Definition: chain.h:77
BCLog::Logger::GetCategoryMask
uint32_t GetCategoryMask() const
Definition: logging.h:146
protocol.h
ExternalSigner::Enumerate
static bool Enumerate(const std::string &command, std::vector< ExternalSigner > &signers, const std::string chain)
Obtain a list of signers.
Definition: external_signer.cpp:24
interfaces::FoundBlock::m_next_block
const FoundBlock * m_next_block
Definition: chain.h:75
interfaces::BlockAndHeaderTipInfo
Block and header tip information.
Definition: node.h:49
node::fImporting
std::atomic_bool fImporting
interfaces::Chain::getHeight
virtual std::optional< int > getHeight()=0
Get current chain height, not including genesis block (returns 0 if chain only contains genesis block...
UniValue::getInt
Int getInt() const
Definition: univalue.h:137
UniValue::isNull
bool isNull() const
Definition: univalue.h:74
TRY_LOCK
#define TRY_LOCK(cs, name)
Definition: sync.h:265
interfaces::Chain::context
virtual node::NodeContext * context()
Get internal node context.
Definition: chain.h:319
interfaces::Chain::findBlock
virtual bool findBlock(const uint256 &hash, const FoundBlock &block={})=0
Return whether node has the block and optionally return block metadata or contents.
bitcoin-config.h
chainparams.h
AppInitBasicSetup
bool AppInitBasicSetup(const ArgsManager &args)
Initialize bitcoin core: Basic context setup.
Definition: init.cpp:764
chain.h
GenTxid::Txid
static GenTxid Txid(const uint256 &hash)
Definition: transaction.h:425
CTransactionRef
std::shared_ptr< const CTransaction > CTransactionRef
Definition: transaction.h:414
UniValue::isNum
bool isNum() const
Definition: univalue.h:79
interfaces::Chain::findAncestorByHeight
virtual bool findAncestorByHeight(const uint256 &block_hash, int ancestor_height, const FoundBlock &ancestor_out={})=0
Find ancestor of block at specified height and optionally return ancestor information.
Network
Network
A network type.
Definition: netaddress.h:44
node::ReadBlockFromDisk
bool ReadBlockFromDisk(CBlock &block, const FlatFilePos &pos, const Consensus::Params &consensusParams)
Functions for disk access for blocks.
Definition: blockstorage.cpp:713
context.h
interfaces::Chain::getRwSetting
virtual util::SettingsValue getRwSetting(const std::string &name)=0
Return <datadir>/settings.json setting value.
Assert
#define Assert(val)
Identity function.
Definition: check.h:74
CFeeRate
Fee rate in satoshis per kilovirtualbyte: CAmount / kvB.
Definition: feerate.h:32
interfaces::Chain::getPackageLimits
virtual void getPackageLimits(unsigned int &limit_ancestor_count, unsigned int &limit_descendant_count)=0
Get the node's package limits.
UniValue
Definition: univalue.h:18
CTransaction
The basic transaction that is broadcasted on the network and contained in blocks.
Definition: transaction.h:287
interface_ui.h
txmempool.h
shutdown.h
transaction.h
deploymentstatus.h
interfaces::Chain::relayIncrementalFee
virtual CFeeRate relayIncrementalFee()=0
Relay incremental fee setting (-incrementalrelayfee), reflecting cost of relay.
interfaces::Chain::getActiveChainLocator
virtual CBlockLocator getActiveChainLocator(const uint256 &block_hash)=0
Return a locator that refers to a block in the active chain.
CBlockIndex::GetBlockTimeMax
int64_t GetBlockTimeMax() const
Definition: chain.h:283
CChain::FindEarliestAtLeast
CBlockIndex * FindEarliestAtLeast(int64_t nTime, int height) const
Find the earliest block with timestamp equal or greater than the given time and height equal or great...
Definition: chain.cpp:70
addrdb.h
FeeEstimateHorizon::LONG_HALFLIFE
@ LONG_HALFLIFE
interfaces::Chain::isReadyToBroadcast
virtual bool isReadyToBroadcast()=0
Check if the node is ready to broadcast transactions.
SyncWithValidationInterfaceQueue
void SyncWithValidationInterfaceQueue()
This is a synonym for the following, which asserts certain locks are not held: std::promise<void> pro...
Definition: validationinterface.cpp:163
TransactionError
TransactionError
Definition: error.h:22
interfaces::Chain::havePruned
virtual bool havePruned()=0
Check if any block has been pruned.
interfaces::Chain
Interface giving clients (wallet processes, maybe other analysis tools in the future) ability to acce...
Definition: chain.h:117
external_signer.h
FeeCalculation
Definition: fees.h:76
CValidationInterface::BlockConnected
virtual void BlockConnected(const std::shared_ptr< const CBlock > &block, const CBlockIndex *pindex)
Notifies listeners of a block being connected.
Definition: validationinterface.h:139
banman.h
coin.h
GetProxy
bool GetProxy(enum Network net, Proxy &proxyInfoOut)
Definition: netbase.cpp:623
Proxy
Definition: netbase.h:48
node::fReindex
std::atomic_bool fReindex
kernel::MakeBlockInfo
interfaces::BlockInfo MakeBlockInfo(const CBlockIndex *index, const CBlock *data)
Return data from block index.
Definition: chain.cpp:13
interfaces::FoundBlock::m_time
int64_t * m_time
Definition: chain.h:70
interfaces::ExternalSigner
External signer interface used by the GUI.
Definition: node.h:59
m_notifications
std::shared_ptr< Chain::Notifications > m_notifications
Definition: interfaces.cpp:440
RPCSetTimerInterfaceIfUnset
void RPCSetTimerInterfaceIfUnset(RPCTimerInterface *iface)
Set the factory function for timer, but only, if unset.
Definition: server.cpp:511
ip
static CService ip(uint32_t i)
Definition: denialofservice_tests.cpp:29
CRPCCommand
Definition: server.h:89
Coin
A UTXO entry.
Definition: coins.h:30
InitWarning
void InitWarning(const bilingual_str &str)
Show warning message.
Definition: interface_ui.cpp:65
RPC_WALLET_NOT_FOUND
@ RPC_WALLET_NOT_FOUND
Invalid wallet specified.
Definition: protocol.h:80
interfaces::Chain::getBlockHash
virtual uint256 getBlockHash(int height)=0
Get block hash. Height must be valid or this function will abort.
interfaces::Chain::mempoolMinFee
virtual CFeeRate mempoolMinFee()=0
Mempool minimum fee.
CBlockIndex::GetMedianTimePast
int64_t GetMedianTimePast() const
Definition: chain.h:290
CValidationInterface::ChainStateFlushed
virtual void ChainStateFlushed(const CBlockLocator &locator)
Notifies listeners of the new active block chain on-disk.
Definition: validationinterface.h:162
InitError
bool InitError(const bilingual_str &str)
Show error message.
Definition: interface_ui.cpp:59
node.h
CRPCTable::execute
UniValue execute(const JSONRPCRequest &request) const
Execute a method.
Definition: server.cpp:449
interfaces::MakeNode
std::unique_ptr< Node > MakeNode(node::NodeContext &context)
Return implementation of Node interface.
Definition: interfaces.cpp:784
JSONRPCRequest::strMethod
std::string strMethod
Definition: request.h:32
interfaces::Chain::waitForNotificationsIfTipChanged
virtual void waitForNotificationsIfTipChanged(const uint256 &old_tip)=0
Wait for pending notifications to be processed unless block hash points to the current chain tip.
AppInitMain
bool AppInitMain(NodeContext &node, interfaces::BlockAndHeaderTipInfo *tip_info)
Bitcoin core main initialization.
Definition: init.cpp:1091
netaddress.h
univalue.h
CChain::GetLocator
CBlockLocator GetLocator(const CBlockIndex *pindex=nullptr) const
Return a CBlockLocator that refers to a block in this chain (by default the tip).
Definition: chain.cpp:31
tableRPC
CRPCTable tableRPC
Definition: server.cpp:546
interfaces::Chain::findLocatorFork
virtual std::optional< int > findLocatorFork(const CBlockLocator &locator)=0
Return height of the highest block on chain in common with the locator, which will either be the orig...
interfaces::WalletLoader
Wallet chain client that in addition to having chain client methods for starting up,...
Definition: wallet.h:319
UnregisterSharedValidationInterface
void UnregisterSharedValidationInterface(std::shared_ptr< CValidationInterface > callbacks)
Unregister subscriber.
Definition: validationinterface.cpp:138
ArgsManager::GetArg
std::string GetArg(const std::string &strArg, const std::string &strDefault) const
Return string argument or default value.
Definition: system.cpp:604
CAmount
int64_t CAmount
Amount in satoshis (Can be negative)
Definition: amount.h:12
CValidationInterface::TransactionAddedToMempool
virtual void TransactionAddedToMempool(const CTransactionRef &tx, uint64_t mempool_sequence)
Notifies listeners of a transaction having been added to mempool.
Definition: validationinterface.h:98
CRPCTable::listCommands
std::vector< std::string > listCommands() const
Returns a list of registered commands.
Definition: server.cpp:487
context
WalletContext context
Definition: notifications.cpp:37
Interrupt
void Interrupt(NodeContext &node)
Interrupt threads.
Definition: init.cpp:192
interfaces::Chain::relayMinFee
virtual CFeeRate relayMinFee()=0
Relay current minimum fee (from -minrelaytxfee and -incrementalrelayfee settings).
CSubNet
Definition: netaddress.h:467
chain.h
interfaces::Chain::shutdownRequested
virtual bool shutdownRequested()=0
Check if shutdown requested.
interfaces::Chain::broadcastTransaction
virtual bool broadcastTransaction(const CTransactionRef &tx, const CAmount &max_tx_fee, bool relay, std::string &err_string)=0
Transaction is added to memory pool, if the transaction fee is below the amount specified by max_tx_f...
interfaces::Chain::updateRwSetting
virtual bool updateRwSetting(const std::string &name, const util::SettingsValue &value, bool write=true)=0
Write a setting to <datadir>/settings.json.
interfaces::FoundBlock
Helper for findBlock to selectively return pieces of block data.
Definition: chain.h:50
m_node
NodeContext & m_node
Definition: interfaces.cpp:778
interfaces::Chain::rpcRunLater
virtual void rpcRunLater(const std::string &name, std::function< void()> fn, int64_t seconds)=0
Run function after given number of seconds. Cancel any previous calls with same name.
uint256
256-bit opaque blob.
Definition: uint256.h:126
ArgsManager::WriteSettingsFile
bool WriteSettingsFile(std::vector< std::string > *errors=nullptr, bool backup=false) const
Write settings file or backup settings file.
Definition: system.cpp:572
net_processing.h
CBlockIndex::GetBlockHash
uint256 GetBlockHash() const
Definition: chain.h:263
gArgs
ArgsManager gArgs
Definition: system.cpp:86
AppInitParameterInteraction
bool AppInitParameterInteraction(const ArgsManager &args, bool use_syscall_sandbox)
Initialization: parameter interaction.
Definition: init.cpp:809
interfaces::Node
Top-level interface for a bitcoin node (bitcoind process).
Definition: node.h:69
interfaces::Chain::isRBFOptIn
virtual RBFTransactionState isRBFOptIn(const CTransaction &tx)=0
Check if transaction is RBF opt in.
interfaces::Chain::findCommonAncestor
virtual bool findCommonAncestor(const uint256 &block_hash1, const uint256 &block_hash2, const FoundBlock &ancestor_out={}, const FoundBlock &block1_out={}, const FoundBlock &block2_out={})=0
Find most recent common ancestor between two blocks and optionally return block information.
JSONRPCRequest::params
UniValue params
Definition: request.h:33
interfaces::Chain::rpcEnableDeprecated
virtual bool rpcEnableDeprecated(const std::string &method)=0
Check if deprecated RPC is enabled.
ChainstateManager
Provides an interface for creating and interacting with one or two chainstates: an IBD chainstate gen...
Definition: validation.h:793
secure.h
ExternalSigner
Enables interaction with an external signing device or service, such as a hardware wallet.
Definition: external_signer.h:18
name
const char * name
Definition: rest.cpp:46
interfaces::Chain::estimateSmartFee
virtual CFeeRate estimateSmartFee(int num_blocks, bool conservative, FeeCalculation *calc=nullptr)=0
Estimate smart fee.
interfaces::Chain::initWarning
virtual void initWarning(const bilingual_str &message)=0
Send init warning.
system.h
ArgsManager::LockSettings
void LockSettings(Fn &&fn)
Access settings with lock held.
Definition: system.h:474
interfaces::FoundBlock::m_hash
uint256 * m_hash
Definition: chain.h:68
ArgsManager::GetSettingsList
std::vector< util::SettingsValue > GetSettingsList(const std::string &arg) const
Get list of setting values.
Definition: system.cpp:1101
CRPCCommand::actor
Actor actor
Definition: server.h:117
CRPCTable::appendCommand
void appendCommand(const std::string &name, const CRPCCommand *pcmd)
Appends a CRPCCommand to the dispatch table.
Definition: server.cpp:269
m_signer
::ExternalSigner m_signer
Definition: interfaces.cpp:78
CChain
An in-memory indexed chain of blocks.
Definition: chain.h:416
command
const auto command
Definition: bitcoin-wallet.cpp:118
base_blob::IsNull
bool IsNull() const
Definition: uint256.h:33
AppInitLockDataDirectory
bool AppInitLockDataDirectory()
Lock bitcoin core data directory.
Definition: init.cpp:1073
fees.h
kernel::MemPoolLimits
Options struct containing limit options for a CTxMemPool.
Definition: mempool_limits.h:18
util::FindKey
auto FindKey(Map &&map, Key &&key) -> decltype(&map.at(key))
Map lookup helper.
Definition: settings.h:106
translation.h
interfaces::Chain::isInMempool
virtual bool isInMempool(const uint256 &txid)=0
Check if transaction is in mempool.
CTxMemPoolEntry
Definition: txmempool.h:88
LOCK
#define LOCK(cs)
Definition: sync.h:261
MemPoolRemovalReason
MemPoolRemovalReason
Reason why a transaction was removed from the mempool, this is passed to the notification signal.
Definition: txmempool.h:349
interfaces::FoundBlock::m_max_time
int64_t * m_max_time
Definition: chain.h:71
interfaces::Chain::relayDustFee
virtual CFeeRate relayDustFee()=0
Relay dust fee setting (-dustrelayfee), reflecting lowest rate it's economical to spend.
interfaces::FoundBlock::m_mtp_time
int64_t * m_mtp_time
Definition: chain.h:72
blockstorage.h
DEFAULT_MIN_RELAY_TX_FEE
static constexpr unsigned int DEFAULT_MIN_RELAY_TX_FEE
Default for -minrelaytxfee, minimum relay fee for transactions.
Definition: policy.h:57
std
Definition: setup_common.h:33
TransactionError::OK
@ OK
No error.
CRPCTable::removeCommand
bool removeCommand(const std::string &name, const CRPCCommand *pcmd)
Definition: server.cpp:276
interfaces::Chain::initMessage
virtual void initMessage(const std::string &message)=0
Send init message.
interfaces::Chain::getSetting
virtual util::SettingsValue getSetting(const std::string &arg)=0
Get settings value.
LockPoints
Definition: txmempool.h:44
RPCSerializationFlags
int RPCSerializationFlags()
Definition: server.cpp:538
interfaces::Chain::getTransactionAncestry
virtual void getTransactionAncestry(const uint256 &txid, size_t &ancestors, size_t &descendants, size_t *ancestorsize=nullptr, CAmount *ancestorfees=nullptr)=0
Calculate mempool ancestor and descendant counts for the given transaction.
interfaces::Chain::checkChainLimits
virtual bool checkChainLimits(const CTransactionRef &tx)=0
Check if transaction will pass the mempool's chain limits.
LogInstance
BCLog::Logger & LogInstance()
Definition: logging.cpp:18
Params
const CChainParams & Params()
Return the currently selected parameters.
Definition: chainparams.cpp:561
node::NodeContext::chainman
std::unique_ptr< ChainstateManager > chainman
Definition: context.h:54
node
Definition: init.h:25
wallet.h
interfaces::Chain::haveBlockOnDisk
virtual bool haveBlockOnDisk(int height)=0
Check that the block is available on disk (i.e.
JSONRPCRequest::URI
std::string URI
Definition: request.h:35
m_command
CRPCCommand m_command
Definition: interfaces.cpp:497
SynchronizationState
SynchronizationState
Current sync state passed to tip changed callbacks.
Definition: validation.h:88
JSONRPCRequest
Definition: request.h:28
banmap_t
std::map< CSubNet, CBanEntry > banmap_t
Definition: net_types.h:41
util::Settings::rw_settings
std::map< std::string, SettingsValue > rw_settings
Map of setting name to read-write file setting value.
Definition: settings.h:37
m_wrapped_command
const CRPCCommand * m_wrapped_command
Definition: interfaces.cpp:498
netbase.h
interfaces::FoundBlock::m_locator
CBlockLocator * m_locator
Definition: chain.h:74
COutPoint
An outpoint - a combination of a transaction hash and an index n into its vout.
Definition: transaction.h:34
lp
LockPoints lp
Definition: mempool_eviction.cpp:17
interfaces::Chain::initError
virtual void initError(const bilingual_str &message)=0
Send init error.
util::Settings::command_line_options
std::map< std::string, std::vector< SettingsValue > > command_line_options
Map of setting name to list of command line values.
Definition: settings.h:35
interfaces::Handler
Generic interface for managing an event handler or callback function registered with another interfac...
Definition: handler.h:22
IsDeprecatedRPCEnabled
bool IsDeprecatedRPCEnabled(const std::string &method)
Definition: server.cpp:351
IsRBFOptIn
RBFTransactionState IsRBFOptIn(const CTransaction &tx, const CTxMemPool &pool)
Determine whether an unconfirmed transaction is signaling opt-in to RBF according to BIP 125 This inv...
Definition: rbf.cpp:20
interfaces::Chain::getTipLocator
virtual CBlockLocator getTipLocator()=0
Get locator for the current chain tip.
CBlock::SetNull
void SetNull()
Definition: block.h:88
ConnectionDirection
ConnectionDirection
Definition: netbase.h:32
interfaces::Chain::requestMempoolTransactions
virtual void requestMempoolTransactions(Notifications &notifications)=0
Synchronously send transactionAddedToMempool notifications about all current mempool transactions to ...
BLOCK_HAVE_DATA
@ BLOCK_HAVE_DATA
full block available in blk*.dat
Definition: chain.h:126
CBlockLocator
Describes a place in the block chain to another node such that if the other node doesn't have the sam...
Definition: block.h:114
node::BroadcastTransaction
TransactionError BroadcastTransaction(NodeContext &node, const CTransactionRef tx, std::string &err_string, const CAmount &max_tx_fee, bool relay, bool wait_callback)
Submit a transaction to the mempool and (optionally) relay it to all P2P peers.
Definition: transaction.cpp:33
server.h
DEFAULT_INCREMENTAL_RELAY_FEE
static constexpr unsigned int DEFAULT_INCREMENTAL_RELAY_FEE
Default for -incrementalrelayfee, which sets the minimum feerate increase for mempool limiting or BIP...
Definition: policy.h:35
CNodeStateStats
Definition: net_processing.h:26
cs_main
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
Definition: validation.cpp:121
CBlockIndex
The block chain is a tree shaped structure starting with the genesis block at the root,...
Definition: chain.h:150
interfaces::Chain::showProgress
virtual void showProgress(const std::string &title, int progress, bool resume_possible)=0
Send progress indicator.
StopRPC
void StopRPC()
Definition: server.cpp:307
interfaces::Chain::estimateMaxBlocks
virtual unsigned int estimateMaxBlocks()=0
Fee estimator max target.
GuessVerificationProgress
double GuessVerificationProgress(const ChainTxData &data, const CBlockIndex *pindex)
Guess how far we are in the verification process at the given block index require cs_main if pindex h...
Definition: validation.cpp:4658
warnings.h
interfaces::Chain::handleRpc
virtual std::unique_ptr< Handler > handleRpc(const CRPCCommand &command)=0
Register handler for RPC.
interfaces::BlockTip
Block tip (could be a header or not, depends on the subscribed signal).
Definition: node.h:276
StartShutdown
void StartShutdown()
Request shutdown of the application.
Definition: shutdown.cpp:58
CValidationInterface::UpdatedBlockTip
virtual void UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockIndex *pindexFork, bool fInitialDownload)
Notifies listeners when the block chain tip advances.
Definition: validationinterface.h:92
AppInitSanityChecks
bool AppInitSanityChecks(const kernel::Context &kernel)
Initialization sanity checks.
Definition: init.cpp:1059
uiInterface
CClientUIInterface uiInterface
Definition: interface_ui.cpp:12
Shutdown
void Shutdown(NodeContext &node)
Definition: init.cpp:211
interfaces::Chain::findFirstBlockWithTimeAndHeight
virtual bool findFirstBlockWithTimeAndHeight(int64_t min_time, int min_height, const FoundBlock &block={})=0
Find first block in the chain with timestamp >= the given time and height >= than the given height,...
WAIT_LOCK
#define WAIT_LOCK(cs, name)
Definition: sync.h:266
interfaces::FoundBlock::m_height
int * m_height
Definition: chain.h:69
interfaces::MakeHandler
std::unique_ptr< Handler > MakeHandler(boost::signals2::connection connection)
Return handler wrapping a boost signal connection.
Definition: handler.cpp:35
CRPCCommand::name
std::string name
Definition: server.h:116
ExternalSigner::m_name
std::string m_name
Name of signer.
Definition: external_signer.h:40
rbf.h
interfaces::Chain::hasBlocks
virtual bool hasBlocks(const uint256 &block_hash, int min_height=0, std::optional< int > max_height={})=0
Return true if data is available for all blocks in the specified range of blocks.