Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 1234]

►Nankerl
►Nnanobench
►Ndetail
CIterationLogic
CPerfCountSet
CPerformanceCounters
CBench	Main entry point to nanobench's benchmarking facility
CBigO
CConfig
CResult
CRng	An extremely fast random generator
►NBCLog
►CLogger
CBufferedLog
►CLogRateLimiter	Fixed window rate limiter for logging
CStats	Keeps track of an individual source location and how many available bytes are left for logging from it
CTimer	RAII-style object that outputs timing information to logs
►Nbech32
CDecodeResult
►Nbenchmark
CArgs
CBenchRunner
►Nbitset_detail
►CIntBitSet	A bitset implementation backed by a single integer of type I
CIterator	Iterator type returned by begin(), which efficiently iterates all 1 positions
CIteratorEnd	Dummy type to return using end()
►CMultiIntBitSet	A bitset implementation backed by N integers of type I
CIterator	Iterator type returned by begin(), which efficiently iterates all 1 positions
CIteratorEnd	Dummy type to return using end()
►Nbloom_tests
CBloomTest
►Nbtck
CBlock
CBlockHash
CBlockHashApi
CBlockHashView
CBlockSpentOutputs
CBlockTreeEntry
CBlockValidationState
CChainMan
CChainParams
CChainstateManagerOptions
CChainView
CCoin
CCoinApi
CCoinView
CContext
CContextOptions
CHandle
Cis_bitmask_enum
Cis_bitmask_enum< ScriptVerificationFlags >
CIterator
CKernelNotifications
CLogger
COutPoint
COutPointApi
COutPointView
CRange
CScriptPubkey
CScriptPubkeyApi
CScriptPubkeyView
CTransaction
CTransactionApi
CTransactionInput
CTransactionInputApi
CTransactionInputView
CTransactionOutput
CTransactionOutputApi
CTransactionOutputView
CTransactionSpentOutputs
CTransactionSpentOutputsApi
CTransactionSpentOutputsView
CTransactionView
CTxid
CTxidApi
CTxidView
►CUniqueHandle
CDeleter
CValidationInterface
CView
►Ncluster_linearize
CAncestorCandidateFinder	Class encapsulating the state needed to find the best remaining ancestor set
►CDepGraph	Data structure that holds a transaction graph's preprocessed data (fee, size, ancestors, descendants)
CEntry	Information about a single transaction
CLinearizationChunking	Data structure encapsulating the chunking of a linearization, permitting removal of subsets
CSearchCandidateFinder	Class encapsulating the state needed to perform search for good candidate sets
CSetInfo	A set of transactions together with their aggregate feerate
►Ncommon
CConfigError
CSettings	Stored settings
CSettingsSpan	Accessor for list of settings that skips negated values when iterated over
►NConsensus	Transaction validation functions
CBIP9Deployment	Struct for each individual consensus rule change using BIP9
CParams	Parameters that influence chain consensus
►Ncrypto_tests
CCryptoTest
►NCuckooCache	High-performance cache primitives
Cbit_packed_atomic_flags	bit_packed_atomic_flags implements a container for garbage collection flags that is only thread unsafe on calls to setup
Ccache	cache implements a cache with properties similar to a cuckoo-set
►Nfs	Filesystem operations and types
Cpath	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)
►Nfsbridge	Bridge operations to C stdio
CFileLock
►NGUIUtil	Utility functions used by the Bitcoin Qt UI
CClickableLabel
CClickableProgressBar
CItemDelegate
CLabelOutOfFocusEventFilter	Qt event filter that intercepts QEvent::FocusOut events for QLabel objects, and resets their ‘textInteractionFlags’ property to get rid of the visible cursor
CThemedLabel
CToolTipToRichTextFilter	Qt event filter that intercepts ToolTipChange events, and replaces the tooltip with a rich text representation if needed
►Ni2p
►Nsam
►CSession	I2P SAM session
CReply	A reply from the SAM proxy
CConnection	An established connection with another peer
►Ninterfaces
CBlockAndHeaderTipInfo	Block and header tip information
CBlockInfo	Block data sent with blockConnected, blockDisconnected notifications
CBlockRef	Hash/height pair to help track and identify blocks
CBlockTemplate	Block template interface
CBlockTip	Block tip (could be a header or not, depends on the subscribed signal)
►CChain	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
CNotifications	Chain notifications
CNotifyOptions	Options specifying which chain notifications are required
CChainClient	Interface to let node manage chain clients (wallets, or maybe tools for monitoring and analysis in the future)
CEcho	Simple string echoing interface for testing
CExternalSigner	External signer interface used by the GUI
CFoundBlock	Helper for findBlock to selectively return pieces of block data
CHandler	Generic interface for managing an event handler or callback function registered with another interface
CInit	Initial interface created when a process is first started, and used to give and get access to other interfaces (Node, Chain, Wallet, etc)
CIpc	Interface providing access to interprocess-communication (IPC) functionality
CMining	Interface giving clients (RPC, Stratum v2 Template Provider in the future) ability to create block templates
CNode	Top-level interface for a bitcoin node (bitcoind process)
CWallet	Interface for accessing a wallet
CWalletAddress	Information about one wallet address
CWalletBalances	Collection of wallet balances
CWalletLoader	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
CWalletMigrationResult	Migrated wallet info
CWalletTx
CWalletTxOut	Wallet transaction output
CWalletTxStatus	Updated transaction status
►Nipc
►Ncapnp
CContext	Cap'n Proto context struct
CContext	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
CException	Exception class thrown when a call to remote method fails due to an IPC error, like a socket getting disconnected
CProcess	IPC process interface for spawning bitcoin processes and serving requests in processes that have been spawned
CProtocol	IPC protocol interface for calling IPC methods over sockets
►Nkernel
CBlockManagerOpts	An options struct for BlockManager, more ergonomically referred to as BlockManager::Options due to the using-declaration in BlockManager
CBlockTreeDB	Access to the block database (blocks/index/)
CCacheSizes
CCBlockFileInfo
CCCoinsStats
CChainstateManagerOpts	An options struct for ChainstateManager, more ergonomically referred to as ChainstateManager::Options due to the using-declaration in ChainstateManager
CContext	Context struct holding the kernel library's logically global state, and passed to external libbitcoin_kernel functions which need access to this state
CInterrupted	Result type for use with std::variant to indicate that an operation should be interrupted
CMemPoolLimits	Options struct containing limit options for a CTxMemPool
CMemPoolOptions	Options struct containing options for constructing a CTxMemPool
CNotifications	A base class defining functions for notifying about certain kernel events
►Nmemusage
Clist_node
Cstl_shared_counter
Cstl_tree_node
Cunordered_node
►Nminer_tests
CMinerTestingSetup
►Nminiscript
►Ninternal
CInputResult	A pair of a satisfaction and a dissatisfaction InputStack
CInputStack	An object representing a sequence of witness stack elements
CMaxInt	Class whose objects represent the maximum of a list of integers
CNoDupCheck
COps
CSatInfo	A data structure to help the calculation of stack size limits
CStackSize
CWitnessSize
CNode	A node in a miniscript expression
CType	This type encapsulates the miniscript type system properties
►Nmp	Functions to serialize / deserialize common bitcoin types
►Ntest
CExtendedCallback
CFooCallback
CFooCustom
CFooEmpty
CFooImplementation
CFooMessage
CFooMutable
CFooStruct
CTestSetup	Test setup class creating a two way connection between a ProxyServer<FooInterface> object and a ProxyClient<FooInterface>
C_Require	SFINAE helper, see using Require below
CAccessor	Accessor type holding flags that determine how to access a message field
CCapRequestTraits
CCapRequestTraits<::capnp::Request< _Params, _Results > >
►CClientException
CBuildParams
CReadResults
CClientInvokeContext
►CClientParam
CBuildParams
CReadResults
CConnection	Object holding network & rpc state associated with either an incoming server connection, or an outgoing client connection
CEventLoop	Event loop implementation
CEventLoopRef	Event loop smart pointer automatically managing m_num_clients
CFunctionTraits	Function traits class used to get method parameter and result types, used in generated ProxyClient and ProxyServer classes produced by gen.cpp to get C++ method type information
CFunctionTraits< _Result(_Class::*const)(_Params...)>	Specialization of above extracting result and params types assuming the template argument is a pointer-to-method type, decltype(&ClassName::methodName)
CGuardedRef
CInvokeContext
CIterateFields
CIterateFieldsHelper
CListOutput
CListOutput<::capnp::List< T, kind > >
CLock
CLogger
CLoggingErrorHandler	Handler for kj::TaskSet failed task events
CLogMessage
CLogOptions
CPriority	Function parameter type for prioritizing overloaded function calls that would otherwise be ambiguous
CPriority< 0 >	Specialization of above (base case)
CProxyCallback	Wrapper around std::function for passing std::function objects between client and servers
CProxyCallback< std::function< Result(Args...)> >	Specialization of above to separate Result and Arg types
CProxyCallbackImpl	Adapter to convert ProxyCallback object call to function object call
CProxyCallFn
CProxyClient	Mapping from capnp interface type to proxy client implementation (specializations are generated by proxy-codegen.cpp)
CProxyClient< Thread >
CProxyClientBase	Base class for generated ProxyClient classes that implement a C++ interface and forward calls to a capnp interface
CProxyClientCustom	Customizable (through template specialization) base class used in generated ProxyClient implementations from proxy-codegen.cpp
CProxyClientMethodTraits	Customizable (through template specialization) traits class used in generated ProxyClient implementations from proxy-codegen.cpp
CProxyContext	Context data associated with proxy client and server classes
CProxyMethod	Mapping from capnp method params type to method traits (specializations are generated by proxy-codegen.cpp)
CProxyMethodTraits	Traits class for a proxy method, providing the same Params/Result/Param/Fields described in the FunctionTraits class above, plus an additional invoke() method that calls the C++ method which is being proxied, forwarding any arguments
CProxyMethodTraits< MethodParams, Require< decltype(ProxyMethod< MethodParams >::impl)> >	Specialization of above for proxy methods that have a ProxyMethod<InterfaceName::MethodNameParams>::impl pointer-to-method constant defined by generated code
CProxyServer	Mapping from capnp interface type to proxy server implementation (specializations are generated by proxy-codegen.cpp)
CProxyServer< Thread >
CProxyServer< ThreadMap >
CProxyServerBase	Base class for generated ProxyServer classes that implement capnp server methods and forward calls to a wrapped c++ implementation class
CProxyServerCustom	Customizable (through template specialization) base class which ProxyServer classes produced by generated code will inherit from
CProxyServerMethodTraits	Customizable (through template specialization) traits class used in generated ProxyServer implementations from proxy-codegen.cpp
CProxyStruct	Mapping from capnp struct type to struct traits (specializations are generated by proxy-codegen.cpp)
CProxyType	Mapping from local c++ type to capnp type and traits (specializations are generated by proxy-codegen.cpp)
CProxyTypeRegister	Map to convert client interface pointers to ProxyContext struct references at runtime using typeids
CPtrOrValue	Convenient wrapper around std::variant<T*, T>
CReadDestEmplace
CReadDestUpdate	Destination parameter type that can be passed to ReadField function as an alternative to ReadDestEmplace
CServerCall
CServerDestroy
CServerExcept
CServerField
CServerInvokeContext
CServerRet
CServerVatId	Vat id for server side of connection
CSplit	Type helper splitting a TypeList into two halves at position index
CSplit< 0, _Second, _First, true >	Specialization of above (base case)
CSplit< index, TypeList< Type, _Second... >, TypeList< _First... >, false >	Specialization of above (recursive case)
CStructField
CThreadContext	The thread_local ThreadContext g_thread_context struct provides information about individual threads and a way of communicating between them
CTypeList	Generic utility functions used by capnp code
CUnlockGuard	Analog to std::lock_guard that unlocks instead of locks
CValueField
CWaiter	Single element task queue used to handle recursive capnp calls
►Nnode
CAncestorFeerateComparator
►CBlockAssembler	Generate a new block, without valid proof-of-work
COptions
CBlockCheckOptions
CBlockCreateOptions
CBlockfileCursor
CBlockManager	Maintains a tree of blocks (stored in m_block_index) which is consulted to determine where the most-work tip is
CBlockWaitOptions
CCacheSizes
CCBlockIndexHeightOnlyComparator
CCBlockIndexWorkComparator
CCBlockTemplate
CChainstateLoadOptions
CImportingNow
CImportMempoolOptions
CIndexCacheSizes
CIteratorComparator
CKernelNotifications
CMiniMiner	A minimal version of BlockAssembler, using the same ancestor set scoring algorithm
CMiniMinerMempoolEntry
CNodeContext	NodeContext struct containing references to chain state and connection state
CPackageToValidate
CPruneLockInfo
CPSBTAnalysis	Holds the results of AnalyzePSBT (miscellaneous information about a PSBT)
CPSBTInputAnalysis	Holds an analysis of one input from a PSBT
CRejectedTxTodo
CSnapshotMetadata	Metadata describing a serialized version of a UTXO set from which an assumeutxo Chainstate can be constructed
CTxDownloadConnectionInfo
CTxDownloadManager	Class responsible for deciding what transactions to request and, once downloaded, whether and how to validate them
►CTxDownloadManagerImpl
CPeerInfo
CTxDownloadOptions
►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 amount of announcements (unique (NodeId, wtxid) pairs), the number of inputs, and size of the orphans stored (both individual and summed)
COrphanInfo	Allows providing orphan information externally
►CTxOrphanageImpl
CAnnouncement	One orphan announcement
CByPeer
CByPeerViewExtractor
CByWtxid
COrphanIndices
CPeerDoSInfo
CWtxidExtractor
CWarnings	Manages warning messages within a node
►Npoly1305_donna
Cpoly1305_context
►Npyminisketch
CGF2Ops
CMinisketch
CTestGF2Ops
CTestMinisketch
CTestPolyFindRoots
►Nspannable
CIgnore
CSpannableNo
CSpannableYes
►Nsubprocess
►Ndetail
CArgumentDeducer
CChild
CCommunication
CStreams
CBuffer
CCalledProcessError
Cerror
Cexecutable
Cinput
COSError
Coutput
CPopen
Cstring_arg
►Nsymbol-check
CUnexpectedExport
►Ntestnet4_miner_tests
CTestnet4MinerTestingSetup
►Ntinyformat
►Ndetail
CconvertToInt
CconvertToInt< T, true >
CFormatArg
CFormatListN
CFormatListN< 0 >
CformatValueAsType
CformatValueAsType< T, fmtT, true >
►Cis_convertible
Cfail
Csucceed
Cis_wchar
Cis_wchar< const wchar_t * >
Cis_wchar< const wchar_t[n]>
Cis_wchar< wchar_t * >
Cis_wchar< wchar_t[n]>
Cformat_error
CFormatList	List of template arguments format(), held in a type-opaque way
CFormatStringCheck
CRuntimeFormat
►Nutil
►Ndetail
CHex
CBilingualFmt
CConstevalFormatString	A wrapper for a compile-time partially validated format string
CError
CExpected	The util::Expected class provides a standard way for low-level functions to return either error values or result values
CImmediateTaskRunner
COverloaded	Overloaded helper for std::visit
CResult
CSignalInterrupt	Helper class that manages an interrupt flag, and allows a thread or signal to interrupt another thread
CTaskRunnerInterface
CTranslatedLiteral	Compile-time literal string that can be translated with an optional translation function
CUnexpected	The util::Unexpected class represents an unexpected value stored in util::Expected
►Nvalidation_block_tests
CMinerTestingSetup
►Nwallet
►Nfeebumper
CSignatureWeightChecker
CSignatureWeights
CBalance
CBerkeleyROBatch	RAII class that provides access to a BerkeleyRODatabase
CBerkeleyROCursor
CBerkeleyRODatabase	A class representing a BerkeleyDB file from which we can only read records
CBytePrefix
CCachableAmount	Cachable amount subdivided into avoid reuse and all balances
CCAddressBookData	Address book data
CCCoinControl	Coin Control Features
CCCrypter	Encryption/decryption context with key information
CCHDChain
CCKeyMetadata
CCMasterKey	Private key encryption is done based on a CMasterKey, which holds a salt and random encryption key
CCMerkleTx	Legacy class used for deserializing vtxPrev for backwards compatibility
CCoinEligibilityFilter	Parameters for filtering which OutputGroups we may use in coin selection
CCoinFilterParams
CCoinSelectionParams	Parameters for one iteration of Coin Selection
CCoinsResult	COutputs available for spending, stored by OutputType
CCOutput	A UTXO under consideration for use in funding a new transaction
CCOutputEntry
CCreatedTransactionResult
CCRecipient
►CCWallet	A CWallet maintains a set of transactions and balances, and provides the ability to create new transactions
CAddrBookFilter
CScanResult
CCWalletTx	A transaction with a bunch of additional info that only the owner cares about
CDatabaseBatch	RAII class that provides access to a WalletDatabase
CDatabaseCursor
CDatabaseOptions
CDataRecord	Class for data in the record directly
CDbExecBlocker
CDbTxnListener
CDescribeWalletAddressVisitor
CDescriptorScriptPubKeyMan
CDummyDescriptor
CExternalSignerScriptPubKeyMan
CFuzzedWallet	Wraps a descriptor wallet for fuzzing
CGroups
CGroupVerifier
CInitWalletDirTestingSetup
CInternalPage	A page of records in the database
CInternalRecord	Class for records representing internal nodes of the BTree
CLegacyDataSPKM
CLegacySigningProvider	Wraps a LegacyScriptPubKeyMan so that it can be returned in a new unique_ptr
CListCoinsTestingSetup
CLoadResult
CMetaPage	Berkeley DB BTree metadata page layout
CMigrationData	Struct containing information needed for migrating legacy wallets to descriptor wallets
CMigrationResult
CMinOutputGroupComparator
CMockableBatch
CMockableCursor
CMockableDatabase	A WalletDatabase whose contents and return values can be modified as needed for testing
COutputGroup	A group of UTXOs paid to the same output script
COutputGroupTypeMap	Stores several 'Groups' whose were mapped by output type
COverflowPage	A page containing overflow data
COverflowRecord	Class for records representing overflow records of the BTree
CPageHeader	A generic data page in the database
CPreselectedInput
CPreSelectedInputs
CRecordHeader	General class for records in a BDB BTree database
CRecordsPage	A page of records in the database
CReserveDestination	A wrapper to reserve an address from a wallet
CScriptPubKeyMan
CSelectionFilter
CSelectionResult
CSQLiteBatch	RAII class that provides access to a WalletDatabase
CSQLiteCursor	RAII class that provides a database cursor
CSQLiteDatabase	An instance of this class represents one SQLite3 database
CSQliteExecHandler	Class responsible for executing SQL statements in SQLite databases
Ctallyitem
CTestCrypter
CTxSize
CTxStateBlockConflicted	State of rejected transaction that conflicts with a confirmed block
CTxStateConfirmed	State of transaction confirmed in a block
CTxStateInactive	State of transaction not confirmed or conflicting with a known block and not in the mempool
CTxStateInMempool	State of transaction added to mempool
CTxStateUnrecognized	State of transaction loaded in an unrecognized state with unexpected hash or index values
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
CWalletDescriptor	Descriptor with some wallet metadata
CWalletDestination
CWalletInit
CWalletRescanReserver	RAII object to check and reserve a wallet rescan
CWalletStorage
CWalletTestingSetup	Testing setup and teardown for wallet
CWalletTXO
CWalletTxOrderComparator
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
CAddressBookPage	Widget that shows a list of sending or receiving addresses
CAddressBookSortFilterProxyModel
CAddressBookTests
CAddressPosition	Location information for an address in AddrMan
CAddressTableEntry
CAddressTableEntryLessThan
CAddressTableModel	Qt model of the address book in the core
CAddressTablePriv
CAddrInfo	Extended statistics about a CAddress
CAddrinfoRequestHandler	Process addrinfo requests
CAddrMan	Stochastic address manager
CAddrManDeterministic
►CAddrManImpl
CNewTriedCount
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
CAmountSpinBox	QSpinBox that uses fixed-point numbers internally and uses our own formatting/parsing functions
CAnnotatedMixin	Template mixin that adds -Wthread-safety locking annotations and lock order checking to a subset of the mutex API
►CAppTests
CHandleCallback	RAII helper to remove no-longer-pending callback
►CArena
CStats	Memory statistics
CArgMap
►CArgsManager
CArg
CCommand
CArgsMergeTestingSetup
Carith_uint256	256-bit unsigned big integer
CAskPassphraseDialog	Multifunctional dialog to ask for passphrases
CAssumeutxoData	Holds configuration for use during UTXO snapshot load and validation
CAssumeutxoHash
CAutoFile	Non-refcounted RAII wrapper for FILE*
CAvailable
CBanMan
CBannedNodeLessThan
CBanTableModel	Qt model providing information about banned peers, similar to the "getpeerinfo" RPC call
CBanTablePriv
CBase	(Un)serialize a number as raw byte or 2 hexadecimal chars
Cbase_blob	Template base class for fixed-sized opaque blobs
Cbase_uint	Template base class for unsigned big integers
CBaseFormat
CBaseHash
►CBaseIndex	Base class for indices of blockchain data
CDB	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
CBaseRequestHandler	Handle 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
CBehaviors
Cbench_data
Cbench_ecdh_data
Cbench_ellswift_data
Cbench_inv
Cbench_recover_data
Cbench_schnorrsig_data
Cbilingual_str	Bilingual messages:
CBIP324Cipher	The BIP324 packet cipher, encapsulating its key derivation, stream cipher, and AEAD
►CBIP9GBTStatus
CInfo
CBIP9Info	Detailed status of an enabled BIP9 deployment
CBIP9Stats	Display status of an in-progress BIP9 softfork
CBitcoinAddressCheckValidator	Bitcoin address widget validator, checks for a valid bitcoin address
CBitcoinAddressEntryValidator	Base58 entry widget validator, checks for valid characters and removes some whitespace
CBitcoinAmountField	Widget for entering bitcoin amounts
CBitcoinApplication	Main Bitcoin application object
CBitcoinGUI	Bitcoin GUI main class
CBitcoinUnits	Bitcoin unit definitions
►Cbitdeque	Class that mimics std::deque<bool>, but with std::vector<bool>'s bit packing
CIterator	Iterator to a bitdeque element, const or not
CBitReader
CBitsInt
CBitStreamReader
CBitStreamWriter
CBitWriter
CBlockFilter	Complete block filter struct as defined in BIP 157
CBlockFilterIndex	BlockFilterIndex is used to store and retrieve block filters, hashes, and headers for a range of blocks by height
CBlockFiltersScanReserver
CBlockHasher
CBlockTransactions
CBlockTransactionsRequest
CBlockValidationState
CBlockValidationStateCatcher
CBlockVersionTest
Cbtck_Block
Cbtck_BlockHash
Cbtck_BlockSpentOutputs
Cbtck_BlockTreeEntry
Cbtck_BlockValidationState
Cbtck_Chain
Cbtck_ChainParameters
Cbtck_ChainstateManager
Cbtck_ChainstateManagerOptions
Cbtck_Coin
Cbtck_Context
Cbtck_ContextOptions
Cbtck_LoggingConnection
Cbtck_LoggingOptions	Options controlling the format of log messages
Cbtck_NotificationInterfaceCallbacks	A struct for holding the kernel notification callbacks
Cbtck_ScriptPubkey
Cbtck_Transaction
Cbtck_TransactionInput
Cbtck_TransactionOutPoint
Cbtck_TransactionOutput
Cbtck_TransactionSpentOutputs
Cbtck_Txid
Cbtck_ValidationInterfaceCallbacks	Holds the validation interface callbacks
CBufferedFile	Wrapper around an AutoFile& that implements a ring buffer to deserialize from
CBufferedReader	Wrapper that buffers reads from an underlying stream
CBufferedWriter	Wrapper that buffers writes to an underlying stream
CBuildChainTestingSetup
CByteVectorHash	Implementation of Hash named requirement for types that internally store a byte array
CCacheTest
CCachingTransactionSignatureChecker
►CCAddress	A CService with information about it as peer
CSerParams
CCalculator
CCalculatorImpl
►CCAppNapInhibitor
CCAppNapImpl
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
CCBitcoinLevelDBLogger
CCBlock
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
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
CTxStatsInfo
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
CRegTestOptions	RegTestOptions holds configurations for creating a regtest CChainParams
CSigNetOptions	SigNetOptions holds configurations for creating a signet CChainParams
CVersionBitsParameters	VersionBitsParameters holds activation parameters
CCCheckQueue	Queue for verifications that have to be performed
CCCheckQueueControl	RAII-style controller object for a CCheckQueue that guarantees the passed queue is finished before continuing
CCClientUIInterface	Signals for UI communication
CCCoin
CCCoinControlWidgetItem
CCCoinsCacheEntry	A Coin in one level of the coins database caching hierarchy
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
CCCoinsViewCursor	Cursor for iterating over CoinsView state
CCCoinsViewDB	CCoinsView backed by the coin database (chainstate/)
CCCoinsViewDBCursor	Specialization of CCoinsViewCursor to iterate over a CCoinsViewDB
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
CCCombinedBan
CCConnectionFailed
►CCConnman
CCachedAddrResponse	Cache responses to addr requests to minimize privacy leak
CListenSocket
CNodesSnapshot	RAII helper to atomically create a copy of m_nodes and add a reference to each of the nodes
COptions
CReconnectionInfo	Struct for entries in m_reconnections
►CCDBBatch	Batch of changes queued to be written to a CDBWrapper
CWriteBatchImpl
►CCDBIterator
CIteratorImpl
CCDBWrapper
CCDiskBlockIndex	Used to marshal pointers into hashes for db storage
CCDiskTxPos
CCExtKey
CCExtPubKey
CCFeeRate	Fee rate in satoshis per virtualbyte: CAmount / vB the feerate is represented internally as FeeFrac
CChaCha20	Unrestricted ChaCha20 cipher
CChaCha20Aligned	ChaCha20 cipher that only operates on multiples of 64 bytes
CChainMergeTestingSetup
CChainstate	Chainstate stores and provides an API to update our local knowledge of the current best chain
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
CChainTestingSetup	Testing setup that performs all steps up until right before ChainstateManager gets initialized
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)
CCheckGlobals
CCheckGlobalsImpl
CCheckQueueTest
►CCheckValueTest	Test GetSetting and GetArg type coercion, negation, and default value handling
CExpect
CCheckVarIntMode
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
CCInv	Inv message data
CCKey	An encapsulated private key
CCKeyID	A reference to a CKey: the Hash160 of its serialized public key
CClientModel	Model for Bitcoin network client
CCMainParams	Main network on which people trade goods and services
CCMerkleBlock	Used to relay blocks as header + vector<merkle branch> to filtered nodes
CCMessageHeader	Message header
CCMutableTransaction	A mutable version of CTransaction
►CCNetAddr	Network address
CSerParams
CCNetCleanup
CCNetMessage	Transport protocol agnostic message container
CCNode	Information about a peer
CCNodeCombinedStats
CCNodeOptions
CCNodeStateStats
CCNodeStats
CCNoDestination
CCoin	A UTXO entry
CCoinControlDialog
CCoinControlTreeWidget
CCoinEntry
CCoinStatsIndex	CoinStatsIndex maintains statistics on the UTXO set
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
CCommandLine
CCompactSizeFormatter	Formatter for integers in CompactSize format
CCompactSizeWriter
CCompareBlocksByHeight	Comparison function for sorting the getchaintips heads
CCompareIteratorByHash
CCompareNodeNetworkTime	Sort eviction candidates by network/localhost and connection uptime
CCompareTxMemPoolEntryByEntryTime
CCompressedHeader
CConnectTrace	Used to track blocks whose transactions were applied to the UTXO state as a part of a single ActivateBestChainStep call
CConnmanTestMsg
CCountingSemaphoreGrant	RAII-style semaphore lock
CCOutPoint	An outpoint - a combination of a transaction hash and an index n into its vout
CCPartialMerkleTree	Data structure that represents a partial merkle tree
CCPartialMerkleTreeTester
CCPubKey	An encapsulated public key
CCreateWalletActivity
CCreateWalletDialog	Dialog for creating wallets
CCRegTestParams	Regression test: intended for private networks only
CCRIPEMD160	A hasher class for RIPEMD-160
CCRollingBloomFilter	RollingBloomFilter is a probabilistic "keep track of most recently inserted" set
CCRPCCommand
CCRPCConvertParam
CCRPCTable	RPC command dispatcher
CCScheduler	Simple class for background tasks that should be run periodically or once "after a while"
CCScript	Serialized script, used inside transaction inputs and outputs
CCScriptCheck	Closure representing one script verification Note that this stores references to the spending transaction
CCScriptID	A reference to a CScript: the Hash160 of its serialization
CCScriptNum
CCScriptNum10
CCScriptWitness
CCSerializedNetMsg
CCSerializeMethodsTestMany
CCSerializeMethodsTestSingle
CCService	A combination of a network address (CNetAddr) and a (TCP) port
CCServiceHash
CCSHA1	A hasher class for SHA1
CCSHA256	A hasher class for SHA-256
CCSHA512	A hasher class for SHA-512
CCSipHasher	General SipHash-2-4 implementation
CCSubNet
►CCSVModelWriter	Export a Qt table model to a CSV file
CColumn
Cctaes_test
CCTestNet4Params	Testnet (v4): public test network which is reset from time to time
CCTestNetParams	Testnet (v3): public test network which is reset from time to time
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
CChangeSet
CCTxMemPoolEntry_Indices
Cdelta_info
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	Undo information for a CTransaction
CCustomUintFormatter	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
CCZMQAbstractNotifier
CCZMQAbstractPublishNotifier
CCZMQNotificationInterface
CCZMQPublishHashBlockNotifier
CCZMQPublishHashTransactionNotifier
CCZMQPublishRawBlockNotifier
CCZMQPublishRawTransactionNotifier
CCZMQPublishSequenceNotifier
CDataStream	Double ended buffer combining vector and stream-like interfaces
CDBOptions	User-controlled performance and debug options
CDBParams	Application-specific storage settings
Cdbwrapper_error
CDebugLogHelper
CDefaultFormatter	Default formatter
CDefaultRequestHandler	Process default single requests
CDeferringSignatureChecker
CDereferencingComparator
CDerived
CDerivedAndBaseFormat
CDersig100Setup
CDescribeAddressVisitor
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
CDisconnectedBlockTransactions	DisconnectedBlockTransactions
CDummyChainState
CDummyTorControlConnection
CDummyWalletInit
►CDynSock	A mocked Sock alternative that allows providing the data to be returned by Recv() and inspecting the data that has been supplied to Send()
CPipe	Unidirectional bytes or CNetMessage queue (FIFO)
CPipes
CQueue	A basic thread-safe queue, used for queuing sockets to be returned by Accept()
CECC_Context	RAII class initializing and deinitializing global state for elliptic curve support
Cecmult_multi_data
CECRYPT_ctx
CEditAddressDialog	Dialog for editing an address and associated information
CElapseSteady
Cellswift_decode_test
Cellswift_xdh_test
Cellswift_xswiftec_inv_test
CEllSwiftPubKey	An ElligatorSwift-encoded public key
Centry_time
CEnvTestingSetup	Save the log level and the value of CreateSock and restore them when the test ends
►CEpoch	Epoch: RAII-style guard for using epoch-based graph traversal algorithms
CGuard
CMarker
CEraseParallelTest
CEraseTest
CEstimationResult
CEstimatorBucket
CExternalSigner	Enables interaction with an external signing device or service, such as a hardware wallet
CFakeCheck
CFakeCheckCheckCompletion
CFastRandomContext	Fast randomness source
CFeeCalculation
CFeeFilterRounder
CFeeFrac	Data structure storing a fee and size, ordered by increasing fee/size
CFeePerUnit	Tagged wrapper around FeeFrac to avoid unit confusion
CFillableSigningProvider	Fillable signing provider that keeps keys in an address->secret map
CFilterHeaderHasher
CFixedCheck
CFlatFilePos
CFlatFileSeq	FlatFileSeq represents a sequence of numbered files storing raw data
CFlatSigningProvider
CFlushTest
CFooImplementation
CFormat
►CFreespaceChecker
CPathQuery
CFrozenCleanupCheck
CFSChaCha20	Forward-secure ChaCha20
CFSChaCha20Poly1305	Forward-secure wrapper around AEADChaCha20Poly1305
CFuzzedDataProvider
CFuzzedFileProvider
CFuzzedHeadersSyncState
CFuzzedNetEvents
CFuzzedSock
CFuzzedThreadInterrupt	Mocked CThreadInterrupt that returns "randomly" whether it is interrupted and never sleeps
CFuzzTarget
CFuzzTargetOptions
►CGCSFilter	This implements a Golomb-coded set as defined in BIP 158
CParams
CGenerateToAddressRequestHandler	Process RPC generatetoaddress request
CGenerationsTest
CGenericTransactionSignatureChecker
CGenTxid
CGetinfoRequestHandler	Process getinfo requests
CGFMulHelper	Helper class for carryless multiplications
CGFMulHelper< I, N, L, F, 0 >
CGlobalMutex	Different type to mark Mutex at global scope
CHashedSourceWriter	Writes data to an underlying source stream, while hashing the written data
CHashVerifier	Reads data from an underlying stream, while hashing the read data
CHashWriter	A writer stream (for serialization) that computes a 256-bit hash
CHasJSON
CHasReason	BOOST_CHECK_EXCEPTION predicates to check the specific validation error
CHeadersGeneratorSetup
CHeadersSyncParams	Configuration for headers sync memory usage
►CHeadersSyncState	HeadersSyncState:
CProcessingResult	Result data structure for ProcessNextHeaders
CHelpMessageDialog	"Help message" dialog box
CHelpResult
CHidingSigningProvider
CHitRateTest
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
CHTTPWorkItem	HTTP request work item
CIdTrans	The identity transformation
Cindex_by_wtxid
CIndexReorgCrash
CIndexSummary
Cindirectmap
CInit
CInitExecutor	Class encapsulating Bitcoin Core startup and shutdown
CInitImpl
CInitTestSetup	Like BasicTestingSetup, but using regtest network instead of mainnet
CInsecureRandomContext	Xoroshiro128++ PRNG
CIntro	Introduction screen (pre-GUI startup)
CInvalidAddrManVersionError
CJSONRPCRequest
CJSONUTF8StringFilter	Filter that generates and validates UTF-8, as well as collates UTF-16 surrogate pairs as specified in RFC4627
CKernelLog
CKeyInfo
CKeyOriginInfo
CKeyPair	KeyPair
CLevelDBContext
CLFSR	Class which implements a stateless LFSR for generic moduli
CLimitedStringFormatter
CLinTrans	A Linear N-bit transformation over the field I
CLoadWalletsActivity
CLocalServiceInfo
CLockedPageAllocator	OS-dependent allocation and deallocation of locked/pinned memory pages
►CLockedPool	Pool for locked memory chunks
CLockedPageArena	Create an arena from locked pages
CStats	Memory statistics
CLockedPoolManager	Singleton class to keep track of locked (ie, non-swappable) memory, for use in std::allocator templates
CLockPoints
CLogCategory
CLogIPsTestingSetup
CLogSetup
CMacDockIconHandler	MacOS-specific Dock icon handler
CMacNotificationHandler	Macintosh-specific notification handler (supports UserNotificationCenter)
CMappingResult	Successful response to a port mapping
CMemoryCheck
CMempoolAcceptResult	Validation result for a transaction evaluated by MemPoolAccept (single or package)
Cmempoolentry_txid
Cmempoolentry_wtxid
CMemPoolTest
CMergeTestingSetup
CMigrateWalletActivity
CMockableSteadyClock	Version of SteadyClock that is mockable in the context of tests (set the current value with SetMockTime), otherwise the system steady clock
CMockedDescriptorConverter	Converts a mocked descriptor string to a valid one
CModalOverlay	Modal overlay to display information about the chain-sync state
CMuHash3072	A class representing MuHash sets
CMultiSigningProvider	A signing provider to be used to interface with multiple signing providers at once
CMuSig2SecNonce	MuSig2SecNonce encapsulates a secret nonce in use in a MuSig2 signing session
CMuSig2SecNonceImpl
Cmusig_key_agg_error_test_case
Cmusig_key_agg_valid_test_case
Cmusig_key_agg_vector
Cmusig_nonce_agg_test_case
Cmusig_nonce_agg_vector
Cmusig_nonce_gen_test_case
Cmusig_nonce_gen_vector
Cmusig_sig_agg_case
Cmusig_sig_agg_vector
Cmusig_sign_error_case
Cmusig_sign_verify_vector
Cmusig_tweak_case
Cmusig_tweak_vector
Cmusig_valid_case
Cmusig_verify_fail_error_case
CMutableTransactionSignatureCreator	A signature creator for transactions
CNetEventsInterface	Interface for message handling
CNetGroupManager	Netgroup manager
►CNetinfoRequestHandler	Process netinfo requests
CPeer
CNetPermissions
CNetWhitebindPermissions
CNetWhitelistPermissions
CNetworkDisable	RAII class that disables the network in its constructor and enables it in its destructor
CNetworkSetup
CNetworkStyle
CNewMempoolTransactionInfo
CNoCopy
CNodeClock	Mockable clock in the context of tests, otherwise the system clock
CNodeEvictionCandidate
CNoechoInst
CNoIncludeConfTest
CNoLockLoggingTestingSetup	Identical to TestingSetup but excludes lock contention logging if DEBUG_LOCKCONTENTION is defined, as some of these tests are designed to be heavily contested to trigger race conditions or other issues
CNonFatalCheckError
Cnontrivial_t
CNotificator	Cross-platform desktop notification client
CNSBundle(returnCorrectIdentifier)
CNum	A type to represent integers in the type system
CNum3072
CObfuscation
COpenURIDialog
COpenWalletActivity
COptionsDialog	Preferences dialog
COptionsModel	Interface from Qt to configuration data structure for Bitcoin client
COptionTests
COtherParam
COtherParamChecker	Checker for value of OtherParam
COutboundTest
COverviewPage	Overview ("home") page widget
CPackageMempoolAcceptResult	Validation result for package mempool acceptance
CPackageValidationState
CParamsStream	Wrapper that overrides the GetParams() function of a stream
CParamsWrapper	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
CPaymentServer
CPayToAnchor
CPCPTestingSetup	Save the value of CreateSock and restore when the test ends
CPCPTestSock	Simple scripted UDP server emulation for testing
CPeerIdViewDelegate
►CPeerManager
COptions
CPeerManagerInfo
CPeerTableModel	Qt model providing information about connected peers, similar to the "getpeerinfo" RPC call
CPeerTableSortProxy
CPeerTest
CPerBlockConnectTrace
CPKHash
CPlainCopyTextEdit	A version of QTextEdit that only populates plaintext mime data from a selection, this avoids some bad behavior in QT's HTML->Markdown conversion
CPlatformStyle
CPoly1305	C++ wrapper with std::byte span interface around poly1305_donna code
►CPoolAllocator	Forwards all allocations/deallocations to the PoolResource
Crebind	The rebind struct here is mandatory because we use non type template arguments for PoolAllocator
►CPoolResource	A memory resource similar to std::pmr::unsynchronized_pool_resource, but optimized for node-based containers
CListNode	In-place linked list of the allocations, used for the freelist
►CPoolResourceTester	Helper to get access to private parts of PoolResource
CPtrAndBytes
CPosixLockedPageAllocator	LockedPageAllocator specialized for OSes that don't try to be special snowflakes
CPrecomputedTransactionData
CPrefilledTransaction
CPresaltedSipHasher	Optimized SipHash-2-4 implementation for uint256
CPreSelectInputs
►Cprevector	Implements a drop-in replacement for std::vector<T> which stores up to N elements directly (without heap allocation)
Cconst_iterator
Cdirect_or_indirect
Citerator
Cprevector_tester
CPrinter
CPrinterImpl
CProxy
CProxyAddressValidator	Proxy address widget validator, checks for a valid proxy address
CProxyCredentials	Credentials for proxy authentication
CProxySetting
CPSBTInput	A structure for PSBTs which contain per-input information
CPSBTOperationsDialog	Dialog showing transaction details
CPSBTOutput	A structure for PSBTs which contains per output information
CPSBTProprietary	A structure for PSBT proprietary types
CPubKeyDestination
CQRImageWidget
CQValidatedLineEdit	Line edit that can be marked as "invalid" to show input validation feedback
CQValueComboBox
CRandomMixin	Mixin class that provides helper randomness functions
CReachableNets	List of reachable networks
CReceiveCoinsDialog	Dialog for requesting payment of bitcoins
CReceiveRequestDialog
CRecentRequestEntry
CRecentRequestEntryLessThan
CRecentRequestsTableModel	Model for list of recently generated payment requests / bitcoin: URIs
CRecLinTrans	A linear transformation constructed using LinTrans tables for sections of bits
CRecLinTrans< I, N >
CRecLinTrans< I, N, X... >
CRegTestingSetup	Identical to TestingSetup, but chain set to regtest
CRemovedMempoolTransactionInfo
CReorgTxns	Reorg where 1 block is disconnected and 2 blocks are connected
CRestoreWalletActivity
CRPCArg
CRPCArgOptions
CRPCCommandExecution
CRPCCommandExecutionInfo
►CRPCConsole	Local Bitcoin RPC console
CTranslatedStrings
CRPCExamples
CRPCExecutor
CRPCHelpMan
CRPCNestedTests
CRPCResult
CRPCResults
CRPCServerInfo
CRPCTestingSetup
CSaltedOutpointHasher
CSaltedSipHasher
CSaltedTxidHasher
CSaltedUint256Hasher
CSaltedWtxidHasher
CSatisfier	Context for solving a Miniscript
CScopedScheduler
Cscript_verify_flags
CScriptCompression	Compact serializer for scripts
CScriptErrorDesc
CScriptExecutionData
CScriptHash
Cscriptnum10_error
Cscriptnum_error
CScriptTest
Csecp256k1_callback
Csecp256k1_context_struct
Csecp256k1_ecdsa_recoverable_signature	Opaque data structure that holds a parsed ECDSA signature, supporting pubkey recovery
Csecp256k1_ecdsa_signature	Opaque data structure 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_keyagg_cache_internal
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_musig_aggnonce	Opaque data structure that holds an aggregate public nonce
Csecp256k1_musig_keyagg_cache	This module implements BIP 327 "MuSig2 for BIP340-compatible Multi-Signatures" (https://github.com/bitcoin/bips/blob/master/bip-0327.mediawiki) v1.0.0
Csecp256k1_musig_partial_sig	Opaque data structure that holds a partial MuSig signature
Csecp256k1_musig_pubkey_agg_ecmult_data
Csecp256k1_musig_pubnonce	Opaque data structure that holds a signer's public nonce
Csecp256k1_musig_secnonce	Opaque data structure that holds a signer's secret nonce
Csecp256k1_musig_session	Opaque data structure that holds a MuSig session
Csecp256k1_musig_session_internal
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
CSecureUniqueDeleter
CSendCoinsDialog	Dialog for sending bitcoins
CSendCoinsEntry	A single entry in the dialog for sending bitcoins
CSendCoinsRecipient
CSendConfirmationDialog
CSerialTaskRunner	Class used by CScheduler clients which may schedule multiple jobs which are required to be run serially
CSHA3_256
CShortestVectorFirstComparator
CShutdownWindow	"Shutdown" window
CSigHashCache	Data structure to cache SHA256 midstates for the ECDSA sighash calculations (bare, P2SH, P2WPKH, P2WSH)
CSigHashTest
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
Csigner
Csigner_secrets	This file demonstrates how to use the MuSig module to create a 3-of-3 multisignature
CSigNetParams	Signet: test network with an additional consensus parameter (see BIP325)
CSignetTxs	Generate the signet tx corresponding to the given block
CSigningProvider	An interface to be implemented by keystores that support signing
CSignVerifyMessageDialog
CSingleEntryCacheTest
CSipHashState	Shared SipHash internal state v[0..3], initialized from (k0, k1)
CSizeComputer
CSketch	Abstract class for internal representation of a minisketch object
CSketchImpl
CSnapshotTestSetup
►CSock	RAII helper class that manages a socket and closes it automatically when it goes out of scope
CEqualSharedPtrSock
CEvents	Auxiliary requested/occurred events to wait for in WaitMany()
CHashSharedPtrSock
CSourceLocationEqual
CSourceLocationHasher
CSpanReader	Minimal stream for reading from an existing byte array by std::span
CSplashScreen	Class for the splashscreen with information of the running client
CStaticContentsSock	A mocked Sock alternative that returns a statically contained data upon read and succeeds and ignores all writes
CStdLockGuard
CStdMutex
CStopHashingException
CStringContentsSerializer
Csubmitblock_StateCatcher
►CTaprootBuilder	Utility class to construct Taproot outputs from internal key and script tree
CLeafInfo	Information about a tracked leaf in the Merkle tree
CNodeInfo	Information associated with a node in the Merkle tree
CTaprootSpendData
CTapSatisfier	Miniscript satisfier specific to Tapscript context
CTemporaryRollback	RAII class that temporarily rolls back the local chain in it's constructor and rolls it forward again in it's destructor
Ctest_hsort_cmp_data
Ctest_only_CheckFailuresAreExceptionsNotAborts
CTestArgsManager
CTestChain100Setup	Testing fixture that pre-creates a 100-block REGTEST-mode block chain
CTestChainstateManager
CTestConditionChecker
CTestDirectory
CTestHeaderAndShortIDs
CTestingSetup	Testing setup that configures a complete environment
CTestInit	Remote init class
CTestInterface
CTestKernelNotifications
CTestLockedPageAllocator	Mock LockedPageAllocator for testing
CTestLog
CTestMemPoolEntryHelper
CTestnet4Setup	Identical to TestingSetup, but chain set to testnet4
CTestOp	UDP test server operation
CTestOpts
CTestSubscriber
CTestSubscriberNoop
CTestValidationInterface
Ctf_args
Ctf_framework
Ctf_targets
Ctf_test_entry
Ctf_test_module
CTimeOffsets
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
CTorStreamIsolationCredentialsGenerator	Generate unique credentials for Tor stream isolation
CTrafficGraphWidget
Ctransaction_identifier	Transaction_identifier represents the two canonical transaction identifier types (txid, wtxid)
CTransactionDesc	Provide a human-readable extended HTML description of a transaction
CTransactionDescDialog	Dialog showing transaction details
CTransactionFilterProxy	Filter the transaction list according to pre-specified rules
CTransactionInfo
CTransactionNotification
CTransactionOverviewWidget
CTransactionRecord	UI model for a transaction
CTransactionSerParams
CTransactionStatus	UI model for transaction status
CTransactionTableModel	UI model for the transaction table of a wallet
CTransactionTablePriv
CTransactionView	Widget showing the transaction list for a wallet, including a filter row
►CTransport	The Transport converts one connection's sent messages to wire bytes, and received bytes back
CInfo
CTxConfirmStats	We will instantiate an instance of this class to track transactions that were included in a block
►CTxGraph	Data structure to encapsulate fees, sizes, and dependencies for a set of transactions
CBlockBuilder	Interface returned by GetBlockBuilder
CRef
►CTxIndex	TxIndex is used to look up transactions included in the blockchain by hash
CDB	Access to the txindex database (indexes/txindex/)
CTxInUndoFormatter	Formatter for undo information for a CTxIn
CTxLessThan
CTxMempoolInfo	Information about a mempool transaction
CTxOutCompression	Wrapper for CTxOut that provides a more compact serialization
CTxPackageTest
►CTxReconciliationTracker	Transaction reconciliation is a way for nodes to efficiently announce transactions
CImpl	Actual implementation for TxReconciliationTracker's data structure
►CTxRequestTracker	Data structure to keep track of, and schedule, transaction downloads from peers
CImpl	Actual implementation for TxRequestTracker's data structure
CTxValidationState
CTxViewDelegate
Cuint160	160-bit opaque blob
Cuint256	256-bit opaque blob
Cuint_error
CUISignals
CUncopyableStream
CUniqueCheck
►CUniqueLock	Wrapper around std::unique_lock style lock for MutexType
Creverse_lock	An RAII-style reverse lock
CUnitDisplayStatusBarControl
►CUniValue
Ctype_error
CUniValueType	Wrapper for UniValue::VType, which includes typeAny: Used to denote don't care type
CUpdateTest
CURITests
CV1Transport
CV2Transport
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
CListEntry	List entries consist of a callback pointer and reference count
CValidationState	Template for capturing information about block/transaction validation
CVarIntFormatter	Serialization wrapper class for integers in VarInt format
CVBDeploymentInfo
CVecDeque	Data structure largely mimicking std::deque, but using single preallocated ring buffer
CVectorFormatter	Formatter to serialize/deserialize vector elements using another formatter
CVectorWriter
CVersionBitsCache	BIP 9 allows multiple softforks to be deployed in parallel
CVersionBitsConditionChecker	Class to implement versionbits logic
CVersionBitsTester
CVSizeTag
CWalletController	Controller between interfaces::Node, WalletModel instances and the GUI
CWalletControllerActivity
CWalletFrame	A container for embedding all wallet-related controls into BitcoinGUI
CWalletInitInterface
►CWalletModel	Interface to Bitcoin wallet from Qt view code
CSendCoinsReturn
CUnlockContext
CWalletModelTransaction	Data model for a walletmodel transaction
CWalletTests
CWalletView
CWeightTag
CWitnessUnknown	CTxDestination subtype to encode any future Witness version
CWitnessV0KeyHash
CWitnessV0ScriptHash
CWitnessV1Taproot
CWorkQueue	Simple work queue for distributing work over multiple threads
CWrapper	Simple wrapper class to serialize objects using a formatter; used by Using()
CWshSatisfier	Miniscript satisfier specific to P2WSH context
Cwycheproof_ecdh_testvector
Cwycheproof_ecdsa_testvector
CXOnlyPubKey
Czero_after_free_allocator
CZeroSock	A mocked Sock alternative that succeeds on all operations