READ THE CODE

Inside Bitcoin

The code behind the network, with room to understand it.

Stable release v32.1bitcoin/bitcoin · f0de87f04062 ↗3,020 source files · 47.5 MB stored on the server440 file guides

Release published 2026-10-28 · Snapshot fetched 2026-11-01. Latest stable release at fetch time; development branches and Git history are excluded. Only the selected code window and visible folders load here.

14,445 bytes · SHA-256 663bfed8eaebbe80… · View upstream ↗

1// Copyright (c) The Bitcoin Core developers
2// Distributed under the MIT software license, see the accompanying
3// file COPYING or http://www.opensource.org/licenses/mit-license.php.
4
5#include <bench/bench.h>
6#include <consensus/consensus.h>
7#include <consensus/validation.h>
8#include <net.h>
9#include <policy/policy.h>
10#include <primitives/block.h>
11#include <primitives/transaction.h>
12#include <node/txorphanage.h>
13#include <random.h>
14#include <test/util/transaction_utils.h>
15#include <threadsafety.h>
16#include <util/check.h>
17
18#include <algorithm>
19#include <cstddef>
20#include <cstdint>
21#include <memory>
22#include <numeric>
23#include <vector>
24
25static constexpr node::TxOrphanage::Usage TINY_TX_WEIGHT{240};
26static constexpr int64_t APPROX_WEIGHT_PER_INPUT{200};
27
28// Creates a transaction with num_inputs inputs and 1 output, padded to target_weight. Use this function to maximize m_outpoint_to_orphan_it operations.
29// If num_inputs is 0, we maximize the number of inputs.
30static CTransactionRef MakeTransactionBulkedTo(unsigned int num_inputs, int64_t target_weight, FastRandomContext& det_rand)
31{
32    CMutableTransaction tx;
33    assert(target_weight >= 40 + APPROX_WEIGHT_PER_INPUT);
34    if (!num_inputs) num_inputs = (target_weight - 40) / APPROX_WEIGHT_PER_INPUT;
35    for (unsigned int i = 0; i < num_inputs; ++i) {
36        tx.vin.emplace_back(Txid::FromUint256(det_rand.rand256()), 0);
37    }
38    assert(GetTransactionWeight(*MakeTransactionRef(tx)) <= target_weight);
39
40    tx.vout.resize(1);
41
42    // If necessary, pad the transaction to the target weight.
43    if (GetTransactionWeight(*MakeTransactionRef(tx)) < target_weight - 4) {
44        BulkTransaction(tx, target_weight);
45    }
46    return MakeTransactionRef(tx);
47}
48
49// Constructs a transaction using a subset of inputs[start_input : start_input + num_inputs] up to the weight_limit.
50static CTransactionRef MakeTransactionSpendingUpTo(const std::vector<CTxIn>& inputs, unsigned int start_input, unsigned int num_inputs, int64_t weight_limit)
51{
52    CMutableTransaction tx;
53    for (unsigned int i{start_input}; i < start_input + num_inputs; ++i) {
54        if (GetTransactionWeight(*MakeTransactionRef(tx)) + APPROX_WEIGHT_PER_INPUT >= weight_limit) break;
55        tx.vin.emplace_back(inputs.at(i % inputs.size()));
56    }
57    assert(tx.vin.size() > 0);
58    return MakeTransactionRef(tx);
59}
60static void OrphanageSinglePeerEviction(benchmark::Bench& bench)
61{
62    FastRandomContext det_rand{true};
63
64    // Fill up announcements slots with tiny txns, followed by a single large one
65    unsigned int NUM_TINY_TRANSACTIONS((node::DEFAULT_MAX_ORPHANAGE_LATENCY_SCORE));
66
67    // Construct transactions to submit to orphanage: 1-in-1-out tiny transactions
68    std::vector<CTransactionRef> tiny_txs;
69    tiny_txs.reserve(NUM_TINY_TRANSACTIONS);
70    for (unsigned int i{0}; i < NUM_TINY_TRANSACTIONS; ++i) {
71        tiny_txs.emplace_back(MakeTransactionBulkedTo(1, TINY_TX_WEIGHT, det_rand));
72    }
73    auto large_tx = MakeTransactionBulkedTo(1, MAX_STANDARD_TX_WEIGHT, det_rand);
74    assert(GetTransactionWeight(*large_tx) <= MAX_STANDARD_TX_WEIGHT);
75
76    const auto orphanage{node::MakeTxOrphanage(/*max_global_latency_score=*/node::DEFAULT_MAX_ORPHANAGE_LATENCY_SCORE, /*reserved_peer_usage=*/node::DEFAULT_RESERVED_ORPHAN_WEIGHT_PER_PEER)};
77
78    // Populate the orphanage. To maximize the number of evictions, first fill up with tiny transactions, then add a huge one.
79    NodeId peer{0};
80    // Add tiny transactions until we are just about to hit the memory limit, up to the max number of announcements.
81    // We use the same tiny transactions for all peers to minimize their contribution to the usage limit.
82    int64_t total_weight_to_add{0};
83    for (unsigned int txindex{0}; txindex < NUM_TINY_TRANSACTIONS; ++txindex) {
84        const auto& tx{tiny_txs.at(txindex)};
85
86        total_weight_to_add += GetTransactionWeight(*tx);
87        if (total_weight_to_add > orphanage->MaxGlobalUsage()) break;
88
89        assert(orphanage->AddTx(tx, peer));
90
91        // Sanity check: we should always be exiting at the point of hitting the weight limit.
92        assert(txindex < NUM_TINY_TRANSACTIONS - 1);
93    }
94
95    // In the real world, we always trim after each new tx.
96    // If we need to trim already, that means the benchmark is not representative of what LimitOrphans may do in a single call.
97    assert(orphanage->TotalOrphanUsage() <= orphanage->MaxGlobalUsage());
98    assert(orphanage->TotalLatencyScore() <= orphanage->MaxGlobalLatencyScore());
99    assert(orphanage->TotalOrphanUsage() + TINY_TX_WEIGHT > orphanage->MaxGlobalUsage());
100
101    bench.epochs(1).epochIterations(1).run([&]() NO_THREAD_SAFETY_ANALYSIS {
102        // Lastly, add the large transaction.
103        const auto num_announcements_before_trim{orphanage->CountAnnouncements()};
104        assert(orphanage->AddTx(large_tx, peer));
105
106        // If there are multiple peers, note that they all have the same DoS score. We will evict only 1 item at a time for each new DoSiest peer.
107        const auto num_announcements_after_trim{orphanage->CountAnnouncements()};
108        const auto num_evicted{num_announcements_before_trim - num_announcements_after_trim};
109
110        // The number of evictions is the same regardless of the number of peers. In both cases, we can exceed the
111        // usage limit using 1 maximally-sized transaction.
112        assert(num_evicted == MAX_STANDARD_TX_WEIGHT / TINY_TX_WEIGHT);
113    });
114}
115static void OrphanageMultiPeerEviction(benchmark::Bench& bench)
116{
117    // Best number is just below sqrt(DEFAULT_MAX_ORPHANAGE_LATENCY_SCORE)
118    static constexpr unsigned int NUM_PEERS{39};
119    // All peers will have the same transactions. We want to be just under the weight limit, so divide the max usage limit by the number of unique transactions.
120    static constexpr node::TxOrphanage::Count NUM_UNIQUE_TXNS{node::DEFAULT_MAX_ORPHANAGE_LATENCY_SCORE / NUM_PEERS};
121    static constexpr node::TxOrphanage::Usage TOTAL_USAGE_LIMIT{node::DEFAULT_RESERVED_ORPHAN_WEIGHT_PER_PEER * NUM_PEERS};
122    // Subtract 4 because BulkTransaction rounds up and we must avoid going over the weight limit early.
123    static constexpr node::TxOrphanage::Usage LARGE_TX_WEIGHT{TOTAL_USAGE_LIMIT / NUM_UNIQUE_TXNS - 4};
124    static_assert(LARGE_TX_WEIGHT >= TINY_TX_WEIGHT * 2, "Tx is too small, increase NUM_PEERS");
125    // The orphanage does not permit any transactions larger than 400'000, so this test will not work if the large tx is much larger.
126    static_assert(LARGE_TX_WEIGHT <= MAX_STANDARD_TX_WEIGHT, "Tx is too large, decrease NUM_PEERS");
127
128    FastRandomContext det_rand{true};
129    // Construct large transactions
130    std::vector<CTransactionRef> shared_txs;
131    shared_txs.reserve(NUM_UNIQUE_TXNS);
132    for (unsigned int i{0}; i < NUM_UNIQUE_TXNS; ++i) {
133        shared_txs.emplace_back(MakeTransactionBulkedTo(9, LARGE_TX_WEIGHT, det_rand));
134    }
135    std::vector<size_t> indexes;
136    indexes.resize(NUM_UNIQUE_TXNS);
137    std::iota(indexes.begin(), indexes.end(), 0);
138
139    const auto orphanage{node::MakeTxOrphanage(/*max_global_latency_score=*/node::DEFAULT_MAX_ORPHANAGE_LATENCY_SCORE, /*reserved_peer_usage=*/node::DEFAULT_RESERVED_ORPHAN_WEIGHT_PER_PEER)};
140    // Every peer sends the same transactions, all from shared_txs.
141    // Each peer has 1 or 2 assigned transactions, which they must place as the last and second-to-last positions.
142    // The assignments ensure that every transaction is in some peer's last 2 transactions, and is thus remains in the orphanage until the end of LimitOrphans.
143    static_assert(NUM_UNIQUE_TXNS <= NUM_PEERS * 2);
144
145    // We need each peer to send some transactions so that the global limit (which is a function of the number of peers providing at least 1 announcement) rises.
146    for (unsigned int i{0}; i < NUM_UNIQUE_TXNS; ++i) {
147        for (NodeId peer{0}; peer < NUM_PEERS; ++peer) {
148            const CTransactionRef& reserved_last_tx{shared_txs.at(peer)};
149            CTransactionRef reserved_second_to_last_tx{peer < NUM_UNIQUE_TXNS - NUM_PEERS ? shared_txs.at(peer + NUM_PEERS) : nullptr};
150
151            const auto& tx{shared_txs.at(indexes.at(i))};
152            if (tx == reserved_last_tx) {
153                // Skip
154            } else if (reserved_second_to_last_tx && tx == reserved_second_to_last_tx) {
155                // Skip
156            } else {
157                orphanage->AddTx(tx, peer);
158            }
159        }
160    }
161
162    // Now add the final reserved transactions.
163    for (NodeId peer{0}; peer < NUM_PEERS; ++peer) {
164        const CTransactionRef& reserved_last_tx{shared_txs.at(peer)};
165        CTransactionRef reserved_second_to_last_tx{peer < NUM_UNIQUE_TXNS - NUM_PEERS ? shared_txs.at(peer + NUM_PEERS) : nullptr};
166        // Add the final reserved transactions.
167        if (reserved_second_to_last_tx) {
168            orphanage->AddTx(reserved_second_to_last_tx, peer);
169        }
170        orphanage->AddTx(reserved_last_tx, peer);
171    }
172
173    assert(orphanage->CountAnnouncements() == NUM_PEERS * NUM_UNIQUE_TXNS);
174    const auto total_usage{orphanage->TotalOrphanUsage()};
175    const auto max_usage{orphanage->MaxGlobalUsage()};
176    assert(max_usage - total_usage <= LARGE_TX_WEIGHT);
177    assert(orphanage->TotalLatencyScore() <= orphanage->MaxGlobalLatencyScore());
178
179    auto last_tx = MakeTransactionBulkedTo(0, max_usage - total_usage + 1, det_rand);
180
181    bench.epochs(1).epochIterations(1).run([&]() NO_THREAD_SAFETY_ANALYSIS {
182        const auto num_announcements_before_trim{orphanage->CountAnnouncements()};
183        // There is a small gap between the total usage and the max usage. Add a transaction to fill it.
184        assert(orphanage->AddTx(last_tx, 0));
185
186        // If there are multiple peers, note that they all have the same DoS score. We will evict only 1 item at a time for each new DoSiest peer.
187        const auto num_evicted{num_announcements_before_trim - orphanage->CountAnnouncements() + 1};
188        // The trimming happens as a round robin. In the first NUM_UNIQUE_TXNS - 2 rounds for each peer, only duplicates are evicted.
189        // Once each peer has 2 transactions left, it's possible to select a peer whose oldest transaction is unique.
190        assert(num_evicted >= (NUM_UNIQUE_TXNS - 2) * NUM_PEERS);
191    });
192}
193
194static void OrphanageEraseAll(benchmark::Bench& bench, bool block_or_disconnect)
195{
196    FastRandomContext det_rand{true};
197    const auto orphanage{node::MakeTxOrphanage(/*max_global_latency_score=*/node::DEFAULT_MAX_ORPHANAGE_LATENCY_SCORE, /*reserved_peer_usage=*/node::DEFAULT_RESERVED_ORPHAN_WEIGHT_PER_PEER)};
198    // This is an unrealistically large number of inputs for a block, as there is almost no room given to witness data,
199    // outputs, and overhead for individual transactions. The entire block is 1 transaction with 20,000 inputs.
200    constexpr unsigned int NUM_BLOCK_INPUTS{MAX_BLOCK_WEIGHT / APPROX_WEIGHT_PER_INPUT};
201    const auto block_tx{MakeTransactionBulkedTo(NUM_BLOCK_INPUTS, MAX_BLOCK_WEIGHT - 4000, det_rand)};
202    CBlock block;
203    block.vtx.push_back(block_tx);
204
205    // Transactions with 9 inputs maximize the computation / LatencyScore ratio.
206    constexpr unsigned int INPUTS_PER_TX{9};
207    constexpr unsigned int NUM_PEERS{125};
208    constexpr unsigned int NUM_TXNS_PER_PEER = node::DEFAULT_MAX_ORPHANAGE_LATENCY_SCORE / NUM_PEERS;
209
210    // Divide the block's inputs evenly among the peers.
211    constexpr unsigned int INPUTS_PER_PEER = NUM_BLOCK_INPUTS / NUM_PEERS;
212    static_assert(INPUTS_PER_PEER > 0);
213    // All the block inputs are spent by the orphanage transactions. Each peer is assigned 76 of them.
214    // Each peer has 24 transactions spending 9 inputs each, so jumping by 3 ensures we cover all of the inputs.
215    static_assert(7 * NUM_TXNS_PER_PEER + INPUTS_PER_TX - 1 >= INPUTS_PER_PEER);
216
217    for (NodeId peer{0}; peer < NUM_PEERS; ++peer) {
218        int64_t weight_left_for_peer{node::DEFAULT_RESERVED_ORPHAN_WEIGHT_PER_PEER};
219        for (unsigned int txnum{0}; txnum < node::DEFAULT_MAX_ORPHANAGE_LATENCY_SCORE / NUM_PEERS; ++txnum) {
220            // Transactions must be unique since they use different (though overlapping) inputs.
221            const unsigned int start_input = peer * INPUTS_PER_PEER + txnum * 7;
222
223            // Note that we shouldn't be able to hit the weight limit with these small transactions.
224            const int64_t weight_limit{std::min<int64_t>(weight_left_for_peer, MAX_STANDARD_TX_WEIGHT)};
225            auto ptx = MakeTransactionSpendingUpTo(block_tx->vin, /*start_input=*/start_input, /*num_inputs=*/INPUTS_PER_TX, /*weight_limit=*/weight_limit);
226
227            assert(GetTransactionWeight(*ptx) <= MAX_STANDARD_TX_WEIGHT);
228            assert(!orphanage->HaveTx(ptx->GetWitnessHash()));
229            assert(orphanage->AddTx(ptx, peer));
230
231            weight_left_for_peer -= GetTransactionWeight(*ptx);
232            if (weight_left_for_peer < TINY_TX_WEIGHT * 2) break;
233        }
234    }
235
236    // If these fail, it means this benchmark is not realistic because the orphanage would have been trimmed already.
237    assert(orphanage->TotalLatencyScore() <= orphanage->MaxGlobalLatencyScore());
238    assert(orphanage->TotalOrphanUsage() <= orphanage->MaxGlobalUsage());
239
240    // 3000 announcements (and unique transactions) in the orphanage.
241    // They spend a total of 27,000 inputs (20,000 unique ones)
242    assert(orphanage->CountAnnouncements() == NUM_PEERS * NUM_TXNS_PER_PEER);
243    assert(orphanage->TotalLatencyScore() == orphanage->CountAnnouncements());
244
245    bench.epochs(1).epochIterations(1).run([&]() NO_THREAD_SAFETY_ANALYSIS {
246        if (block_or_disconnect) {
247            // Erase everything through EraseForBlock.
248            // Every tx conflicts with this block.
249            orphanage->EraseForBlock(block);
250            assert(orphanage->CountAnnouncements() == 0);

src/wallet/receive.cpp

src/wallet/coinselection.cpp

src/consensus/validation.h

src/primitives/transaction.cpp

src/script/descriptor.cpp

src/bitcoin-cli.cpp

src/rpc/blockchain.cpp

src/rpc/rawtransaction.cpp

src/init.cpp

src/crypto/sha256.cpp

src/consensus/merkle.h

src/consensus/tx_check.h

src/consensus/tx_verify.h

src/policy/feerate.h

src/policy/feerate.cpp

src/primitives/transaction_identifier.h

src/chainparamsbase.h

src/chainparamsbase.cpp

src/util/moneystr.cpp

src/crypto/ripemd160.h

src/crypto/sha1.h

src/crypto/sha512.h

src/crypto/hmac_sha256.h

src/crypto/hmac_sha512.h

src/crypto/hmac_sha256.cpp

src/crypto/hmac_sha512.cpp

src/crypto/hkdf_sha256_32.h

src/crypto/hkdf_sha256_32.cpp

src/support/cleanse.h

src/support/cleanse.cpp

src/crypto/siphash.cpp

src/crypto/muhash.h

src/crypto/chacha20.h

src/crypto/poly1305.h

src/crypto/chacha20poly1305.h

src/crypto/chacha20poly1305.cpp

src/util/chaintype.cpp

src/util/obfuscation.h

src/util/byte_units.h

src/util/overflow.h

src/blockencodings.cpp

src/net_permissions.cpp

src/policy/packages.cpp

src/policy/rbf.cpp

src/policy/truc_policy.cpp

src/policy/ephemeral_policy.cpp

src/policy/settings.cpp

src/policy/policy.cpp

src/node/transaction.cpp

src/node/coin.cpp

src/rpc/client.cpp

src/rpc/external_signer.cpp

src/rpc/request.cpp

src/rpc/server_util.cpp

src/rpc/fees.cpp

src/rpc/output_script.cpp

src/rpc/rawtransaction_util.cpp

src/rpc/rawtransaction_util.h

src/rpc/register.h

src/rpc/request.h

src/rpc/server_util.h

src/rpc/protocol.h

src/rpc/server.h

src/rpc/signmessage.cpp

src/rpc/txoutproof.cpp

src/rpc/util.cpp

src/rpc/util.h

src/wallet/rpc/addresses.cpp

src/wallet/rpc/backup.cpp

src/wallet/rpc/coins.cpp

src/wallet/rpc/encrypt.cpp

src/wallet/rpc/signmessage.cpp

src/wallet/rpc/util.cpp

src/wallet/rpc/util.h

src/wallet/coincontrol.cpp

src/wallet/coincontrol.h

src/wallet/context.cpp

src/wallet/context.h

src/wallet/crypter.cpp

src/wallet/crypter.h

src/wallet/db.cpp

src/wallet/export.cpp

src/wallet/external_signer_scriptpubkeyman.cpp

src/wallet/rpc/spend.cpp

src/wallet/rpc/transactions.cpp

src/wallet/rpc/wallet.cpp

src/wallet/feebumper.cpp

src/wallet/feebumper.h

src/index/base.h

src/index/base.cpp

src/index/txindex.h

src/index/txindex.cpp

src/index/txindex_key.h

src/index/txospenderindex.h

src/index/txospenderindex.cpp

src/index/blockfilterindex.h

src/index/blockfilterindex.cpp

src/index/coinstatsindex.h

src/index/coinstatsindex.cpp

src/index/db_key.h

src/index/disktxpos.h

src/kernel/chain.cpp

src/kernel/chain.h

src/kernel/checks.cpp

src/kernel/checks.h

src/kernel/context.cpp

src/kernel/context.h

src/kernel/cs_main.cpp

src/kernel/cs_main.h

src/kernel/disconnected_transactions.cpp

src/kernel/disconnected_transactions.h

src/kernel/mempool_removal_reason.cpp

src/kernel/mempool_removal_reason.h

src/kernel/coinstats.cpp

src/kernel/coinstats.h

src/kernel/chainparams.cpp

src/kernel/chainparams.h

src/wallet/sqlite.cpp

src/wallet/sqlite.h

src/wallet/transaction.cpp

src/wallet/transaction.h

src/wallet/dump.cpp

src/wallet/dump.h

src/wallet/init.cpp

src/wallet/walletutil.cpp

src/wallet/walletutil.h

src/wallet/wallettool.cpp

src/wallet/wallettool.h

src/wallet/export.h

src/wallet/migrate.cpp

src/wallet/migrate.h

src/wallet/db.h

src/wallet/walletdb.cpp

src/wallet/interfaces.cpp

src/wallet/scriptpubkeyman.cpp

src/wallet/scriptpubkeyman.h

src/kernel/bitcoinkernel.cpp

src/kernel/bitcoinkernel.h

src/kernel/bitcoinkernel_wrapper.h

src/node/chainstate.cpp

src/node/chainstate.h

src/node/blockstorage.cpp

src/node/blockstorage.h

src/node/mempool_persist.cpp

src/node/mempool_persist.h

src/node/utxo_snapshot.cpp

src/node/utxo_snapshot.h

src/node/kernel_notifications.cpp

src/node/kernel_notifications.h

src/node/blockmanager_args.cpp

src/kernel/blockmanager_opts.h

src/util/expected.cpp

src/policy/settings.h

src/util/types.h

src/kernel/messagestartchars.h

src/kernel/warning.h

src/util/exception.h

src/common/license_info.h

src/node/coins_view_args.h

src/node/database_args.h

src/util/batchpriority.h

src/util/ui_change_type.h

src/node/coins_view_args.cpp

src/node/peerman_args.h

src/util/serfloat.h

src/node/blockmanager_args.h

src/node/database_args.cpp

src/util/overloaded.h

src/interfaces/types.h

src/node/chainstatemanager_args.h

src/node/minisketchwrapper.h

src/util/macros.h

src/util/syserror.h

src/common/run_command.h

src/util/bytevectorhash.cpp

src/node/mempool_persist_args.cpp

src/util/exec.h

src/util/rbf.h

src/crypto/hex_base.h

src/node/mempool_persist_args.h

src/interfaces/echo.h

src/util/any.h

src/util/batchpriority.cpp

src/util/threadnames.h

src/node/coin.h

src/node/mempool_args.h

src/util/asmap.h

src/util/bytevectorhash.h

src/node/context.cpp

src/util/insert.h

src/util/readwritefile.h

src/node/peerman_args.cpp

src/node/interface_ui.cpp

src/interfaces/handler.h

src/node/mining_args.h

src/util/hasher.cpp

src/common/init.h

src/kernel/mempool_limits.h

src/common/system.h

src/crypto/sha3.h

src/util/threadinterrupt.cpp

src/node/protocol_version.h

src/util/exception.cpp

src/common/messages.h

src/node/connection_types.cpp

src/util/bip32.h

src/common/license_info.cpp

src/util/stdmutex.h

src/common/run_command.cpp

src/util/check.cpp

src/util/golombrice.h

src/node/types.h

src/node/timeoffsets.h

src/util/readwritefile.cpp

src/util/fastrange.h

src/util/signalinterrupt.h

src/util/task_runner.h

src/util/syserror.cpp

src/common/interfaces.cpp

src/common/types.h

src/util/threadinterrupt.h

src/kernel/chainstatemanager_opts.h

src/node/psbt.h

src/policy/ephemeral_policy.h

src/util/trace.h

src/common/url.cpp

src/kernel/mempool_options.h

src/util/serfloat.cpp

src/kernel/notifications_interface.h

src/node/timeoffsets.cpp

src/node/warnings.cpp

src/util/hash_type.h

src/crypto/hex_base.cpp

src/node/eviction.h

src/util/tokenbucket.h

src/crypto/aes.h

src/common/pcp.h

src/util/feefrac.cpp

src/node/transaction.h

src/util/threadnames.cpp

src/common/signmessage.h

src/util/exec.cpp

src/util/signalinterrupt.cpp

src/clientversion.cpp

src/common/signmessage.cpp

src/compat/assumptions.h

src/compat/byteswap.h

src/deploymentinfo.cpp

src/deploymentinfo.h

src/deploymentstatus.cpp

src/deploymentstatus.h

src/dummywallet.cpp

src/external_signer.h

src/init/bitcoin-gui.cpp

src/init/bitcoin-node.cpp

src/init/bitcoin-qt.cpp

src/init/bitcoin-wallet.cpp

src/init/bitcoind.cpp

src/init/common.h

src/interfaces/init.h

src/interfaces/ipc.h

src/key_io.h

src/logging/categories.h

src/logging/timer.h

src/mapport.h

src/musig.h

src/net_permissions.h

src/netgroup.h

src/netmessagemaker.h

src/node/chainstatemanager_args.cpp

src/node/connection_types.h

src/node/context.h

src/node/interface_ui.h

src/node/mempool_args.cpp

src/node/mining_args.cpp

src/node/minisketchwrapper.cpp

src/node/txreconciliation.h

src/policy/fees/estimator_args.cpp

src/policy/fees/estimator_args.h

src/policy/fees/estimator_man.cpp

src/policy/fees/estimator_man.h

src/policy/packages.h

src/policy/rbf.h

src/policy/truc_policy.h

src/pow.h

src/primitives/block.cpp

src/randomenv.h

src/rest.h

src/script/keyorigin.h

src/script/parsing.cpp

src/script/parsing.h

src/script/script_error.h

src/script/sigcache.cpp

src/script/sigcache.h

src/script/solver.h

src/script/verify_flags.h

src/semaphore_grant.h

src/signet.h

src/span.h

src/support/allocators/secure.h

src/support/allocators/zeroafterfree.h

src/util/tokenpipe.cpp

src/util/translation.h

src/util/vector.h

src/versionbits.h

src/versionbits_impl.h

src/wallet/external_signer_scriptpubkeyman.h

src/wallet/fees.h

src/wallet/load.h

src/wallet/receive.h

src/wallet/rpc/wallet.h

src/wallet/types.h

src/walletinitinterface.h

src/zmq/zmqabstractnotifier.cpp

Independent explanations by MyBitcoinExplorer. Not affiliated with or endorsed by Bitcoin Core. Guides are educational and do not replace the source or its tests.

Bitcoin Core source © its contributors, distributed under the MIT license. Original notices and bundled third-party licenses are retained in the source tree.