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 server340 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.

12,637 bytes · SHA-256 f541fe9d67b72ba3… · View upstream ↗

1// Copyright (c) 2009-2010 Satoshi Nakamoto
2// Copyright (c) 2009-present The Bitcoin Core developers
3// Distributed under the MIT software license, see the accompanying
4// file COPYING or http://www.opensource.org/licenses/mit-license.php.
5
6#include <validationinterface.h>
7
8#include <chain.h>
9#include <consensus/validation.h>
10#include <kernel/mempool_entry.h>
11#include <kernel/mempool_removal_reason.h>
12#include <kernel/types.h>
13#include <primitives/block.h>
14#include <primitives/transaction.h>
15#include <util/check.h>
16#include <util/log.h>
17#include <util/task_runner.h>
18
19#include <future>
20#include <memory>
21#include <unordered_map>
22#include <utility>
23
24using kernel::ChainstateRole;
25
26/**
27 * ValidationSignalsImpl manages a list of shared_ptr<CValidationInterface> callbacks.
28 *
29 * A std::unordered_map is used to track what callbacks are currently
30 * registered, and a std::list is used to store the callbacks that are
31 * currently registered as well as any callbacks that are just unregistered
32 * and about to be deleted when they are done executing.
33 */
34class ValidationSignalsImpl
35{
36private:
37    Mutex m_mutex;
38    //! List entries consist of a callback pointer and reference count. The
39    //! count is equal to the number of current executions of that entry, plus 1
40    //! if it's registered. It cannot be 0 because that would imply it is
41    //! unregistered and also not being executed (so shouldn't exist).
42    struct ListEntry { std::shared_ptr<CValidationInterface> callbacks; int count = 1; };
43    std::list<ListEntry> m_list GUARDED_BY(m_mutex);
44    std::unordered_map<CValidationInterface*, std::list<ListEntry>::iterator> m_map GUARDED_BY(m_mutex);
45
46public:
47    std::unique_ptr<util::TaskRunnerInterface> m_task_runner;
48
49    explicit ValidationSignalsImpl(std::unique_ptr<util::TaskRunnerInterface> task_runner)
50        : m_task_runner{std::move(Assert(task_runner))} {}
51
52    void Register(std::shared_ptr<CValidationInterface> callbacks) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
53    {
54        LOCK(m_mutex);
55        auto inserted = m_map.emplace(callbacks.get(), m_list.end());
56        if (inserted.second) inserted.first->second = m_list.emplace(m_list.end());
57        inserted.first->second->callbacks = std::move(callbacks);
58    }
59
60    void Unregister(CValidationInterface* callbacks) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
61    {
62        LOCK(m_mutex);
63        auto it = m_map.find(callbacks);
64        if (it != m_map.end()) {
65            if (!--it->second->count) m_list.erase(it->second);
66            m_map.erase(it);
67        }
68    }
69
70    //! Clear unregisters every previously registered callback, erasing every
71    //! map entry. After this call, the list may still contain callbacks that
72    //! are currently executing, but it will be cleared when they are done
73    //! executing.
74    void Clear() EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
75    {
76        LOCK(m_mutex);
77        for (const auto& entry : m_map) {
78            if (!--entry.second->count) m_list.erase(entry.second);
79        }
80        m_map.clear();
81    }
82
83    template<typename F> void Iterate(F&& f) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
84    {
85        WAIT_LOCK(m_mutex, lock);
86        for (auto it = m_list.begin(); it != m_list.end();) {
87            ++it->count;
88            {
89                REVERSE_LOCK(lock, m_mutex);
90                f(*it->callbacks);
91            }
92            it = --it->count ? std::next(it) : m_list.erase(it);
93        }
94    }
95};
96
97ValidationSignals::ValidationSignals(std::unique_ptr<util::TaskRunnerInterface> task_runner)
98    : m_internals{std::make_unique<ValidationSignalsImpl>(std::move(task_runner))} {}
99
100ValidationSignals::~ValidationSignals() = default;
101
102void ValidationSignals::FlushBackgroundCallbacks()
103{
104    m_internals->m_task_runner->flush();
105}
106
107size_t ValidationSignals::CallbacksPending()
108{
109    return m_internals->m_task_runner->size();
110}
111
112void ValidationSignals::RegisterSharedValidationInterface(std::shared_ptr<CValidationInterface> callbacks)
113{
114    // Each connection captures the shared_ptr to ensure that each callback is
115    // executed before the subscriber is destroyed. For more details see #18338.
116    m_internals->Register(std::move(callbacks));
117}
118
119void ValidationSignals::RegisterValidationInterface(CValidationInterface* callbacks)
120{
121    // Create a shared_ptr with a no-op deleter - CValidationInterface lifecycle
122    // is managed by the caller.
123    RegisterSharedValidationInterface({callbacks, [](CValidationInterface*){}});
124}
125
126void ValidationSignals::UnregisterSharedValidationInterface(std::shared_ptr<CValidationInterface> callbacks)
127{
128    UnregisterValidationInterface(callbacks.get());
129}
130
131void ValidationSignals::UnregisterValidationInterface(CValidationInterface* callbacks)
132{
133    m_internals->Unregister(callbacks);
134}
135
136void ValidationSignals::UnregisterAllValidationInterfaces()
137{
138    m_internals->Clear();
139}
140
141void ValidationSignals::CallFunctionInValidationInterfaceQueue(std::function<void()> func)
142{
143    m_internals->m_task_runner->insert(std::move(func));
144}
145
146void ValidationSignals::SyncWithValidationInterfaceQueue()
147{
148    AssertLockNotHeld(cs_main);
149    // Block until the validation queue drains
150    std::promise<void> promise;
151    CallFunctionInValidationInterfaceQueue([&promise] {
152        promise.set_value();
153    });
154    promise.get_future().wait();
155}
156
157// Use a macro instead of a function for conditional logging to prevent
158// evaluating arguments when logging is not enabled.
159#define ENQUEUE_AND_LOG_EVENT(event, log_msg)                                                                    \
160    do {                                                                                                         \
161        static_assert(std::is_rvalue_reference_v<decltype((event))>,                                             \
162                      "event must be passed as an rvalue");                                                      \
163        static_assert(std::is_rvalue_reference_v<decltype((log_msg))>,                                           \
164                      "log_msg must be passed as an rvalue");                                                    \
165        auto enqueue_log_msg = (log_msg);                                                                        \
166        LOG_EVENT("Enqueuing %s", enqueue_log_msg);                                                              \
167        m_internals->m_task_runner->insert([local_log_msg = std::move(enqueue_log_msg), local_event = (event)] { \
168            LOG_EVENT("%s", local_log_msg);                                                                      \
169            local_event();                                                                                       \
170        });                                                                                                      \
171    } while (0)
172
173#define LOG_MSG(fmt, ...) \
174    (util::log::ShouldDebugLog(BCLog::VALIDATION) ? tfm::format((fmt), __VA_ARGS__) : std::string{})
175
176#define LOG_EVENT(fmt, ...) \
177    LogDebug(BCLog::VALIDATION, fmt, __VA_ARGS__)
178
179void ValidationSignals::UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockIndex *pindexFork, bool fInitialDownload) {
180    // Dependencies exist that require UpdatedBlockTip events to be delivered in the order in which
181    // the chain actually updates. One way to ensure this is for the caller to invoke this signal
182    // in the same critical section where the chain is updated
183
184    auto log_msg = LOG_MSG("%s: new block hash=%s fork block hash=%s (in IBD=%s)", __func__,
185                          pindexNew->GetBlockHash().ToString(),
186                          pindexFork ? pindexFork->GetBlockHash().ToString() : "null",
187                          fInitialDownload);
188    auto event = [pindexNew, pindexFork, fInitialDownload, this] {
189        m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.UpdatedBlockTip(pindexNew, pindexFork, fInitialDownload); });
190    };
191    ENQUEUE_AND_LOG_EVENT(std::move(event), std::move(log_msg));
192}
193
194void ValidationSignals::ActiveTipChange(const CBlockIndex& new_tip, bool is_ibd)
195{
196    LOG_EVENT("%s: new block hash=%s block height=%d", __func__, new_tip.GetBlockHash().ToString(), new_tip.nHeight);
197    m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.ActiveTipChange(new_tip, is_ibd); });
198}
199
200void ValidationSignals::TransactionAddedToMempool(const NewMempoolTransactionInfo& tx, uint64_t mempool_sequence)
201{
202    auto log_msg = LOG_MSG("%s: txid=%s wtxid=%s", __func__,
203                          tx.info.m_tx->GetHash().ToString(),
204                          tx.info.m_tx->GetWitnessHash().ToString());
205    auto event = [tx, mempool_sequence, this] {
206        m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.TransactionAddedToMempool(tx, mempool_sequence); });
207    };
208    ENQUEUE_AND_LOG_EVENT(std::move(event), std::move(log_msg));
209}
210
211void ValidationSignals::TransactionRemovedFromMempool(const CTransactionRef& tx, MemPoolRemovalReason reason, uint64_t mempool_sequence) {
212    auto log_msg = LOG_MSG("%s: txid=%s wtxid=%s reason=%s", __func__,
213                          tx->GetHash().ToString(),
214                          tx->GetWitnessHash().ToString(),
215                          RemovalReasonToString(reason));
216    auto event = [tx, reason, mempool_sequence, this] {
217        m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.TransactionRemovedFromMempool(tx, reason, mempool_sequence); });
218    };
219    ENQUEUE_AND_LOG_EVENT(std::move(event), std::move(log_msg));
220}
221
222void ValidationSignals::BlockConnected(const ChainstateRole& role, std::shared_ptr<const CBlock> pblock, const CBlockIndex* pindex)
223{
224    auto log_msg = LOG_MSG("%s: block hash=%s block height=%d", __func__,
225                          pblock->GetHash().ToString(),
226                          pindex->nHeight);
227    auto event = [role, pblock = std::move(pblock), pindex, this] {
228        m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.BlockConnected(role, pblock, pindex); });
229    };
230    ENQUEUE_AND_LOG_EVENT(std::move(event), std::move(log_msg));
231}
232
233void ValidationSignals::MempoolTransactionsRemovedForBlock(std::shared_ptr<const CBlock> block, std::vector<RemovedMempoolTransactionInfo> txs_removed_for_block, unsigned int block_height)
234{
235    Assume(block);
236    auto log_msg = LOG_MSG("%s: block hash=%s block height=%s txs removed=%s block txs=%s", __func__,
237                           block->GetHash().ToString(),
238                           block_height,
239                           txs_removed_for_block.size(),
240                           block->vtx.size());
241    auto event = [block = std::move(block), txs_removed_for_block = std::move(txs_removed_for_block), block_height, this] {
242        m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.MempoolTransactionsRemovedForBlock(block, txs_removed_for_block, block_height); });
243    };
244    ENQUEUE_AND_LOG_EVENT(std::move(event), std::move(log_msg));
245}
246
247void ValidationSignals::BlockDisconnected(std::shared_ptr<const CBlock> pblock, const CBlockIndex* pindex)
248{
249    auto log_msg = LOG_MSG("%s: block hash=%s block height=%d", __func__,
250                          pblock->GetHash().ToString(),

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

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.