Class Hierarchy

Go to the graphical class hierarchy

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

[detail level 1234]

▶CAbstractThresholdConditionChecker	Abstract class that implements BIP9-style threshold logic, and caches results
CWarningBitsConditionChecker	Threshold condition checker that triggers when unknown versionbits are seen on the network
CAddedNodeInfo
CAddressTableEntry
CAddressTableEntryLessThan
CAddressTablePriv
CAES128_ctx
CAES192_ctx
CAES256_ctx
CAES256CBCDecrypt
CAES256CBCEncrypt
CAES256Decrypt	A decryption class for AES-256
CAES256Encrypt	An encryption class for AES-256
CAES_state
▶Callocator
Csecure_allocator< T >
Czero_after_free_allocator< T >
CAmountCompression
Cancestor_score
▶CArena
CLockedPool::LockedPageArena	Create an arena from locked pages
CArgsManager::Arg
Cbenchmark::Args
CArgsManager
CAssumeutxoData	Holds configuration for use during UTXO snapshot load and validation
CAvailable
CCWallet::Balance
CBanMan
CBannedNodeLessThan
CBanTablePriv
▶CBase
CUniqueLock< Mutex, Base >	Wrapper around std::unique_lock style lock for Mutex
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
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
CWitnessV0KeyHash
▶CBaseHash< uint256 >
CAssumeutxoHash
CWitnessV0ScriptHash
▶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
CAddrinfoRequestHandler	Process addrinfo requests
CDefaultRequestHandler	Process default single requests
CGenerateToAddressRequestHandler	Process RPC generatetoaddress request
CGetinfoRequestHandler	Process getinfo requests
CNetinfoRequestHandler	Process netinfo requests
▶CBaseSignatureChecker
CDeferringSignatureChecker
▶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:
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
CBitStreamReader< IStream >
CBitStreamWriter< OStream >
Cinterfaces::BlockAndHeaderTipInfo	Block and header tip information
CBlockAssembler	Generate a new block, without valid proof-of-work
CBlockFilter	Complete block filter struct as defined in BIP 157
CBlockHasher
CBlockManager	Maintains a tree of blocks (stored in m_block_index) which is consulted to determine where the most-work tip is
Cinterfaces::BlockTip	Block tip (could be a header or not, depends on the subscribed signal)
CBlockTransactions
CBlockTransactionsRequest
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
CCAddrDB	Access to the (IP) address database (peers.dat)
CCAddressBookData	Address book data
CCAddrMan	Stochastical (IP) address manager
CCAppNapInhibitor::CAppNapImpl
CCAppNapInhibitor
CCAutoFile	Non-refcounted RAII wrapper for FILE*
CCBanDB	Access to the banlist databases (banlist.json and 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
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
CCBlockPolicyEstimator	The BlockPolicyEstimator is used for estimating the feerate needed for a transaction to be included in a block within a certain number of blocks
CCBlockTemplate
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 on which people trade goods and services
CCRegTestParams	Regression test: intended for private networks only
CCTestNetParams	Testnet (v3): public test network which is reset from time to time
CSigNetParams	Signet: test network with an additional consensus parameter (see BIP325)
CCChainState	CChainState stores and provides an API to update our local knowledge of the current best chain
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
CCCoinsStats
▶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 index 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/)
CCExtKey
CCExtPubKey
CCFeeRate	Fee rate in satoshis per kilobyte: CAmount / 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
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
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
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
CCImportingNow
CCInputCoin	A UTXO under consideration for use in funding a new transaction
CCInv	Inv message data
CCKey	An encapsulated 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 relay blocks as header + vector<merkle branch> to filtered nodes
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
CCAddrInfo	Extended statistics about a CAddress
CCNetAddrHash
CCNetCleanup
CCNetMessage	Transport protocol agnostic message container
CCNetMsgMaker
CCNode	Information about a peer
CCNodeCombinedStats
CCNodeStateStats
CCNodeStats
CCNoDestination
CCoin	A UTXO entry
CCoinEligibilityFilter	Parameters for filtering which OutputGroups we may use in coin selection
CCoinSelectionParams	Parameters for one iteration of Coin Selection
CCoinsViews	A convenience class for constructing the CCoinsView* hierarchy used to facilitate access to the UTXO set
CCoinsViewScanReserver
CCSVModelWriter::Column
CArgsManager::Command
CCompactSizeFormatter< RangeCheck >	Formatter for integers in CompactSize format
CCompareBlocksByHeight	Comparison function for sorting the getchaintips heads
CCompareCTxMemPoolIter	Comparator for CTxMemPool::txiter objects
CCompareIteratorByHash
CCompareNodeNetworkTime	Sort eviction candidates by network/localhost and connection uptime
CCompareTxIterByAncestorCount
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
Cankerl::nanobench::Config
CCWalletTx::Confirmation	Confirmation includes tx status and a triplet of {block height/block hash/tx index in block} at which tx has been confirmed
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
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 Note that this stores references to the spending transaction
CCScriptNum
CCScriptWitness
CCSemaphore
CCSemaphoreGrant	RAII-style semaphore lock
CCSerActionSerialize	Support for SERIALIZE_METHODS and READWRITE macro
CCSerActionUnserialize
CCSerializedNetMsg
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
CCSubNet
Cctaes_test
CCThreadInterrupt
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)
CCTxMemPoolModifiedEntry
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
▶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 hash
CCZMQNotificationInterface
CPeerManager
Csubmitblock_StateCatcher
CCVectorWriter
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
Cbech32::DecodeResult
CDefaultFormatter	Default formatter
CDereferencingComparator< T >
Cdescendant_score
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
Cprevector< N, T, Size, Diff >::direct_or_indirect
CDisconnectedBlockTransactions
CECCVerifyHandle	Users of this module must hold an ECCVerifyHandle
Cinterfaces::Echo	Simple string echoing interface for testing
Cecmult_multi_data
Centry_time
CEpoch	Epoch: RAII-style guard for using epoch-based graph traversal algorithms
CEstimationResult
CEstimatorBucket
CExternalSigner	Enables interaction with an external signing device or service, such as a hardware wallet
Ctinyformat::detail::is_convertible< T1, T2 >::fail
▶Cfalse_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
CFeeCalculation
CFeeFilterRounder
Cfsbridge::FileLock
CFilterHeaderHasher
▶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
CGenTxid	A generic txid reference (txid or wtxid)
CEpoch::Guard
Cinterfaces::Handler	Generic interface for managing an event handler or callback function registered with another interface
▶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
CTxRequestTracker::Impl	Actual implementation for TxRequestTracker's data structure
CImportData
Cindex_by_wtxid
CIndexSummary
Cindirectmap< K, T >
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)
Cinsertion_order
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
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
CKeyIDHasher
CKeyOriginInfo
CTaprootBuilder::LeafInfo	Information about a tracked leaf in the Merkle tree
CLimitedStringFormatter< Limit >
CCConnman::ListenSocket
CMainSignalsInstance::ListEntry	List entries consist of a callback pointer and reference count
CLocalServiceInfo
▶Clock_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
▶CLogger
CCBitcoinLevelDBLogger
CMainSignalsInstance	The MainSignalsInstance manages a list of shared_ptr<CValidationInterface> callbacks
CEpoch::Marker
CMempoolAcceptResult	Validation result for a single transaction mempool acceptance
Cmempoolentry_txid
Cmempoolentry_wtxid
Cmodifiedentry_iter
CMuHash3072	A class representing MuHash sets
▶Cmutex
CAnnotatedMixin< std::mutex >
CStdMutex
▶CNetEventsInterface	Interface for message handling
CPeerManager
▶CNetPermissions
CNetWhitebindPermissions
CNetWhitelistPermissions
CNetworkStyle
Cinterfaces::Node	Top-level interface for a bitcoin node (bitcoind process)
CNodeContext	NodeContext struct containing references to chain state and connection state
CNodeEvictionCandidate
CTaprootBuilder::NodeInfo	Information associated with a node in the Merkle tree
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
CNSBundle(returnCorrectIdentifier)
CNum3072
CBlockAssembler::Options
CCConnman::Options
CTxOrphanage::OrphanTx
COutputGroup	A group of UTXOs paid to the same output script
COverrideStream< Stream >
CPackageMempoolAcceptResult	Validation result for package mempool acceptance
CConsensus::Params	Parameters that influence chain consensus
CGCSFilter::Params
CPartiallyDownloadedBlock
CPartiallySignedTransaction	A version of CTransaction with the PSBT format
CNetinfoRequestHandler::Peer
CPerBlockConnectTrace
Cankerl::nanobench::detail::PerfCountSet< T >
Cankerl::nanobench::detail::PerfCountSet< bool >
Cankerl::nanobench::detail::PerfCountSet< uint64_t >
Cankerl::nanobench::detail::PerformanceCounters
CPlatformStyle
CPrecomputedTransactionData
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 >
Cipc::Process	IPC process interface for spawning bitcoin processes and serving requests in processes that have been spawned
Cipc::Protocol	IPC protocol interface for calling IPC methods over sockets
CProxyCredentials	Credentials for proxy authentication
CProxySetting
CproxyType
CPSBTAnalysis	Holds the results of AnalyzePSBT (miscellaneous information about a PSBT)
CPSBTInput	A structure for PSBTs which contain per-input information
CPSBTInputAnalysis	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 / bitcoin: 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
CPSBTOperationsDialog	Dialog showing transaction details
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::ThemedLabel
CGUIUtil::ClickableLabel
CQRImageWidget
CUnitDisplayStatusBarControl
▶CQLineEdit
CQValidatedLineEdit	Line edit that can be marked as "invalid" to show input validation feedback
▶CQListView
CTransactionOverviewWidget
▶CQMainWindow
CBitcoinGUI	Bitcoin GUI main class
▶CQMessageBox
CSendConfirmationDialog
▶CQObject
CBitcoinCore	Class encapsulating Bitcoin Core startup and shutdown
CClientModel	Model for Bitcoin network client
CCSVModelWriter	Export a Qt table model to a CSV file
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::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
CPeerTableSortProxy
CTransactionFilterProxy	Filter the transaction list according to pre-specified rules
▶CQStackedWidget
CSendCoinsEntry	A single entry in the dialog for sending bitcoins
CWalletView
▶CQStyledItemDelegate
CPeerIdViewDelegate
▶CQTreeWidget
CCoinControlTreeWidget
▶CQTreeWidgetItem
CCCoinControlWidgetItem
▶CQValidator
CBitcoinAddressCheckValidator	Bitcoin address widget validator, checks for a valid bitcoin address
CBitcoinAddressEntryValidator	Base58 entry widget validator, checks for valid characters and removes some whitespace
CProxyAddressValidator	Proxy address widget validator, checks for a valid proxy address
▶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
Csecure_allocator< T >::rebind< _Other >
Czero_after_free_allocator< T >::rebind< _Other >
CRecentRequestEntry
CRecentRequestEntryLessThan
▶Crecursive_mutex
CAnnotatedMixin< std::recursive_mutex >
Ci2p::sam::Session::Reply	A reply from the SAM proxy
CReserveDestination	A wrapper to reserve an address from a wallet
Cankerl::nanobench::Result
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
CRPCCommandExecution
CRPCCommandExecutionInfo
CRPCExamples
CRPCHelpMan
CRPCResult
CRPCResults
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
▶Cruntime_error
CCConnectionFailed
Cdbwrapper_error
Cipc::Exception	Exception class thrown when a call to remote method fails due to an IPC error, like a socket getting disconnected
CNonFatalCheckError
Cscriptnum_error
Ctinyformat::format_error
Cuint_error
CBerkeleyBatch::SafeDbt	RAII class that automatically cleanses its data on destruction
CSaltedOutpointHasher
CSaltedSipHasher
CSaltedTxidHasher
CCWallet::ScanResult
CScriptCompression	Compact serializer for scripts
CScriptExecutionData
▶CScriptPubKeyMan
▶CDescriptorScriptPubKeyMan
CExternalSignerScriptPubKeyMan
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_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
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
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
CShortestVectorFirstComparator
CSignatureCacheHasher	We're hashing a nonce into the entries themselves, so we don't need extra blinding in the set hash computation
CSignatureData
CSignetTxs	Generate the signet tx corresponding to the given block
▶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
CSnapshotMetadata	Metadata describing a serialized version of a UTXO set from which an assumeutxo CChainState 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
CLockedPool::Stats	Memory statistics
CArena::Stats	Memory statistics
Cmemusage::stl_shared_counter
Cmemusage::stl_tree_node< X >
Ctinyformat::detail::is_convertible< T1, T2 >::succeed
Ctallyitem
CTaprootBuilder	Utility class to construct Taproot outputs from internal key and script tree
CTaprootSpendData
▶CTestChain100Setup
CListCoinsTestingSetup
CTestCrypter
▶CTestingSetup
CWalletTestingSetup	Testing setup and teardown for wallet
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
CRPCConsole::TranslatedStrings
▶CTransportDeserializer	The TransportDeserializer takes care of holding and deserializing the network receive buffer
CV1TransportDeserializer
▶CTransportSerializer	The TransportSerializer prepares messages for the network transport
CV1TransportSerializer
▶Ctrue_type
CSpan< C >::is_Span_int< Span< T > >
CTxConfirmStats	We will instantiate an instance of this class to track transactions that were included in a block
Ctxid_index	DisconnectedBlockTransactions
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
CCNode::TxRelay
CTxRequestTracker	Data structure to keep track of, and schedule, transaction downloads from peers
CTxSize
CCBlockPolicyEstimator::TxStatsInfo
CUISignals
CUniValue
CUniValueType	Wrapper for UniValue::VType, which includes typeAny: Used to denote don't care type
CWalletModel::UnlockContext
Cupdate_ancestor_state
Cupdate_descendant_state
Cupdate_fee_delta
Cupdate_for_parent_inclusion
Cupdate_lock_points
CValidationState< Result >	Template for capturing information about block/transaction validation
▶CValidationState< BlockValidationResult >
CBlockValidationState
▶CValidationState< PackageValidationResult >
CPackageValidationState
▶CValidationState< TxValidationResult >
CTxValidationState
CVarIntFormatter< Mode >	Serialization wrapper class for integers in VarInt format
CVBDeploymentInfo
CVectorFormatter< Formatter >	Formatter to serialize/deserialize vector elements using another formatter
CVectorReader	Minimal stream for reading from an existing vector by reference
CVersionBitsCache	BIP 9 allows multiple softforks to be deployed in parallel
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
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()
▶CX
Cmemusage::unordered_node< X >
▶CXOnlyPubKey
CWitnessV1Taproot
▶CPARENT
CAnnotatedMixin< PARENT >	Template mixin that adds -Wthread-safety locking annotations and lock order checking to a subset of the mutex API
▶CQtActivity
Corg.bitcoincore.qt.BitcoinQtActivity