| Cipc::capnp::messages::Echo::_capnpPrivate | |
| Cipc::capnp::messages::Echo::DestroyParams::_capnpPrivate | |
| Cipc::capnp::messages::Echo::EchoParams::_capnpPrivate | |
| Cipc::capnp::messages::Echo::DestroyResults::_capnpPrivate | |
| Cipc::capnp::messages::Echo::EchoResults::_capnpPrivate | |
| Cipc::capnp::messages::Init::_capnpPrivate | |
| Cipc::capnp::messages::Init::ConstructResults::_capnpPrivate | |
| Cgen::FooInterface::_capnpPrivate | |
| Cgen::FooInterface::AddParams::_capnpPrivate | |
| Cgen::FooInterface::AddResults::_capnpPrivate | |
| Cgen::FooInterface::PassOutPointParams::_capnpPrivate | |
| Cgen::FooInterface::PassOutPointResults::_capnpPrivate | |
| Cgen::FooInterface::PassUniValueParams::_capnpPrivate | |
| Cgen::FooInterface::PassUniValueResults::_capnpPrivate | |
| Cipc::capnp::messages::Init::MakeEchoParams::_capnpPrivate | |
| Cipc::capnp::messages::Init::MakeEchoResults::_capnpPrivate | |
| Cipc::capnp::messages::Init::ConstructParams::_capnpPrivate | |
| Cmp::ipc_test_fields::A | |
| ▶CAbstractThresholdConditionChecker | Abstract class that implements BIP9-style threshold logic, and caches results |
| ▶CTestConditionChecker | |
| CTestAlwaysActiveConditionChecker | |
| CTestDelayedActivationConditionChecker | |
| CTestNeverActiveConditionChecker | |
| CTestConditionChecker | |
| CWarningBitsConditionChecker | Threshold condition checker that triggers when unknown versionbits are seen on the network |
| CActionSerialize | Support for all macros providing or using the ser_action parameter of the SerializationOps method |
| CActionUnserialize | |
| CAddedNodeInfo | |
| CAddedNodeParams | |
| Cgen::FooInterface::AddParams | |
| Cwallet::CWallet::AddrBookFilter | |
| CAddressPosition | Location information for an address in AddrMan |
| CAddressTableEntry | |
| CAddressTableEntryLessThan | |
| CAddressTablePriv | |
| Cgen::FooInterface::AddResults | |
| ▶CAddrMan | Stochastic address manager |
| CAddrManDeterministic | |
| CAddrManImpl | |
| 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 | |
| Cancestor_score | |
| Cnode::AncestorFeerateComparator | |
| ▶CArena | |
| CLockedPool::LockedPageArena | Create an arena from locked pages |
| CArgsManager::Arg | |
| Cmp::ipc_test_fields::Arg | |
| Cbenchmark::Args | |
| ▶CArgsManager | |
| CTestArgsManager | |
| CAssumeutxoData | Holds configuration for use during UTXO snapshot load and validation |
| CAutoFile | Non-refcounted RAII wrapper for FILE* |
| CAvailable | |
| Cmp::ipc_test_fields::B | |
| Cwallet::Balance | |
| CBanMan | |
| CBannedNodeLessThan | |
| CBanTablePriv | |
| ▶CBase | (Un)serialize a number as raw byte or 2 hexadecimal chars |
| CDerived | |
| Cbase_blob< BITS > | Template base class for fixed-sized opaque blobs |
| ▶Cbase_blob< 160 > | |
| ▶Cuint160 | 160-bit opaque blob |
| CCKeyID | A reference to a CKey: the Hash160 of its serialized public key |
| ▶Cbase_blob< 256 > | |
| Cuint256 | 256-bit opaque blob |
| Cbase_uint< BITS > | Template base class for unsigned big integers |
| ▶Cbase_uint< 256 > | |
| Carith_uint256 | 256-bit unsigned big integer |
| CBaseFormat | |
| CBaseHash< HashType > | |
| ▶CBaseHash< uint160 > | |
| CCScriptID | A reference to a CScript: the Hash160 of its serialization |
| CPKHash | |
| CScriptHash | |
| CWitnessV0KeyHash | |
| ▶CBaseHash< uint256 > | |
| CAssumeutxoHash | |
| CWitnessV0ScriptHash | |
| ▶CBaseRequestHandler | Class that handles the conversion from a command-line to a JSON-RPC request, as well as converting back to a JSON object that can be shown as result |
| CAddrinfoRequestHandler | Process addrinfo requests |
| CDefaultRequestHandler | Process default single requests |
| CGenerateToAddressRequestHandler | Process RPC generatetoaddress request |
| CGetinfoRequestHandler | Process getinfo requests |
| CNetinfoRequestHandler | Process netinfo requests |
| ▶CBaseSignatureChecker | |
| ▶CDeferringSignatureChecker | |
| Cwallet::feebumper::SignatureWeightChecker | |
| ▶CGenericTransactionSignatureChecker< T > | |
| CCachingTransactionSignatureChecker | |
| ▶CBaseSignatureCreator | Interface for signature creators |
| CMutableTransactionSignatureCreator | A signature creator for transactions |
| ▶CBasicTestingSetup | Basic testing setup |
| CArgsMergeTestingSetup | |
| CChainMergeTestingSetup | |
| ▶CChainTestingSetup | Testing setup that performs all steps up until right before ChainstateManager gets initialized |
| ▶CTestingSetup | Testing setup that configures a complete environment |
| CLogIPsTestingSetup | |
| Cminer_tests::MinerTestingSetup | |
| 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 |
| ▶CRegTestingSetup | Identical to TestingSetup, but chain set to regtest |
| CHeadersGeneratorSetup | |
| Cvalidation_block_tests::MinerTestingSetup | |
| CRPCTestingSetup | |
| ▶CTestChain100Setup | Testing fixture that pre-creates a 100-block REGTEST-mode block chain |
| CBuildChainTestingSetup | |
| CCheckValueTest | Test GetSetting and GetArg type coercion, negation, and default value handling |
| CDersig100Setup | |
| CSnapshotTestSetup | |
| Cwallet::ListCoinsTestingSetup | |
| Cwallet::WalletTestingSetup | Testing setup and teardown for wallet |
| CEnvTestingSetup | Save the log level and the value of CreateSock and restore them when the test ends |
| CLogSetup | |
| CMergeTestingSetup | |
| Cwallet::InitWalletDirTestingSetup | |
| Cankerl::nanobench::Bench | Main entry point to nanobench's benchmarking facility |
| Cbench_data | |
| Cbench_ecdh_data | |
| Cbench_ellswift_data | |
| Cbench_inv | |
| Cbench_recover_data | |
| Cbench_schnorrsig_data | |
| Cbenchmark::BenchRunner | |
| Cwallet::BerkeleyEnvironment | |
| Cankerl::nanobench::BigO | |
| Cbilingual_str | Bilingual messages: |
| CBIP324Cipher | The BIP324 packet cipher, encapsulating its key derivation, stream cipher, and AEAD |
| CConsensus::BIP9Deployment | Struct for each individual consensus rule change using BIP9 |
| CBIP9Stats | Display status of an in-progress BIP9 softfork |
| CCuckooCache::bit_packed_atomic_flags | bit_packed_atomic_flags implements a container for garbage collection flags that is only thread unsafe on calls to setup |
| Cbitdeque< BlobSize > | Class that mimics std::deque<bool>, but with std::vector<bool>'s bit packing |
| CBitReader | |
| CBitsInt< I, BITS > | |
| CBitStreamReader< IStream > | |
| CBitStreamWriter< OStream > | |
| CBitWriter | |
| Cinterfaces::BlockAndHeaderTipInfo | Block and header tip information |
| Cnode::BlockAssembler | Generate a new block, without valid proof-of-work |
| Cnode::BlockfileCursor | |
| CBlockFilter | Complete block filter struct as defined in BIP 157 |
| CBlockFiltersScanReserver | |
| CBlockHasher | |
| Cinterfaces::BlockInfo | Block data sent with blockConnected, blockDisconnected notifications |
| Cinterfaces::BlockKey | Hash/height pair to help track and identify blocks |
| Cnode::BlockManager | Maintains a tree of blocks (stored in m_block_index) which is consulted to determine where the most-work tip is |
| Ckernel::BlockManagerOpts | An options struct for BlockManager, more ergonomically referred to as BlockManager::Options due to the using-declaration in BlockManager |
| Cinterfaces::BlockTip | Block tip (could be a header or not, depends on the subscribed signal) |
| CBlockTransactions | |
| CBlockTransactionsRequest | |
| CBufferedFile | Wrapper around an AutoFile& that implements a ring buffer to deserialize from |
| Cipc::capnp::messages::Init::MakeEchoResults::Builder | |
| Cipc::capnp::messages::Init::MakeEchoParams::Builder | |
| Cipc::capnp::messages::Echo::DestroyParams::Builder | |
| Cipc::capnp::messages::Echo::DestroyResults::Builder | |
| Cipc::capnp::messages::Echo::EchoResults::Builder | |
| Cipc::capnp::messages::Echo::EchoParams::Builder | |
| Cgen::FooInterface::AddParams::Builder | |
| Cgen::FooInterface::AddResults::Builder | |
| Cgen::FooInterface::PassOutPointParams::Builder | |
| Cgen::FooInterface::PassOutPointResults::Builder | |
| Cgen::FooInterface::PassUniValueParams::Builder | |
| Cgen::FooInterface::PassUniValueResults::Builder | |
| Cipc::capnp::messages::Init::ConstructParams::Builder | |
| Cipc::capnp::messages::Init::ConstructResults::Builder | |
| Cwallet::BytePrefix | |
| CByteVectorHash | Implementation of Hash named requirement for types that internally store a byte array |
| Cwallet::CachableAmount | Cachable amount subdivided into watchonly and spendable parts |
| CCuckooCache::cache< Element, Hash > | cache implements a cache with properties similar to a cuckoo-set |
| CCConnman::CachedAddrResponse | Cache responses to addr requests to minimize privacy leak |
| Cnode::CacheSizes | |
| Cwallet::CAddressBookData | Address book data |
| CCAppNapInhibitor::CAppNapImpl | |
| CCAppNapInhibitor | |
| 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 |
| 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 |
| Cnode::CBlockIndexHeightOnlyComparator | |
| Cnode::CBlockIndexWorkComparator | |
| CCBlockLocator | Describes a place in the block chain to another node such that if the other node doesn't have the same branch, it can find a recent common trunk |
| Cnode::CBlockTemplate | |
| 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 |
| CCMainParams | Main network on which people trade goods and services |
| CCRegTestParams | Regression test: intended for private networks only |
| CCTestNetParams | Testnet (v3): public test network which is reset from time to time |
| CSigNetParams | Signet: test network with an additional consensus parameter (see BIP325) |
| CCCheckpointData | |
| CCCheckQueue< T > | Queue for verifications that have to be performed |
| CCCheckQueue< CScriptCheck > | |
| CCCheckQueueControl< T > | RAII-style controller object for a CCheckQueue that guarantees the passed queue is finished before continuing |
| CCClientUIInterface | Signals for UI communication |
| CCCoin | |
| Cwallet::CCoinControl | Coin Control Features |
| CCCoinsCacheEntry | A Coin in one level of the coins database caching hierarchy |
| Ckernel::CCoinsStats | |
| ▶CCCoinsView | Abstract view on the open txout dataset |
| ▶CCCoinsViewBacked | CCoinsView backed by another CCoinsView |
| CCCoinsViewCache | CCoinsView that adds a memory cache for transactions to another CCoinsView |
| CCCoinsViewErrorCatcher | This is a minimally invasive approach to shutdown on LevelDB read errors from the chainstate, while keeping user interface out of the common library, which is shared between bitcoind, and bitcoin-qt and non-server tools |
| CCCoinsViewMemPool | CCoinsView that brings transactions from a mempool into view |
| CCCoinsViewDB | CCoinsView backed by the coin database (chainstate/) |
| ▶CCCoinsViewCursor | Cursor for iterating over CoinsView state |
| CCCoinsViewDBCursor | Specialization of CCoinsViewCursor to iterate over a CCoinsViewDB |
| CCCombinedBan | |
| ▶CCConnman | |
| CConnmanTestMsg | |
| Cwallet::CCrypter | Encryption/decryption context with key information |
| CCDBBatch | Batch of changes queued to be written to a CDBWrapper |
| CCDBIterator | |
| ▶CCDBWrapper | |
| ▶CBaseIndex::DB | The database stores a block locator of the chain the database is synced to so that the index can efficiently determine the point it last stopped at |
| CTxIndex::DB | Access to the txindex database (indexes/txindex/) |
| Ckernel::BlockTreeDB | Access to the block database (blocks/index/) |
| CCExtKey | |
| CCExtPubKey | |
| CCFeeRate | Fee rate in satoshis per kilovirtualbyte: CAmount / kvB |
| CChaCha20 | Unrestricted ChaCha20 cipher |
| CChaCha20Aligned | ChaCha20 cipher that only operates on multiples of 64 bytes |
| Cinterfaces::Chain | Interface giving clients (wallet processes, maybe other analysis tools in the future) ability to access to the chain state, receive notifications, estimate fees, and submit transactions |
| ▶Cinterfaces::ChainClient | Interface to let node manage chain clients (wallets, or maybe tools for monitoring and analysis in the future) |
| Cinterfaces::WalletLoader | Wallet chain client that in addition to having chain client methods for starting up, shutting down, and registering RPCs, also has additional methods (called by the GUI) to load and create wallets |
| ▶CChainstate | Chainstate stores and provides an API to update our local knowledge of the current best chain |
| CDummyChainState | |
| Cnode::ChainstateLoadOptions | |
| ▶CChainstateManager | Provides an interface for creating and interacting with one or two chainstates: an IBD chainstate generated by downloading blocks, and an optional snapshot chainstate loaded from a UTXO snapshot |
| CTestChainstateManager | |
| Ckernel::ChainstateManagerOpts | An options struct for ChainstateManager, more ergonomically referred to as ChainstateManager::Options due to the using-declaration in ChainstateManager |
| CChainTxData | Holds various statistics on transactions within a chain |
| CCHash160 | A hasher class for Bitcoin's 160-bit hash (SHA-256 + RIPEMD-160) |
| CCHash256 | A hasher class for Bitcoin's 256-bit hash (double SHA-256) |
| Cwallet::CHDChain | |
| CCheckVarIntMode< Mode, I > | |
| CCHKDF_HMAC_SHA256_L32 | A rfc5869 HKDF implementation with HMAC_SHA256 and fixed key output length of 32 bytes (L=32) |
| CCHMAC_SHA256 | A hasher class for HMAC-SHA-256 |
| CCHMAC_SHA512 | A hasher class for HMAC-SHA-512 |
| CChronoFormatter< U, LOSSY > | |
| CCInv | Inv message data |
| CCKey | An encapsulated private key |
| Cwallet::CKeyMetadata | |
| Cwallet::CKeyPool | A key from a CWallet's keypool |
| ▶CClient | |
| Cgen::FooInterface::Client | |
| Cipc::capnp::messages::Echo::Client | |
| Cipc::capnp::messages::Init::Client | |
| CCLogCategoryDesc | |
| CCMainSignals | |
| Cwallet::CMasterKey | Private key encryption is done based on a CMasterKey, which holds a salt and random encryption key |
| CCMedianFilter< T > | Median filter over a stream of values |
| CCMerkleBlock | Used to relay blocks as header + vector<merkle branch> to filtered nodes |
| Cwallet::CMerkleTx | Legacy class used for deserializing vtxPrev for backwards compatibility |
| CCMessageHeader | Message header |
| CCMutableTransaction | A mutable version of CTransaction |
| ▶CCNetAddr | Network address |
| ▶CCService | A combination of a network address (CNetAddr) and a (TCP) port |
| ▶CCAddress | A CService with information about it as peer |
| CAddrInfo | Extended statistics about a CAddress |
| CCNetCleanup | |
| CCNetMessage | Transport protocol agnostic message container |
| CCNode | Information about a peer |
| CCNodeCombinedStats | |
| CCNodeOptions | |
| CCNodeStateStats | |
| CCNodeStats | |
| CCNoDestination | |
| CCoin | A UTXO entry |
| Cwallet::CoinEligibilityFilter | Parameters for filtering which OutputGroups we may use in coin selection |
| Cwallet::CoinFilterParams | |
| Cwallet::CoinSelectionParams | Parameters for one iteration of Coin Selection |
| Cwallet::CoinsResult | COutputs available for spending, stored by OutputType |
| 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 | |
| CCSVModelWriter::Column | |
| CArgsManager::Command | |
| CCompactSizeFormatter< RangeCheck > | Formatter for integers in CompactSize format |
| CCompactSizeWriter | |
| CCompareBlocksByHeight | Comparison function for sorting the getchaintips heads |
| Cnode::CompareCTxMemPoolIter | Comparator for CTxMemPool::txiter objects |
| CCompareIteratorByHash | |
| CCompareNodeNetworkTime | Sort eviction candidates by network/localhost and connection uptime |
| Cnode::CompareTxIterByAncestorCount | |
| CCompareTxMemPoolEntryByAncestorFee | |
| CCompareTxMemPoolEntryByAncestorScore | Sort an entry by min(score/size of entry's tx, score/size with all ancestors) |
| CCompareTxMemPoolEntryByDescendantScore | Sort an entry by max(score/size of entry's tx, score/size with all descendants) |
| CCompareTxMemPoolEntryByEntryTime | |
| CCompareTxMemPoolEntryByScore | Sort by feerate of entry (fee/size) in descending order This is only used for transaction relay, so we use GetFee() instead of GetModifiedFee() to avoid leaking prioritization information via the sort order |
| CCompressedHeader | |
| Cankerl::nanobench::Config | |
| Ccommon::ConfigError | |
| Ci2p::Connection | An established connection with another peer |
| CConnectTrace | Used to track blocks whose transactions were applied to the UTXO state as a part of a single ActivateBestChainStep call |
| Cprevector< N, T, Size, Diff >::const_iterator | |
| Cprevector< N, T, Size, Diff >::const_reverse_iterator | |
| Cipc::capnp::messages::Init::ConstructParams | |
| Cipc::capnp::messages::Init::ConstructResults | |
| Cmp::init_fields::Context | |
| ▶Cipc::Context | 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 |
| Cipc::capnp::Context | Cap'n Proto context struct |
| Ckernel::Context | Context struct holding the kernel library's logically global state, and passed to external libbitcoin_kernel functions which need access to this state |
| Cmp::echo_fields::Context | |
| Ctinyformat::detail::convertToInt< T, convertible > | |
| Ctinyformat::detail::convertToInt< T, true > | |
| CCOutPoint | An outpoint - a combination of a transaction hash and an index n into its vout |
| Cwallet::COutput | A UTXO under consideration for use in funding a new transaction |
| Cwallet::COutputEntry | |
| ▶CCPartialMerkleTree | Data structure that represents a partial merkle tree |
| CCPartialMerkleTreeTester | |
| CCPubKey | An encapsulated public key |
| Cwallet::CreatedTransactionResult | |
| Cwallet::CRecipient | |
| CCRIPEMD160 | A hasher class for RIPEMD-160 |
| CCRollingBloomFilter | RollingBloomFilter is a probabilistic "keep track of most recently inserted" set |
| CCRPCCommand | |
| CCRPCConvertParam | |
| CCRPCConvertTable | |
| CCRPCSignals | |
| CCRPCTable | RPC command dispatcher |
| CCScheduler | Simple class for background tasks that should be run periodically or once "after a while" |
| CCScriptCheck | Closure representing one script verification Note that this stores references to the spending transaction |
| CCScriptNum | |
| CCScriptNum10 | |
| CCScriptWitness | |
| CCSemaphore | An implementation of a semaphore |
| CCSemaphoreGrant | RAII-style semaphore lock |
| CCSerializedNetMsg | |
| ▶CCSerializeMethodsTestSingle | |
| CCSerializeMethodsTestMany | |
| CCServiceHash | |
| CCSHA1 | A hasher class for SHA1 |
| CCSHA256 | A hasher class for SHA-256 |
| CCSHA512 | A hasher class for SHA-512 |
| CCSipHasher | SipHash-2-4 |
| CCSubNet | |
| Cctaes_test | |
| 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 |
| CMemPoolTest | |
| CCTxMemPoolEntry | CTxMemPoolEntry stores data about the corresponding transaction, as well as data about all in-mempool transactions that depend on the transaction ("descendant" transactions) |
| Cnode::CTxMemPoolModifiedEntry | |
| CCTxOut | An output of a transaction |
| CCTxUndo | Undo information for a CTransaction |
| CCUpdatedBlock | |
| CCustomUintFormatter< Bytes, BigEndian > | Serialization wrapper class for custom integers and enums |
| ▶CCValidationInterface | Implement this to subscribe to events generated in validation and mempool |
| ▶CBaseIndex | Base class for indices of blockchain data |
| CBlockFilterIndex | BlockFilterIndex is used to store and retrieve block filters, hashes, and headers for a range of blocks by height |
| CCoinStatsIndex | CoinStatsIndex maintains statistics on the UTXO set |
| CTxIndex | TxIndex is used to look up transactions included in the blockchain by hash |
| CBlockValidationStateCatcher | |
| 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 |
| CCZMQNotificationInterface | |
| CPeerManager | |
| Csubmitblock_StateCatcher | |
| CTestInterface | |
| CTestSubscriber | |
| CTestSubscriberNoop | |
| CCVerifyDB | RAII wrapper for VerifyDB: Verify consistency of the block and coin databases |
| Cwallet::CWalletTx | A transaction with a bunch of additional info that only the owner cares about |
| ▶CCZMQAbstractNotifier | |
| ▶CCZMQAbstractPublishNotifier | |
| CCZMQPublishHashBlockNotifier | |
| CCZMQPublishHashTransactionNotifier | |
| CCZMQPublishRawBlockNotifier | |
| CCZMQPublishRawTransactionNotifier | |
| CCZMQPublishSequenceNotifier | |
| ▶Cwallet::DatabaseBatch | RAII class that provides access to a WalletDatabase |
| Cwallet::BerkeleyBatch | RAII class that provides access to a Berkeley database |
| Cwallet::DummyBatch | RAII class that provides access to a DummyDatabase |
| Cwallet::MockableBatch | |
| Cwallet::SQLiteBatch | RAII class that provides access to a WalletDatabase |
| ▶Cwallet::DatabaseCursor | |
| Cwallet::BerkeleyCursor | |
| Cwallet::DummyCursor | |
| Cwallet::MockableCursor | |
| Cwallet::SQLiteCursor | RAII class that provides a database cursor |
| Cwallet::DatabaseOptions | |
| CDataStream | Double ended buffer combining vector and stream-like interfaces |
| CDBOptions | User-controlled performance and debug options |
| CDBParams | Application-specific storage settings |
| CDebugLogHelper | |
| Cbech32::DecodeResult | |
| CDefaultFormatter | Default formatter |
| CCTxMemPool::delta_info | |
| CDereferencingComparator< T > | |
| CDerivedAndBaseFormat | |
| Cdescendant_score | |
| CDescribeAddressVisitor | |
| Cwallet::DescribeWalletAddressVisitor | |
| ▶CDescriptor | Interface for parsed descriptor objects |
| Cwallet::DummyDescriptor | |
| CDescriptorCache | Cache for single descriptor's derived extended pubkeys |
| Cdeserialize_type | Dummy data type to identify deserializing constructors |
| Cipc::capnp::messages::Echo::DestroyParams | |
| Cipc::capnp::messages::Echo::DestroyResults | |
| CDifferenceFormatter | |
| Cprevector< N, T, Size, Diff >::direct_or_indirect | |
| CDisconnectedBlockTransactions | DisconnectedBlockTransactions |
| Cinterfaces::Echo | Simple string echoing interface for testing |
| Cipc::capnp::messages::Echo | |
| Cmp::echo_fields::Echo | |
| Cipc::capnp::messages::Echo::EchoParams | |
| Cipc::capnp::messages::Echo::EchoResults | |
| Cecmult_multi_data | |
| CECRYPT_ctx | |
| Cellswift_decode_test | |
| Cellswift_xdh_test | |
| Cellswift_xswiftec_inv_test | |
| CEllSwiftPubKey | An ElligatorSwift-encoded public key |
| Centry_time | |
| CEpoch | Epoch: RAII-style guard for using epoch-based graph traversal algorithms |
| CSock::EqualSharedPtrSock | |
| Cutil::Error | |
| CEstimationResult | |
| CEstimatorBucket | |
| CSock::Events | Auxiliary requested/occurred events to wait for in WaitMany() |
| ▶Cexception | |
| CStopHashingException | |
| CCheckValueTest::Expect | |
| CCTxMemPoolEntry::ExplicitCopyTag | |
| CExternalSigner | Enables interaction with an external signing device or service, such as a hardware wallet |
| Cinterfaces::ExternalSigner | External signer interface used by the GUI |
| Ctinyformat::detail::is_convertible< T1, T2 >::fail | |
| CFailingCheck | |
| ▶Cfailure | |
| CInvalidAddrManVersionError | |
| CFakeCheck | |
| CFakeCheckCheckCompletion | |
| ▶Cfalse_type | |
| ▶CSpan< C >::is_Span_int< std::remove_cv< T >::type > | |
| CSpan< C >::is_Span< T > | |
| CSpan< C >::is_Span_int< T > | |
| CFastRandomContext | Fast randomness source |
| CFeeCalculation | |
| CFeeFilterRounder | |
| Cfsbridge::FileLock | |
| CFilterHeaderHasher | |
| ▶CFlatFilePos | |
| CCDiskTxPos | |
| CFlatFileSeq | FlatFileSeq represents a sequence of numbered files storing raw data |
| CFooImplementation | |
| Cgen::FooInterface | |
| Ctinyformat::detail::FormatArg | |
| ▶Ctinyformat::FormatList | List of template arguments format(), held in a type-opaque way |
| Ctinyformat::detail::FormatListN< N > | |
| Ctinyformat::detail::FormatListN< 0 > | |
| Ctinyformat::detail::formatValueAsType< T, fmtT, convertible > | |
| Ctinyformat::detail::formatValueAsType< T, fmtT, true > | |
| Cinterfaces::FoundBlock | Helper for findBlock to selectively return pieces of block data |
| CFrozenCleanupCheck | |
| CFSChaCha20 | Forward-secure ChaCha20 |
| CFSChaCha20Poly1305 | Forward-secure wrapper around AEADChaCha20Poly1305 |
| CFuzzedDataProvider | |
| CFuzzedFileProvider | |
| CFuzzTarget | |
| CFuzzTargetOptions | |
| CGCSFilter | This implements a Golomb-coded set as defined in BIP 158 |
| CGenTxid | A generic txid reference (txid or wtxid) |
| Cpyminisketch.GF2Ops | |
| CGFMulHelper< I, N, L, F, K > | Helper class for carryless multiplications |
| CGFMulHelper< I, N, L, F, 0 > | |
| Cwallet::Groups | |
| Cwallet::GroupVerifier | |
| CEpoch::Guard | |
| CAppTests::HandleCallback | RAII helper to remove no-longer-pending callback |
| Cinterfaces::Handler | Generic interface for managing an event handler or callback function registered with another interface |
| CSock::HashSharedPtrSock | |
| ▶CHashWriter | A writer stream (for serialization) that computes a 256-bit hash |
| CHashedSourceWriter< Source > | Writes data to an underlying source stream, while hashing the written data |
| CHashVerifier< Source > | Reads data from an underlying stream, while hashing the read data |
| CHasJSON | |
| CHasReason | BOOST_CHECK_EXCEPTION predicates to check the specific validation error |
| ▶CHeadersSyncState | HeadersSyncState: |
| CFuzzedHeadersSyncState | |
| ▶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 |
| CHTTPRequestTracker | Helps keep track of open evhttp_connections with active evhttp_requests |
| CIdTrans | The identity transformation |
| CTxRequestTracker::Impl | Actual implementation for TxRequestTracker's data structure |
| CTxReconciliationTracker::Impl | Actual implementation for TxReconciliationTracker's data structure |
| Cwallet::ImportData | |
| Cnode::ImportingNow | |
| Ckernel::ImportMempoolOptions | |
| Cindex_by_wtxid | |
| CIndexSummary | |
| Cindirectmap< K, T > | |
| CTransport::Info | |
| Cipc::capnp::messages::Init | |
| Cinterfaces::Init | Initial interface created when a process is first started, and used to give and get access to other interfaces (Node, Chain, Wallet, etc) |
| Cminiscript::internal::InputResult | A pair of a satisfaction and a dissatisfaction InputStack |
| Cminiscript::internal::InputStack | An object representing a sequence of witness stack elements |
| Ckernel::Interrupted | Result type for use with std::variant to indicate that an operation should be interrupted |
| Cinterfaces::Ipc | Interface providing access to interprocess-communication (IPC) functionality |
| Ctinyformat::detail::is_convertible< T1, T2 > | |
| Ctinyformat::detail::is_wchar< T > | |
| Ctinyformat::detail::is_wchar< const wchar_t * > | |
| Ctinyformat::detail::is_wchar< const wchar_t[n]> | |
| Ctinyformat::detail::is_wchar< wchar_t * > | |
| Ctinyformat::detail::is_wchar< wchar_t[n]> | |
| Cankerl::nanobench::detail::IterationLogic | |
| Cbitdeque< BlobSize >::Iterator< Const > | Iterator to a bitdeque element, const or not |
| Cprevector< N, T, Size, Diff >::iterator | |
| CTxOrphanage::IteratorComparator | |
| Cnode::IteratorComparator | |
| CCDBIterator::IteratorImpl | |
| CJSONRPCRequest | |
| CJSONUTF8StringFilter | Filter that generates and validates UTF-8, as well as collates UTF-16 surrogate pairs as specified in RFC4627 |
| CKeyInfo | |
| CKeyOriginInfo | |
| CTaprootBuilder::LeafInfo | Information about a tracked leaf in the Merkle tree |
| CLevelDBContext | |
| CLFSR< F, MOD > | Class which implements a stateless LFSR for generic moduli |
| CLimitedStringFormatter< Limit > | |
| CLinTrans< I, N > | A Linear N-bit transformation over the field I |
| Cmemusage::list_node< X > | |
| CCConnman::ListenSocket | |
| CMainSignalsImpl::ListEntry | List entries consist of a callback pointer and reference count |
| CPoolResource< MAX_BLOCK_SIZE_BYTES, ALIGN_BYTES >::ListNode | In-place linked list of the allocations, used for the freelist |
| Cwallet::LoadResult | |
| CLocalServiceInfo | |
| ▶Clock_guard | |
| CStdLockGuard | |
| ▶CLockedPageAllocator | OS-dependent allocation and deallocation of locked/pinned memory pages |
| CPosixLockedPageAllocator | LockedPageAllocator specialized for OSes that don't try to be special snowflakes |
| CTestLockedPageAllocator | Mock LockedPageAllocator for testing |
| ▶CLockedPool | Pool for locked memory chunks |
| CLockedPoolManager | Singleton class to keep track of locked (ie, non-swappable) memory, for use in std::allocator templates |
| CLockPoints | |
| CLogCategory | |
| CBCLog::Logger | |
| ▶CLogger | |
| CCBitcoinLevelDBLogger | |
| CMainSignalsImpl | MainSignalsImpl manages a list of shared_ptr<CValidationInterface> callbacks |
| Cipc::capnp::messages::Init::MakeEchoParams | |
| Cipc::capnp::messages::Init::MakeEchoResults | |
| CEpoch::Marker | |
| Cminiscript::internal::MaxInt< I > | Class whose objects represent the maximum of a list of integers |
| Cminiscript::internal::MaxInt< uint32_t > | |
| CMemoryCheck | |
| CMempoolAcceptResult |
Validation result for a transaction evaluated by MemPoolAccept (single or package) |
| Cmempoolentry_txid | |
| Cmempoolentry_wtxid | |
| Ckernel::MemPoolLimits | Options struct containing limit options for a CTxMemPool |
| Ckernel::MemPoolOptions | Options struct containing options for constructing a CTxMemPool |
| Cwallet::MigrationData | Struct containing information needed for migrating legacy wallets to descriptor wallets |
| Cwallet::MigrationResult | |
| Cnode::MiniMiner | A minimal version of BlockAssembler, using the same ancestor set scoring algorithm |
| Cnode::MiniMinerMempoolEntry | |
| Cpyminisketch.Minisketch | |
| Cwallet::MinOutputGroupComparator | |
| CMockedDescriptorConverter | Converts a mocked descriptor string to a valid one |
| Cnode::modifiedentry_iter | |
| CMuHash3072 | A class representing MuHash sets |
| ▶Cmutex | |
| CAnnotatedMixin< std::mutex > | |
| CStdMutex | |
| ▶CNetEventsInterface | Interface for message handling |
| CPeerManager | |
| CNetGroupManager | Netgroup manager |
| ▶CNetPermissions | |
| CNetWhitebindPermissions | |
| CNetWhitelistPermissions | |
| CNetworkSetup | |
| CNetworkStyle | |
| CNewMempoolTransactionInfo | |
| CAddrManImpl::NewTriedCount | |
| CNoCopy | |
| Cminiscript::Node< Key > | A node in a miniscript expression |
| Cinterfaces::Node | Top-level interface for a bitcoin node (bitcoind process) |
| Cnode::NodeContext | NodeContext struct containing references to chain state and connection state |
| CNodeEvictionCandidate | |
| CTaprootBuilder::NodeInfo | Information associated with a node in the Merkle tree |
| CCConnman::NodesSnapshot | RAII helper to atomically create a copy of m_nodes and add a reference to each of the nodes |
| Cminiscript::internal::NoDupCheck | |
| CNoechoInst | |
| CNoIncludeConfTest | |
| Cnontrivial_t | |
| ▶Ckernel::Notifications | A base class defining functions for notifying about certain kernel events |
| Cnode::KernelNotifications | |
| ▶Cinterfaces::Chain::Notifications | Chain notifications |
| Cwallet::CWallet | A CWallet maintains a set of transactions and balances, and provides the ability to create new transactions |
| CNSBundle(returnCorrectIdentifier) | |
| CNum< N > | A type to represent integers in the type system |
| CNum3072 | |
| Cminiscript::internal::Ops | |
| CCConnman::Options | |
| CPeerManager::Options | |
| Cnode::BlockAssembler::Options | |
| CTxOrphanage::OrphanTx | |
| Cwallet::OutputGroup | A group of UTXOs paid to the same output script |
| Cwallet::OutputGroupTypeMap | Stores several 'Groups' whose were mapped by output type |
| CPackageMempoolAcceptResult | Validation result for package mempool acceptance |
| CGCSFilter::Params | |
| CConsensus::Params | Parameters that influence chain consensus |
| CParamsStream< Params, SubStream > | Wrapper that overrides the GetParams() function of a stream (and hides GetVersion/GetType) |
| CParamsWrapper< Params, T > | Wrapper that serializes objects with the specified parameters |
| CParentInfo | Helper for PackageV3Checks, storing info for a mempool or package parent |
| CPartiallyDownloadedBlock | |
| CPartiallySignedTransaction | A version of CTransaction with the PSBT format |
| Cgen::FooInterface::PassOutPointParams | |
| Cgen::FooInterface::PassOutPointResults | |
| Cgen::FooInterface::PassUniValueParams | |
| Cgen::FooInterface::PassUniValueResults | |
| ▶Cpath | |
| Cfs::path | Path class wrapper to block calls to the fs::path(std::string) implicit constructor and the fs::path::string() method, which have unsafe and unpredictable behavior on Windows (see implementation note in PathToString for details) |
| CNetinfoRequestHandler::Peer | |
| CPerBlockConnectTrace | |
| Cankerl::nanobench::detail::PerfCountSet< T > | |
| Cankerl::nanobench::detail::PerfCountSet< bool > | |
| Cankerl::nanobench::detail::PerfCountSet< uint64_t > | |
| Cankerl::nanobench::detail::PerformanceCounters | |
| Cipc::capnp::messages::Init::MakeEchoParams::Pipeline | |
| Cipc::capnp::messages::Init::MakeEchoResults::Pipeline | |
| Cipc::capnp::messages::Echo::EchoParams::Pipeline | |
| Cipc::capnp::messages::Init::ConstructResults::Pipeline | |
| Cipc::capnp::messages::Echo::EchoResults::Pipeline | |
| Cipc::capnp::messages::Echo::DestroyResults::Pipeline | |
| Cipc::capnp::messages::Echo::DestroyParams::Pipeline | |
| Cgen::FooInterface::AddParams::Pipeline | |
| Cgen::FooInterface::AddResults::Pipeline | |
| Cgen::FooInterface::PassOutPointParams::Pipeline | |
| Cgen::FooInterface::PassOutPointResults::Pipeline | |
| Cgen::FooInterface::PassUniValueParams::Pipeline | |
| Cgen::FooInterface::PassUniValueResults::Pipeline | |
| Cipc::capnp::messages::Init::ConstructParams::Pipeline | |
| CPlatformStyle | |
| CPoly1305 | C++ wrapper with std::byte Span interface around poly1305_donna code |
| Cpoly1305_donna::poly1305_context | |
| CPoolAllocator< T, MAX_BLOCK_SIZE_BYTES, ALIGN_BYTES > | Forwards all allocations/deallocations to the PoolResource |
| CPoolResource< MAX_BLOCK_SIZE_BYTES, ALIGN_BYTES > | A memory resource similar to std::pmr::unsynchronized_pool_resource, but optimized for node-based containers |
| CPoolResourceTester | Helper to get access to private parts of PoolResource |
| CPrecomputedTransactionData | |
| CPrefilledTransaction | |
| Cwallet::PreselectedInput | |
| Cwallet::PreSelectedInputs | |
| CPreSelectInputs | |
| ▶Cprevector< N, T, Size, Diff > | Implements a drop-in replacement for std::vector<T> which stores up to N elements directly (without heap allocation) |
| CCScript | Serialized script, used inside transaction inputs and outputs |
| Cprevector< ADDR_IPV6_SIZE, uint8_t > | |
| Cprevector< N, T > | |
| Cprevector_tester< N, T > | |
| Cipc::Process | IPC process interface for spawning bitcoin processes and serving requests in processes that have been spawned |
| CHeadersSyncState::ProcessingResult | Result data structure for ProcessNextHeaders |
| Cipc::Protocol | IPC protocol interface for calling IPC methods over sockets |
| CProxy | |
| ▶CProxyClientCustom | |
| Cmp::ProxyClient< gen::FooInterface > | |
| Cmp::ProxyClient< ipc::capnp::messages::Echo > | |
| Cmp::ProxyClient< ipc::capnp::messages::Init > | |
| CProxyCredentials | Credentials for proxy authentication |
| Cmp::ProxyMethod< gen::FooInterface::AddParams > | |
| Cmp::ProxyMethod< gen::FooInterface::PassOutPointParams > | |
| Cmp::ProxyMethod< gen::FooInterface::PassUniValueParams > | |
| Cmp::ProxyMethod< ipc::capnp::messages::Echo::EchoParams > | |
| Cmp::ProxyMethod< ipc::capnp::messages::Init::MakeEchoParams > | |
| ▶CProxyServerCustom | |
| Cmp::ProxyServer< gen::FooInterface > | |
| Cmp::ProxyServer< ipc::capnp::messages::Echo > | |
| Cmp::ProxyServer< ipc::capnp::messages::Init > | |
| CProxySetting | |
| Cmp::ProxyType< FooImplementation > | |
| Cmp::ProxyType< interfaces::Echo > | |
| Cmp::ProxyType< interfaces::Init > | |
| Cnode::PruneLockInfo | |
| Cnode::PSBTAnalysis | Holds the results of AnalyzePSBT (miscellaneous information about a PSBT) |
| CPSBTInput | A structure for PSBTs which contain per-input information |
| Cnode::PSBTInputAnalysis | Holds an analysis of one input from a PSBT |
| CPSBTOutput | A structure for PSBTs which contains per output information |
| CPSBTProprietary | A structure for PSBT proprietary types |
| CPoolResourceTester::PtrAndBytes | |
| CPubKeyDestination | |
| ▶CQAbstractItemDelegate | |
| CTxViewDelegate | |
| ▶CQAbstractListModel | |
| CBitcoinUnits | Bitcoin unit definitions |
| COptionsModel | Interface from Qt to configuration data structure for Bitcoin client |
| ▶CQAbstractSpinBox | |
| CAmountSpinBox | QSpinBox that uses fixed-point numbers internally and uses our own formatting/parsing functions |
| ▶CQAbstractTableModel | |
| CAddressTableModel | Qt model of the address book in the core |
| CBanTableModel | Qt model providing information about banned peers, similar to the "getpeerinfo" RPC call |
| CPeerTableModel | Qt model providing information about connected peers, similar to the "getpeerinfo" RPC call |
| CRecentRequestsTableModel | Model for list of recently generated payment requests / bitcoin: URIs |
| CTransactionTableModel | UI model for the transaction table of a wallet |
| ▶CQApplication | |
| CBitcoinApplication | Main Bitcoin application object |
| ▶CQComboBox | |
| CQValueComboBox | |
| ▶CQDialog | |
| CAddressBookPage | Widget that shows a list of sending or receiving addresses |
| CAskPassphraseDialog | Multifunctional dialog to ask for passphrases |
| CCoinControlDialog | |
| CCreateWalletDialog | Dialog for creating wallets |
| CEditAddressDialog | Dialog for editing an address and associated information |
| CHelpMessageDialog | "Help message" dialog box |
| CIntro | Introduction screen (pre-GUI startup) |
| COpenURIDialog | |
| COptionsDialog | Preferences dialog |
| CPSBTOperationsDialog | Dialog showing transaction details |
| CReceiveCoinsDialog | Dialog for requesting payment of bitcoins |
| CReceiveRequestDialog | |
| CSendCoinsDialog | Dialog for sending bitcoins |
| CSignVerifyMessageDialog | |
| CTransactionDescDialog | Dialog showing transaction details |
| ▶CQFrame | |
| CWalletFrame | A container for embedding all wallet-related controls into BitcoinGUI |
| ▶CQItemDelegate | |
| CGUIUtil::ItemDelegate | |
| ▶CQLabel | |
| ▶CGUIUtil::ThemedLabel | |
| CGUIUtil::ClickableLabel | |
| CQRImageWidget | |
| CUnitDisplayStatusBarControl | |
| ▶CQLineEdit | |
| CQValidatedLineEdit | Line edit that can be marked as "invalid" to show input validation feedback |
| ▶CQListView | |
| CTransactionOverviewWidget | |
| ▶CQMainWindow | |
| CBitcoinGUI | Bitcoin GUI main class |
| ▶CQMessageBox | |
| CSendConfirmationDialog | |
| ▶CQObject | |
| CAddressBookTests | |
| CAppTests | |
| CClientModel | Model for Bitcoin network client |
| CCSVModelWriter | Export a Qt table model to a CSV file |
| CFreespaceChecker | |
| CGUIUtil::LabelOutOfFocusEventFilter | Qt event filter that intercepts QEvent::FocusOut events for QLabel objects, and resets their ‘textInteractionFlags’ property to get rid of the visible cursor |
| CGUIUtil::ToolTipToRichTextFilter | Qt event filter that intercepts ToolTipChange events, and replaces the tooltip with a rich text representation if needed |
| CInitExecutor | Class encapsulating Bitcoin Core startup and shutdown |
| CMacDockIconHandler | MacOS-specific Dock icon handler |
| CMacNotificationHandler | Macintosh-specific notification handler (supports UserNotificationCenter) |
| CNotificator | Cross-platform desktop notification client |
| COptionTests | |
| CPaymentServer | |
| CQtRPCTimerBase | Class for handling RPC timers (used for e.g |
| CRPCExecutor | |
| CRPCNestedTests | |
| CTransactionDesc | Provide a human-readable extended HTML description of a transaction |
| CURITests | |
| CWalletController | Controller between interfaces::Node, WalletModel instances and the GUI |
| ▶CWalletControllerActivity | |
| CCreateWalletActivity | |
| CLoadWalletsActivity | |
| CMigrateWalletActivity | |
| COpenWalletActivity | |
| CRestoreWalletActivity | |
| CWalletModel | Interface to Bitcoin wallet from Qt view code |
| CWalletTests | |
| ▶CQProgressBar | |
| CGUIUtil::ClickableProgressBar | |
| ▶CQSortFilterProxyModel | |
| CAddressBookSortFilterProxyModel | |
| CPeerTableSortProxy | |
| CTransactionFilterProxy | Filter the transaction list according to pre-specified rules |
| ▶CQStackedWidget | |
| CWalletView | |
| ▶CQStyledItemDelegate | |
| CPeerIdViewDelegate | |
| Cqt_meta_stringdata_AddressBookPage_t | |
| Cqt_meta_stringdata_AddressBookTests_t | |
| Cqt_meta_stringdata_AddressTableModel_t | |
| Cqt_meta_stringdata_AppTests_t | |
| Cqt_meta_stringdata_AskPassphraseDialog_t | |
| Cqt_meta_stringdata_BanTableModel_t | |
| Cqt_meta_stringdata_BitcoinAddressCheckValidator_t | |
| Cqt_meta_stringdata_BitcoinAddressEntryValidator_t | |
| Cqt_meta_stringdata_BitcoinAmountField_t | |
| Cqt_meta_stringdata_BitcoinApplication_t | |
| Cqt_meta_stringdata_BitcoinGUI_t | |
| Cqt_meta_stringdata_BitcoinUnits_t | |
| Cqt_meta_stringdata_ClientModel_t | |
| Cqt_meta_stringdata_CoinControlDialog_t | |
| Cqt_meta_stringdata_CoinControlTreeWidget_t | |
| Cqt_meta_stringdata_CreateWalletActivity_t | |
| Cqt_meta_stringdata_CreateWalletDialog_t | |
| Cqt_meta_stringdata_CSVModelWriter_t | |
| Cqt_meta_stringdata_EditAddressDialog_t | |
| Cqt_meta_stringdata_GUIUtil__ClickableLabel_t | |
| Cqt_meta_stringdata_GUIUtil__ClickableProgressBar_t | |
| Cqt_meta_stringdata_GUIUtil__ItemDelegate_t | |
| Cqt_meta_stringdata_GUIUtil__LabelOutOfFocusEventFilter_t | |
| Cqt_meta_stringdata_GUIUtil__ThemedLabel_t | |
| Cqt_meta_stringdata_GUIUtil__ToolTipToRichTextFilter_t | |
| Cqt_meta_stringdata_HelpMessageDialog_t | |
| Cqt_meta_stringdata_InitExecutor_t | |
| Cqt_meta_stringdata_Intro_t | |
| Cqt_meta_stringdata_LoadWalletsActivity_t | |
| Cqt_meta_stringdata_MacDockIconHandler_t | |
| Cqt_meta_stringdata_MacNotificationHandler_t | |
| Cqt_meta_stringdata_MigrateWalletActivity_t | |
| Cqt_meta_stringdata_ModalOverlay_t | |
| Cqt_meta_stringdata_Notificator_t | |
| Cqt_meta_stringdata_OpenURIDialog_t | |
| Cqt_meta_stringdata_OpenWalletActivity_t | |
| Cqt_meta_stringdata_OptionsDialog_t | |
| Cqt_meta_stringdata_OptionsModel_t | |
| Cqt_meta_stringdata_OptionTests_t | |
| Cqt_meta_stringdata_OverviewPage_t | |
| Cqt_meta_stringdata_PaymentServer_t | |
| Cqt_meta_stringdata_PeerTableModel_t | |
| Cqt_meta_stringdata_PeerTableSortProxy_t | |
| Cqt_meta_stringdata_ProxyAddressValidator_t | |
| Cqt_meta_stringdata_PSBTOperationsDialog_t | |
| Cqt_meta_stringdata_QRImageWidget_t | |
| Cqt_meta_stringdata_QValidatedLineEdit_t | |
| Cqt_meta_stringdata_QValueComboBox_t | |
| Cqt_meta_stringdata_ReceiveCoinsDialog_t | |
| Cqt_meta_stringdata_ReceiveRequestDialog_t | |
| Cqt_meta_stringdata_RecentRequestsTableModel_t | |
| Cqt_meta_stringdata_RestoreWalletActivity_t | |
| Cqt_meta_stringdata_RPCConsole_t | |
| Cqt_meta_stringdata_RPCNestedTests_t | |
| Cqt_meta_stringdata_SendCoinsDialog_t | |
| Cqt_meta_stringdata_SendCoinsEntry_t | |
| Cqt_meta_stringdata_SendConfirmationDialog_t | |
| Cqt_meta_stringdata_ShutdownWindow_t | |
| Cqt_meta_stringdata_SignVerifyMessageDialog_t | |
| Cqt_meta_stringdata_SplashScreen_t | |
| Cqt_meta_stringdata_TrafficGraphWidget_t | |
| Cqt_meta_stringdata_TransactionDesc_t | |
| Cqt_meta_stringdata_TransactionDescDialog_t | |
| Cqt_meta_stringdata_TransactionFilterProxy_t | |
| Cqt_meta_stringdata_TransactionOverviewWidget_t | |
| Cqt_meta_stringdata_TransactionTableModel_t | |
| Cqt_meta_stringdata_TransactionView_t | |
| Cqt_meta_stringdata_UnitDisplayStatusBarControl_t | |
| Cqt_meta_stringdata_URITests_t | |
| Cqt_meta_stringdata_WalletController_t | |
| Cqt_meta_stringdata_WalletControllerActivity_t | |
| Cqt_meta_stringdata_WalletFrame_t | |
| Cqt_meta_stringdata_WalletModel_t | |
| Cqt_meta_stringdata_WalletTests_t | |
| Cqt_meta_stringdata_WalletView_t | |
| ▶CQTreeWidget | |
| CCoinControlTreeWidget | |
| ▶CQTreeWidgetItem | |
| CCCoinControlWidgetItem | |
| ▶CQValidator | |
| CBitcoinAddressCheckValidator | Bitcoin address widget validator, checks for a valid bitcoin address |
| CBitcoinAddressEntryValidator | Base58 entry widget validator, checks for valid characters and removes some whitespace |
| CProxyAddressValidator | Proxy address widget validator, checks for a valid proxy address |
| ▶CQWidget | |
| CBitcoinAmountField | Widget for entering bitcoin amounts |
| CModalOverlay | Modal overlay to display information about the chain-sync state |
| COverviewPage | Overview ("home") page widget |
| CRPCConsole | Local Bitcoin RPC console |
| CSendCoinsEntry | A single entry in the dialog for sending bitcoins |
| 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 |
| CReachableNets | List of reachable networks |
| Cipc::capnp::messages::Echo::EchoResults::Reader | |
| Cipc::capnp::messages::Init::MakeEchoResults::Reader | |
| Cipc::capnp::messages::Init::ConstructParams::Reader | |
| Cgen::FooInterface::PassUniValueParams::Reader | |
| Cgen::FooInterface::PassOutPointParams::Reader | |
| Cipc::capnp::messages::Echo::DestroyResults::Reader | |
| Cgen::FooInterface::AddResults::Reader | |
| Cipc::capnp::messages::Echo::EchoParams::Reader | |
| Cipc::capnp::messages::Init::ConstructResults::Reader | |
| Cgen::FooInterface::AddParams::Reader | |
| Cgen::FooInterface::PassOutPointResults::Reader | |
| Cipc::capnp::messages::Init::MakeEchoParams::Reader | |
| Cgen::FooInterface::PassUniValueResults::Reader | |
| Cipc::capnp::messages::Echo::DestroyParams::Reader | |
| CPoolAllocator< T, MAX_BLOCK_SIZE_BYTES, ALIGN_BYTES >::rebind< U > | The rebind struct here is mandatory because we use non type template arguments for PoolAllocator |
| CRecentRequestEntry | |
| CRecentRequestEntryLessThan | |
| CRecLinTrans< I, N > | A linear transformation constructed using LinTrans tables for sections of bits |
| CRecLinTrans< I, N > | |
| CRecLinTrans< I, N, X... > | |
| CRecLinTrans< I, X... > | |
| CCConnman::ReconnectionInfo | Struct for entries in m_reconnections |
| ▶Crecursive_mutex | |
| CAnnotatedMixin< std::recursive_mutex > | |
| CCChainParams::RegTestOptions | RegTestOptions holds configurations for creating a regtest CChainParams |
| CRemovedMempoolTransactionInfo | |
| CReorgTxns | Reorg where 1 block is disconnected and 2 blocks are connected |
| Ci2p::sam::Session::Reply | A reply from the SAM proxy |
| Cwallet::ReserveDestination | A wrapper to reserve an address from a wallet |
| Cmp::init_fields::Result | |
| Cankerl::nanobench::Result | |
| Cmp::echo_fields::Result | |
| Cutil::Result< M > | |
| Cmp::ipc_test_fields::Result | |
| Cutil::Result< void > | |
| Cprevector< N, T, Size, Diff >::reverse_iterator | |
| CUniqueLock< MutexType >::reverse_lock | An RAII-style reverse lock |
| Creverse_range< T > | Template used for reverse iteration in range-based for loops |
| Cankerl::nanobench::Rng | An extremely fast random generator |
| CRPCArg | |
| CRPCArgOptions | |
| CRPCCommandExecution | |
| CRPCCommandExecutionInfo | |
| CRPCExamples | |
| CRPCHelpMan | |
| CRPCResult | |
| CRPCResults | |
| CRPCServerInfo | |
| ▶CRPCTimerBase | Opaque base class for timers returned by NewTimerFunc |
| CHTTPRPCTimer | Simple one-shot callback timer to be used by the RPC mechanism to e.g |
| CQtRPCTimerBase | Class for handling RPC timers (used for e.g |
| ▶CRPCTimerInterface | RPC timer "driver" |
| CHTTPRPCTimerInterface | |
| CQtRPCTimerInterface | |
| ▶Cruntime_error | |
| CCConnectionFailed | |
| Cdbwrapper_error | |
| Cipc::Exception | Exception class thrown when a call to remote method fails due to an IPC error, like a socket getting disconnected |
| CNonFatalCheckError | |
| Cscriptnum10_error | |
| Cscriptnum_error | |
| Ctinyformat::format_error | |
| Cuint_error | |
| CUniValue::type_error | |
| Cwallet::SafeDbt | RAII class that automatically cleanses its data on destruction |
| CSaltedOutpointHasher | |
| CSaltedSipHasher | |
| CSaltedTxidHasher | |
| Cminiscript::internal::SatInfo | A data structure to help the calculation of stack size limits |
| CSatisfier< Pk > | Context for solving a Miniscript |
| ▶CSatisfier< CPubKey > | |
| CWshSatisfier | Miniscript satisfier specific to P2WSH context |
| ▶CSatisfier< XOnlyPubKey > | |
| CTapSatisfier | Miniscript satisfier specific to Tapscript context |
| Cwallet::CWallet::ScanResult | |
| CScriptCompression | Compact serializer for scripts |
| CScriptErrorDesc | |
| CScriptExecutionData | |
| ▶Cwallet::ScriptPubKeyMan | |
| ▶Cwallet::DescriptorScriptPubKeyMan | |
| Cwallet::ExternalSignerScriptPubKeyMan | |
| Cwallet::LegacyScriptPubKeyMan | |
| Csecp256k1_assumption_checker | |
| Csecp256k1_callback | |
| Csecp256k1_context_struct | |
| Csecp256k1_ecdsa_recoverable_signature | Opaque data structured that holds a parsed ECDSA signature, supporting pubkey recovery |
| Csecp256k1_ecdsa_signature | Opaque data structured that holds a parsed ECDSA signature |
| Csecp256k1_ecmult_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_keypair | Opaque data structure that holds a keypair consisting of a secret and a public key |
| Csecp256k1_modinv32_modinfo | |
| Csecp256k1_modinv32_signed30 | |
| Csecp256k1_modinv32_trans2x2 | |
| Csecp256k1_modinv64_modinfo | |
| Csecp256k1_modinv64_signed62 | |
| Csecp256k1_modinv64_trans2x2 | |
| Csecp256k1_pippenger_point_state | |
| Csecp256k1_pippenger_state | |
| Csecp256k1_pubkey | Opaque data structure that holds a parsed and valid public key |
| Csecp256k1_rfc6979_hmac_sha256 | |
| Csecp256k1_scalar | A scalar modulo the group order of the secp256k1 curve |
| Csecp256k1_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 |
| CSecp256k1Init | |
| CSection | A pair of strings that can be aligned (through padding) with other Sections later on |
| CSectionInfo | |
| CSections | Keeps track of RPCArgs by transforming them into sections for the purpose of serializing everything to a single string |
| Csecure_allocator< T > | |
| CSecureUniqueDeleter< T > | |
| Cwallet::SelectionFilter | |
| Cwallet::SelectionResult | |
| CSendCoinsRecipient | |
| CWalletModel::SendCoinsReturn | |
| Cipc::capnp::Serializable< T > | Use SFINAE to define Serializeable<T> trait which is true if type T has a Serialize(stream) method, false otherwise |
| ▶CCNetAddr::SerParams | |
| CCAddress::SerParams | |
| ▶CServer | |
| Cgen::FooInterface::Server | |
| Cipc::capnp::messages::Echo::Server | |
| Cipc::capnp::messages::Init::Server | |
| Ci2p::sam::Session | I2P SAM session |
| Ccommon::Settings | Stored settings |
| Ccommon::SettingsSpan | Accessor for list of settings that skips negated values when iterated over |
| CSHA3_256 | |
| CShortestVectorFirstComparator | |
| Cutil::SignalInterrupt | Helper class that manages an interrupt flag, and allows a thread or signal to interrupt another thread |
| CSignatureCacheHasher | We're hashing a nonce into the entries themselves, so we don't need extra blinding in the set hash computation |
| CSignatureData | |
| Cwallet::feebumper::SignatureWeights | |
| CCChainParams::SigNetOptions | SigNetOptions holds configurations for creating a signet CChainParams |
| CSignetTxs | Generate the signet tx corresponding to the given block |
| ▶CSigningProvider | An interface to be implemented by keystores that support signing |
| ▶CFillableSigningProvider | Fillable signing provider that keeps keys in an address->secret map |
| Cwallet::LegacyScriptPubKeyMan | |
| CFlatSigningProvider | |
| CHidingSigningProvider | |
| CMultiSigningProvider | A signing provider to be used to interface with multiple signing providers at once |
| Cwallet::LegacySigningProvider | Wraps a LegacyScriptPubKeyMan so that it can be returned in a new unique_ptr |
| CSingleEntryCacheTest | |
| CSingleThreadedSchedulerClient | Class used by CScheduler clients which may schedule multiple jobs which are required to be run serially |
| CSizeComputer | |
| ▶CSketch | Abstract class for internal representation of a minisketch object |
| CSketchImpl< F > | |
| Cnode::SnapshotMetadata | Metadata describing a serialized version of a UTXO set from which an assumeutxo Chainstate can be constructed |
| ▶CSock | RAII helper class that manages a socket and closes it automatically when it goes out of scope |
| CFuzzedSock | |
| CStaticContentsSock | A mocked Sock alternative that returns a statically contained data upon read and succeeds and ignores all writes |
| CSpan< C > | A Span is an object that can refer to a contiguous sequence of objects |
| CSpan< const std::byte > | |
| CSpan< const unsigned char > | |
| CSpanReader | Minimal stream for reading from an existing byte array by Span |
| Cwallet::SQliteExecHandler | Class responsible for executing SQL statements in SQLite databases |
| Cminiscript::internal::StackSize | |
| CLockedPool::Stats | Memory statistics |
| CArena::Stats | Memory statistics |
| Cmemusage::stl_shared_counter | |
| Cmemusage::stl_tree_node< X > | |
| CStringContentsSerializer | |
| Ctinyformat::detail::is_convertible< T1, T2 >::succeed | |
| ▶Csystem_clock | |
| CNodeClock | Mockable clock in the context of tests, otherwise the system clock |
| Cwallet::tallyitem | |
| CTaprootBuilder | Utility class to construct Taproot outputs from internal key and script tree |
| CTaprootSpendData | |
| ▶CTestCase | |
| Cpyminisketch.TestGF2Ops | |
| Cpyminisketch.TestMinisketch | |
| Cpyminisketch.TestPolyFindRoots | |
| Cwallet::TestCrypter | |
| CTestHeaderAndShortIDs | |
| CTestMemPoolEntryHelper | |
| Cmp::init_fields::ThreadMap | |
| CBCLog::Timer< TimeType > | RAII-style object that outputs timing information to logs |
| 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 |
| CDummyTorControlConnection | |
| 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 |
| Ctransaction_identifier< has_witness > | Transaction_identifier represents the two canonical transaction identifier types (txid, wtxid) |
| Ctransaction_identifier< false > | |
| CTransactionInfo | |
| CTransactionNotification | |
| CTransactionRecord | UI model for a transaction |
| CTransactionSerParams | |
| CTransactionStatus | UI model for transaction status |
| CTransactionTablePriv | |
| CRPCConsole::TranslatedStrings | |
| ▶CTransport | The Transport converts one connection's sent messages to wire bytes, and received bytes back |
| CV1Transport | |
| CV2Transport | |
| ▶Ctrue_type | |
| CSpan< C >::is_Span_int< Span< T > > | |
| CTxConfirmStats | We will instantiate an instance of this class to track transactions that were included in a block |
| CTxInUndoFormatter | Formatter for undo information for a CTxIn |
| CTxLessThan | |
| CTxMempoolInfo | Information about a mempool transaction |
| ▶CTxOrphanage | A class to track orphan transactions (failed on TX_MISSING_INPUTS) Since we cannot distinguish orphans from bad transactions with non-existent inputs, we heavily limit the number of orphans we keep and the duration we keep them for |
| CTxOrphanageTest | |
| CTxOutCompression | Wrapper for CTxOut that provides a more compact serialization |
| CTxReconciliationTracker | Transaction reconciliation is a way for nodes to efficiently announce transactions |
| CTxRequestTracker | Data structure to keep track of, and schedule, transaction downloads from peers |
| Cwallet::TxSize | |
| Cwallet::TxStateConfirmed | State of transaction confirmed in a block |
| Cwallet::TxStateConflicted | State of rejected transaction that conflicts with a confirmed block |
| Cwallet::TxStateInactive | State of transaction not confirmed or conflicting with a known block and not in the mempool |
| Cwallet::TxStateInMempool | State of transaction added to mempool |
| Cwallet::TxStateUnrecognized | State of transaction loaded in an unrecognized state with unexpected hash or index values |
| CCBlockPolicyEstimator::TxStatsInfo | |
| Cminiscript::Type | This type encapsulates the miniscript type system properties |
| ▶CUi_AddressBookPage | |
| CUi::AddressBookPage | |
| ▶CUi_AskPassphraseDialog | |
| CUi::AskPassphraseDialog | |
| ▶CUi_CoinControlDialog | |
| CUi::CoinControlDialog | |
| ▶CUi_CreateWalletDialog | |
| CUi::CreateWalletDialog | |
| ▶CUi_EditAddressDialog | |
| CUi::EditAddressDialog | |
| ▶CUi_HelpMessageDialog | |
| CUi::HelpMessageDialog | |
| ▶CUi_Intro | |
| CUi::Intro | |
| ▶CUi_ModalOverlay | |
| CUi::ModalOverlay | |
| ▶CUi_OpenURIDialog | |
| CUi::OpenURIDialog | |
| ▶CUi_OptionsDialog | |
| CUi::OptionsDialog | |
| ▶CUi_OverviewPage | |
| CUi::OverviewPage | |
| ▶CUi_PSBTOperationsDialog | |
| CUi::PSBTOperationsDialog | |
| ▶CUi_ReceiveCoinsDialog | |
| CUi::ReceiveCoinsDialog | |
| ▶CUi_ReceiveRequestDialog | |
| CUi::ReceiveRequestDialog | |
| ▶CUi_RPCConsole | |
| CUi::RPCConsole | |
| ▶CUi_SendCoinsDialog | |
| CUi::SendCoinsDialog | |
| ▶CUi_SendCoinsEntry | |
| CUi::SendCoinsEntry | |
| ▶CUi_SignVerifyMessageDialog | |
| CUi::SignVerifyMessageDialog | |
| ▶CUi_TransactionDescDialog | |
| CUi::TransactionDescDialog | |
| CUISignals | |
| ▶Cunique_lock | |
| CUniqueLock< MutexType > | Wrapper around std::unique_lock style lock for MutexType |
| CUniqueCheck | |
| CUniValue | |
| CUniValueType | Wrapper for UniValue::VType, which includes typeAny: Used to denote don't care type |
| CWalletModel::UnlockContext | |
| Cipc::capnp::Unserializable< T > | Use SFINAE to define Unserializeable<T> trait which is true if type T has an Unserialize(stream) method, false otherwise |
| Cnode::update_for_parent_inclusion | |
| CUTXO | |
| Ckernel::ValidationCacheSizes | |
| CValidationInterfaceTest | |
| CValidationState< Result > | Template for capturing information about block/transaction validation |
| ▶CValidationState< BlockValidationResult > | |
| CBlockValidationState | |
| ▶CValidationState< PackageValidationResult > | |
| CPackageValidationState | |
| ▶CValidationState< TxValidationResult > | |
| CTxValidationState | |
| CVarIntFormatter< Mode > | Serialization wrapper class for integers in VarInt format |
| CVBDeploymentInfo | |
| CVectorFormatter< Formatter > | Formatter to serialize/deserialize vector elements using another formatter |
| CVectorWriter | |
| CVersionBitsCache | BIP 9 allows multiple softforks to be deployed in parallel |
| CCChainParams::VersionBitsParameters | VersionBitsParameters holds activation parameters |
| CVersionBitsTester | |
| Cinterfaces::Wallet | Interface for accessing a wallet |
| Cinterfaces::WalletAddress | Information about one wallet address |
| Cinterfaces::WalletBalances | Collection of wallet balances |
| Cwallet::WalletBatch | Access to the wallet database |
| Cwallet::WalletContext | WalletContext struct containing references to state shared between CWallet instances, like the reference to the chain interface, and the list of opened wallets |
| ▶Cwallet::WalletDatabase | An instance of this class represents one database |
| Cwallet::BerkeleyDatabase | An instance of this class represents one database |
| Cwallet::DummyDatabase | A dummy WalletDatabase that does nothing and never fails |
| Cwallet::MockableDatabase | A WalletDatabase whose contents and return values can be modified as needed for testing |
| Cwallet::SQLiteDatabase | An instance of this class represents one SQLite3 database |
| Cwallet::WalletDatabaseFileId | |
| Cwallet::WalletDescriptor | Descriptor with some wallet metadata |
| Cwallet::WalletDestination | |
| ▶CWalletInitInterface | |
| CDummyWalletInit | |
| Cwallet::WalletInit | |
| Cinterfaces::WalletMigrationResult | Migrated wallet info |
| CWalletModelTransaction | Data model for a walletmodel transaction |
| Cwallet::WalletRescanReserver | RAII object to check and reserve a wallet rescan |
| ▶Cwallet::WalletStorage | |
| Cwallet::CWallet | A CWallet maintains a set of transactions and balances, and provides the ability to create new transactions |
| Cinterfaces::WalletTx | |
| Cwallet::WalletTxOrderComparator | |
| Cinterfaces::WalletTxOut | Wallet transaction output |
| Cinterfaces::WalletTxStatus | Updated transaction status |
| Cminiscript::internal::WitnessSize | |
| CWitnessUnknown | CTxDestination subtype to encode any future Witness version |
| CWorkQueue< WorkItem > | Simple work queue for distributing work over multiple threads |
| CWrapper< Formatter, T > | Simple wrapper class to serialize objects using a formatter; used by Using() |
| CCDBBatch::WriteBatchImpl | |
| Cwycheproof_ecdsa_testvector | |
| ▶CX | |
| Cmemusage::unordered_node< X > | |
| ▶CXOnlyPubKey | |
| CWitnessV1Taproot | |
| CXoRoShiRo128PlusPlus | Xoroshiro128++ PRNG |
| Czero_after_free_allocator< T > | |
| ▶CPARENT | |
| ▶CAnnotatedMixin< PARENT > | Template mixin that adds -Wthread-safety locking annotations and lock order checking to a subset of the mutex API |
| CGlobalMutex | Different type to mark Mutex at global scope |
| ▶CQtActivity | |
| Corg.bitcoincore.qt.BitcoinQtActivity | |
| ▶CTs | |
| Cutil::Overloaded< Ts > | Overloaded helper for std::visit |
1.8.14