Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 1234]

►CAdapter
CShortIdProcessor< PrefilledItemType, Adapter, ItemCompare >
CAddedNodeInfo
Caddr_t
CAddressTableEntry
CAddressTableEntryLessThan
CAddressTablePriv
CAddrMan	Stochastic address manager
CAddrManImpl
CAES128_ctx
CAES128CBCDecrypt
CAES128CBCEncrypt
CAES128Decrypt	A decryption class for AES-128
CAES128Encrypt	An encryption class for AES-128
CAES192_ctx
CAES256_ctx
CAES256CBCDecrypt
CAES256CBCEncrypt
CAES256Decrypt	A decryption class for AES-256
CAES256Encrypt	An encryption class for AES-256
CAES_state
►Cstd::allocator
Csecure_allocator< T >
Czero_after_free_allocator< T >
CAmount
CAmountCompression
►CArena	An arena manages a contiguous region of memory by dividing it into chunks
CLockedPool::LockedPageArena	Create an arena from locked pages
CArgsManager::Arg
Cbenchmark::Args
CArgsManager
CArgsTestingSetup
CAssumeutxoData	Holds configuration for use during UTXO snapshot load and validation
►CAutoFile	Non-refcounted RAII wrapper for FILE*
CCAutoFile
CAvailable
CBalance
CBanMan
CBannedNodeLessThan
CBanTablePriv
Cbase_blob< BITS >	Template base class for fixed-sized opaque blobs
►Cbase_blob< 160 >
►Cuint160	160-bit opaque blob
CCKeyID	A reference to a CKey: the Hash160 of its serialized public key
►Cbase_blob< 256 >
►Cuint256	256-bit opaque blob
CBlockHash	A BlockHash is a unqiue identifier for a block
CTxHash	A TxHash is the double sha256 hash of the full transaction data
CTxId	A TxId is the identifier of a transaction
Cavalanche::DelegationId
Cavalanche::LimitedProofId
Cavalanche::ProofId
Cavalanche::StakeCommitment
Cbase_uint< BITS >	Template base class for unsigned big integers
►Cbase_uint< 256 >
Carith_uint256	256-bit unsigned big integer
CBaseHash< HashType >
►CBaseHash< uint160 >
CCScriptID	A reference to a CScript: the Hash160 of its serialization (see script.h)
CPKHash
CScriptHash
►CBaseHash< uint256 >
CAssumeutxoHash
►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
CDefaultRequestHandler	Process default single requests
CGenerateToAddressRequestHandler	Process RPC generatetoaddress request
CGetinfoRequestHandler	Process getinfo requests
CNetinfoRequestHandler	Process netinfo requests
►CBaseSignatureChecker
►CGenericTransactionSignatureChecker< T >
CCachingTransactionSignatureChecker
►CBaseSignatureCreator	Interface for signature creators
CMutableTransactionSignatureCreator	A signature creator for transactions
►CBasicTestingSetup
CInitWalletDirTestingSetup
Cankerl::nanobench::Bench	Main entry point to nanobench's benchmarking facility
Cbench_data
Cbench_ecdh_data
Cbench_inv
Cbench_recover_data
Cbench_schnorrsig_data
Cbench_sign_data
Cbench_verify_data
Cbenchmark::BenchRunner
CBerkeleyEnvironment
Cankerl::nanobench::BigO
Cbilingual_str	Bilingual messages:
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< BlobSize >	Class that mimics std::deque<bool>, but with std::vector<bool>'s bit packing
CBitStreamReader< IStream >
CBitStreamWriter< OStream >
Cinterfaces::BlockAndHeaderTipInfo	Block and header tip information
Cnode::BlockAssembler	Generate a new block, without valid proof-of-work
CBlockFilter	Complete block filter struct as defined in BIP 157
CBlockHasher	Maintain a map of CBlockIndex for all known headers
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
CBlockStatus
Cinterfaces::BlockTip	Block tip (could be a header or not, depends on the subscribed signal)
CBlockTransactions
CBlockTransactionsRequest
CBlockValidationOptions
CRWCollectionView< T, L >::BracketType< I >
CByteVectorHash	Implementation of Hash named requirement for types that internally store a byte array
CCachableAmount	Cachable amount subdivided into watchonly and spendable parts
CCuckooCache::cache< Element, Hash >	cache implements a cache with properties similar to a cuckoo-set
CCConnman::CachedAddrResponse	Cache responses to addr requests to minimize privacy leak
Cnode::CacheSizes
CCAddrDb
CCAddrDbStats
CCAddressBookData	Address book data
CCAddrReport
CCAddrStat
CCAppNapInhibitor::CAppNapImpl
CCAppNapInhibitor
CCashAddrContent
CCBanDB	Access to the banlist database (banlist.dat)
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
CCBlock
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
CCDiskBlockIndex	Used to marshal pointers into hashes for db storage
CCBlockIndexHeightOnlyComparator
CCBlockIndexWorkComparator
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
Cnode::CBlockTemplateEntry
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
CCBufferedFile	Non-refcounted RAII wrapper around a FILE* that implements a ring buffer to deserialize from
CCChain	An in-memory indexed chain of blocks
►CCChainParams	CChainParams defines various tweakable parameters of a given instance of the Bitcoin system
CCMainParams	Main network
CCRegTestParams	Regression test
CCTestNetParams	Testnet (v3)
CChainParamsWithCustomActivation
CCCheckpointData
CCCheckQueue< T >	Queue for verifications that have to be performed
CCCheckQueueControl< T >	RAII-style controller object for a CCheckQueue that guarantees the passed queue is finished before continuing
CCClientUIInterface	Signals for UI communication
CCCoin
CCCoinControl	Coin Control Features
CCCoinsCacheEntry	A Coin in one level of the coins database caching hierarchy
Cnode::CCoinsStats
►CCCoinsView	Abstract view on the open txout dataset
►CCCoinsViewBacked	CCoinsView backed by another CCoinsView
CCCoinsViewCache	CCoinsView that adds a memory cache for transactions to another CCoinsView
CCCoinsViewErrorCatcher	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-qt and non-server tools
CCCoinsViewMemPool	CCoinsView that brings transactions from a mempool into view
CCCoinsViewDB	CCoinsView backed by the coin database (chainstate/)
►CCCoinsViewCursor	Cursor for iterating over CoinsView state
CCCoinsViewDBCursor	Specialization of CCoinsViewCursor to iterate over a CCoinsViewDB
CCCombinedBan
CCConnman
CCCrypter	Encryption/decryption context with key information
CCDataStream	Double ended buffer combining vector and stream-like interfaces
CCDBBatch	Batch of changes queued to be written to a CDBWrapper
CCDBIterator
►CCDBWrapper
►CBaseIndex::DB	The database stores a block locator of the chain the database is synced to so that the TxIndex can efficiently determine the point it last stopped at
CTxIndex::DB	Access to the txindex database (indexes/txindex/)
CCBlockTreeDB	Access to the block database (blocks/index/)
Cseeder::CDnsSeedOpts
CCDnsThread
CCExtKey
CCExtPubKey
CCFeeRate	Fee rate in satoshis per kilobyte: Amount / kB
CChaCha20	A class for ChaCha20 256-bit stream cipher developed by Daniel J
CChaCha20Poly1305AEAD
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)
Cinterfaces::WalletClient	Wallet chain client that in addition to having chain client methods for starting up, shutting down, and registering RPCs, also has additional methods (called by the GUI) to load and create wallets
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)
►CCHashWriter	A writer stream (for serialization) that computes a 256-bit hash
CCHashVerifier< Source >	Reads data from an underlying stream, while hashing the read data
CCHDChain
►CCheckInputsLimiter	Simple class for regulating resource usage during CheckInputScripts (and CScriptCheck), atomic so as to be compatible with parallel validation
CTxSigCheckLimiter
CCheckVarIntMode< Mode, I >
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 >
CCInputCoin
CCInv	Inv(ventory) message data
CCKey	An encapsulated secp256k1 private key
CCKeyMetadata
CCKeyPool	A key from a CWallet's keypool
CCLogCategoryDesc
CCMainSignals
CCMasterKey	Private key encryption is done based on a CMasterKey, which holds a salt and random encryption key
CCMedianFilter< T >	Median filter over a stream of values
CCMerkleBlock	Used to create a Merkle proof (usually from a subset of transactions), which consists of a block header and partial Merkle Tree
CCMerkleTx	Legacy class used for deserializing vtxPrev for backwards compatibility
CCMessageHeader	Message header
CCMutableTransaction	A mutable version of CTransaction
►CCNetAddr	Network address
►CCService	A combination of a network address (CNetAddr) and a (TCP) port
►CCAddress	A CService with information about it as peer
CAddrInfo	Extended statistics about a CAddress
CCNetCleanup
CCNetMessage	Transport protocol agnostic message container
CCNetMsgMaker
CCNode	Information about a peer
CCNodeCombinedStats
CCNodeStateStats
CCNodeStats	POD that contains various stats about a node
CCNoDestination
CCoin	A UTXO entry
CCoinEligibilityFilter
CCoinSelectionParams
CCoinsViews	A convenience class for constructing the CCoinsView* hierarchy used to facilitate access to the UTXO set
CCoinsViewScanReserver
CCSVModelWriter::Column
Cavalanche::CompactProofs
CCompactSizeFormatter< RangeCheck >	Formatter for integers in CompactSize format
CCompareBlocksByHeight	Comparison function for sorting the getchaintips heads
CCompareIteratorById
CCompareIteratorByRevEntryId	Iterate txs in reverse-topological order
CCompareNodeNetworkTime	Sort eviction candidates by network/localhost and connection uptime
CCompareTxMemPoolEntryByEntryId
CCompareTxMemPoolEntryByEntryTime
CCompareTxMemPoolEntryByModifiedFeeRate	Sort by feerate of entry (modfee/vsize) in descending order
CCompressedHeader
Cankerl::nanobench::Config
Cavalanche::Config
►CConfig
CDummyConfig
CGlobalConfig
CCWalletTx::Confirmation	Confirmation includes tx status and a triplet of {block height/block hash/tx index in block} at which tx has been confirmed
Cavalanche::ConflictingProofComparator	Compare conflicting proofs
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
Ccontrol_data
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
CCOutput
CCOutputEntry
CCPartialMerkleTree	Data structure that represents a partial merkle tree
CCPubKey	An encapsulated public key
CCRecipient
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
CCScriptNum
CCSeederNode
CCSemaphore
CCSemaphoreGrant	RAII-style semaphore lock
CCSerActionSerialize	Support for SERIALIZE_METHODS and READWRITE macro
CCSerActionUnserialize
CCSerializedNetMsg
CCServiceHash
CCServiceResult
CCSHA1	A hasher class for SHA1
CCSHA256	A hasher class for SHA-256
CCSHA512	A hasher class for SHA-512
CCSipHasher	SipHash-2-4
CCSizeComputer	GetSerializeSize implementations
CCSubNet
Cctaes_test
CCThreadInterrupt	A helper class for interruptible sleeps
CCTransaction	The basic transaction that is broadcasted on the network and contained in blocks
CPartiallyDownloadedBlock::CTransactionRefCompare
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)
CCTxOut	An output of a transaction
CCTxUndo	Restore the UTXO in a Coin at a given COutPoint
CCUpdatedBlock
CCurrency
CCustomUintFormatter< Bytes, BigEndian >	Serialization wrapper class for custom integers and enums
►CCValidationInterface	Implement this to subscribe to events generated in validation
►CBaseIndex	Base class for indices of blockchain data
CBlockFilterIndex	BlockFilterIndex is used to store and retrieve block filters, hashes, and headers for a range of blocks by height
CCoinStatsIndex	CoinStatsIndex maintains statistics on the UTXO set
CTxIndex	TxIndex is used to look up transactions included in the blockchain by ID
CCZMQNotificationInterface
CPeerManager
Csubmitblock_StateCatcher
CCVectorWriter	Minimal stream for overwriting and/or appending to an existing byte vector
CCVerifyDB	RAII wrapper for VerifyDB: Verify consistency of the block and coin databases
CCWalletScanState
CCWalletTx	A transaction with a bunch of additional info that only the owner cares about
►CCZMQAbstractNotifier
►CCZMQAbstractPublishNotifier
CCZMQPublishHashBlockNotifier
CCZMQPublishHashTransactionNotifier
CCZMQPublishRawBlockNotifier
CCZMQPublishRawTransactionNotifier
CCZMQPublishSequenceNotifier
►CDatabaseBatch	RAII class that provides access to a WalletDatabase
CBerkeleyBatch	RAII class that provides access to a Berkeley database
CDummyBatch	RAII class that provides access to a DummyDatabase
CSQLiteBatch	RAII class that provides access to a WalletDatabase
CDatabaseOptions
CDataRequestParameters
CDefaultFormatter	Default formatter
Cavalanche::Delegation
Cavalanche::DelegationBuilder
CDereferencingComparator< T >
CDescribeAddressVisitor
CDescribeWalletAddressVisitor
CDescriptor	Interface for parsed descriptor objects
CDescriptorCache	Cache for single descriptor's derived extended pubkeys
Cdeserialize_type	Dummy data type to identify deserializing constructors
►CDifferenceFormatter	Helper for differentially encoded Compact Size integers in lists
CDifferentialIndexedItemFormatter	Helper for a list of items containing a differentially encoded index as their first member
Cprevector< N, T, Size, Diff >::direct_or_indirect
CDisconnectedBlockTransactions
Cdns_opt_t
CECCVerifyHandle	Users of this module must hold an ECCVerifyHandle
Cecmult_multi_data
Centry_id
Centry_time
CEpoch	Epoch: RAII-style guard for using epoch-based graph traversal algorithms
Cutil::Error
CEventLoop
►CException
Corg.bitcoin.NativeSecp256k1Util.AssertFailException
►Cstd::exception
CStopHashingException
Ctinyformat::detail::is_convertible< T1, T2 >::fail
►Cstd::ios_base::failure
CInvalidAddrManVersionError
►Cstd::false_type
►CSpan< C >::is_Span_int< std::remove_cv< T >::type >
CSpan< C >::is_Span< T >
CSpan< C >::is_Span_int< T >
CFastRandomContext	Fast randomness source
CFeeFilterRounder
Cfsbridge::FileLock
CFilterHeaderHasher
CCDnsThread::FlagSpecificData
►CFlatFilePos
CCDiskTxPos
CFlatFileSeq	FlatFileSeq represents a sequence of numbered files storing raw data
Ctinyformat::detail::FormatArg
►Ctinyformat::FormatList	List of template arguments format(), held in a type-opaque way
Ctinyformat::detail::FormatListN< N >
Ctinyformat::detail::FormatListN< 0 >
Ctinyformat::detail::formatValueAsType< T, fmtT, convertible >
Ctinyformat::detail::formatValueAsType< T, fmtT, true >
Cinterfaces::FoundBlock	Helper for findBlock to selectively return pieces of block data
CGCSFilter	This implements a Golomb-coded set as defined in BIP 158
Cavalanche::Processor::GetLocalAcceptance
CEpoch::Guard
Cinterfaces::Handler	Generic interface for managing an event handler or callback function registered with another interface
Cstd::hash< RCUPtr< T > >
CHeadersSyncState	HeadersSyncState:
Cavalanche::Hello
►CHTTPClosure	Event handler closure
CHTTPWorkItem	HTTP request work item
CHTTPEvent	Event class
CHTTPPathHandler
CHTTPReply	Reply structure for request_done to fill in
CHTTPRequest	In-flight HTTP request
CHTTPRPCRequestProcessor
CImportData
Cnode::ImportingNow
CIndexSummary
Cindirectmap< K, T >	Map whose keys are pointers, but are compared by their dereferenced values
Cinsertion_order
CInvRequestTracker< InvId >
►CInvRequestTrackerImplInterface	Data structure to keep track of, and schedule, inventory downloads from peers
CInvRequestTrackerImpl	Actual implementation for InvRequestTracker's data structure
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]>
Cavalanche::Processor::IsWorthPolling
►CItemCompare
CShortIdProcessor< PrefilledItemType, Adapter, ItemCompare >
Cankerl::nanobench::detail::IterationLogic
Cbitdeque< BlobSize >::Iterator< Const >	Iterator to a bitdeque element, const or not
Cprevector< N, T, Size, Diff >::iterator
CTxOrphanage::IteratorComparator
CJSONRPCRequest
CJSONUTF8StringFilter	Filter that generates and validates UTF-8, as well as collates UTF-16 surrogate pairs as specified in RFC4627
CKeyOriginInfo
Cavalanche::Delegation::Level
CLimitedStringFormatter< Limit >
CCConnman::ListenSocket
CMainSignalsImpl::ListEntry	List entries consist of a callback pointer and reference count
CLocalServiceInfo
►Cstd::lock_guard
CStdLockGuard
►CLockedPageAllocator	OS-dependent allocation and deallocation of locked/pinned memory pages
CPosixLockedPageAllocator	LockedPageAllocator specialized for OSes that don't try to be special snowflakes
►CLockedPool	Pool for locked memory chunks
CLockedPoolManager	Singleton class to keep track of locked (ie, non-swappable) memory, for use in std::allocator templates
CLockPoints
CLogCategory
CBCLog::Logger
►Cleveldb::Logger
CCBitcoinLevelDBLogger
CMainSignalsImpl	MainSignalsImpl manages a list of shared_ptr<CValidationInterface> callbacks
CEpoch::Marker
CMempoolAcceptResult	Validation result for a single transaction mempool acceptance
Cmempoolentry_txid
►CMemPoolEntryRadixTreeAdapter	Radix tree adapter for storing a CTxMemPoolEntry as a tree element
CRadixTree< CTxMemPoolEntry, MemPoolEntryRadixTreeAdapter >
Ckernel::MemPoolOptions	Options struct containing options for constructing a CTxMemPool
Cmodified_feerate
CMuHash3072	A class representing MuHash sets
►Cstd::mutex
►CAnnotatedMixin< std::mutex >
CGlobalMutex	Different type to mark Mutex at global scope
CStdMutex
Corg.bitcoin.NativeSecp256k1
Corg.bitcoin.NativeSecp256k1Test	This class holds test cases defined for testing this library
Corg.bitcoin.NativeSecp256k1Util
►CNetEventsInterface	Interface for message handling
CPeerManager
Cavalanche::Processor
►CNetPermissions
CNetWhitebindPermissions
CNetWhitelistPermissions
CNetworkStyle
Cavalanche::next_request_time
Cavalanche::Node
Cinterfaces::Node	Top-level interface for a bitcoin node (bitcoind process)
Cnode::NodeContext	NodeContext struct containing references to chain state and connection state
CNodeEvictionCandidate
CNodeLessThan
CNoechoInst
Cnontrivial_t
►Cinterfaces::Chain::Notifications	Chain notifications
CCWallet	A CWallet maintains a set of transactions and balances, and provides the ability to create new transactions
Cavalanche::Processor::NotificationsHandler
CNSBundle(returnCorrectIdentifier)
CNum3072
CCConnman::Options
Cnode::BlockAssembler::Options
CTxOrphanage::OrphanTx
COutputGroup
COverrideStream< Stream >
CPackageMempoolAcceptResult	Validation result for package mempool acceptance
CConsensus::Params	Parameters that influence chain consensus
CGCSFilter::Params
►CPARENT
CAnnotatedMixin< PARENT >	Template mixin that adds -Wthread-safety locking annotations and lock order checking to a subset of the mutex API
►CParkingPolicy
CMinerFundPolicy
CPreConsensusPolicy
CStakingRewardsPolicy
CPartiallyDownloadedBlock
CPartiallySignedTransaction	A version of CTransaction with the PSBT format
►CPassthroughAdapter< T >
CRadixTree< T, Adapter >	This is a radix tree storing values identified by a unique key
►Cstd::filesystem::path
Cfs::path	Path class wrapper to block calls to the fs::path(std::string) implicit constructor and the fs::path::string() method, which have unsafe and unpredictable behavior on Windows (see implementation note in PathToString for details)
CPaymentRequestPlus
Cavalanche::Peer
CNetinfoRequestHandler::Peer
Cavalanche::Processor::PeerData
Cavalanche::PeerManager
CPeerTablePriv
Cavalanche::PendingNode
CPerBlockConnectTrace
Cankerl::nanobench::detail::PerfCountSet< T >
Cankerl::nanobench::detail::PerfCountSet< bool >
Cankerl::nanobench::detail::PerfCountSet< uint64_t >
Cankerl::nanobench::detail::PerformanceCounters
CPlatformStyle
Cavalanche::Poll
CPrecomputedTransactionData	Precompute sighash midstate to avoid quadratic hashing
Cavalanche::PrefilledProof
CPrefilledTransaction
►Cprevector< N, T, Size, Diff >	Implements a drop-in replacement for std::vector<T> which stores up to N elements directly (without heap allocation)
CCScript	Serialized script, used inside transaction inputs and outputs
Cprevector< ADDR_IPV6_SIZE, uint8_t >
CHeadersSyncState::ProcessingResult	Result data structure for ProcessNextHeaders
Cavalanche::Proof
Cavalanche::proof_index
Cavalanche::ProofBuilder
Cavalanche::ProofComparatorByScore	Compare proofs by score, then by id in case of equality
Cavalanche::ProofPool	Map a proof to each utxo
Cavalanche::ProofPoolEntry
Cavalanche::ProofPoolEntryProofIdKeyExtractor
Cavalanche::ProofRadixTreeAdapter	Radix tree adapter for storing a proof as a tree element
►CProofRadixTreeAdapter
CRadixTree< const Proof, ProofRadixTreeAdapter >
Cavalanche::ProofRefComparatorByAddress	Compare proof references by pointer address
Cavalanche::ProofRefCompare
Cavalanche::ProofsRequest
CProxyCredentials	Credentials for proxy authentication
CProxySetting
CproxyType
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
►CQAbstractItemDelegate
CTxViewDelegate
►CQAbstractListModel
CBitcoinUnits	Bitcoin unit definitions
COptionsModel	Interface from Qt to configuration data structure for Bitcoin client
►CQAbstractSpinBox
CAmountSpinBox	QSpinBox that uses fixed-point numbers internally and uses our own formatting/parsing functions
►CQAbstractTableModel
CAddressTableModel	Qt model of the address book in the core
CBanTableModel	Qt model providing information about connected peers, similar to the "getpeerinfo" RPC call
CPeerTableModel	Qt model providing information about connected peers, similar to the "getpeerinfo" RPC call
CRecentRequestsTableModel	Model for list of recently generated payment requests / bitcoincash: URIs
CTransactionTableModel	UI model for the transaction table of a wallet
►CQApplication
CBitcoinApplication	Main Bitcoin application object
►CQComboBox
CQValueComboBox
►CQDialog
CAddressBookPage	Widget that shows a list of sending or receiving addresses
CAskPassphraseDialog	Multifunctional dialog to ask for passphrases
CCoinControlDialog
CCreateWalletDialog	Dialog for creating wallets
CEditAddressDialog	Dialog for editing an address and associated information
CHelpMessageDialog	"Help message" dialog box
CIntro	Introduction screen (pre-GUI startup)
COpenURIDialog
COptionsDialog	Preferences dialog
CReceiveCoinsDialog	Dialog for requesting payment of bitcoins
CReceiveRequestDialog
CSendCoinsDialog	Dialog for sending bitcoins
CSignVerifyMessageDialog
CTransactionDescDialog	Dialog showing transaction details
►CQFrame
CWalletFrame	A container for embedding all wallet-related controls into BitcoinGUI
►CQItemDelegate
CGUIUtil::ItemDelegate
►CQLabel
CGUIUtil::ClickableLabel
CQRImageWidget	Label widget for QR code
CUnitDisplayStatusBarControl
►CQLineEdit
CQValidatedLineEdit	Line edit that can be marked as "invalid" to show input validation feedback
►CQMainWindow
CBitcoinGUI	Bitcoin GUI main class
►CQMessageBox
CSendConfirmationDialog
►CQObject
CBitcoinABC	Class encapsulating Bitcoin ABC startup and shutdown
CCSVModelWriter	Export a Qt table model to a CSV file
CClientModel	Model for Bitcoin network client
CFreespaceChecker
CGUIUtil::LabelOutOfFocusEventFilter	Qt event filter that intercepts QEvent::FocusOut events for QLabel objects, and resets their ‘textInteractionFlags’ property to get rid of the visible cursor
CGUIUtil::TableViewLastColumnResizingFixer	Makes a QTableView last column feel as if it was being resized from its left border
CGUIUtil::ToolTipToRichTextFilter	Qt event filter that intercepts ToolTipChange events, and replaces the tooltip with a rich text representation if needed
CMacDockIconHandler	MacOS-specific Dock icon handler
CMacNotificationHandler	Macintosh-specific notification handler (supports UserNotificationCenter)
CNotificator	Cross-platform desktop notification client
CPaymentServer
CQtRPCTimerBase	Class for handling RPC timers (used for e.g
CRPCExecutor
CTransactionDesc	Provide a human-readable extended HTML description of a transaction
CWalletController	Controller between interfaces::Node, WalletModel instances and the GUI
►CWalletControllerActivity
CCreateWalletActivity
COpenWalletActivity
CWalletModel	Interface to Bitcoin wallet from Qt view code
►CQProgressBar
CGUIUtil::ClickableProgressBar
►CQSortFilterProxyModel
CAddressBookSortFilterProxyModel
CTransactionFilterProxy	Filter the transaction list according to pre-specified rules
►CQStackedWidget
CSendCoinsEntry	A single entry in the dialog for sending bitcoins
CWalletView	WalletView class
►CQTreeWidget
CCoinControlTreeWidget
►CQTreeWidgetItem
CCCoinControlWidgetItem
Cavalanche::Processor::Query
Cavalanche::query_timeout
►CQValidator
CBitcoinAddressCheckValidator	Bitcoin address widget validator, checks for a valid bitcoin address
CBitcoinAddressEntryValidator	Bitcoin address entry widget validator, checks for valid characters and removes some whitespace
CProxyAddressValidator	Proxy address widget validator, checks for a valid proxy address
CThirdPartyTxUrlsValidator	Third party tx URL validator, checks for an https link
►CQWidget
CBitcoinAmountField	Widget for entering bitcoin amounts
CModalOverlay	Modal overlay to display information about the chain-sync state
COverviewPage	Overview ("home") page widget
CRPCConsole	Local Bitcoin RPC console
CShutdownWindow	"Shutdown" window
CSplashScreen	Class for the splashscreen with information of the running client
CTrafficGraphWidget
CTransactionView	Widget showing the transaction list for a wallet, including a filter row
CRadixTree< T, Adapter >::RadixElement
CRadixTree< T, Adapter >::RadixNode
CRCUInfos::RCUCleanupGuard
CRCUInfos
CRCULock
CRCUPtr< T >
CRCUPtr< const Proof >
Csecure_allocator< T >::rebind< _Other >
Czero_after_free_allocator< T >::rebind< _Other >
CRecentRequestEntry
CRecentRequestEntryLessThan
►Cstd::recursive_mutex
CAnnotatedMixin< std::recursive_mutex >
Cavalanche::RemoteProof
Ci2p::sam::Session::Reply	A reply from the SAM proxy
CReserveDestination	A wrapper to reserve an address from a wallet
Cavalanche::Response
Cankerl::nanobench::Result
Cutil::Result< M >
Cutil::Result< void >
Cprevector< N, T, Size, Diff >::reverse_iterator
CUniqueLock< Mutex, Base >::reverse_lock	An RAII-style reverse lock
Creverse_range< T >	Template used for reverse iteration in C++11 range-based for loops
Cankerl::nanobench::Rng	An extremely fast random generator
CRPCArg
►CRPCCommand	Base class for all RPC commands
CRPCCommandWithArgsContext	By default, use RPCCommandWithArgsContext as the parent class for new RPC command classes that only depend on RPC arguments
CRPCCommandExecution
CRPCCommandExecutionInfo
CRPCExamples
CRPCHelpMan
CRPCResult
CRPCResults
CRPCServer	Class for registering and managing all RPC calls
CRPCServerInfo
►CRPCTimerBase	Opaque base class for timers returned by NewTimerFunc
CHTTPRPCTimer	Simple one-shot callback timer to be used by the RPC mechanism to e.g
CQtRPCTimerBase	Class for handling RPC timers (used for e.g
►CRPCTimerInterface	RPC timer "driver"
CHTTPRPCTimerInterface
CQtRPCTimerInterface
►Cstd::runtime_error
CCConnectionFailed
CNonFatalCheckError
CSSLVerifyError
Cdbwrapper_error
Cscriptnum_error
Ctinyformat::format_error
Cuint_error
CRWCollection< T >
CRWCollection< QuerySet >
CRWCollection< RPCCommandMap >
CRWCollection< VoteMap >
CRWCollectionView< T, L >
CBerkeleyBatch::SafeDbt	RAII class that automatically cleanses its data on destruction
CSaltedOutpointHasher
►CSaltedSipHasher
CTxDestinationHasher
►CSaltedUint256Hasher
CSaltedBlockHashHasher
CSaltedTxIdHasher
Cavalanche::SaltedProofHasher
Cavalanche::SaltedProofIdHasher
CCWallet::ScanResult
Corg.bitcoin.NativeSecp256k1Test.SchnorrTestVector
Cavalanche::score_index
CScriptCacheElement	In future if many more values are added, it should be considered to expand the element size to 64 bytes (with padding the spare space as needed) so the key can be long
CScriptCacheHasher
CScriptCacheKey	The script cache is a map using a key/value element, that caches the success of executing a specific transaction's input scripts under a specific set of flags, along with any associated information learned during execution
CScriptCompression	Compact serializer for scripts
CScriptExecutionMetrics	Struct for holding cumulative results from executing a script or a sequence of scripts
►CScriptPubKeyMan	A class implementing ScriptPubKeyMan manages some (or all) scriptPubKeys used in a wallet
CDescriptorScriptPubKeyMan
CLegacyScriptPubKeyMan
Csecp256k1_assumption_checker
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_context
Csecp256k1_ecmult_gen_context
Csecp256k1_fe
Csecp256k1_fe_storage
Csecp256k1_ge	A group element of the secp256k1 curve, in affine coordinates
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_multiset	Opaque multiset; this is actually a group element
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_scratch_space_struct
Csecp256k1_sha256
Csecp256k1_strauss_point_state
Csecp256k1_strauss_state
Csecp256k1_xonly_pubkey	Opaque data structure that holds a parsed and valid "x-only" public key
Corg.bitcoin.Secp256k1Context	This class holds the context reference used in native methods to handle ECDSA operations
CSecp256k1Init
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
CSeederAddrInfo
CSeederTestingSetup
CSeedSpec6
CSendCoinsRecipient
CWalletModel::SendCoinsReturn
Ci2p::sam::Session	I2P SAM session
Cutil::Settings	Stored settings
Cutil::SettingsSpan	Accessor for list of settings that skips negated values when iterated over
CSHA3_256
Cavalanche::ShortIdProcessorPrefilledProofAdapter
CShortIdProcessorPrefilledTransactionAdapter
CSigHashType	Signature hash type wrapper class
CSignatureCacheHasher	We're hashing a nonce into the entries themselves, so we don't need extra blinding in the set hash computation
CSignatureData
Cavalanche::SignedStake
Cavalanche::ProofBuilder::SignedStakeComparator
►CSigningProvider	An interface to be implemented by keystores that support signing
►CFillableSigningProvider	Fillable signing provider that keeps keys in an address->secret map
CLegacyScriptPubKeyMan
CFlatSigningProvider
CHidingSigningProvider
CLegacySigningProvider	Wraps a LegacyScriptPubKeyMan so that it can be returned in a new unique_ptr
CSingleThreadedSchedulerClient	Class used by CScheduler clients which may schedule multiple jobs which are required to be run serially
Cavalanche::Slot
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
CSpan< C >	A Span is an object that can refer to a contiguous sequence of objects
CSpan< const uint8_t >
CSpanReader	Minimal stream for reading from an existing byte array by Span
Cavalanche::Stake
Cavalanche::Processor::StakingReward
CArena::Stats	Memory statistics
CLockedPool::Stats	Memory statistics
Cmemusage::stl_shared_counter
Cmemusage::stl_tree_node< X >
Ctinyformat::detail::is_convertible< T1, T2 >::succeed
►Cstd::chrono::system_clock
CNodeClock	Mockable clock in the context of tests, otherwise the system clock
►CT
CCuckooCache::KeyOnly< T >	Helper class used when we only want the cache to be a set rather than a map
Ctallyitem
►CTestChain100Setup
CListCoinsTestingSetup
CTestCrypter
►CTestingSetup
CStakingRewardsActivationTestingSetup
CWalletTestingSetup	Testing setup and teardown for wallet
Cavalanche::TestProofBuilder
CTestVector
CBCLog::Timer< TimeType >	RAII-style object that outputs timing information to logs
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
CTransactionNotification
CTransactionRecord	UI model for a transaction
CTransactionStatus	UI model for transaction status
CTransactionTablePriv
►CTransportDeserializer	The TransportDeserializer takes care of holding and deserializing the network receive buffer
CV1TransportDeserializer
►CTransportSerializer	The TransportSerializer prepares messages for the network transport
CV1TransportSerializer
►Cstd::true_type
CSpan< C >::is_Span_int< Span< T > >
Ctxid_index	DisconnectedBlockTransactions
CDisconnectedBlockTransactions::TxInfo
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
CUint256RadixKey	Facility for using an uint256 as a radix tree key
CUISignals
►Ctypename Mutex::UniqueLock
CUniqueLock< Mutex, Base >	Wrapper around std::unique_lock style lock for Mutex
CUniValue
CUniValueType	Wrapper for UniValue::VType, which includes typeAny: used to denote don't care type
CWalletModel::UnlockContext
Ckernel::ValidationCacheSizes
CValidationState< Result >	Template for capturing information about block/transaction validation
►CValidationState< BlockPolicyValidationResult >
CBlockPolicyValidationState
►CValidationState< BlockValidationResult >
CBlockValidationState
►CValidationState< DelegationResult >
Cavalanche::DelegationState
►CValidationState< PackageValidationResult >
CPackageValidationState
►CValidationState< ProofRegistrationResult >
Cavalanche::ProofRegistrationState
►CValidationState< ProofValidationResult >
Cavalanche::ProofValidationState
►CValidationState< TxValidationResult >
CTxValidationState
CVarIntFormatter< Mode >	Serialization wrapper class for integers in VarInt format
CVectorFormatter< Formatter >	Formatter to serialize/deserialize vector elements using another formatter
Cavalanche::Vote
Cavalanche::VoteItemUpdate
Cavalanche::VoteMapComparator
►Cavalanche::VoteRecord	Vote history
Cavalanche::TestVoteRecord
CVoteRecordFixture
Cinterfaces::Wallet	Interface for accessing a wallet
Cinterfaces::WalletAddress	Information about one wallet address
Cinterfaces::WalletBalances	Collection of wallet balances
CWalletBatch	Access to the wallet database
CWalletContext	WalletContext struct containing references to state shared between CWallet instances, like the reference to the chain interface, and the list of opened wallets
►CWalletDatabase	An instance of this class represents one database
CBerkeleyDatabase	An instance of this class represents one database
CDummyDatabase	A dummy WalletDatabase that does nothing and never fails
CSQLiteDatabase	An instance of this class represents one SQLite3 database
CWalletDatabaseFileId
CWalletDescriptor	Descriptor with some wallet metadata
►CWalletInitInterface
CDummyWalletInit
CWalletInit
CWalletModelTransaction	Data model for a walletmodel transaction
CWalletRescanReserver	RAII object to check and reserve a wallet rescan
►CWalletStorage
CCWallet	A CWallet maintains a set of transactions and balances, and provides the ability to create new transactions
Cinterfaces::WalletTx
Cinterfaces::WalletTxOut	Wallet transaction output
Cinterfaces::WalletTxStatus	Updated transaction status
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()
►CX
Cmemusage::unordered_node< X >
►Cvariant::Ts
Cvariant::overloaded< Ts >