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.

55,667 bytes · SHA-256 0edc24ffb4b6d9f7… · View upstream ↗

1// Copyright (c) 2022-present 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#define BITCOINKERNEL_BUILD
6
7#include <kernel/bitcoinkernel.h>
8
9#include <chain.h>
10#include <coins.h>
11#include <consensus/tx_check.h>
12#include <consensus/validation.h>
13#include <dbwrapper.h>
14#include <kernel/caches.h>
15#include <kernel/chainparams.h>
16#include <kernel/checks.h>
17#include <kernel/context.h>
18#include <kernel/notifications_interface.h>
19#include <kernel/warning.h>
20#include <logging.h>
21#include <node/blockstorage.h>
22#include <node/chainstate.h>
23#include <primitives/block.h>
24#include <primitives/transaction.h>
25#include <script/interpreter.h>
26#include <script/script.h>
27#include <script/verify_flags.h>
28#include <serialize.h>
29#include <streams.h>
30#include <sync.h>
31#include <uint256.h>
32#include <undo.h>
33#include <util/check.h>
34#include <util/fs.h>
35#include <util/result.h>
36#include <util/signalinterrupt.h>
37#include <util/task_runner.h>
38#include <util/time.h>
39#include <util/translation.h>
40#include <validation.h>
41#include <validationinterface.h>
42
43#include <cstddef>
44#include <cstring>
45#include <exception>
46#include <functional>
47#include <limits>
48#include <list>
49#include <memory>
50#include <optional>
51#include <span>
52#include <stdexcept>
53#include <string>
54#include <tuple>
55#include <utility>
56#include <vector>
57
58namespace Consensus {
59struct Params;
60} // namespace Consensus
61
62using kernel::ChainstateRole;
63using util::ImmediateTaskRunner;
64
65// Define G_TRANSLATION_FUN symbol in libbitcoinkernel library so users of the
66// library aren't required to export this symbol
67extern const TranslateFn G_TRANSLATION_FUN{nullptr};
68
69static const kernel::Context btck_context_static{};
70
71namespace {
72
73bool is_valid_flag_combination(script_verify_flags flags)
74{
75    if (flags & SCRIPT_VERIFY_CLEANSTACK && ~flags & (SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS)) return false;
76    if (flags & SCRIPT_VERIFY_WITNESS && ~flags & SCRIPT_VERIFY_P2SH) return false;
77    return true;
78}
79
80class WriterStream
81{
82private:
83    btck_WriteBytes m_writer;
84    void* m_user_data;
85
86public:
87    WriterStream(btck_WriteBytes writer, void* user_data)
88        : m_writer{writer}, m_user_data{user_data} {}
89
90    //
91    // Stream subset
92    //
93    void write(std::span<const std::byte> src)
94    {
95        if (m_writer(src.data(), src.size(), m_user_data) != 0) {
96            throw std::runtime_error("Failed to write serialization data");
97        }
98    }
99
100    template <typename T>
101    WriterStream& operator<<(const T& obj)
102    {
103        ::Serialize(*this, obj);
104        return *this;
105    }
106};
107
108template <typename C, typename CPP>
109struct Handle {
110    static C* ref(CPP* cpp_type)
111    {
112        return reinterpret_cast<C*>(cpp_type);
113    }
114
115    static const C* ref(const CPP* cpp_type)
116    {
117        return reinterpret_cast<const C*>(cpp_type);
118    }
119
120    template <typename... Args>
121    static C* create(Args&&... args)
122    {
123        auto cpp_obj{std::make_unique<CPP>(std::forward<Args>(args)...)};
124        return ref(cpp_obj.release());
125    }
126
127    static C* copy(const C* ptr)
128    {
129        auto cpp_obj{std::make_unique<CPP>(get(ptr))};
130        return ref(cpp_obj.release());
131    }
132
133    static const CPP& get(const C* ptr)
134    {
135        return *reinterpret_cast<const CPP*>(ptr);
136    }
137
138    static CPP& get(C* ptr)
139    {
140        return *reinterpret_cast<CPP*>(ptr);
141    }
142
143    static void operator delete(void* ptr)
144    {
145        delete reinterpret_cast<CPP*>(ptr);
146    }
147};
148
149} // namespace
150
151struct btck_BlockTreeEntry: Handle<btck_BlockTreeEntry, CBlockIndex> {};
152struct btck_Block : Handle<btck_Block, std::shared_ptr<const CBlock>> {};
153struct btck_BlockValidationState : Handle<btck_BlockValidationState, BlockValidationState> {};
154struct btck_TxValidationState : Handle<btck_TxValidationState, TxValidationState> {};
155
156namespace {
157
158BCLog::Level get_bclog_level(btck_LogLevel level)
159{
160    switch (level) {
161    case btck_LogLevel_INFO: {
162        return BCLog::Level::Info;
163    }
164    case btck_LogLevel_DEBUG: {
165        return BCLog::Level::Debug;
166    }
167    case btck_LogLevel_TRACE: {
168        return BCLog::Level::Trace;
169    }
170    }
171    assert(false);
172}
173
174BCLog::LogFlags get_bclog_flag(btck_LogCategory category)
175{
176    switch (category) {
177    case btck_LogCategory_BENCH: {
178        return BCLog::LogFlags::BENCH;
179    }
180    case btck_LogCategory_BLOCKSTORAGE: {
181        return BCLog::LogFlags::BLOCKSTORAGE;
182    }
183    case btck_LogCategory_COINDB: {
184        return BCLog::LogFlags::COINDB;
185    }
186    case btck_LogCategory_LEVELDB: {
187        return BCLog::LogFlags::LEVELDB;
188    }
189    case btck_LogCategory_MEMPOOL: {
190        return BCLog::LogFlags::MEMPOOL;
191    }
192    case btck_LogCategory_PRUNE: {
193        return BCLog::LogFlags::PRUNE;
194    }
195    case btck_LogCategory_RAND: {
196        return BCLog::LogFlags::RAND;
197    }
198    case btck_LogCategory_REINDEX: {
199        return BCLog::LogFlags::REINDEX;
200    }
201    case btck_LogCategory_VALIDATION: {
202        return BCLog::LogFlags::VALIDATION;
203    }
204    case btck_LogCategory_KERNEL: {
205        return BCLog::LogFlags::KERNEL;
206    }
207    case btck_LogCategory_ALL: {
208        return BCLog::LogFlags::ALL;
209    }
210    }
211    assert(false);
212}
213
214btck_SynchronizationState cast_state(SynchronizationState state)
215{
216    switch (state) {
217    case SynchronizationState::INIT_REINDEX:
218        return btck_SynchronizationState_INIT_REINDEX;
219    case SynchronizationState::INIT_DOWNLOAD:
220        return btck_SynchronizationState_INIT_DOWNLOAD;
221    case SynchronizationState::POST_INIT:
222        return btck_SynchronizationState_POST_INIT;
223    } // no default case, so the compiler can warn about missing cases
224    assert(false);
225}
226
227btck_Warning cast_btck_warning(kernel::Warning warning)
228{
229    switch (warning) {
230    case kernel::Warning::UNKNOWN_NEW_RULES_ACTIVATED:
231        return btck_Warning_UNKNOWN_NEW_RULES_ACTIVATED;
232    case kernel::Warning::LARGE_WORK_INVALID_CHAIN:
233        return btck_Warning_LARGE_WORK_INVALID_CHAIN;
234    } // no default case, so the compiler can warn about missing cases
235    assert(false);
236}
237
238struct LoggingConnection {
239    std::unique_ptr<std::list<std::function<void(const std::string&)>>::iterator> m_connection;
240    void* m_user_data;
241    std::function<void(void* user_data)> m_deleter;
242
243    LoggingConnection(btck_LogCallback callback, void* user_data, btck_DestroyCallback user_data_destroy_callback)
244    {
245        LOCK(cs_main);
246
247        auto connection{LogInstance().PushBackCallback([callback, user_data](const std::string& str) { callback(user_data, str.c_str(), str.length()); })};
248
249        // Only start logging if we just added the connection.
250        if (LogInstance().NumConnections() == 1 && !LogInstance().StartLogging()) {

FILE GUIDE · KEY SECTIONS

Bridging the C kernel API to validation internals

This implementation wraps internal C++ objects in opaque C handles and adapts serialization, script checking and chainstate operations. The API surface does not turn decoding into full transaction or block validation.

Line 109 ↗

Bridge owned objects and borrowed references

The internal template creates, copies and accesses C++ values behind opaque handle pointers. Some getters return references into another object instead of allocating a copy. Callers must follow each public lifetime contract rather than destroy every pointer returned by a getter.

Line 662 ↗

Check one input script with the supplied context

The function checks supported flag combinations and requires appropriate spent-output data for Taproot. It calls VerifyScript for the selected input using the amount and transaction context. A true result for one script is not proof that every transaction input exists, all values balance or the transaction is confirmed.

Line 1087 ↗

Load and verify before returning a manager

The implementation constructs the internal manager, loads chainstate, verifies loaded data and activates the best chains. Exceptions and unsuccessful statuses return null with logging. A parsed transaction handle created elsewhere has not passed through these state-rich checks.

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.