38 #include <validation.h>
42 #if defined(HAVE_CONFIG_H)
43 #include <config/bitcoin-config.h>
48 #include <boost/signals2/signal.hpp>
66 class NodeImpl :
public Node {
71 explicit NodeImpl(NodeContext *context) { setContext(context); }
73 void initParameterInteraction()
override {
77 bool baseInitialize(
Config &config)
override {
86 return AppInitMain(config, rpcServer, httpRPCRequestProcessor,
89 void appShutdown()
override {
93 void startShutdown()
override {
103 bool isPersistentSettingIgnored(
const std::string &
name)
override {
104 bool ignored =
false;
108 ignored = !options->empty();
114 getPersistentSetting(
const std::string &
name)
override {
117 void updateRwSetting(
const std::string &
name,
121 settings.rw_settings.erase(name);
123 settings.rw_settings[name] = value;
128 void forceSetting(
const std::string &
name,
132 settings.forced_settings.erase(name);
134 settings.forced_settings[name] = value;
138 void resetSettings()
override {
145 void mapPort(
bool use_upnp,
bool use_natpmp)
override {
155 bool getNodesStats(NodesStats &stats)
override {
159 std::vector<CNodeStats> stats_temp;
160 m_context->connman->GetNodeStats(stats_temp);
162 stats.reserve(stats_temp.size());
163 for (
auto &node_stats_temp : stats_temp) {
164 stats.emplace_back(std::move(node_stats_temp),
false,
172 for (
auto &node_stats : stats) {
173 std::get<1>(node_stats) =
175 std::get<0>(node_stats).nodeid,
176 std::get<2>(node_stats));
184 bool getBanned(
banmap_t &banmap)
override {
191 bool ban(
const CNetAddr &net_addr, int64_t ban_time_offset)
override {
193 m_context->banman->Ban(net_addr, ban_time_offset);
198 bool unban(
const CSubNet &ip)
override {
205 bool disconnectByAddress(
const CNetAddr &net_addr)
override {
207 return m_context->connman->DisconnectNode(net_addr);
211 bool disconnectById(
NodeId id)
override {
213 return m_context->connman->DisconnectNode(
id);
217 int64_t getTotalBytesRecv()
override {
221 int64_t getTotalBytesSent()
override {
225 size_t getMempoolSize()
override {
228 size_t getMempoolDynamicUsage()
override {
232 bool getHeaderTip(
int &height, int64_t &block_time)
override {
234 auto best_header = chainman().m_best_header;
236 height = best_header->nHeight;
237 block_time = best_header->GetBlockTime();
242 int getNumBlocks()
override {
244 return chainman().ActiveChain().Height();
250 : chainman().GetParams().GenesisBlock().GetHash();
252 int64_t getLastBlockTime()
override {
254 if (chainman().ActiveChain().Tip()) {
255 return chainman().ActiveChain().Tip()->GetBlockTime();
258 return chainman().GetParams().GenesisBlock().GetBlockTime();
260 double getVerificationProgress()
override {
264 tip = chainman().ActiveChain().Tip();
269 bool isInitialBlockDownload()
override {
270 return chainman().ActiveChainstate().IsInitialBlockDownload();
272 bool isLoadingBlocks()
override {
273 return chainman().m_blockman.LoadingBlocks();
275 void setNetworkActive(
bool active)
override {
277 m_context->connman->SetNetworkActive(active);
280 bool getNetworkActive()
override {
283 CFeeRate getDustRelayFee()
override {
287 return m_context->mempool->m_dust_relay_feerate;
289 UniValue executeRpc(
const Config &config,
const std::string &command,
291 const std::string &uri)
override {
299 std::vector<std::string> listRpcCommands()
override {
308 bool getUnspentOutput(
const COutPoint &output,
Coin &coin)
override {
310 return chainman().ActiveChainstate().CoinsTip().GetCoin(output,
316 std::unique_ptr<Handler> handleInitMessage(InitMessageFn fn)
override {
319 std::unique_ptr<Handler> handleMessageBox(MessageBoxFn fn)
override {
322 std::unique_ptr<Handler> handleQuestion(QuestionFn fn)
override {
325 std::unique_ptr<Handler>
326 handleShowProgress(ShowProgressFn fn)
override {
329 std::unique_ptr<Handler> handleNotifyNumConnectionsChanged(
330 NotifyNumConnectionsChangedFn fn)
override {
332 ::
uiInterface.NotifyNumConnectionsChanged_connect(fn));
334 std::unique_ptr<Handler> handleNotifyNetworkActiveChanged(
335 NotifyNetworkActiveChangedFn fn)
override {
337 ::
uiInterface.NotifyNetworkActiveChanged_connect(fn));
339 std::unique_ptr<Handler>
340 handleNotifyAlertChanged(NotifyAlertChangedFn fn)
override {
343 std::unique_ptr<Handler>
344 handleBannedListChanged(BannedListChangedFn fn)
override {
347 std::unique_ptr<Handler>
348 handleNotifyBlockTip(NotifyBlockTipFn fn)
override {
353 BlockTip{block->nHeight, block->GetBlockTime(),
354 block->GetBlockHash()},
358 std::unique_ptr<Handler>
359 handleNotifyHeaderTip(NotifyHeaderTipFn fn)
override {
363 int64_t timestamp,
bool presync) {
365 BlockTip{int(height), timestamp, BlockHash{}}, presync);
368 NodeContext *context()
override {
return m_context; }
369 void setContext(NodeContext *context)
override {
m_context = context; }
398 FillBlock(active[index->
nHeight] == index
406 Params().GetConsensus())) {
415 explicit NotificationsProxy(
416 std::shared_ptr<Chain::Notifications> notifications)
418 virtual ~NotificationsProxy() =
default;
420 std::shared_ptr<
const std::vector<Coin>>,
421 uint64_t mempool_sequence)
override {
426 uint64_t mempool_sequence)
override {
440 bool is_ibd)
override {
449 class NotificationsHandlerImpl :
public Handler {
451 explicit NotificationsHandlerImpl(
452 std::shared_ptr<Chain::Notifications> notifications)
453 :
m_proxy(std::make_shared<NotificationsProxy>(
454 std::move(notifications))) {
457 ~NotificationsHandlerImpl()
override {
disconnect(); }
467 class RpcHandlerImpl :
public Handler {
469 explicit RpcHandlerImpl(
const CRPCCommand &command)
473 UniValue &result,
bool last_handler) {
511 class ChainImpl :
public Chain {
518 std::optional<int>
getHeight()
override {
521 int height = active.
Height();
538 return block && (block->nStatus.hasData() != 0) && block->
nTx > 0;
553 return fork->nHeight;
561 return FillBlock(
m_node.chainman->m_blockman.LookupBlockIndex(hash),
562 block, lock, active);
569 block, lock, active);
577 m_node.chainman->m_blockman.LookupBlockIndex(block_hash)) {
579 block->GetAncestor(ancestor_height)) {
580 return FillBlock(ancestor, ancestor_out, lock, active);
583 return FillBlock(
nullptr, ancestor_out, lock, active);
591 m_node.chainman->m_blockman.LookupBlockIndex(block_hash);
593 m_node.chainman->m_blockman.LookupBlockIndex(ancestor_hash);
594 if (block && ancestor &&
598 return FillBlock(ancestor, ancestor_out, lock, active);
608 m_node.chainman->m_blockman.LookupBlockIndex(block_hash1);
610 m_node.chainman->m_blockman.LookupBlockIndex(block_hash2);
616 return int{FillBlock(ancestor, ancestor_out, lock, active)} &
617 int{FillBlock(block1, block1_out, lock, active)} &
618 int{FillBlock(block2, block2_out, lock, active)};
620 void findCoins(std::map<COutPoint, Coin> &coins)
override {
626 chainman().GetParams().TxData(),
627 chainman().m_blockman.LookupBlockIndex(block_hash));
630 std::optional<int> max_height)
override {
640 chainman().m_blockman.LookupBlockIndex(block_hash)) {
641 if (max_height && block->
nHeight >= *max_height) {
644 for (; block->nStatus.hasData(); block = block->
pprev) {
655 const Amount &max_tx_fee,
bool relay,
656 std::string &err_string)
override {
671 return m_node.mempool->estimateFee();
677 return m_node.mempool->m_min_relay_feerate;
683 return m_node.mempool->m_dust_relay_feerate;
687 return m_node.chainman->m_blockman.m_have_pruned;
690 return !chainman().m_blockman.LoadingBlocks() &&
694 return chainman().ActiveChainstate().IsInitialBlockDownload();
697 void initMessage(
const std::string &message)
override {
706 void showProgress(
const std::string &title,
int progress,
707 bool resume_possible)
override {
708 ::uiInterface.ShowProgress(title, progress, resume_possible);
711 std::shared_ptr<Notifications> notifications)
override {
712 return std::make_unique<NotificationsHandlerImpl>(
713 std::move(notifications));
727 std::unique_ptr<Handler>
729 return std::make_unique<RpcHandlerImpl>(command);
735 int64_t seconds)
override {
742 std::vector<util::SettingsValue>
758 bool write)
override {
761 settings.rw_settings.erase(name);
763 settings.rw_settings[name] = value;
774 notifications.transactionAddedToMempool(entry->GetSharedTx(),
787 return std::make_unique<node::NodeImpl>(context);
791 return std::make_unique<node::ChainImpl>(
node, params);
const CBlockIndex * LastCommonAncestor(const CBlockIndex *pa, const CBlockIndex *pb)
Find the last common ancestor two blocks have.
const CChainParams & Params()
Return the currently selected parameters.
#define Assert(val)
Identity function.
util::SettingsValue GetPersistentSetting(const std::string &name) const
Get current setting from config file or read/write settings file, ignoring nonpersistent command line...
void LockSettings(Fn &&fn)
Access settings with lock held.
bool WriteSettingsFile(std::vector< std::string > *errors=nullptr, bool backup=false) const
Write settings file or backup settings file.
std::vector< util::SettingsValue > GetSettingsList(const std::string &arg) const
Get list of setting values.
util::SettingsValue GetSetting(const std::string &arg) const
Get setting value.
bool GetBoolArg(const std::string &strArg, bool fDefault) const
Return boolean argument or default value.
The block chain is a tree shaped structure starting with the genesis block at the root,...
CBlockIndex * pprev
pointer to the index of the predecessor of this block
int64_t GetBlockTime() const
int64_t GetMedianTimePast() const
int64_t GetBlockTimeMax() const
unsigned int nTx
Number of transactions in this block.
CBlockIndex * GetAncestor(int height)
Efficiently find an ancestor of this block.
BlockHash GetBlockHash() const
int nHeight
height of the entry in the chain. The genesis block has height 0
An in-memory indexed chain of blocks.
CBlockIndex * Tip() const
Returns the index entry for the tip of this chain, or nullptr if none.
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...
int Height() const
Return the maximal height in the chain.
CBlockLocator GetLocator() const
Return a CBlockLocator that refers to the tip of this chain.
CChainParams defines various tweakable parameters of a given instance of the Bitcoin system.
Fee rate in satoshis per kilobyte: Amount / kB.
An outpoint - a combination of a transaction hash and an index n into its vout.
bool removeCommand(const std::string &name, const CRPCCommand *pcmd)
std::vector< std::string > listCommands() const
Returns a list of registered commands.
UniValue execute(const Config &config, const JSONRPCRequest &request) const
Execute a method.
void appendCommand(const std::string &name, const CRPCCommand *pcmd)
Appends a CRPCCommand to the dispatch table.
Implement this to subscribe to events generated in validation.
virtual void ChainStateFlushed(const CBlockLocator &locator)
Notifies listeners of the new active block chain on-disk.
virtual void TransactionAddedToMempool(const CTransactionRef &tx, std::shared_ptr< const std::vector< Coin >> spent_coins, uint64_t mempool_sequence)
Notifies listeners of a transaction having been added to mempool.
virtual void TransactionRemovedFromMempool(const CTransactionRef &tx, MemPoolRemovalReason reason, uint64_t mempool_sequence)
Notifies listeners of a transaction leaving mempool.
virtual void UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockIndex *pindexFork, bool fInitialDownload)
Notifies listeners when the block chain tip advances.
virtual void BlockConnected(const std::shared_ptr< const CBlock > &block, const CBlockIndex *pindex)
Notifies listeners of a block being connected.
virtual void BlockDisconnected(const std::shared_ptr< const CBlock > &block, const CBlockIndex *pindex)
Notifies listeners of a block being disconnected.
Chainstate stores and provides an API to update our local knowledge of the current best chain.
const CBlockIndex * FindForkInGlobalIndex(const CBlockLocator &locator) const EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Find the last common block of this chain and a locator.
Provides an interface for creating and interacting with one or two chainstates: an IBD chainstate gen...
Class for registering and managing all RPC calls.
Wrapper around std::unique_lock style lock for Mutex.
Interface giving clients (wallet processes, maybe other analysis tools in the future) ability to acce...
virtual void rpcRunLater(const std::string &name, std::function< void()> fn, int64_t seconds)=0
Run function after given number of seconds.
virtual CBlockLocator getTipLocator()=0
Get locator for the current chain tip.
virtual bool findAncestorByHash(const BlockHash &block_hash, const BlockHash &ancestor_hash, const FoundBlock &ancestor_out={})=0
Return whether block descends from a specified ancestor, and optionally return ancestor information.
virtual bool isInitialBlockDownload()=0
Check if in IBD.
virtual BlockHash getBlockHash(int height)=0
Get block hash. Height must be valid or this function will abort.
virtual bool rpcEnableDeprecated(const std::string &method)=0
Check if deprecated RPC is enabled.
virtual int rpcSerializationFlags()=0
Current RPC serialization flags.
virtual bool findBlock(const BlockHash &hash, const FoundBlock &block={})=0
Return whether node has the block and optionally return block metadata or contents.
virtual bool findCommonAncestor(const BlockHash &block_hash1, const BlockHash &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.
virtual bool updateRwSetting(const std::string &name, const util::SettingsValue &value, bool write=true)=0
Write a setting to <datadir>/settings.json.
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,...
virtual bool broadcastTransaction(const Config &config, const CTransactionRef &tx, const Amount &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...
virtual util::SettingsValue getRwSetting(const std::string &name)=0
Return <datadir>/settings.json setting value.
virtual double guessVerificationProgress(const BlockHash &block_hash)=0
Estimate fraction of total transactions verified if blocks up to the specified block hash are verifie...
virtual void showProgress(const std::string &title, int progress, bool resume_possible)=0
Send progress indicator.
virtual bool havePruned()=0
Check if any block has been pruned.
virtual void findCoins(std::map< COutPoint, Coin > &coins)=0
Look up unspent output information.
virtual bool shutdownRequested()=0
Check if shutdown requested.
virtual std::optional< int > getHeight()=0
Get current chain height, not including genesis block (returns 0 if chain only contains genesis block...
virtual bool isReadyToBroadcast()=0
Check if the node is ready to broadcast transactions.
virtual bool hasBlocks(const BlockHash &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.
virtual util::SettingsValue getSetting(const std::string &arg)=0
Get settings value.
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...
virtual bool findAncestorByHeight(const BlockHash &block_hash, int ancestor_height, const FoundBlock &ancestor_out={})=0
Find ancestor of block at specified height and optionally return ancestor information.
virtual void initMessage(const std::string &message)=0
Send init message.
virtual std::unique_ptr< Handler > handleNotifications(std::shared_ptr< Notifications > notifications)=0
Register handler for notifications.
virtual bool haveBlockOnDisk(int height)=0
Check that the block is available on disk (i.e.
virtual std::unique_ptr< Handler > handleRpc(const CRPCCommand &command)=0
Register handler for RPC.
virtual CFeeRate relayDustFee()=0
Relay dust fee setting (-dustrelayfee), reflecting lowest rate it's economical to spend.
virtual CFeeRate estimateFee() const =0
Estimate fee.
virtual void requestMempoolTransactions(Notifications ¬ifications)=0
Synchronously send transactionAddedToMempool notifications about all current mempool transactions to ...
virtual void initError(const bilingual_str &message)=0
Send init error.
virtual void waitForNotificationsIfTipChanged(const BlockHash &old_tip)=0
Wait for pending notifications to be processed unless block hash points to the current chain tip.
virtual void initWarning(const bilingual_str &message)=0
Send init warning.
virtual CFeeRate relayMinFee()=0
Relay current minimum fee (from -minrelaytxfee settings).
virtual const CChainParams & params() const =0
This Chain's parameters.
virtual std::vector< util::SettingsValue > getSettingsList(const std::string &arg)=0
Get list of settings values.
Helper for findBlock to selectively return pieces of block data.
const FoundBlock * m_next_block
Generic interface for managing an event handler or callback function registered with another interfac...
virtual void disconnect()=0
Disconnect the handler.
Top-level interface for a bitcoin node (bitcoind process).
Wallet chain client that in addition to having chain client methods for starting up,...
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
void Interrupt(NodeContext &node)
Interrupt threads.
void InitLogging(const ArgsManager &args)
Initialize global loggers.
bool AppInitLockDataDirectory()
Lock bitcoin data directory.
void Shutdown(NodeContext &node)
bool AppInitMain(Config &config, RPCServer &rpcServer, HTTPRPCRequestProcessor &httpRPCRequestProcessor, NodeContext &node, interfaces::BlockAndHeaderTipInfo *tip_info)
Bitcoin main initialization.
bool AppInitBasicSetup(const ArgsManager &args)
Initialize bitcoin: Basic context setup.
bool AppInitSanityChecks()
Initialization sanity checks: ecc init, sanity checks, dir lock.
bool AppInitInterfaces(NodeContext &node)
Initialize node and wallet interface pointers.
void InitParameterInteraction(ArgsManager &args)
Parameter interaction: change current parameters depending on various rules.
bool AppInitParameterInteraction(Config &config, const ArgsManager &args)
Initialization: parameter interaction.
void StartMapPort(bool use_upnp, bool use_natpmp)
std::unique_ptr< Handler > MakeHandler(boost::signals2::connection connection)
Return handler wrapping a boost signal connection.
std::unique_ptr< Node > MakeNode(node::NodeContext *context)
Return implementation of Node interface.
std::unique_ptr< Chain > MakeChain(node::NodeContext &node, const CChainParams ¶ms)
Return implementation of Chain interface.
TransactionError BroadcastTransaction(const NodeContext &node, const CTransactionRef tx, std::string &err_string, const Amount max_tx_fee, bool relay, bool wait_callback)
Submit a transaction to the mempool and (optionally) relay it to all P2P peers.
bool ReadBlockFromDisk(CBlock &block, const FlatFilePos &pos, const Consensus::Params ¶ms)
Functions for disk access for blocks.
void FindCoins(const NodeContext &node, std::map< COutPoint, Coin > &coins)
Look up unspent output information.
Implement std::hash so RCUPtr can be used as a key for maps or sets.
auto FindKey(Map &&map, Key &&key) -> decltype(&map.at(key))
Map lookup helper.
std::map< CSubNet, CBanEntry > banmap_t
bool GetProxy(enum Network net, proxyType &proxyInfoOut)
std::shared_ptr< Chain::Notifications > m_notifications
const CChainParams & m_params
const CRPCCommand * m_wrapped_command
std::shared_ptr< NotificationsProxy > m_proxy
static constexpr Amount DUST_RELAY_TX_FEE(1000 *SATOSHI)
Min feerate for defining dust.
static constexpr Amount DEFAULT_MIN_RELAY_TX_FEE_PER_KB(1000 *SATOSHI)
Default for -minrelaytxfee, minimum relay fee for transactions.
std::shared_ptr< const CTransaction > CTransactionRef
@ RPC_WALLET_NOT_FOUND
Invalid wallet specified.
void RPCSetTimerInterfaceIfUnset(RPCTimerInterface *iface)
Set the factory function for timer, but only, if unset.
bool IsDeprecatedRPCEnabled(const ArgsManager &args, const std::string &method)
void RPCUnsetTimerInterface(RPCTimerInterface *iface)
Unset factory function for timers.
void RPCRunLater(const std::string &name, std::function< void()> func, int64_t nSeconds)
Run func nSeconds from now.
int RPCSerializationFlags()
Retrieves any serialization flags requested in command line argument.
bool ShutdownRequested()
Returns true if a shutdown is requested, false otherwise.
void StartShutdown()
Request shutdown of the application.
A BlockHash is a unqiue identifier for a block.
Describes a place in the block chain to another node such that if the other node doesn't have the sam...
Block and header tip information.
Block tip (could be a header or not, depends on the subscribed signal).
NodeContext struct containing references to chain state and connection state.
std::map< std::string, SettingsValue > rw_settings
Map of setting name to read-write file setting value.
std::map< std::string, std::vector< SettingsValue > > command_line_options
Map of setting name to list of command line values.
#define WAIT_LOCK(cs, name)
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
#define TRY_LOCK(cs, name)
MemPoolRemovalReason
Reason why a transaction was removed from the mempool, this is passed to the notification signal.
CClientUIInterface uiInterface
void InitWarning(const bilingual_str &str)
Show warning message.
bool InitError(const bilingual_str &str)
Show error message.
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...
SynchronizationState
Current sync state passed to tip changed callbacks.
void UnregisterSharedValidationInterface(std::shared_ptr< CValidationInterface > callbacks)
Unregister subscriber.
void SyncWithValidationInterfaceQueue()
This is a synonym for the following, which asserts certain locks are not held: std::promise<void> pro...
void RegisterSharedValidationInterface(std::shared_ptr< CValidationInterface > callbacks)
Register subscriber.
bilingual_str GetWarnings(bool verbose)
Format a string that describes several potential problems detected by the core.