 |
Bitcoin Core
28.1.0
P2P Digital Currency
|
|
Bitcoin Core
28.1.0
P2P Digital Currency
|
| Cipc::capnp::messages::Echo::DestroyParams::_capnpPrivate | |
| Cipc::capnp::messages::Echo::DestroyResults::_capnpPrivate | |
| Cipc::capnp::messages::Echo::EchoParams::_capnpPrivate | |
| Cipc::capnp::messages::Echo::_capnpPrivate | |
| Cipc::capnp::messages::Echo::EchoResults::_capnpPrivate | |
| Cipc::capnp::messages::Init::_capnpPrivate | |
| Cgen::FooInterface::_capnpPrivate | |
| Cgen::FooInterface::AddParams::_capnpPrivate | |
| Cgen::FooInterface::AddResults::_capnpPrivate | |
| Cgen::FooInterface::PassOutPointParams::_capnpPrivate | |
| Cgen::FooInterface::PassOutPointResults::_capnpPrivate | |
| Cgen::FooInterface::PassUniValueParams::_capnpPrivate | |
| Cgen::FooInterface::PassUniValueResults::_capnpPrivate | |
| Cipc::capnp::messages::Init::ConstructParams::_capnpPrivate | |
| Cipc::capnp::messages::Init::ConstructResults::_capnpPrivate | |
| Cipc::capnp::messages::Init::MakeEchoParams::_capnpPrivate | |
| Cipc::capnp::messages::Init::MakeEchoResults::_capnpPrivate | |
| Cmp::ipc_test_fields::A | |
| ▶CAbstractThresholdConditionChecker | Abstract class that implements BIP9-style threshold logic, and caches results |
| CActionSerialize | Support for all macros providing or using the ser_action parameter of the SerializationOps method |
| CActionUnserialize | |
| CAddedNodeInfo | |
| CAddedNodeParams | |
| Cgen::FooInterface::AddParams | |
| Cwallet::CWallet::AddrBookFilter | |
| CAddressPosition | Location information for an address in AddrMan |
| CAddressTableEntry | |
| CAddressTableEntryLessThan | |
| CAddressTablePriv | |
| Cgen::FooInterface::AddResults | |
| ▶CAddrMan | Stochastic address manager |
| CAddrManImpl | |
| CAEADChaCha20Poly1305 | The AEAD_CHACHA20_POLY1305 authenticated encryption algorithm from RFC8439 section 2.8 |
| CAES128_ctx | |
| CAES192_ctx | |
| CAES256_ctx | |
| CAES256CBCDecrypt | |
| CAES256CBCEncrypt | |
| CAES256Decrypt | A decryption class for AES-256 |
| CAES256Encrypt | An encryption class for AES-256 |
| CAES_state | |
| CAmountCompression | |
| Cancestor_score | |
| Ccluster_linearize::AncestorCandidateFinder< SetType > | Class encapsulating the state needed to find the best remaining ancestor set |
| Cnode::AncestorFeerateComparator | |
| ▶CArena | |
| CArgsManager::Arg | |
| Cmp::ipc_test_fields::Arg | |
| Cbenchmark::Args | |
| ▶CArgsManager | |
| Csubprocess::detail::ArgumentDeducer | |
| CAssumeutxoData | Holds configuration for use during UTXO snapshot load and validation |
| CAutoFile | Non-refcounted RAII wrapper for FILE* |
| CAvailable | |
| Cmp::ipc_test_fields::B | |
| Cwallet::Balance | |
| CBanMan | |
| CBannedNodeLessThan | |
| CBanTablePriv | |
| ▶CBase | (Un)serialize a number as raw byte or 2 hexadecimal chars |
| Cbase_blob< BITS > | Template base class for fixed-sized opaque blobs |
| ▶Cbase_blob< 160 > | |
| ▶Cbase_blob< 256 > | |
| Cbase_uint< BITS > | Template base class for unsigned big integers |
| ▶Cbase_uint< 256 > | |
| CBaseFormat | |
| CBaseHash< HashType > | |
| ▶CBaseHash< uint160 > | |
| ▶CBaseHash< uint256 > | |
| ▶CBaseRequestHandler | Class that handles the conversion from a command-line to a JSON-RPC request, as well as converting back to a JSON object that can be shown as result |
| ▶CBaseSignatureChecker | |
| ▶CBaseSignatureCreator | Interface for signature creators |
| ▶CBasicTestingSetup | Basic testing setup |
| Cankerl::nanobench::Bench | Main entry point to nanobench's benchmarking facility |
| Cbench_data | |
| Cbench_ecdh_data | |
| Cbench_ellswift_data | |
| Cbench_inv | |
| Cbench_recover_data | |
| Cbench_schnorrsig_data | |
| Cbenchmark::BenchRunner | |
| Cwallet::BerkeleyEnvironment | |
| Cankerl::nanobench::BigO | |
| Cbilingual_str | Bilingual messages: |
| CBIP324Cipher | The BIP324 packet cipher, encapsulating its key derivation, stream cipher, and AEAD |
| CConsensus::BIP9Deployment | Struct for each individual consensus rule change using BIP9 |
| CBIP9Stats | Display status of an in-progress BIP9 softfork |
| CCuckooCache::bit_packed_atomic_flags | bit_packed_atomic_flags implements a container for garbage collection flags that is only thread unsafe on calls to setup |
| Cbitdeque< BITS_PER_WORD > | Class that mimics std::deque<bool>, but with std::vector<bool>'s bit packing |
| CBitReader | |
| CBitsInt< I, BITS > | |
| CBitStreamReader< IStream > | |
| CBitStreamWriter< OStream > | |
| CBitWriter | |
| Cinterfaces::BlockAndHeaderTipInfo | Block and header tip information |
| Cnode::BlockAssembler | Generate a new block, without valid proof-of-work |
| ▶Cnode::BlockCreateOptions | |
| Cnode::BlockfileCursor | |
| CBlockFilter | Complete block filter struct as defined in BIP 157 |
| CBlockFiltersScanReserver | |
| CBlockHasher | |
| Cinterfaces::BlockInfo | Block data sent with blockConnected, blockDisconnected notifications |
| Cinterfaces::BlockKey | Hash/height pair to help track and identify blocks |
| Cnode::BlockManager | Maintains a tree of blocks (stored in m_block_index) which is consulted to determine where the most-work tip is |
| Ckernel::BlockManagerOpts | An options struct for BlockManager, more ergonomically referred to as BlockManager::Options due to the using-declaration in BlockManager |
| Cinterfaces::BlockTip | Block tip (could be a header or not, depends on the subscribed signal) |
| CBlockTransactions | |
| CBlockTransactionsRequest | |
| Csubprocess::Buffer | |
| CBufferedFile | Wrapper around an AutoFile& that implements a ring buffer to deserialize from |
| CBCLog::Logger::BufferedLog | |
| Cipc::capnp::messages::Init::ConstructParams::Builder | |
| Cipc::capnp::messages::Init::ConstructResults::Builder | |
| Cipc::capnp::messages::Init::MakeEchoParams::Builder | |
| Cipc::capnp::messages::Init::MakeEchoResults::Builder | |
| Cipc::capnp::messages::Echo::DestroyParams::Builder | |
| Cipc::capnp::messages::Echo::DestroyResults::Builder | |
| Cipc::capnp::messages::Echo::EchoParams::Builder | |
| Cipc::capnp::messages::Echo::EchoResults::Builder | |
| Cgen::FooInterface::AddParams::Builder | |
| Cgen::FooInterface::AddResults::Builder | |
| Cgen::FooInterface::PassOutPointParams::Builder | |
| Cgen::FooInterface::PassOutPointResults::Builder | |
| Cgen::FooInterface::PassUniValueParams::Builder | |
| Cgen::FooInterface::PassUniValueResults::Builder | |
| Cwallet::BytePrefix | |
| CByteVectorHash | Implementation of Hash named requirement for types that internally store a byte array |
| Cwallet::CachableAmount | Cachable amount subdivided into watchonly and spendable parts |
| CCuckooCache::cache< Element, Hash > | cache implements a cache with properties similar to a cuckoo-set |
| CCuckooCache::cache< uint256, SignatureCacheHasher > | |
| CCConnman::CachedAddrResponse | Cache responses to addr requests to minimize privacy leak |
| Cnode::CacheSizes | |
| Cwallet::CAddressBookData | Address book data |
| CCAppNapInhibitor::CAppNapImpl | |
| CCAppNapInhibitor | |
| CCBanDB | Access to the banlist database (banlist.json) |
| CCBanEntry | |
| CCBaseChainParams | CBaseChainParams defines the base parameters (shared between bitcoin-cli and bitcoind) of a given instance of the Bitcoin system |
| CCBlockFileInfo | |
| ▶CCBlockHeader | Nodes collect new transactions into a block, hash them into a hash tree, and scan through nonce values to make the block's hash satisfy proof-of-work requirements |
| CCBlockHeaderAndShortTxIDs | |
| ▶CCBlockIndex | 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 |
| Cnode::CBlockIndexHeightOnlyComparator | |
| Cnode::CBlockIndexWorkComparator | |
| CCBlockLocator | Describes a place in the block chain to another node such that if the other node doesn't have the same branch, it can find a recent common trunk |
| Cnode::CBlockTemplate | |
| CCBlockUndo | Undo information for a CBlock |
| CCBloomFilter | BloomFilter is a probabilistic filter which SPV clients provide so that we can filter the transactions we send them |
| CCChain | An in-memory indexed chain of blocks |
| ▶CCChainParams | CChainParams defines various tweakable parameters of a given instance of the Bitcoin system |
| CCCheckpointData | |
| CCCheckQueue< T > | Queue for verifications that have to be performed |
| CCCheckQueue< CScriptCheck > | |
| CCCheckQueueControl< T > | RAII-style controller object for a CCheckQueue that guarantees the passed queue is finished before continuing |
| CCClientUIInterface | Signals for UI communication |
| CCCoin | |
| Cwallet::CCoinControl | Coin Control Features |
| CCCoinsCacheEntry | A Coin in one level of the coins database caching hierarchy |
| Ckernel::CCoinsStats | |
| ▶CCCoinsView | Abstract view on the open txout dataset |
| ▶CCCoinsViewCursor | Cursor for iterating over CoinsView state |
| CCCombinedBan | |
| ▶CCConnman | |
| Cwallet::CCrypter | Encryption/decryption context with key information |
| CCDBBatch | Batch of changes queued to be written to a CDBWrapper |
| CCDBIterator | |
| ▶CCDBWrapper | |
| CCExtKey | |
| CCExtPubKey | |
| CCFeeRate | Fee rate in satoshis per kilovirtualbyte: CAmount / kvB |
| CChaCha20 | Unrestricted ChaCha20 cipher |
| CChaCha20Aligned | ChaCha20 cipher that only operates on multiples of 64 bytes |
| Cinterfaces::Chain | Interface giving clients (wallet processes, maybe other analysis tools in the future) ability to access to the chain state, receive notifications, estimate fees, and submit transactions |
| ▶Cinterfaces::ChainClient | Interface to let node manage chain clients (wallets, or maybe tools for monitoring and analysis in the future) |
| ▶CChainstate | Chainstate stores and provides an API to update our local knowledge of the current best chain |
| Cnode::ChainstateLoadOptions | |
| ▶CChainstateManager | Provides an interface for creating and interacting with one or two chainstates: an IBD chainstate generated by downloading blocks, and an optional snapshot chainstate loaded from a UTXO snapshot |
| Ckernel::ChainstateManagerOpts | An options struct for ChainstateManager, more ergonomically referred to as ChainstateManager::Options due to the using-declaration in ChainstateManager |
| CChainTxData | Holds various statistics on transactions within a chain |
| CCHash160 | A hasher class for Bitcoin's 160-bit hash (SHA-256 + RIPEMD-160) |
| CCHash256 | A hasher class for Bitcoin's 256-bit hash (double SHA-256) |
| Cwallet::CHDChain | |
| CCheckVarIntMode< Mode, I > | |
| Csubprocess::detail::Child | |
| CCHKDF_HMAC_SHA256_L32 | A rfc5869 HKDF implementation with HMAC_SHA256 and fixed key output length of 32 bytes (L=32) |
| CCHMAC_SHA256 | A hasher class for HMAC-SHA-256 |
| CCHMAC_SHA512 | A hasher class for HMAC-SHA-512 |
| CChronoFormatter< U, LOSSY > | |
| CCInv | Inv message data |
| CCKey | An encapsulated private key |
| Cwallet::CKeyMetadata | |
| Cwallet::CKeyPool | A key from a CWallet's keypool |
| ▶CClient | |
| Cwallet::CMasterKey | Private key encryption is done based on a CMasterKey, which holds a salt and random encryption key |
| CCMerkleBlock | Used to relay blocks as header + vector<merkle branch> to filtered nodes |
| Cwallet::CMerkleTx | Legacy class used for deserializing vtxPrev for backwards compatibility |
| CCMessageHeader | Message header |
| CCMutableTransaction | A mutable version of CTransaction |
| ▶CCNetAddr | Network address |
| CCNetCleanup | |
| CCNetMessage | Transport protocol agnostic message container |
| CCNode | Information about a peer |
| CCNodeCombinedStats | |
| CCNodeOptions | |
| CCNodeStateStats | |
| CCNodeStats | |
| CCNoDestination | |
| CCoin | A UTXO entry |
| Cwallet::CoinEligibilityFilter | Parameters for filtering which OutputGroups we may use in coin selection |
| Cwallet::CoinFilterParams | |
| Cwallet::CoinSelectionParams | Parameters for one iteration of Coin Selection |
| Cwallet::CoinsResult | COutputs available for spending, stored by OutputType |
| CCoinsViewCacheCursor | Cursor for iterating over the linked list of flagged entries in CCoinsViewCache |
| CCoinsViewOptions | User-controlled performance and debug options |
| CCoinsViews | A convenience class for constructing the CCoinsView* hierarchy used to facilitate access to the UTXO set |
| CCoinsViewScanReserver | |
| CCSVModelWriter::Column | |
| CArgsManager::Command | |
| Csubprocess::detail::Communication | |
| CCompactSizeFormatter< RangeCheck > | Formatter for integers in CompactSize format |
| CCompactSizeWriter | |
| CCompareBlocksByHeight | Comparison function for sorting the getchaintips heads |
| Cnode::CompareCTxMemPoolIter | Comparator for CTxMemPool::txiter objects |
| CCompareIteratorByHash | |
| CCompareNodeNetworkTime | Sort eviction candidates by network/localhost and connection uptime |
| Cnode::CompareTxIterByAncestorCount | |
| CCompareTxMemPoolEntryByAncestorFee | |
| CCompareTxMemPoolEntryByAncestorScore | Sort an entry by min(score/size of entry's tx, score/size with all ancestors) |
| CCompareTxMemPoolEntryByDescendantScore | Sort an entry by max(score/size of entry's tx, score/size with all descendants) |
| CCompareTxMemPoolEntryByEntryTime | |
| CCompareTxMemPoolEntryByScore | Sort by feerate of entry (fee/size) in descending order This is only used for transaction relay, so we use GetFee() instead of GetModifiedFee() to avoid leaking prioritization information via the sort order |
| CCompressedHeader | |
| Cankerl::nanobench::Config | |
| Ccommon::ConfigError | |
| Ci2p::Connection | An established connection with another peer |
| CConnectTrace | Used to track blocks whose transactions were applied to the UTXO state as a part of a single ActivateBestChainStep call |
| Cprevector< N, T, Size, Diff >::const_iterator | |
| Cprevector< N, T, Size, Diff >::const_reverse_iterator | |
| CConstevalStringLiteral | |
| Cipc::capnp::messages::Init::ConstructParams | |
| Cipc::capnp::messages::Init::ConstructResults | |
| Cmp::init_fields::Context | |
| ▶Cipc::Context | Context struct used to give IPC protocol implementations or implementation hooks access to application state, in case they need to run extra code that isn't needed within a single process, like code copying global state from an existing process to a new process when it's initialized, or code dealing with shared objects that are created or destroyed remotely |
| Ckernel::Context | Context struct holding the kernel library's logically global state, and passed to external libbitcoin_kernel functions which need access to this state |
| Cmp::echo_fields::Context | |
| Ctinyformat::detail::convertToInt< T, convertible > | |
| Ctinyformat::detail::convertToInt< T, true > | |
| CCOutPoint | An outpoint - a combination of a transaction hash and an index n into its vout |
| Cwallet::COutput | A UTXO under consideration for use in funding a new transaction |
| Cwallet::COutputEntry | |
| ▶CCPartialMerkleTree | Data structure that represents a partial merkle tree |
| CCPubKey | An encapsulated public key |
| Cwallet::CreatedTransactionResult | |
| Cwallet::CRecipient | |
| CCRIPEMD160 | A hasher class for RIPEMD-160 |
| CCRollingBloomFilter | RollingBloomFilter is a probabilistic "keep track of most recently inserted" set |
| CCRPCCommand | |
| CCRPCConvertParam | |
| CCRPCConvertTable | |
| CCRPCSignals | |
| CCRPCTable | RPC command dispatcher |
| CCScheduler | Simple class for background tasks that should be run periodically or once "after a while" |
| CCScriptCheck | Closure representing one script verification Note that this stores references to the spending transaction |
| CCScriptNum | |
| CCScriptNum10 | |
| CCScriptWitness | |
| CCSemaphore | An implementation of a semaphore |
| CCSemaphoreGrant | RAII-style semaphore lock |
| CCSerializedNetMsg | |
| ▶CCSerializeMethodsTestSingle | |
| CCServiceHash | |
| CCSHA1 | A hasher class for SHA1 |
| CCSHA256 | A hasher class for SHA-256 |
| CCSHA512 | A hasher class for SHA-512 |
| CCSipHasher | SipHash-2-4 |
| CCSubNet | |
| Cctaes_test | |
| CCThreadInterrupt | A helper class for interruptible sleeps |
| CCTransaction | The basic transaction that is broadcasted on the network and contained in blocks |
| CCTxIn | An input of a transaction |
| ▶CCTxMemPool | CTxMemPool stores valid-according-to-the-current-best-chain transactions that may be included in the next block |
| CCTxMemPoolEntry | CTxMemPoolEntry stores data about the corresponding transaction, as well as data about all in-mempool transactions that depend on the transaction ("descendant" transactions) |
| Cnode::CTxMemPoolModifiedEntry | |
| CCTxOut | An output of a transaction |
| CCTxUndo | Undo information for a CTransaction |
| CCUpdatedBlock | |
| CCustomUintFormatter< Bytes, BigEndian > | Serialization wrapper class for custom integers and enums |
| ▶CCValidationInterface | Implement this to subscribe to events generated in validation and mempool |
| CCVerifyDB | RAII wrapper for VerifyDB: Verify consistency of the block and coin databases |
| Cwallet::CWalletTx | A transaction with a bunch of additional info that only the owner cares about |
| ▶CCZMQAbstractNotifier | |
| ▶Cwallet::DatabaseBatch | RAII class that provides access to a WalletDatabase |
| ▶Cwallet::DatabaseCursor | |
| Cwallet::DatabaseOptions | |
| Cwallet::DataRecord | Class for data in the record directly |
| ▶CDataStream | Double ended buffer combining vector and stream-like interfaces |
| CDBOptions | User-controlled performance and debug options |
| CDBParams | Application-specific storage settings |
| CDebugLogHelper | |
| Cbech32::DecodeResult | |
| CDefaultFormatter | Default formatter |
| CCTxMemPool::delta_info | |
| Ccluster_linearize::DepGraph< SetType > | Data structure that holds a transaction graph's preprocessed data (fee, size, ancestors, descendants) |
| CDereferencingComparator< T > | |
| CDerivedAndBaseFormat | |
| Cdescendant_score | |
| CDescribeAddressVisitor | |
| Cwallet::DescribeWalletAddressVisitor | |
| ▶CDescriptor | Interface for parsed descriptor objects |
| CDescriptorCache | Cache for single descriptor's derived extended pubkeys |
| Cdeserialize_type | Dummy data type to identify deserializing constructors |
| Cipc::capnp::messages::Echo::DestroyParams | |
| Cipc::capnp::messages::Echo::DestroyResults | |
| CDifferenceFormatter | |
| Cprevector< N, T, Size, Diff >::direct_or_indirect | |
| CDisconnectedBlockTransactions | DisconnectedBlockTransactions |
| CECC_Context | RAII class initializing and deinitializing global state for elliptic curve support |
| Cinterfaces::Echo | Simple string echoing interface for testing |
| Cipc::capnp::messages::Echo | |
| Cmp::echo_fields::Echo | |
| Cipc::capnp::messages::Echo::EchoParams | |
| Cipc::capnp::messages::Echo::EchoResults | |
| Cecmult_multi_data | |
| CECRYPT_ctx | |
| Cellswift_decode_test | |
| Cellswift_xdh_test | |
| Cellswift_xswiftec_inv_test | |
| CEllSwiftPubKey | An ElligatorSwift-encoded public key |
| Ccluster_linearize::DepGraph< SetType >::Entry | Information about a single transaction |
| Centry_time | |
| CEpoch | Epoch: RAII-style guard for using epoch-based graph traversal algorithms |
| CSock::EqualSharedPtrSock | |
| Cutil::Error | |
| Csubprocess::error | |
| CEstimationResult | |
| CEstimatorBucket | |
| CSock::Events | Auxiliary requested/occurred events to wait for in WaitMany() |
| ▶Cexception | |
| CCheckValueTest::Expect | |
| CCTxMemPoolEntry::ExplicitCopyTag | |
| CExternalSigner | Enables interaction with an external signing device or service, such as a hardware wallet |
| Cinterfaces::ExternalSigner | External signer interface used by the GUI |
| Ctinyformat::detail::is_convertible< T1, T2 >::fail | |
| CFailingCheck | |
| ▶Cfailure | |
| CFakeCheck | |
| CFakeCheckCheckCompletion | |
| ▶Cfalse_type | |
| CFeeCalculation | |
| CFeeFilterRounder | |
| CFeeFrac | Data structure storing a fee and size, ordered by increasing fee/size |
| Cfsbridge::FileLock | |
| CFilterHeaderHasher | |
| ▶CFlatFilePos | |
| CFlatFileSeq | FlatFileSeq represents a sequence of numbered files storing raw data |
| CFooImplementation | |
| Cgen::FooInterface | |
| Ctinyformat::detail::FormatArg | |
| ▶Ctinyformat::FormatList | List of template arguments format(), held in a type-opaque way |
| Ctinyformat::detail::formatValueAsType< T, fmtT, convertible > | |
| Ctinyformat::detail::formatValueAsType< T, fmtT, true > | |
| Cinterfaces::FoundBlock | Helper for findBlock to selectively return pieces of block data |
| CFrozenCleanupCheck | |
| CFSChaCha20 | Forward-secure ChaCha20 |
| CFSChaCha20Poly1305 | Forward-secure wrapper around AEADChaCha20Poly1305 |
| CFuzzedDataProvider | |
| CFuzzedFileProvider | |
| CFuzzTarget | |
| CFuzzTargetOptions | |
| CGCSFilter | This implements a Golomb-coded set as defined in BIP 158 |
| CGenTxid | A generic txid reference (txid or wtxid) |
| Cpyminisketch.GF2Ops | |
| CGFMulHelper< I, N, L, F, K > | Helper class for carryless multiplications |
| CGFMulHelper< I, N, L, F, 0 > | |
| Cwallet::Groups | |
| Cwallet::GroupVerifier | |
| CEpoch::Guard | |
| CAppTests::HandleCallback | RAII helper to remove no-longer-pending callback |
| Cinterfaces::Handler | Generic interface for managing an event handler or callback function registered with another interface |
| CSock::HashSharedPtrSock | |
| ▶CHashWriter | A writer stream (for serialization) that computes a 256-bit hash |
| CHasJSON | |
| CHasReason | BOOST_CHECK_EXCEPTION predicates to check the specific validation error |
| ▶CHeadersSyncState | HeadersSyncState: |
| ▶CHTTPClosure | Event handler closure |
| CHTTPEvent | Event class |
| CHTTPPathHandler | |
| CHTTPReply | Reply structure for request_done to fill in |
| CHTTPRequest | In-flight HTTP request |
| CHTTPRequestTracker | Helps keep track of open evhttp_connections with active evhttp_requests |
| CIdTrans | The identity transformation |
| CTxRequestTracker::Impl | Actual implementation for TxRequestTracker's data structure |
| CTxReconciliationTracker::Impl | Actual implementation for TxReconciliationTracker's data structure |
| Cwallet::ImportData | |
| Cnode::ImportingNow | |
| Cnode::ImportMempoolOptions | |
| Cindex_by_wtxid | |
| ▶Cindexed_by | |
| CIndexSummary | |
| Cindirectmap< K, T > | |
| CTransport::Info | |
| Cinterfaces::Init | Initial interface created when a process is first started, and used to give and get access to other interfaces (Node, Chain, Wallet, etc) |
| Cipc::capnp::messages::Init | |
| Csubprocess::input | |
| Cminiscript::internal::InputResult | A pair of a satisfaction and a dissatisfaction InputStack |
| Cminiscript::internal::InputStack | An object representing a sequence of witness stack elements |
| Cbitset_detail::IntBitSet< I > | A bitset implementation backed by a single integer of type I |
| Cwallet::InternalPage | A page of records in the database |
| Cwallet::InternalRecord | Class for records representing internal nodes of the BTree |
| Ckernel::Interrupted | Result type for use with std::variant to indicate that an operation should be interrupted |
| Cinterfaces::Ipc | Interface providing access to interprocess-communication (IPC) functionality |
| Ctinyformat::detail::is_convertible< T1, T2 > | |
| Ctinyformat::detail::is_wchar< T > | |
| Ctinyformat::detail::is_wchar< const wchar_t * > | |
| Ctinyformat::detail::is_wchar< const wchar_t[n]> | |
| Ctinyformat::detail::is_wchar< wchar_t * > | |
| Ctinyformat::detail::is_wchar< wchar_t[n]> | |
| Cankerl::nanobench::detail::IterationLogic | |
| Cbitdeque< BITS_PER_WORD >::Iterator< Const > | Iterator to a bitdeque element, const or not |
| Cbitset_detail::IntBitSet< I >::Iterator | Iterator type returned by begin(), which efficiently iterates all 1 positions |
| Cbitset_detail::MultiIntBitSet< I, N >::Iterator | Iterator type returned by begin(), which efficiently iterates all 1 positions |
| Cprevector< N, T, Size, Diff >::iterator | |
| CTxOrphanage::IteratorComparator | |
| Cnode::IteratorComparator | |
| Cbitset_detail::IntBitSet< I >::IteratorEnd | Dummy type to return using end() |
| Cbitset_detail::MultiIntBitSet< I, N >::IteratorEnd | Dummy type to return using end() |
| CCDBIterator::IteratorImpl | |
| CJSONRPCRequest | |
| CJSONUTF8StringFilter | Filter that generates and validates UTF-8, as well as collates UTF-16 surrogate pairs as specified in RFC4627 |
| CKeyInfo | |
| CKeyOriginInfo | |
| CKeyPair | KeyPair |
| CTaprootBuilder::LeafInfo | Information about a tracked leaf in the Merkle tree |
| CLevelDBContext | |
| CLFSR< F, MOD > | Class which implements a stateless LFSR for generic moduli |
| CLimitedStringFormatter< Limit > | |
| Ccluster_linearize::LinearizationChunking< SetType > | Data structure encapsulating the chunking of a linearization, permitting removal of subsets |
| CLinTrans< I, N > | A Linear N-bit transformation over the field I |
| Cmemusage::list_node< X > | |
| CCConnman::ListenSocket | |
| CValidationSignalsImpl::ListEntry | List entries consist of a callback pointer and reference count |
| CPoolResource< MAX_BLOCK_SIZE_BYTES, ALIGN_BYTES >::ListNode | In-place linked list of the allocations, used for the freelist |
| Cwallet::LoadResult | |
| CLocalServiceInfo | |
| ▶Clock_guard | |
| ▶CLockedPageAllocator | OS-dependent allocation and deallocation of locked/pinned memory pages |
| ▶CLockedPool | Pool for locked memory chunks |
| CLockPoints | |
| CLogCategory | |
| ▶CLogger | |
| CBCLog::Logger | |
| Cipc::capnp::messages::Init::MakeEchoParams | |
| Cipc::capnp::messages::Init::MakeEchoResults | |
| CEpoch::Marker | |
| Cminiscript::internal::MaxInt< I > | Class whose objects represent the maximum of a list of integers |
| Cminiscript::internal::MaxInt< uint32_t > | |
| CMemoryCheck | |
| CMempoolAcceptResult | Validation result for a transaction evaluated by MemPoolAccept (single or package) |
| Cmempoolentry_txid | |
| Cmempoolentry_wtxid | |
| Ckernel::MemPoolLimits | Options struct containing limit options for a CTxMemPool |
| Ckernel::MemPoolOptions | Options struct containing options for constructing a CTxMemPool |
| Cwallet::MetaPage | Berkeley DB BTree metadata page layout |
| Cwallet::MigrationData | Struct containing information needed for migrating legacy wallets to descriptor wallets |
| Cwallet::MigrationResult | |
| Cnode::MiniMiner | A minimal version of BlockAssembler, using the same ancestor set scoring algorithm |
| Cnode::MiniMinerMempoolEntry | |
| Cinterfaces::Mining | Interface giving clients (RPC, Stratum v2 Template Provider in the future) ability to create block templates |
| Cpyminisketch.Minisketch | |
| Cwallet::MinOutputGroupComparator | |
| CMockedDescriptorConverter | Converts a mocked descriptor string to a valid one |
| Cnode::modifiedentry_iter | |
| CMuHash3072 | A class representing MuHash sets |
| Cbitset_detail::MultiIntBitSet< I, N > | A bitset implementation backed by N integers of type I |
| ▶Cmutex | |
| ▶CNetEventsInterface | Interface for message handling |
| CNetGroupManager | Netgroup manager |
| ▶CNetPermissions | |
| CNetworkSetup | |
| CNetworkStyle | |
| CNewMempoolTransactionInfo | |
| CAddrManImpl::NewTriedCount | |
| CNoCopy | |
| Cminiscript::Node< Key > | A node in a miniscript expression |
| Cinterfaces::Node | Top-level interface for a bitcoin node (bitcoind process) |
| Cnode::NodeContext | NodeContext struct containing references to chain state and connection state |
| CNodeEvictionCandidate | |
| CTaprootBuilder::NodeInfo | Information associated with a node in the Merkle tree |
| CCConnman::NodesSnapshot | RAII helper to atomically create a copy of m_nodes and add a reference to each of the nodes |
| Cminiscript::internal::NoDupCheck | |
| CNoechoInst | |
| CNoIncludeConfTest | |
| Cnontrivial_t | |
| ▶Ckernel::Notifications | A base class defining functions for notifying about certain kernel events |
| ▶Cinterfaces::Chain::Notifications | Chain notifications |
| CNSBundle(returnCorrectIdentifier) | |
| CNum< N > | A type to represent integers in the type system |
| CNum3072 | |
| Cminiscript::internal::Ops | |
| CCConnman::Options | |
| CPeerManager::Options | |
| CTxOrphanage::OrphanTx | |
| COtherParam | |
| COtherParamChecker | Checker for value of OtherParam |
| Csubprocess::output | |
| Cwallet::OutputGroup | A group of UTXOs paid to the same output script |
| Cwallet::OutputGroupTypeMap | Stores several 'Groups' whose were mapped by output type |
| Cwallet::OverflowPage | A page containing overflow data |
| Cwallet::OverflowRecord | Class for records representing overflow records of the BTree |
| CPackageMempoolAcceptResult | Validation result for package mempool acceptance |
| Cwallet::PageHeader | A generic data page in the database |
| CConsensus::Params | Parameters that influence chain consensus |
| CGCSFilter::Params | |
| CParamsStream< SubStream, Params > | Wrapper that overrides the GetParams() function of a stream |
| CParamsWrapper< Params, T > | Wrapper that serializes objects with the specified parameters |
| CParentInfo | Helper for PackageTRUCChecks, storing info for a mempool or package parent |
| CPartiallyDownloadedBlock | |
| CPartiallySignedTransaction | A version of CTransaction with the PSBT format |
| Cgen::FooInterface::PassOutPointParams | |
| Cgen::FooInterface::PassOutPointResults | |
| Cgen::FooInterface::PassUniValueParams | |
| Cgen::FooInterface::PassUniValueResults | |
| ▶Cpath | |
| CNetinfoRequestHandler::Peer | |
| CPeerManagerInfo | |
| CPerBlockConnectTrace | |
| Cankerl::nanobench::detail::PerfCountSet< T > | |
| Cankerl::nanobench::detail::PerfCountSet< bool > | |
| Cankerl::nanobench::detail::PerfCountSet< uint64_t > | |
| Cankerl::nanobench::detail::PerformanceCounters | |
| Cipc::capnp::messages::Init::ConstructParams::Pipeline | |
| Cipc::capnp::messages::Init::MakeEchoParams::Pipeline | |
| Cipc::capnp::messages::Init::MakeEchoResults::Pipeline | |
| Cipc::capnp::messages::Init::ConstructResults::Pipeline | |
| Cipc::capnp::messages::Echo::EchoResults::Pipeline | |
| Cipc::capnp::messages::Echo::DestroyParams::Pipeline | |
| Cipc::capnp::messages::Echo::DestroyResults::Pipeline | |
| Cgen::FooInterface::AddParams::Pipeline | |
| Cgen::FooInterface::AddResults::Pipeline | |
| Cgen::FooInterface::PassOutPointParams::Pipeline | |
| Cgen::FooInterface::PassOutPointResults::Pipeline | |
| Cgen::FooInterface::PassUniValueParams::Pipeline | |
| Cgen::FooInterface::PassUniValueResults::Pipeline | |
| Cipc::capnp::messages::Echo::EchoParams::Pipeline | |
| CPlatformStyle | |
| CPoly1305 | C++ wrapper with std::byte Span interface around poly1305_donna code |
| Cpoly1305_donna::poly1305_context | |
| CPoolAllocator< T, MAX_BLOCK_SIZE_BYTES, ALIGN_BYTES > | Forwards all allocations/deallocations to the PoolResource |
| CPoolResource< MAX_BLOCK_SIZE_BYTES, ALIGN_BYTES > | A memory resource similar to std::pmr::unsynchronized_pool_resource, but optimized for node-based containers |
| CPoolResourceTester | Helper to get access to private parts of PoolResource |
| Csubprocess::Popen | |
| CPrecomputedTransactionData | |
| CPrefilledTransaction | |
| Cwallet::PreselectedInput | |
| Cwallet::PreSelectedInputs | |
| CPreSelectInputs | |
| ▶Cprevector< N, T, Size, Diff > | Implements a drop-in replacement for std::vector<T> which stores up to N elements directly (without heap allocation) |
| Cprevector< ADDR_IPV6_SIZE, uint8_t > | |
| Cprevector< N, T > | |
| Cprevector_tester< N, T > | |
| Cipc::Process | IPC process interface for spawning bitcoin processes and serving requests in processes that have been spawned |
| CHeadersSyncState::ProcessingResult | Result data structure for ProcessNextHeaders |
| Cipc::Protocol | IPC protocol interface for calling IPC methods over sockets |
| CProxy | |
| ▶CProxyClientCustom | |
| CProxyCredentials | Credentials for proxy authentication |
| Cmp::ProxyMethod< gen::FooInterface::AddParams > | |
| Cmp::ProxyMethod< gen::FooInterface::PassOutPointParams > | |
| Cmp::ProxyMethod< gen::FooInterface::PassUniValueParams > | |
| Cmp::ProxyMethod< ipc::capnp::messages::Echo::EchoParams > | |
| Cmp::ProxyMethod< ipc::capnp::messages::Init::MakeEchoParams > | |
| ▶CProxyServerCustom | |
| CProxySetting | |
| Cmp::ProxyType< FooImplementation > | |
| Cmp::ProxyType< interfaces::Echo > | |
| Cmp::ProxyType< interfaces::Init > | |
| Cnode::PruneLockInfo | |
| Cnode::PSBTAnalysis | Holds the results of AnalyzePSBT (miscellaneous information about a PSBT) |
| CPSBTInput | A structure for PSBTs which contain per-input information |
| Cnode::PSBTInputAnalysis | Holds an analysis of one input from a PSBT |
| CPSBTOutput | A structure for PSBTs which contains per output information |
| CPSBTProprietary | A structure for PSBT proprietary types |
| CPoolResourceTester::PtrAndBytes | |
| CPubKeyDestination | |
| ▶CQAbstractItemDelegate | |
| ▶CQAbstractListModel | |
| ▶CQAbstractSpinBox | |
| ▶CQAbstractTableModel | |
| ▶CQApplication | |
| ▶CQComboBox | |
| ▶CQDialog | |
| ▶CQFrame | |
| ▶CQItemDelegate | |
| ▶CQLabel | |
| ▶CQLineEdit | |
| ▶CQListView | |
| ▶CQMainWindow | |
| ▶CQMessageBox | |
| ▶CQObject | |
| ▶CQProgressBar | |
| ▶CQSortFilterProxyModel | |
| ▶CQStackedWidget | |
| ▶CQStyledItemDelegate | |
| Cqt_meta_stringdata_AddressBookPage_t | |
| Cqt_meta_stringdata_AddressBookTests_t | |
| Cqt_meta_stringdata_AddressTableModel_t | |
| Cqt_meta_stringdata_AppTests_t | |
| Cqt_meta_stringdata_AskPassphraseDialog_t | |
| Cqt_meta_stringdata_BanTableModel_t | |
| Cqt_meta_stringdata_BitcoinAddressCheckValidator_t | |
| Cqt_meta_stringdata_BitcoinAddressEntryValidator_t | |
| Cqt_meta_stringdata_BitcoinAmountField_t | |
| Cqt_meta_stringdata_BitcoinApplication_t | |
| Cqt_meta_stringdata_BitcoinGUI_t | |
| Cqt_meta_stringdata_BitcoinUnits_t | |
| Cqt_meta_stringdata_ClientModel_t | |
| Cqt_meta_stringdata_CoinControlDialog_t | |
| Cqt_meta_stringdata_CoinControlTreeWidget_t | |
| Cqt_meta_stringdata_CreateWalletActivity_t | |
| Cqt_meta_stringdata_CreateWalletDialog_t | |
| Cqt_meta_stringdata_CSVModelWriter_t | |
| Cqt_meta_stringdata_EditAddressDialog_t | |
| Cqt_meta_stringdata_GUIUtil__ClickableLabel_t | |
| Cqt_meta_stringdata_GUIUtil__ClickableProgressBar_t | |
| Cqt_meta_stringdata_GUIUtil__ItemDelegate_t | |
| Cqt_meta_stringdata_GUIUtil__LabelOutOfFocusEventFilter_t | |
| Cqt_meta_stringdata_GUIUtil__ThemedLabel_t | |
| Cqt_meta_stringdata_GUIUtil__ToolTipToRichTextFilter_t | |
| Cqt_meta_stringdata_HelpMessageDialog_t | |
| Cqt_meta_stringdata_InitExecutor_t | |
| Cqt_meta_stringdata_Intro_t | |
| Cqt_meta_stringdata_LoadWalletsActivity_t | |
| Cqt_meta_stringdata_MacDockIconHandler_t | |
| Cqt_meta_stringdata_MacNotificationHandler_t | |
| Cqt_meta_stringdata_MigrateWalletActivity_t | |
| Cqt_meta_stringdata_ModalOverlay_t | |
| Cqt_meta_stringdata_Notificator_t | |
| Cqt_meta_stringdata_OpenURIDialog_t | |
| Cqt_meta_stringdata_OpenWalletActivity_t | |
| Cqt_meta_stringdata_OptionsDialog_t | |
| Cqt_meta_stringdata_OptionsModel_t | |
| Cqt_meta_stringdata_OptionTests_t | |
| Cqt_meta_stringdata_OverviewPage_t | |
| Cqt_meta_stringdata_PaymentServer_t | |
| Cqt_meta_stringdata_PeerTableModel_t | |
| Cqt_meta_stringdata_PeerTableSortProxy_t | |
| Cqt_meta_stringdata_ProxyAddressValidator_t | |
| Cqt_meta_stringdata_PSBTOperationsDialog_t | |
| Cqt_meta_stringdata_QRImageWidget_t | |
| Cqt_meta_stringdata_QValidatedLineEdit_t | |
| Cqt_meta_stringdata_QValueComboBox_t | |
| Cqt_meta_stringdata_ReceiveCoinsDialog_t | |
| Cqt_meta_stringdata_ReceiveRequestDialog_t | |
| Cqt_meta_stringdata_RecentRequestsTableModel_t | |
| Cqt_meta_stringdata_RestoreWalletActivity_t | |
| Cqt_meta_stringdata_RPCConsole_t | |
| Cqt_meta_stringdata_RPCNestedTests_t | |
| Cqt_meta_stringdata_SendCoinsDialog_t | |
| Cqt_meta_stringdata_SendCoinsEntry_t | |
| Cqt_meta_stringdata_SendConfirmationDialog_t | |
| Cqt_meta_stringdata_ShutdownWindow_t | |
| Cqt_meta_stringdata_SignVerifyMessageDialog_t | |
| Cqt_meta_stringdata_SplashScreen_t | |
| Cqt_meta_stringdata_TrafficGraphWidget_t | |
| Cqt_meta_stringdata_TransactionDesc_t | |
| Cqt_meta_stringdata_TransactionDescDialog_t | |
| Cqt_meta_stringdata_TransactionFilterProxy_t | |
| Cqt_meta_stringdata_TransactionOverviewWidget_t | |
| Cqt_meta_stringdata_TransactionTableModel_t | |
| Cqt_meta_stringdata_TransactionView_t | |
| Cqt_meta_stringdata_UnitDisplayStatusBarControl_t | |
| Cqt_meta_stringdata_URITests_t | |
| Cqt_meta_stringdata_WalletController_t | |
| Cqt_meta_stringdata_WalletControllerActivity_t | |
| Cqt_meta_stringdata_WalletFrame_t | |
| Cqt_meta_stringdata_WalletModel_t | |
| Cqt_meta_stringdata_WalletTests_t | |
| Cqt_meta_stringdata_WalletView_t | |
| ▶CQTreeWidget | |
| ▶CQTreeWidgetItem | |
| ▶CQValidator | |
| ▶CQWidget | |
| CRandomMixin< T > | Mixin class that provides helper randomness functions |
| ▶CRandomMixin< FastRandomContext > | |
| ▶CRandomMixin< InsecureRandomContext > | |
| CReachableNets | List of reachable networks |
| Cipc::capnp::messages::Init::MakeEchoResults::Reader | |
| Cipc::capnp::messages::Init::ConstructParams::Reader | |
| Cipc::capnp::messages::Init::MakeEchoParams::Reader | |
| Cgen::FooInterface::PassUniValueParams::Reader | |
| Cipc::capnp::messages::Echo::EchoResults::Reader | |
| Cgen::FooInterface::AddResults::Reader | |
| Cipc::capnp::messages::Init::ConstructResults::Reader | |
| Cgen::FooInterface::PassOutPointParams::Reader | |
| Cipc::capnp::messages::Echo::EchoParams::Reader | |
| Cipc::capnp::messages::Echo::DestroyParams::Reader | |
| Cipc::capnp::messages::Echo::DestroyResults::Reader | |
| Cgen::FooInterface::AddParams::Reader | |
| Cgen::FooInterface::PassOutPointResults::Reader | |
| Cgen::FooInterface::PassUniValueResults::Reader | |
| CPoolAllocator< T, MAX_BLOCK_SIZE_BYTES, ALIGN_BYTES >::rebind< U > | The rebind struct here is mandatory because we use non type template arguments for PoolAllocator |
| CRecentRequestEntry | |
| CRecentRequestEntryLessThan | |
| CRecLinTrans< I, N > | A linear transformation constructed using LinTrans tables for sections of bits |
| CRecLinTrans< I, N > | |
| CRecLinTrans< I, N, X... > | |
| CRecLinTrans< I, X... > | |
| CCConnman::ReconnectionInfo | Struct for entries in m_reconnections |
| Cwallet::RecordHeader | General class for records in a BDB BTree database |
| Cwallet::RecordsPage | A page of records in the database |
| ▶Crecursive_mutex | |
| CCChainParams::RegTestOptions | RegTestOptions holds configurations for creating a regtest CChainParams |
| CRemovedMempoolTransactionInfo | |
| CReorgTxns | Reorg where 1 block is disconnected and 2 blocks are connected |
| Ci2p::sam::Session::Reply | A reply from the SAM proxy |
| Cwallet::ReserveDestination | A wrapper to reserve an address from a wallet |
| Cmp::echo_fields::Result | |
| Cmp::ipc_test_fields::Result | |
| Cankerl::nanobench::Result | |
| Cmp::init_fields::Result | |
| Cutil::Result< M > | |
| Cutil::Result< void > | |
| Cprevector< N, T, Size, Diff >::reverse_iterator | |
| CUniqueLock< MutexType >::reverse_lock | An RAII-style reverse lock |
| Cankerl::nanobench::Rng | An extremely fast random generator |
| CRPCArg | |
| CRPCArgOptions | |
| CRPCCommandExecution | |
| CRPCCommandExecutionInfo | |
| CRPCExamples | |
| CRPCHelpMan | |
| CRPCResult | |
| CRPCResults | |
| CRPCServerInfo | |
| ▶CRPCTimerBase | Opaque base class for timers returned by NewTimerFunc |
| ▶CRPCTimerInterface | RPC timer "driver" |
| ▶Cruntime_error | |
| Cwallet::SafeDbt | RAII class that automatically cleanses its data on destruction |
| CSaltedOutpointHasher | |
| CSaltedSipHasher | |
| CSaltedTxidHasher | |
| Cminiscript::internal::SatInfo | A data structure to help the calculation of stack size limits |
| CSatisfier< Pk > | Context for solving a Miniscript |
| ▶CSatisfier< CPubKey > | |
| ▶CSatisfier< XOnlyPubKey > | |
| Cwallet::CWallet::ScanResult | |
| CScriptCompression | Compact serializer for scripts |
| CScriptErrorDesc | |
| CScriptExecutionData | |
| ▶Cwallet::ScriptPubKeyMan | |
| Ccluster_linearize::SearchCandidateFinder< SetType > | Class encapsulating the state needed to perform search for good candidate sets |
| Csecp256k1_callback | |
| Csecp256k1_context_struct | |
| Csecp256k1_ecdsa_recoverable_signature | Opaque data structured that holds a parsed ECDSA signature, supporting pubkey recovery |
| Csecp256k1_ecdsa_signature | Opaque data structured that holds a parsed ECDSA signature |
| Csecp256k1_ecmult_gen_context | |
| Csecp256k1_fe | This field implementation represents the value as 10 uint32_t limbs in base 2^26 |
| Csecp256k1_fe_storage | |
| Csecp256k1_ge | A group element in affine coordinates on the secp256k1 curve, or occasionally on an isomorphic curve of the form y^2 = x^3 + 7*t^6 |
| Csecp256k1_ge_storage | |
| Csecp256k1_gej | A group element of the secp256k1 curve, in jacobian coordinates |
| Csecp256k1_hmac_sha256 | |
| Csecp256k1_keypair | Opaque data structure that holds a keypair consisting of a secret and a public key |
| Csecp256k1_modinv32_modinfo | |
| Csecp256k1_modinv32_signed30 | |
| Csecp256k1_modinv32_trans2x2 | |
| Csecp256k1_modinv64_modinfo | |
| Csecp256k1_modinv64_signed62 | |
| Csecp256k1_modinv64_trans2x2 | |
| Csecp256k1_pippenger_point_state | |
| Csecp256k1_pippenger_state | |
| Csecp256k1_pubkey | Opaque data structure that holds a parsed and valid public key |
| Csecp256k1_rfc6979_hmac_sha256 | |
| Csecp256k1_scalar | A scalar modulo the group order of the secp256k1 curve |
| Csecp256k1_schnorrsig_extraparams | Data structure that contains additional arguments for schnorrsig_sign_custom |
| Csecp256k1_scratch_space_struct | |
| Csecp256k1_sha256 | |
| Csecp256k1_strauss_point_state | |
| Csecp256k1_strauss_state | |
| Csecp256k1_uint128 | |
| Csecp256k1_xonly_pubkey | Opaque data structure that holds a parsed and valid "x-only" public key |
| CSection | A pair of strings that can be aligned (through padding) with other Sections later on |
| CSectionInfo | |
| CSections | Keeps track of RPCArgs by transforming them into sections for the purpose of serializing everything to a single string |
| Csecure_allocator< T > | |
| CSecureUniqueDeleter< T > | |
| Cwallet::SelectionFilter | |
| Cwallet::SelectionResult | |
| CSendCoinsRecipient | |
| CWalletModel::SendCoinsReturn | |
| Cipc::capnp::Serializable< T > | Use SFINAE to define Serializeable<T> trait which is true if type T has a Serialize(stream) method, false otherwise |
| ▶CCNetAddr::SerParams | |
| ▶CServer | |
| Ci2p::sam::Session | I2P SAM session |
| Ccluster_linearize::SetInfo< SetType > | A set of transactions together with their aggregate feerate |
| Ccommon::Settings | Stored settings |
| Ccommon::SettingsSpan | Accessor for list of settings that skips negated values when iterated over |
| CSHA3_256 | |
| CShortestVectorFirstComparator | |
| Cutil::SignalInterrupt | Helper class that manages an interrupt flag, and allows a thread or signal to interrupt another thread |
| CSignatureCache | 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) |
| CSignatureCacheHasher | We're hashing a nonce into the entries themselves, so we don't need extra blinding in the set hash computation |
| CSignatureData | |
| Cwallet::feebumper::SignatureWeights | |
| CCChainParams::SigNetOptions | SigNetOptions holds configurations for creating a signet CChainParams |
| CSignetTxs | Generate the signet tx corresponding to the given block |
| ▶CSigningProvider | An interface to be implemented by keystores that support signing |
| CSingleEntryCacheTest | |
| CSizeComputer | |
| ▶CSketch | Abstract class for internal representation of a minisketch object |
| Cnode::SnapshotMetadata | Metadata describing a serialized version of a UTXO set from which an assumeutxo Chainstate can be constructed |
| ▶CSock | RAII helper class that manages a socket and closes it automatically when it goes out of scope |
| CSpan< C > | A Span is an object that can refer to a contiguous sequence of objects |
| CSpan< const ClusterIndex > | |
| CSpan< const std::byte > | |
| CSpan< const unsigned char > | |
| CSpanReader | Minimal stream for reading from an existing byte array by Span |
| Cwallet::SQliteExecHandler | Class responsible for executing SQL statements in SQLite databases |
| Cminiscript::internal::StackSize | |
| CLockedPool::Stats | Memory statistics |
| CArena::Stats | Memory statistics |
| Cmemusage::stl_shared_counter | |
| Cmemusage::stl_tree_node< X > | |
| Csubprocess::detail::Streams | |
| ▶Csubprocess::string_arg | |
| CStringContentsSerializer | |
| Ctinyformat::detail::is_convertible< T1, T2 >::succeed | |
| ▶Csystem_clock | |
| Cwallet::tallyitem | |
| CTaprootBuilder | Utility class to construct Taproot outputs from internal key and script tree |
| CTaprootSpendData | |
| ▶Cutil::TaskRunnerInterface | |
| Ctest_hsort_cmp_data | |
| ▶CTestCase | |
| Cwallet::TestCrypter | |
| CTestHeaderAndShortIDs | |
| CTestMemPoolEntryHelper | |
| CTestOpts | |
| Cmp::init_fields::ThreadMap | |
| CTimeOffsets | |
| CBCLog::Timer< TimeType > | RAII-style object that outputs timing information to logs |
| CTipBlock | |
| CTokenPipe | An interprocess or interthread pipe for sending tokens (one-byte values) over |
| CTokenPipeEnd | One end of a token pipe |
| ▶CTorControlConnection | Low-level handling for Tor control connection |
| CTorController | Controller that connects to Tor control socket, authenticate, then create and maintain an ephemeral onion service |
| CTorControlReply | Reply from Tor, can be single or multi-line |
| Ctransaction_identifier< has_witness > | Transaction_identifier represents the two canonical transaction identifier types (txid, wtxid) |
| Ctransaction_identifier< false > | |
| CTransactionInfo | |
| CTransactionNotification | |
| CTransactionRecord | UI model for a transaction |
| CTransactionSerParams | |
| CTransactionStatus | UI model for transaction status |
| CTransactionTablePriv | |
| CRPCConsole::TranslatedStrings | |
| ▶CTransport | The Transport converts one connection's sent messages to wire bytes, and received bytes back |
| ▶Ctrue_type | |
| CTxConfirmStats | We will instantiate an instance of this class to track transactions that were included in a block |
| CTxInUndoFormatter | Formatter for undo information for a CTxIn |
| CTxLessThan | |
| CTxMempoolInfo | Information about a mempool transaction |
| ▶CTxOrphanage | A class to track orphan transactions (failed on TX_MISSING_INPUTS) Since we cannot distinguish orphans from bad transactions with non-existent inputs, we heavily limit the number of orphans we keep and the duration we keep them for |
| CTxOutCompression | Wrapper for CTxOut that provides a more compact serialization |
| CTxReconciliationTracker | Transaction reconciliation is a way for nodes to efficiently announce transactions |
| CTxRequestTracker | Data structure to keep track of, and schedule, transaction downloads from peers |
| Cwallet::TxSize | |
| Cwallet::TxStateBlockConflicted | State of rejected transaction that conflicts with a confirmed block |
| Cwallet::TxStateConfirmed | State of transaction confirmed in a block |
| Cwallet::TxStateInactive | State of transaction not confirmed or conflicting with a known block and not in the mempool |
| Cwallet::TxStateInMempool | State of transaction added to mempool |
| Cwallet::TxStateUnrecognized | State of transaction loaded in an unrecognized state with unexpected hash or index values |
| CCBlockPolicyEstimator::TxStatsInfo | |
| Cminiscript::Type | This type encapsulates the miniscript type system properties |
| ▶CUi_AddressBookPage | |
| ▶CUi_AskPassphraseDialog | |
| ▶CUi_CoinControlDialog | |
| ▶CUi_CreateWalletDialog | |
| ▶CUi_EditAddressDialog | |
| ▶CUi_HelpMessageDialog | |
| ▶CUi_Intro | |
| ▶CUi_ModalOverlay | |
| ▶CUi_OpenURIDialog | |
| ▶CUi_OptionsDialog | |
| ▶CUi_OverviewPage | |
| ▶CUi_PSBTOperationsDialog | |
| ▶CUi_ReceiveCoinsDialog | |
| ▶CUi_ReceiveRequestDialog | |
| ▶CUi_RPCConsole | |
| ▶CUi_SendCoinsDialog | |
| ▶CUi_SendCoinsEntry | |
| ▶CUi_SignVerifyMessageDialog | |
| ▶CUi_TransactionDescDialog | |
| CUISignals | |
| ▶Cunique_lock | |
| CUniqueCheck | |
| CUniValue | |
| CUniValueType | Wrapper for UniValue::VType, which includes typeAny: Used to denote don't care type |
| CWalletModel::UnlockContext | |
| Cipc::capnp::Unserializable< T > | Use SFINAE to define Unserializeable<T> trait which is true if type T has an Unserialize(stream) method, false otherwise |
| Cnode::update_for_parent_inclusion | |
| CValidationCache | Convenience class for initializing and passing the script execution cache and signature cache |
| CValidationInterfaceTest | |
| CValidationSignals | |
| CValidationSignalsImpl | ValidationSignalsImpl manages a list of shared_ptr<CValidationInterface> callbacks |
| CValidationState< Result > | Template for capturing information about block/transaction validation |
| ▶CValidationState< BlockValidationResult > | |
| ▶CValidationState< PackageValidationResult > | |
| ▶CValidationState< TxValidationResult > | |
| CVarIntFormatter< Mode > | Serialization wrapper class for integers in VarInt format |
| CVBDeploymentInfo | |
| CVecDeque< T > | Data structure largely mimicking std::deque, but using single preallocated ring buffer |
| CVectorFormatter< Formatter > | Formatter to serialize/deserialize vector elements using another formatter |
| CVectorWriter | |
| CVersionBitsCache | BIP 9 allows multiple softforks to be deployed in parallel |
| CCChainParams::VersionBitsParameters | VersionBitsParameters holds activation parameters |
| CVersionBitsTester | |
| Cinterfaces::Wallet | Interface for accessing a wallet |
| Cinterfaces::WalletAddress | Information about one wallet address |
| Cinterfaces::WalletBalances | Collection of wallet balances |
| Cwallet::WalletBatch | Access to the wallet database |
| Cwallet::WalletContext | WalletContext struct containing references to state shared between CWallet instances, like the reference to the chain interface, and the list of opened wallets |
| ▶Cwallet::WalletDatabase | An instance of this class represents one database |
| Cwallet::WalletDatabaseFileId | |
| Cwallet::WalletDescriptor | Descriptor with some wallet metadata |
| Cwallet::WalletDestination | |
| ▶CWalletInitInterface | |
| Cinterfaces::WalletMigrationResult | Migrated wallet info |
| CWalletModelTransaction | Data model for a walletmodel transaction |
| Cwallet::WalletRescanReserver | RAII object to check and reserve a wallet rescan |
| ▶Cwallet::WalletStorage | |
| Cinterfaces::WalletTx | |
| Cwallet::WalletTxOrderComparator | |
| Cinterfaces::WalletTxOut | Wallet transaction output |
| Cinterfaces::WalletTxStatus | Updated transaction status |
| Cnode::Warnings | Manages warning messages within a node |
| Cminiscript::internal::WitnessSize | |
| ▶CWitnessUnknown | CTxDestination subtype to encode any future Witness version |
| CWorkQueue< WorkItem > | Simple work queue for distributing work over multiple threads |
| CWrapper< Formatter, T > | Simple wrapper class to serialize objects using a formatter; used by Using() |
| CCDBBatch::WriteBatchImpl | |
| Cwycheproof_ecdsa_testvector | |
| ▶CX | |
| ▶CXOnlyPubKey | |
| Czero_after_free_allocator< T > | |
| ▶CPARENT | |
| ▶CTs |
1.8.14