 |
Bitcoin Core
22.99.0
P2P Digital Currency
|
Go to the documentation of this file.
45 #include <validation.h>
49 #if defined(HAVE_CONFIG_H)
58 #include <boost/signals2/signal.hpp>
70 #ifdef ENABLE_EXTERNAL_SIGNER
81 class NodeImpl :
public Node
91 bool baseInitialize()
override
100 void appShutdown()
override
105 void startShutdown()
override
115 void mapPort(
bool use_upnp,
bool use_natpmp)
override {
StartMapPort(use_upnp, use_natpmp); }
121 bool getNodesStats(NodesStats& stats)
override
126 std::vector<CNodeStats> stats_temp;
127 m_context->connman->GetNodeStats(stats_temp);
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());
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));
148 bool getBanned(
banmap_t& banmap)
override
156 bool ban(
const CNetAddr& net_addr, int64_t ban_time_offset)
override
159 m_context->banman->Ban(net_addr, ban_time_offset);
172 bool disconnectByAddress(
const CNetAddr& net_addr)
override
175 return m_context->connman->DisconnectNode(net_addr);
179 bool disconnectById(
NodeId id)
override
182 return m_context->connman->DisconnectNode(
id);
186 std::vector<std::unique_ptr<interfaces::ExternalSigner>> listExternalSigners()
override
188 #ifdef ENABLE_EXTERNAL_SIGNER
189 std::vector<ExternalSigner> signers = {};
190 const std::string command =
gArgs.
GetArg(
"-signer",
"");
191 if (command ==
"")
return {};
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)));
206 #endif // ENABLE_EXTERNAL_SIGNER
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
222 int getNumBlocks()
override
225 return chainman().ActiveChain().Height();
227 uint256 getBestBlockHash()
override
232 int64_t getLastBlockTime()
override
235 if (chainman().ActiveChain().Tip()) {
236 return chainman().ActiveChain().Tip()->GetBlockTime();
240 double getVerificationProgress()
override
245 tip = chainman().ActiveChain().Tip();
249 bool isInitialBlockDownload()
override {
250 return chainman().ActiveChainstate().IsInitialBlockDownload();
254 void setNetworkActive(
bool active)
override
257 m_context->connman->SetNetworkActive(active);
260 bool getNetworkActive()
override {
return m_context->connman &&
m_context->connman->GetNetworkActive(); }
262 UniValue executeRpc(
const std::string& command,
const UniValue& params,
const std::string& uri)
override
274 bool getUnspentOutput(
const COutPoint& output,
Coin& coin)
override
277 return chainman().ActiveChainstate().CoinsTip().GetCoin(output, coin);
287 std::unique_ptr<Handler> handleInitMessage(InitMessageFn fn)
override
291 std::unique_ptr<Handler> handleMessageBox(MessageBoxFn fn)
override
295 std::unique_ptr<Handler> handleQuestion(QuestionFn fn)
override
299 std::unique_ptr<Handler> handleShowProgress(ShowProgressFn fn)
override
303 std::unique_ptr<Handler> handleInitWallet(InitWalletFn fn)
override
307 std::unique_ptr<Handler> handleNotifyNumConnectionsChanged(NotifyNumConnectionsChangedFn fn)
override
311 std::unique_ptr<Handler> handleNotifyNetworkActiveChanged(NotifyNetworkActiveChangedFn fn)
override
315 std::unique_ptr<Handler> handleNotifyAlertChanged(NotifyAlertChangedFn fn)
override
319 std::unique_ptr<Handler> handleBannedListChanged(BannedListChangedFn fn)
override
323 std::unique_ptr<Handler> handleNotifyBlockTip(NotifyBlockTipFn fn)
override
326 fn(sync_state, BlockTip{block->nHeight, block->GetBlockTime(), block->GetBlockHash()},
330 std::unique_ptr<Handler> handleNotifyHeaderTip(NotifyHeaderTipFn fn)
override
334 fn(sync_state, BlockTip{block->nHeight, block->GetBlockTime(), block->GetBlockHash()},
339 void setContext(NodeContext*
context)
override
348 if (!index)
return false;
367 explicit NotificationsProxy(std::shared_ptr<Chain::Notifications> notifications)
369 virtual ~NotificationsProxy() =
default;
376 m_notifications->transactionRemovedFromMempool(tx, reason, mempool_sequence);
394 class NotificationsHandlerImpl :
public Handler
397 explicit NotificationsHandlerImpl(std::shared_ptr<Chain::Notifications> notifications)
398 :
m_proxy(std::make_shared<NotificationsProxy>(std::move(notifications)))
402 ~NotificationsHandlerImpl()
override {
disconnect(); }
413 class RpcHandlerImpl :
public Handler
452 class ChainImpl :
public Chain
462 int height = active.
Height();
494 return fork->nHeight;
502 return FillBlock(
m_node.chainman->m_blockman.LookupBlockIndex(hash), block, lock, active);
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);
519 return FillBlock(
nullptr, ancestor_out, lock, active);
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);
534 const CBlockIndex* block1 =
m_node.chainman->m_blockman.LookupBlockIndex(block_hash1);
535 const CBlockIndex* block2 =
m_node.chainman->m_blockman.LookupBlockIndex(block_hash2);
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)};
550 bool hasBlocks(
const uint256& block_hash,
int min_height, std::optional<int> max_height)
override
560 if (
CBlockIndex* block = chainman().m_blockman.LookupBlockIndex(block_hash)) {
561 if (max_height && block->
nHeight >= *max_height) block = block->
GetAncestor(*max_height);
564 if (block->
nHeight <= min_height || !block->
pprev)
return true;
577 if (!
m_node.mempool)
return false;
583 if (!
m_node.mempool)
return false;
585 auto it =
m_node.mempool->GetIter(txid);
586 return it && (*it)->GetCountWithDescendants() > 1;
591 std::string& err_string)
override
601 ancestors = descendants = 0;
602 if (!
m_node.mempool)
return;
603 m_node.mempool->GetTransactionAncestry(txid, ancestors, descendants, ancestorsize, ancestorfees);
605 void getPackageLimits(
unsigned int& limit_ancestor_count,
unsigned int& limit_descendant_count)
override
612 if (!
m_node.mempool)
return true;
620 std::string unused_error_string;
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);
628 if (!
m_node.fee_estimator)
return {};
629 return m_node.fee_estimator->estimateSmartFee(num_blocks, calc, conservative);
633 if (!
m_node.fee_estimator)
return 0;
638 if (!
m_node.mempool)
return {};
651 return chainman().ActiveChainstate().IsInitialBlockDownload();
657 void showProgress(
const std::string& title,
int progress,
bool resume_possible)
override
659 ::uiInterface.ShowProgress(title, progress, resume_possible);
661 std::unique_ptr<Handler>
handleNotifications(std::shared_ptr<Notifications> notifications)
override
663 return std::make_unique<NotificationsHandlerImpl>(std::move(notifications));
676 return std::make_unique<RpcHandlerImpl>(command);
679 void rpcRunLater(
const std::string&
name, std::function<
void()> fn, int64_t seconds)
override
706 settings.rw_settings.erase(name);
708 settings.rw_settings[name] = value;
715 if (!
m_node.mempool)
return;
718 notifications.transactionAddedToMempool(entry.
GetSharedTx(), 0 );
CBlockIndex * FindForkInGlobalIndex(const CBlockLocator &locator) const EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Find the last common block of this chain and a locator.
Implement this to subscribe to events generated in validation.
int64_t GetBlockTime() const
std::unique_ptr< Chain > MakeChain(node::NodeContext &node)
Return implementation of Chain interface.
virtual void TransactionRemovedFromMempool(const CTransactionRef &tx, MemPoolRemovalReason reason, uint64_t mempool_sequence)
Notifies listeners of a transaction leaving mempool.
bool AppInitInterfaces(NodeContext &node)
Initialize node and wallet interface pointers.
bool ShutdownRequested()
Returns true if a shutdown is requested, false otherwise.
std::set< txiter, CompareIteratorByHash > setEntries
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.
std::shared_ptr< NotificationsProxy > m_proxy
bool GetBoolArg(const std::string &strArg, bool fDefault) const
Return boolean argument or default value.
virtual double guessVerificationProgress(const uint256 &block_hash)=0
Estimate fraction of total transactions verified if blocks up to the specified block hash are verifie...
void StartMapPort(bool use_upnp, bool use_natpmp)
void RegisterSharedValidationInterface(std::shared_ptr< CValidationInterface > callbacks)
Register subscriber.
CBlockIndex * GetAncestor(int height)
Efficiently find an ancestor of this block.
virtual int rpcSerializationFlags()=0
Current RPC serialization flags.
void InitParameterInteraction(ArgsManager &args)
Parameter interaction: change current parameters depending on various rules.
static const unsigned int DEFAULT_ANCESTOR_SIZE_LIMIT
Default for -limitancestorsize, maximum kilobytes of tx + all in-mempool ancestors.
virtual void findCoins(std::map< COutPoint, Coin > &coins)=0
Look up unspent output information.
util::SettingsValue GetSetting(const std::string &arg) const
Get setting value.
unsigned int nTx
Number of transactions in this block.
CClientUIInterface uiInterface
void InitLogging(const ArgsManager &args)
Initialize global loggers.
bilingual_str GetWarnings(bool verbose)
Format a string that describes several potential problems detected by the core.
bool fHavePruned
Pruning-related variables and constants.
virtual void BlockDisconnected(const std::shared_ptr< const CBlock > &block, const CBlockIndex *pindex)
Notifies listeners of a block being disconnected.
void RPCUnsetTimerInterface(RPCTimerInterface *iface)
Unset factory function for timers.
RBFTransactionState
The rbf state of unconfirmed transactions.
virtual bool isInitialBlockDownload()=0
Check if in IBD.
CBlockIndex * pprev
pointer to the index of the predecessor of this block
int nHeight
height of the entry in the chain. The genesis block has height 0
NodeContext struct containing references to chain state and connection state.
void FindCoins(const NodeContext &node, std::map< COutPoint, Coin > &coins)
Look up unspent output information.
RBFTransactionState IsRBFOptInEmptyMempool(const CTransaction &tx)
CTransactionRef GetSharedTx() const
virtual std::unique_ptr< Handler > handleNotifications(std::shared_ptr< Notifications > notifications)=0
Register handler for notifications.
virtual std::vector< util::SettingsValue > getSettingsList(const std::string &arg)=0
Get list of settings values.
virtual void disconnect()=0
Disconnect the handler.
CFeeRate minRelayTxFee
A fee rate smaller than this is considered zero fee (for relaying, mining and transaction creation)
virtual bool hasDescendantsInMempool(const uint256 &txid)=0
Check if transaction has descendants in mempool.
void RPCRunLater(const std::string &name, std::function< void()> func, int64_t nSeconds)
Run func nSeconds from now.
const CBlockIndex * LastCommonAncestor(const CBlockIndex *pa, const CBlockIndex *pb)
Find the last common ancestor two blocks have.
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
uint32_t GetCategoryMask() const
static bool Enumerate(const std::string &command, std::vector< ExternalSigner > &signers, const std::string chain)
Obtain a list of signers.
const FoundBlock * m_next_block
Block and header tip information.
std::atomic_bool fImporting
virtual std::optional< int > getHeight()=0
Get current chain height, not including genesis block (returns 0 if chain only contains genesis block...
#define TRY_LOCK(cs, name)
virtual bool findBlock(const uint256 &hash, const FoundBlock &block={})=0
Return whether node has the block and optionally return block metadata or contents.
bool AppInitBasicSetup(const ArgsManager &args)
Initialize bitcoin core: Basic context setup.
static GenTxid Txid(const uint256 &hash)
std::shared_ptr< const CTransaction > CTransactionRef
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.
static const unsigned int DEFAULT_DESCENDANT_LIMIT
Default for -limitdescendantcount, max number of in-mempool descendants.
bool ReadBlockFromDisk(CBlock &block, const FlatFilePos &pos, const Consensus::Params &consensusParams)
Functions for disk access for blocks.
CBlockIndex * Tip() const
Returns the index entry for the tip of this chain, or nullptr if none.
virtual util::SettingsValue getRwSetting(const std::string &name)=0
Return <datadir>/settings.json setting value.
#define Assert(val)
Identity function.
Fee rate in satoshis per kilobyte: CAmount / kB.
virtual void getPackageLimits(unsigned int &limit_ancestor_count, unsigned int &limit_descendant_count)=0
Get the node's package limits.
The basic transaction that is broadcasted on the network and contained in blocks.
virtual CFeeRate relayIncrementalFee()=0
Relay incremental fee setting (-incrementalrelayfee), reflecting cost of relay.
int64_t GetBlockTimeMax() const
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...
virtual bool isReadyToBroadcast()=0
Check if the node is ready to broadcast transactions.
void SyncWithValidationInterfaceQueue()
This is a synonym for the following, which asserts certain locks are not held: std::promise<void> pro...
virtual bool havePruned()=0
Check if any block has been pruned.
Interface giving clients (wallet processes, maybe other analysis tools in the future) ability to acce...
virtual void BlockConnected(const std::shared_ptr< const CBlock > &block, const CBlockIndex *pindex)
Notifies listeners of a block being connected.
std::atomic_bool fReindex
static const unsigned int DEFAULT_ANCESTOR_LIMIT
Default for -limitancestorcount, max number of in-mempool ancestors.
External signer interface used by the GUI.
std::shared_ptr< Chain::Notifications > m_notifications
void RPCSetTimerInterfaceIfUnset(RPCTimerInterface *iface)
Set the factory function for timer, but only, if unset.
static CService ip(uint32_t i)
@ RPC_WALLET_NOT_FOUND
Invalid wallet specified.
virtual uint256 getBlockHash(int height)=0
Get block hash. Height must be valid or this function will abort.
virtual CFeeRate mempoolMinFee()=0
Mempool minimum fee.
int64_t GetMedianTimePast() const
virtual void ChainStateFlushed(const CBlockLocator &locator)
Notifies listeners of the new active block chain on-disk.
bool InitError(const bilingual_str &str)
Show error message.
UniValue execute(const JSONRPCRequest &request) const
Execute a method.
std::unique_ptr< Node > MakeNode(node::NodeContext &context)
Return implementation of Node interface.
virtual void waitForNotificationsIfTipChanged(const uint256 &old_tip)=0
Wait for pending notifications to be processed unless block hash points to the current chain tip.
bool AppInitMain(NodeContext &node, interfaces::BlockAndHeaderTipInfo *tip_info)
Bitcoin core main initialization.
bool WriteSettingsFile(std::vector< std::string > *errors=nullptr) const
Write settings file.
CBlockLocator GetLocator(const CBlockIndex *pindex=nullptr) const
Return a CBlockLocator that refers to a block in this chain (by default the tip).
CBlockIndex * pindexBestHeader
Best header we've seen so far (used for getheaders queries' starting points).
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...
Wallet chain client that in addition to having chain client methods for starting up,...
void UnregisterSharedValidationInterface(std::shared_ptr< CValidationInterface > callbacks)
Unregister subscriber.
std::string GetArg(const std::string &strArg, const std::string &strDefault) const
Return string argument or default value.
int64_t CAmount
Amount in satoshis (Can be negative)
virtual void TransactionAddedToMempool(const CTransactionRef &tx, uint64_t mempool_sequence)
Notifies listeners of a transaction having been added to mempool.
std::vector< std::string > listCommands() const
Returns a list of registered commands.
void Interrupt(NodeContext &node)
Interrupt threads.
virtual CFeeRate relayMinFee()=0
Relay current minimum fee (from -minrelaytxfee and -incrementalrelayfee settings).
virtual bool shutdownRequested()=0
Check if shutdown requested.
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...
virtual bool updateRwSetting(const std::string &name, const util::SettingsValue &value, bool write=true)=0
Write a setting to <datadir>/settings.json.
Helper for findBlock to selectively return pieces of block data.
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.
bool AppInitParameterInteraction(const ArgsManager &args)
Initialization: parameter interaction.
const CBlock & GenesisBlock() const
CChainState stores and provides an API to update our local knowledge of the current best chain.
bool AppInitSanityChecks()
Initialization sanity checks: ecc init, sanity checks, dir lock.
uint256 GetBlockHash() const
Top-level interface for a bitcoin node (bitcoind process).
int Height() const
Return the maximal height in the chain.
virtual RBFTransactionState isRBFOptIn(const CTransaction &tx)=0
Check if transaction is RBF opt in.
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.
virtual bool rpcEnableDeprecated(const std::string &method)=0
Check if deprecated RPC is enabled.
Provides an interface for creating and interacting with one or two chainstates: an IBD chainstate gen...
Enables interaction with an external signing device or service, such as a hardware wallet.
virtual CFeeRate estimateSmartFee(int num_blocks, bool conservative, FeeCalculation *calc=nullptr)=0
Estimate smart fee.
virtual void initWarning(const bilingual_str &message)=0
Send init warning.
void InitWarning(const bilingual_str &str)
Show warning message.
void LockSettings(Fn &&fn)
Access settings with lock held.
std::vector< util::SettingsValue > GetSettingsList(const std::string &arg) const
Get list of setting values.
void appendCommand(const std::string &name, const CRPCCommand *pcmd)
Appends a CRPCCommand to the dispatch table.
CFeeRate incrementalRelayFee
::ExternalSigner m_signer
An in-memory indexed chain of blocks.
bool AppInitLockDataDirectory()
Lock bitcoin core data directory.
auto FindKey(Map &&map, Key &&key) -> decltype(&map.at(key))
Map lookup helper.
virtual bool isInMempool(const uint256 &txid)=0
Check if transaction is in mempool.
MemPoolRemovalReason
Reason why a transaction was removed from the mempool, this is passed to the notification signal.
virtual CFeeRate relayDustFee()=0
Relay dust fee setting (-dustrelayfee), reflecting lowest rate it's economical to spend.
bool removeCommand(const std::string &name, const CRPCCommand *pcmd)
virtual void initMessage(const std::string &message)=0
Send init message.
virtual util::SettingsValue getSetting(const std::string &arg)=0
Get settings value.
int RPCSerializationFlags()
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.
virtual bool checkChainLimits(const CTransactionRef &tx)=0
Check if transaction will pass the mempool's chain limits.
BCLog::Logger & LogInstance()
const CChainParams & Params()
Return the currently selected parameters.
bool GetProxy(enum Network net, proxyType &proxyInfoOut)
virtual bool haveBlockOnDisk(int height)=0
Check that the block is available on disk (i.e.
SynchronizationState
Current sync state passed to tip changed callbacks.
std::map< CSubNet, CBanEntry > banmap_t
std::map< std::string, SettingsValue > rw_settings
Map of setting name to read-write file setting value.
const CRPCCommand * m_wrapped_command
An outpoint - a combination of a transaction hash and an index n into its vout.
virtual void initError(const bilingual_str &message)=0
Send init error.
static const unsigned int DEFAULT_DESCENDANT_SIZE_LIMIT
Default for -limitdescendantsize, maximum kilobytes of in-mempool descendants.
Generic interface for managing an event handler or callback function registered with another interfac...
bool IsDeprecatedRPCEnabled(const std::string &method)
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...
virtual CBlockLocator getTipLocator()=0
Get locator for the current chain tip.
virtual void requestMempoolTransactions(Notifications ¬ifications)=0
Synchronously send transactionAddedToMempool notifications about all current mempool transactions to ...
@ BLOCK_HAVE_DATA
full block available in blk*.dat
Describes a place in the block chain to another node such that if the other node doesn't have the sam...
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.
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
The block chain is a tree shaped structure starting with the genesis block at the root,...
virtual void showProgress(const std::string &title, int progress, bool resume_possible)=0
Send progress indicator.
int64_t GetIntArg(const std::string &strArg, int64_t nDefault) const
Return integer argument or default value.
virtual unsigned int estimateMaxBlocks()=0
Fee estimator max target.
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...
virtual std::unique_ptr< Handler > handleRpc(const CRPCCommand &command)=0
Register handler for RPC.
Block tip (could be a header or not, depends on the subscribed signal).
void StartShutdown()
Request shutdown of the application.
virtual void UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockIndex *pindexFork, bool fInitialDownload)
Notifies listeners when the block chain tip advances.
void Shutdown(NodeContext &node)
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,...
#define WAIT_LOCK(cs, name)
static const unsigned int DEFAULT_MAX_MEMPOOL_SIZE
Default for -maxmempool, maximum megabytes of mempool memory usage.
std::unique_ptr< Handler > MakeHandler(boost::signals2::connection connection)
Return handler wrapping a boost signal connection.
std::string m_name
Name of signer.
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.