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