| ▶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 | |
| CAES128CBCDecrypt | |
| CAES128CBCEncrypt | |
| CAES128Decrypt | A decryption class for AES-128 |
| CAES128Encrypt | An encryption class for AES-128 |
| CAES192_ctx | |
| CAES256_ctx | |
| CAES256CBCDecrypt | |
| CAES256CBCEncrypt | |
| CAES256Decrypt | A decryption class for AES-256 |
| CAES256Encrypt | An encryption class for AES-256 |
| CAES_state | |
| CAggregator< T > | |
| ▶Callocator | |
| Cmt_pooled_secure_allocator< T > | |
| Cpooled_secure_allocator< T > | |
| ▶Cpooled_secure_allocator< uint8_t > | |
| Cmt_pooled_secure_allocator< T >::internal_pool | |
| Csecure_allocator< T > | |
| Czero_after_free_allocator< T > | |
| Cancestor_score | |
| Cimmer::gc_transience_policy::apply< HeapPolicy > | |
| Cimmer::no_transience_policy::apply< typename > | |
| Cimmer::atom< T, MemoryPolicy >::get_gc_atom_impl::apply< U, MP > | |
| Cimmer::atom< T, MemoryPolicy >::get_refcount_atom_impl::apply< U, MP > | |
| ▶CArena | |
| CLockedPool::LockedPageArena | Create an arena from locked pages |
| CArgsManager | |
| CArgsManagerHelper | Internal helper functions for ArgsManager |
| Cimmer::array< T, MemoryPolicy > | |
| Cimmer::atom< T, MemoryPolicy > | |
| CBannedNodeLessThan | |
| CBanTablePriv | |
| ▶CBase | |
| Cimmer::detail::unsafe_free_list_heap_impl< Storage, Size, Limit, Base > | |
| Cimmer::free_list_heap< Size, Limit, Base > | |
| Cimmer::identity_heap< Base > | |
| Cimmer::with_data< T, Base > | |
| ▶Cimmer::detail::unsafe_free_list_heap_impl< detail::thread_local_free_list_storage, Size, Limit, Base > | |
| Cimmer::thread_local_free_list_heap< Size, Limit, Base > | |
| ▶Cimmer::detail::unsafe_free_list_heap_impl< detail::unsafe_free_list_storage, Size, Limit, Base > | |
| Cimmer::unsafe_free_list_heap< Size, Limit, Base > | |
| ▶Cimmer::with_data< free_list_node, Base > | |
| Cimmer::with_free_list_node< Base > | |
| 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 |
| CCScriptID | A reference to a CScript: the Hash160 of its serialization (see script.h) |
| ▶Cbase_blob< 256 > | |
| Cuint256 | 256-bit opaque blob |
| ▶Cbase_blob< 512 > | |
| Cuint512 | 512-bit unsigned big integer |
| Cbase_uint< BITS > | Template base class for unsigned big integers |
| ▶Cbase_uint< 256 > | |
| Carith_uint256 | 256-bit unsigned big integer |
| ▶CBaseRequestHandler | Class that handles the conversion from a command-line to a JSON-RPC request, as well as converting back to a JSON object that can be shown as result |
| CDefaultRequestHandler | Process default single requests |
| CGetinfoRequestHandler | Process getinfo requests |
| ▶CBaseSignatureChecker | |
| ▶CTransactionSignatureChecker | |
| CCachingTransactionSignatureChecker | |
| CMutableTransactionSignatureChecker | |
| ▶CBaseSignatureCreator | Virtual base class for signature creators |
| CDummySignatureCreator | A signature creator that just produces 72-byte empty signatures |
| ▶CTransactionSignatureCreator | A signature creator for transactions |
| CMutableTransactionSignatureCreator | |
| CContributionVerifier::BatchState | |
| Cbench_data | |
| Cbench_ecdh_data | |
| Cbench_inv | |
| Cbench_recover_data | |
| Cbench_sign | |
| Cbenchmark_verify_t | |
| Cbenchmark::BenchRunner | |
| CBerkeleyBatch | RAII class that provides access to a Berkeley database |
| CBerkeleyDatabase | An instance of this class represents one database |
| CBerkeleyEnvironment | |
| Cbenchmark::best_clock | |
| CConsensus::BIP9Deployment | Struct for each individual consensus rule change using BIP9 |
| CBIP9Stats | |
| 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 |
| CBlockAssembler | Generate a new block, without valid proof-of-work |
| CBlockHasher | |
| CBlockTransactions | |
| CBlockTransactionsRequest | |
| Cimmer::box< T, MemoryPolicy > | |
| CCAccount | Account information |
| CCAccountingEntry | Internal transfers |
| CCuckooCache::cache< Element, Hash > | Cache implements a cache with properties similar to a cuckoo-set |
| CCacheItem< K, V > | Serializable structure for key/value items |
| CCacheMap< K, V, Size > | Map like container that keeps the N most recently added items |
| CCacheMap< uint256, CGovernanceObject * > | |
| CCacheMap< uint256, CGovernanceVote > | |
| CCacheMultiMap< K, V, Size > | Map like container that keeps the N most recently added items |
| CCacheMultiMap< uint256, vote_time_pair_t > | |
| CCActiveMasternodeInfo | |
| CCAddrDB | Access to the (IP) address database (peers.dat) |
| CCAddressBookData | Address book data |
| CCAddressIndexIteratorHeightKey | |
| CCAddressIndexIteratorKey | |
| CCAddressIndexKey | |
| CCAddressUnspentKey | |
| CCAddressUnspentValue | |
| CCAddrMan | Stochastical (IP) address manager |
| CCConnman::CAllNodes | |
| CCAppNapInhibitor::CAppNapImpl | |
| CCAppNapInhibitor | |
| CCAutoBitSet | Serializes either as a CFixedBitSet or CFixedVarIntsBitSet, depending on which would give a smaller size |
| CCAutoFile | Non-refcounted RAII wrapper for FILE* |
| CCBanDB | Access to the banlist database (banlist.dat) |
| CCBanEntry | |
| ▶CCBase58Data | Base class for all base58-encoded data |
| CCBitcoinExtKeyBase< K, Size, Type > | |
| CCBitcoinSecret | A base58-encoded secret key |
| ▶CCBaseChainParams | CBaseChainParams defines the base parameters (shared between dash-cli and dashd) of a given instance of the Dash system |
| CCBaseDevNetParams | Devnet |
| CCBaseMainParams | Main network |
| CCBaseRegTestParams | |
| CCBaseTestNetParams | Testnet (v3) |
| ▶CCBatchedLogger | |
| Cllmq::CDKGLogger | |
| Cllmq::CBatchedSigShares | |
| 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 |
| 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 | We want to be able to estimate feerates that are needed on tx's to be included in 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 |
| CCBLSBatchVerifier< SourceId, MessageId > | |
| ▶CCBLSIESEncryptedBlob | |
| CCBLSIESEncryptedObject< Object > | |
| ▶CCBLSIESMultiRecipientBlobs | |
| CCBLSIESMultiRecipientObjects< Object > | |
| CCBLSLazyWrapper< BLSObject > | |
| CCBLSLazyWrapper< CBLSPublicKey > | |
| CCBLSLazyWrapper< CBLSSignature > | |
| CCBLSWorker | |
| CCBLSWorkerCache | |
| CCBLSWrapper< ImplType, _SerSize, C > | |
| ▶CCBLSWrapper< bls::InsecureSignature, BLS_CURVE_SIG_SIZE, CBLSSignature > | |
| CCBLSSignature | |
| ▶CCBLSWrapper< bls::PrivateKey, BLS_CURVE_SECKEY_SIZE, CBLSSecretKey > | |
| CCBLSSecretKey | |
| ▶CCBLSWrapper< bls::PublicKey, BLS_CURVE_PUBKEY_SIZE, CBLSPublicKey > | |
| CCBLSPublicKey | |
| ▶CCBLSWrapper< uint256, BLS_CURVE_ID_SIZE, CBLSId > | |
| CCBLSId | |
| CCBufferedFile | Non-refcounted RAII wrapper around a FILE* that implements a ring buffer to deserialize from |
| CCCbTx | |
| CCChain | An in-memory indexed chain of blocks |
| Cllmq::CChainLockSig | |
| ▶CCChainParams | CChainParams defines various tweakable parameters of a given instance of the Dash system |
| CCDevNetParams | Devnet |
| CCMainParams | Main network |
| CCRegTestParams | Regression test |
| CCTestNetParams | Testnet (v3) |
| CCChainState | CChainState stores and provides an API to update our local knowledge of the current best chain and header tree |
| 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 | |
| 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 dashd, and dash-qt and non-server tools |
| CCCoinsViewMemPool | CCoinsView that brings transactions from a memorypool 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 | |
| CCCompactSize | |
| CCConnman | |
| CCCriticalBlock | Wrapper around std::unique_lock<CCriticalSection> |
| 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 | |
| CCDBTransaction< Parent, CommitTarget > | |
| CCDBTransaction< CDBWrapper, CDBBatch > | |
| CCDBTransaction< RootTransaction, RootTransaction > | |
| CCDBTransactionIterator< CDBTransaction > | |
| ▶CCDBWrapper | |
| CCBlockTreeDB | Access to the block database (blocks/index/) |
| CCDeterministicMN | |
| CCDeterministicMNList | |
| CCDeterministicMNListDiff | |
| CCDeterministicMNListDiff_OldFormat | |
| CCDeterministicMNManager | |
| CCDeterministicMNState | |
| CCDeterministicMNStateDiff | |
| ▶CCDiskBlockPos | |
| CCDiskTxPos | |
| Cllmq::CDKGComplaint | |
| Cllmq::CDKGContribution | |
| Cllmq::CDKGDebugManager | |
| Cllmq::CDKGDebugMemberStatus | |
| Cllmq::CDKGDebugSessionStatus | |
| Cllmq::CDKGDebugStatus | |
| Cllmq::CDKGJustification | |
| Cllmq::CDKGMember | |
| Cllmq::CDKGPendingMessages | Acts as a FIFO queue for incoming DKG messages |
| Cllmq::CDKGPrematureCommitment | |
| Cllmq::CDKGSession | The DKG session is a single instance of the DKG process |
| Cllmq::CDKGSessionHandler | Handles multiple sequential sessions of one specific LLMQ type |
| Cllmq::CDKGSessionManager | |
| CCDynamicBitSet | |
| CCEvoDB | |
| CCEvoDBScopedCommitter | |
| CCExplicitNetCleanup | |
| CCExtKey | |
| CCExtPubKey | |
| CCFeeRate | Fee rate in satoshis per kilobyte: CAmount / kB |
| Cllmq::CFinalCommitment | |
| Cllmq::CFinalCommitmentTxPayload | |
| CCFixedBitSet | |
| CCFixedVarIntsBitSet | Stores a fixed size bitset as a series of VarInts |
| CCFlatData | Wrapper for serializing arrays and POD |
| CCFlatDB< T > | Generic Dumping and Loading
|
| CCConnman::CFullyConnectedOnly | |
| CCGetSimplifiedMNListDiff | P2P messages |
| CCGovernanceManager | |
| ▶CCGovernanceObject | Governance Object |
| CCSuperblock | Trigger : Superblock |
| CCGovernanceObjectVoteFile | Represents the collection of votes associated with a given CGovernanceObject Recently received votes are held in memory until a maximum size is reached after which older votes a flushed to a disk file |
| CCGovernancePayment | Governance Object Payment |
| CCGovernanceTriggerManager | Trigger Mananger |
| CCGovernanceVote | |
| CCGovernanceVoting | Governance Voting |
| CChaCha20 | A class for ChaCha20 256-bit stream cipher developed by Daniel J |
| CChaCha20Poly1305AEAD | |
| CChainTxData | |
| Cimmer::detail::hamts::champ< T, Hash, Equal, MemoryPolicy, B > | |
| Cimmer::detail::hamts::champ< value_t, hash_key, equal_key, default_memory_policy, default_bits > | |
| Cimmer::detail::hamts::champ< value_t, hash_key, equal_key, MemoryPolicy, B > | |
| 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) |
| CCHashSigner | Helper class for signing hashes and checking their signatures |
| ▶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 |
| CCHDAccount | |
| CCHDChain | |
| CCHDPubKey | |
| CCHMAC_SHA256 | A hasher class for HMAC-SHA-256 |
| CCHMAC_SHA512 | A hasher class for HMAC-SHA-512 |
| CCImportingNow | |
| CCInit | |
| CCInputCoin | |
| Cllmq::CInstantSendDb | |
| Cllmq::CInstantSendLock | |
| CCInv | Inv message data |
| CCKeePassIntegrator::CKeePassEntry | |
| CCKeePassIntegrator | |
| CCKeePassIntegrator::CKeePassRequest | |
| CCKeePassIntegrator::CKeePassResponse | |
| CCKey | An encapsulated private key |
| CCKeyHolder | |
| CCKeyHolderStorage | |
| CCKeyMetadata | |
| CCKeyPool | A key pool entry |
| ▶CCKeyStore | A virtual base class for key stores |
| ▶CCBasicKeyStore | Basic key store, that keeps keys in an address->secret map |
| ▶CCCryptoKeyStore | Keystore which keeps the private keys encrypted |
| CCWallet | A CWallet is an extension of a keystore, which also maintains a set of transactions and balances, and provides the ability to create new transactions |
| Cllmq::CLLMQUtils | |
| CCLogCategoryActive | |
| CCLogCategoryDesc | |
| CCMainCleanup | |
| CCMainSignals | |
| CCMasterKey | Private key encryption is done based on a CMasterKey, which holds a salt and random encryption key |
| CCMasternodeMetaInfo | |
| CCMasternodeMetaMan | |
| CCMasternodePayments | |
| CCMasternodeSync | |
| CCMasternodeUtils | |
| CCMedianFilter< T > | Median filter over a stream of values |
| CCMempoolAddressDelta | |
| CCMempoolAddressDeltaKey | |
| CCMempoolAddressDeltaKeyCompare | |
| CCMerkleBlock | Used to relay blocks as header + vector<merkle branch> to filtered nodes |
| ▶CCMerkleTx | A transaction with a merkle branch linking it to the block chain |
| CCWalletTx | A transaction with a bunch of additional info that only the owner cares about |
| CCMessageHeader | Message header |
| CCMessageSigner | Helper class for signing messages and checking their signatures |
| CCMNAuth | This class handles the p2p message MNAUTH |
| CCMnemonic | Copyright (c) 2013-2014 Tomas Dzetkulic Copyright (c) 2013-2014 Pavol Rusnak |
| CCMutableTransaction | A mutable version of CTransaction |
| ▶CCNetAddr | IP address (IPv6, or IPv4 using mapped IPv6 range (::FFFF:0:0/96)) |
| ▶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 |
| CCNetCleanup | |
| CCNetFulfilledRequestManager | |
| CCNetMessage | |
| CCNetMsgMaker | |
| CCNetProcessingCleanup | |
| CCNode | Information about a peer |
| CCNodeCombinedStats | |
| CCNodeStateStats | |
| CCNodeStats | |
| CCNoDestination | |
| CCoin | A UTXO entry |
| Cimmer::detail::hamts::node< T, Hash, Equal, MemoryPolicy, B >::collision_t | |
| CCSVModelWriter::Column | |
| Cimmer::detail::combine_standard_layout< Ts > | |
| Cimmer::detail::csl::combine_standard_layout_aux< Ts > | |
| Cimmer::detail::csl::combine_standard_layout_aux< T > | |
| Cimmer::detail::csl::combine_standard_layout_aux< T, Ts... > | |
| Cimmer::map< K, T, Hash, Equal, MemoryPolicy, B >::combine_value | |
| CCombinerAll | |
| CCompactTallyItem | |
| CCompareBlocksByHeight | Comparison function for sorting the getchaintips heads |
| CCompareByPriority | |
| CCompareCTxMemPoolIter | Comparator for CTxMemPool::txiter objects |
| CCompareInputBIP69 | Implementation of BIP69 https://github.com/bitcoin/bips/blob/master/bip-0069.mediawiki |
| CCompareInputCoinBIP69 | |
| CCompareInvMempoolOrder | |
| CCTxMemPool::CompareIteratorByHash | |
| CCompareOutputBIP69 | |
| CCompareScoreMN | |
| 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 score of entry ((fee+delta)/size) in descending order |
| CCompareValueOnly | |
| Cimmer::detail::rbts::concat_center_pos< Node > | |
| Cimmer::detail::rbts::concat_merger< Node > | |
| Cimmer::detail::rbts::concat_merger_mut< Node > | |
| ▶Cimmer::detail::rbts::concat_rebalance_plan< B, BL > | |
| Cimmer::detail::rbts::concat_rebalance_plan_mut< B, BL > | |
| ▶Cconditional | |
| Cimmer::get_transience_policy< RefcountPolicy > | |
| 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 | |
| Cimmer::detail::constantly< T, value > | |
| Cllmq::CDKGSessionManager::ContributionsCacheEntry | |
| Cllmq::CDKGSessionManager::ContributionsCacheKey | |
| CContributionVerifier | |
| Ctinyformat::detail::convertToInt< T, convertible > | |
| Ctinyformat::detail::convertToInt< T, true > | |
| CCOrphanTx | |
| 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 |
| CCPendingDsaRequest | |
| Cimmer::cpp_heap | |
| CCPrivateSend | |
| CCPrivateSendAccept | |
| ▶CCPrivateSendBaseManager | |
| CCPrivateSendClientManager | Used to keep track of current status of mixing pool |
| CCPrivateSendServer | Used to keep track of current status of mixing pool |
| ▶CCPrivateSendBaseSession | |
| CCPrivateSendClientSession | |
| CCPrivateSendServer | Used to keep track of current status of mixing pool |
| CCPrivateSendBroadcastTx | Helper class to store mixing transaction (tx) information |
| CCPrivateSendEntry | |
| CCPrivateSendQueue | A currently in progress mixing merge and denomination information |
| CCPrivateSendStatusUpdate | |
| CCProposalValidator | |
| CCProRegTx | |
| CCProUpRegTx | |
| CCProUpRevTx | |
| CCProUpServTx | |
| CCPubKey | An encapsulated public key |
| Cllmq::CQuorum | An object of this class represents a quorum which was mined on-chain (through a quorum commitment) It at least contains informations about the members and the quorum public key which is needed to verify recovered signatures from this quorum |
| Cllmq::CQuorumBlockProcessor | |
| Cllmq::CQuorumManager | The quorum manager maintains quorums which were mined on chain |
| Ccrash_info | |
| Ccrash_info_header | |
| CCRateCheckBuffer | |
| CCRecipient | |
| Cllmq::CRecoveredSig | |
| Cllmq::CRecoveredSigsDb | |
| ▶Cllmq::CRecoveredSigsListener | |
| Cllmq::CChainLocksHandler | |
| Cllmq::CInstantSendManager | |
| Cllmq::CSigSharesManager | |
| ▶CCReserveScript | |
| CCReserveKey | A key allocated from the key pool |
| CCRIPEMD160 | A hasher class for RIPEMD-160 |
| CCRollingBloomFilter | RollingBloomFilter is a probabilistic "keep track of most recently inserted" set |
| CCRPCCommand | |
| CCRPCConvertParam | |
| CCRPCConvertTable | |
| CCRPCSignals | |
| CCRPCTable | Dash RPC command dispatcher |
| CCScheduler | |
| CCScriptCheck | Closure representing one script verification Note that this stores references to the spending transaction |
| CCScriptCompressor | Compact serializer for scripts |
| CCScriptNum | |
| CCSemaphore | |
| CCSemaphoreGrant | RAII-style semaphore lock |
| CCSerActionSerialize | Support for ADD_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 |
| Cllmq::CSignedSession | |
| Cllmq::CSigningManager | |
| Cllmq::CSigSesAnn | |
| Cllmq::CSigShare | |
| Cllmq::CSigSharesInv | |
| Cllmq::CSigSharesNodeState | |
| CCSimplifiedMNList | |
| CCSimplifiedMNListDiff | |
| CCSimplifiedMNListEntry | |
| CCSipHasher | SipHash-2-4 |
| CCSizeComputer | |
| CCSpentIndexKey | |
| CCSpentIndexKeyCompare | |
| CCSpentIndexTxInfo | |
| CCSpentIndexValue | |
| CCSporkDef | |
| CCSporkManager | CSporkManager is a higher-level class which manages the node's spork messages, rules for which sporks should be considered active/inactive, and processing for certain sporks (e.g |
| CCSporkMessage | Sporks are network parameters used primarily to prevent forking and turn on/off certain features |
| CCSubNet | |
| CCSuperblockManager | Superblock Manager |
| Cctaes_test | |
| CCThreadInterrupt | |
| CCTimestampIndexIteratorKey | |
| CCTimestampIndexKey | |
| CCTransaction | The basic transaction that is broadcasted on the network and contained in blocks |
| CCTransactionBuilder | Enables simple transaction generation for a given CWallet object |
| CCTransactionBuilderOutput | Used by CTransactionBuilder to represent its transaction outputs |
| CCTranslationInterface | Signals for translation |
| ▶CCTxIn | An input of a transaction |
| CCTxDSIn | Holds a mixing input |
| 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 |
| CCTxOutCompressor | Wrapper for CTxOut that provides a more compact serialization |
| CCTxUndo | Undo information for a CTransaction |
| CCUpdatedBlock | |
| ▶CCValidationInterface | |
| CCActiveMasternodeManager | |
| CCDSNotificationInterface | |
| CCWallet | A CWallet is an extension of a keystore, which also maintains a set of transactions and balances, and provides the ability to create new transactions |
| CCZMQNotificationInterface | |
| CPeerLogicValidation | |
| Csubmitblock_StateCatcher | |
| CCValidationState | Capture information about block/transaction validation |
| CCVarInt< I > | |
| CCVectorWriter | |
| CCVerifyDB | RAII wrapper for VerifyDB: Verify consistency of the block and coin databases |
| CCWalletKey | Private key that includes an expiration date in case it never gets used |
| CCWalletScanState | |
| ▶CCZMQAbstractNotifier | |
| ▶CCZMQAbstractPublishNotifier | |
| CCZMQPublishHashBlockNotifier | |
| CCZMQPublishHashChainLockNotifier | |
| CCZMQPublishHashGovernanceObjectNotifier | |
| CCZMQPublishHashGovernanceVoteNotifier | |
| CCZMQPublishHashInstantSendDoubleSpendNotifier | |
| CCZMQPublishHashTransactionLockNotifier | |
| CCZMQPublishHashTransactionNotifier | |
| CCZMQPublishRawBlockNotifier | |
| CCZMQPublishRawChainLockNotifier | |
| CCZMQPublishRawChainLockSigNotifier | |
| CCZMQPublishRawGovernanceObjectNotifier | |
| CCZMQPublishRawGovernanceVoteNotifier | |
| CCZMQPublishRawInstantSendDoubleSpendNotifier | |
| CCZMQPublishRawTransactionLockNotifier | |
| CCZMQPublishRawTransactionLockSigNotifier | |
| CCZMQPublishRawTransactionNotifier | |
| Cimmer::detail::rbts::node< T, MemoryPolicy, B, BL >::data_t | |
| Cimmer::detail::hamts::champ< T, Hash, Equal, MemoryPolicy, B >::sub_result::data_t | |
| Cimmer::detail::dvektor::node< T, B, MP >::data_t | |
| Cimmer::detail::arrays::node< T, MemoryPolicy >::data_t | |
| Cimmer::detail::hamts::node< T, Hash, Equal, MemoryPolicy, B >::data_t | |
| CCDBTransaction< Parent, CommitTarget >::DataStreamCmp | |
| Cimmer::map< K, T, Hash, Equal, MemoryPolicy, B >::default_value | |
| CDereferencingComparator< T > | |
| Cdescendant_score | |
| Cdeserialize_type | Dummy data type to identify deserializing constructors |
| CDeserializeTuple< Stream, index, Ts > | |
| CDeserializeTuple< Stream, 0, Ts... > | |
| Cprevector< N, T, Size, Diff >::direct_or_indirect | |
| CDisconnectedBlockTransactions | |
| Cimmer::disowned | |
| CDKG | |
| Cimmer::dvektor< T, B, MemoryPolicy > | |
| CECCVerifyHandle | Users of this module must hold an ECCVerifyHandle |
| Cecmult_multi_data | |
| Cimmer::gc_transience_policy::apply< HeapPolicy >::type::edit | |
| Cimmer::no_transience_policy::apply< typename >::type::edit | |
| Cimmer::detail::rbts::empty_leaf_pos< NodeT > | |
| Cimmer::detail::rbts::empty_regular_pos< NodeT > | |
| Cimmer::detail::empty_t | |
| Cimmer::enable_intrusive_ptr< Deriv, RefcountPolicy > | |
| ▶Cimmer::enable_intrusive_ptr< node< T, B, MP >, MP::refcount > | |
| Cimmer::detail::dvektor::node< T, B, MP > | |
| Cimmer::enable_optimized_heap_policy< Deriv, HeapPolicy > | |
| ▶Cimmer::enable_optimized_heap_policy< node< T, B, MP >, MP::heap > | |
| Cimmer::detail::dvektor::node< T, B, MP > | |
| Cimmer::detail::hamts::champ_iterator< T, Hash, Eq, MP, B >::end_t | |
| Cimmer::detail::rbts::rbtree_iterator< T, MP, B, BL >::end_t | |
| Cimmer::detail::rbts::rrbtree_iterator< T, MP, B, BL >::end_t | |
| Cimmer::detail::dvektor::iterator< T, B, MP >::end_t | |
| Centry_time | |
| Cimmer::map< K, T, Hash, Equal, MemoryPolicy, B >::equal_key | |
| Cimmer::map< K, T, Hash, Equal, MemoryPolicy, B >::equal_value | |
| Cimmer::map< K, T, Hash, Equal, MemoryPolicy, B >::error_value | |
| CEstimationResult | |
| CEstimatorBucket | |
| Cimmer::detail::exact_t< T > | |
| ▶CException | |
| Corg.bitcoin.NativeSecp256k1Util.AssertFailException | |
| ▶Cexception | |
| CCGovernanceException | A class which encapsulates information about a governance exception condition |
| Cllmq::AbortPhaseException | |
| CExpirationInfo | |
| Ctinyformat::detail::is_convertible< T1, T2 >::fail | |
| ▶Cfalse_type | |
| Cimmer::detail::compatible_sentinel< T, U, typename > | |
| Cimmer::detail::is_dereferenceable< T, typename > | |
| Cimmer::detail::is_equality_comparable< T, U, typename > | |
| Cimmer::detail::is_forward_iterator< T, typename > | |
| Cimmer::detail::is_inequality_comparable< T, U, typename > | |
| Cimmer::detail::is_iterator< T, typename > | |
| Cimmer::detail::is_preincrementable< T, typename > | |
| Cimmer::detail::is_subtractable< T, U, typename > | |
| Cimmer::detail::std_distance_supports< T, U, typename > | |
| Cimmer::detail::std_uninitialized_copy_supports< T, U, V, typename > | |
| Cimmer::detail::swappable::with< T, U, typename > | |
| Cis_serializable_enum< T > | If none of the specialized versions above matched and T is an enum, default to calling Serialize/Unserialze with the underlying type |
| CFastRandomContext | Fast randomness source |
| CFeeCalculation | |
| Cimmer::flex_vector< T, MemoryPolicy, B, BL > | |
| 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 > | |
| Cimmer::free_list_heap_policy< Heap, Limit > | |
| Cimmer::free_list_node | |
| Cimmer::detail::rbts::full_leaf_pos< NodeT > | |
| Cimmer::detail::rbts::full_pos< NodeT > | |
| Cimmer::detail::gc_atom_impl< T, MemoryPolicy > | |
| Cimmer::gc_heap | |
| Cimmer::gc_transience_policy | |
| Cimmer::detail::hamts::get_bitmap_type< B > | |
| Cimmer::detail::hamts::get_bitmap_type< 6u > | |
| Cimmer::atom< T, MemoryPolicy >::get_gc_atom_impl | |
| Cimmer::atom< T, MemoryPolicy >::get_refcount_atom_impl | |
| Cstd::hash< immer::box< T, MP > > | |
| Cstd::hash< SporkId > | |
| Cstd::hash< uint256 > | |
| Cimmer::map< K, T, Hash, Equal, MemoryPolicy, B >::hash_key | |
| Cimmer::free_list_heap< Size, Limit, Base >::head_t | |
| Cimmer::detail::thread_local_free_list_storage< Heap >::head_t | |
| Cimmer::detail::unsafe_free_list_storage< Heap >::head_t | |
| Cimmer::heap_policy< Heap > | |
| ▶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 |
| Cimmer::detail::dvektor::impl< T, B, MP > | |
| Cimmer::detail::dvektor::impl< T, B, MemoryPolicy > | |
| Cimmer::detail::rbts::node< T, MemoryPolicy, B, BL >::impl_data_t | |
| Cimmer::detail::hamts::node< T, Hash, Equal, MemoryPolicy, B >::impl_data_t | |
| CBitcoinGUI::IncomingTransactionMessage | |
| Cindirectmap< K, T > | |
| Cindirectmap< COutPoint, const CTransaction *> | |
| Cimmer::detail::csl::inherit< T, Next > | |
| Cimmer::detail::csl::inherit< T, void > | |
| Cimmer::detail::rbts::node< T, MemoryPolicy, B, BL >::inner_t | |
| Cimmer::detail::hamts::node< T, Hash, Equal, MemoryPolicy, B >::inner_t | |
| Cinsertion_order | |
| ▶Cintegral_constant | |
| Cimmer::get_prefer_fewer_bigger_objects< HeapPolicy > | |
| Cimmer::get_use_transient_rvalues< RefcountPolicy > | |
| Cpooled_secure_allocator< T >::internal_secure_allocator | |
| 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]> | |
| ▶Citerator | |
| Cimmer::detail::iterator_facade< DerivedT, IteratorCategoryT, T, ReferenceT, DifferenceTypeT, PointerT > | |
| ▶Cimmer::detail::iterator_facade< champ_iterator< T, Hash, Eq, MP, B >, std::forward_iterator_tag, T, const T &, std::ptrdiff_t, const T *> | |
| Cimmer::detail::hamts::champ_iterator< T, Hash, Eq, MP, B > | |
| ▶Cimmer::detail::iterator_facade< rbtree_iterator< T, MP, B, BL >, std::random_access_iterator_tag, T, const T &, std::ptrdiff_t, const T *> | |
| Cimmer::detail::rbts::rbtree_iterator< T, MP, B, BL > | |
| ▶Cimmer::detail::iterator_facade< rrbtree_iterator< T, MP, B, BL >, std::random_access_iterator_tag, T, const T &, std::ptrdiff_t, const T *> | |
| Cimmer::detail::rbts::rrbtree_iterator< T, MP, B, BL > | |
| Cprevector< N, T, Size, Diff >::iterator | |
| Cimmer::detail::iterator_core_access | |
| ▶Citerator_facade | |
| Cimmer::detail::dvektor::iterator< T, B, MP > | |
| CIteratorComparator | |
| CJSONRPCRequest | |
| CJSONUTF8StringFilter | |
| CCGovernanceManager::last_object_rec | |
| Cimmer::detail::rbts::leaf_descent_pos< NodeT > | |
| Cimmer::detail::rbts::leaf_pos< NodeT > | |
| Cimmer::detail::rbts::leaf_sub_pos< NodeT > | |
| Cimmer::detail::rbts::node< T, MemoryPolicy, B, BL >::leaf_t | |
| CLimitedString< Limit > | |
| CCConnman::ListenSocket | |
| CConsensus::LLMQParams | |
| CLocalServiceInfo | |
| ▶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 | |
| ▶CLogger | |
| CCBitcoinLevelDBLogger | |
| CMainSignalsInstance | |
| Cimmer::detail::make_void< Ts > | |
| Cimmer::malloc_heap | |
| Cimmer::map< K, T, Hash, Equal, MemoryPolicy, B > | |
| Cimmer::map< uint256, CDeterministicMNCPtr > | |
| Cimmer::map< uint256, std::pair< uint256, uint32_t > > | |
| Cimmer::map< uint64_t, uint256 > | |
| Cimmer::map_transient< K, T, Hash, Equal, MemoryPolicy, B > | |
| Cimmer::detail::csl::member< T, Next > | |
| CMember | |
| Cimmer::detail::csl::member< T, void > | |
| Cimmer::detail::csl::member_two< T, Next > | |
| Cimmer::memory_policy< HeapPolicy, RefcountPolicy, TransiencePolicy, PreferFewerBiggerObjects, UseTransientRValues > | |
| Cmempoolentry_txid | |
| CCBLSBatchVerifier< SourceId, MessageId >::Message | |
| Cmodifiedentry_iter | |
| Corg.bitcoin.NativeSecp256k1 | |
| Corg.bitcoin.NativeSecp256k1Test | This class holds test cases defined for testing this library |
| Corg.bitcoin.NativeSecp256k1Util | |
| ▶CNetEventsInterface | Interface for message handling |
| CPeerLogicValidation | |
| CNetworkStyle | |
| ▶CNext | |
| Cimmer::detail::csl::inherit< T, Next >::type | |
| Cimmer::detail::csl::member< T, Next >::type | |
| Cimmer::detail::arrays::no_capacity< T, MemoryPolicy > | |
| Cimmer::no_refcount_policy | |
| Cimmer::no_spinlock | |
| Cimmer::no_transience_policy | |
| Cimmer::detail::rbts::node< T, MemoryPolicy, B, BL > | |
| Cimmer::detail::arrays::node< T, MemoryPolicy > | |
| Cimmer::detail::hamts::node< T, Hash, Equal, MemoryPolicy, B > | |
| CNodeEvictionCandidate | |
| CNodeLessThan | |
| Cllmq::CInstantSendManager::NonLockedTxInfo | |
| Cnontrivial_t | |
| Cimmer::norefs_tag | |
| Cimmer::detail::not_supported_t | |
| CNSBundle(returnCorrectIdentifier) | |
| Cimmer::detail::rbts::null_sub_pos | |
| Cimmer::heap_policy< Heap >::optimized< size_t > | |
| Cimmer::free_list_heap_policy< Heap, Limit >::optimized< Size > | |
| Cimmer::unsafe_free_list_heap_policy< Heap, Limit >::optimized< Size > | |
| CBlockAssembler::Options | |
| CCConnman::Options | |
| Cimmer::no_transience_policy::apply< typename >::type::ownee | |
| Cimmer::gc_transience_policy::apply< HeapPolicy >::type::ownee | |
| ▶Cowner | |
| Cimmer::array_transient< T, MemoryPolicy > | |
| Cimmer::flex_vector_transient< T, MemoryPolicy, B, BL > | |
| Cimmer::vector_transient< T, MemoryPolicy, B, BL > | |
| Cimmer::gc_transience_policy::apply< HeapPolicy >::type::owner | |
| Cimmer::no_transience_policy::apply< typename >::type::owner | |
| CConsensus::Params | Parameters that influence chain consensus |
| CPartiallyDownloadedBlock | |
| CPaymentRequestPlus | |
| CPeerTablePriv | |
| CPerBlockConnectTrace | |
| 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 |
| Cimmer::map< K, T, Hash, Equal, MemoryPolicy, B >::project_value | |
| Cimmer::map< K, T, Hash, Equal, MemoryPolicy, B >::project_value_ptr | |
| CProxyCredentials | Credentials for proxy authentication |
| CProxySetting | |
| CproxyType | |
| ▶CQAbstractItemDelegate | |
| CTxViewDelegate | |
| ▶CQAbstractListModel | |
| CBitcoinUnits | Dash unit definitions |
| COptionsModel | Interface from Qt to configuration data structure for Bitcoin client |
| ▶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 / dash: URIs |
| CTransactionTableModel | UI model for the transaction table of a wallet |
| ▶CQApplication | |
| CBitcoinApplication | Main Dash application object |
| ▶CQComboBox | |
| CQValueComboBox | |
| ▶CQDialog | |
| CAddressBookPage | Widget that shows a list of sending or receiving addresses |
| CAskPassphraseDialog | Multifunctional dialog to ask for passphrases |
| CCoinControlDialog | |
| CEditAddressDialog | Dialog for editing an address and associated information |
| CHelpMessageDialog | "Help message" dialog box |
| CIntro | Introduction screen (pre-GUI startup) |
| COpenURIDialog | |
| COptionsDialog | Preferences dialog |
| CQRDialog | |
| 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 |
| ▶CQLabel | |
| CGUIUtil::ClickableLabel | |
| CQRGeneralImageWidget | |
| CQRImageWidget | |
| CUnitDisplayStatusBarControl | |
| ▶CQLineEdit | |
| CAmountLineEdit | QLineEdit that uses fixed-point numbers internally and uses our own formatting/parsing functions |
| CQValidatedLineEdit | Line edit that can be marked as "invalid" to show input validation feedback |
| ▶CQMainWindow | |
| CBitcoinGUI | Bitcoin GUI main class |
| ▶CQMessageBox | |
| CSendConfirmationDialog | |
| ▶CQObject | |
| CBitcoinCore | Class encapsulating Dash Core startup and shutdown |
| ▶CCallback | |
| CFunctionCallback< F > | |
| CClientModel | Model for Dash network client |
| CCSVModelWriter | Export a Qt table model to a CSV file |
| CFreespaceChecker | |
| CGUIUtil::TableViewLastColumnResizingFixer | Makes a QTableView last column feel as if it was being resized from its left border |
| CGUIUtil::ToolTipToRichTextFilter | Qt event filter that intercepts ToolTipChange events, and replaces the tooltip with a rich text representation if needed |
| CMacDockIconHandler | MacOS-specific Dock icon handler |
| CMacNotificationHandler | Macintosh-specific notification handler (supports UserNotificationCenter) |
| CNotificator | Cross-platform desktop notification client |
| CPaymentServer | |
| CQtRPCTimerBase | Class for handling RPC timers (used for e.g |
| CRPCExecutor | |
| CTransactionDesc | Provide a human-readable extended HTML description of a transaction |
| CWalletModel | Interface to Bitcoin wallet from Qt view code |
| ▶CQProgressBar | |
| CGUIUtil::ClickableProgressBar | |
| ▶CQSortFilterProxyModel | |
| CTransactionFilterProxy | Filter the transaction list according to pre-specified rules |
| ▶CQStackedWidget | |
| CSendCoinsEntry | A single entry in the dialog for sending bitcoins |
| CWalletView | |
| ▶CQTreeWidget | |
| CCoinControlTreeWidget | |
| ▶CQTreeWidgetItem | |
| CCCoinControlWidgetItem | |
| ▶CQValidator | |
| CAmountValidator | Amount widget validator, checks for valid CAmount value |
| 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 | |
| CAppearanceWidget | |
| CBitcoinAmountField | Widget for entering bitcoin amounts |
| CMasternodeList | Masternode Manager page widget |
| 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 |
| Cimmer::detail::rbts::rbtree< T, MemoryPolicy, B, BL > | |
| Czero_after_free_allocator< T >::rebind< _Other > | |
| Csecure_allocator< T >::rebind< _Other > | |
| CRecentRequestEntry | |
| CRecentRequestEntryLessThan | |
| ▶Crecursive_mutex | |
| ▶CAnnotatedMixin< std::recursive_mutex > | |
| CCCriticalSection | Wrapped mutex: supports recursive locking, but no waiting TODO: We should move away from using the recursive lock by default |
| Cimmer::detail::dvektor::ref< T, B, MP > | |
| Cimmer::detail::dvektor::ref< T, B, MemoryPolicy > | |
| Cimmer::detail::ref_count_base< Deriv > | |
| ▶Crefcount | |
| Cimmer::box< T, MemoryPolicy >::holder | |
| Cimmer::detail::refcount_atom_impl< T, MemoryPolicy > | |
| Cimmer::refcount_policy | |
| Cimmer::detail::iterator_facade< DerivedT, IteratorCategoryT, T, ReferenceT, DifferenceTypeT, PointerT >::reference_proxy | |
| Cimmer::detail::rbts::regular_descent_pos< NodeT, Shift, B, BL > | |
| Cimmer::detail::rbts::regular_descent_pos< NodeT, BL, B, BL > | |
| Cimmer::detail::rbts::regular_pos< NodeT > | |
| Cimmer::detail::rbts::regular_sub_pos< NodeT > | |
| Cimmer::detail::rbts::node< T, MemoryPolicy, B, BL >::relaxed_data_t | |
| Cimmer::detail::rbts::relaxed_descent_pos< NodeT, Shift, B, BL > | |
| Cimmer::detail::rbts::relaxed_descent_pos< NodeT, BL, B, BL > | |
| Cimmer::detail::rbts::relaxed_pos< NodeT > | |
| Cprevector< N, T, Size, Diff >::reverse_iterator | |
| Creverse_lock< Lock > | An RAII-style reverse lock |
| Creverse_range< T > | Template used for reverse iteration in C++11 range-based for loops |
| ▶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 | |
| Cimmer::detail::rbts::rrbtree< T, MemoryPolicy, B, BL > | |
| ▶Cruntime_error | |
| CCConnectionFailed | |
| Cdbwrapper_error | |
| Cscriptnum_error | |
| CSSLVerifyError | |
| Ctinyformat::format_error | |
| Cuint_error | |
| CSaltedHasher< T, S > | |
| CSaltedHasherBase | |
| CSaltedHasherImpl< T > | Helper classes for std::unordered_map and std::unordered_set hashing |
| CSaltedHasherImpl< std::pair< N, uint256 > > | |
| CSaltedHasherImpl< std::pair< uint256, N > > | |
| CSaltedHasherImpl< uint256 > | |
| CSaltedOutpointHasher | |
| CSaltedTxidHasher | |
| Cimmer::spinlock::scoped_lock | |
| Cimmer::no_spinlock::scoped_lock | |
| CCGovernanceManager::ScopedLockBool | |
| 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_num | |
| 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 | |
| Corg.bitcoin.Secp256k1Context | This class holds the context reference used in native methods to handle ECDSA operations |
| CSecp256k1Init | |
| CSeedSpec6 | |
| CSendCoinsRecipient | |
| CWalletModel::SendCoinsReturn | |
| CSerializeTuple< Stream, index, Ts > | Tuple |
| CSerializeTuple< Stream, 0, Ts... > | |
| Cllmq::CSigSharesNodeState::Session | |
| Cllmq::CSigSharesNodeState::SessionInfo | |
| Cimmer::set< T, Hash, Equal, MemoryPolicy, B > | |
| Cimmer::set_transient< T, Hash, Equal, MemoryPolicy, B > | |
| CSignatureCacheHasher | We're hashing a nonce into the entries themselves, so we don't need extra blinding in the set hash computation |
| CSignatureData | |
| Cllmq::SigShareMap< T > | |
| Cllmq::SigShareMap< bool > | |
| Cllmq::SigShareMap< int64_t > | |
| Cllmq::SigShareMap< llmq::CSigShare > | |
| Cllmq::SigShareMap< std::pair< NodeId, int64_t > > | |
| CCBLSWorker::SigVerifyJob | |
| CSingleThreadedSchedulerClient | Class used by CScheduler clients which may schedule multiple jobs which are required to be run serially |
| Cimmer::detail::rbts::singleton_regular_sub_pos< NodeT > | |
| CsortProposalsByVotes | |
| Csph_blake_small_context | This structure is a context for BLAKE-224 and BLAKE-256 computations: it contains the intermediate values and some data from the last entered block |
| Csph_bmw_small_context | This structure is a context for BMW-224 and BMW-256 computations: it contains the intermediate values and some data from the last entered block |
| Csph_cubehash_context | This structure is a context for CubeHash computations: it contains the intermediate values and some data from the last entered block |
| Csph_echo_big_context | This structure is a context for ECHO computations: it contains the intermediate values and some data from the last entered block |
| Csph_echo_small_context | This structure is a context for ECHO computations: it contains the intermediate values and some data from the last entered block |
| Csph_groestl_big_context | This structure is a context for Groestl-384 and Groestl-512 computations: it contains the intermediate values and some data from the last entered block |
| Csph_groestl_small_context | This structure is a context for Groestl-224 and Groestl-256 computations: it contains the intermediate values and some data from the last entered block |
| Csph_jh_context | This structure is a context for JH computations: it contains the intermediate values and some data from the last entered block |
| Csph_keccak_context | This structure is a context for Keccak computations: it contains the intermediate values and some data from the last entered block |
| Csph_luffa224_context | This structure is a context for Luffa-224 computations: it contains the intermediate values and some data from the last entered block |
| Csph_luffa384_context | This structure is a context for Luffa-384 computations |
| Csph_luffa512_context | This structure is a context for Luffa-512 computations |
| Csph_shavite_big_context | This structure is a context for SHAvite-384 and SHAvite-512 computations: it contains the intermediate values and some data from the last entered block |
| Csph_shavite_small_context | This structure is a context for SHAvite-224 and SHAvite-256 computations: it contains the intermediate values and some data from the last entered block |
| Csph_simd_big_context | This structure is a context for SIMD computations: it contains the intermediate values and some data from the last entered block |
| Csph_simd_small_context | This structure is a context for SIMD computations: it contains the intermediate values and some data from the last entered block |
| Cimmer::spinlock | |
| Cimmer::split_heap< Size, SmallHeap, BigHeap > | |
| Cstackframe_info | |
| Cbenchmark::State | |
| ▶Cstatic_visitor | |
| CCAffectedKeysVisitor | |
| CStaticSaltedHasher | |
| CLockedPool::Stats | Memory statistics |
| CArena::Stats | Memory statistics |
| Cmemusage::stl_shared_counter | |
| Cmemusage::stl_tree_node< X > | |
| Cimmer::detail::hamts::champ< T, Hash, Equal, MemoryPolicy, B >::sub_result | |
| Ctinyformat::detail::is_convertible< T1, T2 >::succeed | |
| ▶CT | |
| Cimmer::detail::csl::inherit< T, Next >::type | |
| Cimmer::detail::csl::inherit< T, void >::type | |
| Ctallyitem | |
| ▶CTestChain100Setup | |
| CCreateTransactionTestSetup | |
| CListCoinsTestingSetup | |
| CTestCrypter | |
| ▶CTestingSetup | |
| CWalletTestingSetup | Testing setup and teardown for wallet |
| Cimmer::detail::thread_local_free_list_storage< Heap > | |
| Cctpl::thread_pool | |
| Ccxxtimer::Timer | This class works as a stopwatch |
| CTorControlConnection | Low-level handling for Tor control connection |
| CTorController | Controller that connects to Tor control socket, authenticate, then create and maintain an ephemeral hidden service |
| CTorControlReply | Reply from Tor, can be single or multi-line |
| CTrafficGraphData | |
| CTrafficSample | |
| CTransactionCompressor | |
| CTransactionNotification | |
| CTransactionRecord | UI model for a transaction |
| CTransactionStatus | UI model for transaction status |
| CTransactionTablePriv | |
| ▶Ctrue_type | |
| Cimmer::detail::compatible_sentinel< T, U, std::enable_if_t< is_iterator_v< T > &&is_equality_comparable_v< T, U > &&is_inequality_comparable_v< T, U > > > | |
| Cimmer::detail::is_dereferenceable< T, void_t< decltype(*(std::declval< T & >()))> > | |
| Cimmer::detail::is_equality_comparable< T, U, std::enable_if_t< std::is_same< bool, decltype(std::declval< T & >()==std::declval< U & >())>::value > > | |
| Cimmer::detail::is_forward_iterator< T, std::enable_if_t< is_iterator_v< T > &&std::is_base_of< std::forward_iterator_tag, typename std::iterator_traits< T >::iterator_category >::value > > | |
| Cimmer::detail::is_inequality_comparable< T, U, std::enable_if_t< std::is_same< bool, decltype(std::declval< T & >() !=std::declval< U & >())>::value > > | |
| Cimmer::detail::is_iterator< T, void_t< std::enable_if_t< is_preincrementable_v< T > &&is_dereferenceable_v< T > &&std::is_copy_constructible< T >::value &&std::is_copy_assignable< T >::value &&std::is_destructible< T >::value &&is_swappable_v< T > >, typename std::iterator_traits< T >::value_type, typename std::iterator_traits< T >::difference_type, typename std::iterator_traits< T >::reference, typename std::iterator_traits< T >::pointer, typename std::iterator_traits< T >::iterator_category > > | |
| Cimmer::detail::is_preincrementable< T, std::enable_if_t< std::is_same< T &, decltype(++(std::declval< T & >()))>::value > > | |
| Cimmer::detail::is_subtractable< T, U, void_t< decltype(std::declval< T & >() - std::declval< U & >())> > | |
| Cimmer::detail::std_distance_supports< T, U, void_t< decltype(std::distance(std::declval< T >(), std::declval< U >()))> > | |
| Cimmer::detail::std_uninitialized_copy_supports< T, U, V, void_t< decltype(std::uninitialized_copy(std::declval< T >(), std::declval< U >(), std::declval< V >()))> > | |
| Cimmer::detail::swappable::with< T, U, void_t< decltype(swap(std::declval< T & >(), std::declval< U & >())), decltype(swap(std::declval< U & >(), std::declval< T & >()))> > | |
| Cis_serializable_enum< Consensus::LLMQType > | |
| Cis_serializable_enum< PoolMessage > | |
| Cis_serializable_enum< PoolState > | |
| Cis_serializable_enum< PoolStatusUpdate > | |
| Cis_serializable_enum< SporkId > | |
| CTxConfirmStats | We will instantiate an instance of this class to track transactions that were included in a block |
| Ctxid_index | DisconnectedBlockTransactions |
| CTxInUndoDeserializer | |
| CTxInUndoSerializer | Undo information for a CTxIn |
| CTxLessThan | |
| CCTxMemPool::TxLinks | |
| CTxMempoolInfo | Information about a mempool transaction |
| CCBlockPolicyEstimator::TxStatsInfo | |
| Cimmer::no_transience_policy::apply< typename >::type | |
| Cimmer::gc_transience_policy::apply< HeapPolicy >::type | |
| Cimmer::detail::csl::member_two< T, Next >::type | |
| Cimmer::detail::csl::member< T, void >::type | |
| Cimmer::detail::csl::type_t< T > | |
| CUniValue | |
| CUniValueType | Wrapper for UniValue::VType, which includes typeAny: Used to denote don't care type |
| CWalletModel::UnlockContext | |
| Cunordered_limitedmap< K, V, Hash > | STL-like map container that only keeps the N elements with the highest value |
| Cunordered_limitedmap< uint256, bool > | |
| Cunordered_lru_cache< Key, Value, Hasher, MaxSize, TruncateThreshold > | |
| Cunordered_lru_cache< COutPoint, uint256, SaltedOutpointHasher, 10000 > | |
| Cunordered_lru_cache< std::pair< Consensus::LLMQType, uint256 >, bool, StaticSaltedHasher, 30000 > | |
| Cunordered_lru_cache< std::pair< Consensus::LLMQType, uint256 >, std::vector< CQuorumCPtr >, StaticSaltedHasher, 32 > | |
| Cunordered_lru_cache< uint256, bool, StaticSaltedHasher, 30000 > | |
| Cunordered_lru_cache< uint256, CInstantSendLockPtr, StaticSaltedHasher, 10000 > | |
| Cunordered_lru_cache< uint256, uint256, StaticSaltedHasher, 10000 > | |
| Cimmer::unsafe_free_list_heap_policy< Heap, Limit > | |
| Cimmer::detail::unsafe_free_list_storage< Heap > | |
| Cimmer::unsafe_refcount_policy | |
| Cupdate_ancestor_state | |
| Cupdate_descendant_state | |
| Cupdate_fee_delta | |
| Cupdate_for_parent_inclusion | |
| Cupdate_lock_points | |
| ▶CCDBTransaction< Parent, CommitTarget >::ValueHolder | |
| CCDBTransaction< Parent, CommitTarget >::ValueHolderImpl< V > | |
| Cimmer::detail::hamts::node< T, Hash, Equal, MemoryPolicy, B >::values_data_t | |
| CVBDeploymentInfo | |
| Cimmer::vector< T, MemoryPolicy, B, BL > | |
| CVectorAggregator< T > | |
| CVersionBitsCache | |
| Cimmer::detail::rbts::visitor_base< Deriv > | |
| ▶Cimmer::detail::rbts::visitor_base< array_for_visitor< T > > | |
| Cimmer::detail::rbts::array_for_visitor< T > | |
| ▶Cimmer::detail::rbts::visitor_base< concat_both_mut_visitor< Node > > | |
| Cimmer::detail::rbts::concat_both_mut_visitor< Node > | |
| ▶Cimmer::detail::rbts::visitor_base< concat_both_visitor< Node > > | |
| Cimmer::detail::rbts::concat_both_visitor< Node > | |
| ▶Cimmer::detail::rbts::visitor_base< concat_left_mut_visitor< Node > > | |
| Cimmer::detail::rbts::concat_left_mut_visitor< Node > | |
| ▶Cimmer::detail::rbts::visitor_base< concat_left_visitor< Node > > | |
| Cimmer::detail::rbts::concat_left_visitor< Node > | |
| ▶Cimmer::detail::rbts::visitor_base< concat_merger_mut_visitor > | |
| Cimmer::detail::rbts::concat_merger_mut_visitor | |
| ▶Cimmer::detail::rbts::visitor_base< concat_merger_visitor > | |
| Cimmer::detail::rbts::concat_merger_visitor | |
| ▶Cimmer::detail::rbts::visitor_base< concat_rebalance_plan_fill_visitor > | |
| Cimmer::detail::rbts::concat_rebalance_plan_fill_visitor | |
| ▶Cimmer::detail::rbts::visitor_base< concat_right_mut_visitor< Node > > | |
| Cimmer::detail::rbts::concat_right_mut_visitor< Node > | |
| ▶Cimmer::detail::rbts::visitor_base< concat_right_visitor< Node > > | |
| Cimmer::detail::rbts::concat_right_visitor< Node > | |
| ▶Cimmer::detail::rbts::visitor_base< concat_trees_left_mut_visitor< Node > > | |
| Cimmer::detail::rbts::concat_trees_left_mut_visitor< Node > | |
| ▶Cimmer::detail::rbts::visitor_base< concat_trees_left_visitor< Node > > | |
| Cimmer::detail::rbts::concat_trees_left_visitor< Node > | |
| ▶Cimmer::detail::rbts::visitor_base< concat_trees_right_mut_visitor< Node > > | |
| Cimmer::detail::rbts::concat_trees_right_mut_visitor< Node > | |
| ▶Cimmer::detail::rbts::visitor_base< concat_trees_right_visitor< Node > > | |
| Cimmer::detail::rbts::concat_trees_right_visitor< Node > | |
| ▶Cimmer::detail::rbts::visitor_base< dec_left_visitor > | |
| Cimmer::detail::rbts::dec_left_visitor | |
| ▶Cimmer::detail::rbts::visitor_base< dec_right_visitor > | |
| Cimmer::detail::rbts::dec_right_visitor | |
| ▶Cimmer::detail::rbts::visitor_base< dec_visitor > | |
| Cimmer::detail::rbts::dec_visitor | |
| ▶Cimmer::detail::rbts::visitor_base< equals_visitor > | |
| Cimmer::detail::rbts::equals_visitor | |
| ▶Cimmer::detail::rbts::visitor_base< for_each_chunk_i_visitor > | |
| Cimmer::detail::rbts::for_each_chunk_i_visitor | |
| ▶Cimmer::detail::rbts::visitor_base< for_each_chunk_left_visitor > | |
| Cimmer::detail::rbts::for_each_chunk_left_visitor | |
| ▶Cimmer::detail::rbts::visitor_base< for_each_chunk_p_i_visitor > | |
| Cimmer::detail::rbts::for_each_chunk_p_i_visitor | |
| ▶Cimmer::detail::rbts::visitor_base< for_each_chunk_p_left_visitor > | |
| Cimmer::detail::rbts::for_each_chunk_p_left_visitor | |
| ▶Cimmer::detail::rbts::visitor_base< for_each_chunk_p_right_visitor > | |
| Cimmer::detail::rbts::for_each_chunk_p_right_visitor | |
| ▶Cimmer::detail::rbts::visitor_base< for_each_chunk_p_visitor > | |
| Cimmer::detail::rbts::for_each_chunk_p_visitor | |
| ▶Cimmer::detail::rbts::visitor_base< for_each_chunk_right_visitor > | |
| Cimmer::detail::rbts::for_each_chunk_right_visitor | |
| ▶Cimmer::detail::rbts::visitor_base< for_each_chunk_visitor > | |
| Cimmer::detail::rbts::for_each_chunk_visitor | |
| ▶Cimmer::detail::rbts::visitor_base< get_mut_visitor< NodeT > > | |
| Cimmer::detail::rbts::get_mut_visitor< NodeT > | |
| ▶Cimmer::detail::rbts::visitor_base< get_visitor< T > > | |
| Cimmer::detail::rbts::get_visitor< T > | |
| ▶Cimmer::detail::rbts::visitor_base< push_tail_mut_visitor< NodeT, Mutating > > | |
| Cimmer::detail::rbts::push_tail_mut_visitor< NodeT, Mutating > | |
| ▶Cimmer::detail::rbts::visitor_base< push_tail_visitor< NodeT > > | |
| Cimmer::detail::rbts::push_tail_visitor< NodeT > | |
| ▶Cimmer::detail::rbts::visitor_base< region_for_visitor< T > > | |
| Cimmer::detail::rbts::region_for_visitor< T > | |
| ▶Cimmer::detail::rbts::visitor_base< rrb > | |
| Cimmer::detail::rbts::equals_visitor::rrb | |
| ▶Cimmer::detail::rbts::visitor_base< slice_left_mut_visitor< NodeT, Collapse, Mutating > > | |
| Cimmer::detail::rbts::slice_left_mut_visitor< NodeT, Collapse, Mutating > | |
| ▶Cimmer::detail::rbts::visitor_base< slice_left_visitor< NodeT, Collapse > > | |
| Cimmer::detail::rbts::slice_left_visitor< NodeT, Collapse > | |
| ▶Cimmer::detail::rbts::visitor_base< slice_right_mut_visitor< NodeT, Collapse, Mutating > > | |
| Cimmer::detail::rbts::slice_right_mut_visitor< NodeT, Collapse, Mutating > | |
| ▶Cimmer::detail::rbts::visitor_base< slice_right_visitor< NodeT, Collapse > > | |
| Cimmer::detail::rbts::slice_right_visitor< NodeT, Collapse > | |
| ▶Cimmer::detail::rbts::visitor_base< this_aux_t > | |
| Cimmer::detail::rbts::equals_visitor::this_aux_t | |
| ▶Cimmer::detail::rbts::visitor_base< update_visitor< NodeT > > | |
| Cimmer::detail::rbts::update_visitor< NodeT > | |
| Cvote_instance_t | |
| Cvote_rec_t | |
| CWalletBatch | Access to the wallet database |
| ▶CWalletInitInterface | |
| CDummyWalletInit | |
| CWalletInit | |
| CWalletModelTransaction | Data model for a walletmodel transaction |
| CWalletRescanReserver | RAII object to check and reserve a wallet rescan |
| CWalletTxHasher | |
| Cimmer::detail::arrays::with_capacity< T, MemoryPolicy > | |
| CWorkQueue< WorkItem > | Simple work queue for distributing work over multiple threads |
| ▶CX | |
| Cmemusage::unordered_node< X > | |
| CX509Deleter | |
| CX509StoreDeleter | |
| ▶CPARENT | |
| CAnnotatedMixin< PARENT > | Template mixin that adds -Wthread-safety locking annotations to a subset of the mutex API |
1.8.14