7 #include <blockfilter.h>
9 #include <chainparams.h>
44 #include <txmempool.h>
51 #include <validation.h>
55 #if defined(HAVE_CONFIG_H)
64 #include <boost/signals2/signal.hpp>
78 #ifdef ENABLE_EXTERNAL_SIGNER
88 class NodeImpl :
public Node
91 explicit NodeImpl(NodeContext& context) { setContext(&context); }
95 int getExitStatus()
override {
return Assert(
m_context)->exit_status.load(); }
97 bool baseInitialize()
override
102 m_context->kernel = std::make_unique<kernel::Context>();
114 m_context->exit_status.store(EXIT_FAILURE);
117 void appShutdown()
override
122 void startShutdown()
override
125 LogPrintf(
"Error: failed to send shutdown signal\n");
128 if (
args().GetBoolArg(
"-server",
false)) {
134 bool isSettingIgnored(
const std::string&
name)
override
136 bool ignored =
false;
139 ignored = !options->empty();
149 settings.rw_settings.erase(name);
151 settings.rw_settings[name] = value;
160 settings.forced_settings.erase(name);
162 settings.forced_settings[name] = value;
166 void resetSettings()
override
174 void mapPort(
bool use_upnp,
bool use_natpmp)
override {
StartMapPort(use_upnp, use_natpmp); }
180 bool getNodesStats(NodesStats& stats)
override
185 std::vector<CNodeStats> stats_temp;
186 m_context->connman->GetNodeStats(stats_temp);
188 stats.reserve(stats_temp.size());
189 for (
auto& node_stats_temp : stats_temp) {
190 stats.emplace_back(std::move(node_stats_temp),
false,
CNodeStateStats());
197 for (
auto& node_stats : stats) {
198 std::get<1>(node_stats) =
199 m_context->peerman->GetNodeStateStats(std::get<0>(node_stats).nodeid, std::get<2>(node_stats));
207 bool getBanned(
banmap_t& banmap)
override
215 bool ban(
const CNetAddr& net_addr, int64_t ban_time_offset)
override
218 m_context->banman->Ban(net_addr, ban_time_offset);
231 bool disconnectByAddress(
const CNetAddr& net_addr)
override
234 return m_context->connman->DisconnectNode(net_addr);
238 bool disconnectById(
NodeId id)
override
241 return m_context->connman->DisconnectNode(
id);
245 std::vector<std::unique_ptr<interfaces::ExternalSigner>> listExternalSigners()
override
247 #ifdef ENABLE_EXTERNAL_SIGNER
248 std::vector<ExternalSigner> signers = {};
252 std::vector<std::unique_ptr<interfaces::ExternalSigner>> result;
253 result.reserve(signers.size());
254 for (
auto& signer : signers) {
255 result.emplace_back(std::make_unique<ExternalSignerImpl>(std::move(signer)));
268 int64_t getTotalBytesRecv()
override {
return m_context->connman ?
m_context->connman->GetTotalBytesRecv() : 0; }
269 int64_t getTotalBytesSent()
override {
return m_context->connman ?
m_context->connman->GetTotalBytesSent() : 0; }
270 size_t getMempoolSize()
override {
return m_context->mempool ?
m_context->mempool->size() : 0; }
271 size_t getMempoolDynamicUsage()
override {
return m_context->mempool ?
m_context->mempool->DynamicMemoryUsage() : 0; }
272 bool getHeaderTip(
int& height, int64_t& block_time)
override
275 auto best_header = chainman().m_best_header;
277 height = best_header->nHeight;
278 block_time = best_header->GetBlockTime();
283 int getNumBlocks()
override
286 return chainman().ActiveChain().Height();
288 uint256 getBestBlockHash()
override
291 return tip ? tip->
GetBlockHash() : chainman().GetParams().GenesisBlock().GetHash();
293 int64_t getLastBlockTime()
override
296 if (chainman().ActiveChain().Tip()) {
297 return chainman().ActiveChain().Tip()->GetBlockTime();
299 return chainman().GetParams().GenesisBlock().GetBlockTime();
301 double getVerificationProgress()
override
305 bool isInitialBlockDownload()
override
307 return chainman().IsInitialBlockDownload();
309 bool isLoadingBlocks()
override {
return chainman().m_blockman.LoadingBlocks(); }
310 void setNetworkActive(
bool active)
override
313 m_context->connman->SetNetworkActive(active);
316 bool getNetworkActive()
override {
return m_context->connman &&
m_context->connman->GetNetworkActive(); }
320 return m_context->mempool->m_dust_relay_feerate;
334 std::optional<Coin> getUnspentOutput(
const COutPoint& output)
override
338 if (chainman().ActiveChainstate().CoinsTip().GetCoin(output, coin))
return coin;
349 std::unique_ptr<Handler> handleInitMessage(InitMessageFn fn)
override
353 std::unique_ptr<Handler> handleMessageBox(MessageBoxFn fn)
override
357 std::unique_ptr<Handler> handleQuestion(QuestionFn fn)
override
361 std::unique_ptr<Handler> handleShowProgress(ShowProgressFn fn)
override
365 std::unique_ptr<Handler> handleInitWallet(InitWalletFn fn)
override
369 std::unique_ptr<Handler> handleNotifyNumConnectionsChanged(NotifyNumConnectionsChangedFn fn)
override
373 std::unique_ptr<Handler> handleNotifyNetworkActiveChanged(NotifyNetworkActiveChangedFn fn)
override
377 std::unique_ptr<Handler> handleNotifyAlertChanged(NotifyAlertChangedFn fn)
override
381 std::unique_ptr<Handler> handleBannedListChanged(BannedListChangedFn fn)
override
385 std::unique_ptr<Handler> handleNotifyBlockTip(NotifyBlockTipFn fn)
override
388 fn(sync_state, BlockTip{block->nHeight, block->GetBlockTime(), block->GetBlockHash()},
392 std::unique_ptr<Handler> handleNotifyHeaderTip(NotifyHeaderTipFn fn)
override
396 fn(sync_state, BlockTip{(int)height, timestamp, uint256{}}, presync);
399 NodeContext* context()
override {
return m_context; }
400 void setContext(NodeContext* context)
override
411 if (!index)
return false;
431 explicit NotificationsProxy(std::shared_ptr<Chain::Notifications> notifications)
433 virtual ~NotificationsProxy() =
default;
460 class NotificationsHandlerImpl :
public Handler
463 explicit NotificationsHandlerImpl(
ValidationSignals& signals, std::shared_ptr<Chain::Notifications> notifications)
464 :
m_signals{signals},
m_proxy{std::make_shared<NotificationsProxy>(std::move(notifications))}
468 ~NotificationsHandlerImpl()
override {
disconnect(); }
480 class RpcHandlerImpl :
public Handler
519 class ChainImpl :
public Chain
525 const int height{
WITH_LOCK(::
cs_main,
return chainman().ActiveChain().Height())};
526 return height >= 0 ? std::optional{height} : std::nullopt;
531 return Assert(chainman().ActiveChain()[height])->GetBlockHash();
536 const CBlockIndex* block{chainman().ActiveChain()[height]};
542 return chainman().ActiveChain().GetLocator();
547 const CBlockIndex* index = chainman().m_blockman.LookupBlockIndex(block_hash);
553 if (
const CBlockIndex* fork = chainman().ActiveChainstate().FindForkInGlobalIndex(locator)) {
554 return fork->nHeight;
565 if (!block_filter_index)
return std::nullopt;
569 if (index ==
nullptr || !block_filter_index->LookupFilter(index, filter))
return std::nullopt;
575 return FillBlock(chainman().m_blockman.LookupBlockIndex(hash), block, lock, chainman().ActiveChain(), chainman().m_blockman);
580 const CChain& active = chainman().ActiveChain();
581 return FillBlock(active.
FindEarliestAtLeast(min_time, min_height), block, lock, active, chainman().m_blockman);
586 const CChain& active = chainman().ActiveChain();
587 if (
const CBlockIndex* block = chainman().m_blockman.LookupBlockIndex(block_hash)) {
588 if (
const CBlockIndex* ancestor = block->GetAncestor(ancestor_height)) {
589 return FillBlock(ancestor, ancestor_out, lock, active, chainman().m_blockman);
592 return FillBlock(
nullptr, ancestor_out, lock, active, chainman().m_blockman);
597 const CBlockIndex* block = chainman().m_blockman.LookupBlockIndex(block_hash);
598 const CBlockIndex* ancestor = chainman().m_blockman.LookupBlockIndex(ancestor_hash);
599 if (block && ancestor && block->
GetAncestor(ancestor->
nHeight) != ancestor) ancestor =
nullptr;
600 return FillBlock(ancestor, ancestor_out, lock, chainman().ActiveChain(), chainman().m_blockman);
605 const CChain& active = chainman().ActiveChain();
606 const CBlockIndex* block1 = chainman().m_blockman.LookupBlockIndex(block_hash1);
607 const CBlockIndex* block2 = chainman().m_blockman.LookupBlockIndex(block_hash2);
612 return int{FillBlock(ancestor, ancestor_out, lock, active, chainman().m_blockman)} &
613 int{FillBlock(block1, block1_out, lock, active, chainman().m_blockman)} &
614 int{FillBlock(block2, block2_out, lock, active, chainman().m_blockman)};
622 bool hasBlocks(
const uint256& block_hash,
int min_height, std::optional<int> max_height)
override
632 if (
const CBlockIndex* block = chainman().m_blockman.LookupBlockIndex(block_hash)) {
633 if (max_height && block->
nHeight >= *max_height) block = block->
GetAncestor(*max_height);
636 if (block->
nHeight <= min_height || !block->
pprev)
return true;
649 if (!
m_node.mempool)
return false;
655 if (!
m_node.mempool)
return false;
658 if (entry ==
nullptr)
return false;
659 return entry->GetCountWithDescendants() > 1;
664 std::string& err_string)
override
674 ancestors = descendants = 0;
675 if (!
m_node.mempool)
return;
676 m_node.mempool->GetTransactionAncestry(txid, ancestors, descendants, ancestorsize, ancestorfees);
682 std::map<COutPoint, CAmount> bump_fees;
683 for (
const auto& outpoint : outpoints) {
684 bump_fees.emplace(outpoint, 0);
688 return MiniMiner(*
m_node.mempool, outpoints).CalculateBumpFees(target_feerate);
696 return MiniMiner(*
m_node.mempool, outpoints).CalculateTotalBumpFees(target_feerate);
698 void getPackageLimits(
unsigned int& limit_ancestor_count,
unsigned int& limit_descendant_count)
override
704 limit_ancestor_count = limits.ancestor_count;
705 limit_descendant_count = limits.descendant_count;
709 if (!
m_node.mempool)
return {};
713 return m_node.mempool->CheckPackageLimits({tx}, entry.GetTxSize());
717 if (!
m_node.fee_estimator)
return {};
718 return m_node.fee_estimator->estimateSmartFee(num_blocks, calc, conservative);
722 if (!
m_node.fee_estimator)
return 0;
727 if (!
m_node.mempool)
return {};
728 return m_node.mempool->GetMinFee();
733 return m_node.mempool->m_min_relay_feerate;
738 return m_node.mempool->m_incremental_relay_feerate;
743 return m_node.mempool->m_dust_relay_feerate;
748 return chainman().m_blockman.m_have_pruned;
753 return chainman().IsInitialBlockDownload();
759 void showProgress(
const std::string& title,
int progress,
bool resume_possible)
override
761 ::uiInterface.ShowProgress(title, progress, resume_possible);
763 std::unique_ptr<Handler>
handleNotifications(std::shared_ptr<Notifications> notifications)
override
765 return std::make_unique<NotificationsHandlerImpl>(validation_signals(), std::move(notifications));
769 if (!old_tip.
IsNull() && old_tip ==
WITH_LOCK(::
cs_main,
return chainman().ActiveChain().Tip()->GetBlockHash()))
return;
770 validation_signals().SyncWithValidationInterfaceQueue();
774 return std::make_unique<RpcHandlerImpl>(
command);
777 void rpcRunLater(
const std::string&
name, std::function<
void()> fn, int64_t seconds)
override
803 settings.rw_settings.erase(name);
805 settings.rw_settings[name] = value;
812 if (!
m_node.mempool)
return;
815 notifications.transactionAddedToMempool(entry.GetSharedTx());
820 return chainman().IsSnapshotActive();
int64_t CAmount
Amount in satoshis (Can be negative)
BlockFilterIndex * GetBlockFilterIndex(BlockFilterType filter_type)
Get a block filter index by type.
CBlockLocator GetLocator(const CBlockIndex *index)
Get a locator for a block index entry.
const CBlockIndex * LastCommonAncestor(const CBlockIndex *pa, const CBlockIndex *pb)
Find the last common ancestor two blocks have.
@ BLOCK_HAVE_DATA
full block available in blk*.dat
const CChainParams & Params()
Return the currently selected parameters.
#define Assert(val)
Identity function.
common::SettingsValue GetSetting(const std::string &arg) const
Get setting value.
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< common::SettingsValue > GetSettingsList(const std::string &arg) const
Get list of setting values.
common::SettingsValue GetPersistentSetting(const std::string &name) const
Get current setting from config file or read/write settings file, ignoring nonpersistent command line...
std::string GetArg(const std::string &strArg, const std::string &strDefault) const
Return string argument or default value.
uint32_t GetCategoryMask() const
Complete block filter struct as defined in BIP 157.
const GCSFilter & GetFilter() const LIFETIMEBOUND
BlockFilterIndex is used to store and retrieve block filters, hashes, and headers for a range of bloc...
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
uint256 GetBlockHash() const
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.
int nHeight
height of the entry in the chain. The genesis block has height 0
An in-memory indexed chain of blocks.
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...
Fee rate in satoshis per kilovirtualbyte: CAmount / kvB.
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 JSONRPCRequest &request) const
Execute a method.
void appendCommand(const std::string &name, const CRPCCommand *pcmd)
Appends a CRPCCommand to the dispatch table.
The basic transaction that is broadcasted on the network and contained in blocks.
CTxMemPoolEntry stores data about the corresponding transaction, as well as data about all in-mempool...
Implement this to subscribe to events generated in validation and mempool.
virtual void ChainStateFlushed(ChainstateRole role, const CBlockLocator &locator)
Notifies listeners of the new active block chain on-disk.
virtual void BlockConnected(ChainstateRole role, const std::shared_ptr< const CBlock > &block, const CBlockIndex *pindex)
Notifies listeners of a block being connected.
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 TransactionAddedToMempool(const NewMempoolTransactionInfo &tx, uint64_t mempool_sequence)
Notifies listeners of a transaction having been added to mempool.
virtual void BlockDisconnected(const std::shared_ptr< const CBlock > &block, const CBlockIndex *pindex)
Notifies listeners of a block being disconnected Provides the block that was disconnected.
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.
std::string m_name
Name of signer.
static bool Enumerate(const std::string &command, std::vector< ExternalSigner > &signers, const std::string chain)
Obtain a list of signers.
std::unordered_set< Element, ByteVectorHash > ElementSet
bool MatchAny(const ElementSet &elements) const
Checks if any of the given elements may be in the set.
static GenTxid Txid(const uint256 &hash)
Wrapper around std::unique_lock style lock for MutexType.
void RegisterSharedValidationInterface(std::shared_ptr< CValidationInterface > callbacks)
Register subscriber.
void UnregisterSharedValidationInterface(std::shared_ptr< CValidationInterface > callbacks)
Unregister subscriber.
constexpr bool IsNull() const
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. Cancel any previous calls with same name.
virtual CBlockLocator getTipLocator()=0
Get locator for the current chain tip.
virtual bool isInitialBlockDownload()=0
Check if in IBD.
virtual bool hasDescendantsInMempool(const uint256 &txid)=0
Check if transaction has descendants in mempool.
virtual CBlockLocator getActiveChainLocator(const uint256 &block_hash)=0
Return a locator that refers to a block in the active chain.
virtual bool rpcEnableDeprecated(const std::string &method)=0
Check if deprecated RPC is enabled.
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.
virtual std::optional< CAmount > calculateCombinedBumpFee(const std::vector< COutPoint > &outpoints, const CFeeRate &target_feerate)=0
Calculate the combined bump fee for an input set per the same strategy.
virtual std::map< COutPoint, CAmount > calculateIndividualBumpFees(const std::vector< COutPoint > &outpoints, const CFeeRate &target_feerate)=0
For each outpoint, calculate the fee-bumping cost to spend this outpoint at the specified.
virtual node::NodeContext * context()
Get internal node context.
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 uint256 getBlockHash(int height)=0
Get block hash. Height must be valid or this function will abort.
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 util::Result< void > checkChainLimits(const CTransactionRef &tx)=0
Check if transaction will pass the mempool's chain limits.
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.
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 bool hasBlockFilterIndex(BlockFilterType filter_type)=0
Returns whether a block filter index is available.
virtual common::SettingsValue getRwSetting(const std::string &name)=0
Return <datadir>/settings.json setting value.
virtual std::optional< int > getHeight()=0
Get current chain height, not including genesis block (returns 0 if chain only contains genesis block...
virtual std::optional< bool > blockFilterMatchesAny(BlockFilterType filter_type, const uint256 &block_hash, const GCSFilter::ElementSet &filter_set)=0
Returns whether any of the elements match the block via a BIP 157 block filter or std::nullopt if the...
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 common::SettingsValue getSetting(const std::string &arg)=0
Get settings value.
virtual bool isReadyToBroadcast()=0
Check if the node is ready to broadcast transactions.
virtual bool hasAssumedValidChain()=0
Return true if an assumed-valid chain is in use.
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.
virtual bool findBlock(const uint256 &hash, const FoundBlock &block={})=0
Return whether node has the block and optionally return block metadata or contents.
virtual double guessVerificationProgress(const uint256 &block_hash)=0
Estimate fraction of total transactions verified if blocks up to the specified block hash are verifie...
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 void waitForNotificationsIfTipChanged(const uint256 &old_tip)=0
Wait for pending notifications to be processed unless block hash points to the current chain tip.
virtual CFeeRate mempoolMinFee()=0
Mempool minimum fee.
virtual void initMessage(const std::string &message)=0
Send init message.
virtual bool isInMempool(const uint256 &txid)=0
Check if transaction is in mempool.
virtual unsigned int estimateMaxBlocks()=0
Fee estimator max target.
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 void getPackageLimits(unsigned int &limit_ancestor_count, unsigned int &limit_descendant_count)=0
Get the node's package limits.
virtual bool updateRwSetting(const std::string &name, const common::SettingsValue &value, bool write=true)=0
Write a setting to <datadir>/settings.json.
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 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 initWarning(const bilingual_str &message)=0
Send init warning.
virtual CFeeRate estimateSmartFee(int num_blocks, bool conservative, FeeCalculation *calc=nullptr)=0
Estimate smart fee.
virtual CFeeRate relayMinFee()=0
Relay current minimum fee (from -minrelaytxfee and -incrementalrelayfee settings).
virtual std::vector< common::SettingsValue > getSettingsList(const std::string &arg)=0
Get list of settings values.
virtual CFeeRate relayIncrementalFee()=0
Relay incremental fee setting (-incrementalrelayfee), reflecting cost of relay.
External signer interface used by the GUI.
Helper for findBlock to selectively return pieces of block data.
const FoundBlock * m_next_block
CBlockLocator * m_locator
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,...
static transaction_identifier FromUint256(const uint256 &id)
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
static CService ip(uint32_t i)
void InitLogging(const ArgsManager &args)
Initialize global loggers.
bool AppInitLockDataDirectory()
Lock bitcoin core data directory.
bool AppInitBasicSetup(const ArgsManager &args, std::atomic< int > &exit_status)
Initialize bitcoin core: Basic context setup.
bool ShutdownRequested(node::NodeContext &node)
Return whether node shutdown was requested.
bool AppInitParameterInteraction(const ArgsManager &args)
Initialization: parameter interaction.
bool AppInitInterfaces(NodeContext &node)
Initialize node and wallet interface pointers.
void InitParameterInteraction(ArgsManager &args)
Parameter interaction: change current parameters depending on various rules.
bool AppInitMain(NodeContext &node, interfaces::BlockAndHeaderTipInfo *tip_info)
Bitcoin core main initialization.
bool AppInitSanityChecks(const kernel::Context &kernel)
Initialization sanity checks.
CClientUIInterface uiInterface
void InitWarning(const bilingual_str &str)
Show warning message.
bool InitError(const bilingual_str &str)
Show error message.
ChainstateRole
This enum describes the various roles a specific Chainstate instance can take.
BCLog::Logger & LogInstance()
void StartMapPort(bool use_upnp, bool use_natpmp)
MemPoolRemovalReason
Reason why a transaction was removed from the mempool, this is passed to the notification signal.
auto FindKey(Map &&map, Key &&key) -> decltype(&map.at(key))
Map lookup helper.
std::unique_ptr< Node > MakeNode(node::NodeContext &context)
Return implementation of Node interface.
std::unique_ptr< Handler > MakeSignalHandler(boost::signals2::connection connection)
Return handler wrapping a boost signal connection.
std::unique_ptr< Chain > MakeChain(node::NodeContext &node)
Return implementation of Chain interface.
interfaces::BlockInfo MakeBlockInfo(const CBlockIndex *index, const CBlock *data)
Return data from block index.
void FindCoins(const NodeContext &node, std::map< COutPoint, Coin > &coins)
Look up unspent output information.
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.
std::map< CSubNet, CBanEntry > banmap_t
bool GetProxy(enum Network net, Proxy &proxyInfoOut)
ValidationSignals & m_signals
::ExternalSigner m_signer
std::shared_ptr< Chain::Notifications > m_notifications
const CRPCCommand * m_wrapped_command
std::shared_ptr< NotificationsProxy > m_proxy
RBFTransactionState IsRBFOptInEmptyMempool(const CTransaction &tx)
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...
RBFTransactionState
The rbf state of unconfirmed transactions.
static constexpr unsigned int DEFAULT_INCREMENTAL_RELAY_FEE
Default for -incrementalrelayfee, which sets the minimum feerate increase for mempool limiting or rep...
static constexpr unsigned int DUST_RELAY_TX_FEE
Min feerate for defining dust.
static constexpr unsigned int DEFAULT_MIN_RELAY_TX_FEE
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 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.
Describes a place in the block chain to another node such that if the other node doesn't have the sam...
const CTransactionRef m_tx
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.
Block and header tip information.
Block tip (could be a header or not, depends on the subscribed signal).
Options struct containing limit options for a CTxMemPool.
NodeContext struct containing references to chain state and connection state.
std::unique_ptr< ChainstateManager > chainman
#define WAIT_LOCK(cs, name)
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
#define TRY_LOCK(cs, name)
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.
bilingual_str GetWarnings(bool verbose)
Format a string that describes several potential problems detected by the core.