Bitcoin ABC  0.23.6
P2P Digital Currency
Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
[detail level 1234]
 NCuckooCacheHigh-performance cache primitives
 NfsbridgeFilesystem operations and types
 NGUIUtilUtility functions used by the Bitcoin Qt UI
 CAbstractThresholdConditionCheckerAbstract class that implements BIP9-style threshold logic, and caches results
 CAddressBookPageWidget that shows a list of sending or receiving addresses
 CAddressTableModelQt model of the address book in the core
 CAES128DecryptA decryption class for AES-128
 CAES128EncryptAn encryption class for AES-128
 CAES256DecryptA decryption class for AES-256
 CAES256EncryptAn encryption class for AES-256
 CAmountSpinBoxQSpinBox that uses fixed-point numbers internally and uses our own formatting/parsing functions
 CAnnotatedMixinTemplate mixin that adds -Wthread-safety locking annotations and lock order checking to a subset of the mutex API
 CArenaAn arena manages a contiguous region of memory by dividing it into chunks
 Carith_uint256256-bit unsigned big integer
 CAskPassphraseDialogMultifunctional dialog to ask for passphrases
 CBanTableModelQt model providing information about connected peers, similar to the "getpeerinfo" RPC call
 Cbase_blobTemplate base class for fixed-sized opaque blobs
 Cbase_uintTemplate base class for unsigned big integers
 CBaseIndexBase class for indices of blockchain data
 CBaseRequestHandlerClass 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
 CBaseSignatureCreatorInterface for signature creators
 CBerkeleyBatchRAII class that provides access to a Berkeley database
 CBerkeleyDatabaseAn instance of this class represents one database
 Cbilingual_strBilingual messages:
 CBIP9StatsDisplay status of an in-progress BIP9 softfork
 CBitcoinABCClass encapsulating Bitcoin ABC startup and shutdown
 CBitcoinAddressCheckValidatorBitcoin address widget validator, checks for a valid bitcoin address
 CBitcoinAddressEntryValidatorBitcoin address entry widget validator, checks for valid characters and removes some whitespace
 CBitcoinAmountFieldWidget for entering bitcoin amounts
 CBitcoinApplicationMain Bitcoin application object
 CBitcoinGUIBitcoin GUI main class
 CBitcoinUnitsBitcoin unit definitions
 CBlockAssemblerGenerate a new block, without valid proof-of-work
 CBlockFilterComplete block filter struct as defined in BIP 157
 CBlockFilterIndexBlockFilterIndex is used to store and retrieve block filters, hashes, and headers for a range of blocks by height
 CBlockHashA BlockHash is a unqiue identifier for a block
 CBlockHasherMaintain a map of CBlockIndex for all known headers
 CBlockManagerMaintains a tree of blocks (stored in m_block_index) which is consulted to determine where the most-work tip is
 CByteVectorHashImplementation of Hash named requirement for types that internally store a byte array
 CCachableAmountCachable amount subdivided into watchonly and spendable parts
        seen nodes
       /          \

(a) banned nodes available nodes-----------— / | \ tracked nodes (b) unknown nodes (e) active nodes / \ (d) good nodes (c) non-good nodes

 CCAddrDBAccess to the (IP) address database (peers.dat)
 CCAddressA CService with information about it as peer
 CCAddressBookDataAddress book data
 CCAddrInfoExtended statistics about a CAddress
 CCAddrManStochastical (IP) address manager
 CCAutoFileNon-refcounted RAII wrapper for FILE*
 CCBanDBAccess to the banlist database (banlist.dat)
 CCBaseChainParamsCBaseChainParams defines the base parameters (shared between bitcoin-cli and bitcoind) of a given instance of the Bitcoin system
 CCBlockHeaderNodes 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
 CCBlockIndexThe 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
 CCBlockLocatorDescribes 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
 CCBlockTreeDBAccess to the block database (blocks/index/)
 CCBlockUndoUndo information for a CBlock
 CCBloomFilterBloomFilter is a probabilistic filter which SPV clients provide so that we can filter the transactions we send them
 CCBufferedFileNon-refcounted RAII wrapper around a FILE* that implements a ring buffer to deserialize from
 CCChainAn in-memory indexed chain of blocks
 CCChainParamsCChainParams defines various tweakable parameters of a given instance of the Bitcoin system
 CCChainStateCChainState stores and provides an API to update our local knowledge of the current best chain
 CCCheckQueueQueue for verifications that have to be performed
 CCCheckQueueControlRAII-style controller object for a CCheckQueue that guarantees the passed queue is finished before continuing
 CCClientUIInterfaceSignals for UI communication
 CCCoinControlCoin Control Features
 CCCoinsCacheEntryA Coin in one level of the coins database caching hierarchy
 CCCoinsViewAbstract view on the open txout dataset
 CCCoinsViewBackedCCoinsView backed by another CCoinsView
 CCCoinsViewCacheCCoinsView that adds a memory cache for transactions to another CCoinsView
 CCCoinsViewCursorCursor for iterating over CoinsView state
 CCCoinsViewDBCCoinsView backed by the coin database (chainstate/)
 CCCoinsViewDBCursorSpecialization of CCoinsViewCursor to iterate over a CCoinsViewDB
 CCCoinsViewErrorCatcherThis 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
 CCCoinsViewMemPoolCCoinsView that brings transactions from a mempool into view
 CCCrypterEncryption/decryption context with key information
 CCDataStreamDouble ended buffer combining vector and stream-like interfaces
 CCDBBatchBatch of changes queued to be written to a CDBWrapper
 CCDiskBlockIndexUsed to marshal pointers into hashes for db storage
 CCFeeRateFee rate in satoshis per kilobyte: Amount / kB
 CChaCha20A class for ChaCha20 256-bit stream cipher developed by Daniel J
 CChainstateManagerProvides 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
 CChainTxDataHolds various statistics on transactions within a chain
 CCHash160A hasher class for Bitcoin's 160-bit hash (SHA-256 + RIPEMD-160)
 CCHash256A hasher class for Bitcoin's 256-bit hash (double SHA-256)
 CCHashVerifierReads data from an underlying stream, while hashing the read data
 CCHashWriterA writer stream (for serialization) that computes a 256-bit hash
 CCheckInputsLimiterSimple class for regulating resource usage during CheckInputScripts (and CScriptCheck), atomic so as to be compatible with parallel validation
 CCHKDF_HMAC_SHA256_L32A rfc5869 HKDF implementation with HMAC_SHA256 and fixed key output length of 32 bytes (L=32)
 CCHMAC_SHA256A hasher class for HMAC-SHA-256
 CCHMAC_SHA512A hasher class for HMAC-SHA-512
 CCInvInv(ventory) message data
 CCKeyAn encapsulated secp256k1 private key
 CCKeyIDA reference to a CKey: the Hash160 of its serialized public key
 CCKeyPoolA key from a CWallet's keypool
 CClientModelModel for Bitcoin network client
 CCMainParamsMain network
 CCMasterKeyPrivate key encryption is done based on a CMasterKey, which holds a salt and random encryption key
 CCMedianFilterMedian filter over a stream of values
 CCMerkleBlockUsed to create a Merkle proof (usually from a subset of transactions), which consists of a block header and partial Merkle Tree
 CCMerkleTxLegacy class used for deserializing vtxPrev for backwards compatibility
 CCMessageHeaderMessage header
 CCMutableTransactionA mutable version of CTransaction
 CCNetAddrNetwork address
 CCNetMessageTransport protocol agnostic message container
 CCNodeInformation about a peer
 CCNodeStatsPOD that contains various stats about a node
 CCoinA UTXO entry
 CCoinsViewsA convenience class for constructing the CCoinsView* hierarchy used to facilitate access to the UTXO set
 CCompactSizeFormatterFormatter for integers in CompactSize format
 CCompareBlocksByHeightComparison function for sorting the getchaintips heads
 CCompareCTxMemPoolIterComparator for CTxMemPool::txiter objects
 CCompareTxMemPoolEntryByAncestorScoreSort an entry by min(score/size of entry's tx, score/size with all ancestors)
 CCompareTxMemPoolEntryByDescendantScoreSort an entry by max(score/size of entry's tx, score/size with all descendants)
 CCompareTxMemPoolEntryByScoreSort 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
 CConnectTraceUsed to track blocks whose transactions were applied to the UTXO state as a part of a single ActivateBestChainStep call
 CCOutPointAn outpoint - a combination of a transaction hash and an index n into its vout
 CCPartialMerkleTreeData structure that represents a partial merkle tree
 CCPubKeyAn encapsulated public key
 CCreateWalletDialogDialog for creating wallets
 CCRegTestParamsRegression test
 CCRIPEMD160A hasher class for RIPEMD-160
 CCRollingBloomFilterRollingBloomFilter is a probabilistic "keep track of most recently inserted" set
 CCRPCTableBitcoin RPC command dispatcher
 CCScriptSerialized script, used inside transaction inputs and outputs
 CCScriptCheckClosure representing one script verification
 CCScriptIDA reference to a CScript: the Hash160 of its serialization (see script.h)
 CCSemaphoreGrantRAII-style semaphore lock
 CCSerActionSerializeSupport for SERIALIZE_METHODS and READWRITE macro
 CCServiceA combination of a network address (CNetAddr) and a (TCP) port
 CCSHA1A hasher class for SHA1
 CCSHA256A hasher class for SHA-256
 CCSHA512A hasher class for SHA-512
 CCSizeComputerGetSerializeSize implementations
 CCSVModelWriterExport a Qt table model to a CSV file
 CCTestNetParamsTestnet (v3)
 CCThreadInterruptA helper class for interruptible sleeps
 CCTransactionThe basic transaction that is broadcasted on the network and contained in blocks
 CCTxInAn input of a transaction
 CCTxMemPoolCTxMemPool stores valid-according-to-the-current-best-chain transactions that may be included in the next block
 CCTxMemPoolEntryCTxMemPoolEntry stores data about the corresponding transaction, as well as data about all in-mempool transactions that depend on the transaction ("descendant" transactions)
 CCTxOutAn output of a transaction
 CCTxUndoRestore the UTXO in a Coin at a given COutPoint
 CCustomUintFormatterSerialization wrapper class for custom integers and enums
 CCValidationInterfaceImplement this to subscribe to events generated in validation
 CCVectorWriterMinimal stream for overwriting and/or appending to an existing byte vector
 CCVerifyDBRAII wrapper for VerifyDB: Verify consistency of the block and coin databases
 CCWalletA CWallet maintains a set of transactions and balances, and provides the ability to create new transactions
 CCWalletTxA transaction with a bunch of additional info that only the owner cares about
 CDefaultFormatterDefault formatter
 CDefaultRequestHandlerProcess default single requests
 CDescriptorInterface for parsed descriptor objects
 CDescriptorCacheCache for single descriptor's derived extended pubkeys
 Cdeserialize_typeDummy data type to identify deserializing constructors
 CECCVerifyHandleUsers of this module must hold an ECCVerifyHandle
 CEditAddressDialogDialog for editing an address and associated information
 CFastRandomContextFast randomness source
 CFillableSigningProviderFillable signing provider that keeps keys in an address->secret map
 CFlatFileSeqFlatFileSeq represents a sequence of numbered files storing raw data
 CGCSFilterThis implements a Golomb-coded set as defined in BIP 158
 CGetinfoRequestHandlerProcess getinfo requests
 CHelpMessageDialog"Help message" dialog box
 CHTTPClosureEvent handler closure
 CHTTPEventEvent class
 CHTTPReplyReply structure for request_done to fill in
 CHTTPRequestIn-flight HTTP request
 CHTTPRPCTimerSimple one-shot callback timer to be used by the RPC mechanism to e.g
 CHTTPWorkItemHTTP request work item
 CindirectmapMap whose keys are pointers, but are compared by their dereferenced values
 CIntroIntroduction screen (pre-GUI startup)
 CInvRequestTrackerImplActual implementation for InvRequestTracker's data structure
 CInvRequestTrackerImplInterfaceData structure to keep track of, and schedule, inventory downloads from peers
 CJSONUTF8StringFilterFilter that generates and validates UTF-8, as well as collates UTF-16 surrogate pairs as specified in RFC4627
 CLegacySigningProviderWraps a LegacyScriptPubKeyMan so that it can be returned in a new unique_ptr
 CLockedPageAllocatorOS-dependent allocation and deallocation of locked/pinned memory pages
 CLockedPoolPool for locked memory chunks
 CLockedPoolManagerSingleton class to keep track of locked (ie, non-swappable) memory, for use in std::allocator templates
 CMacDockIconHandlerMacOS-specific Dock icon handler
 CMacNotificationHandlerMacintosh-specific notification handler (supports UserNotificationCenter)
 CMainSignalsInstanceThe MainSignalsInstance manages a list of shared_ptr<CValidationInterface> callbacks
 CModalOverlayModal overlay to display information about the chain-sync state
 CMutableTransactionSignatureCreatorA signature creator for transactions
 CNetEventsInterfaceInterface for message handling
 CNetinfoRequestHandlerProcess netinfo requests
 CNodeContextNodeContext struct containing references to chain state and connection state
 CNotificatorCross-platform desktop notification client
 COptionsDialogPreferences dialog
 COptionsModelInterface from Qt to configuration data structure for Bitcoin client
 COverviewPageOverview ("home") page widget
 CPartiallySignedTransactionA version of CTransaction with the PSBT format
 CPeerTableModelQt model providing information about connected peers, similar to the "getpeerinfo" RPC call
 CPosixLockedPageAllocatorLockedPageAllocator specialized for OSes that don't try to be special snowflakes
 CPrecomputedTransactionDataPrecompute sighash midstate to avoid quadratic hashing
 CprevectorImplements a drop-in replacement for std::vector<T> which stores up to N elements directly (without heap allocation)
 CProxyAddressValidatorProxy address widget validator, checks for a valid proxy address
 CProxyCredentialsCredentials for proxy authentication
 CPSBTAnalysisHolds the results of AnalyzePSBT (miscellaneous information about a PSBT)
 CPSBTInputA structure for PSBTs which contain per-input information
 CPSBTInputAnalysisHolds an analysis of one input from a PSBT
 CPSBTOutputA structure for PSBTs which contains per output information
 CQRImageWidgetLabel widget for QR code
 CQtRPCTimerBaseClass for handling RPC timers (used for e.g
 CQValidatedLineEditLine edit that can be marked as "invalid" to show input validation feedback
 CRadixTreeThis is a radix tree storing values identified by a unique key
 CReceiveCoinsDialogDialog for requesting payment of bitcoins
 CRecentRequestsTableModelModel for list of recently generated payment requests / bitcoincash: URIs
 CReserveDestinationA wrapper to reserve an address from a wallet
 Creverse_rangeTemplate used for reverse iteration in C++11 range-based for loops
 CRPCCommandBase class for all RPC commands
 CRPCCommandWithArgsContextBy default, use RPCCommandWithArgsContext as the parent class for new RPC command classes that only depend on RPC arguments
 CRPCConsoleLocal Bitcoin RPC console
 CRPCServerClass for registering and managing all RPC calls
 CRPCTimerBaseOpaque base class for timers returned by NewTimerFunc
 CRPCTimerInterfaceRPC timer "driver"
 CScriptCacheElementIn 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
 CScriptCacheKeyThe 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
 CScriptCompressionCompact serializer for scripts
 CScriptExecutionMetricsStruct for holding cumulative results from executing a script or a sequence of scripts
 CScriptPubKeyManA class implementing ScriptPubKeyMan manages some (or all) scriptPubKeys used in a wallet
 Csecp256k1_ecdsa_recoverable_signatureOpaque data structured that holds a parsed ECDSA signature, supporting pubkey recovery
 Csecp256k1_ecdsa_signatureOpaque data structured that holds a parsed ECDSA signature
 Csecp256k1_geA group element of the secp256k1 curve, in affine coordinates
 Csecp256k1_gejA group element of the secp256k1 curve, in jacobian coordinates
 Csecp256k1_keypairOpaque data structure that holds a keypair consisting of a secret and a public key
 Csecp256k1_multisetOpaque multiset; this is actually a group element
 Csecp256k1_pubkeyOpaque data structure that holds a parsed and valid public key
 Csecp256k1_scalarA scalar modulo the group order of the secp256k1 curve
 Csecp256k1_xonly_pubkeyOpaque data structure that holds a parsed and valid "x-only" public key
 CSectionA pair of strings that can be aligned (through padding) with other Sections later on
 CSectionsKeeps track of RPCArgs by transforming them into sections for the purpose of serializing everything to a single string
 CSendCoinsDialogDialog for sending bitcoins
 CSendCoinsEntryA single entry in the dialog for sending bitcoins
 CShutdownWindow"Shutdown" window
 CSigHashTypeSignature hash type wrapper class
 CSignatureCacheHasherWe're hashing a nonce into the entries themselves, so we don't need extra blinding in the set hash computation
 CSigningProviderAn interface to be implemented by keystores that support signing
 CSingleThreadedSchedulerClientClass used by CScheduler clients which may schedule multiple jobs which are required to be run serially
 CSnapshotMetadataMetadata describing a serialized version of a UTXO set from which an assumeutxo CChainState can be constructed
 CSpanA Span is an object that can refer to a contiguous sequence of objects
 CSplashScreenClass for the splashscreen with information of the running client
 CThirdPartyTxUrlsValidatorThird party tx URL validator, checks for an https link
 CTorControlConnectionLow-level handling for Tor control connection
 CTorControllerController that connects to Tor control socket, authenticate, then create and maintain an ephemeral hidden service
 CTorControlReplyReply from Tor, can be single or multi-line
 CTransactionDescProvide a human-readable extended HTML description of a transaction
 CTransactionDescDialogDialog showing transaction details
 CTransactionFilterProxyFilter the transaction list according to pre-specified rules
 CTransactionRecordUI model for a transaction
 CTransactionStatusUI model for transaction status
 CTransactionTableModelUI model for the transaction table of a wallet
 CTransactionViewWidget showing the transaction list for a wallet, including a filter row
 CTransportDeserializerThe TransportDeserializer takes care of holding and deserializing the network receive buffer
 CTransportSerializerThe TransportSerializer prepares messages for the network transport
 CTxHashA TxHash is the double sha256 hash of the full transaction data
 CTxIdA TxId is the identifier of a transaction
 CTxIndexTxIndex is used to look up transactions included in the blockchain by ID
 CTxInUndoFormatterFormatter for undo information for a CTxIn
 CTxMempoolInfoInformation about a mempool transaction
 CTxOutCompressionWrapper for CTxOut that provides a more compact serialization
 Cuint160160-bit opaque blob
 Cuint256256-bit opaque blob
 CUniqueLockWrapper around std::unique_lock style lock for Mutex
 CUniValueTypeWrapper for UniValue::VType, which includes typeAny: used to denote don't care type
 CValidationStateTemplate for capturing information about block/transaction validation
 CVarIntFormatterSerialization wrapper class for integers in VarInt format
 CVectorFormatterFormatter to serialize/deserialize vector elements using another formatter
 CVectorReaderMinimal stream for reading from an existing vector by reference
 CVersionBitsCacheBIP 9 allows multiple softforks to be deployed in parallel
 CWalletBatchAccess to the wallet database
 CWalletContextWalletContext struct containing references to state shared between CWallet instances, like the reference to the chain interface, and the list of opened wallets
 CWalletControllerController between interfaces::Node, WalletModel instances and the GUI
 CWalletDescriptorDescriptor with some wallet metadata
 CWalletFrameA container for embedding all wallet-related controls into BitcoinGUI
 CWalletLocationWallet information
 CWalletModelInterface to Bitcoin wallet from Qt view code
 CWalletModelTransactionData model for a walletmodel transaction
 CWalletRescanReserverRAII object to check and reserve a wallet rescan
 CWalletTestingSetupTesting setup and teardown for wallet
 CWalletViewWalletView class
 CWorkQueueSimple work queue for distributing work over multiple threads
 CWrapperSimple wrapper class to serialize objects using a formatter; used by Using()