[#index]
= Global namespace
:mrdocs:

== Namespaces

[cols="1,4"]
|===
| Name| Description
| xref:BCLog.adoc[`BCLog`] 
| Bitcoin Core logging facilities&colon; log categories and their bit flags&period;
| xref:Consensus.adoc[`Consensus`] 
| Transaction validation functions
| xref:CuckooCache.adoc[`CuckooCache`] 
| High&hyphen;performance cache primitives&period;
| xref:NetMsg.adoc[`NetMsg`] 
| Helpers for constructing serialized network messages&period;
| xref:NetMsgFeature.adoc[`NetMsgFeature`] 
| Identifiers for individual peer&hyphen;negotiated features (BIP 434)&period;
| xref:NetMsgType.adoc[`NetMsgType`] 
| Bitcoin protocol message types&period; When adding new message types, don&apos;t forget to update ALL&lowbar;NET&lowbar;MESSAGE&lowbar;TYPES below&period;
| xref:bech32.adoc[`bech32`] 
| Bech32 and Bech32m string encoding used by newer Bitcoin address types&period;
| xref:bitcoin_http.adoc[`bitcoin&lowbar;http`] 
| Constants and error types for the built&hyphen;in HTTP server&apos;s request parsing&period;
| xref:bitset_detail.adoc[`bitset&lowbar;detail`] 
| Implementation details backing the BitSet alias&period;
| xref:btck.adoc[`btck`] 
| Type&hyphen;safe C&plus;&plus; RAII wrapper over the libbitcoinkernel C API&period;
| xref:btcsignals.adoc[`btcsignals`] 
| btcsignals is a simple mechanism for signaling events to multiple subscribers&period; It is api&hyphen;compatible with a minimal subset of boost&colon;&colon;signals2&period;
| xref:cluster_linearize.adoc[`cluster&lowbar;linearize`] 
| Algorithms and data structures for ordering (linearizing) clusters of dependent transactions&period;
| xref:common.adoc[`common`] 
| Shared types used across the node, wallet, and GUI code&period;
| xref:dbwrapper_private.adoc[`dbwrapper&lowbar;private`] 
| These should be considered an implementation detail of the specific database&period;
| xref:detail.adoc[`detail`] 
| Internal helpers for parsing blobs from hex strings&period;
| xref:fs.adoc[`fs`] 
| Filesystem operations and types
| xref:fsbridge.adoc[`fsbridge`] 
| Bridge operations to C stdio
| xref:i2p.adoc[`i2p`] 
| Support for connecting to and accepting connections over the I2P network&period;
| xref:index_util.adoc[`index&lowbar;util`] 
| Shared database key types for blockfilterindex and coinstatsindex&period;
| xref:init.adoc[`init`] 
| Initialization helpers shared by the node, wallet, and other executables&period;
| xref:interfaces.adoc[`interfaces`] 
| Interfaces between the node and the rest of the application&period;
| xref:kernel.adoc[`kernel`] 
| Kernel library components for validating blocks and maintaining chain state&period;
| xref:leveldb.adoc[`leveldb`] 
| The LevelDB library namespace, forward&hyphen;declared to avoid a public dependency&period;
| xref:memusage.adoc[`memusage`] 
| Helpers for estimating the dynamic memory usage of common data structures&period;
| xref:miniscript.adoc[`miniscript`] 
| Miniscript&colon; a structured representation of Bitcoin Scripts&period;
| xref:node.adoc[`node`] 
| Full&hyphen;node components that run the block, chainstate, and mempool machinery&period;
| xref:poly1305_donna.adoc[`poly1305&lowbar;donna`] 
| Low&hyphen;level Poly1305 routines based on the public domain poly1305&hyphen;donna implementation by Andrew Moon (poly1305&hyphen;donna&hyphen;32&period;h)&period;
| xref:script.adoc[`script`] 
| Helpers for parsing output descriptor strings&period;
| xref:sha256_implementation.adoc[`sha256&lowbar;implementation`] 
| Runtime selection of the SHA&hyphen;256 implementation&period;
| xref:std.adoc[`std`] 
| Standard library namespace, extended here with a deleted hash specialization&period;
| xref:subprocess.adoc[`subprocess`] 
| Getting started with reading this source code&period; The source is mainly divided into four parts&colon; 1&period; Exception Classes&colon; These are very basic exception classes derived from runtime&lowbar;error exception&period; There are two types of exception thrown from subprocess library&colon; OSError and CalledProcessError
| xref:tinyformat.adoc[`tinyformat`] 
| Tiny type&hyphen;safe printf&hyphen;style string formatting library&period;
| xref:txindex-02.adoc[`txindex`] 
| Database key types and constants for the transaction index&period;
| xref:txindex_tests.adoc[`txindex&lowbar;tests`] 
| Unit&hyphen;test helpers that reach into TxIndex internals&period;
| xref:util.adoc[`util`] 
| Bitcoin Core utility helpers shared across the codebase&period;
| xref:wallet.adoc[`wallet`] 
| Wallet subsystem&period;
|===


== Namespace Aliases

[cols="1,4"]
|===
| Name| Description
| xref:tfm.adoc[`tfm`] 
| Short namespace alias for tinyformat&period;
|===


== Types

[cols="1,4"]
|===
| Name| Description
| xref:AEADChaCha20Poly1305.adoc[`AEADChaCha20Poly1305`] 
| The AEAD&lowbar;CHACHA20&lowbar;POLY1305 authenticated encryption algorithm from RFC8439 section 2&period;8&period;
| xref:AES256CBCDecrypt.adoc[`AES256CBCDecrypt`] 
| A decryption class for AES&hyphen;256 in CBC mode with optional PKCS&num;7 padding&period;
| xref:AES256CBCEncrypt.adoc[`AES256CBCEncrypt`] 
| An encryption class for AES&hyphen;256 in CBC mode with optional PKCS&num;7 padding&period;
| xref:AES256Decrypt.adoc[`AES256Decrypt`] 
| A decryption class for AES&hyphen;256&period;
| xref:AES256Encrypt.adoc[`AES256Encrypt`] 
| An encryption class for AES&hyphen;256&period;
| xref:AbstractThresholdConditionChecker.adoc[`AbstractThresholdConditionChecker`] 
| Abstract class that implements BIP9&hyphen;style threshold logic, and caches results&period;
| xref:ActionSerialize.adoc[`ActionSerialize`] 
| Support for all macros providing or using the ser&lowbar;action parameter of the SerializationOps method&period;
| xref:ActionUnserialize.adoc[`ActionUnserialize`] 
| Action that drives the SerializationOps method to unserialize (read) objects&period;
| xref:AddedNodeInfo.adoc[`AddedNodeInfo`] 
| Connection status of a manually added node&period;
| xref:AddedNodeParams.adoc[`AddedNodeParams`] 
| Parameters describing a manually added node (&hyphen;addnode &sol; &hyphen;connect)&period;
| xref:AddrInfo.adoc[`AddrInfo`] 
| Internal per&hyphen;address record stored in the address manager tables&period;
| xref:AddrMan.adoc[`AddrMan`] 
| Stochastic address manager
| xref:AddrManImpl.adoc[`AddrManImpl`] 
| Private implementation of the address manager (pimpl)&period;
| xref:AddressPosition.adoc[`AddressPosition`] 
| Location information for an address in AddrMan
| xref:AmountCompression.adoc[`AmountCompression`] 
| Serialization wrapper that stores amounts using the compact amount encoding&period;
| xref:AnnotatedMixin-03.adoc[`AnnotatedMixin`] 
| Template mixin that adds &hyphen;Wthread&hyphen;safety locking annotations and lock order checking to a subset of the mutex API&period;
| xref:Arena.adoc[`Arena`] 
| An arena manages a contiguous region of memory by dividing it into chunks&period;
| xref:ArgsManager.adoc[`ArgsManager`] 
| Parses and stores command&hyphen;line and configuration file arguments&period;
| xref:AssumeutxoData.adoc[`AssumeutxoData`] 
| Holds configuration for use during UTXO snapshot load and validation&period; The contents here are security critical, since they dictate which UTXO snapshots are recognized as valid&period;
| xref:AssumeutxoHash.adoc[`AssumeutxoHash`] 
| Strongly typed hash of a serialized UTXO snapshot&period;
| xref:AutoFile.adoc[`AutoFile`] 
| Non&hyphen;refcounted RAII wrapper for FILE&ast;
| xref:BIP324Cipher.adoc[`BIP324Cipher`] 
| The BIP324 packet cipher, encapsulating its key derivation, stream cipher, and AEAD&period;
| xref:BIP9GBTStatus.adoc[`BIP9GBTStatus`] 
| getblocktemplate status for the BIP9 deployments grouped by signalling state&period;
| xref:BIP9Info.adoc[`BIP9Info`] 
| Detailed status of an enabled BIP9 deployment
| xref:BIP9Stats.adoc[`BIP9Stats`] 
| Display status of an in&hyphen;progress BIP9 softfork
| xref:BanMan.adoc[`BanMan`] 
| Tracks banned and discouraged peers&period;
| xref:BaseHash-03.adoc[`BaseHash`] 
| Wraps a fixed&hyphen;size hash value and exposes byte&hyphen;range access to it&period;
| xref:BaseIndex.adoc[`BaseIndex`] 
| Base class for the node&apos;s optional block&hyphen;chain indexes&period;
| xref:BaseSignatureChecker.adoc[`BaseSignatureChecker`] 
| Interface for verifying signatures and time locks encountered during script evaluation&period;
| xref:BaseSignatureCreator.adoc[`BaseSignatureCreator`] 
| Interface for signature creators&period;
| xref:BitStreamReader.adoc[`BitStreamReader`] 
| Reads individual bits, most significant first, from an underlying byte stream&period;
| xref:BitStreamWriter.adoc[`BitStreamWriter`] 
| Writes individual bits, most significant first, into an underlying byte stream&period;
| xref:BlockFilter.adoc[`BlockFilter`] 
| Complete block filter struct as defined in BIP 157&period; Serialization matches payload of &quot;cfilter&quot; messages&period;
| xref:BlockFilterIndex.adoc[`BlockFilterIndex`] 
| BlockFilterIndex is used to store and retrieve block filters, hashes, and headers for a range of blocks by height&period; An index is constructed for each supported filter type with its own database (ie&period; filter data for different types are stored in separate databases)&period;
| xref:BlockHasher.adoc[`BlockHasher`] 
| Hashes a block hash by reading its low 64 bits directly, with no salt&period;
| xref:BlockTransactions.adoc[`BlockTransactions`] 
| A blocktxn message carrying the transactions requested for a block&period;
| xref:BlockTransactionsRequest.adoc[`BlockTransactionsRequest`] 
| A getblocktxn message requesting specific transactions of a block by index&period;
| xref:BlockValidationState.adoc[`BlockValidationState`] 
| Validation state specialized for block&hyphen;level results&period;
| xref:BufferedFile.adoc[`BufferedFile`] 
| Wrapper around an AutoFile&amp; that implements a ring buffer to deserialize from&period; It guarantees the ability to rewind a given number of bytes&period;
| xref:BufferedReader.adoc[`BufferedReader`] 
| Wrapper that buffers reads from an underlying stream&period; Requires underlying stream to support read() and detail&lowbar;fread() calls to support fixed&hyphen;size and variable&hyphen;sized reads, respectively&period;
| xref:BufferedWriter.adoc[`BufferedWriter`] 
| Wrapper that buffers writes to an underlying stream&period; Requires underlying stream to support write&lowbar;buffer() method for efficient buffer flushing and obfuscation&period;
| xref:ByRatio.adoc[`ByRatio`] 
| Wrapper around FeeFrac &amp; derived types, which adds a feerate&hyphen;based ordering which treats equal&hyphen;feerate but distinct&hyphen;size FeeFracs as equals&period;
| xref:ByRatioNegSize.adoc[`ByRatioNegSize`] 
| Wrapper around FeeFrac &amp; derived types, which adds a total ordering which first sorts by feerate and then by reversed size (i&period;e&period;, larger sizes come first)&period;
| xref:ByteVectorHash.adoc[`ByteVectorHash`] 
| Implementation of Hash named requirement for types that internally store a byte array&period; This may be used as the hash function in std&colon;&colon;unordered&lowbar;set or std&colon;&colon;unordered&lowbar;map over such types&period; Internally, this uses a random instance of SipHash&hyphen;2&hyphen;4&period;
| xref:CAddress.adoc[`CAddress`] 
| A CService with information about it as peer
| xref:CBanDB.adoc[`CBanDB`] 
| Access to the banlist database (banlist&period;json)
| xref:CBanEntry.adoc[`CBanEntry`] 
| Record of a single ban, storing when it was created and when it expires&period;
| xref:CBaseChainParams.adoc[`CBaseChainParams`] 
| CBaseChainParams defines the base parameters (shared between bitcoin&hyphen;cli and bitcoind) of a given instance of the Bitcoin system&period;
| xref:CBlock.adoc[`CBlock`] 
| A full block, extending the header with its transactions and cached check flags&period;
| xref:CBlockHeader.adoc[`CBlockHeader`] 
| Nodes collect new transactions into a block, hash them into a hash tree, and scan through nonce values to make the block&apos;s hash satisfy proof&hyphen;of&hyphen;work requirements&period; When they solve the proof&hyphen;of&hyphen;work, they broadcast the block to everyone and the block is added to the block chain&period; The first transaction in the block is a special one that creates a new coin owned by the creator of the block&period;
| xref:CBlockHeaderAndShortTxIDs.adoc[`CBlockHeaderAndShortTxIDs`] 
| A cmpctblock message&colon; a block header with short transaction IDs for compact relay&period;
| xref:CBlockIndex.adoc[`CBlockIndex`] 
| The block chain is a tree shaped structure starting with the genesis block at the root, with each block potentially having multiple candidates to be the next block&period; A blockindex may have multiple pprev pointing to it, but at most one of them can be part of the currently active branch&period;
| xref:CBlockLocator.adoc[`CBlockLocator`] 
| Describes a place in the block chain to another node such that if the other node doesn&apos;t have the same branch, it can find a recent common trunk&period; The further back it is, the further before the fork it may be&period;
| xref:CBlockPolicyEstimator.adoc[`CBlockPolicyEstimator`] 
| The BlockPolicyEstimator is used for estimating the feerate needed for a transaction to be included in a block within a certain number of blocks&period;
| xref:CBlockUndo.adoc[`CBlockUndo`] 
| Undo information for a CBlock
| xref:CBloomFilter.adoc[`CBloomFilter`] 
| BloomFilter is a probabilistic filter which SPV clients provide so that we can filter the transactions we send them&period;
| xref:CChain.adoc[`CChain`] 
| An in&hyphen;memory indexed chain of blocks&period;
| xref:CChainParams.adoc[`CChainParams`] 
| Chain parameters describing a particular Bitcoin network&period;
| xref:CCheckQueue.adoc[`CCheckQueue`] 
| Queue for verifications that have to be performed&period; The verifications are represented by a type T, which must provide an operator(), returning an std&colon;&colon;optional&lt;R&gt;&period;
| xref:CCheckQueueControl.adoc[`CCheckQueueControl`] 
| RAII&hyphen;style controller object for a CCheckQueue that guarantees the passed queue is finished before continuing&period;
| xref:CClientUIInterface.adoc[`CClientUIInterface`] 
| Interface used to notify the UI about node events&period;
| xref:CCoinsCacheEntry.adoc[`CCoinsCacheEntry`] 
| A Coin in one level of the coins database caching hierarchy&period;
| xref:CCoinsView.adoc[`CCoinsView`] 
| Pure abstract view on the open txout dataset&period;
| xref:CCoinsViewBacked.adoc[`CCoinsViewBacked`] 
| CCoinsView backed by another CCoinsView
| xref:CCoinsViewCache.adoc[`CCoinsViewCache`] 
| CCoinsView that adds a memory cache for transactions to another CCoinsView
| xref:CCoinsViewCursor.adoc[`CCoinsViewCursor`] 
| Cursor for iterating over CoinsView state
| xref:CCoinsViewDB.adoc[`CCoinsViewDB`] 
| CCoinsView backed by the coin database (chainstate&sol;)
| xref:CCoinsViewErrorCatcher.adoc[`CCoinsViewErrorCatcher`] 
| This is a minimally invasive approach to shutdown on LevelDB read errors from the chainstate, while keeping user interface out of the common library, which is shared between bitcoind, and bitcoin&hyphen;qt and non&hyphen;server tools&period;
| xref:CCoinsViewMemPool.adoc[`CCoinsViewMemPool`] 
| CCoinsView that brings transactions from a mempool into view&period; It does not check for spendings by memory pool transactions&period; Instead, it provides access to all Coins which are either unspent in the base CCoinsView, are outputs from any mempool transaction, or are tracked temporarily to allow transaction dependencies in package validation&period; This allows transaction replacement to work as expected, as you want to have all inputs &quot;available&quot; to check signatures, and any cycles in the dependency graph are checked directly in AcceptToMemoryPool&period; It also allows you to sign a double&hyphen;spend directly in signrawtransactionwithkey and signrawtransactionwithwallet, as long as the conflicting transaction is not yet confirmed&period;
| xref:CConnman.adoc[`CConnman`] 
| Manages all P2P connections&colon; opening, accepting, servicing and tearing them down&period;
| xref:CDBBatch.adoc[`CDBBatch`] 
| Batch of changes queued to be written to a CDBWrapper
| xref:CDBIterator.adoc[`CDBIterator`] 
| Iterates over the key&hyphen;value entries of a CDBWrapper&period;
| xref:CDBWrapper.adoc[`CDBWrapper`] 
| Wraps a LevelDB database, providing typed, serialized key&hyphen;value access&period;
| xref:CDiskBlockIndex.adoc[`CDiskBlockIndex`] 
| Used to marshal pointers into hashes for db storage&period;
| xref:CDiskTxPos.adoc[`CDiskTxPos`] 
| On&hyphen;disk position of a transaction&colon; a block file position plus an offset within the block&period;
| xref:CExtKey.adoc[`CExtKey`] 
| A BIP32 extended private key&colon; a private key plus the chain code and metadata needed for derivation&period;
| xref:CExtPubKey.adoc[`CExtPubKey`] 
| A BIP32 extended public key&colon; a public key plus the chain code and metadata needed for derivation&period;
| xref:CFeeRate.adoc[`CFeeRate`] 
| Fee rate in satoshis per virtualbyte&colon; CAmount &sol; vB the feerate is represented internally as FeeFrac
| xref:CHKDF_HMAC_SHA256_L32.adoc[`CHKDF&lowbar;HMAC&lowbar;SHA256&lowbar;L32`] 
| A rfc5869 HKDF implementation with HMAC&lowbar;SHA256 and fixed key output length of 32 bytes (L&equals;32)
| xref:CHMAC_SHA256.adoc[`CHMAC&lowbar;SHA256`] 
| A hasher class for HMAC&hyphen;SHA&hyphen;256&period;
| xref:CHMAC_SHA512.adoc[`CHMAC&lowbar;SHA512`] 
| A hasher class for HMAC&hyphen;SHA&hyphen;512&period;
| xref:CHash160.adoc[`CHash160`] 
| A hasher class for Bitcoin&apos;s 160&hyphen;bit hash (SHA&hyphen;256 &plus; RIPEMD&hyphen;160)&period;
| xref:CHash256.adoc[`CHash256`] 
| A hasher class for Bitcoin&apos;s 256&hyphen;bit hash (double SHA&hyphen;256)&period;
| xref:CInv.adoc[`CInv`] 
| inv message data
| xref:CKey.adoc[`CKey`] 
| An encapsulated private key&period;
| xref:CKeyID.adoc[`CKeyID`] 
| A reference to a CKey&colon; the Hash160 of its serialized public key
| xref:CMerkleBlock.adoc[`CMerkleBlock`] 
| Used to relay blocks as header &plus; vector&lt;merkle branch&gt; to filtered nodes&period;
| xref:CMessageHeader.adoc[`CMessageHeader`] 
| Message header&period; (4) message start&period; (12) message type&period; (4) size&period; (4) checksum&period;
| xref:CMutableTransaction.adoc[`CMutableTransaction`] 
| A mutable version of CTransaction&period;
| xref:CNetAddr.adoc[`CNetAddr`] 
| Network address&period;
| xref:CNetMessage.adoc[`CNetMessage`] 
| Transport protocol agnostic message container&period; Ideally it should only contain receive time, payload, type and size&period;
| xref:CNoDestination.adoc[`CNoDestination`] 
| A destination that has no associated address, optionally wrapping a script&period;
| xref:CNode.adoc[`CNode`] 
| Information about a peer
| xref:CNodeOptions.adoc[`CNodeOptions`] 
| Per&hyphen;connection options passed when constructing a CNode&period;
| xref:CNodeStateStats.adoc[`CNodeStateStats`] 
| Per&hyphen;peer state statistics reported for diagnostics (e&period;g&period; getpeerinfo)&period;
| xref:CNodeStats.adoc[`CNodeStats`] 
| Reported statistics about a single peer connection&period;
| xref:COutPoint.adoc[`COutPoint`] 
| An outpoint &hyphen; a combination of a transaction hash and an index n into its vout
| xref:CPartialMerkleTree.adoc[`CPartialMerkleTree`] 
| Data structure that represents a partial merkle tree&period;
| xref:CPubKey.adoc[`CPubKey`] 
| An encapsulated public key&period;
| xref:CRIPEMD160.adoc[`CRIPEMD160`] 
| A hasher class for RIPEMD&hyphen;160&period;
| xref:CRPCCommand.adoc[`CRPCCommand`] 
| A single registered RPC command together with its dispatch metadata&period;
| xref:CRPCTable.adoc[`CRPCTable`] 
| Registry of available RPC commands&period;
| xref:CRollingBloomFilter.adoc[`CRollingBloomFilter`] 
| RollingBloomFilter is a probabilistic &quot;keep track of most recently inserted&quot; set&period; Construct it with the number of items to keep track of, and a false&hyphen;positive rate&period; Unlike CBloomFilter, by default nTweak is set to a cryptographically secure random value for you&period; Similarly rather than clear() the method reset() is provided, which also changes nTweak to decrease the impact of false&hyphen;positives&period;
| xref:CSHA1.adoc[`CSHA1`] 
| A hasher class for SHA1&period;
| xref:CSHA256.adoc[`CSHA256`] 
| A hasher class for SHA&hyphen;256&period;
| xref:CSHA512.adoc[`CSHA512`] 
| A hasher class for SHA&hyphen;512&period;
| xref:CScheduler.adoc[`CScheduler`] 
| Schedules deferred and recurring background tasks&period;
| xref:CScript.adoc[`CScript`] 
| Serialized script, used inside transaction inputs and outputs
| xref:CScriptCheck.adoc[`CScriptCheck`] 
| Closure representing one script verification Note that this stores references to the spending transaction
| xref:CScriptID.adoc[`CScriptID`] 
| A reference to a CScript&colon; the Hash160 of its serialization
| xref:CScriptNum.adoc[`CScriptNum`] 
| Script integer with the overflow and encoding semantics of Bitcoin&apos;s numeric opcodes&period;
| xref:CScriptWitness.adoc[`CScriptWitness`] 
| Witness stack for a single transaction input&period;
| xref:CSerializedNetMsg.adoc[`CSerializedNetMsg`] 
| A fully serialized network message, ready to be handed to the transport&period;
| xref:CService.adoc[`CService`] 
| A combination of a network address (CNetAddr) and a (TCP) port
| xref:CServiceHash.adoc[`CServiceHash`] 
| Hasher for CService, suitable for use with unordered containers&period;
| xref:CSipHasher.adoc[`CSipHasher`] 
| General SipHash&hyphen;2&hyphen;4 implementation&period;
| xref:CSubNet.adoc[`CSubNet`] 
| A subnet&colon; a network base address together with a netmask&period;
| xref:CThreadInterrupt.adoc[`CThreadInterrupt`] 
| A helper class for interruptible sleeps&period; Calling operator() will interrupt any current sleep, and after that point operator bool() will return true until reset&period;
| xref:CTransaction.adoc[`CTransaction`] 
| The basic transaction that is broadcasted on the network and contained in blocks&period; A transaction can contain multiple inputs and outputs&period;
| xref:CTxIn.adoc[`CTxIn`] 
| An input of a transaction&period; It contains the location of the previous transaction&apos;s output that it claims and a signature that matches the output&apos;s public key&period;
| xref:CTxMemPool.adoc[`CTxMemPool`] 
| The node&apos;s memory pool of unconfirmed transactions&period;
| xref:CTxMemPoolEntry.adoc[`CTxMemPoolEntry`] 
| CTxMemPoolEntry stores data about the corresponding transaction, as well as data about all in&hyphen;mempool transactions that depend on the transaction (&quot;descendant&quot; transactions)&period;
| xref:CTxOut.adoc[`CTxOut`] 
| An output of a transaction&period; It contains the public key that the next input must be able to sign with to claim it&period;
| xref:CTxUndo.adoc[`CTxUndo`] 
| Undo information for a CTransaction
| xref:CValidationInterface.adoc[`CValidationInterface`] 
| Implement this to subscribe to events generated in validation and mempool
| xref:CVerifyDB.adoc[`CVerifyDB`] 
| RAII wrapper for VerifyDB&colon; Verify consistency of the block and coin databases
| xref:CZMQAbstractNotifier.adoc[`CZMQAbstractNotifier`] 
| Base class for ZMQ notifiers that publish node events to a subscriber&period;
| xref:CZMQAbstractPublishNotifier.adoc[`CZMQAbstractPublishNotifier`] 
| Base class for ZMQ publisher notifiers that send multipart messages to subscribers&period;
| xref:CZMQNotificationInterface.adoc[`CZMQNotificationInterface`] 
| Validation&hyphen;interface listener that fans node events out to the configured ZMQ notifiers&period;
| xref:CZMQPublishHashBlockNotifier.adoc[`CZMQPublishHashBlockNotifier`] 
| Publishes the hash of each new active chain tip block&period;
| xref:CZMQPublishHashTransactionNotifier.adoc[`CZMQPublishHashTransactionNotifier`] 
| Publishes the hash of each notified transaction&period;
| xref:CZMQPublishRawBlockNotifier.adoc[`CZMQPublishRawBlockNotifier`] 
| Publishes the serialized bytes of each new active chain tip block&period;
| xref:CZMQPublishRawTransactionNotifier.adoc[`CZMQPublishRawTransactionNotifier`] 
| Publishes the serialized bytes of each notified transaction&period;
| xref:CZMQPublishSequenceNotifier.adoc[`CZMQPublishSequenceNotifier`] 
| Publishes lightweight sequence messages for block and mempool events&period;
| xref:CachingTransactionSignatureChecker.adoc[`CachingTransactionSignatureChecker`] 
| Signature checker that consults and updates a SignatureCache to avoid repeat verification&period;
| xref:ChaCha20.adoc[`ChaCha20`] 
| Unrestricted ChaCha20 cipher&period;
| xref:ChaCha20Aligned.adoc[`ChaCha20Aligned`] 
| ChaCha20 cipher that only operates on multiples of 64 bytes&period;
| xref:ChainCode.adoc[`ChainCode`] 
| A BIP32 chain code&period; Cleansed on destruction&period;
| xref:ChainTxData.adoc[`ChainTxData`] 
| Holds various statistics on transactions within a chain&period; Used to estimate verification progress during chain sync&period;
| xref:Chainstate.adoc[`Chainstate`] 
| Chainstate stores and provides an API to update our local knowledge of the current best chain&period;
| xref:ChainstateManager.adoc[`ChainstateManager`] 
| Interface for managing multiple Chainstate objects, where each chainstate is associated with chainstate&ast; subdirectory in the data directory and contains a database of UTXOs existing at a different point in history&period; (See the Chainstate class for more information&period;)
| xref:CheckVarIntMode.adoc[`CheckVarIntMode`] 
| Compile&hyphen;time check that a VarInt mode and integer type are compatible&period;
| xref:ChronoFormatter.adoc[`ChronoFormatter`] 
| Formatter that serializes a time point as its underlying representation type U&period;
| xref:Coin-04.adoc[`Coin`] 
| A UTXO entry&period;
| xref:CoinStatsIndex.adoc[`CoinStatsIndex`] 
| CoinStatsIndex maintains statistics on the UTXO set&period;
| xref:CoinsViewCacheCursor.adoc[`CoinsViewCacheCursor`] 
| Cursor for iterating over the linked list of flagged entries in CCoinsViewCache&period;
| xref:CoinsViewEmpty.adoc[`CoinsViewEmpty`] 
| Noop coins view&period;
| xref:CoinsViewOptions.adoc[`CoinsViewOptions`] 
| Tunable options for the on&hyphen;disk coins (UTXO) view database&period;
| xref:CoinsViewOverlay.adoc[`CoinsViewOverlay`] 
| CCoinsViewCache subclass that asynchronously fetches most block input prevouts in parallel during ConnectBlock without mutating the base cache&period;
| xref:CoinsViews.adoc[`CoinsViews`] 
| A convenience class for constructing the CCoinsView&ast; hierarchy used to facilitate access to the UTXO set&period;
| xref:CompactSizeFormatter.adoc[`CompactSizeFormatter`] 
| Formatter for integers in CompactSize format&period;
| xref:CompactSizeReader.adoc[`CompactSizeReader`] 
| Reads a CompactSize value from a stream into a referenced integer&period;
| xref:CompactSizeWriter.adoc[`CompactSizeWriter`] 
| Writes a fixed integer value to a stream in CompactSize format&period;
| xref:CompareIteratorByHash.adoc[`CompareIteratorByHash`] 
| Orders mempool entry handles by the hash of their transaction&period;
| xref:CompareTxMemPoolEntryByEntryTime.adoc[`CompareTxMemPoolEntryByEntryTime`] 
| Orders mempool entries by the time they entered the mempool&period;
| xref:CompressedHeader.adoc[`CompressedHeader`] 
| A compressed CBlockHeader, which leaves out the prevhash&period;
| xref:ConnectedBlock.adoc[`ConnectedBlock`] 
| A block that has been connected to the active chain, tracked during chain activation&period;
| xref:ConnmanTestMsg.adoc[`ConnmanTestMsg`] 
| Test harness that exposes CConnman internals for unit tests&period;
| xref:CountingSemaphoreGrant.adoc[`CountingSemaphoreGrant`] 
| RAII&hyphen;style semaphore lock
| xref:CustomUintFormatter.adoc[`CustomUintFormatter`] 
| Serialization wrapper class for custom integers and enums&period;
| xref:DBOptions.adoc[`DBOptions`] 
| User&hyphen;controlled performance and debug options&period;
| xref:DBParams.adoc[`DBParams`] 
| Application&hyphen;specific storage settings&period;
| xref:DataStream.adoc[`DataStream`] 
| Double ended buffer combining vector and stream&hyphen;like interfaces&period;
| xref:DefaultFormatter.adoc[`DefaultFormatter`] 
| Default formatter&period; Serializes objects as themselves&period;
| xref:DeferringSignatureChecker.adoc[`DeferringSignatureChecker`] 
| Signature checker that forwards every check to a wrapped checker&period;
| xref:DereferencingComparator.adoc[`DereferencingComparator`] 
| Comparator that orders pointers by the values they point to&period;
| xref:Descriptor.adoc[`Descriptor`] 
| Interface for parsed descriptor objects&period;
| xref:DescriptorCache.adoc[`DescriptorCache`] 
| Cache for single descriptor&apos;s derived extended pubkeys
| xref:DifferenceFormatter.adoc[`DifferenceFormatter`] 
| Formatter that (de)serializes a monotonically increasing sequence as differences&period;
| xref:DisconnectedBlockTransactions.adoc[`DisconnectedBlockTransactions`] 
| Transactions removed from the chain during a reorg, held for possible re&hyphen;addition to the mempool&period;
| xref:ECC_Context.adoc[`ECC&lowbar;Context`] 
| RAII class initializing and deinitializing global state for elliptic curve support&period; Only one instance may be initialized at a time&period;
| xref:EllSwiftPubKey.adoc[`EllSwiftPubKey`] 
| An ElligatorSwift&hyphen;encoded public key&period;
| xref:EstimationResult.adoc[`EstimationResult`] 
| Used to return detailed information about a fee estimate calculation&period;
| xref:EstimatorBucket.adoc[`EstimatorBucket`] 
| Used to return detailed information about a feerate bucket&period;
| xref:ExternalSigner.adoc[`ExternalSigner`] 
| Enables interaction with an external signing device or service, such as a hardware wallet&period; See doc&sol;external&hyphen;signer&period;md
| xref:FSChaCha20.adoc[`FSChaCha20`] 
| Forward&hyphen;secure ChaCha20
| xref:FSChaCha20Poly1305.adoc[`FSChaCha20Poly1305`] 
| Forward&hyphen;secure wrapper around AEADChaCha20Poly1305&period;
| xref:FastRandomContext.adoc[`FastRandomContext`] 
| Fast randomness source&period; This is seeded once with secure random data, but is completely deterministic and does not gather more entropy after that&period;
| xref:FeeCalculation.adoc[`FeeCalculation`] 
| Aggregate details about how a smart fee estimate was reached&period;
| xref:FeeFilterRounder.adoc[`FeeFilterRounder`] 
| Quantizes minimum fee values to a discrete set of feerates for fee filter privacy&period;
| xref:FeeFrac.adoc[`FeeFrac`] 
| Data structure storing a fee and size&period;
| xref:FeePerUnit.adoc[`FeePerUnit`] 
| Tagged wrapper around FeeFrac to avoid unit confusion&period;
| xref:FeeRateEstimation.adoc[`FeeRateEstimation`] 
| A successful fee rate estimate returned by a fee rate estimator&period;
| xref:FeeRateEstimationError.adoc[`FeeRateEstimationError`] 
| A failed fee rate estimation, carrying the zero&hyphen;value estimation that identifies the estimator and target alongside the error reason&period;
| xref:FeeRateEstimatorManager.adoc[`FeeRateEstimatorManager`] 
| Tracks fee&hyphen;rate estimates derived from observed transactions&period;
| xref:FillableSigningProvider.adoc[`FillableSigningProvider`] 
| Fillable signing provider that keeps keys in an address&hyphen;&gt;secret map
| xref:FlatFilePos.adoc[`FlatFilePos`] 
| Location of a record within a numbered flat file&colon; a file index and byte offset&period;
| xref:FlatFileSeq.adoc[`FlatFileSeq`] 
| FlatFileSeq represents a sequence of numbered files storing raw data&period; This class facilitates access to and efficient management of these files&period;
| xref:FlatSigningProvider.adoc[`FlatSigningProvider`] 
| A signing provider backed by plain in&hyphen;memory maps of keys and scripts&period;
| xref:GCSFilter.adoc[`GCSFilter`] 
| This implements a Golomb&hyphen;coded set as defined in BIP 158&period; It is a compact, probabilistic data structure for testing set membership&period;
| xref:GenTxid.adoc[`GenTxid`] 
| A transaction identifier that holds either a txid or a wtxid&period;
| xref:GenericTransactionSignatureChecker-03.adoc[`GenericTransactionSignatureChecker`] 
| Signature checker that validates against a concrete spending transaction&period;
| xref:GlobalMutex.adoc[`GlobalMutex`] 
| Different type to mark Mutex at global scope
| xref:HTTPHeaders.adoc[`HTTPHeaders`] 
| Collection of HTTP header field&hyphen;value pairs for a request or response&period;
| xref:HTTPRemoteClient.adoc[`HTTPRemoteClient`] 
| A connected HTTP client, holding its socket plus the receive and send buffers&period;
| xref:HTTPRequest.adoc[`HTTPRequest`] 
| A single HTTP request being parsed from and replied to over a client connection&period;
| xref:HTTPResponse.adoc[`HTTPResponse`] 
| Status line, headers and version of an HTTP response&period;
| xref:HTTPServer.adoc[`HTTPServer`] 
| Socket&hyphen;based HTTP server that accepts connections and dispatches requests to worker threads&period;
| xref:HTTPVersion.adoc[`HTTPVersion`] 
| Major and minor components of an HTTP protocol version&period;
| xref:HashVerifier.adoc[`HashVerifier`] 
| Reads data from an underlying stream, while hashing the read data&period;
| xref:HashWriter.adoc[`HashWriter`] 
| A writer stream (for serialization) that computes a 256&hyphen;bit hash&period;
| xref:HashedSourceWriter.adoc[`HashedSourceWriter`] 
| Writes data to an underlying source stream, while hashing the written data&period;
| xref:HeadersSyncParams.adoc[`HeadersSyncParams`] 
| Configuration for headers sync memory usage&period;
| xref:HeadersSyncState.adoc[`HeadersSyncState`] 
| HeadersSyncState&colon;
| xref:HelpElisionNone.adoc[`HelpElisionNone`] 
| Controls how an RPCResult is rendered in human&hyphen;readable help text&period; The std&colon;&colon;string alternative carries the summary text rendered as &quot;&period;&period;&period;&quot;&period;
| xref:HelpElisionSkip.adoc[`HelpElisionSkip`] 
| Elision mode that hides a field from the rendered help text&period;
| xref:HelpResult.adoc[`HelpResult`] 
| Exception carrying pre&hyphen;rendered RPC help text to return to the caller&period;
| xref:HidingSigningProvider.adoc[`HidingSigningProvider`] 
| Wraps a signing provider, optionally hiding secret keys and key origins&period;
| xref:IndexSummary.adoc[`IndexSummary`] 
| A snapshot of an index&apos;s identity and sync progress&period;
| xref:InsecureRandomContext.adoc[`InsecureRandomContext`] 
| xoroshiro128&plus;&plus; PRNG&period; Extremely fast, not appropriate for cryptographic purposes&period;
| xref:InvalidAddrManVersionError.adoc[`InvalidAddrManVersionError`] 
| Exception thrown when peers&period;dat has an unsupported addrman version&period;
| xref:JSONRPCRequest.adoc[`JSONRPCRequest`] 
| Context and parameters for a single JSON&hyphen;RPC request&period;
| xref:KeyInfo.adoc[`KeyInfo`] 
| Parsed components of a configuration key&period;
| xref:KeyOriginInfo.adoc[`KeyOriginInfo`] 
| Origin information (master key fingerprint and derivation path) for a public key&period;
| xref:KeyPair.adoc[`KeyPair`] 
| KeyPair
| xref:KeyPathElement.adoc[`KeyPathElement`] 
| A single element of a BIP32 hierarchical deterministic key path&period;
| xref:LevelDBContext.adoc[`LevelDBContext`] 
| Opaque holder for the LevelDB&hyphen;specific state of a CDBWrapper&period;
| xref:LimitedStringFormatter.adoc[`LimitedStringFormatter`] 
| Formatter that serializes a string and rejects lengths above a compile&hyphen;time limit&period;
| xref:LimitedVectorFormatter.adoc[`LimitedVectorFormatter`] 
| Limited vector formatter&period; Throws an error if a vector is oversized&period;
| xref:LocalServiceInfo.adoc[`LocalServiceInfo`] 
| A local address we advertise, together with how trustworthy it is&period;
| xref:LockPoints.adoc[`LockPoints`] 
| Cached block height and time that satisfy a transaction&apos;s relative locktimes&period;
| xref:LockedPageAllocator.adoc[`LockedPageAllocator`] 
| OS&hyphen;dependent allocation and deallocation of locked&sol;pinned memory pages&period; Abstract base class&period;
| xref:LockedPool.adoc[`LockedPool`] 
| Pool for locked memory chunks&period;
| xref:LockedPoolManager.adoc[`LockedPoolManager`] 
| Singleton class to keep track of locked (ie, non&hyphen;swappable) memory, for use in std&colon;&colon;allocator templates&period;
| xref:LogCategory.adoc[`LogCategory`] 
| A log category paired with whether it is currently enabled&period;
| xref:MappingResult.adoc[`MappingResult`] 
| Successful response to a port mapping&period;
| xref:MemPoolFeeRateEstimator.adoc[`MemPoolFeeRateEstimator`] 
| Estimate the fee rate required for a transaction to be included in the next block&period;
| xref:MemPoolFeeRateEstimatorCache.adoc[`MemPoolFeeRateEstimatorCache`] 
| MemPoolFeeRateEstimatorCache holds a cache of recent fee rate estimates&period; A cached fee rate is only provided while it is not older than CACHE&lowbar;LIFE and the chain tip has not changed&period;
| xref:MempoolAcceptResult.adoc[`MempoolAcceptResult`] 
| Validation result for a transaction evaluated by MemPoolAccept (single or package)&period; Here are the expected fields and properties of a result depending on its ResultType, applicable to results returned from package evaluation&colon;&plus;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&plus;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&plus;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&plus;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&plus;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&plus;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&plus;&verbar; Field or property &verbar; VALID &verbar; INVALID &verbar; MEMPOOL&lowbar;ENTRY &verbar; DIFFERENT&lowbar;WITNESS &verbar;&verbar; &verbar; &verbar;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&verbar; &verbar; &verbar;&verbar; &verbar; &verbar; TX&lowbar;RECONSIDERABLE &verbar; Other &verbar; &verbar; &verbar;&plus;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&plus;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&plus;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&plus;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&plus;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&plus;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&plus;&verbar; txid in mempool? &verbar; yes &verbar; no &verbar; no&ast; &verbar; yes &verbar; yes &verbar;&verbar; wtxid in mempool? &verbar; yes &verbar; no &verbar; no&ast; &verbar; yes &verbar; no &verbar;&verbar; m&lowbar;state &verbar; yes, IsValid() &verbar; yes, IsInvalid() &verbar; yes, IsInvalid() &verbar; yes, IsValid() &verbar; yes, IsValid() &verbar;&verbar; m&lowbar;vsize &verbar; yes &verbar; no &verbar; no &verbar; yes &verbar; no &verbar;&verbar; m&lowbar;base&lowbar;fees &verbar; yes &verbar; no &verbar; no &verbar; yes &verbar; no &verbar;&verbar; m&lowbar;effective&lowbar;feerate &verbar; yes &verbar; yes &verbar; no &verbar; no &verbar; no &verbar;&verbar; m&lowbar;wtxids&lowbar;fee&lowbar;calculations &verbar; yes &verbar; yes &verbar; no &verbar; no &verbar; no &verbar;&verbar; m&lowbar;other&lowbar;wtxid &verbar; no &verbar; no &verbar; no &verbar; no &verbar; yes &verbar;&plus;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&plus;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&plus;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&plus;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&plus;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&plus;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&plus; (&ast;) Individual transaction acceptance doesn&apos;t return MEMPOOL&lowbar;ENTRY and DIFFERENT&lowbar;WITNESS&period; It returns INVALID, with the errors txn&hyphen;already&hyphen;in&hyphen;mempool and txn&hyphen;same&hyphen;nonwitness&hyphen;data&hyphen;in&hyphen;mempool respectively&period; In those cases, the txid or wtxid may be in the mempool for a TX&lowbar;CONFLICT&period;
| xref:MinedBlockStats.adoc[`MinedBlockStats`] 
| Weight statistics for a recently mined block, used to assess mempool coverage&period;
| xref:MockableSteadyClock.adoc[`MockableSteadyClock`] 
| Version of SteadyClock that is mockable in the context of tests (via FakeSteadyClock, or Self&colon;&colon;SetMockTime), otherwise the system steady clock&period;
| xref:MuHash3072.adoc[`MuHash3072`] 
| A multiplicative hash of the UTXO set&period;
| xref:MuSig2SecNonce.adoc[`MuSig2SecNonce`] 
| MuSig2SecNonce encapsulates a secret nonce in use in a MuSig2 signing session&period; Since this nonce persists outside of libsecp256k1 signing code, we must handle its construction and destruction ourselves&period; The secret nonce must be kept a secret, otherwise the private key may be leaked&period; As such, it needs to be treated in the same way that CKeys are treated&period; So this class handles the secure allocation of the secp256k1&lowbar;musig&lowbar;secnonce object that libsecp256k1 uses, and only gives out references to this object to avoid any possibility of copies being made&period; Furthermore, objects of this class are not copyable to avoid nonce reuse&period;
| xref:MuSig2SecNonceImpl.adoc[`MuSig2SecNonceImpl`] 
| Implementation detail that owns the secure storage of a MuSig2 secret nonce&period;
| xref:MultiSigningProvider.adoc[`MultiSigningProvider`] 
| A signing provider to be used to interface with multiple signing providers at once&period;
| xref:MutableTransactionSignatureCreator.adoc[`MutableTransactionSignatureCreator`] 
| A signature creator for transactions&period;
| xref:NetEventsInterface.adoc[`NetEventsInterface`] 
| Interface for message handling
| xref:NetGroupManager.adoc[`NetGroupManager`] 
| Netgroup manager
| xref:NetPermissions.adoc[`NetPermissions`] 
| Holds the permission flags granted to a peer and helpers to query and modify them&period;
| xref:NetWhitebindPermissions.adoc[`NetWhitebindPermissions`] 
| Permissions bound to a specific listening address, parsed from a &hyphen;whitebind entry&period;
| xref:NetWhitelistPermissions.adoc[`NetWhitelistPermissions`] 
| Permissions applied to peers matching a subnet, parsed from a &hyphen;whitelist entry&period;
| xref:NewMempoolTransactionInfo.adoc[`NewMempoolTransactionInfo`] 
| Notification payload describing a transaction added to the mempool&period;
| xref:NodeClock.adoc[`NodeClock`] 
| Version of the system clock that is mockable in the context of tests (via FakeNodeClock or &colon;&colon;SetMockTime), otherwise the system clock&period;
| xref:NodeEvictionCandidate.adoc[`NodeEvictionCandidate`] 
| Snapshot of one inbound peer&apos;s attributes used by the eviction selection logic&period;
| xref:NoechoInst.adoc[`NoechoInst`] 
| Scoped guard that disables terminal echo on standard input&period;
| xref:NonFatalCheckError.adoc[`NonFatalCheckError`] 
| Exception thrown by CHECK&lowbar;NONFATAL() when its condition is false&period;
| xref:Num3072.adoc[`Num3072`] 
| A 3072&hyphen;bit number in the MuHash prime field, stored as an array of limbs&period;
| xref:Obfuscation.adoc[`Obfuscation`] 
| XOR&hyphen;based obfuscation over a fixed&hyphen;size key, applied to byte ranges&period;
| xref:PKHash.adoc[`PKHash`] 
| A public&hyphen;key&hyphen;hash destination for a P2PKH address&period;
| xref:PSBTInput.adoc[`PSBTInput`] 
| A structure for PSBTs which contain per&hyphen;input information
| xref:PSBTOutput.adoc[`PSBTOutput`] 
| A structure for PSBTs which contains per output information
| xref:PSBTProprietary.adoc[`PSBTProprietary`] 
| A structure for PSBT proprietary types
| xref:PackageMempoolAcceptResult.adoc[`PackageMempoolAcceptResult`] 
| Validation result for package mempool acceptance&period;
| xref:PackageValidationState.adoc[`PackageValidationState`] 
| Validation state for a package, carrying a PackageValidationResult rejection reason&period;
| xref:ParamsStream-02.adoc[`ParamsStream`] 
| Wrapper that overrides the GetParams() function of a stream&period;
| xref:ParamsWrapper.adoc[`ParamsWrapper`] 
| Wrapper that serializes objects with the specified parameters&period;
| xref:PartiallyDownloadedBlock.adoc[`PartiallyDownloadedBlock`] 
| A block being reconstructed from a compact block plus mempool&sol;extra transactions&period;
| xref:PartiallySignedTransaction.adoc[`PartiallySignedTransaction`] 
| A version of CTransaction with the PSBT format
| xref:PayToAnchor.adoc[`PayToAnchor`] 
| A pay&hyphen;to&hyphen;anchor destination for a P2A address&period;
| xref:PeerManager.adoc[`PeerManager`] 
| Drives the peer&hyphen;to&hyphen;peer message processing and relay logic for a node&period;
| xref:PeerManagerInfo.adoc[`PeerManagerInfo`] 
| Aggregate information about the peer manager, reported for diagnostics&period;
| xref:Poly1305.adoc[`Poly1305`] 
| C&plus;&plus; wrapper with std&colon;&colon;byte span interface around poly1305&lowbar;donna code&period;
| xref:PoolAllocator-0e.adoc[`PoolAllocator`] 
| Forwards all allocations&sol;deallocations to the PoolResource&period;
| xref:PoolResource.adoc[`PoolResource`] 
| A memory resource similar to std&colon;&colon;pmr&colon;&colon;unsynchronized&lowbar;pool&lowbar;resource, but optimized for node&hyphen;based containers&period; It has the following properties&colon;
| xref:PoolResourceTester.adoc[`PoolResourceTester`] 
| Access to internals for testing purpose only
| xref:PrecomputedTransactionData.adoc[`PrecomputedTransactionData`] 
| Cached transaction data reused across signature&hyphen;hash computations for a single transaction&period;
| xref:PrefilledTransaction.adoc[`PrefilledTransaction`] 
| A transaction sent inline within a compact block, plus its position&period;
| xref:PresaltedSipHasher.adoc[`PresaltedSipHasher`] 
| Optimized SipHash&hyphen;2&hyphen;4 implementation for uint256&period;
| xref:PrivateBroadcast.adoc[`PrivateBroadcast`] 
| Store a list of transactions to be broadcast privately&period; Supports the following operations&colon; &hyphen; Add a new transaction &hyphen; Remove a transaction &hyphen; Pick a transaction for sending to one recipient &hyphen; Query which transaction has been picked for sending to a given recipient node &hyphen; Mark that a given recipient node has confirmed receipt of a transaction &hyphen; Query whether a given recipient node has confirmed reception &hyphen; Query whether any transactions that need sending are currently on the list
| xref:Proxy.adoc[`Proxy`] 
| A proxy endpoint, either a network service or a local unix domain socket&period;
| xref:ProxyCredentials.adoc[`ProxyCredentials`] 
| Credentials for proxy authentication
| xref:PubKeyDestination.adoc[`PubKeyDestination`] 
| A pay&hyphen;to&hyphen;public&hyphen;key destination that has no associated address&period;
| xref:RPCArg.adoc[`RPCArg`] 
| Describes a single argument of an RPC method for validation and help text&period;
| xref:RPCArgOptions.adoc[`RPCArgOptions`] 
| Optional settings controlling how an RPCArg is validated and rendered&period;
| xref:RPCExamples.adoc[`RPCExamples`] 
| Holds example invocations shown in an RPC method&apos;s help text&period;
| xref:RPCMethod.adoc[`RPCMethod`] 
| Describes an RPC method&colon; its name, arguments, results, examples, and handler&period;
| xref:RPCResult.adoc[`RPCResult`] 
| Describes one part of an RPC method&apos;s result for type checking and help text&period;
| xref:RPCResultOptions.adoc[`RPCResultOptions`] 
| Optional settings controlling how an RPCResult is validated and rendered&period;
| xref:RPCResults.adoc[`RPCResults`] 
| The complete set of result variants an RPC method can return&period;
| xref:RandomMixin-01.adoc[`RandomMixin`] 
| Mixin class that provides helper randomness functions&period;
| xref:ReachableNets.adoc[`ReachableNets`] 
| List of reachable networks&period; Everything is reachable by default&period;
| xref:RemovedMempoolTransactionInfo.adoc[`RemovedMempoolTransactionInfo`] 
| Notification payload describing a transaction removed from the mempool&period;
| xref:SHA3_256.adoc[`SHA3&lowbar;256`] 
| A hasher class for SHA3&hyphen;256 (fixed 256&hyphen;bit output Keccak)&period;
| xref:SaltedCoinsCacheHasher.adoc[`SaltedCoinsCacheHasher`] 
| SipHash&hyphen;1&hyphen;3&hyphen;UJ based hasher for the coins cache and related coins containers&period;
| xref:SaltedOutpointHasher.adoc[`SaltedOutpointHasher`] 
| Hashes a transaction outpoint (COutPoint) with a per&hyphen;instance random salt&period;
| xref:SaltedSipHasher.adoc[`SaltedSipHasher`] 
| Hashes an arbitrary byte span with a per&hyphen;instance random SipHash salt&period;
| xref:SaltedTxidHasher.adoc[`SaltedTxidHasher`] 
| Hashes a transaction id (Txid) with a per&hyphen;instance random salt&period;
| xref:SaltedUint256Hasher.adoc[`SaltedUint256Hasher`] 
| Hashes a uint256 with a per&hyphen;instance random salt&period;
| xref:SaltedWtxidHasher.adoc[`SaltedWtxidHasher`] 
| Hashes a witness transaction id (Wtxid) with a per&hyphen;instance random salt&period;
| xref:ScopedDataStreamUsage.adoc[`ScopedDataStreamUsage`] 
| Require empty scratch streams on entry and reset them on exit&period;
| xref:ScriptCompression.adoc[`ScriptCompression`] 
| Compact serializer for scripts&period;
| xref:ScriptExecutionData.adoc[`ScriptExecutionData`] 
| Mutable per&hyphen;input state carried through Taproot&sol;Tapscript execution&period;
| xref:ScriptHash.adoc[`ScriptHash`] 
| A script&hyphen;hash destination for a P2SH address&period;
| xref:SectionInfo.adoc[`SectionInfo`] 
| Location where a config section name was encountered&period;
| xref:Sections.adoc[`Sections`] 
| Accumulator for the formatted sections that make up RPC help text&period;
| xref:SecureUniqueDeleter.adoc[`SecureUniqueDeleter`] 
| Deleter that securely deallocates a single object through secure&lowbar;allocator&period;
| xref:SerialTaskRunner.adoc[`SerialTaskRunner`] 
| Class used by CScheduler clients which may schedule multiple jobs which are required to be run serially&period; Jobs may not be run on the same thread, but no two jobs will be executed at the same time and memory will be release&hyphen;acquire consistent (the scheduler will internally do an acquire before invoking a callback as well as a release at the end)&period; In practice this means that a callback B() will be able to observe all of the effects of callback A() which executed before it&period;
| xref:ShortestVectorFirstComparator.adoc[`ShortestVectorFirstComparator`] 
| Orders byte vectors by length first, then lexicographically&period;
| xref:SigHashCache.adoc[`SigHashCache`] 
| Data structure to cache SHA256 midstates for the ECDSA sighash calculations (bare, P2SH, P2WPKH, P2WSH)&period;
| xref:SignOptions.adoc[`SignOptions`] 
| Options that influence how an input is signed&period;
| xref:SignatureCache.adoc[`SignatureCache`] 
| Valid signature cache, to avoid doing expensive ECDSA signature checking twice for every transaction (once when accepted into memory pool, and again when accepted into the block chain)
| xref:SignatureCacheHasher.adoc[`SignatureCacheHasher`] 
| We&apos;re hashing a nonce into the entries themselves, so we don&apos;t need extra blinding in the set hash computation&period;
| xref:SignatureData.adoc[`SignatureData`] 
| Signature material collected for a single transaction input&period;
| xref:SignetTxs.adoc[`SignetTxs`] 
| Generate the signet tx corresponding to the given block
| xref:SigningProvider.adoc[`SigningProvider`] 
| An interface to be implemented by keystores that support signing&period;
| xref:SipHashState.adoc[`SipHashState`] 
| Shared SipHash state (v0&period;&period;v3) with its round, compression, and finalization primitives&period; Internal building block, only meant to be composed by the hasher classes below&period;
| xref:SipHasher13UJ.adoc[`SipHasher13UJ`] 
| A custom weaker variant of SipHash&hyphen;1&hyphen;3 without padding, and supporting &quot;jumbo&quot; inputs&period;
| xref:SizeComputer.adoc[`SizeComputer`] 
| Stream&hyphen;like object that only records how many bytes a serialization would write&period;
| xref:Sock.adoc[`Sock`] 
| RAII helper class that manages a socket and closes it automatically when it goes out of scope&period;
| xref:SourceLocation.adoc[`SourceLocation`] 
| Like std&colon;&colon;source&lowbar;location, but allowing to override the function name&period;
| xref:SourceLocationEqual.adoc[`SourceLocationEqual`] 
| Equality comparator for SourceLocation keys, comparing line and file name&period;
| xref:SourceLocationHasher.adoc[`SourceLocationHasher`] 
| Hash functor for SourceLocation keys, mixing line and file name&period;
| xref:SpanReader.adoc[`SpanReader`] 
| Minimal stream for reading from an existing byte array by std&colon;&colon;span&period;
| xref:SpanWriter.adoc[`SpanWriter`] 
| Minimal stream for writing to an existing span of bytes&period;
| xref:StdMutex.adoc[`StdMutex`] 
| An annotated version of std&colon;&colon;mutex for Clang Thread Safety Analysis&period;
| xref:TaprootBuilder.adoc[`TaprootBuilder`] 
| Utility class to construct Taproot outputs from internal key and script tree&period;
| xref:TaprootSpendData.adoc[`TaprootSpendData`] 
| Data needed to spend a Taproot output, including its script tree&period;
| xref:ThreadPool.adoc[`ThreadPool`] 
| Fixed&hyphen;size thread pool for running arbitrary tasks concurrently&period;
| xref:TimeOffsets.adoc[`TimeOffsets`] 
| Tracks clock differences against outbound peers and warns when the local clock drifts&period;
| xref:TokenPipe.adoc[`TokenPipe`] 
| An interprocess or interthread pipe for sending tokens (one&hyphen;byte values) over&period;
| xref:TokenPipeEnd.adoc[`TokenPipeEnd`] 
| One end of a token pipe&period;
| xref:TorControlConnection.adoc[`TorControlConnection`] 
| Low&hyphen;level handling for Tor control connection&period; Speaks the SMTP&hyphen;like protocol as defined in torspec&sol;control&hyphen;spec&period;txt
| xref:TorControlReply.adoc[`TorControlReply`] 
| Reply from Tor, can be single or multi&hyphen;line
| xref:TorController.adoc[`TorController`] 
| Manages the node&apos;s Tor hidden service and control connection&period;
| xref:TransactionInfo.adoc[`TransactionInfo`] 
| Snapshot of the policy&hyphen;relevant data for a mempool transaction&period;
| xref:TransactionSerParams.adoc[`TransactionSerParams`] 
| Serialization parameters controlling whether transaction witnesses are included&period;
| xref:Transport.adoc[`Transport`] 
| The Transport converts one connection&apos;s sent messages to wire bytes, and received bytes back&period;
| xref:TxConfirmStats.adoc[`TxConfirmStats`] 
| Tracks transaction confirmation history for a single time horizon&period;
| xref:TxDocOptions.adoc[`TxDocOptions`] 
| Options controlling how TxDoc renders the decoded transaction help&period;
| xref:TxGraph.adoc[`TxGraph`] 
| Data structure to encapsulate fees, sizes, and dependencies for a set of transactions&period;
| xref:TxInUndoFormatter.adoc[`TxInUndoFormatter`] 
| Formatter for undo information for a CTxIn
| xref:TxIndex-01.adoc[`TxIndex`] 
| TxIndex is used to look up transactions included in the blockchain by hash&period; The index is written to a LevelDB database and records the block sequence number and serialized block offset of each transaction by transaction hash&period;
| xref:TxIndexResult.adoc[`TxIndexResult`] 
| A found transaction and the hash of the block that contains it&period;
| xref:TxMempoolInfo.adoc[`TxMempoolInfo`] 
| Information about a mempool transaction&period;
| xref:TxOutCompression.adoc[`TxOutCompression`] 
| wrapper for CTxOut that provides a more compact serialization
| xref:TxReconciliationTracker.adoc[`TxReconciliationTracker`] 
| Transaction reconciliation is a way for nodes to efficiently announce transactions&period; This object keeps track of all txreconciliation&hyphen;related communications with the peers&period; The high&hyphen;level protocol is&colon; 0&period; Txreconciliation protocol handshake&period; 1&period; Once we receive a new transaction, add it to the set instead of announcing immediately&period; 2&period; At regular intervals, a txreconciliation initiator requests a sketch from a peer, where a sketch is a compressed representation of short form IDs of the transactions in their set&period; 3&period; Once the initiator received a sketch from the peer, the initiator computes a local sketch, and combines the two sketches to attempt finding the difference in _sets_&period; 4a&period; If the difference was not larger than estimated, see SUCCESS below&period; 4b&period; If the difference was larger than estimated, initial txreconciliation fails&period; The initiator requests a larger sketch via an extension round (allowed only once)&period; &hyphen; If extension succeeds (a larger sketch is sufficient), see SUCCESS below&period; &hyphen; If extension fails (a larger sketch is insufficient), see FAILURE below&period;
| xref:TxRequestTracker.adoc[`TxRequestTracker`] 
| Data structure to keep track of, and schedule, transaction downloads from peers&period;
| xref:TxValidationState.adoc[`TxValidationState`] 
| Holds the outcome and reason of transaction&hyphen;level validation&period;
| xref:TxoSpender.adoc[`TxoSpender`] 
| A spending transaction and the hash of the block that contains it&period;
| xref:TxoSpenderIndex.adoc[`TxoSpenderIndex`] 
| TxoSpenderIndex is used to look up which transaction spent a given output&period; The index is written to a LevelDB database and, for each input of each transaction in a block, records the outpoint that is spent and the hash of the spending transaction&period;
| xref:UniValue.adoc[`UniValue`] 
| A dynamically typed JSON value used across Bitcoin Core&apos;s RPC layer&period;
| xref:UniValueType.adoc[`UniValueType`] 
| Wrapper for UniValue&colon;&colon;VType, which includes typeAny&colon; Used to denote don&apos;t care type&period;
| xref:UniqueLock.adoc[`UniqueLock`] 
| Wrapper around std&colon;&colon;unique&lowbar;lock style lock for MutexType&period;
| xref:V1Transport.adoc[`V1Transport`] 
| Transport implementation for the legacy (v1) unencrypted P2P protocol&period;
| xref:V2Transport.adoc[`V2Transport`] 
| Transport implementation for the encrypted BIP324 (v2) P2P protocol, with automatic fallback to v1 when the peer does not speak v2&period;
| xref:VBDeploymentInfo.adoc[`VBDeploymentInfo`] 
| Static description of a version&hyphen;bits soft fork deployment&period;
| xref:VSizeTag.adoc[`VSizeTag`] 
| Tag selecting the satoshi&hyphen;per&hyphen;vbyte FeePerUnit instantiation&period;
| xref:ValidationCache.adoc[`ValidationCache`] 
| Convenience class for initializing and passing the script execution cache and signature cache&period;
| xref:ValidationInterfaceTest.adoc[`ValidationInterfaceTest`] 
| Test fixture granted access to the interface&apos;s protected callbacks&period;
| xref:ValidationSignals.adoc[`ValidationSignals`] 
| Dispatches validation event notifications to registered subscribers&period;
| xref:ValidationSignalsImpl.adoc[`ValidationSignalsImpl`] 
| Private implementation details of ValidationSignals&period;
| xref:ValidationState-04.adoc[`ValidationState`] 
| Template for capturing information about block&sol;transaction validation&period; This is instantiated by TxValidationState and BlockValidationState for validation information on transactions and blocks respectively&period;
| xref:VarIntFormatter.adoc[`VarIntFormatter`] 
| Serialization wrapper class for integers in VarInt format&period;
| xref:VecDeque.adoc[`VecDeque`] 
| Data structure largely mimicking std&colon;&colon;deque, but using single preallocated ring buffer&period;
| xref:VectorFormatter.adoc[`VectorFormatter`] 
| Formatter to serialize&sol;deserialize vector elements using another formatter
| xref:VectorWriter.adoc[`VectorWriter`] 
| Minimal stream for overwriting and&sol;or appending to an existing byte vector
| xref:VersionBitsCache.adoc[`VersionBitsCache`] 
| BIP 9 allows multiple softforks to be deployed in parallel&period; We cache per&hyphen;period state for every one we implement and warning state for each BIP 323 allowed bit&period;
| xref:VersionBitsConditionChecker.adoc[`VersionBitsConditionChecker`] 
| Class to implement versionbits logic&period;
| xref:WalletInitInterface.adoc[`WalletInitInterface`] 
| Interface that lets the node initialize the optional wallet component&period;
| xref:WeightTag.adoc[`WeightTag`] 
| Tag selecting the satoshi&hyphen;per&hyphen;weight&hyphen;unit FeePerUnit instantiation&period;
| xref:WitnessUnknown.adoc[`WitnessUnknown`] 
| CTxDestination subtype to encode any future Witness version&period;
| xref:WitnessV0KeyHash.adoc[`WitnessV0KeyHash`] 
| A version&hyphen;0 witness key&hyphen;hash destination for a P2WPKH address&period;
| xref:WitnessV0ScriptHash.adoc[`WitnessV0ScriptHash`] 
| A version&hyphen;0 witness script&hyphen;hash destination for a P2WSH address&period;
| xref:WitnessV1Taproot.adoc[`WitnessV1Taproot`] 
| A version&hyphen;1 taproot destination for a P2TR address&period;
| xref:Wrapper.adoc[`Wrapper`] 
| Simple wrapper class to serialize objects using a formatter&semi; used by Using()&period;
| xref:XOnlyPubKey.adoc[`XOnlyPubKey`] 
| A BIP340&hyphen;style x&hyphen;only public key, storing only the 32&hyphen;byte x coordinate&period;
| xref:arith_uint256.adoc[`arith&lowbar;uint256`] 
| 256&hyphen;bit unsigned big integer&period;
| xref:base_blob-09.adoc[`base&lowbar;blob`] 
| Template base class for fixed&hyphen;sized opaque blobs&period;
| xref:base_uint-02.adoc[`base&lowbar;uint`] 
| Template base class for unsigned big integers&period;
| xref:bilingual_str.adoc[`bilingual&lowbar;str`] 
| Bilingual messages&colon; &hyphen; in GUI&colon; user&apos;s native language &plus; untranslated (i&period;e&period; English) &hyphen; in log and stderr&colon; untranslated only
| xref:bitdeque.adoc[`bitdeque`] 
| Class that mimics std&colon;&colon;deque&lt;bool&gt;, but with std&colon;&colon;vector&lt;bool&gt;&apos;s bit packing&period;
| xref:btck_Block-01.adoc[`btck&lowbar;Block`] 
| Opaque data structure for holding a block&period;
| xref:btck_BlockHash-0e.adoc[`btck&lowbar;BlockHash`] 
| Opaque data structure for holding a block hash&period;
| xref:btck_BlockHeader-02.adoc[`btck&lowbar;BlockHeader`] 
| Opaque data structure for holding a btck&lowbar;BlockHeader&period;
| xref:btck_BlockSpentOutputs-03.adoc[`btck&lowbar;BlockSpentOutputs`] 
| Opaque data structure for holding a block&apos;s spent outputs&period;
| xref:btck_BlockTreeEntry-0d.adoc[`btck&lowbar;BlockTreeEntry`] 
| Opaque data structure for holding a block tree entry&period;
| xref:btck_BlockValidationState-0b.adoc[`btck&lowbar;BlockValidationState`] 
| Opaque data structure for holding the state of a block during validation&period;
| xref:btck_Chain-0b.adoc[`btck&lowbar;Chain`] 
| Opaque data structure for holding the currently known best&hyphen;chain associated with a chainstate&period;
| xref:btck_ChainParameters-0a.adoc[`btck&lowbar;ChainParameters`] 
| Opaque data structure for holding the chain parameters&period;
| xref:btck_ChainstateManager-00.adoc[`btck&lowbar;ChainstateManager`] 
| Opaque data structure for holding a chainstate manager&period;
| xref:btck_ChainstateManagerOptions-01.adoc[`btck&lowbar;ChainstateManagerOptions`] 
| Opaque data structure for holding options for creating a new chainstate manager&period;
| xref:btck_Coin-05.adoc[`btck&lowbar;Coin`] 
| Opaque data structure for holding a coin&period;
| xref:btck_ConsensusParams-04.adoc[`btck&lowbar;ConsensusParams`] 
| Opaque data structure for holding the Consensus Params&period;
| xref:btck_Context-0b.adoc[`btck&lowbar;Context`] 
| Opaque data structure for holding a kernel context&period;
| xref:btck_ContextOptions-07.adoc[`btck&lowbar;ContextOptions`] 
| Opaque data structure for holding options for creating a new kernel context&period;
| xref:btck_LoggingConnection-06.adoc[`btck&lowbar;LoggingConnection`] 
| Opaque data structure for holding a logging connection&period;
| xref:btck_LoggingOptions.adoc[`btck&lowbar;LoggingOptions`] 
| Options controlling the format of log messages&period;
| xref:btck_NotificationInterfaceCallbacks.adoc[`btck&lowbar;NotificationInterfaceCallbacks`] 
| A struct for holding the kernel notification callbacks&period; The user data pointer may be used to point to user&hyphen;defined structures to make processing the notifications easier&period;
| xref:btck_PrecomputedTransactionData-07.adoc[`btck&lowbar;PrecomputedTransactionData`] 
| Opaque data structure for holding precomputed transaction data&period;
| xref:btck_ScriptPubkey-0b.adoc[`btck&lowbar;ScriptPubkey`] 
| Opaque data structure for holding a script pubkey&period;
| xref:btck_Transaction-02.adoc[`btck&lowbar;Transaction`] 
| Opaque data structure for holding a transaction&period;
| xref:btck_TransactionInput-06.adoc[`btck&lowbar;TransactionInput`] 
| Opaque data structure for holding a transaction input&period;
| xref:btck_TransactionOutPoint-08.adoc[`btck&lowbar;TransactionOutPoint`] 
| Opaque data structure for holding a transaction out point&period;
| xref:btck_TransactionOutput-02.adoc[`btck&lowbar;TransactionOutput`] 
| Opaque data structure for holding a transaction output&period;
| xref:btck_TransactionSpentOutputs-0b.adoc[`btck&lowbar;TransactionSpentOutputs`] 
| Opaque data structure for holding a transaction&apos;s spent outputs&period;
| xref:btck_TxValidationState-08.adoc[`btck&lowbar;TxValidationState`] 
| Opaque data structure for holding the state of a transaction during validation&period;
| xref:btck_Txid-02.adoc[`btck&lowbar;Txid`] 
| Opaque data structure for holding a btck&lowbar;Txid&period;
| xref:btck_ValidationInterfaceCallbacks.adoc[`btck&lowbar;ValidationInterfaceCallbacks`] 
| Holds the validation interface callbacks&period; The user data pointer may be used to point to user&hyphen;defined structures to make processing the validation callbacks easier&period; Note that these callbacks block any further validation execution when they are called&period;
| xref:btck_WitnessStack-04.adoc[`btck&lowbar;WitnessStack`] 
| Opaque data structure for holding a witness stack&period;
| xref:dbwrapper_error.adoc[`dbwrapper&lowbar;error`] 
| Exception thrown when a database operation fails&period;
| xref:deserialize_type.adoc[`deserialize&lowbar;type`] 
| Dummy data type to identify deserializing constructors&period;
| xref:entry_time.adoc[`entry&lowbar;time`] 
| Multi&hyphen;index tag for the index ordered by mempool entry time&period;
| xref:index_by_wtxid.adoc[`index&lowbar;by&lowbar;wtxid`] 
| Multi&hyphen;index tag for the index keyed by witness&hyphen;transaction hash (wtxid)&period;
| xref:indirectmap.adoc[`indirectmap`] 
| Map whose keys are pointers, but are compared by their dereferenced values&period;
| xref:mempoolentry_txid.adoc[`mempoolentry&lowbar;txid`] 
| Extracts a transaction hash (txid) from a CTxMemPoolEntry or CTransactionRef&period;
| xref:mempoolentry_wtxid.adoc[`mempoolentry&lowbar;wtxid`] 
| Extracts a transaction witness&hyphen;hash (wtxid) from a CTxMemPoolEntry or CTransactionRef&period;
| xref:prevector-0c.adoc[`prevector`] 
| Implements a drop&hyphen;in replacement for std&colon;&colon;vector&lt;T&gt; which stores up to N elements directly (without heap allocation)&period; The types Size and Diff are used to store element counts, and can be any unsigned &plus; signed type&period;
| xref:script_verify_flags.adoc[`script&lowbar;verify&lowbar;flags`] 
| Type&hyphen;safe set of script verification flags backed by a bitmask&period;
| xref:scriptnum_error.adoc[`scriptnum&lowbar;error`] 
| Exception thrown for invalid CScriptNum operations or encodings&period;
| xref:secp256k1_context_struct.adoc[`secp256k1&lowbar;context&lowbar;struct`] 
| Opaque libsecp256k1 context structure&period;
| xref:secp256k1_musig_keyagg_cache.adoc[`secp256k1&lowbar;musig&lowbar;keyagg&lowbar;cache`] 
| Opaque libsecp256k1 cache holding the aggregate public key state of a MuSig2 session&period;
| xref:secp256k1_musig_secnonce.adoc[`secp256k1&lowbar;musig&lowbar;secnonce`] 
| Opaque libsecp256k1 object holding a MuSig2 secret nonce&period;
| xref:secure_allocator.adoc[`secure&lowbar;allocator`] 
| Allocator that locks its contents from being paged out of memory and clears its contents before deletion&period;
| xref:sqlite3.adoc[`sqlite3`] 
| Opaque SQLite database connection handle, defined by the SQLite library&period;
| xref:sqlite3_stmt.adoc[`sqlite3&lowbar;stmt`] 
| Opaque SQLite prepared statement handle, defined by the SQLite library&period;
| xref:test_only_CheckFailuresAreExceptionsNotAborts.adoc[`test&lowbar;only&lowbar;CheckFailuresAreExceptionsNotAborts`] 
| RAII guard that makes failed checks throw instead of abort for the duration of a test&period;
| xref:transaction_identifier.adoc[`transaction&lowbar;identifier`] 
| transaction&lowbar;identifier represents the two canonical transaction identifier types (txid, wtxid)&period;
| xref:uint160.adoc[`uint160`] 
| 160&hyphen;bit opaque blob&period;
| xref:uint256.adoc[`uint256`] 
| 256&hyphen;bit opaque blob&period;
| xref:uint_error.adoc[`uint&lowbar;error`] 
| Exception thrown on arithmetic errors involving big integers&period;
| xref:zero_after_free_allocator-01.adoc[`zero&lowbar;after&lowbar;free&lowbar;allocator`] 
| Allocator that clears the memory it manages before returning it to the system&period;
|===


== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:BigEndianFormatter.adoc[`BigEndianFormatter`] 
| CustomUintFormatter alias that serializes integers in big&hyphen;endian byte order&period;
| xref:BinarySemaphoreGrant.adoc[`BinarySemaphoreGrant`] 
| A grant over a binary (single&hyphen;slot) semaphore&period;
| xref:BitSet.adoc[`BitSet`] 
| A bitset supporting at least BITS elements&period;
| xref:CAmount.adoc[`CAmount`] 
| Amount in satoshis (Can be negative)
| xref:CCoinsMap.adoc[`CCoinsMap`] 
| PoolAllocator&apos;s MAX&lowbar;BLOCK&lowbar;SIZE&lowbar;BYTES parameter here uses sizeof the data, and adds the size of 4 pointers&period; We do not know the exact node size used in the std&colon;&colon;unordered&lowbar;node implementation because it is implementation defined&period; Most implementations have an overhead of 1 or 2 pointers, so nodes can be connected in a linked list, and in some cases the hash value is stored as well&period; Using an additional sizeof(void&ast;)&ast;4 for MAX&lowbar;BLOCK&lowbar;SIZE&lowbar;BYTES should thus be sufficient so that all implementations can allocate the nodes from the PoolAllocator&period;
| xref:CCoinsMapMemoryResource.adoc[`CCoinsMapMemoryResource`] 
| Memory resource backing the pool allocator used by the coins map&period;
| xref:CPrivKey.adoc[`CPrivKey`] 
| CPrivKey is a serialized private key, with all parameters included (SIZE bytes)
| xref:CScriptBase.adoc[`CScriptBase`] 
| We use a prevector for the script to reduce the considerable memory overhead of vectors in cases where they normally contain a small number of small elements&period;
| xref:CTransactionRef.adoc[`CTransactionRef`] 
| Shared pointer to an immutable transaction&period;
| xref:CTxDestination.adoc[`CTxDestination`] 
| A txout script categorized into standard templates&period; &ast; CNoDestination&colon; Optionally a script, no corresponding address&period; &ast; PubKeyDestination&colon; TxoutType&colon;&colon;PUBKEY (P2PK), no corresponding address &ast; PKHash&colon; TxoutType&colon;&colon;PUBKEYHASH destination (P2PKH address) &ast; ScriptHash&colon; TxoutType&colon;&colon;SCRIPTHASH destination (P2SH address) &ast; WitnessV0ScriptHash&colon; TxoutType&colon;&colon;WITNESS&lowbar;V0&lowbar;SCRIPTHASH destination (P2WSH address) &ast; WitnessV0KeyHash&colon; TxoutType&colon;&colon;WITNESS&lowbar;V0&lowbar;KEYHASH destination (P2WPKH address) &ast; WitnessV1Taproot&colon; TxoutType&colon;&colon;WITNESS&lowbar;V1&lowbar;TAPROOT destination (P2TR address) &ast; PayToAnchor&colon; TxoutType&colon;&colon;ANCHOR destination (P2A address) &ast; WitnessUnknown&colon; TxoutType&colon;&colon;WITNESS&lowbar;UNKNOWN destination (P2W??? address) A CTxDestination is the internal data type encoded in a bitcoin address
| xref:CTxMemPoolEntryRef.adoc[`CTxMemPoolEntryRef`] 
| A reference to a constant mempool entry&period;
| xref:CZMQNotifierFactory.adoc[`CZMQNotifierFactory`] 
| Factory function that creates a ZMQ notifier instance&period;
| xref:CoinsCachePair.adoc[`CoinsCachePair`] 
| Key&hyphen;value pair stored in the coins map, linking an outpoint to its cache entry&period;
| xref:CompressedScript.adoc[`CompressedScript`] 
| This saves us from making many heap allocations when serializing and deserializing compressed scripts&period;
| xref:DNSLookupFn.adoc[`DNSLookupFn`] 
| Function type used to resolve a host name to network addresses&period;
| xref:DataBuffer.adoc[`DataBuffer`] 
| Byte buffer used by the buffered stream wrappers&period;
| xref:ECDHSecret.adoc[`ECDHSecret`] 
| Fixed&hyphen;size buffer holding an ECDH shared secret (ECDH&lowbar;SECRET&lowbar;SIZE bytes)&period;
| xref:ExtPubKeyMap.adoc[`ExtPubKeyMap`] 
| Map from a derivation index to its cached extended public key&period;
| xref:FeePerVSize.adoc[`FeePerVSize`] 
| Fee rate expressed in satoshis per virtual byte&period;
| xref:FeePerWeight.adoc[`FeePerWeight`] 
| Fee rate expressed in satoshis per weight unit&period;
| xref:HTTPRequestHandler.adoc[`HTTPRequestHandler`] 
| Handler for requests to a certain HTTP path
| xref:HelpElision.adoc[`HelpElision`] 
| How a result field is elided in help&colon; printed normally, hidden, or summarized as &quot;&period;&period;&period;&quot;&period;
| xref:HoursDouble.adoc[`HoursDouble`] 
| Duration of hours stored as a double&period;
| xref:KeyFingerprint.adoc[`KeyFingerprint`] 
| The first four bytes of a key identifier, used as a BIP32 parent fingerprint&period;
| xref:LoadWalletFn.adoc[`LoadWalletFn`] 
| Callback invoked when a wallet is loaded, receiving the wallet interface&period;
| xref:LossyChronoFormatter.adoc[`LossyChronoFormatter`] 
| ChronoFormatter alias that allows lossy conversion of the time point representation&period;
| xref:MessageStartChars.adoc[`MessageStartChars`] 
| Four&hyphen;byte magic prefix that starts every P2P network message&period;
| xref:MillisecondsDouble.adoc[`MillisecondsDouble`] 
| Duration of milliseconds stored as a double&period;
| xref:MutableTransactionSignatureChecker.adoc[`MutableTransactionSignatureChecker`] 
| Signature checker bound to a CMutableTransaction&period;
| xref:Mutex.adoc[`Mutex`] 
| Wrapped mutex&colon; supports waiting but not recursive locking
| xref:NodeId-08.adoc[`NodeId`] 
| Type used to uniquely identify a connected peer&period;
| xref:NodeId-03.adoc[`NodeId`] 
| Identifier assigned to a connected peer&period;
| xref:NodeSeconds.adoc[`NodeSeconds`] 
| NodeClock time point measured in whole seconds&period;
| xref:PCPMappingNonce.adoc[`PCPMappingNonce`] 
| PCP mapping nonce&period; Arbitrary data chosen by the client to identify a mapping&period;
| xref:Package.adoc[`Package`] 
| A package is an ordered list of transactions&period; The transactions cannot conflict with (spend the same inputs as) one another&period;
| xref:RPCArgList.adoc[`RPCArgList`] 
| A list of named RPC arguments, each a (name, value) pair&period;
| xref:ReadStatus.adoc[`ReadStatus`] 
| Outcome of reading or reconstructing a compact block&period;
| xref:RecursiveMutex.adoc[`RecursiveMutex`] 
| Wrapped mutex&colon; supports recursive locking, but no waiting TODO&colon; We should move away from using the recursive lock by default&period;
| xref:RpcMethodFnType.adoc[`RpcMethodFnType`] 
| Pointer to a factory function returning the metadata for an RPC method&period;
| xref:SOCKET.adoc[`SOCKET`] 
| Socket descriptor type on non&hyphen;Windows platforms, mapped to the Windows SOCKET handle&period;
| xref:ScriptError.adoc[`ScriptError`] 
| Error codes returned by the Bitcoin Script interpreter&period;
| xref:SecondsDouble.adoc[`SecondsDouble`] 
| Duration of seconds stored as a double&period;
| xref:SecureString.adoc[`SecureString`] 
| A std&colon;&colon;string that keeps its contents in locked, cleared&hyphen;on&hyphen;free memory&period;
| xref:SerializeData.adoc[`SerializeData`] 
| Byte&hyphen;vector that clears its contents before deletion&period;
| xref:SigPair.adoc[`SigPair`] 
| A public key paired with a signature produced for it&period;
| xref:SteadyClock.adoc[`SteadyClock`] 
| The monotonic steady clock&period;
| xref:SteadyMicroseconds.adoc[`SteadyMicroseconds`] 
| Steady clock time point measured in microseconds&period;
| xref:SteadyMilliseconds.adoc[`SteadyMilliseconds`] 
| Steady clock time point measured in milliseconds&period;
| xref:SteadySeconds.adoc[`SteadySeconds`] 
| Steady clock time point measured in whole seconds&period;
| xref:SystemClock.adoc[`SystemClock`] 
| The wall&hyphen;clock system clock&period;
| xref:ThresholdConditionCache.adoc[`ThresholdConditionCache`] 
| Maps a block&apos;s parent to the threshold state for the following period&period;
| xref:TransactionCompression.adoc[`TransactionCompression`] 
| Formatter used to (de)serialize transactions inside compact blocks&period;
| xref:TransactionSignatureChecker.adoc[`TransactionSignatureChecker`] 
| Signature checker bound to an immutable CTransaction&period;
| xref:TranslateFn.adoc[`TranslateFn`] 
| Translate a message to the native language of the user&period;
| xref:Txid.adoc[`Txid`] 
| Txid commits to all transaction fields except the witness&period;
| xref:Wtxid.adoc[`Wtxid`] 
| Wtxid commits to all transaction fields including the witness&period;
| xref:banmap_t.adoc[`banmap&lowbar;t`] 
| Map of banned subnets to their ban entries&period;
| xref:btck_Block-04.adoc[`btck&lowbar;Block`] 
| Opaque data structure for holding a block&period;
| xref:btck_BlockCheckFlags.adoc[`btck&lowbar;BlockCheckFlags`] 
| Bitflags to control context&hyphen;free block checks (optional)&period;
| xref:btck_BlockHash-07.adoc[`btck&lowbar;BlockHash`] 
| Opaque data structure for holding a block hash&period;
| xref:btck_BlockHeader-00.adoc[`btck&lowbar;BlockHeader`] 
| Opaque data structure for holding a btck&lowbar;BlockHeader&period;
| xref:btck_BlockSpentOutputs-0d.adoc[`btck&lowbar;BlockSpentOutputs`] 
| Opaque data structure for holding a block&apos;s spent outputs&period;
| xref:btck_BlockTreeEntry-0c.adoc[`btck&lowbar;BlockTreeEntry`] 
| Opaque data structure for holding a block tree entry&period;
| xref:btck_BlockValidationResult.adoc[`btck&lowbar;BlockValidationResult`] 
| A granular &quot;reason&quot; why a block was invalid&period;
| xref:btck_BlockValidationState-0e.adoc[`btck&lowbar;BlockValidationState`] 
| Opaque data structure for holding the state of a block during validation&period;
| xref:btck_Chain-09.adoc[`btck&lowbar;Chain`] 
| Opaque data structure for holding the currently known best&hyphen;chain associated with a chainstate&period;
| xref:btck_ChainParameters-0f.adoc[`btck&lowbar;ChainParameters`] 
| Opaque data structure for holding the chain parameters&period;
| xref:btck_ChainType.adoc[`btck&lowbar;ChainType`] 
| Identifies which Bitcoin chain (network) a set of chain parameters describes&period;
| xref:btck_ChainstateManager-0e.adoc[`btck&lowbar;ChainstateManager`] 
| Opaque data structure for holding a chainstate manager&period;
| xref:btck_ChainstateManagerOptions-08.adoc[`btck&lowbar;ChainstateManagerOptions`] 
| Opaque data structure for holding options for creating a new chainstate manager&period;
| xref:btck_Coin-0f.adoc[`btck&lowbar;Coin`] 
| Opaque data structure for holding a coin&period;
| xref:btck_ConsensusParams-08.adoc[`btck&lowbar;ConsensusParams`] 
| Opaque data structure for holding the Consensus Params&period;
| xref:btck_Context-07.adoc[`btck&lowbar;Context`] 
| Opaque data structure for holding a kernel context&period;
| xref:btck_ContextOptions-0d.adoc[`btck&lowbar;ContextOptions`] 
| Opaque data structure for holding options for creating a new kernel context&period;
| xref:btck_DestroyCallback.adoc[`btck&lowbar;DestroyCallback`] 
| Function signature for freeing user data&period;
| xref:btck_LogCallback.adoc[`btck&lowbar;LogCallback`] 
| Function signature for the global logging callback&period; All bitcoin kernel internal logs will pass through this callback&period;
| xref:btck_LogCategory.adoc[`btck&lowbar;LogCategory`] 
| A collection of logging categories that may be encountered by kernel code&period;
| xref:btck_LogLevel.adoc[`btck&lowbar;LogLevel`] 
| The level at which logs should be produced&period;
| xref:btck_LoggingConnection-04.adoc[`btck&lowbar;LoggingConnection`] 
| Opaque data structure for holding a logging connection&period;
| xref:btck_NotifyBlockTip.adoc[`btck&lowbar;NotifyBlockTip`] 
| Function signatures for the kernel notifications&period;
| xref:btck_NotifyFatalError.adoc[`btck&lowbar;NotifyFatalError`] 
| Callback invoked on an unrecoverable kernel error&period;
| xref:btck_NotifyFlushError.adoc[`btck&lowbar;NotifyFlushError`] 
| Callback invoked when flushing chainstate data fails&period;
| xref:btck_NotifyHeaderTip.adoc[`btck&lowbar;NotifyHeaderTip`] 
| Callback invoked when a new best header tip is seen during sync&period;
| xref:btck_NotifyProgress.adoc[`btck&lowbar;NotifyProgress`] 
| Callback reporting validation or sync progress as a percentage&period;
| xref:btck_NotifyWarningSet.adoc[`btck&lowbar;NotifyWarningSet`] 
| Callback invoked when a kernel warning is raised&period;
| xref:btck_NotifyWarningUnset.adoc[`btck&lowbar;NotifyWarningUnset`] 
| Callback invoked when a previously raised kernel warning is cleared&period;
| xref:btck_PrecomputedTransactionData-00.adoc[`btck&lowbar;PrecomputedTransactionData`] 
| Opaque data structure for holding precomputed transaction data&period;
| xref:btck_ScriptPubkey-0e.adoc[`btck&lowbar;ScriptPubkey`] 
| Opaque data structure for holding a script pubkey&period;
| xref:btck_ScriptVerificationFlags.adoc[`btck&lowbar;ScriptVerificationFlags`] 
| Script verification flags that may be composed with each other&period;
| xref:btck_ScriptVerifyStatus.adoc[`btck&lowbar;ScriptVerifyStatus`] 
| A collection of status codes that may be issued by the script verify function&period;
| xref:btck_SynchronizationState.adoc[`btck&lowbar;SynchronizationState`] 
| Current sync state passed to tip changed callbacks&period;
| xref:btck_Transaction-08.adoc[`btck&lowbar;Transaction`] 
| Opaque data structure for holding a transaction&period;
| xref:btck_TransactionInput-01.adoc[`btck&lowbar;TransactionInput`] 
| Opaque data structure for holding a transaction input&period;
| xref:btck_TransactionOutPoint-09.adoc[`btck&lowbar;TransactionOutPoint`] 
| Opaque data structure for holding a transaction out point&period;
| xref:btck_TransactionOutput-0d.adoc[`btck&lowbar;TransactionOutput`] 
| Opaque data structure for holding a transaction output&period;
| xref:btck_TransactionSpentOutputs-05.adoc[`btck&lowbar;TransactionSpentOutputs`] 
| Opaque data structure for holding a transaction&apos;s spent outputs&period;
| xref:btck_TxValidationResult.adoc[`btck&lowbar;TxValidationResult`] 
| Indicates the reason why a transaction failed validation&period; The subset of values reachable depends on which validation function was used&period;
| xref:btck_TxValidationState-06.adoc[`btck&lowbar;TxValidationState`] 
| Opaque data structure for holding the state of a transaction during validation&period;
| xref:btck_Txid-0e.adoc[`btck&lowbar;Txid`] 
| Opaque data structure for holding a btck&lowbar;Txid&period;
| xref:btck_ValidationInterfaceBlockChecked.adoc[`btck&lowbar;ValidationInterfaceBlockChecked`] 
| Function signatures for the validation interface&period;
| xref:btck_ValidationInterfaceBlockConnected.adoc[`btck&lowbar;ValidationInterfaceBlockConnected`] 
| Callback when a block is connected to the active chain&period;
| xref:btck_ValidationInterfaceBlockDisconnected.adoc[`btck&lowbar;ValidationInterfaceBlockDisconnected`] 
| Callback when a block is disconnected from the active chain&period;
| xref:btck_ValidationInterfacePoWValidBlock.adoc[`btck&lowbar;ValidationInterfacePoWValidBlock`] 
| Callback when a proof&hyphen;of&hyphen;work valid block is accepted into the tree&period;
| xref:btck_ValidationMode.adoc[`btck&lowbar;ValidationMode`] 
| Whether a validated data structure is valid, invalid, or an error was encountered during processing&period;
| xref:btck_Warning.adoc[`btck&lowbar;Warning`] 
| Possible warning types issued by validation&period;
| xref:btck_WitnessStack-0e.adoc[`btck&lowbar;WitnessStack`] 
| Opaque data structure for holding a witness stack&period;
| xref:btck_WriteBytes.adoc[`btck&lowbar;WriteBytes`] 
| Function signature for serializing data&period;
| xref:mapMsgTypeSize.adoc[`mapMsgTypeSize`] 
| Maps a message type to the total number of bytes seen for it&period;
| xref:secp256k1_context.adoc[`secp256k1&lowbar;context`] 
| Handle to an opaque libsecp256k1 context&period;
| xref:secure_unique_ptr.adoc[`secure&lowbar;unique&lowbar;ptr`] 
| A unique&lowbar;ptr whose managed object lives in secure memory and is securely freed&period;
|===


== Enums

[cols="1,4"]
|===
| Name| Description
| xref:_04enum-01.adoc[`Unnamed enum`] 
| How a local address became known, from least to most trusted&period;
| xref:_04enum-07.adoc[`Unnamed enum`] 
| Signature hash types&sol;flags
| xref:Assumeutxo.adoc[`Assumeutxo`] 
| Chainstate assumeutxo validity&period;
| xref:AuthCookieResult.adoc[`AuthCookieResult`] 
| Outcome of generating or reading the RPC authentication cookie&period;
| xref:BlockFilterType.adoc[`BlockFilterType`] 
| Identifies the kind of block filter, controlling which data it indexes&period;
| xref:BlockPolicyEstimateReason.adoc[`BlockPolicyEstimateReason`] 
| Enumeration of reason for returned fee estimate&period;
| xref:BlockStatus.adoc[`BlockStatus`] 
| Bit flags describing how far a block has been validated and which data is available for it&period;
| xref:BlockValidationResult.adoc[`BlockValidationResult`] 
| A &quot;reason&quot; why a block was invalid, suitable for determining whether the provider of the block should be banned&sol;ignored&sol;disconnected&sol;etc&period; These are much more granular than the rejection codes, which may be more useful for some other use&hyphen;cases&period;
| xref:ByteUnit.adoc[`ByteUnit`] 
| Used by ParseByteUnits() Lowercase base 1000 Uppercase base 1024
| xref:ChainType.adoc[`ChainType`] 
| Identifies which Bitcoin chain a node operates on&period;
| xref:ChangeType.adoc[`ChangeType`] 
| General change type (added, updated, removed)&period;
| xref:CoinsCacheSizeState.adoc[`CoinsCacheSizeState`] 
| How full the in&hyphen;memory coins cache is relative to its budget&period;
| xref:ConnectionDirection.adoc[`ConnectionDirection`] 
| Bit flags describing the direction of a connection&period;
| xref:ConnectionType.adoc[`ConnectionType`] 
| Different types of connections to a peer&period; This enum encapsulates the information we have available at the time of opening or accepting the connection&period; Aside from INBOUND, all types are initiated by us&period;
| xref:DiagramCheckError.adoc[`DiagramCheckError`] 
| Reason a feerate diagram comparison could not confirm an improvement&period;
| xref:DisconnectResult.adoc[`DisconnectResult`] 
| Outcome of disconnecting a block from the UTXO set&period;
| xref:ElisionMode.adoc[`ElisionMode`] 
| How top&hyphen;level fields are elided when rendering transaction help&period;
| xref:FeeEstimateHorizon.adoc[`FeeEstimateHorizon`] 
| Identifier for each of the 3 different TxConfirmStats which track history over different time horizons&period;
| xref:FeeEstimateMode.adoc[`FeeEstimateMode`] 
| Used to determine type of fee estimation requested
| xref:FeeRateEstimatorType.adoc[`FeeRateEstimatorType`] 
| Identifier for fee rate estimator&period;
| xref:FeeRateFormat.adoc[`FeeRateFormat`] 
| Selects the unit used when formatting a fee rate as text&period;
| xref:FeeReason.adoc[`FeeReason`] 
| Used to determine the reason a wallet selected a transaction fee rate
| xref:FlushStateMode.adoc[`FlushStateMode`] 
| How aggressively FlushStateToDisk should flush chainstate to disk&period;
| xref:GetDataMsg.adoc[`GetDataMsg`] 
| getdata &sol; inv message types&period; These numbers are defined by the protocol&period; When adding a new value, be sure to mention it in the respective BIP&period;
| xref:HTTPRequestMethod.adoc[`HTTPRequestMethod`] 
| HTTP request method parsed from a request line&period;
| xref:HTTPStatusCode.adoc[`HTTPStatusCode`] 
| HTTP status codes
| xref:JSONRPCVersion.adoc[`JSONRPCVersion`] 
| Version of the JSON&hyphen;RPC protocol a request or reply uses&period;
| xref:MappingError.adoc[`MappingError`] 
| Unsuccessful response to a port mapping&period;
| xref:MemPoolRemovalReason.adoc[`MemPoolRemovalReason`] 
| Reason why a transaction was removed from the mempool, this is passed to the notification signal&period;
| xref:MessageVerificationResult.adoc[`MessageVerificationResult`] 
| The result of a signed message verification&period; Message verification takes as an input&colon; &hyphen; address (with whose private key the message is supposed to have been signed) &hyphen; signature &hyphen; message
| xref:MissingDataBehavior.adoc[`MissingDataBehavior`] 
| Enum to specify what &ast;TransactionSignatureChecker&apos;s behavior should be when dealing with missing transaction data&period;
| xref:NetPermissionFlags.adoc[`NetPermissionFlags`] 
| Fine&hyphen;grained permissions granted to a peer via &hyphen;whitebind or &hyphen;whitelist&period;
| xref:Network.adoc[`Network`] 
| A network type&period;
| xref:OptionsCategory.adoc[`OptionsCategory`] 
| Grouping used to organize options in the help output&period;
| xref:OuterType.adoc[`OuterType`] 
| Serializing JSON objects depends on the outer type&period; Only arrays and dictionaries can be nested in json&period; The top&hyphen;level outer type is &quot;NONE&quot;&period;
| xref:OutputType.adoc[`OutputType`] 
| Address encoding to use for a newly generated destination&period;
| xref:PSBTRole.adoc[`PSBTRole`] 
| The roles a participant can play when processing a PSBT&period;
| xref:PackageValidationResult.adoc[`PackageValidationResult`] 
| A &quot;reason&quot; why a package was invalid&period; It may be that one or more of the included transactions is invalid or the package itself violates our rules&period; We don&apos;t distinguish between consensus and policy violations right now&period;
| xref:RBFTransactionState.adoc[`RBFTransactionState`] 
| The rbf state of unconfirmed transactions
| xref:RESTResponseFormat.adoc[`RESTResponseFormat`] 
| Response body format requested from the REST interface&period;
| xref:ReadStatus_t.adoc[`ReadStatus&lowbar;t`] 
| Outcome of reading or reconstructing a compact block&period;
| xref:ReconciliationRegisterResult.adoc[`ReconciliationRegisterResult`] 
| Outcome of trying to register a peer for transaction reconciliation&period;
| xref:SafeChars.adoc[`SafeChars`] 
| Used by SanitizeString()
| xref:ScriptError_t.adoc[`ScriptError&lowbar;t`] 
| Error codes returned by the Bitcoin Script interpreter&period;
| xref:ServiceFlags.adoc[`ServiceFlags`] 
| nServices flags
| xref:SigVersion.adoc[`SigVersion`] 
| Script execution context that selects the signature&hyphen;hashing scheme&period;
| xref:SigningResult.adoc[`SigningResult`] 
| Outcome of an attempt to sign a message&period;
| xref:SnapshotCompletionResult.adoc[`SnapshotCompletionResult`] 
| Outcome of attempting to complete validation of an assumeutxo snapshot&period;
| xref:SynchronizationState.adoc[`SynchronizationState`] 
| Stage of block synchronization the node is currently in&period;
| xref:ThresholdState.adoc[`ThresholdState`] 
| Opaque type for BIP9 state&period; See versionbits&lowbar;impl&period;h for details&period;
| xref:TransportProtocolType.adoc[`TransportProtocolType`] 
| Transport layer version
| xref:TxValidationResult.adoc[`TxValidationResult`] 
| A &quot;reason&quot; why a transaction was invalid, suitable for determining whether the provider of the transaction should be banned&sol;ignored&sol;disconnected&sol;etc&period;
| xref:TxVerbosity.adoc[`TxVerbosity`] 
| Verbose level for block&apos;s transaction
| xref:TxoutType.adoc[`TxoutType`] 
| Classification of a scriptPubKey into a standard output type&period;
| xref:VarIntMode.adoc[`VarIntMode`] 
| Mode for encoding VarInts&period;
| xref:VerifyDBResult.adoc[`VerifyDBResult`] 
| Outcome of verifying the consistency of the block and coin databases&period;
| xref:bloomflags.adoc[`bloomflags`] 
| First two bits of nFlags control how much IsRelevantAndUpdate actually updates The remaining bits are reserved
| xref:opcodetype.adoc[`opcodetype`] 
| Script opcodes
| xref:script_verify_flag_name.adoc[`script&lowbar;verify&lowbar;flag&lowbar;name`] 
| Names of the individual SCRIPT&lowbar;VERIFY&lowbar;&ast; verification flags (forward declaration)&period;
|===


== Functions

[cols="1,4"]
|===
| Name| Description
| xref:AbsPathForConfigVal.adoc[`AbsPathForConfigVal`] 
| Most paths passed as configuration arguments are treated as relative to the datadir if they are not absolute&period;
| xref:AcceptToMemoryPool.adoc[`AcceptToMemoryPool`] 
| Try to add a transaction to the mempool&period; This is an internal function and is exposed only for testing&period; Client code should use ChainstateManager&colon;&colon;ProcessTransaction()
| xref:AccessByTxid.adoc[`AccessByTxid`] 
| Utility function to find any unspent output with a given txid&period; This function can be quite expensive because in the event of a transaction which is not found in the cache, it can cause up to MAX&lowbar;OUTPUTS&lowbar;PER&lowbar;BLOCK lookups to database, so it should be used with care&period;
| xref:AddAndGetDestinationForScript.adoc[`AddAndGetDestinationForScript`] 
| Get a destination of the requested type (if possible) to the specified script&period; This function will automatically add the script (and any other necessary scripts) to the keystore&period;
| xref:AddAndGetMultisigDestination.adoc[`AddAndGetMultisigDestination`] 
| Build a multisig destination and add its keys and script to the keystore&period;
| xref:AddCoins.adoc[`AddCoins`] 
| Utility function to add all of a transaction&apos;s outputs to a cache&period; When check is false, this assumes that overwrites are only possible for coinbase transactions&period; When check is true, the underlying view may be queried to determine whether an addition is an overwrite&period;
| xref:AddInputs.adoc[`AddInputs`] 
| Normalize univalue&hyphen;represented inputs and add them to the transaction
| xref:AddLocal-06.adoc[`AddLocal`] 
| `AddLocal` overloads
| xref:AddOutputs.adoc[`AddOutputs`] 
| Normalize, parse, and add outputs to the transaction
| xref:AdditionOverflow.adoc[`AdditionOverflow`] 
| Test whether the sum of two integers would overflow&period;
| xref:AllBlockFilterTypes.adoc[`AllBlockFilterTypes`] 
| Get a list of known filter types&period;
| xref:AllocateFileRange.adoc[`AllocateFileRange`] 
| Pre&hyphen;allocate a range of a file so later writes into it do not fragment or fail&period;
| xref:AmountFromValue.adoc[`AmountFromValue`] 
| Validate and return a CAmount from a UniValue number or string&period;
| xref:AppInitBasicSetup.adoc[`AppInitBasicSetup`] 
| Initialize bitcoin core&colon; Basic context setup&period;
| xref:AppInitInterfaces.adoc[`AppInitInterfaces`] 
| Initialize node and wallet interface pointers&period; Has no prerequisites or side effects besides allocating memory&period;
| xref:AppInitLockDirectories.adoc[`AppInitLockDirectories`] 
| Lock bitcoin core critical directories&period;
| xref:AppInitMain.adoc[`AppInitMain`] 
| Bitcoin core main initialization&period;
| xref:AppInitParameterInteraction.adoc[`AppInitParameterInteraction`] 
| Initialization&colon; parameter interaction&period;
| xref:AppInitSanityChecks.adoc[`AppInitSanityChecks`] 
| Initialization sanity checks&period;
| xref:ApplyArgsManOptions.adoc[`ApplyArgsManOptions`] 
| Overlay the options set in `argsman` on top of corresponding members in `mempool&lowbar;opts&period;` Returns an error if one was encountered&period;
| xref:ArithToUint256.adoc[`ArithToUint256`] 
| Converts an arithmetic 256&hyphen;bit integer to a uint256 blob&period;
| xref:AsBase-0a0.adoc[`AsBase`] 
| `AsBase` overloads
| xref:AsmapVersion.adoc[`AsmapVersion`] 
| Calculate the asmap version, a checksum identifying the asmap being used&period;
| xref:AssertLockHeldInternal.adoc[`AssertLockHeldInternal`] 
| Assert that the given mutex is held by the current thread&period;
| xref:AssertLockNotHeldInline-0cc.adoc[`AssertLockNotHeldInline`] 
| `AssertLockNotHeldInline` overloads
| xref:AssertLockNotHeldInternal.adoc[`AssertLockNotHeldInternal`] 
| Assert that the given mutex is not held by the current thread&period;
| xref:BIP32Hash.adoc[`BIP32Hash`] 
| Computes the BIP32 child key derivation hash&period;
| xref:BanMapFromJson.adoc[`BanMapFromJson`] 
| Convert a JSON array to a `banmap&lowbar;t` object&period;
| xref:BanMapToJson.adoc[`BanMapToJson`] 
| Convert a `banmap&lowbar;t` object to a JSON array&period;
| xref:BaseParams.adoc[`BaseParams`] 
| Return the currently selected parameters&period; This won&apos;t change after app startup, except for unit tests&period;
| xref:BitsToBytes.adoc[`BitsToBytes`] 
| Pack a vector of bits into bytes, eight bits per byte, least significant bit first&period;
| xref:BlockFilterTypeByName.adoc[`BlockFilterTypeByName`] 
| Find a filter type by its human&hyphen;readable name&period;
| xref:BlockFilterTypeName.adoc[`BlockFilterTypeName`] 
| Get the human&hyphen;readable name for a filter type&period; Returns empty string for unknown types&period;
| xref:BlockMerkleRoot.adoc[`BlockMerkleRoot`] 
| Compute the Merkle root of the transactions in a block&period; &ast;mutated is set to true if a duplicated subtree was found&period;
| xref:BlockPolicyFeeEstPath.adoc[`BlockPolicyFeeEstPath`] 
| Path of the block policy fee estimator data file&period;
| xref:BlockWitnessMerkleRoot.adoc[`BlockWitnessMerkleRoot`] 
| Compute the Merkle root of the witness transactions in a block&period;
| xref:BuildScript.adoc[`BuildScript`] 
| Build a script by concatenating other scripts, or any argument accepted by CScript&colon;&colon;operator&lt;&lt;&period;
| xref:BytesToBits.adoc[`BytesToBits`] 
| Unpack bytes into a vector of bits, eight bits per byte, least significant bit first&period;
| xref:CalculateClaimedHeadersWork.adoc[`CalculateClaimedHeadersWork`] 
| Return the sum of the claimed work on a given set of headers&period; No verification of PoW is done&period;
| xref:CalculateLockPointsAtTip.adoc[`CalculateLockPointsAtTip`] 
| Calculate LockPoints required to check if transaction will be BIP68 final in the next block to be created on top of tip&period;
| xref:CalculateNextWorkRequired.adoc[`CalculateNextWorkRequired`] 
| Compute the retargeted proof&hyphen;of&hyphen;work target after a difficulty adjustment interval&period;
| xref:CalculateOutputValue.adoc[`CalculateOutputValue`] 
| Sums the value of all outputs of a transaction&period;
| xref:CalculatePercentilesByWeight.adoc[`CalculatePercentilesByWeight`] 
| Used by getblockstats to get feerates at different percentiles by weight
| xref:CalculateSequenceLocks.adoc[`CalculateSequenceLocks`] 
| Calculates the block height and previous block&apos;s median time past at which the transaction will be considered final in the context of BIP 68&period; For each input that is not sequence locked, the corresponding entries in prevHeights are set to 0 as they do not affect the calculation&period;
| xref:Capitalize.adoc[`Capitalize`] 
| Capitalizes the first character of the given string&period; This function is locale independent&period; It only converts lowercase characters in the standard 7&hyphen;bit ASCII range&period; This is a feature, not a limitation&period;
| xref:CaseInsensitiveEqual.adoc[`CaseInsensitiveEqual`] 
| Locale&hyphen;independent, ASCII&hyphen;only comparator
| xref:Cat-05a.adoc[`Cat`] 
| `Cat` overloads
| xref:CeilDiv.adoc[`CeilDiv`] 
| Integer ceiling division (for unsigned values)&period;
| xref:ChainTypeFromString.adoc[`ChainTypeFromString`] 
| Parse a chain type from its canonical string name&period;
| xref:ChainTypeToString.adoc[`ChainTypeToString`] 
| Convert a chain type to its canonical string name&period;
| xref:CheckBlock.adoc[`CheckBlock`] 
| Context&hyphen;independent validity checks&period;
| xref:CheckBlockDataAvailability.adoc[`CheckBlockDataAvailability`] 
| Check that a block&apos;s data (and optionally undo data) is available on disk&period;
| xref:CheckDataDirOption.adoc[`CheckDataDirOption`] 
| Return true if &hyphen;datadir option points to a valid directory or is not specified&period;
| xref:CheckDiskSpace.adoc[`CheckDiskSpace`] 
| Check that a directory has enough free space for an additional write&period;
| xref:CheckEphemeralSpends.adoc[`CheckEphemeralSpends`] 
| Called for each transaction(package) if any dust is in the package&period; Checks that each transaction&apos;s parents have their dust spent by the child, where parents are either in the mempool or in the package itself&period; Sets out&lowbar;child&lowbar;state and out&lowbar;child&lowbar;wtxid on failure&period;
| xref:CheckFinalTxAtTip.adoc[`CheckFinalTxAtTip`] 
| Check if transaction will be final in the next block to be created&period;
| xref:CheckLastCritical.adoc[`CheckLastCritical`] 
| Verify that the most recently entered critical section matches the given mutex&period;
| xref:CheckMinimalPush.adoc[`CheckMinimalPush`] 
| Checks whether pushed data uses the minimal encoding for its opcode&period;
| xref:CheckProofOfWork.adoc[`CheckProofOfWork`] 
| Check whether a block hash satisfies the proof&hyphen;of&hyphen;work requirement specified by nBits
| xref:CheckProofOfWorkImpl.adoc[`CheckProofOfWorkImpl`] 
| Implementation of CheckProofOfWork that verifies a hash against a compact target&period;
| xref:CheckSequenceLocksAtTip.adoc[`CheckSequenceLocksAtTip`] 
| Check if transaction will be BIP68 final in the next block to be created on top of tip&period;
| xref:CheckSignatureEncoding.adoc[`CheckSignatureEncoding`] 
| Check that a signature uses a valid encoding for the given verification flags&period;
| xref:CheckSignetBlockSolution.adoc[`CheckSignetBlockSolution`] 
| Extract signature and check whether a block has a valid solution
| xref:CheckStandardAsmap.adoc[`CheckStandardAsmap`] 
| Check standard asmap data (128 bits for IPv6)&period;
| xref:CheckTransaction.adoc[`CheckTransaction`] 
| Performs context&hyphen;independent validity checks on a transaction&period;
| xref:CheckedAdd.adoc[`CheckedAdd`] 
| Add two integers, checking for overflow&period;
| xref:CheckedLeftShift.adoc[`CheckedLeftShift`] 
| Left bit shift with overflow checking&period;
| xref:ClearLocal.adoc[`ClearLocal`] 
| Forget all known local addresses&period;
| xref:ClearShrink.adoc[`ClearShrink`] 
| Clear a vector (or std&colon;&colon;deque) and release its allocated memory&period;
| xref:CombinePSBTs.adoc[`CombinePSBTs`] 
| Combines PSBTs with the same underlying transaction, resulting in a single PSBT with all partial signatures from each input&period;
| xref:CompareChunks.adoc[`CompareChunks`] 
| Compare the feerate diagrams implied by the provided sorted chunks data&period;
| xref:CompressAmount.adoc[`CompressAmount`] 
| Compress amount&period;
| xref:CompressScript.adoc[`CompressScript`] 
| Compresses a script into the compact on&hyphen;disk representation&period;
| xref:ComputeMerkleRoot.adoc[`ComputeMerkleRoot`] 
| Compute a Merkle root from the provided leaf hashes&period; If non&hyphen;null, `&ast;mutated` is set to true if two identical hashes are paired at any tree level before the odd&hyphen;count hash duplication step, and false otherwise&period;
| xref:ComputeTapbranchHash.adoc[`ComputeTapbranchHash`] 
| Compute the BIP341 tapbranch hash from two branches&period; Spans must be 32 bytes each&period;
| xref:ComputeTapleafHash.adoc[`ComputeTapleafHash`] 
| Compute the BIP341 tapleaf hash from leaf version &amp; script&period;
| xref:ComputeTaprootMerkleRoot.adoc[`ComputeTaprootMerkleRoot`] 
| Compute the BIP341 taproot script tree Merkle root from control block and leaf hash&period; Requires control block to have valid length (33 &plus; k&ast;32, with k in &lcub;0,1,&period;&period;,128&rcub;)&period;
| xref:ConnectDirectly-00.adoc[`ConnectDirectly`] 
| `ConnectDirectly` overloads
| xref:ConnectThroughProxy.adoc[`ConnectThroughProxy`] 
| Connect to a specified destination service through a SOCKS5 proxy by first connecting to the SOCKS5 proxy&period;
| xref:ConnectionTypeAsString.adoc[`ConnectionTypeAsString`] 
| Convert ConnectionType enum to a string value
| xref:ConstructTransaction.adoc[`ConstructTransaction`] 
| Create a transaction from univalue parameters
| xref:ConvertBits.adoc[`ConvertBits`] 
| Convert from one power&hyphen;of&hyphen;2 number base to another&period;
| xref:CopyrightHolders.adoc[`CopyrightHolders`] 
| Build the multi&hyphen;line copyright holders string&period;
| xref:CountPSBTUnsignedInputs.adoc[`CountPSBTUnsignedInputs`] 
| Counts the unsigned inputs of a PSBT&period;
| xref:CountWitnessSigOps.adoc[`CountWitnessSigOps`] 
| Count the signature operations contributed by a witness spend&period;
| xref:CreateBaseChainParams.adoc[`CreateBaseChainParams`] 
| Creates and returns a std&colon;&colon;unique&lowbar;ptr&lt;CBaseChainParams&gt; of the chosen chain&period;
| xref:CreateChainParams.adoc[`CreateChainParams`] 
| Creates and returns a std&colon;&colon;unique&lowbar;ptr&lt;CChainParams&gt; of the chosen chain&period;
| xref:CreateMuSig2AggregateSig.adoc[`CreateMuSig2AggregateSig`] 
| Combine the participants&apos; partial signatures into a final MuSig2 aggregate signature&period;
| xref:CreateMuSig2Nonce.adoc[`CreateMuSig2Nonce`] 
| Generate a MuSig2 public nonce for a signing session and store the matching secret nonce&period;
| xref:CreateMuSig2PartialSig.adoc[`CreateMuSig2PartialSig`] 
| Produce this participant&apos;s MuSig2 partial signature for the session&period;
| xref:CreateMuSig2SyntheticXpub.adoc[`CreateMuSig2SyntheticXpub`] 
| Construct the BIP 328 synthetic xpub for a pubkey
| xref:CreateSockOS.adoc[`CreateSockOS`] 
| Create a real socket from the operating system&period;
| xref:CreateUTXOSnapshot.adoc[`CreateUTXOSnapshot`] 
| Helper to create UTXO snapshots given a chainstate and a file handle&period;
| xref:DataFromTransaction.adoc[`DataFromTransaction`] 
| Extract signature data from a transaction input, and insert it&period;
| xref:DecodeAsmap.adoc[`DecodeAsmap`] 
| Read and check asmap from provided binary file&period;
| xref:DecodeBase32.adoc[`DecodeBase32`] 
| Decode a base32&hyphen;encoded string&period;
| xref:DecodeBase58.adoc[`DecodeBase58`] 
| Decode a base58&hyphen;encoded string (str) into a byte vector (vchRet)&period; return true if decoding is successful&period;
| xref:DecodeBase58Check.adoc[`DecodeBase58Check`] 
| Decode a base58&hyphen;encoded string (str) that includes a checksum into a byte vector (vchRet), return true if decoding is successful
| xref:DecodeBase64.adoc[`DecodeBase64`] 
| Decode a base64&hyphen;encoded string&period;
| xref:DecodeBase64PSBT.adoc[`DecodeBase64PSBT`] 
| Decode a base64&hyphen;encoded PSBT into a PartiallySignedTransaction&period;
| xref:DecodeDestination-01.adoc[`DecodeDestination`] 
| `DecodeDestination` overloads
| xref:DecodeDouble.adoc[`DecodeDouble`] 
| Decode a double from its IEEE 754 binary64 representation&period;
| xref:DecodeExtKey.adoc[`DecodeExtKey`] 
| Decode a Base58Check&hyphen;encoded extended private key&period;
| xref:DecodeExtPubKey.adoc[`DecodeExtPubKey`] 
| Decode a Base58Check&hyphen;encoded extended public key&period;
| xref:DecodeHexBlk.adoc[`DecodeHexBlk`] 
| Decode a hex&hyphen;encoded serialized block&period;
| xref:DecodeHexBlockHeader.adoc[`DecodeHexBlockHeader`] 
| Decode a hex&hyphen;encoded serialized block header&period;
| xref:DecodeHexTx.adoc[`DecodeHexTx`] 
| Decode a hex&hyphen;encoded serialized transaction&period;
| xref:DecodeRawPSBT.adoc[`DecodeRawPSBT`] 
| Decode a raw binary PSBT into a PartiallySignedTransaction&period;
| xref:DecodeSecret.adoc[`DecodeSecret`] 
| Decode a WIF&hyphen;encoded private key&period;
| xref:DecompressAmount.adoc[`DecompressAmount`] 
| Reverses CompressAmount, recovering the original amount in satoshis&period;
| xref:DecompressScript.adoc[`DecompressScript`] 
| Reconstructs a script from its compressed representation&period;
| xref:DefaultOnionServiceTarget.adoc[`DefaultOnionServiceTarget`] 
| Build the default local target address for the onion service&period;
| xref:DeleteAuthCookie.adoc[`DeleteAuthCookie`] 
| Delete RPC authentication cookie from disk
| xref:DeleteLock.adoc[`DeleteLock`] 
| Remove all lock&hyphen;order bookkeeping for the given mutex&period;
| xref:DeploymentActiveAfter-0e.adoc[`DeploymentActiveAfter`] 
| `DeploymentActiveAfter` overloads
| xref:DeploymentActiveAt-01a.adoc[`DeploymentActiveAt`] 
| `DeploymentActiveAt` overloads
| xref:DeploymentEnabled-0c.adoc[`DeploymentEnabled`] 
| `DeploymentEnabled` overloads
| xref:DeploymentName-06.adoc[`DeploymentName`] 
| `DeploymentName` overloads
| xref:DeriveExtKey.adoc[`DeriveExtKey`] 
| Get extended key and origin info for a given path
| xref:DeriveTarget.adoc[`DeriveTarget`] 
| Convert nBits value to target&period;
| xref:DescribeAddress.adoc[`DescribeAddress`] 
| Describe an address as a JSON object for RPC output&period;
| xref:DescriptorID.adoc[`DescriptorID`] 
| Unique identifier that may not change over time, unless explicitly marked as not backwards compatible&period; This is not part of BIP 380, not guaranteed to be interoperable and should not be exposed to the user&period;
| xref:DeserializeHDKeypath.adoc[`DeserializeHDKeypath`] 
| Deserialize a length&hyphen;prefixed KeyOriginInfo from a stream&period;
| xref:DeserializeHDKeypaths.adoc[`DeserializeHDKeypaths`] 
| Deserialize an HD keypath and insert it into a map keyed by public key&period;
| xref:DeserializeKeyOrigin.adoc[`DeserializeKeyOrigin`] 
| Deserialize a fixed number of bytes from a stream as a KeyOriginInfo&period;
| xref:DeserializeMuSig2ParticipantDataIdentifier.adoc[`DeserializeMuSig2ParticipantDataIdentifier`] 
| Deserialize the MuSig2 participant identifiers from a PSBT MuSig2 field&period;
| xref:DeserializeMuSig2ParticipantPubkeys.adoc[`DeserializeMuSig2ParticipantPubkeys`] 
| Deserialize a PSBT&lowbar;&lcub;IN,OUT&rcub;&lowbar;MUSIG2&lowbar;PARTICIPANT&lowbar;PUBKEYS field&period;
| xref:DestroyAllBlockFilterIndexes.adoc[`DestroyAllBlockFilterIndexes`] 
| Destroy all open block filter indexes&period;
| xref:DestroyBlockFilterIndex.adoc[`DestroyBlockFilterIndex`] 
| Destroy the block filter index with the given type&period; Returns false if no such index exists&period; This just releases the allocated memory and closes the database connection, it does not delete the index data&period;
| xref:DestroyDB.adoc[`DestroyDB`] 
| Destroys the LevelDB database stored at the given path&period;
| xref:DirectoryCommit.adoc[`DirectoryCommit`] 
| Sync directory contents&period; This is required on some environments to ensure that newly created files are committed to disk&period;
| xref:Discover.adoc[`Discover`] 
| Look up IP addresses from all interfaces on the machine and add them to the list of local addresses to self&hyphen;advertise&period; The loopback interface is skipped&period;
| xref:DumpAnchors.adoc[`DumpAnchors`] 
| Dump the anchor IP address database (anchors&period;dat)
| xref:DumpPeerAddresses.adoc[`DumpPeerAddresses`] 
| Writes the peer address database (peers&period;dat) to disk&period;
| xref:ECC_InitSanityCheck.adoc[`ECC&lowbar;InitSanityCheck`] 
| Check that required EC support is available at runtime&period;
| xref:ElideGroup.adoc[`ElideGroup`] 
| Stamp elision onto an entire vector of RPCResult fields at once&period; Merges into existing m&lowbar;opts so that flags like skip&lowbar;type&lowbar;check are preserved&period;
| xref:EnableFuzzDeterminism.adoc[`EnableFuzzDeterminism`] 
| Report whether fuzz determinism is currently enabled&period;
| xref:EncodeBase32-0b.adoc[`EncodeBase32`] 
| Base32 encode&period; If `pad` is true, then the output will be padded with &apos;&equals;&apos; so that its length is a multiple of 8&period;
| xref:EncodeBase58.adoc[`EncodeBase58`] 
| Encode a byte span as a base58&hyphen;encoded string
| xref:EncodeBase58Check.adoc[`EncodeBase58Check`] 
| Encode a byte span into a base58&hyphen;encoded string, including checksum
| xref:EncodeBase64-0a.adoc[`EncodeBase64`] 
| `EncodeBase64` overloads
| xref:EncodeDestination.adoc[`EncodeDestination`] 
| Encode a destination as an address string&period;
| xref:EncodeDouble.adoc[`EncodeDouble`] 
| Encode a double using the IEEE 754 binary64 format&period;
| xref:EncodeExtKey.adoc[`EncodeExtKey`] 
| Encode an extended private key in Base58Check format&period;
| xref:EncodeExtPubKey.adoc[`EncodeExtPubKey`] 
| Encode an extended public key in Base58Check format&period;
| xref:EncodeHexTx.adoc[`EncodeHexTx`] 
| Serialize a transaction and encode it as a hex string&period;
| xref:EncodeSecret.adoc[`EncodeSecret`] 
| Encode a private key in WIF format&period;
| xref:EnsureAddrman.adoc[`EnsureAddrman`] 
| Get the address manager from a node context, asserting it is present&period;
| xref:EnsureAnyAddrman.adoc[`EnsureAnyAddrman`] 
| Get the address manager from an opaque RPC context, asserting it is present&period;
| xref:EnsureAnyArgsman.adoc[`EnsureAnyArgsman`] 
| Get the argument manager from an opaque RPC context, asserting it is present&period;
| xref:EnsureAnyBanman.adoc[`EnsureAnyBanman`] 
| Get the ban manager from an opaque RPC context, asserting it is present&period;
| xref:EnsureAnyChainman.adoc[`EnsureAnyChainman`] 
| Get the chainstate manager from an opaque RPC context, asserting it is present&period;
| xref:EnsureAnyFeeEstimatorMan.adoc[`EnsureAnyFeeEstimatorMan`] 
| Get the fee estimator from an opaque RPC context, asserting it is present&period;
| xref:EnsureAnyMemPool.adoc[`EnsureAnyMemPool`] 
| Get the mempool from an opaque RPC context, asserting it is present&period;
| xref:EnsureAnyNodeContext.adoc[`EnsureAnyNodeContext`] 
| Extract the node context from an opaque RPC context, asserting it is present&period;
| xref:EnsureArgsman.adoc[`EnsureArgsman`] 
| Get the argument manager from a node context, asserting it is present&period;
| xref:EnsureBanman.adoc[`EnsureBanman`] 
| Get the ban manager from a node context, asserting it is present&period;
| xref:EnsureChainman.adoc[`EnsureChainman`] 
| Get the chainstate manager from a node context, asserting it is present&period;
| xref:EnsureConnman.adoc[`EnsureConnman`] 
| Get the connection manager from a node context, asserting it is present&period;
| xref:EnsureFeeEstimatorMan.adoc[`EnsureFeeEstimatorMan`] 
| Get the fee estimator from a node context, asserting it is present&period;
| xref:EnsureMemPool.adoc[`EnsureMemPool`] 
| Get the mempool from a node context, asserting it is present&period;
| xref:EnsureMining.adoc[`EnsureMining`] 
| Get the mining interface from a node context, asserting it is present&period;
| xref:EnsurePeerman.adoc[`EnsurePeerman`] 
| Get the peer manager from a node context, asserting it is present&period;
| xref:EnterCritical.adoc[`EnterCritical`] 
| Register that a critical section is being entered, for lock&hyphen;order checking&period;
| xref:EntriesAndTxidsDisjoint.adoc[`EntriesAndTxidsDisjoint`] 
| Check the intersection between two sets of transactions (a set of mempool entries and a set of txids) to make sure they are disjoint&period;
| xref:EstimationError.adoc[`EstimationError`] 
| Build a fee rate estimation error result&colon; a zero&hyphen;value estimation identifying the estimator and target, alongside the error message&period;
| xref:EvalDescriptorStringOrObject.adoc[`EvalDescriptorStringOrObject`] 
| Evaluate a descriptor given as a string, or as a &lcub;&quot;desc&quot;&colon;&period;&period;&period;,&quot;range&quot;&colon;&period;&period;&period;&rcub; object, with default range of 1000&period;
| xref:EvalScript-09.adoc[`EvalScript`] 
| `EvalScript` overloads
| xref:EvaluateSequenceLocks.adoc[`EvaluateSequenceLocks`] 
| Checks whether previously computed sequence locks are satisfied by a block&period;
| xref:ExecuteHTTPRPC.adoc[`ExecuteHTTPRPC`] 
| Execute a single HTTP request containing one or more JSONRPC requests&period; Specified jreq will be modified and status will be returned&period;
| xref:ExtractDestination.adoc[`ExtractDestination`] 
| Parse a scriptPubKey for the destination&period;
| xref:FatalError.adoc[`FatalError`] 
| Report an unrecoverable error, flag the validation state as failed, and notify the node to shut down&period;
| xref:FeeRateEstimationRef.adoc[`FeeRateEstimationRef`] 
| Return the estimation carried by a fee rate estimate result&colon; the successful estimation, or the error&apos;s zero&hyphen;value estimation&period;
| xref:FeeRateEstimatorTypeFromString.adoc[`FeeRateEstimatorTypeFromString`] 
| Parse a fee rate estimator type from its canonical string name&period;
| xref:FeeRateEstimatorTypeToString.adoc[`FeeRateEstimatorTypeToString`] 
| Convert a fee rate estimator type to its canonical string name&period;
| xref:FileCommit.adoc[`FileCommit`] 
| Ensure file contents are fully committed to disk, using a platform&hyphen;specific feature analogous to fsync()&period;
| xref:FinalizeAndExtractPSBT.adoc[`FinalizeAndExtractPSBT`] 
| Finalizes a PSBT if possible, and extracts it to a CMutableTransaction if it could be finalized&period;
| xref:FinalizePSBT.adoc[`FinalizePSBT`] 
| Finalizes a PSBT if possible, combining partial signatures&period;
| xref:FindAndDelete.adoc[`FindAndDelete`] 
| Remove every occurrence of a subscript from a script in place&period;
| xref:FindFirst.adoc[`FindFirst`] 
| Return the first element of a vector matching a predicate&period;
| xref:ForEachBlockFilterIndex.adoc[`ForEachBlockFilterIndex`] 
| Iterate over all running block filter indexes, invoking fn on each&period;
| xref:FormatAllOutputTypes.adoc[`FormatAllOutputTypes`] 
| Return a comma&hyphen;separated list of all supported output type names&period;
| xref:FormatFullVersion.adoc[`FormatFullVersion`] 
| Returns the full client version string, including build metadata&period;
| xref:FormatHDKeypath.adoc[`FormatHDKeypath`] 
| Format an HD keypath as a string, prefixed with the master key marker &quot;m&quot;&period;
| xref:FormatISO8601Date.adoc[`FormatISO8601Date`] 
| Format a Unix timestamp as an ISO 8601 date string&period;
| xref:FormatISO8601DateTime.adoc[`FormatISO8601DateTime`] 
| ISO 8601 formatting is preferred&period; Use the FormatISO8601&lcub;DateTime,Date&rcub; helper functions if possible&period;
| xref:FormatMoney.adoc[`FormatMoney`] 
| Format an amount as a string denoted in full coins&period;
| xref:FormatOutputType.adoc[`FormatOutputType`] 
| Return the string name of an output type&period;
| xref:FormatParagraph.adoc[`FormatParagraph`] 
| Format a paragraph of text to a fixed width, adding spaces for indentation to any added line&period;
| xref:FormatRFC1123DateTime.adoc[`FormatRFC1123DateTime`] 
| RFC1123 formatting https&colon;&sol;&sol;www&period;rfc&hyphen;editor&period;org&sol;rfc&sol;rfc1123&num;section&hyphen;5&period;2&period;14 Used in HTTP&sol;1&period;1 responses
| xref:FormatScript.adoc[`FormatScript`] 
| Format a script as a compact single&hyphen;line string for logging and display&period;
| xref:FormatSubVersion.adoc[`FormatSubVersion`] 
| Formats a BIP14&hyphen;style user agent subversion string&period;
| xref:GenerateAuthCookie.adoc[`GenerateAuthCookie`] 
| Generate a new RPC authentication cookie and write it to disk
| xref:GenerateRandomKey.adoc[`GenerateRandomKey`] 
| Generate a new random private key&period;
| xref:GetAllOutputTypes.adoc[`GetAllOutputTypes`] 
| Gets all existing output types formatted for RPC help sections&period;
| xref:GetAuthCookie.adoc[`GetAuthCookie`] 
| Read the RPC authentication cookie from disk
| xref:GetBindAddress.adoc[`GetBindAddress`] 
| Get the bind address for a socket as CService&period;
| xref:GetBitsProof.adoc[`GetBitsProof`] 
| Compute how much work an nBits value corresponds to&period;
| xref:GetBlockFilterIndex.adoc[`GetBlockFilterIndex`] 
| Get a block filter index by type&period; Returns nullptr if index has not been initialized or was already destroyed&period;
| xref:GetBlockProof-02.adoc[`GetBlockProof`] 
| `GetBlockProof` overloads
| xref:GetBlockProofEquivalentTime.adoc[`GetBlockProofEquivalentTime`] 
| Return the time it would take to redo the work difference between from and to, assuming the current hashrate corresponds to the difficulty at tip, in seconds&period;
| xref:GetBlockScriptFlags.adoc[`GetBlockScriptFlags`] 
| Return the script flags which should be checked for a given block&period;
| xref:GetBlockSubsidy.adoc[`GetBlockSubsidy`] 
| Compute the block subsidy (newly created coins) for a block at a given height&period;
| xref:GetBuriedDeployment.adoc[`GetBuriedDeployment`] 
| Looks up a buried deployment by its name&period;
| xref:GetDefaultDataDir.adoc[`GetDefaultDataDir`] 
| Get the default data directory for the current platform and user&period;
| xref:GetDescriptorChecksum.adoc[`GetDescriptorChecksum`] 
| Get the checksum for a `descriptor`&period;
| xref:GetDifficulty.adoc[`GetDifficulty`] 
| Get the difficulty of the net wrt to the given block index&period;
| xref:GetDust.adoc[`GetDust`] 
| Get the vout index numbers of all dust outputs
| xref:GetDustThreshold.adoc[`GetDustThreshold`] 
| Compute the minimum output value below which an output is considered dust&period;
| xref:GetEntriesForConflicts.adoc[`GetEntriesForConflicts`] 
| Get all descendants of iters&lowbar;conflicting&period; Checks that there are no more than MAX&lowbar;REPLACEMENT&lowbar;CANDIDATES distinct clusters affected&period;
| xref:GetFileSize.adoc[`GetFileSize`] 
| Get the size of a file by scanning it&period;
| xref:GetKeyForDestination.adoc[`GetKeyForDestination`] 
| Return the CKeyID of the key involved in a script (if there is a unique one)&period;
| xref:GetLegacySigOpCount.adoc[`GetLegacySigOpCount`] 
| Count ECDSA signature operations the old&hyphen;fashioned (pre&hyphen;0&period;6) way
| xref:GetListenPort.adoc[`GetListenPort`] 
| Return the port we listen on for incoming connections&period;
| xref:GetLocalAddrForPeer.adoc[`GetLocalAddrForPeer`] 
| Returns a local address that we should advertise to this peer&period;
| xref:GetLocalAddress.adoc[`GetLocalAddress`] 
| Return the best local address to use when talking to the given peer&period;
| xref:GetLocalAddresses.adoc[`GetLocalAddresses`] 
| Return all local non&hyphen;loopback IPv4 and IPv6 network addresses&period;
| xref:GetLocator.adoc[`GetLocator`] 
| Get a locator for a block index entry&period;
| xref:GetMockTime.adoc[`GetMockTime`] 
| For testing&period;
| xref:GetNameProxy.adoc[`GetNameProxy`] 
| Get the configured name proxy, if any&period;
| xref:GetNetworkForMagic.adoc[`GetNetworkForMagic`] 
| Determines which chain a set of network magic bytes belongs to&period;
| xref:GetNetworkName.adoc[`GetNetworkName`] 
| Get the canonical name of a network&period;
| xref:GetNetworkNames.adoc[`GetNetworkNames`] 
| Return a vector of publicly routable Network names&semi; optionally append NET&lowbar;UNROUTABLE&period;
| xref:GetNextWorkRequired.adoc[`GetNextWorkRequired`] 
| Compute the proof&hyphen;of&hyphen;work target (nBits) required for the block following pindexLast&period;
| xref:GetNumCores.adoc[`GetNumCores`] 
| Return the number of cores available on the current system&period;
| xref:GetOpName.adoc[`GetOpName`] 
| Returns the mnemonic name of an opcode&period;
| xref:GetP2SHSigOpCount.adoc[`GetP2SHSigOpCount`] 
| Count ECDSA signature operations in pay&hyphen;to&hyphen;script&hyphen;hash inputs&period;
| xref:GetPackageHash.adoc[`GetPackageHash`] 
| Get the hash of the concatenated wtxids of transactions, with wtxids treated as a little&hyphen;endian numbers and sorted in ascending numeric order&period;
| xref:GetProxy.adoc[`GetProxy`] 
| Get the proxy configured for a given network, if any&period;
| xref:GetPruneHeight.adoc[`GetPruneHeight`] 
| Return height of highest block that has been pruned, or std&colon;&colon;nullopt if no blocks have been pruned
| xref:GetQueryParameterFromUri.adoc[`GetQueryParameterFromUri`] 
| Extract a query&hyphen;string parameter value from a request URI&period;
| xref:GetRandBytes.adoc[`GetRandBytes`] 
| Generate random data via the internal PRNG&period;
| xref:GetRandHash.adoc[`GetRandHash`] 
| Generate a random uint256&period;
| xref:GetScriptFlagNames.adoc[`GetScriptFlagNames`] 
| List the human&hyphen;readable names of the set verification flags&period;
| xref:GetScriptForDestination.adoc[`GetScriptForDestination`] 
| Generate a Bitcoin scriptPubKey for the given CTxDestination&period; Returns a P2PKH script for a CKeyID destination, a P2SH script for a CScriptID, and an empty script for CNoDestination&period;
| xref:GetScriptForMultisig.adoc[`GetScriptForMultisig`] 
| Generate a multisig script&period;
| xref:GetScriptForRawPubKey.adoc[`GetScriptForRawPubKey`] 
| Generate a P2PK script for the given pubkey&period;
| xref:GetScriptOp.adoc[`GetScriptOp`] 
| Reads the next opcode, and any pushed data, from a script&period;
| xref:GetSecp256k1SignContext.adoc[`GetSecp256k1SignContext`] 
| Access the secp256k1 context used for signing and MuSig2 nonce generation&period;
| xref:GetSerializeSize.adoc[`GetSerializeSize`] 
| Return the number of bytes the serialization of an object would occupy&period;
| xref:GetSigOpsAdjustedWeight.adoc[`GetSigOpsAdjustedWeight`] 
| Adjust a transaction weight to account for its signature operation cost&period;
| xref:GetSizeOfCompactSize.adoc[`GetSizeOfCompactSize`] 
| Compact Size size &lt; 253 &hyphen;&hyphen; 1 byte size &lt;&equals; USHRT&lowbar;MAX &hyphen;&hyphen; 3 bytes (253 &plus; 2 bytes) size &lt;&equals; UINT&lowbar;MAX &hyphen;&hyphen; 5 bytes (254 &plus; 4 bytes) size &gt; UINT&lowbar;MAX &hyphen;&hyphen; 9 bytes (255 &plus; 8 bytes)
| xref:GetSizeOfVarInt.adoc[`GetSizeOfVarInt`] 
| Return the number of bytes the VarInt encoding of a value occupies&period;
| xref:GetSpecialScriptSize.adoc[`GetSpecialScriptSize`] 
| Returns the decompressed byte length of a special (compressed) script&period;
| xref:GetStrongRandBytes.adoc[`GetStrongRandBytes`] 
| Gather entropy from various sources, feed it into the internal PRNG, and generate random data using it&period;
| xref:GetTarget.adoc[`GetTarget`] 
| &ast; Get the target for a given block index&period;
| xref:GetTime-0d8.adoc[`GetTime`] 
| `GetTime` overloads
| xref:GetTransactionSigOpCost.adoc[`GetTransactionSigOpCost`] 
| Compute total signature operation cost of a transaction&period;
| xref:GetTxnOutputType.adoc[`GetTxnOutputType`] 
| Get the name of a TxoutType as a string
| xref:GetUptime.adoc[`GetUptime`] 
| Monotonic uptime (not affected by system time changes)&period;
| xref:GetVirtualTransactionInputSize.adoc[`GetVirtualTransactionInputSize`] 
| Compute the virtual size of a single transaction input&period;
| xref:GetVirtualTransactionSize-0a.adoc[`GetVirtualTransactionSize`] 
| `GetVirtualTransactionSize` overloads
| xref:GetWitnessCommitmentIndex.adoc[`GetWitnessCommitmentIndex`] 
| Compute at which vout of the block&apos;s coinbase transaction the witness commitment occurs, or &hyphen;1 if not found
| xref:GolombRiceDecode.adoc[`GolombRiceDecode`] 
| Golomb&hyphen;Rice decode a value from a bit stream&period;
| xref:GolombRiceEncode.adoc[`GolombRiceEncode`] 
| Golomb&hyphen;Rice encode a value into a bit stream&period;
| xref:HasHardenedDerivation.adoc[`HasHardenedDerivation`] 
| Whether a parsed HD keypath contains at least one hardened derivation step&period;
| xref:HasTestOption.adoc[`HasTestOption`] 
| Checks if a particular test option is present in &hyphen;test command&hyphen;line arg options
| xref:HasValidProofOfWork.adoc[`HasValidProofOfWork`] 
| Check that the proof of work on each blockheader matches the value in nBits&period;
| xref:Hash-07.adoc[`Hash`] 
| `Hash` overloads
| xref:Hash160.adoc[`Hash160`] 
| Compute the 160&hyphen;bit hash an object&period;
| xref:HaveNameProxy.adoc[`HaveNameProxy`] 
| Check whether a name proxy has been configured&period;
| xref:HelpExampleCli.adoc[`HelpExampleCli`] 
| Format a bitcoin&hyphen;cli example invocation with positional arguments&period;
| xref:HelpExampleCliNamed.adoc[`HelpExampleCliNamed`] 
| Format a bitcoin&hyphen;cli example invocation with named arguments&period;
| xref:HelpExampleRpc.adoc[`HelpExampleRpc`] 
| Format a JSON&hyphen;RPC example request with positional arguments&period;
| xref:HelpExampleRpcNamed.adoc[`HelpExampleRpcNamed`] 
| Format a JSON&hyphen;RPC example request with named arguments&period;
| xref:HelpMessageGroup.adoc[`HelpMessageGroup`] 
| Format a string to be used as group of options in help messages
| xref:HelpMessageOpt.adoc[`HelpMessageOpt`] 
| Format a string to be used as option description in help messages
| xref:HelpRequested.adoc[`HelpRequested`] 
| Return whether the user asked for help on the command line&period;
| xref:HexDigit.adoc[`HexDigit`] 
| Return the numeric value of a hexadecimal digit character&period;
| xref:HexStr-02f.adoc[`HexStr`] 
| `HexStr` overloads
| xref:HexToPubKey.adoc[`HexToPubKey`] 
| Parse a hex&hyphen;encoded public key, throwing an RPC error if it is invalid&period;
| xref:IOErrorIsPermanent.adoc[`IOErrorIsPermanent`] 
| Check whether a socket error code represents a permanent failure&period;
| xref:ImprovesFeerateDiagram.adoc[`ImprovesFeerateDiagram`] 
| The replacement transaction must improve the feerate diagram of the mempool&period;
| xref:InferDescriptor.adoc[`InferDescriptor`] 
| Find a descriptor for the specified `script`, using information from `provider` where possible&period;
| xref:InferTaprootTree.adoc[`InferTaprootTree`] 
| Given a TaprootSpendData and the output key, reconstruct its script tree&period;
| xref:InitBlockFilterIndex.adoc[`InitBlockFilterIndex`] 
| Initialize a block filter index for the given type if one does not already exist&period; Returns true if a new index is created and false if one has already been initialized&period;
| xref:InitContext.adoc[`InitContext`] 
| Initialize node context shutdown and args variables&period;
| xref:InitError-09.adoc[`InitError`] 
| `InitError` overloads
| xref:InitHTTPServer.adoc[`InitHTTPServer`] 
| Initialize HTTP server&period; Call this before RegisterHTTPHandler or EventBase()&period;
| xref:InitLogging.adoc[`InitLogging`] 
| Initialize the logging infrastructure
| xref:InitParameterInteraction.adoc[`InitParameterInteraction`] 
| Parameter interaction&colon; change current parameters depending on various rules
| xref:InitWarning.adoc[`InitWarning`] 
| Show warning message
| xref:Interpret.adoc[`Interpret`] 
| Map an IP address to its Autonomous System Number using the given asmap&period;
| xref:InterpretKey.adoc[`InterpretKey`] 
| Split a raw configuration key into its section, name, and negation&period;
| xref:InterpretPermString.adoc[`InterpretPermString`] 
| Interpret a custom permissions level string as fs&colon;&colon;perms
| xref:InterpretValue.adoc[`InterpretValue`] 
| Interpret a raw configuration value according to a key and its flags&period;
| xref:Interrupt.adoc[`Interrupt`] 
| Interrupt threads
| xref:InterruptHTTPRPC.adoc[`InterruptHTTPRPC`] 
| Interrupt HTTP RPC subsystem&period;
| xref:InterruptHTTPServer.adoc[`InterruptHTTPServer`] 
| Interrupt HTTP server threads
| xref:InterruptMapPort.adoc[`InterruptMapPort`] 
| Signal the port mapping thread to stop as soon as possible&period;
| xref:InterruptREST.adoc[`InterruptREST`] 
| Interrupt RPC REST subsystem&period;
| xref:InterruptRPC.adoc[`InterruptRPC`] 
| Interrupt the RPC service, unblocking any pending waits&period;
| xref:IsBIP30Repeat.adoc[`IsBIP30Repeat`] 
| Identifies blocks that overwrote an existing coinbase output in the UTXO set (see BIP30)&period;
| xref:IsBIP30Unspendable.adoc[`IsBIP30Unspendable`] 
| Identifies blocks which coinbase output was subsequently overwritten in the UTXO set (see BIP30)&period;
| xref:IsBadPort.adoc[`IsBadPort`] 
| Determine if a port is &quot;bad&quot; from the perspective of attempting to connect to a node on that port&period;
| xref:IsBlockMutated.adoc[`IsBlockMutated`] 
| Check if a block has been mutated (with respect to its merkle root and witness commitments)&period;
| xref:IsChildWithParents.adoc[`IsChildWithParents`] 
| Context&hyphen;free check that a package is exactly one child and its parents&semi; not all parents need to be present, but the package must not contain any transactions that are not the child&apos;s parents&period; It is expected to be sorted, which means the last transaction must be the child&period;
| xref:IsChildWithParentsTree.adoc[`IsChildWithParentsTree`] 
| Context&hyphen;free check that a package IsChildWithParents() and none of the parents depend on each other (the package is a &quot;tree&quot;)&period;
| xref:IsConsistentPackage.adoc[`IsConsistentPackage`] 
| Checks that these transactions don&apos;t conflict, i&period;e&period;, spend the same prevout&period; This includes checking that there are no duplicate transactions&period; Since these checks require looking at the inputs of a transaction, returns false immediately if any transactions have empty vin&period;
| xref:IsDeprecatedRPCEnabled.adoc[`IsDeprecatedRPCEnabled`] 
| Report whether the given deprecated RPC method is currently enabled&period;
| xref:IsDigit.adoc[`IsDigit`] 
| Tests if the given character is a decimal digit&period;
| xref:IsDirWritable.adoc[`IsDirWritable`] 
| Check if a directory is writable by creating a temporary file on it&period;
| xref:IsDust.adoc[`IsDust`] 
| Test whether an output is dust at the given relay fee rate&period;
| xref:IsFinalTx.adoc[`IsFinalTx`] 
| Check if transaction is final and can be included in a block with the specified height and time&period; Consensus critical&period;
| xref:IsHex.adoc[`IsHex`] 
| Returns true if each character in str is a hex character, and has an even number of hex digits&period;
| xref:IsLocal.adoc[`IsLocal`] 
| Return whether the given address is one of our known local addresses&period;
| xref:IsOpSuccess.adoc[`IsOpSuccess`] 
| Test for OP&lowbar;SUCCESSx opcodes as defined by BIP342&period;
| xref:IsProxy.adoc[`IsProxy`] 
| Check whether an address is one of the configured proxies&period;
| xref:IsPushdataOp.adoc[`IsPushdataOp`] 
| Test whether an opcode is a data&hyphen;push operation&period;
| xref:IsRBFOptIn.adoc[`IsRBFOptIn`] 
| Determine whether an unconfirmed transaction is signaling opt&hyphen;in to RBF according to BIP 125 This involves checking sequence numbers of the transaction, as well as the sequence numbers of all in&hyphen;mempool ancestors&period;
| xref:IsRBFOptInEmptyMempool.adoc[`IsRBFOptInEmptyMempool`] 
| Determine the RBF signaling state of a transaction assuming an empty mempool&period;
| xref:IsRPCRunning.adoc[`IsRPCRunning`] 
| Query whether RPC is running
| xref:IsSegWitOutput.adoc[`IsSegWitOutput`] 
| Check whether a scriptPubKey is known to be segwit&period;
| xref:IsSpace.adoc[`IsSpace`] 
| Tests if the given character is a whitespace character&period; The whitespace characters are&colon; space, form&hyphen;feed (&apos;f&apos;), newline (&apos;
&apos;), carriage return (&apos;r&apos;), horizontal tab (&apos;t&apos;), and vertical tab (&apos;v&apos;)&period;
| xref:IsStandard.adoc[`IsStandard`] 
| Determine whether a scriptPubKey uses a standard output form&period;
| xref:IsStandardTx.adoc[`IsStandardTx`] 
| Check for standard transaction types
| xref:IsSwitchChar.adoc[`IsSwitchChar`] 
| Return true if the character introduces a command&hyphen;line switch&period;
| xref:IsTopoSortedPackage.adoc[`IsTopoSortedPackage`] 
| If any direct dependencies exist between transactions (i&period;e&period; a child spending the output of a parent), checks that all parents appear somewhere in the list before their respective children&period; No other ordering is enforced&period; This function cannot detect indirect dependencies (e&period;g&period; a transaction&apos;s grandparent if its parent is not present)&period;
| xref:IsUnixSocketPath.adoc[`IsUnixSocketPath`] 
| Check if a string is a valid UNIX domain socket path
| xref:IsValidDestination.adoc[`IsValidDestination`] 
| Check whether a CTxDestination corresponds to one with an address&period;
| xref:IsValidDestinationString-00.adoc[`IsValidDestinationString`] 
| `IsValidDestinationString` overloads
| xref:IsWellFormedPackage.adoc[`IsWellFormedPackage`] 
| Context&hyphen;free package policy checks&colon; 1&period; The number of transactions cannot exceed MAX&lowbar;PACKAGE&lowbar;COUNT&period; 2&period; The total weight cannot exceed MAX&lowbar;PACKAGE&lowbar;WEIGHT&period; 3&period; If any dependencies exist between transactions, parents must appear before children&period; 4&period; Transactions cannot conflict, i&period;e&period;, spend the same inputs&period;
| xref:IsWitnessStandard.adoc[`IsWitnessStandard`] 
| Check if the transaction is over standard P2WSH resources limit&colon; 3600bytes witnessScript size, 80bytes per witness stack element, 100 witness stack elements These limits are adequate for multisignatures up to n&hyphen;of&hyphen;100 using OP&lowbar;CHECKSIG, OP&lowbar;ADD, and OP&lowbar;EQUAL&period;
| xref:JSONRPCError.adoc[`JSONRPCError`] 
| Build a JSON&hyphen;RPC error object&period;
| xref:JSONRPCExec.adoc[`JSONRPCExec`] 
| Execute an RPC request and return its JSON&hyphen;RPC reply&period;
| xref:JSONRPCPSBTError.adoc[`JSONRPCPSBTError`] 
| Build a JSON&hyphen;RPC error object for a PSBT error&period;
| xref:JSONRPCProcessBatchReply.adoc[`JSONRPCProcessBatchReply`] 
| Parse JSON&hyphen;RPC batch reply into a vector
| xref:JSONRPCReplyObj.adoc[`JSONRPCReplyObj`] 
| Build a JSON&hyphen;RPC reply object from a result or error&period;
| xref:JSONRPCRequestObj.adoc[`JSONRPCRequestObj`] 
| JSON&hyphen;RPC 2&period;0 request, only used in bitcoin&hyphen;cli
| xref:JSONRPCTransactionError.adoc[`JSONRPCTransactionError`] 
| Build a JSON&hyphen;RPC error object for a transaction error&period;
| xref:KeccakF.adoc[`KeccakF`] 
| The Keccak&hyphen;f&lsqb;1600&rsqb;permutation&period;
| xref:LargeCoinsCacheThreshold.adoc[`LargeCoinsCacheThreshold`] 
| Compute the coins&hyphen;cache usage threshold above which a periodic flush is warranted&period;
| xref:LastCommonAncestor.adoc[`LastCommonAncestor`] 
| Find the forking point between two chain tips&period;
| xref:LeaveCritical.adoc[`LeaveCritical`] 
| Register that the most recently entered critical section is being left&period;
| xref:LicenseInfo.adoc[`LicenseInfo`] 
| Returns licensing information (for &hyphen;version)
| xref:ListBlockFilterTypes.adoc[`ListBlockFilterTypes`] 
| Get a comma&hyphen;separated list of known filter type names&period;
| xref:LoadAddrman.adoc[`LoadAddrman`] 
| Loads the address manager (peers&period;dat), creating a fresh one if needed&period;
| xref:LocaleIndependentAtoi.adoc[`LocaleIndependentAtoi`] 
| Locale&hyphen;independent replacement for std&colon;&colon;atoi, provided for backwards compatibility reasons&period;
| xref:LocatorEntries.adoc[`LocatorEntries`] 
| Construct a list of hash entries to put in a locator&period;
| xref:LockStackEmpty.adoc[`LockStackEmpty`] 
| Check whether the current thread holds no tracked critical sections&period;
| xref:LogInstance.adoc[`LogInstance`] 
| Access the global logger instance&period;
| xref:Lookup-0d.adoc[`Lookup`] 
| `Lookup` overloads
| xref:LookupHost-02.adoc[`LookupHost`] 
| `LookupHost` overloads
| xref:LookupNumeric.adoc[`LookupNumeric`] 
| Resolve a service string with a numeric IP to its first corresponding service&period;
| xref:LookupSubNet.adoc[`LookupSubNet`] 
| Parse and resolve a specified subnet string into the appropriate internal representation&period;
| xref:MakeByteSpan.adoc[`MakeByteSpan`] 
| Return a read&hyphen;only span of bytes viewing the same memory as the range `v`&period;
| xref:MakeExponentiallyDistributed.adoc[`MakeExponentiallyDistributed`] 
| Given a uniformly random uint64&lowbar;t, return an exponentially distributed double with mean 1&period;
| xref:MakeTransactionRef.adoc[`MakeTransactionRef`] 
| Builds a shared pointer to an immutable transaction from the given value&period;
| xref:MakeTxGraph.adoc[`MakeTxGraph`] 
| Construct a new TxGraph with the specified limit on the number of transactions within a cluster, and on the sum of transaction sizes within a cluster&period;
| xref:MakeUCharSpan.adoc[`MakeUCharSpan`] 
| Like the std&colon;&colon;span constructor, but for (const) unsigned char member types only&period; Only works for (un)signed char containers&period;
| xref:MakeWritableByteSpan.adoc[`MakeWritableByteSpan`] 
| Return a writable span of bytes viewing the same memory as the range `v`&period;
| xref:MakeWritableUCharSpan.adoc[`MakeWritableUCharSpan`] 
| Like MakeUCharSpan, but returns a writable span of `unsigned char`&period;
| xref:MatchMultiA.adoc[`MatchMultiA`] 
| Determine if script is a &quot;multi&lowbar;a&quot; script&period; Returns (threshold, keyspans) if so, and nullopt otherwise&period; The keyspans refer to bytes in the passed script&period;
| xref:MaybeCheckNotHeld-0f.adoc[`MaybeCheckNotHeld`] 
| `MaybeCheckNotHeld` overloads
| xref:MaybeFlipIPv6toCJDNS.adoc[`MaybeFlipIPv6toCJDNS`] 
| If an IPv6 address belongs to the address range used by the CJDNS network and the CJDNS network is reachable (&hyphen;cjdnsreachable config is set), then change the type from NET&lowbar;IPV6 to NET&lowbar;CJDNS&period;
| xref:MaybeMigrateLegacyFeeEstimates.adoc[`MaybeMigrateLegacyFeeEstimates`] 
| Move a legacy fee&lowbar;estimates&period;dat file to the current block policy fee estimator path, if needed&period;
| xref:MempoolInfoToJSON.adoc[`MempoolInfoToJSON`] 
| Mempool information to JSON
| xref:MempoolPolicyEstimatorPath.adoc[`MempoolPolicyEstimatorPath`] 
| Path of the mempool policy estimator data file&period;
| xref:MempoolToJSON.adoc[`MempoolToJSON`] 
| Mempool to JSON
| xref:MessageHash.adoc[`MessageHash`] 
| Hashes a message for signing and verification in a manner that prevents inadvertently signing a transaction&period;
| xref:MessageSign.adoc[`MessageSign`] 
| Sign a message&period;
| xref:MessageVerify.adoc[`MessageVerify`] 
| Verify a signed message&period;
| xref:MillisToTimeval-0a7.adoc[`MillisToTimeval`] 
| Convert milliseconds to a struct timeval for e&period;g&period; select&period;
| xref:MoneyRange.adoc[`MoneyRange`] 
| Returns true when the amount is non&hyphen;negative and does not exceed MAX&lowbar;MONEY&period;
| xref:MuSig2AggregatePubkeys-01.adoc[`MuSig2AggregatePubkeys`] 
| `MuSig2AggregatePubkeys` overloads
| xref:MuSig2SessionID.adoc[`MuSig2SessionID`] 
| Computes an arbitrary unique session ID to identify ongoing signing sessions&period; It is the SHA256 of the signing (aggregate) pubkey, the participant pubkey, the sighash, and the pubnonce
| xref:MurmurHash3.adoc[`MurmurHash3`] 
| Computes the 32&hyphen;bit MurmurHash3 of the given data&period;
| xref:NATPMPRequestPortMap.adoc[`NATPMPRequestPortMap`] 
| Try to open a port using RFC 6886 NAT&hyphen;PMP&period; IPv4 only&period;
| xref:NetworkErrorString.adoc[`NetworkErrorString`] 
| Return readable error string for a network error code&period;
| xref:NextEmptyBlockIndex.adoc[`NextEmptyBlockIndex`] 
| Return an empty block index on top of the tip, with height, time and nBits set
| xref:NormalizeOutputs.adoc[`NormalizeOutputs`] 
| Normalize univalue&hyphen;represented outputs
| xref:Now.adoc[`Now`] 
| Return the current time point cast to the given precision&period; Only use this when an exact precision is needed, otherwise use T&colon;&colon;clock&colon;&colon;now() directly&period;
| xref:OnionToString.adoc[`OnionToString`] 
| Encode a raw Tor v3 address as its human&hyphen;readable &period;onion string&period;
| xref:OutputTypeFromDestination.adoc[`OutputTypeFromDestination`] 
| Get the OutputType for a CTxDestination
| xref:PCPRequestPortMap.adoc[`PCPRequestPortMap`] 
| Try to open a port using RFC 6887 Port Control Protocol (PCP)&period; Handles IPv4 and IPv6&period;
| xref:PSBTInputSigned.adoc[`PSBTInputSigned`] 
| Checks whether a PSBTInput is already signed by checking for non&hyphen;null finalized fields&period;
| xref:PSBTInputSignedAndVerified.adoc[`PSBTInputSignedAndVerified`] 
| Checks whether a PSBTInput is already signed by doing script verification using final fields&period;
| xref:PSBTRoleName.adoc[`PSBTRoleName`] 
| Return a human&hyphen;readable name for a PSBT role&period;
| xref:PackageTRUCChecks.adoc[`PackageTRUCChecks`] 
| Must be called for every transaction that is submitted within a package, even if not TRUC&period;
| xref:Params.adoc[`Params`] 
| Return the currently selected parameters&period; This won&apos;t change after app startup, except for unit tests&period;
| xref:Parse.adoc[`Parse`] 
| Parse a `descriptor` string&period; Included private keys are put in `out`&period;
| xref:ParseByteUnits.adoc[`ParseByteUnits`] 
| Parse a string with suffix unit &lsqb;k&verbar;K&verbar;m&verbar;M&verbar;g&verbar;G&verbar;t&verbar;T&rsqb;&period; Must be a whole integer, fractions not allowed (0&period;5t), no whitespace or &plus;&hyphen; Lowercase units are 1000 base&period; Uppercase units are 1024 base&period; Examples&colon; 2m,27M,19g,41T
| xref:ParseConfirmTarget.adoc[`ParseConfirmTarget`] 
| Parse a confirm target option and raise an RPC error if it is invalid&period;
| xref:ParseDataFormat.adoc[`ParseDataFormat`] 
| Parse a URI to get the data format and URI without data format and query string&period;
| xref:ParseDescriptorRange.adoc[`ParseDescriptorRange`] 
| Parse a JSON range specified as an int64 or as a &lsqb;int64, int64&rsqb;pair&period;
| xref:ParseFeeRate.adoc[`ParseFeeRate`] 
| Parse a json number or string, denoting BTC&sol;kvB, into a CFeeRate (sat&sol;kvB)&period; Reject negative values or rates larger than 1BTC&sol;kvB&period;
| xref:ParseFixedPoint.adoc[`ParseFixedPoint`] 
| Parse number as fixed point according to JSON number syntax&period;
| xref:ParseHDKeypath.adoc[`ParseHDKeypath`] 
| Parse an HD keypaths like &quot;m&sol;7&sol;0&apos;&sol;2000&quot;&period;
| xref:ParseHashO.adoc[`ParseHashO`] 
| Parse a hex&hyphen;encoded hash from a named field of an object&period;
| xref:ParseHashV.adoc[`ParseHashV`] 
| Parse a hex&hyphen;encoded hash from a UniValue, throwing an RPC error if it is not valid hex&period;
| xref:ParseHex.adoc[`ParseHex`] 
| Like TryParseHex, but returns an empty vector on invalid input&period;
| xref:ParseHexO.adoc[`ParseHexO`] 
| Parse a hex&hyphen;encoded byte vector from a named field of an object&period;
| xref:ParseHexV.adoc[`ParseHexV`] 
| Parse a hex&hyphen;encoded byte vector from a UniValue, throwing an RPC error if it is not valid hex&period;
| xref:ParseISO8601DateTime.adoc[`ParseISO8601DateTime`] 
| Parse an ISO 8601 date and time string into a Unix timestamp&period;
| xref:ParseKeyPathElement.adoc[`ParseKeyPathElement`] 
| Parse a single key path element like &quot;0&quot;, &quot;0&apos;&quot;, or &quot;0h&quot;&period; Returns the derivation index and hardened status, or an error message&period;
| xref:ParseMoney.adoc[`ParseMoney`] 
| Parse an amount denoted in full coins&period; E&period;g&period; &quot;0&period;0034&quot; supplied on the command line&period;
| xref:ParseNetwork.adoc[`ParseNetwork`] 
| Parse a network name into its Network enumerator&period;
| xref:ParseOutputType.adoc[`ParseOutputType`] 
| Parse an output type from its string name&period;
| xref:ParseOutputs.adoc[`ParseOutputs`] 
| Parse normalized outputs into destination, amount tuples
| xref:ParsePathBIP32.adoc[`ParsePathBIP32`] 
| Parse a BIP32 derivation path&period;
| xref:ParsePrevouts.adoc[`ParsePrevouts`] 
| Parse a prevtxs UniValue array and get the map of coins from it
| xref:ParseScript.adoc[`ParseScript`] 
| Parse a human&hyphen;readable script (opcodes and push data) into a CScript&period;
| xref:ParseSighashString.adoc[`ParseSighashString`] 
| Parse a sighash string representation and raise an RPC error if it is invalid&period;
| xref:ParseVerbosity.adoc[`ParseVerbosity`] 
| Parses verbosity from provided UniValue&period;
| xref:PaysForRBF.adoc[`PaysForRBF`] 
| The replacement transaction must pay more fees than the original transactions&period; The additional fees must pay for the replacement&apos;s bandwidth at or above the incremental relay feerate&period;
| xref:PermittedDifficultyTransition.adoc[`PermittedDifficultyTransition`] 
| Return false if the proof&hyphen;of&hyphen;work requirement specified by new&lowbar;nbits at a given height is not possible, given the proof&hyphen;of&hyphen;work on the prior block as specified by old&lowbar;nbits&period;
| xref:PermsToSymbolicString.adoc[`PermsToSymbolicString`] 
| Convert fs&colon;&colon;perms to symbolic string of the form &apos;rwxrwxrwx&apos;
| xref:PreCheckEphemeralTx.adoc[`PreCheckEphemeralTx`] 
| Called for each transaction once transaction fees are known&period; Does context&hyphen;less checks about a single transaction&period;
| xref:PrecomputePSBTData.adoc[`PrecomputePSBTData`] 
| Compute a PrecomputedTransactionData object from a psbt&period;
| xref:PrintExceptionContinue.adoc[`PrintExceptionContinue`] 
| Log an exception and its originating thread without rethrowing&period;
| xref:ProcessNewPackage.adoc[`ProcessNewPackage`] 
| Validate (and maybe submit) a package to the mempool&period; See doc&sol;policy&sol;packages&period;md for full details on package validation rules&period;
| xref:ProduceSignature.adoc[`ProduceSignature`] 
| Produce a script signature using a generic signature creator&period;
| xref:ProtectEvictionCandidatesByRatio.adoc[`ProtectEvictionCandidatesByRatio`] 
| Protect desirable or disadvantaged inbound peers from eviction by ratio&period;
| xref:PruneBlockFilesManual.adoc[`PruneBlockFilesManual`] 
| Prune block files up to a given height&period;
| xref:PushWarnings-0c.adoc[`PushWarnings`] 
| `PushWarnings` overloads
| xref:QueryDefaultGateway.adoc[`QueryDefaultGateway`] 
| Query the OS for the default gateway for `network`&period; This only makes sense for NET&lowbar;IPV4 and NET&lowbar;IPV6&period; Returns std&colon;&colon;nullopt if it cannot be found, or there is no support for this OS&period;
| xref:RIPEMD160.adoc[`RIPEMD160`] 
| Compute the 160&hyphen;bit RIPEMD&hyphen;160 hash of an array&period;
| xref:RPCConvertNamedValues.adoc[`RPCConvertNamedValues`] 
| Convert named arguments to command&hyphen;specific RPC representation
| xref:RPCConvertValues.adoc[`RPCConvertValues`] 
| Convert positional arguments to command&hyphen;specific RPC representation
| xref:RPCErrorFromTransactionError.adoc[`RPCErrorFromTransactionError`] 
| Map a transaction error to the matching RPC error code&period;
| xref:RPCIsInWarmup.adoc[`RPCIsInWarmup`] 
| Report whether the RPC server is still warming up&period;
| xref:RPCTypeCheckObj.adoc[`RPCTypeCheckObj`] 
| Check that an object contains the expected keys with the expected value types&period;
| xref:RaiseFileDescriptorLimit.adoc[`RaiseFileDescriptorLimit`] 
| Try to raise the file descriptor limit to the requested number&period;
| xref:RandAddDynamicEnv.adoc[`RandAddDynamicEnv`] 
| Gather non&hyphen;cryptographic environment data that changes over time&period;
| xref:RandAddEvent.adoc[`RandAddEvent`] 
| Gathers entropy from the low bits of the time at which events occur&period; Should be called with a uint32&lowbar;t describing the event at the time an event occurs&period;
| xref:RandAddPeriodic.adoc[`RandAddPeriodic`] 
| Gather entropy from various expensive sources, and feed them to the PRNG state&period;
| xref:RandAddStaticEnv.adoc[`RandAddStaticEnv`] 
| Gather non&hyphen;cryptographic environment data that does not change over time&period;
| xref:RandomInit.adoc[`RandomInit`] 
| Initialize global RNG state and log any CPU features that are used&period;
| xref:Random_SanityCheck.adoc[`Random&lowbar;SanityCheck`] 
| Check that OS randomness is available and returning the requested number of bytes&period;
| xref:ReadAnchors.adoc[`ReadAnchors`] 
| Read the anchor IP address database (anchors&period;dat)
| xref:ReadBE16.adoc[`ReadBE16`] 
| Read a big&hyphen;endian 16&hyphen;bit integer from a byte buffer&period;
| xref:ReadBE32.adoc[`ReadBE32`] 
| Read a big&hyphen;endian 32&hyphen;bit integer from a byte buffer&period;
| xref:ReadBE64.adoc[`ReadBE64`] 
| Read a big&hyphen;endian 64&hyphen;bit integer from a byte buffer&period;
| xref:ReadBinaryFile.adoc[`ReadBinaryFile`] 
| Read full contents of a file and return them in a std&colon;&colon;string&period;
| xref:ReadCompactSize.adoc[`ReadCompactSize`] 
| Decode a CompactSize&hyphen;encoded variable&hyphen;length integer&period;
| xref:ReadFromStream.adoc[`ReadFromStream`] 
| Reads peer addresses from a stream into the address manager&period;
| xref:ReadLE16.adoc[`ReadLE16`] 
| Read a little&hyphen;endian 16&hyphen;bit integer from a byte buffer&period;
| xref:ReadLE32.adoc[`ReadLE32`] 
| Read a little&hyphen;endian 32&hyphen;bit integer from a byte buffer&period;
| xref:ReadLE64.adoc[`ReadLE64`] 
| Read a little&hyphen;endian 64&hyphen;bit integer from a byte buffer&period;
| xref:ReadVarInt.adoc[`ReadVarInt`] 
| Read a VarInt&hyphen;encoded value from a stream&period;
| xref:RecursiveDynamicUsage.adoc[`RecursiveDynamicUsage`] 
| Recursively measure the dynamic memory used by the pointee of a shared pointer&period;
| xref:RegisterBlockchainRPCCommands.adoc[`RegisterBlockchainRPCCommands`] 
| Register the blockchain RPC commands&period;
| xref:RegisterFeeRPCCommands.adoc[`RegisterFeeRPCCommands`] 
| Register the fee&hyphen;estimation RPC commands&period;
| xref:RegisterHTTPHandler.adoc[`RegisterHTTPHandler`] 
| Register handler for prefix&period; If multiple handlers match a prefix, the first&hyphen;registered one will be invoked&period;
| xref:RegisterMempoolRPCCommands.adoc[`RegisterMempoolRPCCommands`] 
| Register the mempool RPC commands&period;
| xref:RegisterMiningRPCCommands.adoc[`RegisterMiningRPCCommands`] 
| Register the mining RPC commands&period;
| xref:RegisterNetRPCCommands.adoc[`RegisterNetRPCCommands`] 
| Register the network RPC commands&period;
| xref:RegisterNodeRPCCommands.adoc[`RegisterNodeRPCCommands`] 
| Register the node RPC commands&period;
| xref:RegisterOutputScriptRPCCommands.adoc[`RegisterOutputScriptRPCCommands`] 
| Register the output&hyphen;script RPC commands&period;
| xref:RegisterRawTransactionRPCCommands.adoc[`RegisterRawTransactionRPCCommands`] 
| Register the raw&hyphen;transaction RPC commands&period;
| xref:RegisterSignMessageRPCCommands.adoc[`RegisterSignMessageRPCCommands`] 
| Register the message&hyphen;signing RPC commands&period;
| xref:RegisterSignerRPCCommands.adoc[`RegisterSignerRPCCommands`] 
| Register the external&hyphen;signer RPC commands&period;
| xref:RegisterTxoutProofRPCCommands.adoc[`RegisterTxoutProofRPCCommands`] 
| Register the txout&hyphen;proof RPC commands&period;
| xref:RegisterZMQRPCCommands.adoc[`RegisterZMQRPCCommands`] 
| Register the ZMQ&hyphen;related RPC commands&period;
| xref:ReleaseDirectoryLocks.adoc[`ReleaseDirectoryLocks`] 
| Release all directory locks&period; This is used for unit testing only, at runtime the global destructor will take care of the locks&period;
| xref:RemovalReasonToString.adoc[`RemovalReasonToString`] 
| Convert a mempool removal reason to a human&hyphen;readable string&period;
| xref:RemoveLocal.adoc[`RemoveLocal`] 
| Forget a previously recorded local address&period;
| xref:RemoveUnnecessaryTransactions.adoc[`RemoveUnnecessaryTransactions`] 
| Reduces the size of the PSBT by dropping unnecessary `non&lowbar;witness&lowbar;utxos` (i&period;e&period; complete previous transactions) from a psbt when all inputs are segwit v1&period;
| xref:RenameOver.adoc[`RenameOver`] 
| Rename src to dest&period;
| xref:RpcInterruptionPoint.adoc[`RpcInterruptionPoint`] 
| Throw JSONRPCError if RPC is not running
| xref:RunCommandParseJSON.adoc[`RunCommandParseJSON`] 
| Execute a command which returns JSON, and parse the result&period;
| xref:SHA256AutoDetect.adoc[`SHA256AutoDetect`] 
| Autodetect the best available SHA256 implementation&period; Returns the name of the implementation&period;
| xref:SHA256D64.adoc[`SHA256D64`] 
| Compute multiple double&hyphen;SHA256&apos;s of 64&hyphen;byte blobs&period; output&colon; pointer to a blocks&ast;32 byte output buffer input&colon; pointer to a blocks&ast;64 byte input buffer blocks&colon; the number of hashes to compute&period;
| xref:SHA256Uint256.adoc[`SHA256Uint256`] 
| Single&hyphen;SHA256 a 32&hyphen;byte input (represented as uint256)&period;
| xref:SanitizeString.adoc[`SanitizeString`] 
| Remove unsafe chars&period; Safe chars chosen to allow simple messages&sol;URLs&sol;email addresses, but avoid anything even possibly remotely dangerous like &amp; or &gt;
| xref:SanityCheckAsmap.adoc[`SanityCheckAsmap`] 
| Check that the asmap is well formed for the given address size&period;
| xref:SaturatingAdd.adoc[`SaturatingAdd`] 
| Add two integers, saturating instead of overflowing&period;
| xref:SaturatingLeftShift.adoc[`SaturatingLeftShift`] 
| Left bit shift with safe minimum and maximum values&period;
| xref:ScheduleBatchPriority.adoc[`ScheduleBatchPriority`] 
| On platforms that support it, tell the kernel the calling thread is CPU&hyphen;intensive and non&hyphen;interactive&period; See SCHED&lowbar;BATCH in sched(7) for details&period;
| xref:ScriptErrorString.adoc[`ScriptErrorString`] 
| Returns a human&hyphen;readable message describing a script error code&period;
| xref:ScriptFlagNamesToEnum.adoc[`ScriptFlagNamesToEnum`] 
| Return the mapping from verification flag names to their enum values&period;
| xref:ScriptPubKeyDoc.adoc[`ScriptPubKeyDoc`] 
| Return the standard result documentation for a scriptPubKey object&period;
| xref:ScriptToAsmStr.adoc[`ScriptToAsmStr`] 
| Render a script as a human&hyphen;readable assembly string&period;
| xref:ScriptToUniv.adoc[`ScriptToUniv`] 
| Fill a JSON object with a human&hyphen;readable description of a script&period;
| xref:SeedsAssumedServiceFlags.adoc[`SeedsAssumedServiceFlags`] 
| Service flags we assume for addresses obtained from the DNS seeds and the fixed seeds, which don&apos;t come with service flags attached&period; BIP324 support can be safely assumed because the vast majority of listening nodes signals NODE&lowbar;P2P&lowbar;V2, and if the assumption is wrong for a given peer we simply reconnect using v1 transport&period;
| xref:SeedsServiceFlags.adoc[`SeedsServiceFlags`] 
| State independent service flags&period; If the return value is changed, contrib&sol;seeds&sol;makeseeds&period;py should be updated appropriately to filter for nodes with desired service flags (compatible with our new flags)&period;
| xref:SeenLocal.adoc[`SeenLocal`] 
| Mark a local address as having been seen, returning whether it was already known&period;
| xref:SelectBaseParams.adoc[`SelectBaseParams`] 
| Sets the params returned by Params() to those for the given chain&period;
| xref:SelectNodeToEvict.adoc[`SelectNodeToEvict`] 
| Select an inbound peer to evict after filtering out (protecting) peers having distinct, difficult&hyphen;to&hyphen;forge characteristics&period; The protection logic picks out fixed numbers of desirable peers per various criteria, followed by (mostly) ratios of desirable or disadvantaged peers&period; If any eviction candidates remain, the selection logic chooses a peer to evict&period;
| xref:SelectParams.adoc[`SelectParams`] 
| Sets the params returned by Params() to those for the given chain type&period;
| xref:SequenceLocks.adoc[`SequenceLocks`] 
| Check if transaction is final per BIP 68 sequence numbers and can be included in a block&period; Consensus critical&period; Takes as input a list of heights at which tx&apos;s inputs (in order) confirmed&period;
| xref:Serialize-055.adoc[`Serialize`] 
| `Serialize` overloads
| xref:SerializeHDKeypath.adoc[`SerializeHDKeypath`] 
| Serialize a length&hyphen;prefixed KeyOriginInfo to a stream&period;
| xref:SerializeHDKeypaths.adoc[`SerializeHDKeypaths`] 
| Serialize a map of HD keypaths to a stream under the given key type&period;
| xref:SerializeKeyOrigin.adoc[`SerializeKeyOrigin`] 
| Serialize a KeyOriginInfo to a stream&period;
| xref:SerializeMany.adoc[`SerializeMany`] 
| Serialize several objects in sequence to the same stream&period;
| xref:SerializeToVector.adoc[`SerializeToVector`] 
| Serialize arguments as a length&hyphen;prefixed vector into a stream&period;
| xref:SerializeTransaction.adoc[`SerializeTransaction`] 
| Writes a transaction to a stream, optionally including witness data&period;
| xref:SetMockTime-03.adoc[`SetMockTime`] 
| `SetMockTime` overloads
| xref:SetNameProxy.adoc[`SetNameProxy`] 
| Set the name proxy to use for all connections to nodes specified by a hostname&period; After setting this proxy, connecting to a node specified by a hostname won&apos;t result in a local lookup of said hostname, rather, connect to the node by asking the name proxy for a proxy connection to the hostname, effectively delegating the hostname lookup to the specified proxy&period;
| xref:SetProxy.adoc[`SetProxy`] 
| Set the proxy used to reach a given network&period;
| xref:SetRPCWarmupFinished.adoc[`SetRPCWarmupFinished`] 
| Mark warmup as done&period; RPC calls will be processed from now on&period;
| xref:SetRPCWarmupStarting.adoc[`SetRPCWarmupStarting`] 
| Enter the warmup state so RPC calls report that the node is starting up&period;
| xref:SetRPCWarmupStatus.adoc[`SetRPCWarmupStatus`] 
| Set the RPC warmup status&period; When this is done, all RPC calls will error out immediately with RPC&lowbar;IN&lowbar;WARMUP&period;
| xref:SettingTo-07.adoc[`SettingTo`] 
| `SettingTo` overloads
| xref:SettingToBool-05.adoc[`SettingToBool`] 
| `SettingToBool` overloads
| xref:SettingToString-00.adoc[`SettingToString`] 
| `SettingToString` overloads
| xref:SetupChainParamsBaseOptions.adoc[`SetupChainParamsBaseOptions`] 
| Set the arguments for chainparams
| xref:SetupEnvironment.adoc[`SetupEnvironment`] 
| Initialize locale, standard streams, and other process&hyphen;wide environment settings&period;
| xref:SetupHelpOptions.adoc[`SetupHelpOptions`] 
| Add help options to the args manager
| xref:SetupNetworking.adoc[`SetupNetworking`] 
| Initialize networking support for the current platform&period;
| xref:SetupServerArgs.adoc[`SetupServerArgs`] 
| Register all arguments with the ArgsManager
| xref:ShellEscape.adoc[`ShellEscape`] 
| Quote and escape a string so it can be safely passed as a single shell argument&period;
| xref:Shutdown.adoc[`Shutdown`] 
| Shut down the node, stopping threads and releasing resources&period;
| xref:ShutdownRequested.adoc[`ShutdownRequested`] 
| Return whether node shutdown was requested&period;
| xref:SighashFromStr.adoc[`SighashFromStr`] 
| Parse a signature&hyphen;hash type from its textual name&period;
| xref:SighashToStr.adoc[`SighashToStr`] 
| Convert a signature&hyphen;hash type byte into its textual name&period;
| xref:SignPSBTInput.adoc[`SignPSBTInput`] 
| Signs a PSBTInput, verifying that all provided data matches what is being signed&period;
| xref:SignTransaction-07.adoc[`SignTransaction`] 
| `SignTransaction` overloads
| xref:SignTransactionResultToJSON.adoc[`SignTransactionResultToJSON`] 
| Encode the outcome of a signing attempt as a JSON object
| xref:SignalsOptInRBF.adoc[`SignalsOptInRBF`] 
| Check whether the sequence numbers on this transaction are signaling opt&hyphen;in to replace&hyphen;by&hyphen;fee, according to BIP 125&period; Allow opt&hyphen;out of transaction replacement by setting nSequence &gt; MAX&lowbar;BIP125&lowbar;RBF&lowbar;SEQUENCE (SEQUENCE&lowbar;FINAL&hyphen;2) on all inputs&period;
| xref:SignatureHash.adoc[`SignatureHash`] 
| Compute the signature hash for one input under the selected signature version&period;
| xref:SignatureHashSchnorr.adoc[`SignatureHashSchnorr`] 
| Compute the BIP341 Taproot signature hash for one input&period;
| xref:SigningResultString.adoc[`SigningResultString`] 
| Return a human&hyphen;readable description of a signing result&period;
| xref:SingleTRUCChecks.adoc[`SingleTRUCChecks`] 
| Must be called for every transaction, even if not TRUC&period; Not strictly necessary for transactions accepted through AcceptMultipleTransactions&period;
| xref:Socks5.adoc[`Socks5`] 
| Connect to a specified destination service through an already connected SOCKS5 proxy&period;
| xref:Solver.adoc[`Solver`] 
| Parse a scriptPubKey and identify script type for standard scripts&period; If successful, returns script type and parsed pubkeys or hashes, depending on the type&period; For example, for a P2SH script, vSolutionsRet will contain the script hash, for P2PKH it will contain the key hash, etc&period;
| xref:SpanPopBack.adoc[`SpanPopBack`] 
| Pop the last element off a span, and return a reference to that element&period;
| xref:SpendsNonAnchorWitnessProg.adoc[`SpendsNonAnchorWitnessProg`] 
| Check whether this transaction spends any witness program but P2A, including not&hyphen;yet&hyphen;defined ones&period; May return `false` early for consensus&hyphen;invalid transactions&period;
| xref:SplitHostPort.adoc[`SplitHostPort`] 
| Splits socket address string into host string and port value&period; Validates port value&period;
| xref:StartHTTPRPC.adoc[`StartHTTPRPC`] 
| Start HTTP RPC subsystem&period; Precondition&semi; HTTP and RPC has been started&period;
| xref:StartHTTPServer.adoc[`StartHTTPServer`] 
| Start HTTP server&period; This is separate from InitHTTPServer to give users race&hyphen;condition&hyphen;free time to register their handlers between InitHTTPServer and StartHTTPServer&period;
| xref:StartIndexBackgroundSync.adoc[`StartIndexBackgroundSync`] 
| Validates requirements to run the indexes and spawns each index initial sync thread
| xref:StartMapPort.adoc[`StartMapPort`] 
| Start the port mapping thread that requests a port forward from the gateway&period;
| xref:StartREST.adoc[`StartREST`] 
| Start HTTP REST subsystem&period; Precondition&semi; HTTP and RPC has been started&period;
| xref:StartRPC.adoc[`StartRPC`] 
| Start the RPC service so it begins accepting calls&period;
| xref:StateName.adoc[`StateName`] 
| Get a string with the state name
| xref:StdinReady.adoc[`StdinReady`] 
| Reports whether standard input has data available to read&period;
| xref:StdinTerminal.adoc[`StdinTerminal`] 
| Reports whether standard input is connected to a terminal&period;
| xref:StopHTTPRPC.adoc[`StopHTTPRPC`] 
| Stop HTTP RPC subsystem&period; Precondition&semi; HTTP and RPC has been stopped&period;
| xref:StopHTTPServer.adoc[`StopHTTPServer`] 
| Stop HTTP server
| xref:StopMapPort.adoc[`StopMapPort`] 
| Stop the port mapping thread and remove any established port mapping&period;
| xref:StopREST.adoc[`StopREST`] 
| Stop HTTP REST subsystem&period; Precondition&semi; HTTP and RPC has been stopped&period;
| xref:StopRPC.adoc[`StopRPC`] 
| Stop the RPC service and release its resources&period;
| xref:StrFormatInternalBug.adoc[`StrFormatInternalBug`] 
| Format an internal bug report message that includes its source location&period;
| xref:StringForBlockPolicyEstimateReason.adoc[`StringForBlockPolicyEstimateReason`] 
| Return a human&hyphen;readable name for a block policy estimate reason&period;
| xref:StringForFeeEstimateHorizon.adoc[`StringForFeeEstimateHorizon`] 
| Return a human&hyphen;readable name for a fee estimate horizon&period;
| xref:SubmitErrorString.adoc[`SubmitErrorString`] 
| Returns a human&hyphen;readable description of a task submission error&period;
| xref:SysErrorString.adoc[`SysErrorString`] 
| Return system error string from errno value&period; Use this instead of std&colon;&colon;strerror, which is not thread&hyphen;safe&period; For network errors use NetworkErrorString from sock&period;h instead&period;
| xref:TaggedHash.adoc[`TaggedHash`] 
| Return a HashWriter primed for tagged hashes (as specified in BIP 340)&period;
| xref:TestBlockValidity.adoc[`TestBlockValidity`] 
| Verify a block, including transactions&period;
| xref:TestLockPointValidity.adoc[`TestLockPointValidity`] 
| Test whether the LockPoints height and time are still valid on the current chain
| xref:Ticks.adoc[`Ticks`] 
| Helper to count the seconds of a duration&sol;time&lowbar;point&period;
| xref:TicksSeconds.adoc[`TicksSeconds`] 
| Count the whole seconds of a duration as a signed 64&hyphen;bit integer&period;
| xref:TicksSinceEpoch.adoc[`TicksSinceEpoch`] 
| Count the ticks of a time point&apos;s duration since the clock epoch&period;
| xref:TimingResistantEqual.adoc[`TimingResistantEqual`] 
| Timing&hyphen;attack&hyphen;resistant comparison&period; Takes time proportional to length of first argument&period;
| xref:ToByteVector.adoc[`ToByteVector`] 
| Copies the bytes of a container into a byte vector&period;
| xref:ToGenTxid.adoc[`ToGenTxid`] 
| Convert a TX&sol;WITNESS&lowbar;TX&sol;WTX CInv to a GenTxid&period;
| xref:ToIntegral.adoc[`ToIntegral`] 
| Convert string to integral type T&period; Leading whitespace, a leading &plus;, or any trailing character fail the parsing&period; The required format expressed as regex is `&hyphen;?&lsqb;0&hyphen;9&rsqb;&plus;` by default (or `&hyphen;?&lsqb;0&hyphen;9a&hyphen;fA&hyphen;F&rsqb;&plus;` if base &equals; 16)&period; The minus sign is only permitted for signed integer types&period;
| xref:ToKeyID-0d.adoc[`ToKeyID`] 
| `ToKeyID` overloads
| xref:ToLower-0a.adoc[`ToLower`] 
| `ToLower` overloads
| xref:ToScriptID.adoc[`ToScriptID`] 
| Convert a script&hyphen;hash destination back to a script identifier&period;
| xref:ToUpper-00.adoc[`ToUpper`] 
| `ToUpper` overloads
| xref:TransactionMerklePath.adoc[`TransactionMerklePath`] 
| Compute merkle path to the specified transaction
| xref:TransportTypeAsString.adoc[`TransportTypeAsString`] 
| Convert TransportProtocolType enum to a string value
| xref:TruncateFile.adoc[`TruncateFile`] 
| Truncate a file to the given length&period;
| xref:TryCreateDirectories.adoc[`TryCreateDirectories`] 
| Create a directory and any missing parent directories&period;
| xref:TryGetTotalRam.adoc[`TryGetTotalRam`] 
| Return the total RAM available on the current system, if detectable&period;
| xref:TryParseHex.adoc[`TryParseHex`] 
| Parse the hex string into bytes (uint8&lowbar;t or std&colon;&colon;byte)&period; Ignores whitespace&period; Returns nullopt on invalid input&period;
| xref:TrySub.adoc[`TrySub`] 
| Subtract j from i in place, only if it does not underflow&period;
| xref:TxDoc.adoc[`TxDoc`] 
| Explain the UniValue &quot;decoded&quot; transaction object, may include extra fields if processed by wallet
| xref:TxToUniv.adoc[`TxToUniv`] 
| Fill a JSON object with a human&hyphen;readable description of a transaction&period;
| xref:UCharCast-04.adoc[`UCharCast`] 
| `UCharCast` overloads
| xref:UCharSpanCast.adoc[`UCharSpanCast`] 
| Convert a span to a span of `&lsqb;const&rsqb;unsigned char` viewing the same memory&period;
| xref:UintToArith256.adoc[`UintToArith256`] 
| Converts a uint256 blob to an arithmetic 256&hyphen;bit integer&period;
| xref:UninterruptibleSleep.adoc[`UninterruptibleSleep`] 
| Sleep for the given duration without responding to interruption&period;
| xref:UnlockDirectory.adoc[`UnlockDirectory`] 
| Release a directory lock previously taken with LockDirectory&period;
| xref:UnregisterHTTPHandler.adoc[`UnregisterHTTPHandler`] 
| Unregister handler for prefix&period;
| xref:Unserialize-004.adoc[`Unserialize`] 
| `Unserialize` overloads
| xref:UnserializeFromVector.adoc[`UnserializeFromVector`] 
| Unserialize a length&hyphen;prefixed vector of objects from a stream&period;
| xref:UnserializeMany.adoc[`UnserializeMany`] 
| Unserialize several objects in sequence from the same stream&period;
| xref:UnserializeTransaction.adoc[`UnserializeTransaction`] 
| Basic transaction serialization format&colon; &hyphen; uint32&lowbar;t version &hyphen; std&colon;&colon;vector&lt;CTxIn&gt; vin &hyphen; std&colon;&colon;vector&lt;CTxOut&gt; vout &hyphen; uint32&lowbar;t nLockTime
| xref:Untranslated.adoc[`Untranslated`] 
| Mark a bilingual&lowbar;str as untranslated
| xref:UpdateInput.adoc[`UpdateInput`] 
| Write the scriptSig and witness from signature data back into an input&period;
| xref:UpdatePSBTOutput.adoc[`UpdatePSBTOutput`] 
| Updates a PSBTOutput with information from provider&period;
| xref:UrlDecode.adoc[`UrlDecode`] 
| Decode a percent&hyphen;encoded URL string&period;
| xref:UrlEncode.adoc[`UrlEncode`] 
| Percent&hyphen;encode a string for use in a URL&period;
| xref:Using.adoc[`Using`] 
| Cause serialization&sol;deserialization of an object to be done using a specified formatter class&period;
| xref:ValidateInputsStandardness.adoc[`ValidateInputsStandardness`] 
| Check for standard transaction types
| xref:ValueFromAmount.adoc[`ValueFromAmount`] 
| Convert an amount in satoshis into a JSON value denominated in whole coins&period;
| xref:Vector.adoc[`Vector`] 
| Construct a vector with the specified elements&period;
| xref:VerifyScript.adoc[`VerifyScript`] 
| Verify that an input&apos;s scriptSig and witness satisfy the output&apos;s scriptPubKey&period;
| xref:WrappedGetAddrInfo.adoc[`WrappedGetAddrInfo`] 
| Wrapper for getaddrinfo(3)&period; Do not use directly&colon; call Lookup&sol;LookupHost&sol;LookupNumeric&sol;LookupSubNet&period;
| xref:WriteBE16.adoc[`WriteBE16`] 
| Write a 16&hyphen;bit integer to a byte buffer in big&hyphen;endian order&period;
| xref:WriteBE32.adoc[`WriteBE32`] 
| Write a 32&hyphen;bit integer to a byte buffer in big&hyphen;endian order&period;
| xref:WriteBE64.adoc[`WriteBE64`] 
| Write a 64&hyphen;bit integer to a byte buffer in big&hyphen;endian order&period;
| xref:WriteBinaryFile.adoc[`WriteBinaryFile`] 
| Write contents of std&colon;&colon;string to a file&period;
| xref:WriteCompactSize-00.adoc[`WriteCompactSize`] 
| `WriteCompactSize` overloads
| xref:WriteHDKeypath.adoc[`WriteHDKeypath`] 
| Write HD keypaths as strings&period;
| xref:WriteLE16.adoc[`WriteLE16`] 
| Write a 16&hyphen;bit integer to a byte buffer in little&hyphen;endian order&period;
| xref:WriteLE32.adoc[`WriteLE32`] 
| Write a 32&hyphen;bit integer to a byte buffer in little&hyphen;endian order&period;
| xref:WriteLE64.adoc[`WriteLE64`] 
| Write a 64&hyphen;bit integer to a byte buffer in little&hyphen;endian order&period;
| xref:WriteVarInt-025.adoc[`WriteVarInt`] 
| `WriteVarInt` overloads
| xref:_.adoc[`&lowbar;`] 
| Translation marker macro helper&colon; return the literal unchanged at compile time&period;
| xref:assertion_fail.adoc[`assertion&lowbar;fail`]  [.small]#[noreturn]#
| Internal helper&period; The noreturn enables optimizers to discard invalid paths&period;
| xref:be16toh_internal.adoc[`be16toh&lowbar;internal`] 
| Converts a 16&hyphen;bit value from big&hyphen;endian byte order to host byte order&period;
| xref:be32toh_internal.adoc[`be32toh&lowbar;internal`] 
| Converts a 32&hyphen;bit value from big&hyphen;endian byte order to host byte order&period;
| xref:be64toh_internal.adoc[`be64toh&lowbar;internal`] 
| Converts a 64&hyphen;bit value from big&hyphen;endian byte order to host byte order&period;
| xref:blockToJSON.adoc[`blockToJSON`] 
| Block description to JSON
| xref:blockheaderToJSON.adoc[`blockheaderToJSON`] 
| Block header to JSON
| xref:btck_block_check.adoc[`btck&lowbar;block&lowbar;check`] 
| Perform context&hyphen;free validation checks on a btck&lowbar;Block&period;
| xref:btck_block_copy.adoc[`btck&lowbar;block&lowbar;copy`] 
| Copy a block&period; Blocks are reference counted, so this just increments the reference count&period;
| xref:btck_block_count_transactions.adoc[`btck&lowbar;block&lowbar;count&lowbar;transactions`] 
| Count the number of transactions contained in a block&period;
| xref:btck_block_create.adoc[`btck&lowbar;block&lowbar;create`] 
| Parse a serialized raw block into a new block object&period;
| xref:btck_block_destroy.adoc[`btck&lowbar;block&lowbar;destroy`] 
| Destroy the block&period;
| xref:btck_block_get_hash.adoc[`btck&lowbar;block&lowbar;get&lowbar;hash`] 
| Calculate and return the hash of a block&period;
| xref:btck_block_get_header.adoc[`btck&lowbar;block&lowbar;get&lowbar;header`] 
| Get the btck&lowbar;BlockHeader from the block&period;
| xref:btck_block_get_transaction_at.adoc[`btck&lowbar;block&lowbar;get&lowbar;transaction&lowbar;at`] 
| Get the transaction at the provided index&period; The returned transaction is not owned and depends on the lifetime of the block&period;
| xref:btck_block_hash_copy.adoc[`btck&lowbar;block&lowbar;hash&lowbar;copy`] 
| Copy a block hash&period;
| xref:btck_block_hash_create.adoc[`btck&lowbar;block&lowbar;hash&lowbar;create`] 
| Create a block hash from its raw data&period;
| xref:btck_block_hash_destroy.adoc[`btck&lowbar;block&lowbar;hash&lowbar;destroy`] 
| Destroy the block hash&period;
| xref:btck_block_hash_equals.adoc[`btck&lowbar;block&lowbar;hash&lowbar;equals`] 
| Check if two block hashes are equal&period;
| xref:btck_block_hash_to_bytes.adoc[`btck&lowbar;block&lowbar;hash&lowbar;to&lowbar;bytes`] 
| Serializes the block hash to bytes&period;
| xref:btck_block_header_copy.adoc[`btck&lowbar;block&lowbar;header&lowbar;copy`] 
| Copy a btck&lowbar;BlockHeader&period;
| xref:btck_block_header_create.adoc[`btck&lowbar;block&lowbar;header&lowbar;create`] 
| Create a btck&lowbar;BlockHeader from serialized data&period;
| xref:btck_block_header_destroy.adoc[`btck&lowbar;block&lowbar;header&lowbar;destroy`] 
| Destroy the btck&lowbar;BlockHeader&period;
| xref:btck_block_header_get_bits.adoc[`btck&lowbar;block&lowbar;header&lowbar;get&lowbar;bits`] 
| Get the nBits difficulty target from btck&lowbar;BlockHeader&period;
| xref:btck_block_header_get_hash.adoc[`btck&lowbar;block&lowbar;header&lowbar;get&lowbar;hash`] 
| Get the btck&lowbar;BlockHash&period;
| xref:btck_block_header_get_nonce.adoc[`btck&lowbar;block&lowbar;header&lowbar;get&lowbar;nonce`] 
| Get the nonce from btck&lowbar;BlockHeader&period;
| xref:btck_block_header_get_prev_hash.adoc[`btck&lowbar;block&lowbar;header&lowbar;get&lowbar;prev&lowbar;hash`] 
| Get the previous btck&lowbar;BlockHash from btck&lowbar;BlockHeader&period; The returned hash is unowned and only valid for the lifetime of the btck&lowbar;BlockHeader&period;
| xref:btck_block_header_get_timestamp.adoc[`btck&lowbar;block&lowbar;header&lowbar;get&lowbar;timestamp`] 
| Get the timestamp from btck&lowbar;BlockHeader&period;
| xref:btck_block_header_get_version.adoc[`btck&lowbar;block&lowbar;header&lowbar;get&lowbar;version`] 
| Get the version from btck&lowbar;BlockHeader&period;
| xref:btck_block_header_to_bytes.adoc[`btck&lowbar;block&lowbar;header&lowbar;to&lowbar;bytes`] 
| Serializes the btck&lowbar;BlockHeader to bytes&period; This is consensus serialization that is also used for the P2P network&period;
| xref:btck_block_read.adoc[`btck&lowbar;block&lowbar;read`] 
| Reads the block the passed in block tree entry points to from disk and returns it&period;
| xref:btck_block_spent_outputs_copy.adoc[`btck&lowbar;block&lowbar;spent&lowbar;outputs&lowbar;copy`] 
| Copy a block&apos;s spent outputs&period;
| xref:btck_block_spent_outputs_count.adoc[`btck&lowbar;block&lowbar;spent&lowbar;outputs&lowbar;count`] 
| Returns the number of transaction spent outputs whose data is contained in block spent outputs&period;
| xref:btck_block_spent_outputs_destroy.adoc[`btck&lowbar;block&lowbar;spent&lowbar;outputs&lowbar;destroy`] 
| Destroy the block spent outputs&period;
| xref:btck_block_spent_outputs_get_transaction_spent_outputs_at.adoc[`btck&lowbar;block&lowbar;spent&lowbar;outputs&lowbar;get&lowbar;transaction&lowbar;spent&lowbar;outputs&lowbar;at`] 
| Returns a transaction spent outputs contained in the block spent outputs at a certain index&period; The returned pointer is unowned and only valid for the lifetime of block&lowbar;spent&lowbar;outputs&period;
| xref:btck_block_spent_outputs_read.adoc[`btck&lowbar;block&lowbar;spent&lowbar;outputs&lowbar;read`] 
| Reads the block spent coins data the passed in block tree entry points to from disk and returns it&period;
| xref:btck_block_to_bytes.adoc[`btck&lowbar;block&lowbar;to&lowbar;bytes`] 
| Serializes the block through the passed in callback to bytes&period; This is consensus serialization that is also used for the P2P network&period;
| xref:btck_block_tree_entry_equals.adoc[`btck&lowbar;block&lowbar;tree&lowbar;entry&lowbar;equals`] 
| Check if two block tree entries are equal&period; Two block tree entries are equal when they point to the same block&period;
| xref:btck_block_tree_entry_get_ancestor.adoc[`btck&lowbar;block&lowbar;tree&lowbar;entry&lowbar;get&lowbar;ancestor`] 
| Return the ancestor of a btck&lowbar;BlockTreeEntry at the given height&period;
| xref:btck_block_tree_entry_get_block_hash.adoc[`btck&lowbar;block&lowbar;tree&lowbar;entry&lowbar;get&lowbar;block&lowbar;hash`] 
| Return the block hash associated with a block tree entry&period;
| xref:btck_block_tree_entry_get_block_header.adoc[`btck&lowbar;block&lowbar;tree&lowbar;entry&lowbar;get&lowbar;block&lowbar;header`] 
| Return the btck&lowbar;BlockHeader associated with this entry&period;
| xref:btck_block_tree_entry_get_height.adoc[`btck&lowbar;block&lowbar;tree&lowbar;entry&lowbar;get&lowbar;height`] 
| Return the height of a certain block tree entry&period;
| xref:btck_block_tree_entry_get_previous.adoc[`btck&lowbar;block&lowbar;tree&lowbar;entry&lowbar;get&lowbar;previous`] 
| Returns the previous block tree entry in the tree, or null if the current block tree entry is the genesis block&period;
| xref:btck_block_validation_state_copy.adoc[`btck&lowbar;block&lowbar;validation&lowbar;state&lowbar;copy`] 
| Copies the btck&lowbar;BlockValidationState&period;
| xref:btck_block_validation_state_create.adoc[`btck&lowbar;block&lowbar;validation&lowbar;state&lowbar;create`] 
| Create a new btck&lowbar;BlockValidationState&period;
| xref:btck_block_validation_state_destroy.adoc[`btck&lowbar;block&lowbar;validation&lowbar;state&lowbar;destroy`] 
| Destroy the btck&lowbar;BlockValidationState&period;
| xref:btck_block_validation_state_get_block_validation_result.adoc[`btck&lowbar;block&lowbar;validation&lowbar;state&lowbar;get&lowbar;block&lowbar;validation&lowbar;result`] 
| Returns the validation result from an opaque btck&lowbar;BlockValidationState pointer&period;
| xref:btck_block_validation_state_get_validation_mode.adoc[`btck&lowbar;block&lowbar;validation&lowbar;state&lowbar;get&lowbar;validation&lowbar;mode`] 
| Returns the validation mode from an opaque btck&lowbar;BlockValidationState pointer&period;
| xref:btck_chain_contains.adoc[`btck&lowbar;chain&lowbar;contains`] 
| Return true if the passed in chain contains the block tree entry&period;
| xref:btck_chain_get_by_height.adoc[`btck&lowbar;chain&lowbar;get&lowbar;by&lowbar;height`] 
| Retrieve a block tree entry by its height in the currently active chain&period; Once retrieved there is no guarantee that it remains in the active chain&period;
| xref:btck_chain_get_height.adoc[`btck&lowbar;chain&lowbar;get&lowbar;height`] 
| Return the height of the tip of the chain&period;
| xref:btck_chain_parameters_copy.adoc[`btck&lowbar;chain&lowbar;parameters&lowbar;copy`] 
| Copy the chain parameters&period;
| xref:btck_chain_parameters_create.adoc[`btck&lowbar;chain&lowbar;parameters&lowbar;create`] 
| Creates a chain parameters struct with default parameters based on the passed in chain type&period;
| xref:btck_chain_parameters_create_signet.adoc[`btck&lowbar;chain&lowbar;parameters&lowbar;create&lowbar;signet`] 
| Create a signet chain parameters struct with a user&hyphen;provided challenge&period;
| xref:btck_chain_parameters_destroy.adoc[`btck&lowbar;chain&lowbar;parameters&lowbar;destroy`] 
| Destroy the chain parameters&period;
| xref:btck_chain_parameters_get_consensus_params.adoc[`btck&lowbar;chain&lowbar;parameters&lowbar;get&lowbar;consensus&lowbar;params`] 
| Get btck&lowbar;ConsensusParams from btck&lowbar;ChainParameters&period; The returned btck&lowbar;ConsensusParams pointer is valid only for the lifetime of the btck&lowbar;ChainParameters object and must not be destroyed by the caller&period;
| xref:btck_chainstate_manager_create.adoc[`btck&lowbar;chainstate&lowbar;manager&lowbar;create`] 
| Create a chainstate manager&period; This is the main object for many validation tasks as well as for retrieving data from the chain and interacting with its chainstate and indexes&period;
| xref:btck_chainstate_manager_destroy.adoc[`btck&lowbar;chainstate&lowbar;manager&lowbar;destroy`] 
| Destroy the chainstate manager&period;
| xref:btck_chainstate_manager_get_active_chain.adoc[`btck&lowbar;chainstate&lowbar;manager&lowbar;get&lowbar;active&lowbar;chain`] 
| Returns the best known currently active chain&period; Its lifetime is dependent on the chainstate manager&period; It can be thought of as a view on a vector of block tree entries that form the best chain&period; The returned chain reference always points to the currently active best chain&period; However, state transitions within the chainstate manager (e&period;g&period;, processing blocks) will update the chain&apos;s contents&period; Data retrieved from this chain is only consistent up to the point when new data is processed in the chainstate manager&period; It is the user&apos;s responsibility to guard against these inconsistencies&period;
| xref:btck_chainstate_manager_get_best_entry.adoc[`btck&lowbar;chainstate&lowbar;manager&lowbar;get&lowbar;best&lowbar;entry`] 
| Get the btck&lowbar;BlockTreeEntry whose associated btck&lowbar;BlockHeader has the most known cumulative proof of work&period;
| xref:btck_chainstate_manager_get_block_tree_entry_by_hash.adoc[`btck&lowbar;chainstate&lowbar;manager&lowbar;get&lowbar;block&lowbar;tree&lowbar;entry&lowbar;by&lowbar;hash`] 
| Retrieve a block tree entry by its block hash&period;
| xref:btck_chainstate_manager_import_blocks.adoc[`btck&lowbar;chainstate&lowbar;manager&lowbar;import&lowbar;blocks`] 
| Triggers the start of a reindex if the wipe options were previously set for the chainstate manager&period; Can also import an array of existing block files selected by the user&period;
| xref:btck_chainstate_manager_options_create.adoc[`btck&lowbar;chainstate&lowbar;manager&lowbar;options&lowbar;create`] 
| Create options for the chainstate manager&period;
| xref:btck_chainstate_manager_options_destroy.adoc[`btck&lowbar;chainstate&lowbar;manager&lowbar;options&lowbar;destroy`] 
| Destroy the chainstate manager options&period;
| xref:btck_chainstate_manager_options_set_database_cache_bytes.adoc[`btck&lowbar;chainstate&lowbar;manager&lowbar;options&lowbar;set&lowbar;database&lowbar;cache&lowbar;bytes`] 
| Set the total database cache used by the chainstate manager&period;
| xref:btck_chainstate_manager_options_set_wipe_dbs.adoc[`btck&lowbar;chainstate&lowbar;manager&lowbar;options&lowbar;set&lowbar;wipe&lowbar;dbs`] 
| Sets wipe db in the options&period; In combination with calling xref:btck_chainstate_manager_import_blocks.adoc[`btck&lowbar;chainstate&lowbar;manager&lowbar;import&lowbar;blocks`] this triggers either a full reindex, or a reindex of just the chainstate database&period;
| xref:btck_chainstate_manager_options_set_worker_threads_num.adoc[`btck&lowbar;chainstate&lowbar;manager&lowbar;options&lowbar;set&lowbar;worker&lowbar;threads&lowbar;num`] 
| Set the number of available worker threads used during validation&period;
| xref:btck_chainstate_manager_options_update_block_tree_db_in_memory.adoc[`btck&lowbar;chainstate&lowbar;manager&lowbar;options&lowbar;update&lowbar;block&lowbar;tree&lowbar;db&lowbar;in&lowbar;memory`] 
| Sets block tree db in memory in the options&period;
| xref:btck_chainstate_manager_options_update_chainstate_db_in_memory.adoc[`btck&lowbar;chainstate&lowbar;manager&lowbar;options&lowbar;update&lowbar;chainstate&lowbar;db&lowbar;in&lowbar;memory`] 
| Sets chainstate db in memory in the options&period;
| xref:btck_chainstate_manager_process_block.adoc[`btck&lowbar;chainstate&lowbar;manager&lowbar;process&lowbar;block`] 
| Process and validate the passed in block with the chainstate manager&period; Processing first does checks on the block, and if these passed, saves it to disk&period; It then validates the block against the utxo set&period; If it is valid, the chain is extended with it&period; The return value is not indicative of the block&apos;s validity&period; Detailed information on the validity of the block can be retrieved by registering the `block&lowbar;checked` callback in the validation interface&period;
| xref:btck_chainstate_manager_process_block_header.adoc[`btck&lowbar;chainstate&lowbar;manager&lowbar;process&lowbar;block&lowbar;header`] 
| Processes and validates the provided btck&lowbar;BlockHeader&period;
| xref:btck_coin_confirmation_height.adoc[`btck&lowbar;coin&lowbar;confirmation&lowbar;height`] 
| Returns the block height where the transaction that created this coin was included in&period;
| xref:btck_coin_copy.adoc[`btck&lowbar;coin&lowbar;copy`] 
| Copy a coin&period;
| xref:btck_coin_destroy.adoc[`btck&lowbar;coin&lowbar;destroy`] 
| Destroy the coin&period;
| xref:btck_coin_get_output.adoc[`btck&lowbar;coin&lowbar;get&lowbar;output`] 
| Return the transaction output of a coin&period; The returned pointer is unowned and only valid for the lifetime of the coin&period;
| xref:btck_coin_is_coinbase.adoc[`btck&lowbar;coin&lowbar;is&lowbar;coinbase`] 
| Returns whether the containing transaction was a coinbase&period;
| xref:btck_context_copy.adoc[`btck&lowbar;context&lowbar;copy`] 
| Copy the context&period;
| xref:btck_context_create.adoc[`btck&lowbar;context&lowbar;create`] 
| Create a new kernel context&period; If the options have not been previously set, their corresponding fields will be initialized to default values&semi; the context will assume mainnet chain parameters and won&apos;t attempt to call the kernel notification callbacks&period;
| xref:btck_context_destroy.adoc[`btck&lowbar;context&lowbar;destroy`] 
| Destroy the context&period;
| xref:btck_context_interrupt.adoc[`btck&lowbar;context&lowbar;interrupt`] 
| Interrupt can be used to halt long&hyphen;running validation functions like when reindexing, importing or processing blocks&period;
| xref:btck_context_options_create.adoc[`btck&lowbar;context&lowbar;options&lowbar;create`] 
| Creates an empty context options&period;
| xref:btck_context_options_destroy.adoc[`btck&lowbar;context&lowbar;options&lowbar;destroy`] 
| Destroy the context options&period;
| xref:btck_context_options_set_chainparams.adoc[`btck&lowbar;context&lowbar;options&lowbar;set&lowbar;chainparams`] 
| Sets the chain params for the context options&period; The context created with the options will be configured for these chain parameters&period;
| xref:btck_context_options_set_notifications.adoc[`btck&lowbar;context&lowbar;options&lowbar;set&lowbar;notifications`] 
| Set the kernel notifications for the context options&period; The context created with the options will be configured with these notifications&period;
| xref:btck_context_options_set_validation_interface.adoc[`btck&lowbar;context&lowbar;options&lowbar;set&lowbar;validation&lowbar;interface`] 
| Set the validation interface callbacks for the context options&period; The context created with the options will be configured for these validation interface callbacks&period; The callbacks will then be triggered from validation events issued by the chainstate manager created from the same context&period;
| xref:btck_logging_connection_create.adoc[`btck&lowbar;logging&lowbar;connection&lowbar;create`] 
| Start logging messages through the provided callback&period; Log messages produced before this function is first called are buffered and on calling this function are logged immediately&period;
| xref:btck_logging_connection_destroy.adoc[`btck&lowbar;logging&lowbar;connection&lowbar;destroy`] 
| Stop logging and destroy the logging connection&period;
| xref:btck_logging_disable.adoc[`btck&lowbar;logging&lowbar;disable`] 
| This disables the global internal logger&period; No log messages will be buffered internally anymore once this is called and the buffer is cleared&period; This function should only be called once and is not thread or re&hyphen;entry safe&period; Log messages will be buffered until this function is called, or a logging connection is created&period; This must not be called while a logging connection already exists&period;
| xref:btck_logging_disable_category.adoc[`btck&lowbar;logging&lowbar;disable&lowbar;category`] 
| Disable a specific log category for the global internal logger&period; This changes a global setting and will override settings for all existing xref:btck_LoggingConnection-04.adoc[`btck&lowbar;LoggingConnection`] instances&period;
| xref:btck_logging_enable_category.adoc[`btck&lowbar;logging&lowbar;enable&lowbar;category`] 
| Enable a specific log category for the global internal logger&period; This changes a global setting and will override settings for all existing xref:btck_LoggingConnection-04.adoc[`btck&lowbar;LoggingConnection`] instances&period;
| xref:btck_logging_set_level_category.adoc[`btck&lowbar;logging&lowbar;set&lowbar;level&lowbar;category`] 
| Set the log level of the global internal logger&period; This does not enable the selected categories&period; Use xref:btck_logging_enable_category.adoc[`btck&lowbar;logging&lowbar;enable&lowbar;category`] to start logging from a specific, or all categories&period; This changes a global setting and will override settings for all existing xref:btck_LoggingConnection-04.adoc[`btck&lowbar;LoggingConnection`] instances&period;
| xref:btck_logging_set_options.adoc[`btck&lowbar;logging&lowbar;set&lowbar;options`] 
| Set some options for the global internal logger&period; This changes global settings and will override settings for all existing xref:btck_LoggingConnection-04.adoc[`btck&lowbar;LoggingConnection`] instances&period;
| xref:btck_precomputed_transaction_data_copy.adoc[`btck&lowbar;precomputed&lowbar;transaction&lowbar;data&lowbar;copy`] 
| Copy precomputed transaction data&period;
| xref:btck_precomputed_transaction_data_create.adoc[`btck&lowbar;precomputed&lowbar;transaction&lowbar;data&lowbar;create`] 
| Create precomputed transaction data for script verification&period;
| xref:btck_precomputed_transaction_data_destroy.adoc[`btck&lowbar;precomputed&lowbar;transaction&lowbar;data&lowbar;destroy`] 
| Destroy the precomputed transaction data&period;
| xref:btck_script_pubkey_copy.adoc[`btck&lowbar;script&lowbar;pubkey&lowbar;copy`] 
| Copy a script pubkey&period;
| xref:btck_script_pubkey_create.adoc[`btck&lowbar;script&lowbar;pubkey&lowbar;create`] 
| Create a script pubkey from serialized data&period;
| xref:btck_script_pubkey_destroy.adoc[`btck&lowbar;script&lowbar;pubkey&lowbar;destroy`] 
| Destroy the script pubkey&period;
| xref:btck_script_pubkey_to_bytes.adoc[`btck&lowbar;script&lowbar;pubkey&lowbar;to&lowbar;bytes`] 
| Serializes the script pubkey through the passed in callback to bytes&period;
| xref:btck_script_pubkey_verify.adoc[`btck&lowbar;script&lowbar;pubkey&lowbar;verify`] 
| Verify if the input at input&lowbar;index of tx&lowbar;to spends the script pubkey under the constraints specified by flags&period; If the `btck&lowbar;ScriptVerificationFlags&lowbar;WITNESS` flag is set in the flags bitfield, the amount parameter is used&period; If the taproot flag is set, the precomputed data must contain the spent outputs&period;
| xref:btck_set_mock_time.adoc[`btck&lowbar;set&lowbar;mock&lowbar;time`] 
| Override the current time with a fixed timestamp for testing&period;
| xref:btck_transaction_check.adoc[`btck&lowbar;transaction&lowbar;check`] 
| Run context&hyphen;free consensus validation on a btck&lowbar;Transaction&period;
| xref:btck_transaction_copy.adoc[`btck&lowbar;transaction&lowbar;copy`] 
| Copy a transaction&period; Transactions are reference counted, so this just increments the reference count&period;
| xref:btck_transaction_count_inputs.adoc[`btck&lowbar;transaction&lowbar;count&lowbar;inputs`] 
| Get the number of inputs of a transaction&period;
| xref:btck_transaction_count_outputs.adoc[`btck&lowbar;transaction&lowbar;count&lowbar;outputs`] 
| Get the number of outputs of a transaction&period;
| xref:btck_transaction_create.adoc[`btck&lowbar;transaction&lowbar;create`] 
| Create a new transaction from the serialized data&period;
| xref:btck_transaction_destroy.adoc[`btck&lowbar;transaction&lowbar;destroy`] 
| Destroy the transaction&period;
| xref:btck_transaction_get_input_at.adoc[`btck&lowbar;transaction&lowbar;get&lowbar;input&lowbar;at`] 
| Get the transaction input at the provided index&period; The returned transaction input is not owned and depends on the lifetime of the transaction&period;
| xref:btck_transaction_get_locktime.adoc[`btck&lowbar;transaction&lowbar;get&lowbar;locktime`] 
| Get a transaction&apos;s nLockTime value&period;
| xref:btck_transaction_get_output_at.adoc[`btck&lowbar;transaction&lowbar;get&lowbar;output&lowbar;at`] 
| Get the transaction outputs at the provided index&period; The returned transaction output is not owned and depends on the lifetime of the transaction&period;
| xref:btck_transaction_get_txid.adoc[`btck&lowbar;transaction&lowbar;get&lowbar;txid`] 
| Get the txid of a transaction&period; The returned txid is not owned and depends on the lifetime of the transaction&period;
| xref:btck_transaction_input_copy.adoc[`btck&lowbar;transaction&lowbar;input&lowbar;copy`] 
| Copy a transaction input&period;
| xref:btck_transaction_input_destroy.adoc[`btck&lowbar;transaction&lowbar;input&lowbar;destroy`] 
| Destroy the transaction input&period;
| xref:btck_transaction_input_get_out_point.adoc[`btck&lowbar;transaction&lowbar;input&lowbar;get&lowbar;out&lowbar;point`] 
| Get the transaction out point&period; The returned transaction out point is not owned and depends on the lifetime of the transaction&period;
| xref:btck_transaction_input_get_script_sig.adoc[`btck&lowbar;transaction&lowbar;input&lowbar;get&lowbar;script&lowbar;sig`] 
| Serialize the script sig of a transaction input through the passed in callback&period;
| xref:btck_transaction_input_get_sequence.adoc[`btck&lowbar;transaction&lowbar;input&lowbar;get&lowbar;sequence`] 
| Get a transaction input&apos;s nSequence value&period;
| xref:btck_transaction_input_get_witness_stack.adoc[`btck&lowbar;transaction&lowbar;input&lowbar;get&lowbar;witness&lowbar;stack`] 
| Get the witness stack of a transaction input&period; The returned witness stack is not owned and depends on the lifetime of the transaction input&period;
| xref:btck_transaction_out_point_copy.adoc[`btck&lowbar;transaction&lowbar;out&lowbar;point&lowbar;copy`] 
| Copy a transaction out point&period;
| xref:btck_transaction_out_point_destroy.adoc[`btck&lowbar;transaction&lowbar;out&lowbar;point&lowbar;destroy`] 
| Destroy the transaction out point&period;
| xref:btck_transaction_out_point_get_index.adoc[`btck&lowbar;transaction&lowbar;out&lowbar;point&lowbar;get&lowbar;index`] 
| Get the output position from the transaction out point&period;
| xref:btck_transaction_out_point_get_txid.adoc[`btck&lowbar;transaction&lowbar;out&lowbar;point&lowbar;get&lowbar;txid`] 
| Get the txid from the transaction out point&period; The returned txid is not owned and depends on the lifetime of the transaction out point&period;
| xref:btck_transaction_output_copy.adoc[`btck&lowbar;transaction&lowbar;output&lowbar;copy`] 
| Copy a transaction output&period;
| xref:btck_transaction_output_create.adoc[`btck&lowbar;transaction&lowbar;output&lowbar;create`] 
| Create a transaction output from a script pubkey and an amount&period;
| xref:btck_transaction_output_destroy.adoc[`btck&lowbar;transaction&lowbar;output&lowbar;destroy`] 
| Destroy the transaction output&period;
| xref:btck_transaction_output_get_amount.adoc[`btck&lowbar;transaction&lowbar;output&lowbar;get&lowbar;amount`] 
| Get the amount in the output&period;
| xref:btck_transaction_output_get_script_pubkey.adoc[`btck&lowbar;transaction&lowbar;output&lowbar;get&lowbar;script&lowbar;pubkey`] 
| Get the script pubkey of the output&period; The returned script pubkey is not owned and depends on the lifetime of the transaction output&period;
| xref:btck_transaction_spent_outputs_copy.adoc[`btck&lowbar;transaction&lowbar;spent&lowbar;outputs&lowbar;copy`] 
| Copy a transaction&apos;s spent outputs&period;
| xref:btck_transaction_spent_outputs_count.adoc[`btck&lowbar;transaction&lowbar;spent&lowbar;outputs&lowbar;count`] 
| Returns the number of previous transaction outputs contained in the transaction spent outputs data&period;
| xref:btck_transaction_spent_outputs_destroy.adoc[`btck&lowbar;transaction&lowbar;spent&lowbar;outputs&lowbar;destroy`] 
| Destroy the transaction spent outputs&period;
| xref:btck_transaction_spent_outputs_get_coin_at.adoc[`btck&lowbar;transaction&lowbar;spent&lowbar;outputs&lowbar;get&lowbar;coin&lowbar;at`] 
| Returns a coin contained in the transaction spent outputs at a certain index&period; The returned pointer is unowned and only valid for the lifetime of transaction&lowbar;spent&lowbar;outputs&period;
| xref:btck_transaction_to_bytes.adoc[`btck&lowbar;transaction&lowbar;to&lowbar;bytes`] 
| Serializes the transaction through the passed in callback to bytes&period; This is consensus serialization that is also used for the P2P network&period;
| xref:btck_tx_validation_state_create.adoc[`btck&lowbar;tx&lowbar;validation&lowbar;state&lowbar;create`] 
| Create a new btck&lowbar;TxValidationState&period;
| xref:btck_tx_validation_state_destroy.adoc[`btck&lowbar;tx&lowbar;validation&lowbar;state&lowbar;destroy`] 
| Destroy the btck&lowbar;TxValidationState&period;
| xref:btck_tx_validation_state_get_tx_validation_result.adoc[`btck&lowbar;tx&lowbar;validation&lowbar;state&lowbar;get&lowbar;tx&lowbar;validation&lowbar;result`] 
| Returns the validation result from an opaque btck&lowbar;TxValidationState pointer&period;
| xref:btck_tx_validation_state_get_validation_mode.adoc[`btck&lowbar;tx&lowbar;validation&lowbar;state&lowbar;get&lowbar;validation&lowbar;mode`] 
| Returns the validation mode from an opaque btck&lowbar;TxValidationState pointer&period;
| xref:btck_txid_copy.adoc[`btck&lowbar;txid&lowbar;copy`] 
| Copy a txid&period;
| xref:btck_txid_destroy.adoc[`btck&lowbar;txid&lowbar;destroy`] 
| Destroy the txid&period;
| xref:btck_txid_equals.adoc[`btck&lowbar;txid&lowbar;equals`] 
| Check if two txids are equal&period;
| xref:btck_txid_to_bytes.adoc[`btck&lowbar;txid&lowbar;to&lowbar;bytes`] 
| Serializes the txid to bytes&period;
| xref:btck_witness_stack_copy.adoc[`btck&lowbar;witness&lowbar;stack&lowbar;copy`] 
| Copy a witness stack&period;
| xref:btck_witness_stack_count_items.adoc[`btck&lowbar;witness&lowbar;stack&lowbar;count&lowbar;items`] 
| Return the number of items in a witness stack&period;
| xref:btck_witness_stack_destroy.adoc[`btck&lowbar;witness&lowbar;stack&lowbar;destroy`] 
| Destroy the witness stack&period;
| xref:btck_witness_stack_get_item_at.adoc[`btck&lowbar;witness&lowbar;stack&lowbar;get&lowbar;item&lowbar;at`] 
| Serialize a witness stack item at a given index through the passed in callback&period;
| xref:count_microseconds.adoc[`count&lowbar;microseconds`] 
| Return the whole&hyphen;microsecond count of a microseconds duration&period;
| xref:count_milliseconds.adoc[`count&lowbar;milliseconds`] 
| Return the whole&hyphen;millisecond count of a milliseconds duration&period;
| xref:count_seconds.adoc[`count&lowbar;seconds`] 
| Return the whole&hyphen;second count of a seconds duration&period;
| xref:htobe16_internal.adoc[`htobe16&lowbar;internal`] 
| Converts a 16&hyphen;bit value from host byte order to big&hyphen;endian byte order&period;
| xref:htobe32_internal.adoc[`htobe32&lowbar;internal`] 
| Converts a 32&hyphen;bit value from host byte order to big&hyphen;endian byte order&period;
| xref:htobe64_internal.adoc[`htobe64&lowbar;internal`] 
| Converts a 64&hyphen;bit value from host byte order to big&hyphen;endian byte order&period;
| xref:htole16_internal.adoc[`htole16&lowbar;internal`] 
| Converts a 16&hyphen;bit value from host byte order to little&hyphen;endian byte order&period;
| xref:htole32_internal.adoc[`htole32&lowbar;internal`] 
| Converts a 32&hyphen;bit value from host byte order to little&hyphen;endian byte order&period;
| xref:htole64_internal.adoc[`htole64&lowbar;internal`] 
| Converts a 64&hyphen;bit value from host byte order to little&hyphen;endian byte order&period;
| xref:inline_assertion_check.adoc[`inline&lowbar;assertion&lowbar;check`] 
| Helper for Assert()&sol;Assume()&period;
| xref:inline_check_non_fatal.adoc[`inline&lowbar;check&lowbar;non&lowbar;fatal`] 
| Helper for CHECK&lowbar;NONFATAL()&period;
| xref:internal_bswap_16.adoc[`internal&lowbar;bswap&lowbar;16`] 
| Reverses the byte order of a 16&hyphen;bit value&period;
| xref:internal_bswap_32.adoc[`internal&lowbar;bswap&lowbar;32`] 
| Reverses the byte order of a 32&hyphen;bit value&period;
| xref:internal_bswap_64.adoc[`internal&lowbar;bswap&lowbar;64`] 
| Reverses the byte order of a 64&hyphen;bit value&period;
| xref:le16toh_internal.adoc[`le16toh&lowbar;internal`] 
| Converts a 16&hyphen;bit value from little&hyphen;endian byte order to host byte order&period;
| xref:le32toh_internal.adoc[`le32toh&lowbar;internal`] 
| Converts a 32&hyphen;bit value from little&hyphen;endian byte order to host byte order&period;
| xref:le64toh_internal.adoc[`le64toh&lowbar;internal`] 
| Converts a 64&hyphen;bit value from little&hyphen;endian byte order to host byte order&period;
| xref:make_secure_unique.adoc[`make&lowbar;secure&lowbar;unique`] 
| Constructs an object of type T in secure memory and returns owning pointer&period;
| xref:memory_cleanse.adoc[`memory&lowbar;cleanse`] 
| Secure overwrite a buffer (possibly containing secret data) with zero&hyphen;bytes&period; The write operation will not be optimized out by the compiler&period;
| xref:noui_InitMessage.adoc[`noui&lowbar;InitMessage`] 
| Non&hyphen;GUI handler, which only logs a message&period;
| xref:noui_ThreadSafeMessageBox.adoc[`noui&lowbar;ThreadSafeMessageBox`] 
| Non&hyphen;GUI handler, which logs and prints messages&period;
| xref:noui_ThreadSafeQuestion.adoc[`noui&lowbar;ThreadSafeQuestion`] 
| Non&hyphen;GUI handler, which logs and prints questions&period;
| xref:noui_connect.adoc[`noui&lowbar;connect`] 
| Connect all bitcoind signal handlers
| xref:noui_reconnect.adoc[`noui&lowbar;reconnect`] 
| Reconnects the regular Non&hyphen;GUI handlers after having used noui&lowbar;test&lowbar;redirect
| xref:noui_test_redirect.adoc[`noui&lowbar;test&lowbar;redirect`] 
| Redirect all bitcoind signal handlers to LogInfo&period; Used to check or suppress output during test runs that produce expected errors
| xref:operator_GiB.adoc[`operator&quot;&quot;&lowbar;GiB`] 
| Conversion of GiB to bytes&period;
| xref:operator_MiB.adoc[`operator&quot;&quot;&lowbar;MiB`] 
| Conversion of MiB to bytes&period;
| xref:operator_bitand-08.adoc[`operator&amp;`] 
| Bitwise conjunction operators
| xref:operator_star-0c.adoc[`operator&ast;`] 
| Multiplication operators
| xref:operator_plus-03.adoc[`operator&plus;`] 
| Addition operators
| xref:operator_minus-0c.adoc[`operator&hyphen;`] 
| Subtraction operators
| xref:operator_slash-05.adoc[`operator&sol;`] 
| Returns the quotient of two big integers&period;
| xref:operator_rshift-06.adoc[`operator&gt;&gt;`] 
| Returns the value shifted right by a number of bits&period;
| xref:operator_xor-05.adoc[`operator&circ;`] 
| Returns the bitwise XOR of two big integers&period;
| xref:operator_bitor-0e.adoc[`operator&verbar;`] 
| Bitwise disjunction operators
| xref:operator_bitnot.adoc[`operator&#126;`] 
| Bitwise complement of a single flag name&period;
| xref:ser_readdata16.adoc[`ser&lowbar;readdata16`] 
| Read a 16&hyphen;bit little&hyphen;endian integer from a stream and convert it to host byte order&period;
| xref:ser_readdata32.adoc[`ser&lowbar;readdata32`] 
| Read a 32&hyphen;bit little&hyphen;endian integer from a stream and convert it to host byte order&period;
| xref:ser_readdata32be.adoc[`ser&lowbar;readdata32be`] 
| Read a 32&hyphen;bit big&hyphen;endian integer from a stream and convert it to host byte order&period;
| xref:ser_readdata64.adoc[`ser&lowbar;readdata64`] 
| Read a 64&hyphen;bit little&hyphen;endian integer from a stream and convert it to host byte order&period;
| xref:ser_readdata8.adoc[`ser&lowbar;readdata8`] 
| Read a byte from a stream&period;
| xref:ser_writedata16.adoc[`ser&lowbar;writedata16`] 
| Write a 16&hyphen;bit integer to a stream in little&hyphen;endian byte order&period;
| xref:ser_writedata32.adoc[`ser&lowbar;writedata32`] 
| Write a 32&hyphen;bit integer to a stream in little&hyphen;endian byte order&period;
| xref:ser_writedata32be.adoc[`ser&lowbar;writedata32be`] 
| Write a 32&hyphen;bit integer to a stream in big&hyphen;endian byte order&period;
| xref:ser_writedata64.adoc[`ser&lowbar;writedata64`] 
| Write a 64&hyphen;bit integer to a stream in little&hyphen;endian byte order&period;
| xref:ser_writedata8.adoc[`ser&lowbar;writedata8`] 
| Write a byte to a stream&period;
| xref:serviceFlagsToStr.adoc[`serviceFlagsToStr`] 
| Convert service flags (a bitmask of NODE&lowbar;&ast;) to human readable strings&period; It supports unknown service flags which will be returned as &quot;UNKNOWN&lsqb;&period;&period;&period;&rsqb;&quot;&period;
| xref:swap-05.adoc[`swap`] 
| `swap` overloads
| xref:zmqError.adoc[`zmqError`] 
| Log a ZMQ error together with the underlying libzmq error message&period;
| xref:operator_lshift-05.adoc[`operator&lt;&lt;`] 
| Returns the value shifted left by a number of bits&period;
| xref:operator_eq-073.adoc[`operator&equals;&equals;`] 
| Equality operators
| xref:operator_lt-079.adoc[`operator&lt;`] 
| Less&hyphen;than operators
| xref:operator_le.adoc[`operator&lt;&equals;`] 
| Check whether the first feerate is lower than or equal to the second&period;
| xref:operator_gt-06.adoc[`operator&gt;`] 
| Greater&hyphen;than operators
| xref:operator_ge.adoc[`operator&gt;&equals;`] 
| Check whether the first feerate is higher than or equal to the second&period;
| xref:operator_3way-01.adoc[`operator&lt;&equals;&gt;`] 
| Three&hyphen;way comparison operators
|===


== Variables

[cols="1,4"]
|===
| Name| Description
| xref:ACCEPTABLE_COST.adoc[`ACCEPTABLE&lowbar;COST`] 
| How much linearization cost required for TxGraph clusters to have &quot;acceptable&quot; quality, if they cannot be optimally linearized with less cost&period;
| xref:ADDRMAN_HORIZON.adoc[`ADDRMAN&lowbar;HORIZON`] 
| How old addresses can maximally be
| xref:ADDRMAN_MAX_FAILURES.adoc[`ADDRMAN&lowbar;MAX&lowbar;FAILURES`] 
| How many successive failures are allowed &period;&period;&period;
| xref:ADDRMAN_MIN_FAIL.adoc[`ADDRMAN&lowbar;MIN&lowbar;FAIL`] 
| &period;&period;&period; in at least this duration
| xref:ADDRMAN_NEW_BUCKETS_PER_ADDRESS.adoc[`ADDRMAN&lowbar;NEW&lowbar;BUCKETS&lowbar;PER&lowbar;ADDRESS`] 
| Maximum number of times an address can occur in the new table
| xref:ADDRMAN_NEW_BUCKETS_PER_SOURCE_GROUP.adoc[`ADDRMAN&lowbar;NEW&lowbar;BUCKETS&lowbar;PER&lowbar;SOURCE&lowbar;GROUP`] 
| Over how many buckets entries with new addresses originating from a single group are spread
| xref:ADDRMAN_REPLACEMENT.adoc[`ADDRMAN&lowbar;REPLACEMENT`] 
| How recent a successful connection should be before we allow an address to be evicted from tried
| xref:ADDRMAN_RETRIES.adoc[`ADDRMAN&lowbar;RETRIES`] 
| After how many failed attempts we give up on a new node
| xref:ADDRMAN_SET_TRIED_COLLISION_SIZE.adoc[`ADDRMAN&lowbar;SET&lowbar;TRIED&lowbar;COLLISION&lowbar;SIZE`] 
| The maximum number of tried addr collisions to store
| xref:ADDRMAN_TEST_WINDOW.adoc[`ADDRMAN&lowbar;TEST&lowbar;WINDOW`] 
| The maximum time we&apos;ll spend trying to resolve a tried table collision
| xref:ADDRMAN_TRIED_BUCKETS_PER_GROUP.adoc[`ADDRMAN&lowbar;TRIED&lowbar;BUCKETS&lowbar;PER&lowbar;GROUP`] 
| Over how many buckets entries with tried addresses from a single group (&sol;16 for IPv4) are spread
| xref:ADDR_CJDNS_SIZE.adoc[`ADDR&lowbar;CJDNS&lowbar;SIZE`] 
| Size of CJDNS address (in bytes)&period;
| xref:ADDR_I2P_SIZE.adoc[`ADDR&lowbar;I2P&lowbar;SIZE`] 
| Size of I2P address (in bytes)&period;
| xref:ADDR_INTERNAL_SIZE.adoc[`ADDR&lowbar;INTERNAL&lowbar;SIZE`] 
| Size of &quot;internal&quot; (NET&lowbar;INTERNAL) address (in bytes)&period;
| xref:ADDR_IPV4_SIZE.adoc[`ADDR&lowbar;IPV4&lowbar;SIZE`] 
| Size of IPv4 address (in bytes)&period;
| xref:ADDR_IPV6_SIZE.adoc[`ADDR&lowbar;IPV6&lowbar;SIZE`] 
| Size of IPv6 address (in bytes)&period;
| xref:ADDR_PREFIX_IPC.adoc[`ADDR&lowbar;PREFIX&lowbar;IPC`] 
| Prefix for unix domain socket addresses (which are local filesystem paths)
| xref:ADDR_PREFIX_UNIX.adoc[`ADDR&lowbar;PREFIX&lowbar;UNIX`] 
| Prefix for unix domain socket addresses (which are local filesystem paths)
| xref:ADDR_TORV3_SIZE.adoc[`ADDR&lowbar;TORV3&lowbar;SIZE`] 
| Size of TORv3 address (in bytes)&period; This is the length of just the address as used in BIP155, without the checksum and the version byte&period;
| xref:AES256_KEYSIZE.adoc[`AES256&lowbar;KEYSIZE`] 
| Size of an AES&hyphen;256 key, in bytes&period;
| xref:AES_BLOCKSIZE.adoc[`AES&lowbar;BLOCKSIZE`] 
| Size of an AES block, in bytes&period;
| xref:ALL_FEE_ESTIMATE_HORIZONS.adoc[`ALL&lowbar;FEE&lowbar;ESTIMATE&lowbar;HORIZONS`] 
| All fee estimate horizons, in increasing order of half&hyphen;life&period;
| xref:ALL_NET_MESSAGE_TYPES.adoc[`ALL&lowbar;NET&lowbar;MESSAGE&lowbar;TYPES`] 
| All known message types (see above)&period; Keep this in the same order as the list of messages above&period;
| xref:ALWAYS_FALSE.adoc[`ALWAYS&lowbar;FALSE`] 
| Always&hyphen;false variable template used to make static&lowbar;assert dependent on a type&period;
| xref:ANCHOR_BYTES.adoc[`ANCHOR&lowbar;BYTES`] 
| Witness program for Pay&hyphen;to&hyphen;Anchor output script type
| xref:ANNEX_TAG.adoc[`ANNEX&lowbar;TAG`] 
| Tag for the input annex&period;
| xref:ASMAP_HEALTH_CHECK_INTERVAL.adoc[`ASMAP&lowbar;HEALTH&lowbar;CHECK&lowbar;INTERVAL`] 
| Interval for ASMap Health Check &ast;
| xref:BASIC_FILTER_M.adoc[`BASIC&lowbar;FILTER&lowbar;M`] 
| Inverse false positive rate M for the basic block filter type&period;
| xref:BASIC_FILTER_P.adoc[`BASIC&lowbar;FILTER&lowbar;P`] 
| Golomb&hyphen;Rice coding parameter P for the basic block filter type&period;
| xref:BIP0031_VERSION.adoc[`BIP0031&lowbar;VERSION`] 
| BIP 0031, pong message, is enabled for all versions AFTER this one
| xref:BIP324_SHORTIDS_IMPLEMENTED.adoc[`BIP324&lowbar;SHORTIDS&lowbar;IMPLEMENTED`] 
| Protocol version at which BIP324 short message IDs are implemented&period;
| xref:BIP32_EXTKEY_SIZE.adoc[`BIP32&lowbar;EXTKEY&lowbar;SIZE`] 
| Size in bytes of a BIP32 extended key serialization without the version prefix&period;
| xref:BIP32_EXTKEY_WITH_VERSION_SIZE.adoc[`BIP32&lowbar;EXTKEY&lowbar;WITH&lowbar;VERSION&lowbar;SIZE`] 
| Size in bytes of a BIP32 extended key serialization including the version prefix&period;
| xref:BITCOIN_CONF_FILENAME.adoc[`BITCOIN&lowbar;CONF&lowbar;FILENAME`] 
| Default file name of the read&hyphen;only configuration file&period;
| xref:BITCOIN_SETTINGS_FILENAME.adoc[`BITCOIN&lowbar;SETTINGS&lowbar;FILENAME`] 
| Default file name of the read&hyphen;write settings file&period;
| xref:CACHE_LIFE.adoc[`CACHE&lowbar;LIFE`] 
| Maximum age of a cached fee rate estimate before it is considered stale&period;
| xref:CFCHECKPT_INTERVAL.adoc[`CFCHECKPT&lowbar;INTERVAL`] 
| Interval between compact filter checkpoints&period; See BIP 157&period;
| xref:CHECKLEVEL_DOC.adoc[`CHECKLEVEL&lowbar;DOC`] 
| Documentation for argument &apos;checklevel&apos;&period;
| xref:CJDNS_PREFIX.adoc[`CJDNS&lowbar;PREFIX`] 
| All CJDNS addresses start with 0xFC&period; See https&colon;&sol;&sol;github&period;com&sol;cjdelisle&sol;cjdns&sol;blob&sol;master&sol;doc&sol;Whitepaper&period;md&num;pulling&hyphen;it&hyphen;all&hyphen;together
| xref:CLIENT_VERSION.adoc[`CLIENT&lowbar;VERSION`] 
| Numeric client version encoded as 10000_major &plus; 100_minor &plus; build&period;
| xref:CMPCTBLOCKS_VERSION.adoc[`CMPCTBLOCKS&lowbar;VERSION`] 
| The compactblocks version we support&period; See BIP 152&period;
| xref:COIN-06.adoc[`COIN`] 
| The amount of satoshis in one BTC&period;
| xref:COINBASE_MATURITY.adoc[`COINBASE&lowbar;MATURITY`] 
| Coinbase transaction outputs can only be spent after this number of new blocks (network rule)
| xref:CURRENCY_ATOM.adoc[`CURRENCY&lowbar;ATOM`] 
| One indivisible minimum value unit (&quot;sat&quot;)&period;
| xref:CURRENCY_UNIT.adoc[`CURRENCY&lowbar;UNIT`] 
| One formatted currency unit (&quot;BTC&quot;)&period;
| xref:CaptureMessage.adoc[`CaptureMessage`] 
| Defaults to `CaptureMessageToFile()`, but can be overridden by unit tests&period;
| xref:CreateSock.adoc[`CreateSock`] 
| Socket factory&period; Defaults to `CreateSockOS()`, but can be overridden by unit tests&period;
| xref:DBCACHE_WARNING_RESERVED_RAM.adoc[`DBCACHE&lowbar;WARNING&lowbar;RESERVED&lowbar;RAM`] 
| Reserved non&hyphen;dbcache memory usage&period;
| xref:DBWRAPPER_MAX_FILE_SIZE.adoc[`DBWRAPPER&lowbar;MAX&lowbar;FILE&lowbar;SIZE`] 
| Maximum size of a single LevelDB SST file&period;
| xref:DBWRAPPER_PREALLOC_KEY_SIZE.adoc[`DBWRAPPER&lowbar;PREALLOC&lowbar;KEY&lowbar;SIZE`] 
| Preallocated buffer size, in bytes, for serialized keys&period;
| xref:DBWRAPPER_PREALLOC_VALUE_SIZE.adoc[`DBWRAPPER&lowbar;PREALLOC&lowbar;VALUE&lowbar;SIZE`] 
| Preallocated buffer size, in bytes, for serialized values&period;
| xref:DEFAULT_ACCEPT_DATACARRIER.adoc[`DEFAULT&lowbar;ACCEPT&lowbar;DATACARRIER`] 
| Default for &hyphen;datacarrier
| xref:DEFAULT_ACCEPT_NON_STD_TXN.adoc[`DEFAULT&lowbar;ACCEPT&lowbar;NON&lowbar;STD&lowbar;TXN`] 
| Default for &hyphen;acceptnonstdtxn
| xref:DEFAULT_ACCEPT_STALE_FEE_ESTIMATES.adoc[`DEFAULT&lowbar;ACCEPT&lowbar;STALE&lowbar;FEE&lowbar;ESTIMATES`] 
| Whether we allow importing a fee&lowbar;estimates file older than MAX&lowbar;FILE&lowbar;AGE&period;
| xref:DEFAULT_ADDRMAN_CONSISTENCY_CHECKS.adoc[`DEFAULT&lowbar;ADDRMAN&lowbar;CONSISTENCY&lowbar;CHECKS`] 
| Default for &hyphen;checkaddrman
| xref:DEFAULT_ANCESTOR_LIMIT.adoc[`DEFAULT&lowbar;ANCESTOR&lowbar;LIMIT`] 
| Default for &hyphen;limitancestorcount, max number of in&hyphen;mempool ancestors
| xref:DEFAULT_BLOCKFILTERINDEX.adoc[`DEFAULT&lowbar;BLOCKFILTERINDEX`] 
| Default value for the &hyphen;blockfilterindex option (no filter index enabled)&period;
| xref:DEFAULT_BLOCKSONLY.adoc[`DEFAULT&lowbar;BLOCKSONLY`] 
| Default for blocks only
| xref:DEFAULT_BLOCKSONLY_MAX_MEMPOOL_SIZE_MB.adoc[`DEFAULT&lowbar;BLOCKSONLY&lowbar;MAX&lowbar;MEMPOOL&lowbar;SIZE&lowbar;MB`] 
| Default for &hyphen;maxmempool when blocksonly is set
| xref:DEFAULT_BLOCK_MAX_WEIGHT.adoc[`DEFAULT&lowbar;BLOCK&lowbar;MAX&lowbar;WEIGHT`] 
| Default for &hyphen;blockmaxweight, which controls the range of block weights the mining code will create &ast;
| xref:DEFAULT_BLOCK_MIN_TX_FEE.adoc[`DEFAULT&lowbar;BLOCK&lowbar;MIN&lowbar;TX&lowbar;FEE`] 
| Default for &hyphen;blockmintxfee, which sets the minimum feerate for a transaction in blocks created by mining code &ast;
| xref:DEFAULT_BLOCK_RECONSTRUCTION_EXTRA_TXN.adoc[`DEFAULT&lowbar;BLOCK&lowbar;RECONSTRUCTION&lowbar;EXTRA&lowbar;TXN`] 
| Default number of non&hyphen;mempool transactions to keep around for block reconstruction&period; Includes orphan, replaced, and rejected transactions&period;
| xref:DEFAULT_BLOCK_RESERVED_WEIGHT.adoc[`DEFAULT&lowbar;BLOCK&lowbar;RESERVED&lowbar;WEIGHT`] 
| Default for &hyphen;blockreservedweight &ast;
| xref:DEFAULT_BYTES_PER_SIGOP.adoc[`DEFAULT&lowbar;BYTES&lowbar;PER&lowbar;SIGOP`] 
| Default for &hyphen;bytespersigop
| xref:DEFAULT_CHECKBLOCKS.adoc[`DEFAULT&lowbar;CHECKBLOCKS`] 
| Default number of blocks to verify at startup (the &hyphen;checkblocks setting)&period;
| xref:DEFAULT_CHECKLEVEL.adoc[`DEFAULT&lowbar;CHECKLEVEL`] 
| Default depth of block&hyphen;verification checks performed at startup (the &hyphen;checklevel setting)&period;
| xref:DEFAULT_CLUSTER_LIMIT.adoc[`DEFAULT&lowbar;CLUSTER&lowbar;LIMIT`] 
| Maximum number of transactions per cluster (default)
| xref:DEFAULT_CLUSTER_SIZE_LIMIT_KVB.adoc[`DEFAULT&lowbar;CLUSTER&lowbar;SIZE&lowbar;LIMIT&lowbar;KVB`] 
| Maximum size of cluster in virtual kilobytes
| xref:DEFAULT_COINBASE_OUTPUT_MAX_ADDITIONAL_SIGOPS.adoc[`DEFAULT&lowbar;COINBASE&lowbar;OUTPUT&lowbar;MAX&lowbar;ADDITIONAL&lowbar;SIGOPS`] 
| Default sigops cost to reserve for coinbase transaction outputs when creating block templates&period;
| xref:DEFAULT_COINSTATSINDEX.adoc[`DEFAULT&lowbar;COINSTATSINDEX`] 
| Default value for the &hyphen;coinstatsindex option (index disabled)&period;
| xref:DEFAULT_CONNECT_TIMEOUT.adoc[`DEFAULT&lowbar;CONNECT&lowbar;TIMEOUT`] 
| &hyphen;timeout default
| xref:DEFAULT_DAEMON.adoc[`DEFAULT&lowbar;DAEMON`] 
| Default value for &hyphen;daemon option
| xref:DEFAULT_DAEMONWAIT.adoc[`DEFAULT&lowbar;DAEMONWAIT`] 
| Default value for &hyphen;daemonwait option
| xref:DEFAULT_DB_CACHE_BATCH.adoc[`DEFAULT&lowbar;DB&lowbar;CACHE&lowbar;BATCH`] 
| Default LevelDB write batch size
| xref:DEFAULT_DEBUGLOGFILE.adoc[`DEFAULT&lowbar;DEBUGLOGFILE`] 
| Default file name for the debug log&period;
| xref:DEFAULT_DESCENDANT_LIMIT.adoc[`DEFAULT&lowbar;DESCENDANT&lowbar;LIMIT`] 
| Default for &hyphen;limitdescendantcount, max number of in&hyphen;mempool descendants
| xref:DEFAULT_DNSSEED.adoc[`DEFAULT&lowbar;DNSSEED`] 
| Default for &hyphen;dnsseed&colon; whether to query the DNS seeds when short on peers&period;
| xref:DEFAULT_FIXEDSEEDS.adoc[`DEFAULT&lowbar;FIXEDSEEDS`] 
| Default for &hyphen;fixedseeds&colon; whether to fall back to the hardcoded seed addresses&period;
| xref:DEFAULT_FORCEDNSSEED.adoc[`DEFAULT&lowbar;FORCEDNSSEED`] 
| Default for &hyphen;forcednsseed&colon; whether to always query the DNS seeds&period;
| xref:DEFAULT_FULL_RELAY_INBOUND_PCT.adoc[`DEFAULT&lowbar;FULL&lowbar;RELAY&lowbar;INBOUND&lowbar;PCT`] 
| Default percentage of inbound connection slots that tx&hyphen;relaying peers can use
| xref:DEFAULT_HTTP_SERVER_TIMEOUT.adoc[`DEFAULT&lowbar;HTTP&lowbar;SERVER&lowbar;TIMEOUT`] 
| The default value for `&hyphen;rpcservertimeout`, in seconds, before an idle client is disconnected&period;
| xref:DEFAULT_HTTP_THREADS.adoc[`DEFAULT&lowbar;HTTP&lowbar;THREADS`] 
| The default value for `&hyphen;rpcthreads`&period; This number of threads will be created at startup&period;
| xref:DEFAULT_HTTP_WORKQUEUE.adoc[`DEFAULT&lowbar;HTTP&lowbar;WORKQUEUE`] 
| The default value for `&hyphen;rpcworkqueue`&period; This is the maximum depth of the work queue, we don&apos;t allocate this number of work queue items upfront&period;
| xref:DEFAULT_INCREMENTAL_RELAY_FEE.adoc[`DEFAULT&lowbar;INCREMENTAL&lowbar;RELAY&lowbar;FEE`] 
| Default for &hyphen;incrementalrelayfee, which sets the minimum feerate increase for mempool limiting or replacement &ast;
| xref:DEFAULT_KERNEL_CACHE.adoc[`DEFAULT&lowbar;KERNEL&lowbar;CACHE`] 
| Suggested default amount of cache reserved for the kernel (bytes)
| xref:DEFAULT_LISTEN.adoc[`DEFAULT&lowbar;LISTEN`] 
| &hyphen;listen default
| xref:DEFAULT_LISTEN_ONION.adoc[`DEFAULT&lowbar;LISTEN&lowbar;ONION`] 
| Whether to listen for incoming connections on a Tor onion service by default&period;
| xref:DEFAULT_LOGIPS.adoc[`DEFAULT&lowbar;LOGIPS`] 
| Default for `&hyphen;logips`&colon; whether to log client IP addresses&period;
| xref:DEFAULT_LOGLEVELALWAYS.adoc[`DEFAULT&lowbar;LOGLEVELALWAYS`] 
| Default for `&hyphen;loglevelalways`&colon; whether to always print the category and level&period;
| xref:DEFAULT_LOGSOURCELOCATIONS.adoc[`DEFAULT&lowbar;LOGSOURCELOCATIONS`] 
| Default for `&hyphen;logsourcelocations`&colon; whether to include the source location in log lines&period;
| xref:DEFAULT_LOGTHREADNAMES.adoc[`DEFAULT&lowbar;LOGTHREADNAMES`] 
| Default for `&hyphen;logthreadnames`&colon; whether to include the thread name in log lines&period;
| xref:DEFAULT_LOGTIMEMICROS.adoc[`DEFAULT&lowbar;LOGTIMEMICROS`] 
| Default for `&hyphen;logtimemicros`&colon; whether to add microsecond precision to timestamps&period;
| xref:DEFAULT_LOGTIMESTAMPS.adoc[`DEFAULT&lowbar;LOGTIMESTAMPS`] 
| Default for `&hyphen;logtimestamps`&colon; whether to prefix log lines with timestamps&period;
| xref:DEFAULT_MAXRECEIVEBUFFER.adoc[`DEFAULT&lowbar;MAXRECEIVEBUFFER`] 
| Default for &hyphen;maxreceivebuffer, in kilobytes&period;
| xref:DEFAULT_MAXSENDBUFFER.adoc[`DEFAULT&lowbar;MAXSENDBUFFER`] 
| Default for &hyphen;maxsendbuffer, in kilobytes&period;
| xref:DEFAULT_MAX_HTTP_CONNECTIONS.adoc[`DEFAULT&lowbar;MAX&lowbar;HTTP&lowbar;CONNECTIONS`] 
| Maximum number of connected HTTP clients
| xref:DEFAULT_MAX_MEMPOOL_SIZE_MB.adoc[`DEFAULT&lowbar;MAX&lowbar;MEMPOOL&lowbar;SIZE&lowbar;MB`] 
| Default for &hyphen;maxmempool, maximum megabytes of mempool memory usage
| xref:DEFAULT_MAX_PEER_CONNECTIONS.adoc[`DEFAULT&lowbar;MAX&lowbar;PEER&lowbar;CONNECTIONS`] 
| The maximum number of peer connections to maintain&period;
| xref:DEFAULT_MAX_TIP_AGE.adoc[`DEFAULT&lowbar;MAX&lowbar;TIP&lowbar;AGE`] 
| Default maximum tip age before the node is considered out of initial block download&period;
| xref:DEFAULT_MAX_TRIES.adoc[`DEFAULT&lowbar;MAX&lowbar;TRIES`] 
| Default max iterations to try in RPC generatetodescriptor, generatetoaddress, and generateblock&period;
| xref:DEFAULT_MAX_UPLOAD_TARGET.adoc[`DEFAULT&lowbar;MAX&lowbar;UPLOAD&lowbar;TARGET`] 
| The default for &hyphen;maxuploadtarget&period; 0 &equals; Unlimited
| xref:DEFAULT_MEMPOOL_EXPIRY_HOURS.adoc[`DEFAULT&lowbar;MEMPOOL&lowbar;EXPIRY&lowbar;HOURS`] 
| Default for &hyphen;mempoolexpiry, expiration time for mempool transactions in hours
| xref:DEFAULT_MIN_RELAY_TX_FEE.adoc[`DEFAULT&lowbar;MIN&lowbar;RELAY&lowbar;TX&lowbar;FEE`] 
| Default for &hyphen;minrelaytxfee, minimum relay fee for transactions
| xref:DEFAULT_MISBEHAVING_BANTIME.adoc[`DEFAULT&lowbar;MISBEHAVING&lowbar;BANTIME`] 
| Default ban duration for a misbehaving peer, in seconds (24 hours)&period;
| xref:DEFAULT_NAME_LOOKUP.adoc[`DEFAULT&lowbar;NAME&lowbar;LOOKUP`] 
| &hyphen;dns default
| xref:DEFAULT_NATPMP.adoc[`DEFAULT&lowbar;NATPMP`] 
| Default value for the &hyphen;natpmp option controlling automatic port mapping&period;
| xref:DEFAULT_PEERBLOCKFILTERS.adoc[`DEFAULT&lowbar;PEERBLOCKFILTERS`] 
| Whether to serve BIP 157 compact block filters to peers by default&period;
| xref:DEFAULT_PEERBLOOMFILTERS.adoc[`DEFAULT&lowbar;PEERBLOOMFILTERS`] 
| Whether to serve BIP 37 bloom filters to peers by default&period;
| xref:DEFAULT_PEER_CONNECT_TIMEOUT.adoc[`DEFAULT&lowbar;PEER&lowbar;CONNECT&lowbar;TIMEOUT`] 
| &hyphen;peertimeout default
| xref:DEFAULT_PERMIT_BAREMULTISIG.adoc[`DEFAULT&lowbar;PERMIT&lowbar;BAREMULTISIG`] 
| Default for &hyphen;permitbaremultisig
| xref:DEFAULT_PERSIST_V1_DAT.adoc[`DEFAULT&lowbar;PERSIST&lowbar;V1&lowbar;DAT`] 
| Whether to fall back to legacy V1 serialization when writing mempool&period;dat
| xref:DEFAULT_PREVOUTFETCH_THREADS.adoc[`DEFAULT&lowbar;PREVOUTFETCH&lowbar;THREADS`] 
| Default number of worker threads used to prefetch block input prevouts&period;
| xref:DEFAULT_PRIVATE_BROADCAST.adoc[`DEFAULT&lowbar;PRIVATE&lowbar;BROADCAST`] 
| Default for &hyphen;privatebroadcast&period;
| xref:DEFAULT_RPC_DOC_CHECK.adoc[`DEFAULT&lowbar;RPC&lowbar;DOC&lowbar;CHECK`] 
| Whether RPC help documentation is verified at runtime by default&period;
| xref:DEFAULT_SCRIPTCHECK_THREADS.adoc[`DEFAULT&lowbar;SCRIPTCHECK&lowbar;THREADS`] 
| &hyphen;par default (number of script&hyphen;checking threads, 0 &equals; auto)
| xref:DEFAULT_SCRIPT_EXECUTION_CACHE_BYTES.adoc[`DEFAULT&lowbar;SCRIPT&lowbar;EXECUTION&lowbar;CACHE&lowbar;BYTES`] 
| Default size in bytes of the script&hyphen;execution result cache&period;
| xref:DEFAULT_SIGNATURE_CACHE_BYTES.adoc[`DEFAULT&lowbar;SIGNATURE&lowbar;CACHE&lowbar;BYTES`] 
| Default size in bytes of the ECDSA&sol;Schnorr signature cache&period;
| xref:DEFAULT_TOR_CONTROL.adoc[`DEFAULT&lowbar;TOR&lowbar;CONTROL`] 
| Default host&colon;port address of the Tor control socket&period;
| xref:DEFAULT_TOR_CONTROL_PORT.adoc[`DEFAULT&lowbar;TOR&lowbar;CONTROL&lowbar;PORT`] 
| Default port on which Tor listens for control connections&period;
| xref:DEFAULT_TOR_SOCKS_PORT.adoc[`DEFAULT&lowbar;TOR&lowbar;SOCKS&lowbar;PORT`] 
| Default port on which Tor listens for SOCKS connections&period;
| xref:DEFAULT_TXINDEX.adoc[`DEFAULT&lowbar;TXINDEX`] 
| Default value for the &hyphen;txindex option (index disabled)&period;
| xref:DEFAULT_TXOSPENDERINDEX.adoc[`DEFAULT&lowbar;TXOSPENDERINDEX`] 
| Default value for the &hyphen;txospenderindex option (index disabled)&period;
| xref:DEFAULT_TXRECONCILIATION_ENABLE.adoc[`DEFAULT&lowbar;TXRECONCILIATION&lowbar;ENABLE`] 
| Whether transaction reconciliation protocol should be enabled by default&period;
| xref:DEFAULT_TX_SEND_RATE.adoc[`DEFAULT&lowbar;TX&lowbar;SEND&lowbar;RATE`] 
| Default maximum per&hyphen;second rate for sending transaction inventory to peers&period;
| xref:DEFAULT_V2_TRANSPORT.adoc[`DEFAULT&lowbar;V2&lowbar;TRANSPORT`] 
| Default for &hyphen;v2transport&colon; whether to enable BIP324 v2 transport&period;
| xref:DEFAULT_VALIDATION_CACHE_BYTES.adoc[`DEFAULT&lowbar;VALIDATION&lowbar;CACHE&lowbar;BYTES`] 
| Default combined size of the signature and script&hyphen;execution validation caches&period;
| xref:DEFAULT_WHITELISTFORCERELAY.adoc[`DEFAULT&lowbar;WHITELISTFORCERELAY`] 
| Default for &hyphen;whitelistforcerelay&period;
| xref:DEFAULT_WHITELISTRELAY.adoc[`DEFAULT&lowbar;WHITELISTRELAY`] 
| Default for &hyphen;whitelistrelay&period;
| xref:DUMMY_CHECKER.adoc[`DUMMY&lowbar;CHECKER`] 
| A signature checker that accepts all signatures
| xref:DUMMY_MAXIMUM_SIGNATURE_CREATOR.adoc[`DUMMY&lowbar;MAXIMUM&lowbar;SIGNATURE&lowbar;CREATOR`] 
| A signature creator that just produces 72&hyphen;byte empty signatures&period;
| xref:DUMMY_SIGNATURE_CREATOR.adoc[`DUMMY&lowbar;SIGNATURE&lowbar;CREATOR`] 
| A signature creator that just produces 71&hyphen;byte empty signatures&period;
| xref:DUMMY_SIGNING_PROVIDER.adoc[`DUMMY&lowbar;SIGNING&lowbar;PROVIDER`] 
| A shared signing provider used where no real keys are available&period;
| xref:DUMP_BANS_INTERVAL.adoc[`DUMP&lowbar;BANS&lowbar;INTERVAL`] 
| How often to dump banned addresses&sol;subnets to disk&period;
| xref:DUST_RELAY_TX_FEE.adoc[`DUST&lowbar;RELAY&lowbar;TX&lowbar;FEE`] 
| Min feerate for defining dust&period; Changing the dust limit changes which transactions are standard and should be done with care and ideally rarely&period; It makes sense to only increase the dust limit after prior releases were already not creating outputs below the new threshold
| xref:ECDH_SECRET_SIZE.adoc[`ECDH&lowbar;SECRET&lowbar;SIZE`] 
| Size of ECDH shared secrets&period;
| xref:EXAMPLE_ADDRESS.adoc[`EXAMPLE&lowbar;ADDRESS`] 
| Example bech32 addresses for the RPCExamples help documentation&period; They are intentionally invalid to prevent accidental transactions by users&period;
| xref:EXTRA_BLOCK_RELAY_ONLY_PEER_INTERVAL.adoc[`EXTRA&lowbar;BLOCK&lowbar;RELAY&lowbar;ONLY&lowbar;PEER&lowbar;INTERVAL`] 
| Run the extra block&hyphen;relay&hyphen;only connection loop once every 5 minutes&period; &ast;
| xref:EXTRA_DESCENDANT_TX_SIZE_LIMIT.adoc[`EXTRA&lowbar;DESCENDANT&lowbar;TX&lowbar;SIZE&lowbar;LIMIT`] 
| An extra transaction can be added to a package, as long as it only has one ancestor and is no larger than this&period; Not really any reason to make this configurable as it doesn&apos;t materially change DoS parameters&period;
| xref:FEATURE_VERSION.adoc[`FEATURE&lowbar;VERSION`] 
| &quot;feature&quot; message type for feature negotiation starts with this version
| xref:FEEFILTER_VERSION.adoc[`FEEFILTER&lowbar;VERSION`] 
| &quot;feefilter&quot; tells peers to filter invs to you by fee starts with this version
| xref:FEELER_INTERVAL.adoc[`FEELER&lowbar;INTERVAL`] 
| Run the feeler connection loop once every 2 minutes&period; &ast;
| xref:FEE_FLUSH_INTERVAL.adoc[`FEE&lowbar;FLUSH&lowbar;INTERVAL`] 
| How often recorded fee estimate data is flushed to disk&period;
| xref:FlushStateModeNames.adoc[`FlushStateModeNames`] 
| Human&hyphen;readable names for the FlushStateMode values, indexed by enum value&period;
| xref:G_ABORT_ON_FAILED_ASSUME.adoc[`G&lowbar;ABORT&lowbar;ON&lowbar;FAILED&lowbar;ASSUME`] 
| True when a failed Assume() should abort rather than continue&period;
| xref:G_FUZZING_BUILD.adoc[`G&lowbar;FUZZING&lowbar;BUILD`] 
| True when the binary is compiled in fuzzing mode&period;
| xref:G_TRANSLATION_FUN.adoc[`G&lowbar;TRANSLATION&lowbar;FUN`] 
| Global translation function, set by the GUI and null when no translation is available&period;
| xref:HASHER_TAPBRANCH.adoc[`HASHER&lowbar;TAPBRANCH`] 
| Hasher with tag &quot;TapBranch&quot; pre&hyphen;fed to it&period;
| xref:HASHER_TAPLEAF.adoc[`HASHER&lowbar;TAPLEAF`] 
| Hasher with tag &quot;TapLeaf&quot; pre&hyphen;fed to it&period;
| xref:HASHER_TAPSIGHASH.adoc[`HASHER&lowbar;TAPSIGHASH`] 
| Hasher with tag &quot;TapSighash&quot; pre&hyphen;fed to it&period;
| xref:I2P_SAM31_PORT.adoc[`I2P&lowbar;SAM31&lowbar;PORT`] 
| SAM 3&period;1 and earlier do not support specifying ports and force the port to 0&period;
| xref:INIT_PROTO_VERSION.adoc[`INIT&lowbar;PROTO&lowbar;VERSION`] 
| initial proto version, to be increased after version&sol;verack negotiation
| xref:INTERNAL_IN_IPV6_PREFIX.adoc[`INTERNAL&lowbar;IN&lowbar;IPV6&lowbar;PREFIX`] 
| Prefix of an IPv6 address when it contains an embedded &quot;internal&quot; address&period; Used when (un)serializing addresses in ADDRv1 format (pre&hyphen;BIP155)&period; The prefix comes from 0xFD &plus; SHA256(&quot;bitcoin&quot;)&lsqb;0&colon;5&rsqb;&period; Such dummy IPv6 addresses are guaranteed to not be publicly routable as they fall under RFC4193&apos;s fc00&colon;&colon;&sol;7 subnet allocated to unique&hyphen;local addresses&period;
| xref:INVALID_CB_NO_BAN_VERSION.adoc[`INVALID&lowbar;CB&lowbar;NO&lowbar;BAN&lowbar;VERSION`] 
| not banning for invalid compact blocks starts with this version
| xref:IPV4_IN_IPV6_PREFIX.adoc[`IPV4&lowbar;IN&lowbar;IPV6&lowbar;PREFIX`] 
| Prefix of an IPv6 address when it contains an embedded IPv4 address&period; Used when (un)serializing addresses in ADDRv1 format (pre&hyphen;BIP155)&period;
| xref:LOCKTIME_MAX.adoc[`LOCKTIME&lowbar;MAX`] 
| Maximum nLockTime&period;
| xref:LOCKTIME_THRESHOLD.adoc[`LOCKTIME&lowbar;THRESHOLD`] 
| Threshold for nLockTime&period;
| xref:LOCKTIME_VERIFY_SEQUENCE.adoc[`LOCKTIME&lowbar;VERIFY&lowbar;SEQUENCE`] 
| Flags for nSequence and nLockTime locks
| xref:MANDATORY_SCRIPT_VERIFY_FLAGS.adoc[`MANDATORY&lowbar;SCRIPT&lowbar;VERIFY&lowbar;FLAGS`] 
| Mandatory script verification flags that all new transactions must comply with for them to be valid&period;
| xref:MAX_ADDNODE_CONNECTIONS.adoc[`MAX&lowbar;ADDNODE&lowbar;CONNECTIONS`] 
| Maximum number of addnode outgoing nodes
| xref:MAX_BIP125_RBF_SEQUENCE.adoc[`MAX&lowbar;BIP125&lowbar;RBF&lowbar;SEQUENCE`] 
| Highest input sequence number that still signals opt&hyphen;in replace&hyphen;by&hyphen;fee under BIP 125 (SEQUENCE&lowbar;FINAL &hyphen; 2)&period;
| xref:MAX_BLOCK_DB_CACHE.adoc[`MAX&lowbar;BLOCK&lowbar;DB&lowbar;CACHE`] 
| Max memory allocated to block tree DB specific cache (bytes)
| xref:MAX_BLOCK_RELAY_ONLY_CONNECTIONS.adoc[`MAX&lowbar;BLOCK&lowbar;RELAY&lowbar;ONLY&lowbar;CONNECTIONS`] 
| Maximum number of block&hyphen;relay&hyphen;only outgoing connections
| xref:MAX_BLOCK_SERIALIZED_SIZE.adoc[`MAX&lowbar;BLOCK&lowbar;SERIALIZED&lowbar;SIZE`] 
| The maximum allowed size for a serialized block, in bytes (only for buffer size limits)
| xref:MAX_BLOCK_SIGOPS_COST.adoc[`MAX&lowbar;BLOCK&lowbar;SIGOPS&lowbar;COST`] 
| The maximum allowed number of signature check operations in a block (network rule)
| xref:MAX_BLOCK_WEIGHT.adoc[`MAX&lowbar;BLOCK&lowbar;WEIGHT`] 
| The maximum allowed weight for a block, see BIP 141 (network rule)
| xref:MAX_BLOOM_FILTER_SIZE.adoc[`MAX&lowbar;BLOOM&lowbar;FILTER&lowbar;SIZE`] 
| 20,000 items with fp rate &lt; 0&period;1% or 10,000 items and &lt;0&period;0001%
| xref:MAX_CLUSTER_COUNT_LIMIT.adoc[`MAX&lowbar;CLUSTER&lowbar;COUNT&lowbar;LIMIT`] 
| Hard upper bound on the per&hyphen;cluster transaction count limit a TxGraph may be configured with&period;
| xref:MAX_CMPCTBLOCKS_INFLIGHT_PER_BLOCK.adoc[`MAX&lowbar;CMPCTBLOCKS&lowbar;INFLIGHT&lowbar;PER&lowbar;BLOCK`] 
| Maximum number of outstanding CMPCTBLOCK requests for the same block&period;
| xref:MAX_COINS_DB_CACHE.adoc[`MAX&lowbar;COINS&lowbar;DB&lowbar;CACHE`] 
| Max memory allocated to coin DB specific cache (bytes)
| xref:MAX_DBCACHE_BYTES.adoc[`MAX&lowbar;DBCACHE&lowbar;BYTES`] 
| Maximum total database cache on current architecture (bytes)
| xref:MAX_DISCONNECTED_TX_POOL_BYTES.adoc[`MAX&lowbar;DISCONNECTED&lowbar;TX&lowbar;POOL&lowbar;BYTES`] 
| Maximum bytes for transactions to store for processing during reorg
| xref:MAX_DUST_OUTPUTS_PER_TX.adoc[`MAX&lowbar;DUST&lowbar;OUTPUTS&lowbar;PER&lowbar;TX`] 
| Maximum number of ephemeral dust outputs allowed&period;
| xref:MAX_FEATUREDATA_LENGTH.adoc[`MAX&lowbar;FEATUREDATA&lowbar;LENGTH`] 
| Maximum length in bytes of the data payload for a single feature&period;
| xref:MAX_FEATUREID_LENGTH.adoc[`MAX&lowbar;FEATUREID&lowbar;LENGTH`] 
| Maximum length in bytes of a feature identifier in a feature message&period;
| xref:MAX_FEELER_CONNECTIONS.adoc[`MAX&lowbar;FEELER&lowbar;CONNECTIONS`] 
| Maximum number of feeler connections
| xref:MAX_FILE_AGE.adoc[`MAX&lowbar;FILE&lowbar;AGE`] 
| Block policy estimate files that are more than 60 hours (2&period;5 days) old will not be read, as fee estimates are based on historical data and may be inaccurate if network activity has changed&period;
| xref:MAX_FILE_SIZE_PSBT.adoc[`MAX&lowbar;FILE&lowbar;SIZE&lowbar;PSBT`] 
| Maximum accepted PSBT file size, capped to bound memory use while reading&period;
| xref:MAX_FUTURE_BLOCK_TIME.adoc[`MAX&lowbar;FUTURE&lowbar;BLOCK&lowbar;TIME`] 
| Maximum amount of time that a block timestamp is allowed to exceed the current time before the block will be accepted&period;
| xref:MAX_HASH_FUNCS.adoc[`MAX&lowbar;HASH&lowbar;FUNCS`] 
| Maximum number of hash functions a bloom filter may use&period;
| xref:MAX_HEADERS_RESULTS.adoc[`MAX&lowbar;HEADERS&lowbar;RESULTS`] 
| Number of headers sent in one getheaders result&period; We rely on the assumption that if a peer sends less than this number, we reached its tip&period; Changing this value is a protocol upgrade&period;
| xref:MAX_MONEY.adoc[`MAX&lowbar;MONEY`] 
| No amount larger than this (in satoshi) is valid&period;
| xref:MAX_OPCODE.adoc[`MAX&lowbar;OPCODE`] 
| Maximum value that an opcode can take&period;
| xref:MAX_OPS_PER_SCRIPT.adoc[`MAX&lowbar;OPS&lowbar;PER&lowbar;SCRIPT`] 
| Maximum number of non&hyphen;push operations per script&period;
| xref:MAX_OP_RETURN_RELAY.adoc[`MAX&lowbar;OP&lowbar;RETURN&lowbar;RELAY`] 
| Default setting for &hyphen;datacarriersize in vbytes&period;
| xref:MAX_OUTBOUND_FULL_RELAY_CONNECTIONS.adoc[`MAX&lowbar;OUTBOUND&lowbar;FULL&lowbar;RELAY&lowbar;CONNECTIONS`] 
| Maximum number of automatic outgoing nodes over which we&apos;ll relay everything (blocks, tx, addrs, etc)
| xref:MAX_P2SH_SIGOPS.adoc[`MAX&lowbar;P2SH&lowbar;SIGOPS`] 
| Maximum number of signature check operations in an IsStandard() P2SH script
| xref:MAX_PACKAGE_COUNT.adoc[`MAX&lowbar;PACKAGE&lowbar;COUNT`] 
| Default maximum number of transactions in a package&period;
| xref:MAX_PACKAGE_WEIGHT.adoc[`MAX&lowbar;PACKAGE&lowbar;WEIGHT`] 
| Default maximum total weight of transactions in a package in weight to allow for context&hyphen;less checks&period; This must allow a superset of sigops weighted vsize limited transactions to not disallow transactions we would have otherwise accepted individually&period;
| xref:MAX_PREVOUTFETCH_THREADS.adoc[`MAX&lowbar;PREVOUTFETCH&lowbar;THREADS`] 
| Maximum number of dedicated threads allowed for prefetching block input prevouts
| xref:MAX_PRIVATE_BROADCAST_CONNECTIONS.adoc[`MAX&lowbar;PRIVATE&lowbar;BROADCAST&lowbar;CONNECTIONS`] 
| Maximum number of private broadcast connections
| xref:MAX_PROTOCOL_MESSAGE_LENGTH.adoc[`MAX&lowbar;PROTOCOL&lowbar;MESSAGE&lowbar;LENGTH`] 
| Maximum length of incoming protocol messages (no message over 4 MB is currently acceptable)&period;
| xref:MAX_PUBKEYS_PER_MULTISIG.adoc[`MAX&lowbar;PUBKEYS&lowbar;PER&lowbar;MULTISIG`] 
| Maximum number of public keys per multisig&period;
| xref:MAX_PUBKEYS_PER_MULTI_A.adoc[`MAX&lowbar;PUBKEYS&lowbar;PER&lowbar;MULTI&lowbar;A`] 
| The limit of keys in OP&lowbar;CHECKSIGADD&hyphen;based scripts&period; It is due to the stack limit in BIP342&period;
| xref:MAX_REPLACEMENT_CANDIDATES.adoc[`MAX&lowbar;REPLACEMENT&lowbar;CANDIDATES`] 
| Maximum number of unique clusters that can be affected by an RBF (Rule &num;5)&semi; see GetEntriesForConflicts()
| xref:MAX_SCRIPTCHECK_THREADS.adoc[`MAX&lowbar;SCRIPTCHECK&lowbar;THREADS`] 
| Maximum number of dedicated script&hyphen;checking threads allowed
| xref:MAX_SCRIPT_ELEMENT_SIZE.adoc[`MAX&lowbar;SCRIPT&lowbar;ELEMENT&lowbar;SIZE`] 
| Maximum number of bytes pushable to the stack&period;
| xref:MAX_SCRIPT_SIZE.adoc[`MAX&lowbar;SCRIPT&lowbar;SIZE`] 
| Maximum script length in bytes&period;
| xref:MAX_SCRIPT_VERIFY_FLAGS.adoc[`MAX&lowbar;SCRIPT&lowbar;VERIFY&lowbar;FLAGS`] 
| Bit mask with every defined verification flag set&period;
| xref:MAX_SCRIPT_VERIFY_FLAGS_BITS.adoc[`MAX&lowbar;SCRIPT&lowbar;VERIFY&lowbar;FLAGS&lowbar;BITS`] 
| Number of defined verification flag bits, equal to the value of SCRIPT&lowbar;VERIFY&lowbar;END&lowbar;MARKER&period;
| xref:MAX_SIZE.adoc[`MAX&lowbar;SIZE`] 
| The maximum size of a serialized object in bytes or number of elements (for eg vectors) when the size is encoded as CompactSize&period;
| xref:MAX_STACK_SIZE.adoc[`MAX&lowbar;STACK&lowbar;SIZE`] 
| Maximum number of values on the script interpreter stack&period;
| xref:MAX_STANDARD_P2WSH_SCRIPT_SIZE.adoc[`MAX&lowbar;STANDARD&lowbar;P2WSH&lowbar;SCRIPT&lowbar;SIZE`] 
| The maximum size in bytes of a standard witnessScript
| xref:MAX_STANDARD_P2WSH_STACK_ITEMS.adoc[`MAX&lowbar;STANDARD&lowbar;P2WSH&lowbar;STACK&lowbar;ITEMS`] 
| The maximum number of witness stack items in a standard P2WSH script
| xref:MAX_STANDARD_P2WSH_STACK_ITEM_SIZE.adoc[`MAX&lowbar;STANDARD&lowbar;P2WSH&lowbar;STACK&lowbar;ITEM&lowbar;SIZE`] 
| The maximum size in bytes of each witness stack item in a standard P2WSH script
| xref:MAX_STANDARD_SCRIPTSIG_SIZE.adoc[`MAX&lowbar;STANDARD&lowbar;SCRIPTSIG&lowbar;SIZE`] 
| The maximum size of a standard ScriptSig
| xref:MAX_STANDARD_TAPSCRIPT_STACK_ITEM_SIZE.adoc[`MAX&lowbar;STANDARD&lowbar;TAPSCRIPT&lowbar;STACK&lowbar;ITEM&lowbar;SIZE`] 
| The maximum size in bytes of each witness stack item in a standard BIP 342 script (Taproot, leaf version 0xc0)
| xref:MAX_STANDARD_TX_SIGOPS_COST.adoc[`MAX&lowbar;STANDARD&lowbar;TX&lowbar;SIGOPS&lowbar;COST`] 
| The maximum number of sigops we&apos;re willing to relay&sol;mine in a single tx
| xref:MAX_STANDARD_TX_WEIGHT.adoc[`MAX&lowbar;STANDARD&lowbar;TX&lowbar;WEIGHT`] 
| The maximum weight for transactions we&apos;re willing to relay&sol;mine
| xref:MAX_SUBVERSION_LENGTH.adoc[`MAX&lowbar;SUBVERSION&lowbar;LENGTH`] 
| Maximum length of the user agent string in `version` message
| xref:MAX_TIMEWARP.adoc[`MAX&lowbar;TIMEWARP`] 
| Maximum number of seconds that the timestamp of the first block of a difficulty adjustment period is allowed to be earlier than the last block of the previous period (BIP94)&period;
| xref:MAX_TX_LEGACY_SIGOPS.adoc[`MAX&lowbar;TX&lowbar;LEGACY&lowbar;SIGOPS`] 
| The maximum number of potentially executed legacy signature operations in a single standard tx
| xref:MAX_VECTOR_ALLOCATE.adoc[`MAX&lowbar;VECTOR&lowbar;ALLOCATE`] 
| Maximum amount of memory (in bytes) to allocate at once when deserializing vectors&period;
| xref:MAX_WAIT_FOR_IO.adoc[`MAX&lowbar;WAIT&lowbar;FOR&lowbar;IO`] 
| Maximum time to wait for I&sol;O readiness&period; It will take up until this time to break off in case of an interruption&period;
| xref:MEMPOOL_FEE_ESTIMATOR_MAX_TARGET.adoc[`MEMPOOL&lowbar;FEE&lowbar;ESTIMATOR&lowbar;MAX&lowbar;TARGET`] 
| Maximum confirmation target, in blocks, for which the mempool estimator is reliable&period;
| xref:MEMPOOL_HEALTH_WINDOW_BLOCKS.adoc[`MEMPOOL&lowbar;HEALTH&lowbar;WINDOW&lowbar;BLOCKS`] 
| Number of recent mined blocks inspected when assessing mempool health&period;
| xref:MEMPOOL_HEIGHT.adoc[`MEMPOOL&lowbar;HEIGHT`] 
| Fake height value used in Coin to signify they are only in the memory pool (since 0&period;8)
| xref:MEMPOOL_REPRESENTATION_THRESHOLD.adoc[`MEMPOOL&lowbar;REPRESENTATION&lowbar;THRESHOLD`] 
| Minimum fraction of block weight that must come from the mempool for it to be well represented&period;
| xref:MESSAGE_MAGIC.adoc[`MESSAGE&lowbar;MAGIC`] 
| Magic string prefixed to a message before hashing, to domain&hyphen;separate it from transactions&period;
| xref:MINIMUM_BLOCK_RESERVED_WEIGHT.adoc[`MINIMUM&lowbar;BLOCK&lowbar;RESERVED&lowbar;WEIGHT`] 
| This accounts for the block header, var&lowbar;int encoding of the transaction count and a minimally viable coinbase transaction&period; It adds an additional safety margin, because even with a thorough understanding of block serialization, it&apos;s easy to make a costly mistake when trying to squeeze every last byte&period; Setting a lower value is prevented at startup&period;
| xref:MINIMUM_WITNESS_COMMITMENT.adoc[`MINIMUM&lowbar;WITNESS&lowbar;COMMITMENT`] 
| Minimum size of a witness commitment structure&period; Defined in BIP 141&period; &ast;
| xref:MIN_BLOCKS_TO_KEEP.adoc[`MIN&lowbar;BLOCKS&lowbar;TO&lowbar;KEEP`] 
| Block files containing a block&hyphen;height within MIN&lowbar;BLOCKS&lowbar;TO&lowbar;KEEP of ActiveChain()&period;Tip() will not be pruned&period;
| xref:MIN_DBCACHE_BYTES.adoc[`MIN&lowbar;DBCACHE&lowbar;BYTES`] 
| Minimum total database cache (bytes)
| xref:MIN_DISK_SPACE_FOR_BLOCK_FILES.adoc[`MIN&lowbar;DISK&lowbar;SPACE&lowbar;FOR&lowbar;BLOCK&lowbar;FILES`] 
| Minimum free disk space, in bytes, that a user must allocate for block and undo files&period;
| xref:MIN_PEER_PROTO_VERSION.adoc[`MIN&lowbar;PEER&lowbar;PROTO&lowbar;VERSION`] 
| disconnect from peers older than this proto version
| xref:MIN_SERIALIZABLE_TRANSACTION_WEIGHT.adoc[`MIN&lowbar;SERIALIZABLE&lowbar;TRANSACTION&lowbar;WEIGHT`] 
| Minimum weight of any serializable CTransaction (10 bytes is the lower bound for its serialized size)&period;
| xref:MIN_STANDARD_TX_NONWITNESS_SIZE.adoc[`MIN&lowbar;STANDARD&lowbar;TX&lowbar;NONWITNESS&lowbar;SIZE`] 
| The minimum non&hyphen;witness size for transactions we&apos;re willing to relay&sol;mine&colon; one larger than 64
| xref:MIN_TRANSACTION_WEIGHT.adoc[`MIN&lowbar;TRANSACTION&lowbar;WEIGHT`] 
| Minimum weight of a valid serialized CTransaction (60 bytes is the lower bound for its serialized size)&period;
| xref:MSG_TYPE_MASK.adoc[`MSG&lowbar;TYPE&lowbar;MASK`] 
| Mask covering the bits used to encode a getdata&sol;inv message type&period;
| xref:MSG_WITNESS_FLAG.adoc[`MSG&lowbar;WITNESS&lowbar;FLAG`] 
| getdata message type flags
| xref:MUSIG2_PUBNONCE_SIZE.adoc[`MUSIG2&lowbar;PUBNONCE&lowbar;SIZE`] 
| Size in bytes of a serialized MuSig2 public nonce&period;
| xref:NET_MESSAGE_TYPE_OTHER.adoc[`NET&lowbar;MESSAGE&lowbar;TYPE&lowbar;OTHER`] 
| Bucket name used to aggregate byte counts for message types not tracked individually&period;
| xref:NET_PERMISSIONS_DOC.adoc[`NET&lowbar;PERMISSIONS&lowbar;DOC`] 
| Human&hyphen;readable descriptions of the available net permission flags, for help output&period;
| xref:NO_WITNESS_COMMITMENT.adoc[`NO&lowbar;WITNESS&lowbar;COMMITMENT`] 
| Index marker for when no witness commitment is present in a coinbase transaction&period;
| xref:NUM_FDS_MESSAGE_CAPTURE.adoc[`NUM&lowbar;FDS&lowbar;MESSAGE&lowbar;CAPTURE`] 
| Number of file descriptors required for message capture &ast;
| xref:NUM_GETBLOCKSTATS_PERCENTILES.adoc[`NUM&lowbar;GETBLOCKSTATS&lowbar;PERCENTILES`] 
| Number of weight percentiles reported by the getblockstats RPC&period;
| xref:OUTPUT_TYPES.adoc[`OUTPUT&lowbar;TYPES`] 
| The output types that can be produced, excluding UNKNOWN&period;
| xref:PCP_MAP_NONCE_SIZE.adoc[`PCP&lowbar;MAP&lowbar;NONCE&lowbar;SIZE`] 
| Mapping nonce size in bytes (see RFC6887 section 11&period;1)&period;
| xref:POST_CHANGE_COST.adoc[`POST&lowbar;CHANGE&lowbar;COST`] 
| How much work we ask TxGraph to do after a mempool change occurs (either due to a changeset being applied, a new block being found, or a reorg)&period;
| xref:PROTOCOL_VERSION.adoc[`PROTOCOL&lowbar;VERSION`] 
| network protocol versioning
| xref:PSBT_GLOBAL_FALLBACK_LOCKTIME.adoc[`PSBT&lowbar;GLOBAL&lowbar;FALLBACK&lowbar;LOCKTIME`] 
| Global map key type for the fallback locktime&period;
| xref:PSBT_GLOBAL_INPUT_COUNT.adoc[`PSBT&lowbar;GLOBAL&lowbar;INPUT&lowbar;COUNT`] 
| Global map key type for the input count&period;
| xref:PSBT_GLOBAL_OUTPUT_COUNT.adoc[`PSBT&lowbar;GLOBAL&lowbar;OUTPUT&lowbar;COUNT`] 
| Global map key type for the output count&period;
| xref:PSBT_GLOBAL_PROPRIETARY.adoc[`PSBT&lowbar;GLOBAL&lowbar;PROPRIETARY`] 
| Global map key type for proprietary use&period;
| xref:PSBT_GLOBAL_TX_MODIFIABLE.adoc[`PSBT&lowbar;GLOBAL&lowbar;TX&lowbar;MODIFIABLE`] 
| Global map key type for the transaction&hyphen;modifiable flags&period;
| xref:PSBT_GLOBAL_TX_VERSION.adoc[`PSBT&lowbar;GLOBAL&lowbar;TX&lowbar;VERSION`] 
| Global map key type for the transaction version&period;
| xref:PSBT_GLOBAL_UNSIGNED_TX.adoc[`PSBT&lowbar;GLOBAL&lowbar;UNSIGNED&lowbar;TX`] 
| Global map key type for the unsigned transaction&period;
| xref:PSBT_GLOBAL_VERSION.adoc[`PSBT&lowbar;GLOBAL&lowbar;VERSION`] 
| Global map key type for the PSBT version number&period;
| xref:PSBT_GLOBAL_XPUB.adoc[`PSBT&lowbar;GLOBAL&lowbar;XPUB`] 
| Global map key type for an extended public key&period;
| xref:PSBT_HIGHEST_VERSION.adoc[`PSBT&lowbar;HIGHEST&lowbar;VERSION`] 
| Highest PSBT version this implementation supports&period;
| xref:PSBT_IN_BIP32_DERIVATION.adoc[`PSBT&lowbar;IN&lowbar;BIP32&lowbar;DERIVATION`] 
| Input map key type for a BIP32 derivation path&period;
| xref:PSBT_IN_HASH160.adoc[`PSBT&lowbar;IN&lowbar;HASH160`] 
| Input map key type for a HASH160 preimage&period;
| xref:PSBT_IN_HASH256.adoc[`PSBT&lowbar;IN&lowbar;HASH256`] 
| Input map key type for a HASH256 preimage&period;
| xref:PSBT_IN_MUSIG2_PARTIAL_SIG.adoc[`PSBT&lowbar;IN&lowbar;MUSIG2&lowbar;PARTIAL&lowbar;SIG`] 
| Input map key type for a MuSig2 partial signature&period;
| xref:PSBT_IN_MUSIG2_PARTICIPANT_PUBKEYS.adoc[`PSBT&lowbar;IN&lowbar;MUSIG2&lowbar;PARTICIPANT&lowbar;PUBKEYS`] 
| Input map key type for the MuSig2 participant public keys&period;
| xref:PSBT_IN_MUSIG2_PUB_NONCE.adoc[`PSBT&lowbar;IN&lowbar;MUSIG2&lowbar;PUB&lowbar;NONCE`] 
| Input map key type for a MuSig2 public nonce&period;
| xref:PSBT_IN_NON_WITNESS_UTXO.adoc[`PSBT&lowbar;IN&lowbar;NON&lowbar;WITNESS&lowbar;UTXO`] 
| Input map key type for the non&hyphen;witness UTXO&period;
| xref:PSBT_IN_OUTPUT_INDEX.adoc[`PSBT&lowbar;IN&lowbar;OUTPUT&lowbar;INDEX`] 
| Input map key type for the previous output index&period;
| xref:PSBT_IN_PARTIAL_SIG.adoc[`PSBT&lowbar;IN&lowbar;PARTIAL&lowbar;SIG`] 
| Input map key type for a partial signature&period;
| xref:PSBT_IN_PREVIOUS_TXID.adoc[`PSBT&lowbar;IN&lowbar;PREVIOUS&lowbar;TXID`] 
| Input map key type for the previous transaction id&period;
| xref:PSBT_IN_PROPRIETARY.adoc[`PSBT&lowbar;IN&lowbar;PROPRIETARY`] 
| Input map key type for proprietary use&period;
| xref:PSBT_IN_REDEEMSCRIPT.adoc[`PSBT&lowbar;IN&lowbar;REDEEMSCRIPT`] 
| Input map key type for the redeem script&period;
| xref:PSBT_IN_REQUIRED_HEIGHT_LOCKTIME.adoc[`PSBT&lowbar;IN&lowbar;REQUIRED&lowbar;HEIGHT&lowbar;LOCKTIME`] 
| Input map key type for the required height&hyphen;based locktime&period;
| xref:PSBT_IN_REQUIRED_TIME_LOCKTIME.adoc[`PSBT&lowbar;IN&lowbar;REQUIRED&lowbar;TIME&lowbar;LOCKTIME`] 
| Input map key type for the required time&hyphen;based locktime&period;
| xref:PSBT_IN_RIPEMD160.adoc[`PSBT&lowbar;IN&lowbar;RIPEMD160`] 
| Input map key type for a RIPEMD160 preimage&period;
| xref:PSBT_IN_SCRIPTSIG.adoc[`PSBT&lowbar;IN&lowbar;SCRIPTSIG`] 
| Input map key type for the finalized scriptSig&period;
| xref:PSBT_IN_SCRIPTWITNESS.adoc[`PSBT&lowbar;IN&lowbar;SCRIPTWITNESS`] 
| Input map key type for the finalized script witness&period;
| xref:PSBT_IN_SEQUENCE.adoc[`PSBT&lowbar;IN&lowbar;SEQUENCE`] 
| Input map key type for the input sequence number&period;
| xref:PSBT_IN_SHA256.adoc[`PSBT&lowbar;IN&lowbar;SHA256`] 
| Input map key type for a SHA256 preimage&period;
| xref:PSBT_IN_SIGHASH.adoc[`PSBT&lowbar;IN&lowbar;SIGHASH`] 
| Input map key type for the sighash type&period;
| xref:PSBT_IN_TAP_BIP32_DERIVATION.adoc[`PSBT&lowbar;IN&lowbar;TAP&lowbar;BIP32&lowbar;DERIVATION`] 
| Input map key type for a taproot BIP32 derivation path&period;
| xref:PSBT_IN_TAP_INTERNAL_KEY.adoc[`PSBT&lowbar;IN&lowbar;TAP&lowbar;INTERNAL&lowbar;KEY`] 
| Input map key type for the taproot internal key&period;
| xref:PSBT_IN_TAP_KEY_SIG.adoc[`PSBT&lowbar;IN&lowbar;TAP&lowbar;KEY&lowbar;SIG`] 
| Input map key type for a taproot key&hyphen;path signature&period;
| xref:PSBT_IN_TAP_LEAF_SCRIPT.adoc[`PSBT&lowbar;IN&lowbar;TAP&lowbar;LEAF&lowbar;SCRIPT`] 
| Input map key type for a taproot leaf script&period;
| xref:PSBT_IN_TAP_MERKLE_ROOT.adoc[`PSBT&lowbar;IN&lowbar;TAP&lowbar;MERKLE&lowbar;ROOT`] 
| Input map key type for the taproot merkle root&period;
| xref:PSBT_IN_TAP_SCRIPT_SIG.adoc[`PSBT&lowbar;IN&lowbar;TAP&lowbar;SCRIPT&lowbar;SIG`] 
| Input map key type for a taproot script&hyphen;path signature&period;
| xref:PSBT_IN_WITNESSSCRIPT.adoc[`PSBT&lowbar;IN&lowbar;WITNESSSCRIPT`] 
| Input map key type for the witness script&period;
| xref:PSBT_IN_WITNESS_UTXO.adoc[`PSBT&lowbar;IN&lowbar;WITNESS&lowbar;UTXO`] 
| Input map key type for the witness UTXO&period;
| xref:PSBT_MAGIC_BYTES.adoc[`PSBT&lowbar;MAGIC&lowbar;BYTES`] 
| Magic bytes that prefix every serialized PSBT&period;
| xref:PSBT_OUT_AMOUNT.adoc[`PSBT&lowbar;OUT&lowbar;AMOUNT`] 
| Output map key type for the output amount&period;
| xref:PSBT_OUT_BIP32_DERIVATION.adoc[`PSBT&lowbar;OUT&lowbar;BIP32&lowbar;DERIVATION`] 
| Output map key type for a BIP32 derivation path&period;
| xref:PSBT_OUT_MUSIG2_PARTICIPANT_PUBKEYS.adoc[`PSBT&lowbar;OUT&lowbar;MUSIG2&lowbar;PARTICIPANT&lowbar;PUBKEYS`] 
| Output map key type for the MuSig2 participant public keys&period;
| xref:PSBT_OUT_PROPRIETARY.adoc[`PSBT&lowbar;OUT&lowbar;PROPRIETARY`] 
| Output map key type for proprietary use&period;
| xref:PSBT_OUT_REDEEMSCRIPT.adoc[`PSBT&lowbar;OUT&lowbar;REDEEMSCRIPT`] 
| Output map key type for the redeem script&period;
| xref:PSBT_OUT_SCRIPT.adoc[`PSBT&lowbar;OUT&lowbar;SCRIPT`] 
| Output map key type for the output script&period;
| xref:PSBT_OUT_TAP_BIP32_DERIVATION.adoc[`PSBT&lowbar;OUT&lowbar;TAP&lowbar;BIP32&lowbar;DERIVATION`] 
| Output map key type for a taproot BIP32 derivation path&period;
| xref:PSBT_OUT_TAP_INTERNAL_KEY.adoc[`PSBT&lowbar;OUT&lowbar;TAP&lowbar;INTERNAL&lowbar;KEY`] 
| Output map key type for the taproot internal key&period;
| xref:PSBT_OUT_TAP_TREE.adoc[`PSBT&lowbar;OUT&lowbar;TAP&lowbar;TREE`] 
| Output map key type for the taproot tree&period;
| xref:PSBT_OUT_WITNESSSCRIPT.adoc[`PSBT&lowbar;OUT&lowbar;WITNESSSCRIPT`] 
| Output map key type for the witness script&period;
| xref:PSBT_SEPARATOR.adoc[`PSBT&lowbar;SEPARATOR`] 
| Map separator byte, read as a zero&hyphen;length key that carries no value&period;
| xref:SCRIPT_VERIFY_NONE.adoc[`SCRIPT&lowbar;VERIFY&lowbar;NONE`] 
| Script verification flags&period;
| xref:SENDHEADERS_VERSION.adoc[`SENDHEADERS&lowbar;VERSION`] 
| &quot;sendheaders&quot; message type and announcing blocks with headers starts with this version
| xref:SEQ_ID_BEST_CHAIN_FROM_DISK.adoc[`SEQ&lowbar;ID&lowbar;BEST&lowbar;CHAIN&lowbar;FROM&lowbar;DISK`] 
| Init values for CBlockIndex nSequenceId when loaded from disk
| xref:SEQ_ID_INIT_FROM_DISK.adoc[`SEQ&lowbar;ID&lowbar;INIT&lowbar;FROM&lowbar;DISK`] 
| Init value for CBlockIndex nSequenceId for a block loaded from disk that is not on the best chain&period;
| xref:SHORT_IDS_BLOCKS_VERSION.adoc[`SHORT&lowbar;IDS&lowbar;BLOCKS&lowbar;VERSION`] 
| short&hyphen;id&hyphen;based block download starts with this version
| xref:SNAPSHOT_MAGIC_BYTES.adoc[`SNAPSHOT&lowbar;MAGIC&lowbar;BYTES`] 
| Magic bytes marking the start of a serialized UTXO set snapshot&period;
| xref:STANDARD_LOCKTIME_VERIFY_FLAGS.adoc[`STANDARD&lowbar;LOCKTIME&lowbar;VERIFY&lowbar;FLAGS`] 
| Used as the flags parameter to sequence and nLocktime checks in non&hyphen;consensus code&period;
| xref:STANDARD_NOT_MANDATORY_VERIFY_FLAGS.adoc[`STANDARD&lowbar;NOT&lowbar;MANDATORY&lowbar;VERIFY&lowbar;FLAGS`] 
| For convenience, standard but not mandatory verify flags&period;
| xref:STANDARD_SCRIPT_VERIFY_FLAGS.adoc[`STANDARD&lowbar;SCRIPT&lowbar;VERIFY&lowbar;FLAGS`] 
| Standard script verification flags that standard transactions will comply with&period; However we do not ban&sol;disconnect nodes that forward txs violating the additional (non&hyphen;mandatory) rules here, to improve forwards and backwards compatibility&period;
| xref:TAPROOT_CONTROL_BASE_SIZE.adoc[`TAPROOT&lowbar;CONTROL&lowbar;BASE&lowbar;SIZE`] 
| Fixed prefix size of a Taproot control block (leaf byte &plus; internal key)&period;
| xref:TAPROOT_CONTROL_MAX_NODE_COUNT.adoc[`TAPROOT&lowbar;CONTROL&lowbar;MAX&lowbar;NODE&lowbar;COUNT`] 
| Maximum number of Merkle branch nodes in a control block&period;
| xref:TAPROOT_CONTROL_MAX_SIZE.adoc[`TAPROOT&lowbar;CONTROL&lowbar;MAX&lowbar;SIZE`] 
| Maximum total byte size of a Taproot control block&period;
| xref:TAPROOT_CONTROL_NODE_SIZE.adoc[`TAPROOT&lowbar;CONTROL&lowbar;NODE&lowbar;SIZE`] 
| Byte size of one Merkle branch node in a control block&period;
| xref:TAPROOT_LEAF_MASK.adoc[`TAPROOT&lowbar;LEAF&lowbar;MASK`] 
| Mask isolating the leaf&hyphen;version bits of a Taproot control byte&period;
| xref:TAPROOT_LEAF_TAPSCRIPT.adoc[`TAPROOT&lowbar;LEAF&lowbar;TAPSCRIPT`] 
| Leaf version identifying a BIP342 tapscript&period;
| xref:TEST_OPTIONS_DOC.adoc[`TEST&lowbar;OPTIONS&lowbar;DOC`] 
| Names of the recognized values for the &hyphen;test command&hyphen;line argument&period;
| xref:TIMEOUT_INTERVAL.adoc[`TIMEOUT&lowbar;INTERVAL`] 
| Time after which to disconnect, after waiting for a ping response (or inactivity)&period;
| xref:TIMESTAMP_WINDOW.adoc[`TIMESTAMP&lowbar;WINDOW`] 
| Timestamp window used as a grace period by code that compares external timestamps (such as timestamps passed to RPCs, or wallet key creation times) to block timestamps&period; This should be set at least as high as MAX&lowbar;FUTURE&lowbar;BLOCK&lowbar;TIME&period;
| xref:TORV2_IN_IPV6_PREFIX.adoc[`TORV2&lowbar;IN&lowbar;IPV6&lowbar;PREFIX`] 
| Prefix of an IPv6 address when it contains an embedded TORv2 address&period; Used when (un)serializing addresses in ADDRv1 format (pre&hyphen;BIP155)&period; Such dummy IPv6 addresses are guaranteed to not be publicly routable as they fall under RFC4193&apos;s fc00&colon;&colon;&sol;7 subnet allocated to unique&hyphen;local addresses&period;
| xref:TOR_REPLY_OK.adoc[`TOR&lowbar;REPLY&lowbar;OK`] 
| Tor control reply code&period; Ref&colon; https&colon;&sol;&sol;spec&period;torproject&period;org&sol;control&hyphen;spec&sol;replies&period;html
| xref:TOR_REPLY_SYNTAX_ERROR.adoc[`TOR&lowbar;REPLY&lowbar;SYNTAX&lowbar;ERROR`] 
| Syntax error in command argument
| xref:TOR_REPLY_UNRECOGNIZED.adoc[`TOR&lowbar;REPLY&lowbar;UNRECOGNIZED`] 
| Tor control reply code for an unrecognized command&period;
| xref:TRUC_ANCESTOR_LIMIT.adoc[`TRUC&lowbar;ANCESTOR&lowbar;LIMIT`] 
| Maximum number of transactions including a TRUC tx and all its mempool ancestors&period;
| xref:TRUC_CHILD_MAX_VSIZE.adoc[`TRUC&lowbar;CHILD&lowbar;MAX&lowbar;VSIZE`] 
| Maximum sigop&hyphen;adjusted virtual size of a tx which spends from an unconfirmed TRUC transaction&period;
| xref:TRUC_CHILD_MAX_WEIGHT.adoc[`TRUC&lowbar;CHILD&lowbar;MAX&lowbar;WEIGHT`] 
| Maximum weight of a TRUC child transaction, derived from TRUC&lowbar;CHILD&lowbar;MAX&lowbar;VSIZE&period;
| xref:TRUC_DESCENDANT_LIMIT.adoc[`TRUC&lowbar;DESCENDANT&lowbar;LIMIT`] 
| Maximum number of transactions including an unconfirmed tx and its descendants&period;
| xref:TRUC_MAX_VSIZE.adoc[`TRUC&lowbar;MAX&lowbar;VSIZE`] 
| Maximum sigop&hyphen;adjusted virtual size of all v3 transactions&period;
| xref:TRUC_MAX_WEIGHT.adoc[`TRUC&lowbar;MAX&lowbar;WEIGHT`] 
| Maximum weight of a TRUC transaction, derived from TRUC&lowbar;MAX&lowbar;VSIZE&period;
| xref:TRUC_VERSION.adoc[`TRUC&lowbar;VERSION`] 
| Transaction version that marks a transaction as TRUC (BIP 431)&period;
| xref:TXRECONCILIATION_VERSION.adoc[`TXRECONCILIATION&lowbar;VERSION`] 
| Supported transaction reconciliation protocol version
| xref:TX_MAX_STANDARD_VERSION.adoc[`TX&lowbar;MAX&lowbar;STANDARD&lowbar;VERSION`] 
| Highest transaction version accepted by standard relay policy&period;
| xref:TX_MIN_STANDARD_VERSION.adoc[`TX&lowbar;MIN&lowbar;STANDARD&lowbar;VERSION`] 
| Lowest transaction version accepted by standard relay policy&period;
| xref:TX_NO_WITNESS.adoc[`TX&lowbar;NO&lowbar;WITNESS`] 
| Serialization parameters that omit transaction witness data&period;
| xref:TX_WITH_WITNESS.adoc[`TX&lowbar;WITH&lowbar;WITNESS`] 
| Serialization parameters that include transaction witness data&period;
| xref:UA_NAME.adoc[`UA&lowbar;NAME`] 
| Base user agent name advertised to peers (for example &quot;Satoshi&quot;)&period;
| xref:UNIX_EPOCH_TIME.adoc[`UNIX&lowbar;EPOCH&lowbar;TIME`] 
| String used to describe UNIX epoch time in documentation, factored out to a constant for consistency&period;
| xref:VALIDATION_WEIGHT_OFFSET.adoc[`VALIDATION&lowbar;WEIGHT&lowbar;OFFSET`] 
| Weight budget added to the witness size (Tapscript only, see BIP 342)&period;
| xref:VALIDATION_WEIGHT_PER_SIGOP_PASSED.adoc[`VALIDATION&lowbar;WEIGHT&lowbar;PER&lowbar;SIGOP&lowbar;PASSED`] 
| Validation weight per passing signature (Tapscript only, see BIP 342)&period;
| xref:VERSIONBITS_LAST_OLD_BLOCK_VERSION.adoc[`VERSIONBITS&lowbar;LAST&lowbar;OLD&lowbar;BLOCK&lowbar;VERSION`] 
| What block version to use for new blocks (pre versionbits)
| xref:VERSIONBITS_NUM_BITS.adoc[`VERSIONBITS&lowbar;NUM&lowbar;BITS`] 
| Total bits available for versionbits (BIP 323)
| xref:VERSIONBITS_TOP_BITS.adoc[`VERSIONBITS&lowbar;TOP&lowbar;BITS`] 
| What bits to set in version for versionbits blocks
| xref:VERSIONBITS_TOP_MASK.adoc[`VERSIONBITS&lowbar;TOP&lowbar;MASK`] 
| What bitmask determines whether versionbits is in use
| xref:VersionBitsDeploymentInfo.adoc[`VersionBitsDeploymentInfo`] 
| Lookup table of deployment info, indexed by version&hyphen;bits deployment position&period;
| xref:WITNESS_SCALE_FACTOR.adoc[`WITNESS&lowbar;SCALE&lowbar;FACTOR`] 
| Weight given to non&hyphen;witness bytes relative to witness bytes when computing block weight (BIP 141)&period;
| xref:WITNESS_V0_KEYHASH_SIZE.adoc[`WITNESS&lowbar;V0&lowbar;KEYHASH&lowbar;SIZE`] 
| Byte length of a witness v0 P2WPKH key hash&period;
| xref:WITNESS_V0_SCRIPTHASH_SIZE.adoc[`WITNESS&lowbar;V0&lowbar;SCRIPTHASH&lowbar;SIZE`] 
| Byte length of a witness v0 P2WSH script hash&period;
| xref:WITNESS_V1_TAPROOT_SIZE.adoc[`WITNESS&lowbar;V1&lowbar;TAPROOT&lowbar;SIZE`] 
| Byte length of a witness v1 Taproot output key&period;
| xref:WTXID_RELAY_VERSION.adoc[`WTXID&lowbar;RELAY&lowbar;VERSION`] 
| &quot;wtxidrelay&quot; message type for wtxid&hyphen;based relay starts with this version
| xref:cs_main.adoc[`cs&lowbar;main`] 
| Mutex to guard access to validation specific variables, such as reading or changing the chainstate&period;
| xref:deserialize.adoc[`deserialize`] 
| Tag instance used to select deserializing constructors&period;
| xref:fDiscover.adoc[`fDiscover`] 
| Whether to discover our own local addresses (&hyphen;discover)&period;
| xref:fListen.adoc[`fListen`] 
| Whether to accept incoming connections (&hyphen;listen)&period;
| xref:fLogIPs.adoc[`fLogIPs`] 
| Whether client IP addresses are included in log output&period;
| xref:fNameLookup.adoc[`fNameLookup`] 
| Whether DNS name lookups are allowed, set by the `&hyphen;dns` option&period;
| xref:gArgs.adoc[`gArgs`] 
| Global argument manager shared across the application&period;
| xref:g_coin_stats_index.adoc[`g&lowbar;coin&lowbar;stats&lowbar;index`] 
| The global UTXO set hash object&period;
| xref:g_detail_test_only_CheckFailuresAreExceptionsNotAborts.adoc[`g&lowbar;detail&lowbar;test&lowbar;only&lowbar;CheckFailuresAreExceptionsNotAborts`] 
| When true, failed checks throw an exception instead of aborting (test only)&period;
| xref:g_dns_lookup.adoc[`g&lowbar;dns&lowbar;lookup`] 
| The DNS resolver used by lookup functions&semi; overridable for tests&period;
| xref:g_enable_dynamic_fuzz_determinism.adoc[`g&lowbar;enable&lowbar;dynamic&lowbar;fuzz&lowbar;determinism`] 
| Runtime toggle that enables fuzz determinism when it is not fixed at compile time&period;
| xref:g_maplocalhost_mutex.adoc[`g&lowbar;maplocalhost&lowbar;mutex`] 
| Guards access to mapLocalHost&period;
| xref:g_reachable_nets.adoc[`g&lowbar;reachable&lowbar;nets`] 
| Global set of networks currently considered reachable&period;
| xref:g_socks5_interrupt.adoc[`g&lowbar;socks5&lowbar;interrupt`] 
| Interrupt SOCKS5 reads or writes&period;
| xref:g_txindex.adoc[`g&lowbar;txindex`] 
| The global transaction index, used in GetTransaction&period; May be null&period;
| xref:g_txospenderindex.adoc[`g&lowbar;txospenderindex`] 
| The global txo spender index&period; May be null&period;
| xref:g_wallet_init_interface.adoc[`g&lowbar;wallet&lowbar;init&lowbar;interface`] 
| Global wallet initialization interface, either the real wallet or a stub&period;
| xref:g_zmq_notification_interface.adoc[`g&lowbar;zmq&lowbar;notification&lowbar;interface`] 
| The process&hyphen;wide ZMQ notification interface, or nullptr when ZMQ is disabled&period;
| xref:mapLocalHost.adoc[`mapLocalHost`] 
| Map of our known local addresses to their advertised service info&period;
| xref:nBytesPerSigOp.adoc[`nBytesPerSigOp`] 
| Bytes&hyphen;per&hyphen;sigop ratio used to weight signature operations against transaction size in policy checks&period;
| xref:nConnectTimeout.adoc[`nConnectTimeout`] 
| Connection timeout in milliseconds, set by the `&hyphen;timeout` option&period;
| xref:strSubVersion.adoc[`strSubVersion`] 
| Subversion as sent to the P2P network in `version` messages
| xref:tableRPC.adoc[`tableRPC`] 
| The global RPC command dispatch table&period;
| xref:uiInterface.adoc[`uiInterface`] 
| The process&hyphen;wide UI signal interface used to communicate with the front end&period;
|===


== Concepts

[cols="1,4"]
|===
| Name| Description
| xref:BasicByte.adoc[`BasicByte`] 
| Satisfied by types whose pointer can be cast to an unsigned char pointer via UCharCast&period;
| xref:ByteType.adoc[`ByteType`] 
| Constrains a type to a single&hyphen;byte type usable as a raw buffer element&period;
| xref:CharNotInt8.adoc[`CharNotInt8`] 
| Matches char only when it is a distinct type from int8&lowbar;t, used to forbid serializing char&period;
| xref:ContainsStream.adoc[`ContainsStream`] 
| Check if type contains a stream by seeing if has a GetStream() method&period;
| xref:RandomNumberGenerator.adoc[`RandomNumberGenerator`] 
| A concept for RandomMixin&hyphen;based random number generators&period;
| xref:Serializable.adoc[`Serializable`] 
| If none of the specialized versions above matched, default to calling member function&period;
| xref:StdChronoDuration.adoc[`StdChronoDuration`] 
| A concept for C&plus;&plus; std&colon;&colon;chrono durations&period;
| xref:TxidOrWtxid.adoc[`TxidOrWtxid`] 
| Satisfied only by the Txid and Wtxid identifier types&period;
| xref:Unserializable.adoc[`Unserializable`] 
| Satisfied by types that provide an Unserialize member function&period;
|===


== Using Declarations

[cols="1,4"]
|===
| Name| Description
| xref:BlockRef.adoc[`BlockRef`] 
| Bring the block reference type into the current namespace&period;
| xref:PSBTError.adoc[`PSBTError`] 
| Alias for the PSBT error type used throughout this header&period;
|===


== Macros

[cols="1,4"]
|===
| Name| Description
| xref:Assert.adoc[`Assert`] 
| Identity function&period; Abort if the value compares equal to zero&period;
| xref:Assume.adoc[`Assume`] 
| Assume is the identity function&period;
| xref:CHECK_NONFATAL.adoc[`CHECK&lowbar;NONFATAL`] 
| Identity function&period; Throw a NonFatalCheckError when the condition evaluates to false
| xref:COPYRIGHT_STR.adoc[`COPYRIGHT&lowbar;STR`] 
| Copyright string used in Windows &period;rc files
| xref:FORMATTER_METHODS.adoc[`FORMATTER&lowbar;METHODS`] 
| Implement the Ser and Unser methods needed for implementing a formatter (see Using below)&period;
| xref:LIST_CHAIN_NAMES.adoc[`LIST&lowbar;CHAIN&lowbar;NAMES`] 
| List of possible chain &sol; network names
| xref:MAKE_RANGE_METHOD.adoc[`MAKE&lowbar;RANGE&lowbar;METHOD`] 
| Defines a range accessor method `method&lowbar;name` over the given size and get functions&period;
| xref:NONFATAL_UNREACHABLE.adoc[`NONFATAL&lowbar;UNREACHABLE`] 
| NONFATAL&lowbar;UNREACHABLE() is a macro that is used to mark unreachable code&period; It throws a NonFatalCheckError&period;
| xref:SERIALIZE_METHODS.adoc[`SERIALIZE&lowbar;METHODS`] 
| Implement the Serialize and Unserialize methods by delegating to a single templated static method that takes the to&hyphen;be&hyphen;(de)serialized object as a parameter&period; This approach has the advantage that the constness of the object becomes a template parameter, and thus allows a single implementation that sees the object as const for serializing and non&hyphen;const for deserializing, without casts&period;
| xref:SER_PARAMS.adoc[`SER&lowbar;PARAMS`] 
| Formatter methods can retrieve parameters attached to a stream using the SER&lowbar;PARAMS(type) macro as long as the stream is created directly or indirectly with a parameter of that type&period; This permits making serialization depend on run&hyphen;time context in a type&hyphen;safe way&period;
| xref:SER_PARAMS_OPFUNC.adoc[`SER&lowbar;PARAMS&lowbar;OPFUNC`] 
| Helper macro for SerParams structs
| xref:STRINGIZE.adoc[`STRINGIZE`] 
| Converts the parameter X to a string after macro replacement on X has been performed&period; Don&apos;t merge these into one macro!
| xref:WITH_LOCK.adoc[`WITH&lowbar;LOCK`] 
| Run code while locking a mutex&period;
| xref:btck_BlockCheckFlags_ALL.adoc[`btck&lowbar;BlockCheckFlags&lowbar;ALL`] 
| enable all optional context&hyphen;free block checks
| xref:btck_BlockCheckFlags_BASE.adoc[`btck&lowbar;BlockCheckFlags&lowbar;BASE`] 
| run the base context&hyphen;free block checks only
| xref:btck_BlockCheckFlags_MERKLE.adoc[`btck&lowbar;BlockCheckFlags&lowbar;MERKLE`] 
| verify merkle root (and mutation detection)
| xref:btck_BlockCheckFlags_POW.adoc[`btck&lowbar;BlockCheckFlags&lowbar;POW`] 
| run CheckProofOfWork via CheckBlockHeader
| xref:btck_BlockValidationResult_CACHED_INVALID.adoc[`btck&lowbar;BlockValidationResult&lowbar;CACHED&lowbar;INVALID`] 
| this block was cached as being invalid and we didn&apos;t store the reason why
| xref:btck_BlockValidationResult_CONSENSUS.adoc[`btck&lowbar;BlockValidationResult&lowbar;CONSENSUS`] 
| invalid by consensus rules (excluding any below reasons)
| xref:btck_BlockValidationResult_HEADER_LOW_WORK.adoc[`btck&lowbar;BlockValidationResult&lowbar;HEADER&lowbar;LOW&lowbar;WORK`] 
| the block header may be on a too&hyphen;little&hyphen;work chain
| xref:btck_BlockValidationResult_INVALID_HEADER.adoc[`btck&lowbar;BlockValidationResult&lowbar;INVALID&lowbar;HEADER`] 
| invalid proof of work or time too old
| xref:btck_BlockValidationResult_INVALID_PREV.adoc[`btck&lowbar;BlockValidationResult&lowbar;INVALID&lowbar;PREV`] 
| A block this one builds on is invalid
| xref:btck_BlockValidationResult_MISSING_PREV.adoc[`btck&lowbar;BlockValidationResult&lowbar;MISSING&lowbar;PREV`] 
| We don&apos;t have the previous block the checked one is built on
| xref:btck_BlockValidationResult_MUTATED.adoc[`btck&lowbar;BlockValidationResult&lowbar;MUTATED`] 
| the block&apos;s data didn&apos;t match the data committed to by the PoW
| xref:btck_BlockValidationResult_TIME_FUTURE.adoc[`btck&lowbar;BlockValidationResult&lowbar;TIME&lowbar;FUTURE`] 
| block timestamp was &gt; 2 hours in the future (or our clock is bad)
| xref:btck_BlockValidationResult_UNSET.adoc[`btck&lowbar;BlockValidationResult&lowbar;UNSET`] 
| initial value&period; Block has not yet been rejected
| xref:btck_ScriptVerificationFlags_CHECKLOCKTIMEVERIFY.adoc[`btck&lowbar;ScriptVerificationFlags&lowbar;CHECKLOCKTIMEVERIFY`] 
| enable CHECKLOCKTIMEVERIFY (BIP65)
| xref:btck_ScriptVerificationFlags_CHECKSEQUENCEVERIFY.adoc[`btck&lowbar;ScriptVerificationFlags&lowbar;CHECKSEQUENCEVERIFY`] 
| enable CHECKSEQUENCEVERIFY (BIP112)
| xref:btck_ScriptVerificationFlags_DERSIG.adoc[`btck&lowbar;ScriptVerificationFlags&lowbar;DERSIG`] 
| enforce strict DER (BIP66) compliance
| xref:btck_ScriptVerificationFlags_NULLDUMMY.adoc[`btck&lowbar;ScriptVerificationFlags&lowbar;NULLDUMMY`] 
| enforce NULLDUMMY (BIP147)
| xref:btck_ScriptVerificationFlags_P2SH.adoc[`btck&lowbar;ScriptVerificationFlags&lowbar;P2SH`] 
| evaluate P2SH (BIP16) subscripts
| xref:btck_ScriptVerificationFlags_TAPROOT.adoc[`btck&lowbar;ScriptVerificationFlags&lowbar;TAPROOT`] 
| enable TAPROOT (BIPs 341 &amp; 342)
| xref:btck_ScriptVerificationFlags_WITNESS.adoc[`btck&lowbar;ScriptVerificationFlags&lowbar;WITNESS`] 
| enable WITNESS (BIP141)
| xref:btck_ScriptVerifyStatus_ERROR_INVALID_FLAGS_COMBINATION.adoc[`btck&lowbar;ScriptVerifyStatus&lowbar;ERROR&lowbar;INVALID&lowbar;FLAGS&lowbar;COMBINATION`] 
| The flags were combined in an invalid way&period;
| xref:btck_ScriptVerifyStatus_ERROR_SPENT_OUTPUTS_REQUIRED.adoc[`btck&lowbar;ScriptVerifyStatus&lowbar;ERROR&lowbar;SPENT&lowbar;OUTPUTS&lowbar;REQUIRED`] 
| The taproot flag was set, so valid spent&lowbar;outputs have to be provided&period;
| xref:btck_TxValidationResult_CONFLICT.adoc[`btck&lowbar;TxValidationResult&lowbar;CONFLICT`] 
| tx already in mempool or conflicts with a tx in the chain
| xref:btck_TxValidationResult_CONSENSUS.adoc[`btck&lowbar;TxValidationResult&lowbar;CONSENSUS`] 
| invalid by consensus rules
| xref:btck_TxValidationResult_INPUTS_NOT_STANDARD.adoc[`btck&lowbar;TxValidationResult&lowbar;INPUTS&lowbar;NOT&lowbar;STANDARD`] 
| inputs (covered by txid) failed policy rules
| xref:btck_TxValidationResult_MEMPOOL_POLICY.adoc[`btck&lowbar;TxValidationResult&lowbar;MEMPOOL&lowbar;POLICY`] 
| violated mempool&apos;s fee&sol;size&sol;descendant&sol;RBF&sol;etc limits
| xref:btck_TxValidationResult_MISSING_INPUTS.adoc[`btck&lowbar;TxValidationResult&lowbar;MISSING&lowbar;INPUTS`] 
| transaction was missing some of its inputs
| xref:btck_TxValidationResult_NOT_STANDARD.adoc[`btck&lowbar;TxValidationResult&lowbar;NOT&lowbar;STANDARD`] 
| otherwise didn&apos;t meet local policy rules
| xref:btck_TxValidationResult_NO_MEMPOOL.adoc[`btck&lowbar;TxValidationResult&lowbar;NO&lowbar;MEMPOOL`] 
| this node does not have a mempool so can&apos;t validate the transaction
| xref:btck_TxValidationResult_PREMATURE_SPEND.adoc[`btck&lowbar;TxValidationResult&lowbar;PREMATURE&lowbar;SPEND`] 
| transaction spends a coinbase too early, or violates locktime&sol;sequence locks
| xref:btck_TxValidationResult_RECONSIDERABLE.adoc[`btck&lowbar;TxValidationResult&lowbar;RECONSIDERABLE`] 
| fails some policy, but might be acceptable if submitted in a (different) package
| xref:btck_TxValidationResult_UNKNOWN.adoc[`btck&lowbar;TxValidationResult&lowbar;UNKNOWN`] 
| transaction was not validated because package failed
| xref:btck_TxValidationResult_UNSET.adoc[`btck&lowbar;TxValidationResult&lowbar;UNSET`] 
| initial value&period; Tx has not yet been rejected
| xref:btck_TxValidationResult_WITNESS_MUTATED.adoc[`btck&lowbar;TxValidationResult&lowbar;WITNESS&lowbar;MUTATED`] 
| witness may have been malleated or is prior to SegWit activation
| xref:btck_TxValidationResult_WITNESS_STRIPPED.adoc[`btck&lowbar;TxValidationResult&lowbar;WITNESS&lowbar;STRIPPED`] 
| transaction is missing a witness
| xref:strprintf.adoc[`strprintf`] 
| Format arguments and return the string or write to given std&colon;&colon;ostream (see tinyformat&colon;&colon;format doc for details)
|===


== xref:BCLog.adoc[BCLog] namespace

Bitcoin Core logging facilities&colon; log categories and their bit flags&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:BCLog/LogRateLimiter.adoc[`LogRateLimiter`] 
| Fixed window rate limiter for logging&period;
| xref:BCLog/Logger.adoc[`Logger`] 
| Central logger that formats entries and writes them to the console, a file and callbacks&period;
| xref:BCLog/Timer.adoc[`Timer`] 
| RAII&hyphen;style object that outputs timing information to logs&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:BCLog/CategoryMask.adoc[`CategoryMask`] 
| Bit mask holding a set of BCLog&colon;&colon;LogFlags log categories&period;
| xref:BCLog/Level.adoc[`Level`] 
| Alias for compatibility&period; Prefer util&colon;&colon;log&colon;&colon;Level over BCLog&colon;&colon;Level in new code&period;
|===


=== Enums

[cols="1,4"]
|===
| Name| Description
| xref:BCLog/LogFlags.adoc[`LogFlags`] 
| Debug logging categories, each a distinct bit in a CategoryMask&period;
|===


=== Variables

[cols="1,4"]
|===
| Name| Description
| xref:BCLog/DEFAULT_LOGRATELIMIT.adoc[`DEFAULT&lowbar;LOGRATELIMIT`] 
| Default for whether log rate limiting is enabled&period;
| xref:BCLog/DEFAULT_LOG_LEVEL.adoc[`DEFAULT&lowbar;LOG&lowbar;LEVEL`] 
| Default global log severity level&period;
| xref:BCLog/DEFAULT_MAX_LOG_BUFFER.adoc[`DEFAULT&lowbar;MAX&lowbar;LOG&lowbar;BUFFER`] 
| buffer up to 1MB of log data prior to StartLogging
| xref:BCLog/RATELIMIT_MAX_BYTES.adoc[`RATELIMIT&lowbar;MAX&lowbar;BYTES`] 
| maximum number of bytes per source location that can be logged within the rate&hyphen;limit window
| xref:BCLog/RATELIMIT_WINDOW.adoc[`RATELIMIT&lowbar;WINDOW`] 
| time window after which log ratelimit stats are reset
|===


== xref:Consensus.adoc[Consensus] namespace

Transaction validation functions

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:Consensus/BIP9Deployment.adoc[`BIP9Deployment`] 
| Struct for each individual consensus rule change using BIP9&period;
| xref:Consensus/Params.adoc[`Params`] 
| Parameters that influence chain consensus&period;
|===


=== Enums

[cols="1,4"]
|===
| Name| Description
| xref:Consensus/BuriedDeployment.adoc[`BuriedDeployment`] 
| A buried deployment is one where the height of the activation has been hardcoded into the client implementation long after the consensus change has activated&period; See BIP 90&period; Consensus changes for which the new rules are enforced from genesis are not listed here&period;
| xref:Consensus/DeploymentPos.adoc[`DeploymentPos`] 
| Identifiers for BIP9 version&hyphen;bits deployments&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:Consensus/CheckTxInputs.adoc[`CheckTxInputs`] 
| Check whether all inputs of this transaction are valid (no double spends and amounts) This does not modify the UTXO set&period; This does not check scripts and sigs&period;
| xref:Consensus/ValidDeployment-0c.adoc[`ValidDeployment`] 
| `ValidDeployment` overloads
|===


== xref:CuckooCache.adoc[CuckooCache] namespace

High&hyphen;performance cache primitives&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:CuckooCache/bit_packed_atomic_flags.adoc[`bit&lowbar;packed&lowbar;atomic&lowbar;flags`] 
| xref:CuckooCache/bit_packed_atomic_flags/2constructor-0e.adoc[`bit&lowbar;packed&lowbar;atomic&lowbar;flags`] implements a container for garbage collection flags that is only thread unsafe on calls to setup&period; This class bit&hyphen;packs collection flags for memory efficiency&period;
| xref:CuckooCache/cache.adoc[`cache`] 
| xref:CuckooCache/cache/2constructor.adoc[`cache`] implements a cache with properties similar to a cuckoo&hyphen;set&period;
|===


== xref:NetMsg.adoc[NetMsg] namespace

Helpers for constructing serialized network messages&period;

=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:NetMsg/Make.adoc[`Make`] 
| Build a serialized network message of the given type from its payload&period;
|===


== xref:NetMsgFeature.adoc[NetMsgFeature] namespace

Identifiers for individual peer&hyphen;negotiated features (BIP 434)&period;

== xref:NetMsgType.adoc[NetMsgType] namespace

Bitcoin protocol message types&period; When adding new message types, don&apos;t forget to update ALL&lowbar;NET&lowbar;MESSAGE&lowbar;TYPES below&period;

=== Variables

[cols="1,4"]
|===
| Name| Description
| xref:NetMsgType/ADDR.adoc[`ADDR`] 
| The addr (IP address) message relays connection information for peers on the network&period;
| xref:NetMsgType/ADDRV2.adoc[`ADDRV2`] 
| The addrv2 message relays connection information for peers on the network just like the addr message, but is extended to allow gossiping of longer node addresses (see BIP155)&period;
| xref:NetMsgType/BLOCK.adoc[`BLOCK`] 
| The block message transmits a single serialized block&period;
| xref:NetMsgType/BLOCKTXN.adoc[`BLOCKTXN`] 
| Contains a BlockTransactions&period; Sent in response to a &quot;getblocktxn&quot; message&period;
| xref:NetMsgType/CFCHECKPT.adoc[`CFCHECKPT`] 
| cfcheckpt is a response to a getcfcheckpt request containing a vector of evenly spaced filter headers for blocks on the requested chain&period;
| xref:NetMsgType/CFHEADERS.adoc[`CFHEADERS`] 
| cfheaders is a response to a getcfheaders request containing a filter header and a vector of filter hashes for each subsequent block in the requested range&period;
| xref:NetMsgType/CFILTER.adoc[`CFILTER`] 
| cfilter is a response to a getcfilters request containing a single compact filter&period;
| xref:NetMsgType/CMPCTBLOCK.adoc[`CMPCTBLOCK`] 
| Contains a CBlockHeaderAndShortTxIDs object &hyphen; providing a header and list of &quot;short txids&quot;&period;
| xref:NetMsgType/FEATURE.adoc[`FEATURE`] 
| BIP 434 Peer feature negotiation
| xref:NetMsgType/FEEFILTER.adoc[`FEEFILTER`] 
| The feefilter message tells the receiving peer not to inv us any txs which do not meet the specified min fee rate&period;
| xref:NetMsgType/FILTERADD.adoc[`FILTERADD`] 
| The filteradd message tells the receiving peer to add a single element to a previously&hyphen;set bloom filter, such as a new public key&period;
| xref:NetMsgType/FILTERCLEAR.adoc[`FILTERCLEAR`] 
| The filterclear message tells the receiving peer to remove a previously&hyphen;set bloom filter&period;
| xref:NetMsgType/FILTERLOAD.adoc[`FILTERLOAD`] 
| The filterload message tells the receiving peer to filter all relayed transactions and requested merkle blocks through the provided filter&period;
| xref:NetMsgType/GETADDR.adoc[`GETADDR`] 
| The getaddr message requests an addr message from the receiving node, preferably one with lots of IP addresses of other receiving nodes&period;
| xref:NetMsgType/GETBLOCKS.adoc[`GETBLOCKS`] 
| The getblocks message requests an inv message that provides block header hashes starting from a particular point in the block chain&period;
| xref:NetMsgType/GETBLOCKTXN.adoc[`GETBLOCKTXN`] 
| Contains a BlockTransactionsRequest Peer should respond with &quot;blocktxn&quot; message&period;
| xref:NetMsgType/GETCFCHECKPT.adoc[`GETCFCHECKPT`] 
| getcfcheckpt requests evenly spaced compact filter headers, enabling parallelized download and validation of the headers between them&period; Only available with service bit NODE&lowbar;COMPACT&lowbar;FILTERS as described by BIP 157 &amp; 158&period;
| xref:NetMsgType/GETCFHEADERS.adoc[`GETCFHEADERS`] 
| getcfheaders requests a compact filter header and the filter hashes for a range of blocks, which can then be used to reconstruct the filter headers for those blocks&period; Only available with service bit NODE&lowbar;COMPACT&lowbar;FILTERS as described by BIP 157 &amp; 158&period;
| xref:NetMsgType/GETCFILTERS.adoc[`GETCFILTERS`] 
| getcfilters requests compact filters for a range of blocks&period; Only available with service bit NODE&lowbar;COMPACT&lowbar;FILTERS as described by BIP 157 &amp; 158&period;
| xref:NetMsgType/GETDATA.adoc[`GETDATA`] 
| The getdata message requests one or more data objects from another node&period;
| xref:NetMsgType/GETHEADERS.adoc[`GETHEADERS`] 
| The getheaders message requests a headers message that provides block headers starting from a particular point in the block chain&period;
| xref:NetMsgType/HEADERS.adoc[`HEADERS`] 
| The headers message sends one or more block headers to a node which previously requested certain headers with a getheaders message&period;
| xref:NetMsgType/INV.adoc[`INV`] 
| The inv message (inventory message) transmits one or more inventories of objects known to the transmitting peer&period;
| xref:NetMsgType/MEMPOOL.adoc[`MEMPOOL`] 
| The mempool message requests the TXIDs of transactions that the receiving node has verified as valid but which have not yet appeared in a block&period;
| xref:NetMsgType/MERKLEBLOCK.adoc[`MERKLEBLOCK`] 
| The merkleblock message is a reply to a getdata message which requested a block using the inventory type MSG&lowbar;MERKLEBLOCK&period;
| xref:NetMsgType/NOTFOUND.adoc[`NOTFOUND`] 
| The notfound message is a reply to a getdata message which requested an object the receiving node does not have available for relay&period;
| xref:NetMsgType/PING.adoc[`PING`] 
| The ping message is sent periodically to help confirm that the receiving peer is still connected&period;
| xref:NetMsgType/PONG.adoc[`PONG`] 
| The pong message replies to a ping message, proving to the pinging node that the ponging node is still alive&period;
| xref:NetMsgType/SENDADDRV2.adoc[`SENDADDRV2`] 
| The sendaddrv2 message signals support for receiving ADDRV2 messages (BIP155)&period; It also implies that its sender can encode as ADDRV2 and would send ADDRV2 instead of ADDR to a peer that has signaled ADDRV2 support by sending SENDADDRV2&period;
| xref:NetMsgType/SENDCMPCT.adoc[`SENDCMPCT`] 
| Contains a 1&hyphen;byte bool and 8&hyphen;byte LE version number&period; Indicates that a node is willing to provide blocks via &quot;cmpctblock&quot; messages&period; May indicate that a node prefers to receive new block announcements via a &quot;cmpctblock&quot; message rather than an &quot;inv&quot;, depending on message contents&period;
| xref:NetMsgType/SENDHEADERS.adoc[`SENDHEADERS`] 
| Indicates that a node prefers to receive new block announcements via a &quot;headers&quot; message rather than an &quot;inv&quot;&period;
| xref:NetMsgType/SENDTXRCNCL.adoc[`SENDTXRCNCL`] 
| Contains a 4&hyphen;byte version number and an 8&hyphen;byte salt&period; The salt is used to compute short txids needed for efficient txreconciliation, as described by BIP 330&period;
| xref:NetMsgType/TX.adoc[`TX`] 
| The tx message transmits a single transaction&period;
| xref:NetMsgType/VERACK.adoc[`VERACK`] 
| The verack message acknowledges a previously&hyphen;received version message, informing the connecting node that it can begin to send other messages&period;
| xref:NetMsgType/VERSION.adoc[`VERSION`] 
| The version message provides information about the transmitting node to the receiving node at the beginning of a connection&period;
| xref:NetMsgType/WTXIDRELAY.adoc[`WTXIDRELAY`] 
| Indicates that a node prefers to relay transactions via wtxid, rather than txid&period;
|===


== xref:bech32.adoc[bech32] namespace

Bech32 and Bech32m string encoding used by newer Bitcoin address types&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:bech32/DecodeResult.adoc[`DecodeResult`] 
| Result of decoding a Bech32(m) string&colon; its encoding, human&hyphen;readable part, and payload&period;
|===


=== Enums

[cols="1,4"]
|===
| Name| Description
| xref:bech32/CharLimit.adoc[`CharLimit`] 
| Character limits for Bech32(m) encoded strings&period; Character limits are how we provide error location guarantees&period; These values should never exceed 2&circ;31 &hyphen; 1 (max value for a 32&hyphen;bit int), since there are places where we may need to convert the CharLimit&colon;&colon;VALUE to an int&period; In practice, this should never happen since this CharLimit applies to an address encoding and we would never encode an address with such a massive value
| xref:bech32/Encoding.adoc[`Encoding`] 
| Which Bech32 variant a string uses, or that decoding failed&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:bech32/Decode.adoc[`Decode`] 
| Decode a Bech32 or Bech32m string&period;
| xref:bech32/Encode.adoc[`Encode`] 
| Encode a Bech32 or Bech32m string&period; If hrp contains uppercase characters, this will cause an assertion error&period; Encoding must be one of BECH32 or BECH32M&period;
| xref:bech32/LocateErrors.adoc[`LocateErrors`] 
| Return the positions of errors in a Bech32 string&period;
|===


=== Variables

[cols="1,4"]
|===
| Name| Description
| xref:bech32/CHECKSUM_SIZE.adoc[`CHECKSUM&lowbar;SIZE`] 
| Number of trailing checksum characters in a Bech32(m) string&period;
| xref:bech32/SEPARATOR.adoc[`SEPARATOR`] 
| Character separating the human&hyphen;readable part from the data section&period;
|===


== xref:bitcoin_http.adoc[bitcoin&lowbar;http] namespace

Constants and error types for the built&hyphen;in HTTP server&apos;s request parsing&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:bitcoin_http/ContentTooLargeError.adoc[`ContentTooLargeError`] 
| Thrown when a request body exceeds MAX&lowbar;BODY&lowbar;SIZE (or _will_ exceed, in chunked transfer) so the server can reply with more specific code 413 (content too large) vs general 400 (bad request)
|===


=== Variables

[cols="1,4"]
|===
| Name| Description
| xref:bitcoin_http/MAX_BODY_SIZE.adoc[`MAX&lowbar;BODY&lowbar;SIZE`] 
| Maximum size of an HTTP request body
| xref:bitcoin_http/MAX_HEADERS_SIZE.adoc[`MAX&lowbar;HEADERS&lowbar;SIZE`] 
| Maximum size of each headers line in an HTTP request, also the maximum size of all headers total&period; See https&colon;&sol;&sol;github&period;com&sol;bitcoin&sol;bitcoin&sol;pull&sol;6859 And libevent http&period;c evhttp&lowbar;parse&lowbar;headers&lowbar;()
| xref:bitcoin_http/MIN_REQUEST_LINE_LENGTH.adoc[`MIN&lowbar;REQUEST&lowbar;LINE&lowbar;LENGTH`] 
| Shortest valid request line, used by libevent in evhttp&lowbar;parse&lowbar;request&lowbar;line()
|===


== xref:bitset_detail.adoc[bitset&lowbar;detail] namespace

Implementation details backing the BitSet alias&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:bitset_detail/IntBitSet.adoc[`IntBitSet`] 
| A bitset implementation backed by a single integer of type I&period;
| xref:bitset_detail/MultiIntBitSet.adoc[`MultiIntBitSet`] 
| A bitset implementation backed by N integers of type I&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:bitset_detail/PopCount.adoc[`PopCount`] 
| Count the number of bits set in an unsigned integer type&period;
| xref:bitset_detail/operator_bitand-02.adoc[`operator&amp;`] 
| Return an object with the binary AND between respective bits from a and b&period;
| xref:bitset_detail/operator_minus-0c.adoc[`operator&hyphen;`] 
| Return an object with the binary AND NOT between respective bits from a and b&period;
| xref:bitset_detail/operator_xor-08.adoc[`operator&circ;`] 
| Return an object with the binary XOR between respective bits from a and b&period;
| xref:bitset_detail/operator_bitor-0a.adoc[`operator&verbar;`] 
| Return an object with the binary OR between respective bits from a and b&period;
| xref:bitset_detail/swap-05.adoc[`swap`] 
| Swap two bitsets&period;
| xref:bitset_detail/operator_eq-0b.adoc[`operator&equals;&equals;`] 
| Equality operators
|===


== xref:btck.adoc[btck] namespace

Type&hyphen;safe C&plus;&plus; RAII wrapper over the libbitcoinkernel C API&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:btck/Block.adoc[`Block`] 
| Owning wrapper over a `btck&lowbar;Block`, a full block with its transactions&period;
| xref:btck/BlockHash.adoc[`BlockHash`] 
| Owning wrapper over a `btck&lowbar;BlockHash`&period;
| xref:btck/BlockHashApi-00.adoc[`BlockHashApi`] 
| CRTP mixin adding block&hyphen;hash operations shared by the view and owning types&period;
| xref:btck/BlockHashView.adoc[`BlockHashView`] 
| Non&hyphen;owning view over a `btck&lowbar;BlockHash`&period;
| xref:btck/BlockHeader.adoc[`BlockHeader`] 
| Owning wrapper over a `btck&lowbar;BlockHeader`&period;
| xref:btck/BlockHeaderApi-03.adoc[`BlockHeaderApi`] 
| CRTP mixin adding block&hyphen;header accessors shared by the view and owning types&period;
| xref:btck/BlockHeaderView.adoc[`BlockHeaderView`] 
| Non&hyphen;owning view over a `btck&lowbar;BlockHeader`&period;
| xref:btck/BlockSpentOutputs.adoc[`BlockSpentOutputs`] 
| Owning wrapper over a `btck&lowbar;BlockSpentOutputs`, the undo data of a whole block&period;
| xref:btck/BlockTreeEntry.adoc[`BlockTreeEntry`] 
| Non&hyphen;owning view over a `btck&lowbar;BlockTreeEntry`, a node in the block index tree&period;
| xref:btck/BlockValidationState.adoc[`BlockValidationState`] 
| Owning wrapper over a `btck&lowbar;BlockValidationState`, holding a block&apos;s validation outcome&period;
| xref:btck/BlockValidationStateApi-0c.adoc[`BlockValidationStateApi`] 
| CRTP mixin adding block&hyphen;validation&hyphen;state accessors shared by the view and owning types&period;
| xref:btck/BlockValidationStateView.adoc[`BlockValidationStateView`] 
| Non&hyphen;owning view over a `btck&lowbar;BlockValidationState`&period;
| xref:btck/ChainMan.adoc[`ChainMan`] 
| Owning wrapper over a `btck&lowbar;ChainstateManager`, the entry point for block processing&period;
| xref:btck/ChainParams.adoc[`ChainParams`] 
| Owning wrapper over `btck&lowbar;ChainParameters`, the consensus parameters for a network&period;
| xref:btck/ChainView.adoc[`ChainView`] 
| Non&hyphen;owning view over a `btck&lowbar;Chain`, a sequence of block tree entries by height&period;
| xref:btck/ChainstateManagerOptions.adoc[`ChainstateManagerOptions`] 
| Owning wrapper over `btck&lowbar;ChainstateManagerOptions`, configuring a ChainMan&period;
| xref:btck/Coin.adoc[`Coin`] 
| Owning wrapper over a `btck&lowbar;Coin`&period;
| xref:btck/CoinApi-06.adoc[`CoinApi`] 
| CRTP mixin adding coin accessors shared by the view and owning types&period;
| xref:btck/CoinView.adoc[`CoinView`] 
| Non&hyphen;owning view over a `btck&lowbar;Coin`, an unspent transaction output entry&period;
| xref:btck/ConsensusParamsView.adoc[`ConsensusParamsView`] 
| Non&hyphen;owning view over `btck&lowbar;ConsensusParams`, the consensus parameters of a chain&period;
| xref:btck/Context.adoc[`Context`] 
| Owning wrapper over a `btck&lowbar;Context`, the top&hyphen;level kernel execution context&period;
| xref:btck/ContextOptions.adoc[`ContextOptions`] 
| Owning wrapper over `btck&lowbar;ContextOptions`, configuring a Context before creation&period;
| xref:btck/Handle-046.adoc[`Handle`] 
| Owning RAII handle for a copyable C object of type `CType&period;`
| xref:btck/Iterator.adoc[`Iterator`] 
| Random&hyphen;access iterator that lazily materializes views of a collection by index&period;
| xref:btck/KernelNotifications.adoc[`KernelNotifications`] 
| Base class for receiving kernel notifications&semi; override the handlers you need&period;
| xref:btck/Logger.adoc[`Logger`] 
| Connects a user log sink of type `T` to the kernel logging system&period;
| xref:btck/OutPoint.adoc[`OutPoint`] 
| Owning wrapper over a `btck&lowbar;TransactionOutPoint`&period;
| xref:btck/OutPointApi-0b.adoc[`OutPointApi`] 
| CRTP mixin adding out&hyphen;point accessors shared by the view and owning types&period;
| xref:btck/OutPointView.adoc[`OutPointView`] 
| Non&hyphen;owning view over a `btck&lowbar;TransactionOutPoint`&period;
| xref:btck/PrecomputedTransactionData.adoc[`PrecomputedTransactionData`] 
| Owning wrapper over `btck&lowbar;PrecomputedTransactionData` used to cache signature hashes&period;
| xref:btck/Range-01.adoc[`Range`] 
| Read&hyphen;only random&hyphen;access view over an indexed C&hyphen;handle collection&period;
| xref:btck/Range-0b.adoc[`Range`] 
| Read&hyphen;only random&hyphen;access view over an indexed C&hyphen;handle collection&period;
| xref:btck/ScriptPubkey.adoc[`ScriptPubkey`] 
| Owning wrapper over a `btck&lowbar;ScriptPubkey` output script&period;
| xref:btck/ScriptPubkeyApi-02.adoc[`ScriptPubkeyApi`] 
| CRTP mixin adding script&hyphen;pubkey operations shared by the view and owning types&period;
| xref:btck/ScriptPubkeyView.adoc[`ScriptPubkeyView`] 
| Non&hyphen;owning view over a `btck&lowbar;ScriptPubkey`&period;
| xref:btck/Transaction.adoc[`Transaction`] 
| Owning wrapper over a `btck&lowbar;Transaction`&period;
| xref:btck/TransactionApi-08.adoc[`TransactionApi`] 
| CRTP mixin adding transaction accessors shared by the view and owning types&period;
| xref:btck/TransactionInput.adoc[`TransactionInput`] 
| Owning wrapper over a `btck&lowbar;TransactionInput`&period;
| xref:btck/TransactionInputApi-0b.adoc[`TransactionInputApi`] 
| CRTP mixin adding transaction&hyphen;input accessors shared by the view and owning types&period;
| xref:btck/TransactionInputView.adoc[`TransactionInputView`] 
| Non&hyphen;owning view over a `btck&lowbar;TransactionInput`&period;
| xref:btck/TransactionOutput.adoc[`TransactionOutput`] 
| Owning wrapper over a `btck&lowbar;TransactionOutput`&period;
| xref:btck/TransactionOutputApi-04.adoc[`TransactionOutputApi`] 
| CRTP mixin adding transaction&hyphen;output accessors shared by the view and owning types&period;
| xref:btck/TransactionOutputView.adoc[`TransactionOutputView`] 
| Non&hyphen;owning view over a `btck&lowbar;TransactionOutput`&period;
| xref:btck/TransactionSpentOutputs.adoc[`TransactionSpentOutputs`] 
| Owning wrapper over a `btck&lowbar;TransactionSpentOutputs`, the coins spent by one transaction&period;
| xref:btck/TransactionSpentOutputsApi-0d.adoc[`TransactionSpentOutputsApi`] 
| CRTP mixin adding accessors over the coins spent by one transaction&period;
| xref:btck/TransactionSpentOutputsView.adoc[`TransactionSpentOutputsView`] 
| Non&hyphen;owning view over a `btck&lowbar;TransactionSpentOutputs`&period;
| xref:btck/TransactionView.adoc[`TransactionView`] 
| Non&hyphen;owning view over a `btck&lowbar;Transaction`&period;
| xref:btck/TxValidationState.adoc[`TxValidationState`] 
| Owning wrapper over a `btck&lowbar;TxValidationState`, holding a transaction&apos;s validation outcome&period;
| xref:btck/Txid.adoc[`Txid`] 
| Owning wrapper over a `btck&lowbar;Txid` transaction identifier&period;
| xref:btck/TxidApi-020.adoc[`TxidApi`] 
| CRTP mixin adding transaction&hyphen;id operations shared by the view and owning types&period;
| xref:btck/TxidView.adoc[`TxidView`] 
| Non&hyphen;owning view over a `btck&lowbar;Txid`&period;
| xref:btck/UniqueHandle-0da.adoc[`UniqueHandle`] 
| Owning RAII handle for a non&hyphen;copyable C object, backed by std&colon;&colon;unique&lowbar;ptr&period;
| xref:btck/ValidationInterface.adoc[`ValidationInterface`] 
| Base class for receiving validation events&semi; override the handlers you need&period;
| xref:btck/View-041.adoc[`View`] 
| Non&hyphen;owning view over a const C handle of type `CType&period;`
| xref:btck/WitnessStack.adoc[`WitnessStack`] 
| Owning wrapper over a `btck&lowbar;WitnessStack`&period;
| xref:btck/WitnessStackApi-04.adoc[`WitnessStackApi`] 
| CRTP mixin adding witness&hyphen;stack accessors shared by the view and owning types&period;
| xref:btck/WitnessStackView.adoc[`WitnessStackView`] 
| Non&hyphen;owning view over a `btck&lowbar;WitnessStack`&period;
| xref:btck/is_bitmask_enum-04.adoc[`is&lowbar;bitmask&lowbar;enum`] 
| Trait marking an enum as a bitmask&semi; specialize to `std&colon;&colon;true&lowbar;type` to opt in&period;
|===


=== Enums

[cols="1,4"]
|===
| Name| Description
| xref:btck/BlockCheckFlags.adoc[`BlockCheckFlags`] 
| Selects which block checks to run, mirroring `btck&lowbar;BlockCheckFlags`&semi; combinable as a bitmask&period;
| xref:btck/BlockValidationResult.adoc[`BlockValidationResult`] 
| Reason a block failed validation, mirroring `btck&lowbar;BlockValidationResult`&period;
| xref:btck/ChainType.adoc[`ChainType`] 
| Bitcoin network the chain parameters describe, mirroring `btck&lowbar;ChainType`&period;
| xref:btck/LogCategory.adoc[`LogCategory`] 
| Logging category, mirroring `btck&lowbar;LogCategory`&period;
| xref:btck/LogLevel.adoc[`LogLevel`] 
| Logging verbosity level, mirroring `btck&lowbar;LogLevel`&period;
| xref:btck/ScriptVerificationFlags.adoc[`ScriptVerificationFlags`] 
| Script verification flags, mirroring `btck&lowbar;ScriptVerificationFlags`&semi; combinable as a bitmask&period;
| xref:btck/ScriptVerifyStatus.adoc[`ScriptVerifyStatus`] 
| Status of a script verification call, mirroring `btck&lowbar;ScriptVerifyStatus`&period;
| xref:btck/SynchronizationState.adoc[`SynchronizationState`] 
| Stage of block synchronization, mirroring `btck&lowbar;SynchronizationState`&period;
| xref:btck/TxValidationResult.adoc[`TxValidationResult`] 
| Reason a transaction failed validation, mirroring `btck&lowbar;TxValidationResult`&period;
| xref:btck/ValidationMode.adoc[`ValidationMode`] 
| Outcome of a validation operation, mirroring `btck&lowbar;ValidationMode`&period;
| xref:btck/Warning.adoc[`Warning`] 
| Kernel warning condition, mirroring `btck&lowbar;Warning`&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:btck/CheckTransaction.adoc[`CheckTransaction`] 
| Runs consensus&hyphen;level checks on a standalone transaction&period;
| xref:btck/check.adoc[`check`] 
| Throws if a freshly returned C handle is null, otherwise passes it through&period;
| xref:btck/logging_disable.adoc[`logging&lowbar;disable`] 
| Disables all kernel logging&period;
| xref:btck/logging_disable_category.adoc[`logging&lowbar;disable&lowbar;category`] 
| Disables logging for a category&period;
| xref:btck/logging_enable_category.adoc[`logging&lowbar;enable&lowbar;category`] 
| Enables logging for a category&period;
| xref:btck/logging_set_level_category.adoc[`logging&lowbar;set&lowbar;level&lowbar;category`] 
| Sets the log level for a single category&period;
| xref:btck/logging_set_options.adoc[`logging&lowbar;set&lowbar;options`] 
| Applies global logging options&period;
| xref:btck/operator_bitand.adoc[`operator&amp;`] 
| Bitwise AND of two bitmask&hyphen;enum values&period;
| xref:btck/operator_and_eq.adoc[`operator&amp;&equals;`] 
| Bitwise AND&hyphen;assign for a bitmask&hyphen;enum value&period;
| xref:btck/operator_plus.adoc[`operator&plus;`] 
| Returns an iterator advanced by `n` positions (offset on the left)&period;
| xref:btck/operator_xor.adoc[`operator&circ;`] 
| Bitwise XOR of two bitmask&hyphen;enum values&period;
| xref:btck/operator_xor_eq.adoc[`operator&circ;&equals;`] 
| Bitwise XOR&hyphen;assign for a bitmask&hyphen;enum value&period;
| xref:btck/operator_bitor.adoc[`operator&verbar;`] 
| Bitwise OR of two bitmask&hyphen;enum values&period;
| xref:btck/operator_or_eq.adoc[`operator&verbar;&equals;`] 
| Bitwise OR&hyphen;assign for a bitmask&hyphen;enum value&period;
| xref:btck/operator_bitnot.adoc[`operator&#126;`] 
| Bitwise complement of a bitmask&hyphen;enum value&period;
| xref:btck/set_mock_time.adoc[`set&lowbar;mock&lowbar;time`] 
| Overrides the kernel&apos;s notion of the current time, for testing&period;
| xref:btck/write_bytes.adoc[`write&lowbar;bytes`] 
| Serializes a C object into a byte vector using its `to&lowbar;bytes` callback&period;
|===


=== Concepts

[cols="1,4"]
|===
| Name| Description
| xref:btck/BitmaskEnum.adoc[`BitmaskEnum`] 
| Satisfied by enums opted into bitmask operators via is&lowbar;bitmask&lowbar;enum&period;
| xref:btck/IndexedContainer.adoc[`IndexedContainer`] 
| Satisfied when a container exposes a size accessor and an indexed element accessor&period;
| xref:btck/Log.adoc[`Log`] 
| Satisfied by a type exposing `LogMessage(std&colon;&colon;string&lowbar;view)` returning void&period;
|===


== xref:btcsignals.adoc[btcsignals] namespace

btcsignals is a simple mechanism for signaling events to multiple subscribers&period; It is api&hyphen;compatible with a minimal subset of boost&colon;&colon;signals2&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:btcsignals/any_of.adoc[`any&lowbar;of`] 
| A combiner, which checks if at least one callback returned true&period;
| xref:btcsignals/connection.adoc[`connection`] 
| State object representing the liveness of a registered callback&period; signal&colon;&colon;connect() returns an enabled connection which can be held and disabled in the future&period;
| xref:btcsignals/null_value.adoc[`null&lowbar;value`] 
| The default combiner, which only returns void&period;
| xref:btcsignals/scoped_connection.adoc[`scoped&lowbar;connection`] 
| RAII&hyphen;style connection management that disconnects on destruction&period;
| xref:btcsignals/signal.adoc[`signal`] 
| Functor for calling zero or more connected callbacks&period;
|===


== xref:cluster_linearize.adoc[cluster&lowbar;linearize] namespace

Algorithms and data structures for ordering (linearizing) clusters of dependent transactions&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:cluster_linearize/DepGraph.adoc[`DepGraph`] 
| Data structure that holds a transaction graph&apos;s preprocessed data (fee, size, ancestors, descendants)&period;
| xref:cluster_linearize/SFLDefaultCostModel.adoc[`SFLDefaultCostModel`] 
| A default cost model for SFL for SetType&equals;BitSet&lt;64&gt;, based on benchmarks&period;
| xref:cluster_linearize/SetInfo.adoc[`SetInfo`] 
| A set of transactions together with their aggregate feerate&period;
| xref:cluster_linearize/SpanningForestState.adoc[`SpanningForestState`] 
| Class to represent the internal state of the spanning&hyphen;forest linearization (SFL) algorithm&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:cluster_linearize/DepGraphIndex.adoc[`DepGraphIndex`] 
| Data type to represent transaction indices in DepGraphs and the clusters they represent&period;
| xref:cluster_linearize/IndexTxOrder.adoc[`IndexTxOrder`] 
| Simple default transaction ordering function for SpanningForestState&colon;&colon;GetLinearization() and Linearize(), which just sorts by DepGraphIndex&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:cluster_linearize/ChunkLinearization.adoc[`ChunkLinearization`] 
| Compute the feerates of the chunks of linearization&period; Identical to ChunkLinearizationInfo, but only returns the chunk feerates, not the corresponding transaction sets&period;
| xref:cluster_linearize/ChunkLinearizationInfo.adoc[`ChunkLinearizationInfo`] 
| Compute the chunks of linearization as SetInfos&period;
| xref:cluster_linearize/Linearize.adoc[`Linearize`] 
| Find or improve a linearization for a cluster&period;
| xref:cluster_linearize/PostLinearize.adoc[`PostLinearize`] 
| Improve a given linearization&period;
| xref:cluster_linearize/swap.adoc[`swap`] 
| Swap two SetInfo objects&period;
| xref:cluster_linearize/operator_eq-01.adoc[`operator&equals;&equals;`] 
| Equality operators
|===


=== Concepts

[cols="1,4"]
|===
| Name| Description
| xref:cluster_linearize/StrongComparator.adoc[`StrongComparator`] 
| Concept for function objects that return std&colon;&colon;strong&lowbar;ordering when invoked with two Args&period;
|===


== xref:common.adoc[common] namespace

Shared types used across the node, wallet, and GUI code&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:common/ConfigError.adoc[`ConfigError`] 
| Details about a configuration initialization failure&period;
| xref:common/PSBTFillOptions.adoc[`PSBTFillOptions`] 
| Instructions for how a PSBT should be signed or filled with information&period;
| xref:common/Settings.adoc[`Settings`] 
| Stored settings&period; This struct combines settings from the command line, a read&hyphen;only configuration file, and a read&hyphen;write runtime settings file&period;
| xref:common/SettingsSpan.adoc[`SettingsSpan`] 
| Accessor for list of settings that skips negated values when iterated over&period; The last boolean `false` value in the list and all earlier values are considered negated&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:common/SettingsAbortFn.adoc[`SettingsAbortFn`] 
| Callback function to let the user decide whether to abort loading if settings&period;json file exists and can&apos;t be parsed, or to ignore the error and overwrite the file&period;
| xref:common/SettingsValue.adoc[`SettingsValue`] 
| Settings value type (string&sol;integer&sol;boolean&sol;null variant)&period;
|===


=== Enums

[cols="1,4"]
|===
| Name| Description
| xref:common/ConfigStatus.adoc[`ConfigStatus`] 
| Outcome of reading configuration and initializing the data directory&period;
| xref:common/PSBTError.adoc[`PSBTError`] 
| Error conditions reported while processing a PSBT&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:common/AmountErrMsg.adoc[`AmountErrMsg`] 
| Build the error message for an invalid amount value&period;
| xref:common/AmountHighWarn.adoc[`AmountHighWarn`] 
| Build a warning that a configured amount is unusually high&period;
| xref:common/FeeModeFromString.adoc[`FeeModeFromString`] 
| Parse a fee estimate mode from its string name&period;
| xref:common/FeeModeInfo.adoc[`FeeModeInfo`] 
| Format a single fee mode and its description&period;
| xref:common/FeeModes.adoc[`FeeModes`] 
| List the available fee estimate mode names&period;
| xref:common/FeeModesDetail.adoc[`FeeModesDetail`] 
| Build the detailed help text describing all fee modes&period;
| xref:common/FindKey.adoc[`FindKey`] 
| Map lookup helper&period;
| xref:common/GetSetting.adoc[`GetSetting`] 
| Get settings value from combined sources&colon; forced settings, command line arguments, runtime read&hyphen;write settings, and the read&hyphen;only config file&period;
| xref:common/GetSettingsList.adoc[`GetSettingsList`] 
| Get combined setting value similar to GetSetting(), except if setting was specified multiple times, return a list of all the values specified&period;
| xref:common/InitConfig.adoc[`InitConfig`] 
| Read config files, and create datadir and settings&period;json if they don&apos;t exist&period;
| xref:common/InvalidEstimateModeErrorMessage.adoc[`InvalidEstimateModeErrorMessage`] 
| Return the error message shown when an invalid estimate mode is given&period;
| xref:common/InvalidPortErrMsg.adoc[`InvalidPortErrMsg`] 
| Build the error message for an invalid port value&period;
| xref:common/OnlyHasDefaultSectionSetting.adoc[`OnlyHasDefaultSectionSetting`] 
| Return true if a setting is set in the default config file section, and not overridden by a higher priority command&hyphen;line or network section value&period;
| xref:common/PSBTErrorString.adoc[`PSBTErrorString`] 
| Return a bilingual message describing a PSBT error&period;
| xref:common/ReadSettings.adoc[`ReadSettings`] 
| Read settings file&period;
| xref:common/ResolveErrMsg.adoc[`ResolveErrMsg`] 
| Build the error message for a failed address resolution&period;
| xref:common/StringForFeeReason.adoc[`StringForFeeReason`] 
| Return a human&hyphen;readable description of a fee reason&period;
| xref:common/TransactionErrorString.adoc[`TransactionErrorString`] 
| Return a bilingual message describing a transaction error&period;
| xref:common/WriteSettings.adoc[`WriteSettings`] 
| Write settings file&period;
|===


== xref:dbwrapper_private.adoc[dbwrapper&lowbar;private] namespace

These should be considered an implementation detail of the specific database&period;

=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:dbwrapper_private/GetObfuscation.adoc[`GetObfuscation`] 
| Work around circular dependency, as well as for testing in dbwrapper&lowbar;tests&period; Database obfuscation should be considered an implementation detail of the specific database&period;
|===


== xref:detail.adoc[detail] namespace

Internal helpers for parsing blobs from hex strings&period;

=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:detail/FromHex.adoc[`FromHex`] 
| Writes the hex string (in reverse byte order) into a new uintN&lowbar;t object and only returns a value iff all of the checks pass&colon; &hyphen; Input length is uintN&lowbar;t&colon;&colon;size()&ast;2 &hyphen; All characters are hex
| xref:detail/FromUserHex.adoc[`FromUserHex`] 
| Like FromHex(std&colon;&colon;string&lowbar;view str), but allows an &quot;0x&quot; prefix and pads the input with leading zeroes if it is shorter than the expected length of uintN&lowbar;t&colon;&colon;size()&ast;2&period;
|===


== xref:fs.adoc[fs] namespace

Filesystem operations and types

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:fs/path.adoc[`path`] 
| Path class wrapper to block calls to the fs&colon;&colon;path(std&colon;&colon;string) implicit constructor and the fs&colon;&colon;path&colon;&colon;string() method, which have unsafe and unpredictable behavior on Windows (see implementation note in PathToString for details)
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:fs/operator_plus.adoc[`operator&plus;`]  [.small]#[deleted]#
| Deleted catch&hyphen;all overload that forbids unsafe path concatenation via operator&plus;&period;
| xref:fs/operator_slash.adoc[`operator&sol;`]  [.small]#[deleted]#
| Deleted catch&hyphen;all overload that forbids unsafe path append operations via operator&sol;&period;
|===


== xref:fsbridge.adoc[fsbridge] namespace

Bridge operations to C stdio

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:fsbridge/FileLock.adoc[`FileLock`] 
| Advisory lock on a file, released when the object is destroyed&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:fsbridge/FopenFn.adoc[`FopenFn`] 
| Callable type matching fopen, so a custom file opener can be injected&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:fsbridge/AbsPathJoin.adoc[`AbsPathJoin`] 
| Helper function for joining two paths
| xref:fsbridge/fopen.adoc[`fopen`] 
| Open a file, handling path encoding correctly across platforms&period;
|===


== xref:i2p.adoc[i2p] namespace

Support for connecting to and accepting connections over the I2P network&period;

=== Namespaces

[cols="1,4"]
|===
| Name| Description
| xref:i2p/sam.adoc[`sam`] 
| Types and helpers for talking to an I2P router over the SAM (v3) protocol&period;
|===


=== Types

[cols="1,4"]
|===
| Name| Description
| xref:i2p/Connection.adoc[`Connection`] 
| An established connection with another peer&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:i2p/Binary.adoc[`Binary`] 
| Binary data&period;
|===


== xref:i2p/sam.adoc[i2p::sam] namespace

Types and helpers for talking to an I2P router over the SAM (v3) protocol&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:i2p/sam/Session.adoc[`Session`] 
| I2P SAM session&period;
|===


=== Variables

[cols="1,4"]
|===
| Name| Description
| xref:i2p/sam/MAX_MSG_SIZE.adoc[`MAX&lowbar;MSG&lowbar;SIZE`] 
| The maximum size of an incoming message from the I2P SAM proxy (in bytes)&period; Used to avoid a runaway proxy from sending us an &quot;unlimited&quot; amount of data without a terminator&period; The longest known message is &#126;1400 bytes, so this is high enough not to be triggered during normal operation, yet low enough to avoid a malicious proxy from filling our memory&period;
|===


== xref:index_util.adoc[index&lowbar;util] namespace

Shared database key types for blockfilterindex and coinstatsindex&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:index_util/DBHashKey.adoc[`DBHashKey`] 
| Database key for an index entry looked up by block hash&period;
| xref:index_util/DBHeightKey.adoc[`DBHeightKey`] 
| Database key for an index entry looked up by block height&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:index_util/CopyHeightIndexToHashIndex.adoc[`CopyHeightIndexToHashIndex`] 
| Copy an index entry from the height index to the hash index&period;
| xref:index_util/LookUpOne.adoc[`LookUpOne`] 
| Look up a single index entry for a block, trying the height index then the hash index&period;
|===


=== Variables

[cols="1,4"]
|===
| Name| Description
| xref:index_util/DB_BLOCK_HASH.adoc[`DB&lowbar;BLOCK&lowbar;HASH`] 
| Key prefix byte identifying an entry in the hash index&period;
| xref:index_util/DB_BLOCK_HEIGHT.adoc[`DB&lowbar;BLOCK&lowbar;HEIGHT`] 
| Key prefix byte identifying an entry in the height index&period;
|===


== xref:init.adoc[init] namespace

Initialization helpers shared by the node, wallet, and other executables&period;

=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:init/AddLoggingArgs.adoc[`AddLoggingArgs`] 
| Registers the logging&hyphen;related command&hyphen;line options with the argument manager&period;
| xref:init/LogPackageVersion.adoc[`LogPackageVersion`] 
| Writes the package name and version banner to the log&period;
| xref:init/SetLoggingCategories.adoc[`SetLoggingCategories`] 
| Enables or disables the debug logging categories selected by the arguments&period;
| xref:init/SetLoggingLevel.adoc[`SetLoggingLevel`] 
| Sets the global logging severity level selected by the arguments&period;
| xref:init/SetLoggingOptions.adoc[`SetLoggingOptions`] 
| Applies the general logging options (log file, timestamps, thread names, and similar flags) parsed from the arguments to the global logger&period;
| xref:init/StartLogging.adoc[`StartLogging`] 
| Opens the debug log file and begins writing buffered log messages&period;
|===


== xref:interfaces.adoc[interfaces] namespace

Interfaces between the node and the rest of the application&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:interfaces/BlockAndHeaderTipInfo.adoc[`BlockAndHeaderTipInfo`] 
| Summary of the current block and header tip, returned from initialization&period;
| xref:interfaces/BlockInfo.adoc[`BlockInfo`] 
| Block data sent with blockConnected, blockDisconnected notifications&period;
| xref:interfaces/BlockRef.adoc[`BlockRef`] 
| A lightweight reference to a block by hash and height&period;
| xref:interfaces/Chain.adoc[`Chain`] 
| Interface giving clients read and write access to the node&apos;s chain state&period;
| xref:interfaces/ChainClient.adoc[`ChainClient`] 
| Interface for a client (such as a wallet) attached to the node&period;
| xref:interfaces/Init.adoc[`Init`] 
| Interface for process initialization and inter&hyphen;process setup&period;
| xref:interfaces/Mining.adoc[`Mining`] 
| Interface exposing block&hyphen;template creation to mining clients&period;
| xref:interfaces/Wallet.adoc[`Wallet`] 
| Interface to a single wallet exposed to the node&period;
| xref:interfaces/WalletLoader.adoc[`WalletLoader`] 
| Interface for loading and creating wallets&period;
|===


== xref:kernel.adoc[kernel] namespace

Kernel library components for validating blocks and maintaining chain state&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:kernel/BlockManagerOpts.adoc[`BlockManagerOpts`] 
| An options struct for `BlockManager`, more ergonomically referred to as `BlockManager&colon;&colon;Options` due to the using&hyphen;declaration in `BlockManager`&period;
| xref:kernel/BlockTreeDB.adoc[`BlockTreeDB`] 
| Access to the block database (blocks&sol;index&sol;)
| xref:kernel/CBlockFileInfo.adoc[`CBlockFileInfo`] 
| On&hyphen;disk statistics describing the contents of one block file&period;
| xref:kernel/CCoinsStats.adoc[`CCoinsStats`] 
| Aggregate statistics computed over the UTXO set&period;
| xref:kernel/CacheSizes.adoc[`CacheSizes`] 
| Byte budgets for the validation caches, derived from a single total&period;
| xref:kernel/ChainstateManagerOpts.adoc[`ChainstateManagerOpts`] 
| An options struct for `ChainstateManager`, more ergonomically referred to as `ChainstateManager&colon;&colon;Options` due to the using&hyphen;declaration in `ChainstateManager`&period;
| xref:kernel/ChainstateRole.adoc[`ChainstateRole`] 
| Identifies which chainstate (active or background) a notification refers to&period;
| xref:kernel/Context.adoc[`Context`] 
| Process&hyphen;wide context owning the libbitcoin&lowbar;kernel global state&period;
| xref:kernel/Interrupted.adoc[`Interrupted`] 
| Result type for use with std&colon;&colon;variant to indicate that an operation should be interrupted&period;
| xref:kernel/MemPoolLimits.adoc[`MemPoolLimits`] 
| Options struct containing limit options for a CTxMemPool&period; Default constructor populates the struct with sane default values which can be modified&period;
| xref:kernel/MemPoolOptions.adoc[`MemPoolOptions`] 
| Tunable options controlling memory&hyphen;pool acceptance and limits&period;
| xref:kernel/Notifications.adoc[`Notifications`] 
| A base class defining functions for notifying about certain kernel events&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:kernel/InterruptResult.adoc[`InterruptResult`] 
| Simple result type for functions that need to propagate an interrupt status and don&apos;t have other return values&period;
|===


=== Enums

[cols="1,4"]
|===
| Name| Description
| xref:kernel/CoinStatsHashType.adoc[`CoinStatsHashType`] 
| Selects the hashing scheme used to summarize the UTXO set&period;
| xref:kernel/Warning.adoc[`Warning`] 
| Categories of node warning raised by the validation kernel&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:kernel/ApplyCoinHash.adoc[`ApplyCoinHash`] 
| Folds a coin into the running MuHash of the UTXO set&period;
| xref:kernel/ComputeUTXOStats.adoc[`ComputeUTXOStats`] 
| Computes aggregate statistics over the UTXO set&period;
| xref:kernel/GetBogoSize.adoc[`GetBogoSize`] 
| Computes the serialization&hyphen;agnostic size measure of an output script&period;
| xref:kernel/IsInterrupted.adoc[`IsInterrupted`] 
| Tests whether a variant result holds the Interrupted alternative&period;
| xref:kernel/MakeBlockInfo.adoc[`MakeBlockInfo`] 
| Builds block metadata from a block index entry&period;
| xref:kernel/RemoveCoinHash.adoc[`RemoveCoinHash`] 
| Removes a coin from the running MuHash of the UTXO set&period;
| xref:kernel/SanityChecks.adoc[`SanityChecks`] 
| Ensure a usable environment with all necessary library support&period;
| xref:kernel/operator_lshift.adoc[`operator&lt;&lt;`] 
| Writes a human&hyphen;readable form of a chainstate role to a stream&period;
|===


=== Variables

[cols="1,4"]
|===
| Name| Description
| xref:kernel/DEFAULT_XOR_BLOCKSDIR.adoc[`DEFAULT&lowbar;XOR&lowbar;BLOCKSDIR`] 
| Default for whether block files are obfuscated (XOR&hyphen;ed) on disk&period;
|===


== xref:leveldb.adoc[leveldb] namespace

The LevelDB library namespace, forward&hyphen;declared to avoid a public dependency&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:leveldb/Env.adoc[`Env`] 
| LevelDB storage environment abstraction&period;
|===


== xref:memusage.adoc[memusage] namespace

Helpers for estimating the dynamic memory usage of common data structures&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:memusage/list_node.adoc[`list&lowbar;node`] 
| Layout model of a doubly linked list node, used to size std&colon;&colon;list&period;
| xref:memusage/stl_shared_counter.adoc[`stl&lowbar;shared&lowbar;counter`] 
| Layout model of the control block shared by shared&lowbar;ptr&sol;weak&lowbar;ptr, used for sizing&period;
| xref:memusage/stl_tree_node.adoc[`stl&lowbar;tree&lowbar;node`] 
| Layout model of a libstdc&plus;&plus; red&hyphen;black tree node, used to size STL containers&period;
| xref:memusage/unordered_node.adoc[`unordered&lowbar;node`] 
| Layout model of an unordered container node, used to size hashed containers&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:memusage/DynamicUsage-06c.adoc[`DynamicUsage`] 
| `DynamicUsage` overloads
| xref:memusage/IncrementalDynamicUsage-0f.adoc[`IncrementalDynamicUsage`] 
| `IncrementalDynamicUsage` overloads
|===


== xref:miniscript.adoc[miniscript] namespace

Miniscript&colon; a structured representation of Bitcoin Scripts&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:miniscript/Node.adoc[`Node`] 
| A node in a miniscript expression&period;
| xref:miniscript/Type.adoc[`Type`] 
| This type encapsulates the miniscript type system properties&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:miniscript/Opcode.adoc[`Opcode`] 
| A single script opcode together with any immediate data it pushes&period;
|===


=== Enums

[cols="1,4"]
|===
| Name| Description
| xref:miniscript/Availability.adoc[`Availability`] 
| Three&hyphen;valued result for whether a satisfaction or dissatisfaction is available&period;
| xref:miniscript/Fragment.adoc[`Fragment`] 
| The different node types in miniscript&period;
| xref:miniscript/MiniscriptContext.adoc[`MiniscriptContext`] 
| The script context a Miniscript is used under&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:miniscript/Compare.adoc[`Compare`] 
| Compare two miniscript subtrees, using a non&hyphen;recursive algorithm&period;
| xref:miniscript/ForEachNode.adoc[`ForEachNode`] 
| Unordered traversal of a miniscript node tree&period;
| xref:miniscript/FromScript.adoc[`FromScript`] 
| Decodes a Miniscript from a Bitcoin Script&period;
| xref:miniscript/FromString.adoc[`FromString`] 
| Parses a Miniscript from its textual (policy&hyphen;language) representation&period;
| xref:miniscript/IsTapscript.adoc[`IsTapscript`] 
| Whether the context Tapscript, ensuring the only other possibility is P2WSH&period;
| xref:miniscript/operator_mst.adoc[`operator&quot;&quot;&lowbar;mst`] 
| The only way to publicly construct a Type is using this literal operator&period;
|===


== xref:node.adoc[node] namespace

Full&hyphen;node components that run the block, chainstate, and mempool machinery&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:node/BlockAssembler.adoc[`BlockAssembler`] 
| Generate a new block, without valid proof&hyphen;of&hyphen;work
| xref:node/BlockCheckOptions.adoc[`BlockCheckOptions`] 
| Options controlling which checks a block&hyphen;template validity check performs&period;
| xref:node/BlockCreateOptions.adoc[`BlockCreateOptions`] 
| Block template creation options&period; These override node defaults, but can&apos;t exceed node limits (e&period;g&period; block&lowbar;reserved&lowbar;weight can&apos;t exceed max block weight)&period;
| xref:node/BlockManager.adoc[`BlockManager`] 
| Maintains a tree of blocks (stored in `m&lowbar;block&lowbar;index`) which is consulted to determine where the most&hyphen;work tip is&period;
| xref:node/BlockWaitOptions.adoc[`BlockWaitOptions`] 
| Options controlling how long a block&hyphen;template wait call blocks and when it returns&period;
| xref:node/BlockfileCursor.adoc[`BlockfileCursor`] 
| Tracks the current block file and how far its undo data has been written&period;
| xref:node/CBlockIndexHeightOnlyComparator.adoc[`CBlockIndexHeightOnlyComparator`] 
| Orders block indices purely by height, without tie&hyphen;breaking&period;
| xref:node/CBlockIndexWorkComparator.adoc[`CBlockIndexWorkComparator`] 
| Orders block indices by most accumulated work, for choosing the best tip&period;
| xref:node/CBlockTemplate.adoc[`CBlockTemplate`] 
| A candidate block together with the per&hyphen;transaction data needed to finalize it&period;
| xref:node/CacheSizes.adoc[`CacheSizes`] 
| Cache sizes split between the optional indexes and the kernel (validation) caches&period;
| xref:node/ChainstateLoadOptions.adoc[`ChainstateLoadOptions`] 
| Options controlling how the chainstate is loaded and verified&period;
| xref:node/CoinbaseTx.adoc[`CoinbaseTx`] 
| Template containing all coinbase transaction fields that are set by our miner code&period; Clients are expected to add their own outputs and typically also expand the scriptSig&period;
| xref:node/ImportMempoolOptions.adoc[`ImportMempoolOptions`] 
| Options controlling how a persisted mempool file is imported&period;
| xref:node/IndexCacheSizes.adoc[`IndexCacheSizes`] 
| Cache sizes allotted to each optional block&hyphen;chain index&period;
| xref:node/IteratorComparator.adoc[`IteratorComparator`] 
| Comparator ordering map iterators by their key, for use in ordered sets of iterators&period;
| xref:node/KernelNotifications.adoc[`KernelNotifications`] 
| Kernel notification handler that tracks chain state for code above the validation layer&period;
| xref:node/KernelState.adoc[`KernelState`] 
| State tracked by the KernelNotifications interface meant to be used by mining code, index code, RPCs, and other code sitting above the validation layer&period;
| xref:node/MiniMiner.adoc[`MiniMiner`] 
| A minimal version of BlockAssembler, using the same ancestor set scoring algorithm&period; Allows us to run this algorithm on a limited set of transactions (e&period;g&period; subset of mempool or transactions that are not yet in mempool) instead of the entire mempool, ignoring consensus rules&period; Callers may use this to&colon; &hyphen; Calculate the &quot;bump fee&quot; needed to spend an unconfirmed UTXO at a given feerate &hyphen; &quot;Linearize&quot; a list of transactions to see the order in which they would be selected for inclusion in a block
| xref:node/MiniMinerMempoolEntry.adoc[`MiniMinerMempoolEntry`] 
| Container for tracking updates to ancestor feerate as we include ancestors in the &quot;block&quot;&period;
| xref:node/NodeContext.adoc[`NodeContext`] 
| NodeContext struct containing references to chain state and connection state&period;
| xref:node/PSBTAnalysis.adoc[`PSBTAnalysis`] 
| Holds the results of AnalyzePSBT (miscellaneous information about a PSBT)
| xref:node/PSBTInputAnalysis.adoc[`PSBTInputAnalysis`] 
| Holds an analysis of one input from a PSBT
| xref:node/PackageToValidate.adoc[`PackageToValidate`] 
| A parent&sol;child transaction package queued for joint mempool validation&period;
| xref:node/PruneLockInfo.adoc[`PruneLockInfo`] 
| Records the oldest block an external component still needs, to guard it from pruning&period;
| xref:node/RejectedTxTodo.adoc[`RejectedTxTodo`] 
| Follow&hyphen;up actions returned after a transaction is rejected from the mempool&period;
| xref:node/SnapshotMetadata.adoc[`SnapshotMetadata`] 
| Metadata describing a serialized UTXO snapshot file&period;
| xref:node/TxDownloadConnectionInfo.adoc[`TxDownloadConnectionInfo`] 
| Per&hyphen;peer connection attributes that affect transaction download scheduling&period;
| xref:node/TxDownloadManager.adoc[`TxDownloadManager`] 
| Class responsible for deciding what transactions to request and, once downloaded, whether and how to validate them&period; It is also responsible for deciding what transaction packages to validate and how to resolve orphan transactions&period; Its data structures include TxRequestTracker for scheduling requests, rolling bloom filters for remembering transactions that have already been &lcub;accepted, rejected, confirmed&rcub;, an orphanage, and a registry of each peer&apos;s transaction relay&hyphen;related information&period;
| xref:node/TxDownloadManagerImpl.adoc[`TxDownloadManagerImpl`] 
| Private implementation of TxDownloadManager&period;
| xref:node/TxDownloadOptions.adoc[`TxDownloadOptions`] 
| Options used to construct a TxDownloadManager&period;
| xref:node/TxOrphanage.adoc[`TxOrphanage`] 
| A class to track orphan transactions (failed on TX&lowbar;MISSING&lowbar;INPUTS) Since we cannot distinguish orphans from bad transactions with non&hyphen;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)&period; We also try to prevent adversaries from churning this data structure&colon; once global limits are reached, we continuously evict the oldest announcement (sorting non&hyphen;reconsiderable orphans before reconsiderable ones) from the most resource&hyphen;intensive peer until we are back within limits&period; &hyphen; Peers can exceed their individual limits (e&period;g&period; because they are very useful transaction relay peers) as long as the global limits are not exceeded&period; &hyphen; As long as the orphan has 1 announcer, it remains in the orphanage&period; &hyphen; No peer can trigger the eviction of another peer&apos;s orphans&period; &hyphen; Peers&apos; orphans are effectively protected from eviction as long as they don&apos;t exceed their limits&period; Not thread&hyphen;safe&period; Requires external synchronization&period;
| xref:node/Warnings.adoc[`Warnings`] 
| Manages warning messages within a node&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:node/BlockMap.adoc[`BlockMap`] 
| Map from block hash to its in&hyphen;memory block index entry&period;
| xref:node/ChainstateLoadResult.adoc[`ChainstateLoadResult`] 
| Chainstate load status code and optional error string&period;
|===


=== Enums

[cols="1,4"]
|===
| Name| Description
| xref:node/BlockfileType.adoc[`BlockfileType`] 
| Which kind of chainstate a block file belongs to, used to segment storage&period;
| xref:node/ChainstateLoadStatus.adoc[`ChainstateLoadStatus`] 
| Chainstate load status&period; Simple applications can just check for the success case, and treat other cases as errors&period; 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&period;
| xref:node/ReadRawError.adoc[`ReadRawError`] 
| Reason a raw block read from disk failed&period;
| xref:node/TransactionError.adoc[`TransactionError`] 
| Result of attempting to submit or broadcast a transaction&period;
| xref:node/TxBroadcast.adoc[`TxBroadcast`] 
| How to broadcast a local transaction&period; Used to influence `BroadcastTransaction()` and its callers&period;
| xref:node/Warning.adoc[`Warning`] 
| Categories of node&hyphen;level warning shown to the user and over RPC&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:node/AbortNode.adoc[`AbortNode`] 
| Abort the node in response to a fatal, unrecoverable internal error&period;
| xref:node/AddMerkleRootAndCoinbase.adoc[`AddMerkleRootAndCoinbase`] 
| Insert the coinbase transaction and compute the merkle root of a block&period;
| xref:node/AnalyzePSBT.adoc[`AnalyzePSBT`] 
| Provides helpful miscellaneous information about where a PSBT is in the signing workflow&period;
| xref:node/ApplyArgsManOptions-0c.adoc[`ApplyArgsManOptions`] 
| `ApplyArgsManOptions` overloads
| xref:node/BroadcastTransaction.adoc[`BroadcastTransaction`] 
| Submit a transaction to the mempool and (optionally) relay it to all P2P peers&period;
| xref:node/CalculateCacheSizes.adoc[`CalculateCacheSizes`] 
| Split the configured total database cache across the indexes and kernel caches&period;
| xref:node/CheckMiningOptions.adoc[`CheckMiningOptions`] 
| Check option values for validity&period; Returns an error for invalid values&period;
| xref:node/CooldownIfHeadersAhead.adoc[`CooldownIfHeadersAhead`] 
| 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&period; If the tip is sufficiently far behind, allow up to 20 seconds for the next tip update&period;
| xref:node/DumpMempool.adoc[`DumpMempool`] 
| Dump the mempool to a file&period;
| xref:node/FindAssumeutxoChainstateDir.adoc[`FindAssumeutxoChainstateDir`] 
| Return a path to the snapshot&hyphen;based chainstate dir, if one exists&period;
| xref:node/FindCoins.adoc[`FindCoins`] 
| Look up unspent output information&period; Returns coins in the mempool and in the current chain UTXO set&period; Iterates through all the keys in the map and populates the values&period;
| xref:node/FlattenMiningOptions.adoc[`FlattenMiningOptions`] 
| Replace null optional values with their hardcoded defaults&period;
| xref:node/GetDefaultDBCache.adoc[`GetDefaultDBCache`] 
| Return the default total database cache size in bytes&period;
| xref:node/GetMinimumTime.adoc[`GetMinimumTime`] 
| Get the minimum time a miner should use in the next block&period; This always accounts for the BIP94 timewarp rule, so does not necessarily reflect the consensus limit&period;
| xref:node/GetTip.adoc[`GetTip`] 
| Return the hash and height of the active chain tip&period;
| xref:node/GetTransaction.adoc[`GetTransaction`] 
| Return transaction with a given hash&period; If mempool is provided and block&lowbar;index is not provided, check it first for the tx&period; If &hyphen;txindex is available, check it next for the tx&period; Finally, if block&lowbar;index is provided, check for tx by reading entire block from disk&period;
| xref:node/GetWarningsForRpc.adoc[`GetWarningsForRpc`] 
| RPC helper function that wraps warnings&period;GetMessages()&period;
| xref:node/ImportBlocks.adoc[`ImportBlocks`] 
| Load blocks from the given files and activate the best chain, even if none are imported&period;
| xref:node/InterruptWait.adoc[`InterruptWait`] 
| Interrupt a blocking wait call&period;
| xref:node/LoadChainstate.adoc[`LoadChainstate`] 
| This sequence can have 4 types of outcomes&colon;
| xref:node/LoadMempool.adoc[`LoadMempool`] 
| Import the file and attempt to add its contents to the mempool&period;
| xref:node/LogOversizedDbCache.adoc[`LogOversizedDbCache`] 
| Log a warning when the configured database cache is larger than available RAM allows&period;
| xref:node/MakeMinisketch32.adoc[`MakeMinisketch32`] 
| Wrapper around Minisketch&colon;&colon;Minisketch(32, implementation, capacity)&period;
| xref:node/MakeMinisketch32FP.adoc[`MakeMinisketch32FP`] 
| Wrapper around Minisketch&colon;&colon;CreateFP&period;
| xref:node/MakeTxOrphanage-07.adoc[`MakeTxOrphanage`] 
| `MakeTxOrphanage` overloads
| xref:node/MempoolPath.adoc[`MempoolPath`] 
| Return the on&hyphen;disk path used to load and save the persisted mempool&period;
| xref:node/MergeMiningOptions.adoc[`MergeMiningOptions`] 
| Merge two BlockCreateOptions structs, replacing null values in `x` with non&hyphen;null values from `y&period;`
| xref:node/ReadCoinsViewArgs.adoc[`ReadCoinsViewArgs`] 
| Read coins&hyphen;view database options from the argument manager&period;
| xref:node/ReadDatabaseArgs.adoc[`ReadDatabaseArgs`] 
| Read database options from the argument manager&period;
| xref:node/ReadMiningArgs.adoc[`ReadMiningArgs`] 
| Read the mining options set in `args&period;` Returns an error if one was encountered&period;
| xref:node/ReadNotificationArgs.adoc[`ReadNotificationArgs`] 
| Apply notification&hyphen;related options from the argument manager&period;
| xref:node/ReadSnapshotBaseBlockhash.adoc[`ReadSnapshotBaseBlockhash`] 
| Read the blockhash of the snapshot base block that was used to construct the chainstate&period;
| xref:node/RegenerateCommitments.adoc[`RegenerateCommitments`] 
| Update an old GenerateCoinbaseCommitment from CreateNewBlock after the block txs have changed
| xref:node/ShouldPersistMempool.adoc[`ShouldPersistMempool`] 
| Determine whether the mempool should be persisted across restarts&period;
| xref:node/ShouldWarnOversizedDbCache.adoc[`ShouldWarnOversizedDbCache`] 
| Report whether the configured database cache is large enough to warrant a warning&period;
| xref:node/SubmitBlock.adoc[`SubmitBlock`] 
| Submit a block and capture the validation state via the BlockChecked callback&period; Returns whether the block was accepted as a new valid block&period;
| xref:node/UpdateTime.adoc[`UpdateTime`] 
| Update a block header&apos;s time field and return the new time&period;
| xref:node/VerifyLoadedChainstate.adoc[`VerifyLoadedChainstate`] 
| Verify a chainstate that has already been loaded&period;
| xref:node/WaitAndCreateNewBlock.adoc[`WaitAndCreateNewBlock`] 
| Return a new block template when fees rise to a certain threshold or after a new tip&semi; return nullopt if timeout is reached&period;
| xref:node/WaitTipChanged.adoc[`WaitTipChanged`] 
| Waits for the connected tip to change until timeout has elapsed&period; During node initialization, this will wait until the tip is connected (regardless of `timeout`)&period; Returns the current tip, or nullopt if the node is shutting down or interrupt() is called&period;
| xref:node/WriteSnapshotBaseBlockhash.adoc[`WriteSnapshotBaseBlockhash`] 
| Write out the blockhash of the snapshot base block that was used to construct this chainstate&period; This value is read in during subsequent initializations and used to reconstruct snapshot&hyphen;based chainstates&period;
| xref:node/operator_lshift-05.adoc[`operator&lt;&lt;`] 
| Stream insertion operators
|===


=== Variables

[cols="1,4"]
|===
| Name| Description
| xref:node/BLOCKFILE_CHUNK_SIZE.adoc[`BLOCKFILE&lowbar;CHUNK&lowbar;SIZE`] 
| The pre&hyphen;allocation chunk size for blk?????&period;dat files (since 0&period;8)
| xref:node/DEFAULT_MAX_BURN_AMOUNT.adoc[`DEFAULT&lowbar;MAX&lowbar;BURN&lowbar;AMOUNT`] 
| Maximum burn value for sendrawtransaction, submitpackage, and testmempoolaccept RPC calls&period; By default, a transaction with a burn value higher than this will be rejected by these RPCs and the GUI&period; This can be overridden with the maxburnamount argument&period;
| xref:node/DEFAULT_MAX_ORPHANAGE_LATENCY_SCORE.adoc[`DEFAULT&lowbar;MAX&lowbar;ORPHANAGE&lowbar;LATENCY&lowbar;SCORE`] 
| Default value for TxOrphanage&colon;&colon;m&lowbar;max&lowbar;global&lowbar;latency&lowbar;score&period; Helps limit the maximum latency for operations like EraseForBlock and LimitOrphans&period;
| xref:node/DEFAULT_MAX_RAW_TX_FEE_RATE.adoc[`DEFAULT&lowbar;MAX&lowbar;RAW&lowbar;TX&lowbar;FEE&lowbar;RATE`] 
| Maximum fee rate for sendrawtransaction and testmempoolaccept RPC calls&period; Also used by the GUI when broadcasting a completed PSBT&period; By default, a transaction with a fee rate higher than this will be rejected by these RPCs and the GUI&period; This can be overridden with the maxfeerate argument&period;
| xref:node/DEFAULT_PERSIST_MEMPOOL.adoc[`DEFAULT&lowbar;PERSIST&lowbar;MEMPOOL`] 
| Default for &hyphen;persistmempool, indicating whether the node should attempt to automatically load the mempool on start and save to disk on shutdown
| xref:node/DEFAULT_PRINT_MODIFIED_FEE.adoc[`DEFAULT&lowbar;PRINT&lowbar;MODIFIED&lowbar;FEE`] 
| Default for whether block templates print each transaction&apos;s modified fee&period;
| xref:node/DEFAULT_RESERVED_ORPHAN_WEIGHT_PER_PEER.adoc[`DEFAULT&lowbar;RESERVED&lowbar;ORPHAN&lowbar;WEIGHT&lowbar;PER&lowbar;PEER`] 
| Default value for TxOrphanage&colon;&colon;m&lowbar;reserved&lowbar;usage&lowbar;per&lowbar;peer&period; Helps limit the total amount of memory used by the orphanage&period;
| xref:node/DEFAULT_STOPATHEIGHT.adoc[`DEFAULT&lowbar;STOPATHEIGHT`] 
| Default for `&hyphen;stopatheight`&semi; 0 means never stop at a given height&period;
| xref:node/GETDATA_TX_INTERVAL.adoc[`GETDATA&lowbar;TX&lowbar;INTERVAL`] 
| How long to wait before downloading a transaction from an additional peer
| xref:node/MAX_BLOCKFILE_SIZE.adoc[`MAX&lowbar;BLOCKFILE&lowbar;SIZE`] 
| The maximum size of a blk?????&period;dat file (since 0&period;8)
| xref:node/MAX_PEER_TX_ANNOUNCEMENTS.adoc[`MAX&lowbar;PEER&lowbar;TX&lowbar;ANNOUNCEMENTS`] 
| Maximum number of transactions to consider for requesting, per peer&period; It provides a reasonable DoS limit to per&hyphen;peer memory usage spent on announcements, while covering peers continuously sending INVs at the maximum rate (by our own policy, see DEFAULT&lowbar;TX&lowbar;SEND&lowbar;RATE) for several minutes, while not receiving the actual transaction (from any peer) in response to requests for them&period;
| xref:node/MAX_PEER_TX_REQUEST_IN_FLIGHT.adoc[`MAX&lowbar;PEER&lowbar;TX&lowbar;REQUEST&lowbar;IN&lowbar;FLIGHT`] 
| Maximum number of in&hyphen;flight transaction requests from a peer&period; It is not a hard limit, but the threshold at which point the OVERLOADED&lowbar;PEER&lowbar;TX&lowbar;DELAY kicks in&period;
| xref:node/NONPREF_PEER_TX_DELAY.adoc[`NONPREF&lowbar;PEER&lowbar;TX&lowbar;DELAY`] 
| How long to delay requesting transactions from non&hyphen;preferred peers
| xref:node/OVERLOADED_PEER_TX_DELAY.adoc[`OVERLOADED&lowbar;PEER&lowbar;TX&lowbar;DELAY`] 
| How long to delay requesting transactions from overloaded peers (see MAX&lowbar;PEER&lowbar;TX&lowbar;REQUEST&lowbar;IN&lowbar;FLIGHT)&period;
| xref:node/SNAPSHOT_BLOCKHASH_FILENAME.adoc[`SNAPSHOT&lowbar;BLOCKHASH&lowbar;FILENAME`] 
| The file in the snapshot chainstate dir which stores the base blockhash&period; This is needed to reconstruct snapshot chainstates on init&period;
| xref:node/SNAPSHOT_CHAINSTATE_SUFFIX.adoc[`SNAPSHOT&lowbar;CHAINSTATE&lowbar;SUFFIX`] 
| Suffix appended to the chainstate (leveldb) dir when created based upon a snapshot&period;
| xref:node/STORAGE_HEADER_BYTES.adoc[`STORAGE&lowbar;HEADER&lowbar;BYTES`] 
| Size of header written by WriteBlock before a serialized CBlock (8 bytes)
| xref:node/TXID_RELAY_DELAY.adoc[`TXID&lowbar;RELAY&lowbar;DELAY`] 
| How long to delay requesting transactions via txids, if we have wtxid&hyphen;relaying peers
| xref:node/UNDOFILE_CHUNK_SIZE.adoc[`UNDOFILE&lowbar;CHUNK&lowbar;SIZE`] 
| The pre&hyphen;allocation chunk size for rev?????&period;dat files (since 0&period;8)
| xref:node/UNDO_DATA_DISK_OVERHEAD.adoc[`UNDO&lowbar;DATA&lowbar;DISK&lowbar;OVERHEAD`] 
| Total overhead when writing undo data&colon; header (8 bytes) plus checksum (32 bytes)
|===


=== Using Declarations

[cols="1,4"]
|===
| Name| Description
| xref:node/BlockTreeDB.adoc[`BlockTreeDB`] 
| Bring the kernel block&hyphen;tree database type into the node namespace&period;
| xref:node/CBlockFileInfo.adoc[`CBlockFileInfo`] 
| Bring the kernel block&hyphen;file info type into the node namespace&period;
|===


== xref:poly1305_donna.adoc[poly1305&lowbar;donna] namespace

Low&hyphen;level Poly1305 routines based on the public domain poly1305&hyphen;donna implementation by Andrew Moon (poly1305&hyphen;donna&hyphen;32&period;h)&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:poly1305_donna/poly1305_context.adoc[`poly1305&lowbar;context`] 
| Incremental state for a Poly1305 one&hyphen;time authenticator computation&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:poly1305_donna/poly1305_finish.adoc[`poly1305&lowbar;finish`] 
| Finish a Poly1305 computation and write the 16&hyphen;byte authentication tag&period;
| xref:poly1305_donna/poly1305_init.adoc[`poly1305&lowbar;init`] 
| Initialize a Poly1305 state with a 32&hyphen;byte one&hyphen;time key&period;
| xref:poly1305_donna/poly1305_update.adoc[`poly1305&lowbar;update`] 
| Feed message bytes into a Poly1305 state&period;
|===


== xref:script.adoc[script] namespace

Helpers for parsing output descriptor strings&period;

=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:script/Const.adoc[`Const`] 
| Parse a constant&period;
| xref:script/Expr.adoc[`Expr`] 
| Extract the expression that sp begins with&period;
| xref:script/Func.adoc[`Func`] 
| Parse a function call&period;
|===


== xref:sha256_implementation.adoc[sha256&lowbar;implementation] namespace

Runtime selection of the SHA&hyphen;256 implementation&period;

=== Enums

[cols="1,4"]
|===
| Name| Description
| xref:sha256_implementation/UseImplementation.adoc[`UseImplementation`] 
| Bit flags selecting which CPU&hyphen;specific SHA&hyphen;256 implementations may be used&period;
|===


== xref:std.adoc[std] namespace

Standard library namespace, extended here with a deleted hash specialization&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:std/hash-038.adoc[`hash&lt;CTransactionRef&gt;`] 
| Disable default std&colon;&colon;hash for CTransactionRef to prevent accidentally comparing by pointer&period; Use CTransactionRefHash or provide a custom hasher&period;
|===


== xref:subprocess.adoc[subprocess] namespace

Getting started with reading this source code&period; The source is mainly divided into four parts&colon; 1&period; Exception Classes&colon; These are very basic exception classes derived from runtime&lowbar;error exception&period; There are two types of exception thrown from subprocess library&colon; OSError and CalledProcessError

=== Namespaces

[cols="1,4"]
|===
| Name| Description
| xref:subprocess/util.adoc[`util`] 
| Low&hyphen;level helpers shared by the subprocess implementation (argument quoting, pipes, descriptors)&period;
|===


=== Types

[cols="1,4"]
|===
| Name| Description
| xref:subprocess/Buffer.adoc[`Buffer`] 
| class&colon; Buffer This class is a very thin wrapper around std&colon;&colon;vector&lt;char&gt; This is basically used to determine the length of the actual data stored inside the dynamically resized vector&period;
| xref:subprocess/CalledProcessError.adoc[`CalledProcessError`] 
| class&colon; CalledProcessError Thrown when there was error executing the command&period; Check Popen class API&apos;s to know when this exception can be thrown&period;
| xref:subprocess/OSError.adoc[`OSError`] 
| class&colon; OSError Thrown when some system call fails to execute or give result&period; The exception message contains the name of the failed system call with the stringisized errno code&period; Check Popen class API&apos;s to know when this exception would be thrown&period; Its usual that the API exception specification would have this exception together with CalledProcessError&period;
| xref:subprocess/Popen.adoc[`Popen`] 
| class&colon; Popen This is the single most important class in the whole library and glues together all the helper classes to provide a common interface to the client&period;
| xref:subprocess/error.adoc[`error`] 
| Option to specify the error channel for the child process&period; It can be&colon; 1&period; An already open file descriptor&period; 2&period; A file name&period; 3&period; IOTYPE&period; Usually a PIPE or STDOUT
| xref:subprocess/executable.adoc[`executable`] 
| Option to specify the executable name separately from the args sequence&period; In this case the cmd args must only contain the options required for this executable&period;
| xref:subprocess/input.adoc[`input`] 
| Option to specify the input channel for the child process&period; It can be&colon; 1&period; An already open file descriptor&period; 2&period; A file name&period; 3&period; IOTYPE&period; Usual a PIPE
| xref:subprocess/output.adoc[`output`] 
| Option to specify the output channel for the child process&period; It can be&colon; 1&period; An already open file descriptor&period; 2&period; A file name&period; 3&period; IOTYPE&period; Usually a PIPE&period;
| xref:subprocess/string_arg.adoc[`string&lowbar;arg`] 
| Base class for all arguments involving string value&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:subprocess/ErrBuffer.adoc[`ErrBuffer`] 
| Buffer holding the data captured from the child&apos;s error descriptor&period;
| xref:subprocess/OutBuffer.adoc[`OutBuffer`] 
| Buffer holding the data captured from the child&apos;s output descriptor&period;
|===


=== Enums

[cols="1,4"]
|===
| Name| Description
| xref:subprocess/IOTYPE.adoc[`IOTYPE`] 
| Used for redirecting input&sol;output&sol;error
|===


=== Variables

[cols="1,4"]
|===
| Name| Description
| xref:subprocess/DEFAULT_BUF_CAP_BYTES.adoc[`DEFAULT&lowbar;BUF&lowbar;CAP&lowbar;BYTES`] 
| Default buffer capacity for OutBuffer and ErrBuffer, in bytes&period;
| xref:subprocess/SP_MAX_ERR_BUF_SIZ.adoc[`SP&lowbar;MAX&lowbar;ERR&lowbar;BUF&lowbar;SIZ`] 
| Maximum buffer size allocated on the stack when reading an error from a pipe&period;
|===


== xref:subprocess/util.adoc[subprocess::util] namespace

Low&hyphen;level helpers shared by the subprocess implementation (argument quoting, pipes, descriptors)&period;

== xref:tinyformat.adoc[tinyformat] namespace

Tiny type&hyphen;safe printf&hyphen;style string formatting library&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:tinyformat/FormatList.adoc[`FormatList`] 
| List of template arguments format(), held in a type&hyphen;opaque way&period;
| xref:tinyformat/FormatStringCheck.adoc[`FormatStringCheck`] 
| Format string wrapper that checks the format at compile time&period;
| xref:tinyformat/RuntimeFormat.adoc[`RuntimeFormat`] 
| Wrapper marking a format string as runtime data, skipping compile&hyphen;time checks&period;
| xref:tinyformat/format_error.adoc[`format&lowbar;error`] 
| Exception thrown when formatting fails&period; Added for Bitcoin Core&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:tinyformat/FormatListRef.adoc[`FormatListRef`] 
| Reference to type&hyphen;opaque format list for passing to vformat()
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:tinyformat/format-0c.adoc[`format`] 
| `format` overloads
| xref:tinyformat/formatValue-07.adoc[`formatValue`] 
| `formatValue` overloads
| xref:tinyformat/makeFormatList.adoc[`makeFormatList`] 
| Make type&hyphen;agnostic format list from list of template arguments&period;
| xref:tinyformat/printf.adoc[`printf`] 
| Format list of arguments to std&colon;&colon;cout, according to the given format string
| xref:tinyformat/printfln.adoc[`printfln`] 
| Format list of arguments to std&colon;&colon;cout, then append a newline&period;
| xref:tinyformat/vformat.adoc[`vformat`] 
| Format a list of arguments to a stream according to a format string&period;
|===


== xref:txindex-02.adoc[txindex] namespace

Database key types and constants for the transaction index&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:txindex-02/BlockHashKey.adoc[`BlockHashKey`] 
| Key for looking up the sequence number assigned to the block with the given hash&period;
| xref:txindex-02/BlockSeqKey.adoc[`BlockSeqKey`] 
| Key for looking up the hash of the block with the given sequence number&period;
| xref:txindex-02/BlockTxPosition.adoc[`BlockTxPosition`] 
| The location of a transaction&colon; the sequence number of the block that contains it and the transaction&apos;s serialized byte offset from the start of that block (including the header), so the on&hyphen;disk position is simply block&lowbar;data&lowbar;pos &plus; tx&lowbar;offset&lowbar;in&lowbar;block&period;
| xref:txindex-02/DBKey.adoc[`DBKey`] 
| Hashed txindex key&colon; a truncated txid hash prefix plus the block position&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:txindex-02/TxHashKeyPrefix.adoc[`TxHashKeyPrefix`] 
| Integer type holding the truncated txid hash prefix of a key&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:txindex-02/CreateKeyPrefix.adoc[`CreateKeyPrefix`] 
| Compute the txid&hyphen;hash key prefix for a transaction&period;
| xref:txindex-02/LegacyTxKey.adoc[`LegacyTxKey`] 
| Key of a legacy (pre&hyphen;hashing) txindex row&colon; the full txid under the &apos;t&apos; prefix&period;
| xref:txindex-02/operator_eq.adoc[`operator&equals;&equals;`] 
| Compare two positions for equality by block sequence and offset&period;
|===


=== Variables

[cols="1,4"]
|===
| Name| Description
| xref:txindex-02/BLOCK_HEADER_SIZE.adoc[`BLOCK&lowbar;HEADER&lowbar;SIZE`] 
| Serialized size of a block header, the offset of the first byte after it&period;
| xref:txindex-02/DB_BEST_BLOCK_V2.adoc[`DB&lowbar;BEST&lowbar;BLOCK&lowbar;V2`] 
| Key holding the sync locator for the current (v2) index format&period;
| xref:txindex-02/DB_BLOCK_HASH.adoc[`DB&lowbar;BLOCK&lowbar;HASH`] 
| Key prefix mapping a block hash to its sequence number&period;
| xref:txindex-02/DB_BLOCK_SEQ.adoc[`DB&lowbar;BLOCK&lowbar;SEQ`] 
| Key prefix mapping a block sequence number to its block hash&period;
| xref:txindex-02/DB_NEXT_BLOCK_SEQ.adoc[`DB&lowbar;NEXT&lowbar;BLOCK&lowbar;SEQ`] 
| Key holding the next block sequence number to assign&period;
| xref:txindex-02/DB_TXID_HASH_SALT.adoc[`DB&lowbar;TXID&lowbar;HASH&lowbar;SALT`] 
| Key holding the salt used to hash txids&period;
| xref:txindex-02/DB_TXINDEX.adoc[`DB&lowbar;TXINDEX`] 
| Prefix of a legacy (pre&hyphen;hashing) txindex row&period;
| xref:txindex-02/DB_TXINDEX_HASHED.adoc[`DB&lowbar;TXINDEX&lowbar;HASHED`] 
| Key prefix for a hashed txindex row keyed by txid hash prefix and position&period;
| xref:txindex-02/EMPTY_VALUE.adoc[`EMPTY&lowbar;VALUE`] 
| Empty value of a hashed txindex row, whose position is encoded in its key&period;
| xref:txindex-02/HASH_PREFIX_SIZE.adoc[`HASH&lowbar;PREFIX&lowbar;SIZE`] 
| Number of leading txid&hyphen;hash bytes kept in a hashed txindex key&period;
|===


== xref:txindex_tests.adoc[txindex&lowbar;tests] namespace

Unit&hyphen;test helpers that reach into TxIndex internals&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:txindex_tests/TxIndexTest.adoc[`TxIndexTest`] 
| Test fixture granting access to TxIndex private members&period;
|===


== xref:util.adoc[util] namespace

Bitcoin Core utility helpers shared across the codebase&period;

=== Namespaces

[cols="1,4"]
|===
| Name| Description
| xref:util/log.adoc[`log`] 
| Application&hyphen;agnostic logging interface shared across Bitcoin Core&period;
|===


=== Types

[cols="1,4"]
|===
| Name| Description
| xref:util/BadExpectedAccess.adoc[`BadExpectedAccess`] 
| Exception thrown when the value of an errored util&colon;&colon;Expected is accessed&period;
| xref:util/BilingualFmt.adoc[`BilingualFmt`] 
| Compile&hyphen;time bilingual format string carrying a checked format and its translatable literal&period;
| xref:util/ConstevalFormatString.adoc[`ConstevalFormatString`] 
| A wrapper for a compile&hyphen;time partially validated format string
| xref:util/Error.adoc[`Error`] 
| Wraps a failure message used to construct a util&colon;&colon;Result in the error state&period;
| xref:util/Expected-0b.adoc[`Expected`] 
| The util&colon;&colon;Expected class provides a standard way for low&hyphen;level functions to return either error values or result values&period;
| xref:util/ImmediateTaskRunner.adoc[`ImmediateTaskRunner`] 
| Task runner that processes each callback synchronously on insertion&period;
| xref:util/LineReader.adoc[`LineReader`] 
| Reads a character buffer line by line or in fixed&hyphen;length chunks&period;
| xref:util/Overloaded.adoc[`Overloaded`] 
| Overloaded helper for std&colon;&colon;visit&period; This helper and std&colon;&colon;visit in general are useful to write code that switches on a variant type&period; Unlike if&sol;else&hyphen;if and switch&sol;case statements, std&colon;&colon;visit will trigger compile errors if there are unhandled cases&period;
| xref:util/Result.adoc[`Result`] 
| The util&colon;&colon;Result class provides a standard way for functions to return either error messages or result values&period;
| xref:util/SignalInterrupt.adoc[`SignalInterrupt`] 
| Helper class that manages an interrupt flag, and allows a thread or signal to interrupt another thread&period;
| xref:util/TaskRunnerInterface.adoc[`TaskRunnerInterface`] 
| This header provides an interface and simple implementation for a task runner&period; Another threaded, serial implementation using a queue is available in the scheduler module&apos;s SerialTaskRunner&period;
| xref:util/TokenBucket.adoc[`TokenBucket`] 
| A token bucket rate limiter&period;
| xref:util/TranslatedLiteral.adoc[`TranslatedLiteral`] 
| Compile&hyphen;time literal string that can be translated with an optional translation function&period;
| xref:util/Unexpected.adoc[`Unexpected`] 
| The util&colon;&colon;Unexpected class represents an unexpected value stored in util&colon;&colon;Expected&period;
|===


=== Enums

[cols="1,4"]
|===
| Name| Description
| xref:util/LockResult.adoc[`LockResult`] 
| Outcome of trying to acquire a directory lock&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:util/AnyPtr.adoc[`AnyPtr`] 
| Helper function to access the contained object of a std&colon;&colon;any instance&period; Returns a pointer to the object if passed instance has a value and the type matches, nullptr otherwise&period;
| xref:util/ConstevalHexDigit.adoc[`ConstevalHexDigit`] 
| consteval version of HexDigit() without the lookup table&period;
| xref:util/ContainsNoNUL.adoc[`ContainsNoNUL`] 
| Check if a string does not contain any embedded NUL (0) characters
| xref:util/ErrorString-0d.adoc[`ErrorString`] 
| Extracts the error message from a result&period;
| xref:util/ExecVp.adoc[`ExecVp`] 
| Cross&hyphen;platform wrapper for POSIX execvp function&period; Arguments and return value are the same as for POSIX execvp, and the argv array should consist of null terminated strings and be null terminated itself, like the POSIX function&period;
| xref:util/GetExePath.adoc[`GetExePath`] 
| Return path to current executable assuming it was invoked with argv0&period; If path could not be determined, returns an empty path&period;
| xref:util/HasPrefix.adoc[`HasPrefix`] 
| Check whether a container begins with the given prefix&period;
| xref:util/Join-07.adoc[`Join`] 
| `Join` overloads
| xref:util/LockDirectory.adoc[`LockDirectory`] 
| Acquire an exclusive lock on a directory via a lock file&period;
| xref:util/MakeUnorderedList.adoc[`MakeUnorderedList`] 
| Create an unordered multi&hyphen;line list of items&period;
| xref:util/RemovePrefix.adoc[`RemovePrefix`] 
| Return a copy of str with the given prefix removed, if present&period;
| xref:util/RemovePrefixView.adoc[`RemovePrefixView`] 
| Return a view of str with the given prefix removed, if present&period;
| xref:util/RemoveSuffixView.adoc[`RemoveSuffixView`] 
| Return a view of str with the given suffix removed, if present&period;
| xref:util/ReplaceAll.adoc[`ReplaceAll`] 
| Replace every occurrence of a substring in place&period;
| xref:util/Split-0b.adoc[`Split`] 
| `Split` overloads
| xref:util/SplitString-0e.adoc[`SplitString`] 
| `SplitString` overloads
| xref:util/ThreadGetInternalName.adoc[`ThreadGetInternalName`] 
| Get the thread&apos;s internal (in&hyphen;memory) name&semi; used e&period;g&period; for identification in logging&period;
| xref:util/ThreadRename.adoc[`ThreadRename`] 
| Rename a thread both in terms of an internal (in&hyphen;memory) name as well as its system thread name&period;
| xref:util/ThreadSetInternalName.adoc[`ThreadSetInternalName`] 
| Set the internal (in&hyphen;memory) name of the current thread only&period;
| xref:util/ToString.adoc[`ToString`] 
| Locale&hyphen;independent version of std&colon;&colon;to&lowbar;string
| xref:util/TraceThread.adoc[`TraceThread`] 
| A wrapper for do&hyphen;something&hyphen;once thread functions&period;
| xref:util/TrimString.adoc[`TrimString`] 
| Return a copy of str with leading and trailing pattern characters removed&period;
| xref:util/TrimStringView.adoc[`TrimStringView`] 
| Return a view of str with leading and trailing pattern characters removed&period;
| xref:util/insert-0b.adoc[`insert`] 
| `insert` overloads
| xref:util/operator_hex.adoc[`operator&quot;&quot;&lowbar;hex`] 
| Compile&hyphen;time hex literal returning a `std&colon;&colon;array&lt;std&colon;&colon;byte, N&sol;2&gt;`&period;
| xref:util/operator_hex_u8.adoc[`operator&quot;&quot;&lowbar;hex&lowbar;u8`] 
| Compile&hyphen;time hex literal returning a `std&colon;&colon;array&lt;uint8&lowbar;t, N&sol;2&gt;`&period;
| xref:util/operator_hex_v.adoc[`operator&quot;&quot;&lowbar;hex&lowbar;v`] 
| Compile&hyphen;time hex literal returning a `std&colon;&colon;vector&lt;std&colon;&colon;byte&gt;`&period;
| xref:util/operator_hex_v_u8.adoc[`operator&quot;&quot;&lowbar;hex&lowbar;v&lowbar;u8`] 
| Compile&hyphen;time hex literal returning a `std&colon;&colon;vector&lt;uint8&lowbar;t&gt;`&period;
| xref:util/operator_plus-01.adoc[`operator&plus;`] 
| Addition operators
| xref:util/operator_lshift.adoc[`operator&lt;&lt;`] 
| Write the translated form of a literal to an output stream&period;
|===


== xref:util/log.adoc[util::log] namespace

Application&hyphen;agnostic logging interface shared across Bitcoin Core&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:util/log/Entry.adoc[`Entry`] 
| A single log message together with its metadata&period;
| xref:util/log/NoRateLimitTag.adoc[`NoRateLimitTag`] 
| Structure and constant for tagging not to rate limit&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:util/log/Category.adoc[`Category`] 
| Opaque to util&colon;&colon;log&semi; interpreted by consumers (e&period;g&period;, BCLog&colon;&colon;LogFlags)&period;
|===


=== Enums

[cols="1,4"]
|===
| Name| Description
| xref:util/log/Level.adoc[`Level`] 
| Severity level of a log entry&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:util/log/Log.adoc[`Log`] 
| Send message to be logged&period; Applications using the logging library need to provide this&period;
| xref:util/log/LogPrintFormatInternal-08.adoc[`LogPrintFormatInternal`] 
| `LogPrintFormatInternal` overloads
| xref:util/log/LogPrintFormatInternal_.adoc[`LogPrintFormatInternal&lowbar;`] 
| Format a log message and forward it to util&colon;&colon;log&colon;&colon;Log&period;
| xref:util/log/ShouldDebugLog.adoc[`ShouldDebugLog`] 
| Return whether messages with specified category should be debug logged&period; Applications using the logging library need to provide this&period;
| xref:util/log/ShouldTraceLog.adoc[`ShouldTraceLog`] 
| Return whether messages with specified category should be trace logged&period; Applications using the logging library need to provide this&period;
|===


=== Variables

[cols="1,4"]
|===
| Name| Description
| xref:util/log/NO_RATE_LIMIT.adoc[`NO&lowbar;RATE&lowbar;LIMIT`] 
| Tag value passed to logging macros to opt out of rate limiting&period;
|===


== xref:wallet.adoc[wallet] namespace

Wallet subsystem&period;

=== Namespaces

[cols="1,4"]
|===
| Name| Description
| xref:wallet/DBKeys.adoc[`DBKeys`] 
| Record type prefixes used as keys in the wallet database&period;
| xref:wallet/WalletTool.adoc[`WalletTool`] 
| Command&hyphen;line wallet tool commands&period;
| xref:wallet/feebumper.adoc[`feebumper`] 
| Helpers for replacing a wallet transaction with a higher&hyphen;fee version&period;
| xref:wallet/wallet_crypto_tests.adoc[`wallet&lowbar;crypto&lowbar;tests`] 
| Test&hyphen;only helpers for exercising the wallet crypto internals&period;
|===


=== Types

[cols="1,4"]
|===
| Name| Description
| xref:wallet/Balance.adoc[`Balance`] 
| Breakdown of a wallet&apos;s balance by category&period;
| xref:wallet/BerkeleyROBatch.adoc[`BerkeleyROBatch`] 
| RAII class that provides access to a BerkeleyRODatabase
| xref:wallet/BerkeleyROCursor.adoc[`BerkeleyROCursor`] 
| Cursor that iterates over the records of a BerkeleyRODatabase&period;
| xref:wallet/BerkeleyRODatabase.adoc[`BerkeleyRODatabase`] 
| A class representing a BerkeleyDB file from which we can only read records&period; This is used only for migration of legacy to descriptor wallets
| xref:wallet/BytePrefix.adoc[`BytePrefix`] 
| Compares equal to any byte span that begins with the same prefix&period;
| xref:wallet/CAddressBookData.adoc[`CAddressBookData`] 
| Address book data&period;
| xref:wallet/CCoinControl.adoc[`CCoinControl`] 
| Coin Control Features&period;
| xref:wallet/CCrypter.adoc[`CCrypter`] 
| Encryption&sol;decryption context with key information
| xref:wallet/CHDChain.adoc[`CHDChain`] 
| Simple HD chain data model&period;
| xref:wallet/CKeyMetadata.adoc[`CKeyMetadata`] 
| Metadata about a wallet key, such as its creation time and HD derivation info&period;
| xref:wallet/CMasterKey.adoc[`CMasterKey`] 
| Master key for wallet encryption
| xref:wallet/CMerkleTx.adoc[`CMerkleTx`] 
| Legacy class used for deserializing vtxPrev for backwards compatibility&period; vtxPrev was removed in commit 93a18a3650292afbb441a47d1fa1b94aeb0164e3, but old wallet&period;dat files may still contain vtxPrev vectors of CMerkleTxs&period; These need to get deserialized for field alignment when deserializing a CWalletTx, but the deserialized values are discarded&period;&ast;
| xref:wallet/COutput.adoc[`COutput`] 
| A UTXO under consideration for use in funding a new transaction&period;
| xref:wallet/COutputEntry.adoc[`COutputEntry`] 
| A single received or sent output belonging to the wallet&period;
| xref:wallet/CRecipient.adoc[`CRecipient`] 
| A transaction output target&colon; a destination, an amount, and fee handling&period;
| xref:wallet/CWallet.adoc[`CWallet`] 
| A CWallet maintains a set of transactions and balances, and provides the ability to create new transactions&period;
| xref:wallet/CWalletTx.adoc[`CWalletTx`] 
| A transaction with a bunch of additional info that only the owner cares about&period; It includes any unrecorded transactions needed to link it back to the block chain&period;
| xref:wallet/CachableAmount.adoc[`CachableAmount`] 
| Cachable amount subdivided into avoid reuse and all balances
| xref:wallet/CoinEligibilityFilter.adoc[`CoinEligibilityFilter`] 
| Parameters for filtering which OutputGroups we may use in coin selection&period; We start by being very selective and requiring multiple confirmations and then get more permissive if we cannot fund the transaction&period;
| xref:wallet/CoinFilterParams.adoc[`CoinFilterParams`] 
| Parameters that filter which coins are considered available for spending&period;
| xref:wallet/CoinSelectionParams.adoc[`CoinSelectionParams`] 
| Parameters for one iteration of Coin Selection&period;
| xref:wallet/CoinsResult.adoc[`CoinsResult`] 
| COutputs available for spending, stored by OutputType&period; This struct is really just a wrapper around OutputType vectors with a convenient method for concatenating and returning all COutputs as one vector&period;
| xref:wallet/CreatedTransactionResult.adoc[`CreatedTransactionResult`] 
| Outcome of building a new transaction, bundling the transaction with its fee details&period;
| xref:wallet/DatabaseBatch.adoc[`DatabaseBatch`] 
| RAII class that provides access to a WalletDatabase
| xref:wallet/DatabaseCursor.adoc[`DatabaseCursor`] 
| Iterates over records stored in a wallet database&period;
| xref:wallet/DatabaseOptions.adoc[`DatabaseOptions`] 
| Options controlling how a wallet database is opened or created&period;
| xref:wallet/DbTxnListener.adoc[`DbTxnListener`] 
| Callbacks invoked when a wallet database transaction commits or aborts&period;
| xref:wallet/DescriptorScriptPubKeyMan.adoc[`DescriptorScriptPubKeyMan`] 
| A ScriptPubKeyMan backed by a single output descriptor&period;
| xref:wallet/Groups.adoc[`Groups`] 
| A pair of output group collections split by whether they hold only positive&hyphen;value UTXOs&period;
| xref:wallet/InMemoryWalletDatabase.adoc[`InMemoryWalletDatabase`] 
| An in&hyphen;memory SQLiteDatabase&period; Used as a temporary build artifact where no on&hyphen;disk persistence is needed&period;
| xref:wallet/LegacyDataSPKM.adoc[`LegacyDataSPKM`] 
| Manages the minimum data needed to load and migrate a legacy wallet&period;
| xref:wallet/LegacySigningProvider.adoc[`LegacySigningProvider`] 
| SigningProvider wrapper for LegacyDataSPKM that does not provide private keys&period;
| xref:wallet/MigrationData.adoc[`MigrationData`] 
| struct containing information needed for migrating legacy wallets to descriptor wallets
| xref:wallet/MigrationResult.adoc[`MigrationResult`] 
| Result of migrating a legacy wallet to descriptor wallets&period;
| xref:wallet/MinimumFeeRateResult.adoc[`MinimumFeeRateResult`] 
| Result of resolving the minimum fee rate to use for a transaction&period;
| xref:wallet/OutputGroup.adoc[`OutputGroup`] 
| A group of UTXOs paid to the same output script&period;
| xref:wallet/OutputGroupTypeMap.adoc[`OutputGroupTypeMap`] 
| Stores several &apos;Groups&apos; whose were mapped by output type&period;
| xref:wallet/OutputPtrComparator.adoc[`OutputPtrComparator`] 
| Comparator ordering shared pointers to COutput by the pointed&hyphen;to output&period;
| xref:wallet/PreselectedInput.adoc[`PreselectedInput`] 
| Holds the user&hyphen;supplied details for a single manually selected transaction input&period;
| xref:wallet/ReserveDestination.adoc[`ReserveDestination`] 
| A wrapper to reserve an address from a wallet
| xref:wallet/SQLiteBatch.adoc[`SQLiteBatch`] 
| RAII class that provides access to a WalletDatabase
| xref:wallet/SQLiteCursor.adoc[`SQLiteCursor`] 
| RAII class that provides a database cursor
| xref:wallet/SQLiteDatabase.adoc[`SQLiteDatabase`] 
| An instance of this class represents one SQLite3 database&period;
| xref:wallet/SQliteExecHandler.adoc[`SQliteExecHandler`] 
| Class responsible for executing SQL statements in SQLite databases&period; Methods are virtual so they can be overridden by unit tests testing unusual database conditions&period;
| xref:wallet/ScriptPubKeyMan.adoc[`ScriptPubKeyMan`] 
| A class implementing ScriptPubKeyMan manages some (or all) scriptPubKeys used in a wallet&period; It contains the scripts and keys related to the scriptPubKeys it manages&period; A ScriptPubKeyMan will be able to give out scriptPubKeys to be used, as well as marking when a scriptPubKey has been used&period; It also handles when and how to store a scriptPubKey and its related scripts and keys, including encryption&period;
| xref:wallet/SelectionFilter.adoc[`SelectionFilter`] 
| Pairs a coin eligibility filter with whether mixing output types is allowed&period;
| xref:wallet/SelectionResult.adoc[`SelectionResult`] 
| The set of inputs chosen by a coin selection algorithm, along with its metrics&period;
| xref:wallet/TxSize.adoc[`TxSize`] 
| Holds the virtual size and weight of a transaction&period;
| xref:wallet/TxStateBlockConflicted.adoc[`TxStateBlockConflicted`] 
| State of rejected transaction that conflicts with a confirmed block&period;
| xref:wallet/TxStateConfirmed.adoc[`TxStateConfirmed`] 
| State of transaction confirmed in a block&period;
| xref:wallet/TxStateInMempool.adoc[`TxStateInMempool`] 
| State of transaction added to mempool&period;
| xref:wallet/TxStateInactive.adoc[`TxStateInactive`] 
| State of transaction not confirmed or conflicting with a known block and not in the mempool&period; May conflict with the mempool, or with an unknown block, or be abandoned, never broadcast, or rejected from the mempool for another reason&period;
| xref:wallet/TxStateUnrecognized.adoc[`TxStateUnrecognized`] 
| State of transaction loaded in an unrecognized state with unexpected hash or index values&period; Treated as inactive (with serialized hash and index values preserved) by default, but may enter another state if transaction is added to the mempool, or confirmed, or abandoned, or found conflicting&period;
| xref:wallet/WalletBatch.adoc[`WalletBatch`] 
| Access to the wallet database&period; Opens the database and provides read and write access to it&period; Each read and write is its own transaction&period; Multiple operation transactions can be started using TxnBegin() and committed using TxnCommit() Otherwise the transaction will be committed when the object goes out of scope&period; Optionally (on by default) it will flush to disk on close&period; Every 1000 writes will automatically trigger a flush to disk&period;
| xref:wallet/WalletContext.adoc[`WalletContext`] 
| WalletContext struct containing references to state shared between CWallet instances, like the reference to the chain interface, and the list of opened wallets&period;
| xref:wallet/WalletDatabase.adoc[`WalletDatabase`] 
| An instance of this class represents one database&period;
| xref:wallet/WalletDescInfo.adoc[`WalletDescInfo`] 
| Exportable form of a WalletDescriptor with the descriptor as a string and without its ID or cache&period;
| xref:wallet/WalletDescriptor.adoc[`WalletDescriptor`] 
| Descriptor with some wallet metadata
| xref:wallet/WalletDestination.adoc[`WalletDestination`] 
| A destination together with whether it belongs to the internal (change) chain&period;
| xref:wallet/WalletError.adoc[`WalletError`] 
| Wallet&hyphen;layer error with both programmatic and user&hyphen;facing information&period;
| xref:wallet/WalletRescanReserver.adoc[`WalletRescanReserver`] 
| RAII object to check and reserve a wallet rescan
| xref:wallet/WalletStorage.adoc[`WalletStorage`] 
| Wallet storage things that ScriptPubKeyMans need in order to be able to store things to the wallet database&period; It provides access to things that are part of the entire wallet and not specific to a ScriptPubKeyMan such as wallet flags, wallet version, encryption keys, encryption status, and the database itself&period; This allows a ScriptPubKeyMan to have callbacks into CWallet without causing a circular dependency&period; WalletStorage should be the same for all ScriptPubKeyMans of a wallet&period;
| xref:wallet/WalletTXO.adoc[`WalletTXO`] 
| A single wallet transaction output, pairing a wallet transaction with one of its outputs&period;
| xref:wallet/WalletTxOrderComparator.adoc[`WalletTxOrderComparator`] 
| Orders wallet transactions by their position in the ordered transaction list&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:wallet/BerkeleyROData.adoc[`BerkeleyROData`] 
| Ordered map of raw key&sol;value records read from a BerkeleyDB file&period;
| xref:wallet/CKeyingMaterial.adoc[`CKeyingMaterial`] 
| Secure byte buffer used to hold sensitive key material in memory&period;
| xref:wallet/CryptedKeyMap.adoc[`CryptedKeyMap`] 
| Map from key id to its public key and encrypted private key material&period;
| xref:wallet/FilteredOutputGroups.adoc[`FilteredOutputGroups`] 
| Output groups keyed by the eligibility filter that selected them&period;
| xref:wallet/KeyMap.adoc[`KeyMap`] 
| Map from key id to its private key&period;
| xref:wallet/LoadWalletFn.adoc[`LoadWalletFn`] 
| Callback invoked when a wallet is loaded, receiving the wallet interface&period;
| xref:wallet/OutputSet.adoc[`OutputSet`] 
| A set of COutput pointers ordered by the pointed&hyphen;to output&period;
| xref:wallet/SyncTxState.adoc[`SyncTxState`] 
| Subset of states transaction sync logic is implemented to handle&period;
| xref:wallet/TxState.adoc[`TxState`] 
| All possible CWalletTx states
|===


=== Enums

[cols="1,4"]
|===
| Name| Description
| xref:wallet/AddressPurpose.adoc[`AddressPurpose`] 
| Address purpose field that has been been stored with wallet sending and receiving addresses since BIP70 payment protocol support was added in https&colon;&sol;&sol;github&period;com&sol;bitcoin&sol;bitcoin&sol;pull&sol;2539&period; This field is not currently used for any logic inside the wallet, but it is still shown in RPC and GUI interfaces and saved for new addresses&period; It is basically redundant with an address&apos;s IsMine() result&period;
| xref:wallet/DBErrors.adoc[`DBErrors`] 
| Error statuses for the wallet database&period; Values are in order of severity&period; When multiple errors occur, the most severe (highest value) will be returned&period;
| xref:wallet/DatabaseFormat.adoc[`DatabaseFormat`] 
| On&hyphen;disk format of a wallet database&period;
| xref:wallet/DatabaseStatus.adoc[`DatabaseStatus`] 
| Result of opening or creating a wallet database&period;
| xref:wallet/SelectionAlgorithm.adoc[`SelectionAlgorithm`] 
| Identifies which coin selection algorithm produced a result&period;
| xref:wallet/WalletErrorCode.adoc[`WalletErrorCode`] 
| Machine&hyphen;readable wallet error codes&period;
| xref:wallet/WalletFlags.adoc[`WalletFlags`] 
| Feature and state flags stored on a wallet&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:wallet/AddWallet.adoc[`AddWallet`] 
| Register a loaded wallet with the wallet context&period;
| xref:wallet/AddWalletSetting.adoc[`AddWalletSetting`] 
| Add wallet name to persistent configuration so it will be loaded on startup&period;
| xref:wallet/AllInputsMine.adoc[`AllInputsMine`] 
| Returns whether all of the inputs belong to the wallet
| xref:wallet/AppendLastProcessedBlock.adoc[`AppendLastProcessedBlock`] 
| Appends the wallet&apos;s last processed block to an RPC result object&period;
| xref:wallet/AttemptSelection.adoc[`AttemptSelection`] 
| Attempt to find a valid input set that preserves privacy by not mixing OutputTypes&period; `ChooseSelectionResult()` will be called on each OutputType individually and the best the solution (according to the waste metric) will be chosen&period; If a valid input cannot be found from any single OutputType, fallback to running `ChooseSelectionResult()` over all available coins&period;
| xref:wallet/AutomaticCoinSelection.adoc[`AutomaticCoinSelection`] 
| Select a set of coins such that nTargetValue is met&semi; never select unconfirmed coins if they are not ours
| xref:wallet/AvailableCoins.adoc[`AvailableCoins`] 
| Populate the CoinsResult struct with vectors of available COutputs, organized by OutputType&period;
| xref:wallet/BDBDataFile.adoc[`BDBDataFile`] 
| Returns the path to the Berkeley DB data file for a wallet path&period;
| xref:wallet/CachedTxGetAmounts.adoc[`CachedTxGetAmounts`] 
| Splits a wallet transaction into received and sent entries plus its fee&period;
| xref:wallet/CachedTxGetChange.adoc[`CachedTxGetChange`] 
| Returns the cached change amount of a wallet transaction&period;
| xref:wallet/CachedTxGetCredit.adoc[`CachedTxGetCredit`] 
| Returns the cached total credit of a wallet transaction&period;
| xref:wallet/CachedTxGetDebit.adoc[`CachedTxGetDebit`] 
| Returns the cached total debit of a wallet transaction&period;
| xref:wallet/CachedTxIsFromMe.adoc[`CachedTxIsFromMe`] 
| Returns whether a wallet transaction debits from the wallet&period;
| xref:wallet/CachedTxIsTrusted-04.adoc[`CachedTxIsTrusted`] 
| `CachedTxIsTrusted` overloads
| xref:wallet/CalculateMaximumSignedInputSize-09.adoc[`CalculateMaximumSignedInputSize`] 
| `CalculateMaximumSignedInputSize` overloads
| xref:wallet/CalculateMaximumSignedTxSize-08.adoc[`CalculateMaximumSignedTxSize`] 
| `CalculateMaximumSignedTxSize` overloads
| xref:wallet/ChooseSelectionResult.adoc[`ChooseSelectionResult`] 
| Attempt to find a valid input set that meets the provided eligibility filter and target&period; Multiple coin selection algorithms will be run and the input set that produces the least waste (according to the waste metric) will be chosen&period;
| xref:wallet/CoinGrinder.adoc[`CoinGrinder`] 
| Select coins using the CoinGrinder deterministic search algorithm&period;
| xref:wallet/CreateFromDump.adoc[`CreateFromDump`] 
| Creates a new wallet database from a previously dumped file&period;
| xref:wallet/CreateTransaction.adoc[`CreateTransaction`] 
| Create a new transaction paying the recipients with a set of coins selected by SelectCoins()&semi; Also create the change output, when needed
| xref:wallet/CreateWallet.adoc[`CreateWallet`] 
| Create a new wallet and load it into the context&period;
| xref:wallet/DecryptKey.adoc[`DecryptKey`] 
| Decrypts an encrypted private key and validates it against its public key&period;
| xref:wallet/DecryptSecret.adoc[`DecryptSecret`] 
| Decrypts a secret with the master key using the given IV&period;
| xref:wallet/DiscourageFeeSniping.adoc[`DiscourageFeeSniping`] 
| Set a height&hyphen;based locktime for new transactions (uses the height of the current chain tip unless we are not synced with the current chain
| xref:wallet/DumpWallet.adoc[`DumpWallet`] 
| Dumps the records of a wallet database to a human&hyphen;readable file&period;
| xref:wallet/EncryptSecret.adoc[`EncryptSecret`] 
| Encrypts a secret with the master key using the given IV&period;
| xref:wallet/EnsureUniqueWalletName.adoc[`EnsureUniqueWalletName`] 
| Ensures that a wallet name is specified across the endpoint and wallet&lowbar;name&period; Throws `RPC&lowbar;INVALID&lowbar;PARAMETER` if none or different wallet names are specified&period;
| xref:wallet/EnsureWalletContext.adoc[`EnsureWalletContext`] 
| Retrieves the WalletContext stored in an RPC context, throwing if absent&period;
| xref:wallet/EnsureWalletIsUnlocked.adoc[`EnsureWalletIsUnlocked`] 
| Throws an RPC error if the wallet is locked&period;
| xref:wallet/ExportDescriptors.adoc[`ExportDescriptors`] 
| Export the descriptors from a wallet so that they can be imported elsewhere
| xref:wallet/ExportWatchOnlyWallet.adoc[`ExportWatchOnlyWallet`] 
| Make a new watchonly wallet file containing the public descriptors from this wallet The exported watchonly wallet file will be named and placed at the path specified in &apos;destination&apos;
| xref:wallet/FetchSelectedInputs.adoc[`FetchSelectedInputs`] 
| Fetch and validate coin control selected inputs&period; Coins could be internal (from the wallet) or external&period;
| xref:wallet/FindNonChangeParentOutput.adoc[`FindNonChangeParentOutput`] 
| Find non&hyphen;change parent output&period;
| xref:wallet/FundTransaction.adoc[`FundTransaction`] 
| Insert additional inputs into the transaction by calling CreateTransaction()&semi;
| xref:wallet/GenerateChangeTarget.adoc[`GenerateChangeTarget`] 
| Choose a random change target for each transaction to make it harder to fingerprint the Core wallet based on the change output values of transactions it creates&period; Change target covers at least change fees and adds a random value on top of it&period; The random value is between 50ksat and min(2 &ast; payment&lowbar;value, 1milsat) When payment&lowbar;value &lt;&equals; 25ksat, the value is just 50ksat&period;
| xref:wallet/GenerateWalletDescriptor.adoc[`GenerateWalletDescriptor`] 
| Builds a new wallet descriptor for the given key and output type&period;
| xref:wallet/GetAddressBalances.adoc[`GetAddressBalances`] 
| Returns the confirmed balance held at each of the wallet&apos;s addresses&period;
| xref:wallet/GetAddressGroupings.adoc[`GetAddressGroupings`] 
| Groups addresses that are believed to share a common owner&period;
| xref:wallet/GetAlgorithmName.adoc[`GetAlgorithmName`] 
| Return the human&hyphen;readable name of a selection algorithm&period;
| xref:wallet/GetAvoidReuseFlag.adoc[`GetAvoidReuseFlag`] 
| Resolves the effective avoid&hyphen;reuse flag from a request parameter&period;
| xref:wallet/GetBalance.adoc[`GetBalance`] 
| Computes the wallet&apos;s balance broken down by category&period;
| xref:wallet/GetDefaultWallet.adoc[`GetDefaultWallet`] 
| Return the default wallet and report how many wallets are loaded&period;
| xref:wallet/GetDiscardRate.adoc[`GetDiscardRate`] 
| Return the maximum feerate for discarding change&period;
| xref:wallet/GetMinimumFee.adoc[`GetMinimumFee`] 
| Return the minimum fee for this size given a fee rate result&period;
| xref:wallet/GetMinimumFeeRate.adoc[`GetMinimumFeeRate`] 
| Estimate the minimum fee rate considering user set parameters and the required fee
| xref:wallet/GetRequiredFee.adoc[`GetRequiredFee`] 
| Return the minimum required absolute fee for this size based on the required fee rate
| xref:wallet/GetRequiredFeeRate.adoc[`GetRequiredFeeRate`] 
| Return the minimum required feerate taking into account the minimum relay feerate and user set minimum transaction feerate
| xref:wallet/GetWallet.adoc[`GetWallet`] 
| Look up a loaded wallet by name&period;
| xref:wallet/GetWalletDir.adoc[`GetWalletDir`] 
| Get the path of the wallet directory&period;
| xref:wallet/GetWalletForJSONRPCRequest.adoc[`GetWalletForJSONRPCRequest`] 
| Figures out what wallet, if any, to use for a JSONRPCRequest&period;
| xref:wallet/GetWalletNameFromJSONRPCRequest.adoc[`GetWalletNameFromJSONRPCRequest`] 
| Extracts the wallet name encoded in a JSON&hyphen;RPC request endpoint, if any&period;
| xref:wallet/GetWalletPath.adoc[`GetWalletPath`] 
| Determine the path that the wallet is stored in
| xref:wallet/GetWalletRPCCommands.adoc[`GetWalletRPCCommands`] 
| Returns the RPC commands provided by the wallet component&period;
| xref:wallet/GetWallets.adoc[`GetWallets`] 
| Return all wallets currently loaded in the context&period;
| xref:wallet/GroupOutputs.adoc[`GroupOutputs`] 
| Group coins by the provided filters&period;
| xref:wallet/HandleLoadWallet.adoc[`HandleLoadWallet`] 
| Register a callback invoked whenever a wallet is loaded&period;
| xref:wallet/HandleWalletError.adoc[`HandleWalletError`] 
| Translates a wallet loading result into the appropriate RPC error&period;
| xref:wallet/HasLegacyRecords-0e.adoc[`HasLegacyRecords`] 
| `HasLegacyRecords` overloads
| xref:wallet/InputIsMine.adoc[`InputIsMine`] 
| Returns whether the output spent by an input belongs to the wallet&period;
| xref:wallet/IsBDBFile.adoc[`IsBDBFile`] 
| Returns whether the file at the path is a Berkeley DB file&period;
| xref:wallet/IsSQLiteFile.adoc[`IsSQLiteFile`] 
| Returns whether the file at the path is a SQLite file&period;
| xref:wallet/KnapsackSolver.adoc[`KnapsackSolver`] 
| Select coins using the original Knapsack approximation, used as a fallback&period;
| xref:wallet/LabelFromValue.adoc[`LabelFromValue`] 
| Validates and extracts an address label from an RPC value&period;
| xref:wallet/ListCoins.adoc[`ListCoins`] 
| Return list of available coins and locked coins grouped by non&hyphen;change output address&period;
| xref:wallet/ListDatabases.adoc[`ListDatabases`] 
| Recursively list database paths in directory&period;
| xref:wallet/LoadCryptedKey.adoc[`LoadCryptedKey`] 
| Loads an encrypted key from a database record into the wallet&period;
| xref:wallet/LoadEncryptionKey.adoc[`LoadEncryptionKey`] 
| Loads a master encryption key from a database record into the wallet&period;
| xref:wallet/LoadHDChain.adoc[`LoadHDChain`] 
| Loads HD chain data from a database record into the wallet&period;
| xref:wallet/LoadKey.adoc[`LoadKey`] 
| Loads an unencrypted key from a database record into the wallet&period;
| xref:wallet/LoadWallet.adoc[`LoadWallet`] 
| Load an existing wallet from disk into the context&period;
| xref:wallet/LoadWallets.adoc[`LoadWallets`] 
| Load wallet databases&period;
| xref:wallet/LogDBInfo.adoc[`LogDBInfo`] 
| Logs information about the database, including available engines, features, and other capabilities&period;
| xref:wallet/MakeBerkeleyRODatabase.adoc[`MakeBerkeleyRODatabase`] 
| Return object giving access to Berkeley Read Only database at specified path&period;
| xref:wallet/MakeDatabase.adoc[`MakeDatabase`] 
| Creates or opens a wallet database at the given path&period;
| xref:wallet/MakeInMemoryWalletDatabase.adoc[`MakeInMemoryWalletDatabase`] 
| Create a new in&hyphen;memory wallet database&period;
| xref:wallet/MakeSQLiteDatabase.adoc[`MakeSQLiteDatabase`] 
| Open or create a SQLite wallet database at the given path&period;
| xref:wallet/MakeWalletDatabase.adoc[`MakeWalletDatabase`] 
| Open the database backend for a wallet&period;
| xref:wallet/MaybeResendWalletTxs.adoc[`MaybeResendWalletTxs`] 
| Called periodically by the schedule thread&period; Prompts individual wallets to resend their transactions&period; Actual rebroadcast schedule is managed by the wallets themselves&period;
| xref:wallet/MigrateLegacyToDescriptor-08.adoc[`MigrateLegacyToDescriptor`] 
| `MigrateLegacyToDescriptor` overloads
| xref:wallet/NotifyWalletLoaded.adoc[`NotifyWalletLoaded`] 
| Fire the load&hyphen;wallet callbacks for a newly loaded wallet&period;
| xref:wallet/OutputGetChange.adoc[`OutputGetChange`] 
| Returns the change amount an output contributes&period;
| xref:wallet/OutputGetCredit.adoc[`OutputGetCredit`] 
| Returns the credit an output contributes if it belongs to the wallet&period;
| xref:wallet/OutputIsChange.adoc[`OutputIsChange`] 
| Returns whether an output is a change output of the wallet&period;
| xref:wallet/PurposeFromString.adoc[`PurposeFromString`] 
| Parse an address purpose from its serialized string form&period;
| xref:wallet/PurposeToString.adoc[`PurposeToString`] 
| Convert an address purpose to its serialized string form&period;
| xref:wallet/PushParentDescriptors.adoc[`PushParentDescriptors`] 
| Fetch parent descriptors of this scriptPubKey&period;
| xref:wallet/ReadDatabaseArgs.adoc[`ReadDatabaseArgs`] 
| Fills database options from command&hyphen;line arguments&period;
| xref:wallet/RemoveWallet-07.adoc[`RemoveWallet`] 
| Remove a wallet from the wallet context and optionally update its load&hyphen;on&hyphen;startup setting&period;
| xref:wallet/RemoveWalletSetting.adoc[`RemoveWalletSetting`] 
| Remove wallet name from persistent configuration so it will not be loaded on startup&period;
| xref:wallet/RestoreWallet.adoc[`RestoreWallet`] 
| Restore a wallet from a backup file&period;
| xref:wallet/RunWithinTxn.adoc[`RunWithinTxn`] 
| Executes the provided function &apos;func&apos; within a database transaction context&period;
| xref:wallet/SQLiteDataFile.adoc[`SQLiteDataFile`] 
| Returns the path to the SQLite data file for a wallet path&period;
| xref:wallet/SQLiteDatabaseVersion.adoc[`SQLiteDatabaseVersion`] 
| Return the version of the SQLite library in use&period;
| xref:wallet/ScriptIsChange.adoc[`ScriptIsChange`] 
| Returns whether a script is a change output of the wallet&period;
| xref:wallet/SelectCoins.adoc[`SelectCoins`] 
| Select all coins from coin&lowbar;control, and if coin&lowbar;control &apos;m&lowbar;allow&lowbar;other&lowbar;inputs&equals;true&apos;, call &apos;AutomaticCoinSelection&apos; to select a set of coins such that nTargetValue &hyphen; pre&lowbar;set&lowbar;inputs&period;total&lowbar;amount is met&period;
| xref:wallet/SelectCoinsBnB.adoc[`SelectCoinsBnB`] 
| Select coins using the Branch and Bound algorithm to find a changeless solution&period;
| xref:wallet/SelectCoinsSRD.adoc[`SelectCoinsSRD`] 
| Select coins by Single Random Draw (SRD)&period; SRD selects eligible OutputGroups from a shuffled ordering until the effective value of the input set suffices to create the recipient outputs and a change output with an amount of at least CHANGE&lowbar;LOWER&period; While the maximum selection weight is exceeded during selection, the OutputGroup with the lowest effective value is dropped from the selection before additional OutputGroups are selected&period; Due to this greedy approach, SRD can fail to discover possible solutions in pathological cases&period;
| xref:wallet/StartWallets.adoc[`StartWallets`] 
| Complete startup of wallets&period;
| xref:wallet/TxGetChange.adoc[`TxGetChange`] 
| Returns the total change amount of a transaction&period;
| xref:wallet/TxGetCredit.adoc[`TxGetCredit`] 
| Returns the total credit of a transaction&apos;s outputs owned by the wallet&period;
| xref:wallet/TxStateString.adoc[`TxStateString`] 
| Return TxState or SyncTxState as a string for logging or debugging&period;
| xref:wallet/UnloadWallets.adoc[`UnloadWallets`] 
| Stop and unload all wallets held by the context&period;
| xref:wallet/VerifyWallets.adoc[`VerifyWallets`] 
| Responsible for reading and validating the &hyphen;wallet arguments and verifying the wallet database&period;
| xref:wallet/WaitForDeleteWallet.adoc[`WaitForDeleteWallet`] 
| Explicitly delete the wallet&period; Blocks the current thread until the wallet is destructed&period;
| xref:wallet/operator_lt-06.adoc[`operator&lt;`] 
| Less&hyphen;than operators
|===


=== Variables

[cols="1,4"]
|===
| Name| Description
| xref:wallet/CHANGE_LOWER.adoc[`CHANGE&lowbar;LOWER`] 
| lower bound for randomly&hyphen;chosen target change amount
| xref:wallet/CHANGE_UPPER.adoc[`CHANGE&lowbar;UPPER`] 
| upper bound for randomly&hyphen;chosen target change amount
| xref:wallet/DEFAULT_ADDRESS_TYPE.adoc[`DEFAULT&lowbar;ADDRESS&lowbar;TYPE`] 
| Default for &hyphen;addresstype
| xref:wallet/DEFAULT_AVOIDPARTIALSPENDS.adoc[`DEFAULT&lowbar;AVOIDPARTIALSPENDS`] 
| Default for &hyphen;avoidpartialspends
| xref:wallet/DEFAULT_CONSOLIDATE_FEERATE.adoc[`DEFAULT&lowbar;CONSOLIDATE&lowbar;FEERATE`] 
| &hyphen;consolidatefeerate default
| xref:wallet/DEFAULT_DISABLE_WALLET.adoc[`DEFAULT&lowbar;DISABLE&lowbar;WALLET`] 
| &hyphen;disablewallet default
| xref:wallet/DEFAULT_DISCARD_FEE.adoc[`DEFAULT&lowbar;DISCARD&lowbar;FEE`] 
| &hyphen;discardfee default
| xref:wallet/DEFAULT_FALLBACK_FEE.adoc[`DEFAULT&lowbar;FALLBACK&lowbar;FEE`] 
| &hyphen;fallbackfee default
| xref:wallet/DEFAULT_KEYPOOL_SIZE.adoc[`DEFAULT&lowbar;KEYPOOL&lowbar;SIZE`] 
| Default for &hyphen;keypool
| xref:wallet/DEFAULT_MAX_AVOIDPARTIALSPEND_FEE.adoc[`DEFAULT&lowbar;MAX&lowbar;AVOIDPARTIALSPEND&lowbar;FEE`] 
| maximum fee increase allowed to do partial spend avoidance, even for nodes with this feature disabled by default
| xref:wallet/DEFAULT_MAX_DEPTH.adoc[`DEFAULT&lowbar;MAX&lowbar;DEPTH`] 
| Default maximum chain depth for a coin to be considered available&period;
| xref:wallet/DEFAULT_MIN_DEPTH.adoc[`DEFAULT&lowbar;MIN&lowbar;DEPTH`] 
| Default minimum chain depth for a coin to be considered available&period;
| xref:wallet/DEFAULT_SPEND_ZEROCONF_CHANGE.adoc[`DEFAULT&lowbar;SPEND&lowbar;ZEROCONF&lowbar;CHANGE`] 
| Default for &hyphen;spendzeroconfchange
| xref:wallet/DEFAULT_TRANSACTION_MAXFEE.adoc[`DEFAULT&lowbar;TRANSACTION&lowbar;MAXFEE`] 
| &hyphen;maxtxfee default
| xref:wallet/DEFAULT_TRANSACTION_MINFEE.adoc[`DEFAULT&lowbar;TRANSACTION&lowbar;MINFEE`] 
| &hyphen;mintxfee default
| xref:wallet/DEFAULT_TX_CONFIRM_TARGET.adoc[`DEFAULT&lowbar;TX&lowbar;CONFIRM&lowbar;TARGET`] 
| &hyphen;txconfirmtarget default
| xref:wallet/DEFAULT_WALLETBROADCAST.adoc[`DEFAULT&lowbar;WALLETBROADCAST`] 
| &hyphen;walletbroadcast default
| xref:wallet/DEFAULT_WALLETCROSSCHAIN.adoc[`DEFAULT&lowbar;WALLETCROSSCHAIN`] 
| &hyphen;walletcrosschain default
| xref:wallet/DEFAULT_WALLET_RBF.adoc[`DEFAULT&lowbar;WALLET&lowbar;RBF`] 
| &hyphen;walletrbf default
| xref:wallet/DEFAULT_WALLET_REJECT_LONG_CHAINS.adoc[`DEFAULT&lowbar;WALLET&lowbar;REJECT&lowbar;LONG&lowbar;CHAINS`] 
| Default for &hyphen;walletrejectlongchains
| xref:wallet/DEFAULT_WALLET_TX_VERSION.adoc[`DEFAULT&lowbar;WALLET&lowbar;TX&lowbar;VERSION`] 
| Default transaction version used when building wallet transactions&period;
| xref:wallet/DUMMY_NESTED_P2WPKH_INPUT_SIZE.adoc[`DUMMY&lowbar;NESTED&lowbar;P2WPKH&lowbar;INPUT&lowbar;SIZE`] 
| Pre&hyphen;calculated constants for input size estimation in _virtual size_
| xref:wallet/HELP_REQUIRING_PASSPHRASE.adoc[`HELP&lowbar;REQUIRING&lowbar;PASSPHRASE`] 
| Help text appended to RPC methods that require the wallet passphrase&period;
| xref:wallet/HIGH_APS_FEE.adoc[`HIGH&lowbar;APS&lowbar;FEE`] 
| discourage APS fee higher than this amount
| xref:wallet/HIGH_MAX_TX_FEE.adoc[`HIGH&lowbar;MAX&lowbar;TX&lowbar;FEE`] 
| &hyphen;maxtxfee will warn if called with a higher fee than this amount (in satoshis)
| xref:wallet/HIGH_TX_FEE_PER_KB.adoc[`HIGH&lowbar;TX&lowbar;FEE&lowbar;PER&lowbar;KB`] 
| Discourage users to set fees higher than this amount (in satoshis) per kB
| xref:wallet/KNOWN_WALLET_FLAGS.adoc[`KNOWN&lowbar;WALLET&lowbar;FLAGS`] 
| Bitmask of all wallet flags recognized by this version&period;
| xref:wallet/LEGACY_OUTPUT_TYPES.adoc[`LEGACY&lowbar;OUTPUT&lowbar;TYPES`] 
| Output types associated with LegacyDataSPKM&period;
| xref:wallet/MUTABLE_WALLET_FLAGS.adoc[`MUTABLE&lowbar;WALLET&lowbar;FLAGS`] 
| Bitmask of wallet flags that may be changed after wallet creation&period;
| xref:wallet/RESULT_LAST_PROCESSED_BLOCK.adoc[`RESULT&lowbar;LAST&lowbar;PROCESSED&lowbar;BLOCK`] 
| RPC result describing the block a piece of wallet information was generated on&period;
| xref:wallet/STRING_TO_WALLET_FLAG.adoc[`STRING&lowbar;TO&lowbar;WALLET&lowbar;FLAG`] 
| Maps each wallet flag string name back to its flag value&period;
| xref:wallet/UNKNOWN_TIME.adoc[`UNKNOWN&lowbar;TIME`] 
| Constant representing an unknown spkm creation time
| xref:wallet/WALLET_CRYPTO_IV_SIZE.adoc[`WALLET&lowbar;CRYPTO&lowbar;IV&lowbar;SIZE`] 
| Size in bytes of the AES initialization vector&period;
| xref:wallet/WALLET_CRYPTO_KEY_SIZE.adoc[`WALLET&lowbar;CRYPTO&lowbar;KEY&lowbar;SIZE`] 
| Size in bytes of the AES&hyphen;256 encryption key derived for the wallet&period;
| xref:wallet/WALLET_CRYPTO_SALT_SIZE.adoc[`WALLET&lowbar;CRYPTO&lowbar;SALT&lowbar;SIZE`] 
| Size in bytes of the salt mixed into the passphrase during key derivation&period;
| xref:wallet/WALLET_FLAG_TO_STRING.adoc[`WALLET&lowbar;FLAG&lowbar;TO&lowbar;STRING`] 
| Maps each wallet flag to its serialized string name&period;
| xref:wallet/WALLET_INCREMENTAL_RELAY_FEE.adoc[`WALLET&lowbar;INCREMENTAL&lowbar;RELAY&lowbar;FEE`] 
| minimum recommended increment for replacement txs
|===


== xref:wallet/DBKeys.adoc[wallet::DBKeys] namespace

Record type prefixes used as keys in the wallet database&period;

=== Variables

[cols="1,4"]
|===
| Name| Description
| xref:wallet/DBKeys/ACENTRY.adoc[`ACENTRY`] 
| Legacy accounting entry record&period;
| xref:wallet/DBKeys/ACTIVEEXTERNALSPK.adoc[`ACTIVEEXTERNALSPK`] 
| Active external ScriptPubKeyMan record&period;
| xref:wallet/DBKeys/ACTIVEINTERNALSPK.adoc[`ACTIVEINTERNALSPK`] 
| Active internal ScriptPubKeyMan record&period;
| xref:wallet/DBKeys/BESTBLOCK.adoc[`BESTBLOCK`] 
| Best block locator scanned by the wallet&period;
| xref:wallet/DBKeys/BESTBLOCK_NOMERKLE.adoc[`BESTBLOCK&lowbar;NOMERKLE`] 
| Best block locator without a merkle branch&period;
| xref:wallet/DBKeys/CRYPTED_KEY.adoc[`CRYPTED&lowbar;KEY`] 
| Encrypted private key record&period;
| xref:wallet/DBKeys/CSCRIPT.adoc[`CSCRIPT`] 
| Watch&hyphen;only script record&period;
| xref:wallet/DBKeys/DEFAULTKEY.adoc[`DEFAULTKEY`] 
| Legacy default key record&period;
| xref:wallet/DBKeys/DESTDATA.adoc[`DESTDATA`] 
| Destination metadata record&period;
| xref:wallet/DBKeys/FLAGS.adoc[`FLAGS`] 
| Wallet flags record&period;
| xref:wallet/DBKeys/HDCHAIN.adoc[`HDCHAIN`] 
| HD chain data record&period;
| xref:wallet/DBKeys/KEY.adoc[`KEY`] 
| Unencrypted private key record&period;
| xref:wallet/DBKeys/KEYMETA.adoc[`KEYMETA`] 
| Key metadata record&period;
| xref:wallet/DBKeys/LEGACY_TYPES.adoc[`LEGACY&lowbar;TYPES`] 
| Keys in this set pertain only to legacy wallets and are removed during migration to descriptors&period;
| xref:wallet/DBKeys/LOCKED_UTXO.adoc[`LOCKED&lowbar;UTXO`] 
| Locked UTXO record&period;
| xref:wallet/DBKeys/MASTER_KEY.adoc[`MASTER&lowbar;KEY`] 
| Master key record used to encrypt other keys&period;
| xref:wallet/DBKeys/MINVERSION.adoc[`MINVERSION`] 
| Minimum client version required to read the wallet&period;
| xref:wallet/DBKeys/NAME.adoc[`NAME`] 
| Address book label record&period;
| xref:wallet/DBKeys/OLD_KEY.adoc[`OLD&lowbar;KEY`] 
| Legacy wallet key record&period;
| xref:wallet/DBKeys/ORDERPOSNEXT.adoc[`ORDERPOSNEXT`] 
| Next transaction ordering position record&period;
| xref:wallet/DBKeys/POOL.adoc[`POOL`] 
| Key pool entry record&period;
| xref:wallet/DBKeys/PURPOSE.adoc[`PURPOSE`] 
| Address purpose record&period;
| xref:wallet/DBKeys/SETTINGS.adoc[`SETTINGS`] 
| Wallet settings record&period;
| xref:wallet/DBKeys/TX.adoc[`TX`] 
| Wallet transaction record&period;
| xref:wallet/DBKeys/VERSION.adoc[`VERSION`] 
| Wallet format version record&period;
| xref:wallet/DBKeys/WALLETDESCRIPTOR.adoc[`WALLETDESCRIPTOR`] 
| Wallet descriptor record&period;
| xref:wallet/DBKeys/WALLETDESCRIPTORCKEY.adoc[`WALLETDESCRIPTORCKEY`] 
| Encrypted descriptor private key record&period;
| xref:wallet/DBKeys/WALLETDESCRIPTORKEY.adoc[`WALLETDESCRIPTORKEY`] 
| Descriptor private key record&period;
| xref:wallet/DBKeys/WATCHMETA.adoc[`WATCHMETA`] 
| Watch&hyphen;only key metadata record&period;
| xref:wallet/DBKeys/WATCHS.adoc[`WATCHS`] 
| Watch&hyphen;only script record&period;
| xref:wallet/DBKeys/WTX_VARIANT.adoc[`WTX&lowbar;VARIANT`] 
| Wallet transaction variant record&period;
|===


== xref:wallet/WalletTool.adoc[wallet::WalletTool] namespace

Command&hyphen;line wallet tool commands&period;

=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:wallet/WalletTool/ExecuteWalletToolFunc.adoc[`ExecuteWalletToolFunc`] 
| Runs a wallet&hyphen;tool command such as create, info, or dump&period;
|===


== xref:wallet/feebumper.adoc[wallet::feebumper] namespace

Helpers for replacing a wallet transaction with a higher&hyphen;fee version&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:wallet/feebumper/SignatureWeightChecker.adoc[`SignatureWeightChecker`] 
| Signature checker that records the weight of every valid signature it verifies&period;
| xref:wallet/feebumper/SignatureWeights.adoc[`SignatureWeights`] 
| Accumulates signature counts and weights to estimate transaction size&period;
|===


=== Enums

[cols="1,4"]
|===
| Name| Description
| xref:wallet/feebumper/Result.adoc[`Result`] 
| Outcome of a fee&hyphen;bumping operation&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:wallet/feebumper/CommitTransaction.adoc[`CommitTransaction`] 
| Commit the bumpfee transaction&period;
| xref:wallet/feebumper/CreateRateBumpTransaction.adoc[`CreateRateBumpTransaction`] 
| Create bumpfee transaction based on feerate estimates&period;
| xref:wallet/feebumper/SignTransaction.adoc[`SignTransaction`] 
| Sign the new transaction,
| xref:wallet/feebumper/TransactionCanBeBumped.adoc[`TransactionCanBeBumped`] 
| Return whether transaction can be bumped&period;
|===


== xref:wallet/wallet_crypto_tests.adoc[wallet::wallet&lowbar;crypto&lowbar;tests] namespace

Test&hyphen;only helpers for exercising the wallet crypto internals&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:wallet/wallet_crypto_tests/TestCrypter.adoc[`TestCrypter`] 
| Test fixture granting access to CCrypter internals&period;
|===



[.small]#Created with https://www.mrdocs.com[MrDocs]#
