Full‐node components that run the block, chainstate, and mempool machinery.
Types
Name |
Description |
Generate a new block, without valid proof‐of‐work |
|
Options controlling which checks a block‐template validity check performs. |
|
Block template creation options. These override node defaults, but can't exceed node limits (e.g. block_reserved_weight can't exceed max block weight). |
|
Maintains a tree of blocks (stored in |
|
Options controlling how long a block‐template wait call blocks and when it returns. |
|
Tracks the current block file and how far its undo data has been written. |
|
Orders block indices purely by height, without tie‐breaking. |
|
Orders block indices by most accumulated work, for choosing the best tip. |
|
A candidate block together with the per‐transaction data needed to finalize it. |
|
Cache sizes split between the optional indexes and the kernel (validation) caches. |
|
Options controlling how the chainstate is loaded and verified. |
|
Template containing all coinbase transaction fields that are set by our miner code. Clients are expected to add their own outputs and typically also expand the scriptSig. |
|
Options controlling how a persisted mempool file is imported. |
|
Cache sizes allotted to each optional block‐chain index. |
|
Comparator ordering map iterators by their key, for use in ordered sets of iterators. |
|
Kernel notification handler that tracks chain state for code above the validation layer. |
|
State tracked by the KernelNotifications interface meant to be used by mining code, index code, RPCs, and other code sitting above the validation layer. |
|
A minimal version of BlockAssembler, using the same ancestor set scoring algorithm. Allows us to run this algorithm on a limited set of transactions (e.g. subset of mempool or transactions that are not yet in mempool) instead of the entire mempool, ignoring consensus rules. Callers may use this to: ‐ Calculate the "bump fee" needed to spend an unconfirmed UTXO at a given feerate ‐ "Linearize" a list of transactions to see the order in which they would be selected for inclusion in a block |
|
Container for tracking updates to ancestor feerate as we include ancestors in the "block". |
|
NodeContext struct containing references to chain state and connection state. |
|
Holds the results of AnalyzePSBT (miscellaneous information about a PSBT) |
|
Holds an analysis of one input from a PSBT |
|
A parent/child transaction package queued for joint mempool validation. |
|
Records the oldest block an external component still needs, to guard it from pruning. |
|
Follow‐up actions returned after a transaction is rejected from the mempool. |
|
Metadata describing a serialized UTXO snapshot file. |
|
Per‐peer connection attributes that affect transaction download scheduling. |
|
Class responsible for deciding what transactions to request and, once downloaded, whether and how to validate them. It is also responsible for deciding what transaction packages to validate and how to resolve orphan transactions. Its data structures include TxRequestTracker for scheduling requests, rolling bloom filters for remembering transactions that have already been {accepted, rejected, confirmed}, an orphanage, and a registry of each peer's transaction relay‐related information. |
|
Private implementation of TxDownloadManager. |
|
Options used to construct a TxDownloadManager. |
|
A class to track orphan transactions (failed on TX_MISSING_INPUTS) Since we cannot distinguish orphans from bad transactions with non‐existent inputs, we heavily limit the amount of announcements (unique (NodeId, wtxid) pairs), the number of inputs, and size of the orphans stored (both individual and summed). We also try to prevent adversaries from churning this data structure: once global limits are reached, we continuously evict the oldest announcement (sorting non‐reconsiderable orphans before reconsiderable ones) from the most resource‐intensive peer until we are back within limits. ‐ Peers can exceed their individual limits (e.g. because they are very useful transaction relay peers) as long as the global limits are not exceeded. ‐ As long as the orphan has 1 announcer, it remains in the orphanage. ‐ No peer can trigger the eviction of another peer's orphans. ‐ Peers' orphans are effectively protected from eviction as long as they don't exceed their limits. Not thread‐safe. Requires external synchronization. |
|
Manages warning messages within a node. |
Type Aliases
Name |
Description |
Map from block hash to its in‐memory block index entry. |
|
Chainstate load status code and optional error string. |
Enums
Name |
Description |
Which kind of chainstate a block file belongs to, used to segment storage. |
|
Chainstate load status. Simple applications can just check for the success case, and treat other cases as errors. More complex applications may want to try reindexing in the generic failure case, and pass an interrupt callback and exit cleanly in the interrupted case. |
|
Reason a raw block read from disk failed. |
|
Result of attempting to submit or broadcast a transaction. |
|
How to broadcast a local transaction. Used to influence |
|
Categories of node‐level warning shown to the user and over RPC. |
Functions
Name |
Description |
Abort the node in response to a fatal, unrecoverable internal error. |
|
Insert the coinbase transaction and compute the merkle root of a block. |
|
Provides helpful miscellaneous information about where a PSBT is in the signing workflow. |
|
|
|
Submit a transaction to the mempool and (optionally) relay it to all P2P peers. |
|
Split the configured total database cache across the indexes and kernel caches. |
|
Check option values for validity. Returns an error for invalid values. |
|
Wait while the best known header extends the current chain tip AND at least one block is being added to the tip every 3 seconds. If the tip is sufficiently far behind, allow up to 20 seconds for the next tip update. |
|
Dump the mempool to a file. |
|
Return a path to the snapshot‐based chainstate dir, if one exists. |
|
Look up unspent output information. Returns coins in the mempool and in the current chain UTXO set. Iterates through all the keys in the map and populates the values. |
|
Replace null optional values with their hardcoded defaults. |
|
Return the default total database cache size in bytes. |
|
Get the minimum time a miner should use in the next block. This always accounts for the BIP94 timewarp rule, so does not necessarily reflect the consensus limit. |
|
Return the hash and height of the active chain tip. |
|
Return transaction with a given hash. If mempool is provided and block_index is not provided, check it first for the tx. If ‐txindex is available, check it next for the tx. Finally, if block_index is provided, check for tx by reading entire block from disk. |
|
RPC helper function that wraps warnings.GetMessages(). |
|
Load blocks from the given files and activate the best chain, even if none are imported. |
|
Interrupt a blocking wait call. |
|
This sequence can have 4 types of outcomes: |
|
Import the file and attempt to add its contents to the mempool. |
|
Log a warning when the configured database cache is larger than available RAM allows. |
|
Wrapper around Minisketch::Minisketch(32, implementation, capacity). |
|
Wrapper around Minisketch::CreateFP. |
|
|
|
Return the on‐disk path used to load and save the persisted mempool. |
|
Merge two BlockCreateOptions structs, replacing null values in |
|
Read coins‐view database options from the argument manager. |
|
Read database options from the argument manager. |
|
Read the mining options set in |
|
Apply notification‐related options from the argument manager. |
|
Read the blockhash of the snapshot base block that was used to construct the chainstate. |
|
Update an old GenerateCoinbaseCommitment from CreateNewBlock after the block txs have changed |
|
Determine whether the mempool should be persisted across restarts. |
|
Report whether the configured database cache is large enough to warrant a warning. |
|
Submit a block and capture the validation state via the BlockChecked callback. Returns whether the block was accepted as a new valid block. |
|
Update a block header's time field and return the new time. |
|
Verify a chainstate that has already been loaded. |
|
Return a new block template when fees rise to a certain threshold or after a new tip; return nullopt if timeout is reached. |
|
Waits for the connected tip to change until timeout has elapsed. During node initialization, this will wait until the tip is connected (regardless of |
|
Write out the blockhash of the snapshot base block that was used to construct this chainstate. This value is read in during subsequent initializations and used to reconstruct snapshot‐based chainstates. |
|
Stream insertion operators |
Variables
Name |
Description |
The pre‐allocation chunk size for blk?????.dat files (since 0.8) |
|
Maximum burn value for sendrawtransaction, submitpackage, and testmempoolaccept RPC calls. By default, a transaction with a burn value higher than this will be rejected by these RPCs and the GUI. This can be overridden with the maxburnamount argument. |
|
Default value for TxOrphanage::m_max_global_latency_score. Helps limit the maximum latency for operations like EraseForBlock and LimitOrphans. |
|
Maximum fee rate for sendrawtransaction and testmempoolaccept RPC calls. Also used by the GUI when broadcasting a completed PSBT. By default, a transaction with a fee rate higher than this will be rejected by these RPCs and the GUI. This can be overridden with the maxfeerate argument. |
|
Default for ‐persistmempool, indicating whether the node should attempt to automatically load the mempool on start and save to disk on shutdown |
|
Default for whether block templates print each transaction's modified fee. |
|
Default value for TxOrphanage::m_reserved_usage_per_peer. Helps limit the total amount of memory used by the orphanage. |
|
Default for |
|
How long to wait before downloading a transaction from an additional peer |
|
The maximum size of a blk?????.dat file (since 0.8) |
|
Maximum number of transactions to consider for requesting, per peer. It provides a reasonable DoS limit to per‐peer memory usage spent on announcements, while covering peers continuously sending INVs at the maximum rate (by our own policy, see DEFAULT_TX_SEND_RATE) for several minutes, while not receiving the actual transaction (from any peer) in response to requests for them. |
|
Maximum number of in‐flight transaction requests from a peer. It is not a hard limit, but the threshold at which point the OVERLOADED_PEER_TX_DELAY kicks in. |
|
How long to delay requesting transactions from non‐preferred peers |
|
How long to delay requesting transactions from overloaded peers (see MAX_PEER_TX_REQUEST_IN_FLIGHT). |
|
The file in the snapshot chainstate dir which stores the base blockhash. This is needed to reconstruct snapshot chainstates on init. |
|
Suffix appended to the chainstate (leveldb) dir when created based upon a snapshot. |
|
Size of header written by WriteBlock before a serialized CBlock (8 bytes) |
|
How long to delay requesting transactions via txids, if we have wtxid‐relaying peers |
|
The pre‐allocation chunk size for rev?????.dat files (since 0.8) |
|
Total overhead when writing undo data: header (8 bytes) plus checksum (32 bytes) |
Using Declarations
Name |
Description |
Bring the kernel block‐tree database type into the node namespace. |
|
Bring the kernel block‐file info type into the node namespace. |
Created with MrDocs