Bitcoin Core  21.99.0
P2P Digital Currency
interfaces.cpp
Go to the documentation of this file.
1 // Copyright (c) 2018-2020 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 <init.h>
10 #include <interfaces/chain.h>
11 #include <interfaces/handler.h>
12 #include <interfaces/node.h>
13 #include <interfaces/wallet.h>
14 #include <mapport.h>
15 #include <net.h>
16 #include <net_processing.h>
17 #include <netaddress.h>
18 #include <netbase.h>
19 #include <node/blockstorage.h>
20 #include <node/coin.h>
21 #include <node/context.h>
22 #include <node/transaction.h>
23 #include <node/ui_interface.h>
24 #include <policy/feerate.h>
25 #include <policy/fees.h>
26 #include <policy/policy.h>
27 #include <policy/rbf.h>
28 #include <policy/settings.h>
29 #include <primitives/block.h>
30 #include <primitives/transaction.h>
31 #include <rpc/protocol.h>
32 #include <rpc/server.h>
33 #include <shutdown.h>
35 #include <sync.h>
36 #include <timedata.h>
37 #include <txmempool.h>
38 #include <uint256.h>
39 #include <univalue.h>
40 #include <util/check.h>
41 #include <util/system.h>
42 #include <util/translation.h>
43 #include <validation.h>
44 #include <validationinterface.h>
45 #include <warnings.h>
46 
47 #if defined(HAVE_CONFIG_H)
48 #include <config/bitcoin-config.h>
49 #endif
50 
51 #include <any>
52 #include <memory>
53 #include <optional>
54 #include <utility>
55 
56 #include <boost/signals2/signal.hpp>
57 
59 using interfaces::Chain;
63 using interfaces::Node;
65 
66 namespace node {
67 namespace {
68 class NodeImpl : public Node
69 {
70 private:
71  ChainstateManager& chainman() { return *Assert(m_context->chainman); }
72 public:
73  explicit NodeImpl(NodeContext* context) { setContext(context); }
74  void initLogging() override { InitLogging(*Assert(m_context->args)); }
75  void initParameterInteraction() override { InitParameterInteraction(*Assert(m_context->args)); }
76  bilingual_str getWarnings() override { return GetWarnings(true); }
77  uint32_t getLogCategories() override { return LogInstance().GetCategoryMask(); }
78  bool baseInitialize() override
79  {
82  }
83  bool appInitMain(interfaces::BlockAndHeaderTipInfo* tip_info) override
84  {
85  return AppInitMain(*m_context, tip_info);
86  }
87  void appShutdown() override
88  {
91  }
92  void startShutdown() override
93  {
94  StartShutdown();
95  // Stop RPC for clean shutdown if any of waitfor* commands is executed.
96  if (gArgs.GetBoolArg("-server", false)) {
97  InterruptRPC();
98  StopRPC();
99  }
100  }
101  bool shutdownRequested() override { return ShutdownRequested(); }
102  void mapPort(bool use_upnp, bool use_natpmp) override { StartMapPort(use_upnp, use_natpmp); }
103  bool getProxy(Network net, proxyType& proxy_info) override { return GetProxy(net, proxy_info); }
104  size_t getNodeCount(ConnectionDirection flags) override
105  {
106  return m_context->connman ? m_context->connman->GetNodeCount(flags) : 0;
107  }
108  bool getNodesStats(NodesStats& stats) override
109  {
110  stats.clear();
111 
112  if (m_context->connman) {
113  std::vector<CNodeStats> stats_temp;
114  m_context->connman->GetNodeStats(stats_temp);
115 
116  stats.reserve(stats_temp.size());
117  for (auto& node_stats_temp : stats_temp) {
118  stats.emplace_back(std::move(node_stats_temp), false, CNodeStateStats());
119  }
120 
121  // Try to retrieve the CNodeStateStats for each node.
122  if (m_context->peerman) {
123  TRY_LOCK(::cs_main, lockMain);
124  if (lockMain) {
125  for (auto& node_stats : stats) {
126  std::get<1>(node_stats) =
127  m_context->peerman->GetNodeStateStats(std::get<0>(node_stats).nodeid, std::get<2>(node_stats));
128  }
129  }
130  }
131  return true;
132  }
133  return false;
134  }
135  bool getBanned(banmap_t& banmap) override
136  {
137  if (m_context->banman) {
138  m_context->banman->GetBanned(banmap);
139  return true;
140  }
141  return false;
142  }
143  bool ban(const CNetAddr& net_addr, int64_t ban_time_offset) override
144  {
145  if (m_context->banman) {
146  m_context->banman->Ban(net_addr, ban_time_offset);
147  return true;
148  }
149  return false;
150  }
151  bool unban(const CSubNet& ip) override
152  {
153  if (m_context->banman) {
154  m_context->banman->Unban(ip);
155  return true;
156  }
157  return false;
158  }
159  bool disconnectByAddress(const CNetAddr& net_addr) override
160  {
161  if (m_context->connman) {
162  return m_context->connman->DisconnectNode(net_addr);
163  }
164  return false;
165  }
166  bool disconnectById(NodeId id) override
167  {
168  if (m_context->connman) {
169  return m_context->connman->DisconnectNode(id);
170  }
171  return false;
172  }
173  int64_t getTotalBytesRecv() override { return m_context->connman ? m_context->connman->GetTotalBytesRecv() : 0; }
174  int64_t getTotalBytesSent() override { return m_context->connman ? m_context->connman->GetTotalBytesSent() : 0; }
175  size_t getMempoolSize() override { return m_context->mempool ? m_context->mempool->size() : 0; }
176  size_t getMempoolDynamicUsage() override { return m_context->mempool ? m_context->mempool->DynamicMemoryUsage() : 0; }
177  bool getHeaderTip(int& height, int64_t& block_time) override
178  {
179  LOCK(::cs_main);
180  if (::pindexBestHeader) {
181  height = ::pindexBestHeader->nHeight;
182  block_time = ::pindexBestHeader->GetBlockTime();
183  return true;
184  }
185  return false;
186  }
187  int getNumBlocks() override
188  {
189  LOCK(::cs_main);
190  assert(std::addressof(::ChainActive()) == std::addressof(chainman().ActiveChain()));
191  return chainman().ActiveChain().Height();
192  }
193  uint256 getBestBlockHash() override
194  {
195  const CBlockIndex* tip;
196  {
197  // TODO: Temporary scope to check correctness of refactored code.
198  // Should be removed manually after merge of
199  // https://github.com/bitcoin/bitcoin/pull/20158
200  LOCK(cs_main);
201  assert(std::addressof(::ChainActive()) == std::addressof(chainman().ActiveChain()));
202  tip = chainman().ActiveChain().Tip();
203  }
204  return tip ? tip->GetBlockHash() : Params().GenesisBlock().GetHash();
205  }
206  int64_t getLastBlockTime() override
207  {
208  LOCK(::cs_main);
209  assert(std::addressof(::ChainActive()) == std::addressof(chainman().ActiveChain()));
210  if (chainman().ActiveChain().Tip()) {
211  return chainman().ActiveChain().Tip()->GetBlockTime();
212  }
213  return Params().GenesisBlock().GetBlockTime(); // Genesis block's time of current network
214  }
215  double getVerificationProgress() override
216  {
217  const CBlockIndex* tip;
218  {
219  LOCK(::cs_main);
220  assert(std::addressof(::ChainActive()) == std::addressof(chainman().ActiveChain()));
221  tip = chainman().ActiveChain().Tip();
222  }
223  return GuessVerificationProgress(Params().TxData(), tip);
224  }
225  bool isInitialBlockDownload() override {
226  const CChainState* active_chainstate;
227  {
228  // TODO: Temporary scope to check correctness of refactored code.
229  // Should be removed manually after merge of
230  // https://github.com/bitcoin/bitcoin/pull/20158
231  LOCK(::cs_main);
232  active_chainstate = &m_context->chainman->ActiveChainstate();
233  assert(std::addressof(::ChainstateActive()) == std::addressof(*active_chainstate));
234  }
235  return active_chainstate->IsInitialBlockDownload();
236  }
237  bool getReindex() override { return ::fReindex; }
238  bool getImporting() override { return ::fImporting; }
239  void setNetworkActive(bool active) override
240  {
241  if (m_context->connman) {
242  m_context->connman->SetNetworkActive(active);
243  }
244  }
245  bool getNetworkActive() override { return m_context->connman && m_context->connman->GetNetworkActive(); }
246  CFeeRate getDustRelayFee() override { return ::dustRelayFee; }
247  UniValue executeRpc(const std::string& command, const UniValue& params, const std::string& uri) override
248  {
249  JSONRPCRequest req;
250  req.context = m_context;
251  req.params = params;
252  req.strMethod = command;
253  req.URI = uri;
255  }
256  std::vector<std::string> listRpcCommands() override { return ::tableRPC.listCommands(); }
257  void rpcSetTimerInterfaceIfUnset(RPCTimerInterface* iface) override { RPCSetTimerInterfaceIfUnset(iface); }
258  void rpcUnsetTimerInterface(RPCTimerInterface* iface) override { RPCUnsetTimerInterface(iface); }
259  bool getUnspentOutput(const COutPoint& output, Coin& coin) override
260  {
261  LOCK(::cs_main);
262  assert(std::addressof(::ChainstateActive()) == std::addressof(chainman().ActiveChainstate()));
263  return chainman().ActiveChainstate().CoinsTip().GetCoin(output, coin);
264  }
265  WalletClient& walletClient() override
266  {
267  return *Assert(m_context->wallet_client);
268  }
269  std::unique_ptr<Handler> handleInitMessage(InitMessageFn fn) override
270  {
271  return MakeHandler(::uiInterface.InitMessage_connect(fn));
272  }
273  std::unique_ptr<Handler> handleMessageBox(MessageBoxFn fn) override
274  {
275  return MakeHandler(::uiInterface.ThreadSafeMessageBox_connect(fn));
276  }
277  std::unique_ptr<Handler> handleQuestion(QuestionFn fn) override
278  {
279  return MakeHandler(::uiInterface.ThreadSafeQuestion_connect(fn));
280  }
281  std::unique_ptr<Handler> handleShowProgress(ShowProgressFn fn) override
282  {
283  return MakeHandler(::uiInterface.ShowProgress_connect(fn));
284  }
285  std::unique_ptr<Handler> handleNotifyNumConnectionsChanged(NotifyNumConnectionsChangedFn fn) override
286  {
287  return MakeHandler(::uiInterface.NotifyNumConnectionsChanged_connect(fn));
288  }
289  std::unique_ptr<Handler> handleNotifyNetworkActiveChanged(NotifyNetworkActiveChangedFn fn) override
290  {
291  return MakeHandler(::uiInterface.NotifyNetworkActiveChanged_connect(fn));
292  }
293  std::unique_ptr<Handler> handleNotifyAlertChanged(NotifyAlertChangedFn fn) override
294  {
295  return MakeHandler(::uiInterface.NotifyAlertChanged_connect(fn));
296  }
297  std::unique_ptr<Handler> handleBannedListChanged(BannedListChangedFn fn) override
298  {
299  return MakeHandler(::uiInterface.BannedListChanged_connect(fn));
300  }
301  std::unique_ptr<Handler> handleNotifyBlockTip(NotifyBlockTipFn fn) override
302  {
303  return MakeHandler(::uiInterface.NotifyBlockTip_connect([fn](SynchronizationState sync_state, const CBlockIndex* block) {
304  fn(sync_state, BlockTip{block->nHeight, block->GetBlockTime(), block->GetBlockHash()},
305  GuessVerificationProgress(Params().TxData(), block));
306  }));
307  }
308  std::unique_ptr<Handler> handleNotifyHeaderTip(NotifyHeaderTipFn fn) override
309  {
310  return MakeHandler(
311  ::uiInterface.NotifyHeaderTip_connect([fn](SynchronizationState sync_state, const CBlockIndex* block) {
312  fn(sync_state, BlockTip{block->nHeight, block->GetBlockTime(), block->GetBlockHash()},
313  /* verification progress is unused when a header was received */ 0);
314  }));
315  }
316  NodeContext* context() override { return m_context; }
317  void setContext(NodeContext* context) override
318  {
319  m_context = context;
320  }
322 };
323 
324 bool FillBlock(const CBlockIndex* index, const FoundBlock& block, UniqueLock<RecursiveMutex>& lock, const CChain& active)
325 {
326  if (!index) return false;
327  if (block.m_hash) *block.m_hash = index->GetBlockHash();
328  if (block.m_height) *block.m_height = index->nHeight;
329  if (block.m_time) *block.m_time = index->GetBlockTime();
330  if (block.m_max_time) *block.m_max_time = index->GetBlockTimeMax();
331  if (block.m_mtp_time) *block.m_mtp_time = index->GetMedianTimePast();
332  if (block.m_in_active_chain) *block.m_in_active_chain = active[index->nHeight] == index;
333  if (block.m_next_block) FillBlock(active[index->nHeight] == index ? active[index->nHeight + 1] : nullptr, *block.m_next_block, lock, active);
334  if (block.m_data) {
335  REVERSE_LOCK(lock);
336  if (!ReadBlockFromDisk(*block.m_data, index, Params().GetConsensus())) block.m_data->SetNull();
337  }
338  return true;
339 }
340 
341 class NotificationsProxy : public CValidationInterface
342 {
343 public:
344  explicit NotificationsProxy(std::shared_ptr<Chain::Notifications> notifications)
345  : m_notifications(std::move(notifications)) {}
346  virtual ~NotificationsProxy() = default;
347  void TransactionAddedToMempool(const CTransactionRef& tx, uint64_t mempool_sequence) override
348  {
349  m_notifications->transactionAddedToMempool(tx, mempool_sequence);
350  }
351  void TransactionRemovedFromMempool(const CTransactionRef& tx, MemPoolRemovalReason reason, uint64_t mempool_sequence) override
352  {
353  m_notifications->transactionRemovedFromMempool(tx, reason, mempool_sequence);
354  }
355  void BlockConnected(const std::shared_ptr<const CBlock>& block, const CBlockIndex* index) override
356  {
357  m_notifications->blockConnected(*block, index->nHeight);
358  }
359  void BlockDisconnected(const std::shared_ptr<const CBlock>& block, const CBlockIndex* index) override
360  {
361  m_notifications->blockDisconnected(*block, index->nHeight);
362  }
363  void UpdatedBlockTip(const CBlockIndex* index, const CBlockIndex* fork_index, bool is_ibd) override
364  {
365  m_notifications->updatedBlockTip();
366  }
367  void ChainStateFlushed(const CBlockLocator& locator) override { m_notifications->chainStateFlushed(locator); }
368  std::shared_ptr<Chain::Notifications> m_notifications;
369 };
370 
371 class NotificationsHandlerImpl : public Handler
372 {
373 public:
374  explicit NotificationsHandlerImpl(std::shared_ptr<Chain::Notifications> notifications)
375  : m_proxy(std::make_shared<NotificationsProxy>(std::move(notifications)))
376  {
378  }
379  ~NotificationsHandlerImpl() override { disconnect(); }
380  void disconnect() override
381  {
382  if (m_proxy) {
384  m_proxy.reset();
385  }
386  }
387  std::shared_ptr<NotificationsProxy> m_proxy;
388 };
389 
390 class RpcHandlerImpl : public Handler
391 {
392 public:
393  explicit RpcHandlerImpl(const CRPCCommand& command) : m_command(command), m_wrapped_command(&command)
394  {
395  m_command.actor = [this](const JSONRPCRequest& request, UniValue& result, bool last_handler) {
396  if (!m_wrapped_command) return false;
397  try {
398  return m_wrapped_command->actor(request, result, last_handler);
399  } catch (const UniValue& e) {
400  // If this is not the last handler and a wallet not found
401  // exception was thrown, return false so the next handler can
402  // try to handle the request. Otherwise, reraise the exception.
403  if (!last_handler) {
404  const UniValue& code = e["code"];
405  if (code.isNum() && code.get_int() == RPC_WALLET_NOT_FOUND) {
406  return false;
407  }
408  }
409  throw;
410  }
411  };
413  }
414 
415  void disconnect() final
416  {
417  if (m_wrapped_command) {
418  m_wrapped_command = nullptr;
420  }
421  }
422 
423  ~RpcHandlerImpl() override { disconnect(); }
424 
427 };
428 
429 class ChainImpl : public Chain
430 {
431 private:
432  ChainstateManager& chainman() { return *Assert(m_node.chainman); }
433 public:
434  explicit ChainImpl(NodeContext& node) : m_node(node) {}
435  std::optional<int> getHeight() override
436  {
437  LOCK(::cs_main);
438  const CChain& active = Assert(m_node.chainman)->ActiveChain();
439  int height = active.Height();
440  if (height >= 0) {
441  return height;
442  }
443  return std::nullopt;
444  }
445  uint256 getBlockHash(int height) override
446  {
447  LOCK(::cs_main);
448  const CChain& active = Assert(m_node.chainman)->ActiveChain();
449  CBlockIndex* block = active[height];
450  assert(block);
451  return block->GetBlockHash();
452  }
453  bool haveBlockOnDisk(int height) override
454  {
455  LOCK(cs_main);
456  const CChain& active = Assert(m_node.chainman)->ActiveChain();
457  CBlockIndex* block = active[height];
458  return block && ((block->nStatus & BLOCK_HAVE_DATA) != 0) && block->nTx > 0;
459  }
460  CBlockLocator getTipLocator() override
461  {
462  LOCK(cs_main);
463  const CChain& active = Assert(m_node.chainman)->ActiveChain();
464  return active.GetLocator();
465  }
466  bool checkFinalTx(const CTransaction& tx) override
467  {
468  LOCK(cs_main);
469  assert(std::addressof(::ChainActive()) == std::addressof(chainman().ActiveChain()));
470  return CheckFinalTx(chainman().ActiveChain().Tip(), tx);
471  }
472  std::optional<int> findLocatorFork(const CBlockLocator& locator) override
473  {
474  LOCK(cs_main);
475  const CChain& active = Assert(m_node.chainman)->ActiveChain();
476  assert(std::addressof(g_chainman) == std::addressof(*m_node.chainman));
477  if (CBlockIndex* fork = m_node.chainman->m_blockman.FindForkInGlobalIndex(active, locator)) {
478  return fork->nHeight;
479  }
480  return std::nullopt;
481  }
482  bool findBlock(const uint256& hash, const FoundBlock& block) override
483  {
484  WAIT_LOCK(cs_main, lock);
485  const CChain& active = Assert(m_node.chainman)->ActiveChain();
486  assert(std::addressof(g_chainman) == std::addressof(*m_node.chainman));
487  return FillBlock(m_node.chainman->m_blockman.LookupBlockIndex(hash), block, lock, active);
488  }
489  bool findFirstBlockWithTimeAndHeight(int64_t min_time, int min_height, const FoundBlock& block) override
490  {
491  WAIT_LOCK(cs_main, lock);
492  const CChain& active = Assert(m_node.chainman)->ActiveChain();
493  return FillBlock(active.FindEarliestAtLeast(min_time, min_height), block, lock, active);
494  }
495  bool findAncestorByHeight(const uint256& block_hash, int ancestor_height, const FoundBlock& ancestor_out) override
496  {
497  WAIT_LOCK(cs_main, lock);
498  const CChain& active = Assert(m_node.chainman)->ActiveChain();
499  assert(std::addressof(g_chainman) == std::addressof(*m_node.chainman));
500  if (const CBlockIndex* block = m_node.chainman->m_blockman.LookupBlockIndex(block_hash)) {
501  if (const CBlockIndex* ancestor = block->GetAncestor(ancestor_height)) {
502  return FillBlock(ancestor, ancestor_out, lock, active);
503  }
504  }
505  return FillBlock(nullptr, ancestor_out, lock, active);
506  }
507  bool findAncestorByHash(const uint256& block_hash, const uint256& ancestor_hash, const FoundBlock& ancestor_out) override
508  {
509  WAIT_LOCK(cs_main, lock);
510  const CChain& active = Assert(m_node.chainman)->ActiveChain();
511  assert(std::addressof(g_chainman) == std::addressof(*m_node.chainman));
512  const CBlockIndex* block = m_node.chainman->m_blockman.LookupBlockIndex(block_hash);
513  assert(std::addressof(g_chainman) == std::addressof(*m_node.chainman));
514  const CBlockIndex* ancestor = m_node.chainman->m_blockman.LookupBlockIndex(ancestor_hash);
515  if (block && ancestor && block->GetAncestor(ancestor->nHeight) != ancestor) ancestor = nullptr;
516  return FillBlock(ancestor, ancestor_out, lock, active);
517  }
518  bool findCommonAncestor(const uint256& block_hash1, const uint256& block_hash2, const FoundBlock& ancestor_out, const FoundBlock& block1_out, const FoundBlock& block2_out) override
519  {
520  WAIT_LOCK(cs_main, lock);
521  const CChain& active = Assert(m_node.chainman)->ActiveChain();
522  assert(std::addressof(g_chainman) == std::addressof(*m_node.chainman));
523  const CBlockIndex* block1 = m_node.chainman->m_blockman.LookupBlockIndex(block_hash1);
524  assert(std::addressof(g_chainman) == std::addressof(*m_node.chainman));
525  const CBlockIndex* block2 = m_node.chainman->m_blockman.LookupBlockIndex(block_hash2);
526  const CBlockIndex* ancestor = block1 && block2 ? LastCommonAncestor(block1, block2) : nullptr;
527  // Using & instead of && below to avoid short circuiting and leaving
528  // output uninitialized.
529  return FillBlock(ancestor, ancestor_out, lock, active) & FillBlock(block1, block1_out, lock, active) & FillBlock(block2, block2_out, lock, active);
530  }
531  void findCoins(std::map<COutPoint, Coin>& coins) override { return FindCoins(m_node, coins); }
532  double guessVerificationProgress(const uint256& block_hash) override
533  {
534  LOCK(cs_main);
535  assert(std::addressof(g_chainman.m_blockman) == std::addressof(chainman().m_blockman));
536  return GuessVerificationProgress(Params().TxData(), chainman().m_blockman.LookupBlockIndex(block_hash));
537  }
538  bool hasBlocks(const uint256& block_hash, int min_height, std::optional<int> max_height) override
539  {
540  // hasBlocks returns true if all ancestors of block_hash in specified
541  // range have block data (are not pruned), false if any ancestors in
542  // specified range are missing data.
543  //
544  // For simplicity and robustness, min_height and max_height are only
545  // used to limit the range, and passing min_height that's too low or
546  // max_height that's too high will not crash or change the result.
547  LOCK(::cs_main);
548  assert(std::addressof(g_chainman.m_blockman) == std::addressof(chainman().m_blockman));
549  if (CBlockIndex* block = chainman().m_blockman.LookupBlockIndex(block_hash)) {
550  if (max_height && block->nHeight >= *max_height) block = block->GetAncestor(*max_height);
551  for (; block->nStatus & BLOCK_HAVE_DATA; block = block->pprev) {
552  // Check pprev to not segfault if min_height is too low
553  if (block->nHeight <= min_height || !block->pprev) return true;
554  }
555  }
556  return false;
557  }
558  RBFTransactionState isRBFOptIn(const CTransaction& tx) override
559  {
560  if (!m_node.mempool) return IsRBFOptInEmptyMempool(tx);
561  LOCK(m_node.mempool->cs);
562  return IsRBFOptIn(tx, *m_node.mempool);
563  }
564  bool isInMempool(const uint256& txid) override
565  {
566  if (!m_node.mempool) return false;
567  LOCK(m_node.mempool->cs);
568  return m_node.mempool->exists(txid);
569  }
570  bool hasDescendantsInMempool(const uint256& txid) override
571  {
572  if (!m_node.mempool) return false;
573  LOCK(m_node.mempool->cs);
574  auto it = m_node.mempool->GetIter(txid);
575  return it && (*it)->GetCountWithDescendants() > 1;
576  }
577  bool broadcastTransaction(const CTransactionRef& tx,
578  const CAmount& max_tx_fee,
579  bool relay,
580  std::string& err_string) override
581  {
582  const TransactionError err = BroadcastTransaction(m_node, tx, err_string, max_tx_fee, relay, /*wait_callback*/ false);
583  // Chain clients only care about failures to accept the tx to the mempool. Disregard non-mempool related failures.
584  // Note: this will need to be updated if BroadcastTransactions() is updated to return other non-mempool failures
585  // that Chain clients do not need to know about.
586  return TransactionError::OK == err;
587  }
588  void getTransactionAncestry(const uint256& txid, size_t& ancestors, size_t& descendants) override
589  {
590  ancestors = descendants = 0;
591  if (!m_node.mempool) return;
592  m_node.mempool->GetTransactionAncestry(txid, ancestors, descendants);
593  }
594  void getPackageLimits(unsigned int& limit_ancestor_count, unsigned int& limit_descendant_count) override
595  {
596  limit_ancestor_count = gArgs.GetArg("-limitancestorcount", DEFAULT_ANCESTOR_LIMIT);
597  limit_descendant_count = gArgs.GetArg("-limitdescendantcount", DEFAULT_DESCENDANT_LIMIT);
598  }
599  bool checkChainLimits(const CTransactionRef& tx) override
600  {
601  if (!m_node.mempool) return true;
602  LockPoints lp;
603  CTxMemPoolEntry entry(tx, 0, 0, 0, false, 0, lp);
604  CTxMemPool::setEntries ancestors;
605  auto limit_ancestor_count = gArgs.GetArg("-limitancestorcount", DEFAULT_ANCESTOR_LIMIT);
606  auto limit_ancestor_size = gArgs.GetArg("-limitancestorsize", DEFAULT_ANCESTOR_SIZE_LIMIT) * 1000;
607  auto limit_descendant_count = gArgs.GetArg("-limitdescendantcount", DEFAULT_DESCENDANT_LIMIT);
608  auto limit_descendant_size = gArgs.GetArg("-limitdescendantsize", DEFAULT_DESCENDANT_SIZE_LIMIT) * 1000;
609  std::string unused_error_string;
610  LOCK(m_node.mempool->cs);
611  return m_node.mempool->CalculateMemPoolAncestors(
612  entry, ancestors, limit_ancestor_count, limit_ancestor_size,
613  limit_descendant_count, limit_descendant_size, unused_error_string);
614  }
615  CFeeRate estimateSmartFee(int num_blocks, bool conservative, FeeCalculation* calc) override
616  {
617  if (!m_node.fee_estimator) return {};
618  return m_node.fee_estimator->estimateSmartFee(num_blocks, calc, conservative);
619  }
620  unsigned int estimateMaxBlocks() override
621  {
622  if (!m_node.fee_estimator) return 0;
623  return m_node.fee_estimator->HighestTargetTracked(FeeEstimateHorizon::LONG_HALFLIFE);
624  }
625  CFeeRate mempoolMinFee() override
626  {
627  if (!m_node.mempool) return {};
628  return m_node.mempool->GetMinFee(gArgs.GetArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000);
629  }
633  bool havePruned() override
634  {
635  LOCK(cs_main);
637  }
638  bool isReadyToBroadcast() override { return !::fImporting && !::fReindex && !isInitialBlockDownload(); }
639  bool isInitialBlockDownload() override {
640  const CChainState* active_chainstate;
641  {
642  // TODO: Temporary scope to check correctness of refactored code.
643  // Should be removed manually after merge of
644  // https://github.com/bitcoin/bitcoin/pull/20158
645  LOCK(::cs_main);
646  active_chainstate = &chainman().ActiveChainstate();
647  assert(std::addressof(::ChainstateActive()) == std::addressof(*active_chainstate));
648  }
649  return active_chainstate->IsInitialBlockDownload();
650  }
651  bool shutdownRequested() override { return ShutdownRequested(); }
652  int64_t getAdjustedTime() override { return GetAdjustedTime(); }
653  void initMessage(const std::string& message) override { ::uiInterface.InitMessage(message); }
654  void initWarning(const bilingual_str& message) override { InitWarning(message); }
655  void initError(const bilingual_str& message) override { InitError(message); }
656  void showProgress(const std::string& title, int progress, bool resume_possible) override
657  {
658  ::uiInterface.ShowProgress(title, progress, resume_possible);
659  }
660  std::unique_ptr<Handler> handleNotifications(std::shared_ptr<Notifications> notifications) override
661  {
662  return std::make_unique<NotificationsHandlerImpl>(std::move(notifications));
663  }
664  void waitForNotificationsIfTipChanged(const uint256& old_tip) override
665  {
666  if (!old_tip.IsNull()) {
667  LOCK(::cs_main);
668  const CChain& active = Assert(m_node.chainman)->ActiveChain();
669  if (old_tip == active.Tip()->GetBlockHash()) return;
670  }
672  }
673  std::unique_ptr<Handler> handleRpc(const CRPCCommand& command) override
674  {
675  return std::make_unique<RpcHandlerImpl>(command);
676  }
677  bool rpcEnableDeprecated(const std::string& method) override { return IsDeprecatedRPCEnabled(method); }
678  void rpcRunLater(const std::string& name, std::function<void()> fn, int64_t seconds) override
679  {
680  RPCRunLater(name, std::move(fn), seconds);
681  }
682  int rpcSerializationFlags() override { return RPCSerializationFlags(); }
683  util::SettingsValue getRwSetting(const std::string& name) override
684  {
685  util::SettingsValue result;
686  gArgs.LockSettings([&](const util::Settings& settings) {
687  if (const util::SettingsValue* value = util::FindKey(settings.rw_settings, name)) {
688  result = *value;
689  }
690  });
691  return result;
692  }
693  bool updateRwSetting(const std::string& name, const util::SettingsValue& value) override
694  {
695  gArgs.LockSettings([&](util::Settings& settings) {
696  if (value.isNull()) {
697  settings.rw_settings.erase(name);
698  } else {
699  settings.rw_settings[name] = value;
700  }
701  });
702  return gArgs.WriteSettingsFile();
703  }
704  void requestMempoolTransactions(Notifications& notifications) override
705  {
706  if (!m_node.mempool) return;
707  LOCK2(::cs_main, m_node.mempool->cs);
708  for (const CTxMemPoolEntry& entry : m_node.mempool->mapTx) {
709  notifications.transactionAddedToMempool(entry.GetSharedTx(), 0 /* mempool_sequence */);
710  }
711  }
713 };
714 } // namespace
715 } // namespace node
716 
717 namespace interfaces {
718 std::unique_ptr<Node> MakeNode(NodeContext* context) { return std::make_unique<node::NodeImpl>(context); }
719 std::unique_ptr<Chain> MakeChain(NodeContext& context) { return std::make_unique<node::ChainImpl>(context); }
720 } // namespace interfaces
CValidationInterface
Implement this to subscribe to events generated in validation.
Definition: validationinterface.h:78
CBlockIndex::GetBlockTime
int64_t GetBlockTime() const
Definition: chain.h:260
CValidationInterface::TransactionRemovedFromMempool
virtual void TransactionRemovedFromMempool(const CTransactionRef &tx, MemPoolRemovalReason reason, uint64_t mempool_sequence)
Notifies listeners of a transaction leaving mempool.
Definition: validationinterface.h:134
NodeId
int64_t NodeId
Definition: net.h:90
interfaces
Definition: dummywallet.cpp:10
AppInitInterfaces
bool AppInitInterfaces(NodeContext &node)
Initialize node and wallet interface pointers.
Definition: init.cpp:1180
block.h
LOCK2
#define LOCK2(cs1, cs2)
Definition: sync.h:233
ShutdownRequested
bool ShutdownRequested()
Returns true if a shutdown is requested, false otherwise.
Definition: shutdown.cpp:87
CTxMemPool::setEntries
std::set< txiter, CompareIteratorByHash > setEntries
Definition: txmempool.h:571
policy.h
interfaces::Chain::checkFinalTx
virtual bool checkFinalTx(const CTransaction &tx)=0
Check if transaction will be final given chain height current time.
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:387
feerate.h
ArgsManager::GetBoolArg
bool GetBoolArg(const std::string &strArg, bool fDefault) const
Return boolean argument or default value.
Definition: system.cpp:594
interfaces::Chain::updateRwSetting
virtual bool updateRwSetting(const std::string &name, const util::SettingsValue &value)=0
Write a setting to <datadir>/settings.json.
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:324
RegisterSharedValidationInterface
void RegisterSharedValidationInterface(std::shared_ptr< CValidationInterface > callbacks)
Register subscriber.
Definition: validationinterface.cpp:121
NodeContext::fee_estimator
std::unique_ptr< CBlockPolicyEstimator > fee_estimator
Definition: context.h:42
CBlockIndex::GetAncestor
CBlockIndex * GetAncestor(int height)
Efficiently find an ancestor of this block.
Definition: chain.cpp:111
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:321
settings.h
ChainActive
CChain & ChainActive()
Please prefer the identical ChainstateManager::ActiveChain.
Definition: validation.cpp:115
interfaces::FoundBlock::m_data
CBlock * m_data
Definition: chain.h:62
InitParameterInteraction
void InitParameterInteraction(ArgsManager &args)
Parameter interaction: change current parameters depending on various rules.
Definition: init.cpp:719
DEFAULT_ANCESTOR_SIZE_LIMIT
static const unsigned int DEFAULT_ANCESTOR_SIZE_LIMIT
Default for -limitancestorsize, maximum kilobytes of tx + all in-mempool ancestors.
Definition: validation.h:66
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
NodeContext::args
ArgsManager * args
Definition: context.h:46
flags
int flags
Definition: bitcoin-tx.cpp:512
RPCTimerInterface
RPC timer "driver".
Definition: server.h:60
CBlockIndex::nTx
unsigned int nTx
Number of transactions in this block.
Definition: chain.h:169
uiInterface
CClientUIInterface uiInterface
Definition: ui_interface.cpp:12
InitLogging
void InitLogging(const ArgsManager &args)
Initialize global loggers.
Definition: init.cpp:797
NodeContext::mempool
std::unique_ptr< CTxMemPool > mempool
Definition: context.h:41
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:227
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:147
timedata.h
RPCUnsetTimerInterface
void RPCUnsetTimerInterface(RPCTimerInterface *iface)
Unset factory function for timers.
Definition: server.cpp:524
RBFTransactionState
RBFTransactionState
The rbf state of unconfirmed transactions.
Definition: rbf.h:11
InterruptRPC
void InterruptRPC()
Definition: server.cpp:297
bilingual_str
Bilingual messages:
Definition: translation.h:16
interfaces::Chain::isInitialBlockDownload
virtual bool isInitialBlockDownload()=0
Check if in IBD.
CNetAddr
Network address.
Definition: netaddress.h:119
interfaces::MakeChain
std::unique_ptr< Chain > MakeChain(NodeContext &node)
Return implementation of Chain interface.
Definition: interfaces.cpp:719
uint256.h
CBlockIndex::pprev
CBlockIndex * pprev
pointer to the index of the predecessor of this block
Definition: chain.h:144
interfaces::FoundBlock::m_in_active_chain
bool * m_in_active_chain
Definition: chain.h:60
CBlockIndex::nHeight
int nHeight
height of the entry in the chain. The genesis block has height 0
Definition: chain.h:150
validationinterface.h
handler.h
IsRBFOptInEmptyMempool
RBFTransactionState IsRBFOptInEmptyMempool(const CTransaction &tx)
Definition: rbf.cpp:40
CTxMemPoolEntry::GetSharedTx
CTransactionRef GetSharedTx() const
Definition: txmempool.h:123
interfaces::Chain::handleNotifications
virtual std::unique_ptr< Handler > handleNotifications(std::shared_ptr< Notifications > notifications)=0
Register handler for notifications.
interfaces::Handler::disconnect
virtual void disconnect()=0
Disconnect the handler.
minRelayTxFee
CFeeRate minRelayTxFee
A fee rate smaller than this is considered zero fee (for relaying, mining and transaction creation)
Definition: validation.cpp:151
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:530
LastCommonAncestor
const CBlockIndex * LastCommonAncestor(const CBlockIndex *pa, const CBlockIndex *pb)
Find the last common ancestor two blocks have.
Definition: chain.cpp:156
BCLog::Logger::GetCategoryMask
uint32_t GetCategoryMask() const
Definition: logging.h:132
protocol.h
interfaces::FoundBlock::m_next_block
const FoundBlock * m_next_block
Definition: chain.h:61
interfaces::BlockAndHeaderTipInfo
Block and header tip information.
Definition: node.h:43
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::isNull
bool isNull() const
Definition: univalue.h:77
TRY_LOCK
#define TRY_LOCK(cs, name)
Definition: sync.h:236
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:844
chain.h
ChainstateManager::ActiveChainstate
CChainState & ActiveChainstate() const
The most-work chain.
Definition: validation.cpp:5357
CTransactionRef
std::shared_ptr< const CTransaction > CTransactionRef
Definition: transaction.h:386
UniValue::isNum
bool isNum() const
Definition: univalue.h:82
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:43
DEFAULT_DESCENDANT_LIMIT
static const unsigned int DEFAULT_DESCENDANT_LIMIT
Default for -limitdescendantcount, max number of in-mempool descendants.
Definition: validation.h:68
CChain::Tip
CBlockIndex * Tip() const
Returns the index entry for the tip of this chain, or nullptr if none.
Definition: chain.h:403
cs_main
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
Definition: validation.cpp:131
context.h
interfaces::Chain::getRwSetting
virtual util::SettingsValue getRwSetting(const std::string &name)=0
Return <datadir>/settings.json setting value.
proxyType
Definition: netbase.h:48
Assert
#define Assert(val)
Identity function.
Definition: check.h:57
CFeeRate
Fee rate in satoshis per kilobyte: CAmount / kB.
Definition: feerate.h:29
CBlockHeader::GetHash
uint256 GetHash() const
Definition: block.cpp:11
fHavePruned
bool fHavePruned
Pruning-related variables and constants.
Definition: validation.cpp:140
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:19
CTransaction
The basic transaction that is broadcasted on the network and contained in blocks.
Definition: transaction.h:259
ChainstateActive
CChainState & ChainstateActive()
Please prefer the identical ChainstateManager::ActiveChainstate.
Definition: validation.cpp:108
txmempool.h
shutdown.h
transaction.h
interfaces::Chain::relayIncrementalFee
virtual CFeeRate relayIncrementalFee()=0
Relay incremental fee setting (-incrementalrelayfee), reflecting cost of relay.
FindCoins
void FindCoins(const NodeContext &node, std::map< COutPoint, Coin > &coins)
Look up unspent output information.
Definition: coin.cpp:11
CBlockIndex::GetBlockTimeMax
int64_t GetBlockTimeMax() const
Definition: chain.h:265
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:62
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:160
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:89
FeeCalculation
Definition: fees.h:75
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:141
banman.h
coin.h
interfaces::MakeNode
std::unique_ptr< Node > MakeNode(NodeContext *context=nullptr)
Return implementation of Node interface.
Definition: interfaces.cpp:718
interfaces::FoundBlock::m_time
int64_t * m_time
Definition: chain.h:57
DEFAULT_ANCESTOR_LIMIT
static const unsigned int DEFAULT_ANCESTOR_LIMIT
Default for -limitancestorcount, max number of in-mempool ancestors.
Definition: validation.h:64
CBlockIndex::nStatus
uint32_t nStatus
Verification status of this block.
Definition: chain.h:187
m_notifications
std::shared_ptr< Chain::Notifications > m_notifications
Definition: interfaces.cpp:368
RPCSetTimerInterfaceIfUnset
void RPCSetTimerInterfaceIfUnset(RPCTimerInterface *iface)
Set the factory function for timer, but only, if unset.
Definition: server.cpp:513
CBlockHeader::GetBlockTime
int64_t GetBlockTime() const
Definition: block.h:55
CRPCCommand
Definition: server.h:90
Coin
A UTXO entry.
Definition: coins.h:32
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:272
init.h
CValidationInterface::ChainStateFlushed
virtual void ChainStateFlushed(const CBlockLocator &locator)
Notifies listeners of the new active block chain on-disk.
Definition: validationinterface.h:164
node.h
InitError
bool InitError(const bilingual_str &str)
Show error message.
Definition: ui_interface.cpp:56
CRPCTable::execute
UniValue execute(const JSONRPCRequest &request) const
Execute a method.
Definition: server.cpp:451
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:1191
netaddress.h
ArgsManager::WriteSettingsFile
bool WriteSettingsFile(std::vector< std::string > *errors=nullptr) const
Write settings file.
Definition: system.cpp:557
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:23
tableRPC
CRPCTable tableRPC
Definition: server.cpp:548
pindexBestHeader
CBlockIndex * pindexBestHeader
Best header we've seen so far (used for getheaders queries' starting points).
Definition: validation.cpp:133
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...
g_chainman
ChainstateManager g_chainman
Definition: validation.cpp:106
UnregisterSharedValidationInterface
void UnregisterSharedValidationInterface(std::shared_ptr< CValidationInterface > callbacks)
Unregister subscriber.
Definition: validationinterface.cpp:135
ArgsManager::GetArg
std::string GetArg(const std::string &strArg, const std::string &strDefault) const
Return string argument or default value.
Definition: system.cpp:582
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:100
CRPCTable::listCommands
std::vector< std::string > listCommands() const
Returns a list of registered commands.
Definition: server.cpp:489
Interrupt
void Interrupt(NodeContext &node)
Interrupt threads.
Definition: init.cpp:156
ReadBlockFromDisk
bool ReadBlockFromDisk(CBlock &block, const FlatFilePos &pos, const Consensus::Params &consensusParams)
Functions for disk access for blocks.
Definition: blockstorage.cpp:44
interfaces::Chain::relayMinFee
virtual CFeeRate relayMinFee()=0
Relay current minimum fee (from -minrelaytxfee and -incrementalrelayfee settings).
CSubNet
Definition: netaddress.h:480
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::FoundBlock
Helper for findBlock to selectively return pieces of block data.
Definition: chain.h:39
m_node
NodeContext & m_node
Definition: interfaces.cpp:712
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.
AppInitParameterInteraction
bool AppInitParameterInteraction(const ArgsManager &args)
Initialization: parameter interaction.
Definition: init.cpp:889
interfaces::WalletClient
Wallet chain client that in addition to having chain client methods for starting up,...
Definition: wallet.h:309
CChainParams::GenesisBlock
const CBlock & GenesisBlock() const
Definition: chainparams.h:81
uint256
256-bit opaque blob.
Definition: uint256.h:124
fReindex
std::atomic_bool fReindex
CChainState
CChainState stores and provides an API to update our local knowledge of the current best chain.
Definition: validation.h:530
interfaces::Chain::getTransactionAncestry
virtual void getTransactionAncestry(const uint256 &txid, size_t &ancestors, size_t &descendants)=0
Calculate mempool ancestor and descendant counts for the given transaction.
interfaces::Chain::getAdjustedTime
virtual int64_t getAdjustedTime()=0
Get adjusted time.
AppInitSanityChecks
bool AppInitSanityChecks()
Initialization sanity checks: ecc init, sanity checks, dir lock.
Definition: init.cpp:1147
net_processing.h
CBlockIndex::GetBlockHash
uint256 GetBlockHash() const
Definition: chain.h:246
interfaces::Node
Top-level interface for a bitcoin node (bitcoind process).
Definition: node.h:53
CChain::Height
int Height() const
Return the maximal height in the chain.
Definition: chain.h:428
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.
NodeContext::peerman
std::unique_ptr< PeerManager > peerman
Definition: context.h:43
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:807
secure.h
name
const char * name
Definition: rest.cpp:43
NodeContext::wallet_client
interfaces::WalletClient * wallet_client
Reference to chain client that should used to load or create wallets opened by the gui.
Definition: context.h:52
ui_interface.h
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.
InitWarning
void InitWarning(const bilingual_str &str)
Show warning message.
Definition: ui_interface.cpp:62
system.h
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:29
CChainState::IsInitialBlockDownload
bool IsInitialBlockDownload() const
Check whether we are doing an initial block download (synchronizing from disk or network)
Definition: validation.cpp:1209
ArgsManager::LockSettings
void LockSettings(Fn &&fn)
Access settings with lock held.
Definition: system.h:428
interfaces::FoundBlock::m_hash
uint256 * m_hash
Definition: chain.h:55
CRPCCommand::actor
Actor actor
Definition: server.h:118
CRPCTable::appendCommand
void appendCommand(const std::string &name, const CRPCCommand *pcmd)
Appends a CRPCCommand to the dispatch table.
Definition: server.cpp:270
incrementalRelayFee
CFeeRate incrementalRelayFee
Definition: settings.cpp:12
GetAdjustedTime
int64_t GetAdjustedTime()
Definition: timedata.cpp:34
CChain
An in-memory indexed chain of blocks.
Definition: chain.h:392
base_blob::IsNull
bool IsNull() const
Definition: uint256.h:31
AppInitLockDataDirectory
bool AppInitLockDataDirectory()
Lock bitcoin core data directory.
Definition: init.cpp:1168
NodeContext::banman
std::unique_ptr< BanMan > banman
Definition: context.h:45
UniValue::get_int
int get_int() const
Definition: univalue_get.cpp:104
fees.h
util::FindKey
auto FindKey(Map &&map, Key &&key) -> decltype(&map.at(key))
Map lookup helper.
Definition: settings.h:100
translation.h
interfaces::Chain::isInMempool
virtual bool isInMempool(const uint256 &txid)=0
Check if transaction is in mempool.
CTxMemPoolEntry
Definition: txmempool.h:81
LOCK
#define LOCK(cs)
Definition: sync.h:232
MemPoolRemovalReason
MemPoolRemovalReason
Reason why a transaction was removed from the mempool, this is passed to the notification signal.
Definition: txmempool.h:395
gArgs
ArgsManager gArgs
Definition: system.cpp:79
interfaces::FoundBlock::m_max_time
int64_t * m_max_time
Definition: chain.h:58
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:59
blockstorage.h
TransactionError::OK
@ OK
No error.
CheckFinalTx
bool CheckFinalTx(const CBlockIndex *active_chain_tip, const CTransaction &tx, int flags)
Transaction validation functions.
Definition: validation.cpp:212
CRPCTable::removeCommand
bool removeCommand(const std::string &name, const CRPCCommand *pcmd)
Definition: server.cpp:277
interfaces::Chain::initMessage
virtual void initMessage(const std::string &message)=0
Send init message.
LockPoints
Definition: txmempool.h:39
RPCSerializationFlags
int RPCSerializationFlags()
Definition: server.cpp:540
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:15
Params
const CChainParams & Params()
Return the currently selected parameters.
Definition: chainparams.cpp:538
GetProxy
bool GetProxy(enum Network net, proxyType &proxyInfoOut)
Definition: netbase.cpp:616
node
Definition: interfaces.cpp:66
fImporting
std::atomic_bool fImporting
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:425
SynchronizationState
SynchronizationState
Current sync state passed to tip changed callbacks.
Definition: validation.h:104
JSONRPCRequest
Definition: request.h:28
banmap_t
std::map< CSubNet, CBanEntry > banmap_t
Definition: net_types.h:13
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:426
netbase.h
COutPoint
An outpoint - a combination of a transaction hash and an index n into its vout.
Definition: transaction.h:26
lp
LockPoints lp
Definition: mempool_eviction.cpp:17
interfaces::Chain::initError
virtual void initError(const bilingual_str &message)=0
Send init error.
DEFAULT_DESCENDANT_SIZE_LIMIT
static const unsigned int DEFAULT_DESCENDANT_SIZE_LIMIT
Default for -limitdescendantsize, maximum kilobytes of in-mempool descendants.
Definition: validation.h:70
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:352
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:8
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 ...
NodeContext::connman
std::unique_ptr< CConnman > connman
Definition: context.h:40
BLOCK_HAVE_DATA
@ BLOCK_HAVE_DATA
full block available in blk*.dat
Definition: chain.h:121
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
NodeContext
NodeContext struct containing references to chain state and connection state.
Definition: context.h:38
server.h
CNodeStateStats
Definition: net_processing.h:29
CBlockIndex
The block chain is a tree shaped structure starting with the genesis block at the root,...
Definition: chain.h:137
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:308
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:5019
assert
assert(std::addressof(::ChainstateActive().CoinsTip())==std::addressof(coins_cache))
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:232
StartShutdown
void StartShutdown()
Request shutdown of the application.
Definition: shutdown.cpp:56
CValidationInterface::UpdatedBlockTip
virtual void UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockIndex *pindexFork, bool fInitialDownload)
Notifies listeners when the block chain tip advances.
Definition: validationinterface.h:94
Shutdown
void Shutdown(NodeContext &node)
Definition: init.cpp:172
dustRelayFee
CFeeRate dustRelayFee
Definition: settings.cpp:13
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:237
DEFAULT_MAX_MEMPOOL_SIZE
static const unsigned int DEFAULT_MAX_MEMPOOL_SIZE
Default for -maxmempool, maximum megabytes of mempool memory usage.
Definition: policy.h:32
interfaces::FoundBlock::m_height
int * m_height
Definition: chain.h:56
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:117
it
auto it
Definition: validation.cpp:399
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.
NodeContext::chainman
ChainstateManager * chainman
Definition: context.h:44