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