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.

172,736 bytes · SHA-256 fb08af4bd58946b9… · View upstream ↗

1// Copyright (c) 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 <rpc/blockchain.h>
7#include <rpc/register.h> // IWYU pragma: associated
8
9#include <arith_uint256.h>
10#include <blockfilter.h>
11#include <chain.h>
12#include <chainparams.h>
13#include <chainparamsbase.h>
14#include <coins.h>
15#include <common/args.h>
16#include <consensus/amount.h>
17#include <consensus/consensus.h>
18#include <consensus/params.h>
19#include <consensus/validation.h>
20#include <core_io.h>
21#include <crypto/hex_base.h>
22#include <dbwrapper.h>
23#include <deploymentinfo.h>
24#include <flatfile.h>
25#include <index/base.h>
26#include <index/blockfilterindex.h>
27#include <index/coinstatsindex.h>
28#include <interfaces/mining.h>
29#include <interfaces/types.h>
30#include <kernel/coinstats.h>
31#include <logging/timer.h>
32#include <net.h>
33#include <net_processing.h>
34#include <node/blockstorage.h>
35#include <node/context.h>
36#include <node/utxo_snapshot.h>
37#include <node/warnings.h>
38#include <policy/feerate.h>
39#include <prevector.h>
40#include <primitives/block.h>
41#include <primitives/transaction.h>
42#include <protocol.h>
43#include <rpc/protocol.h>
44#include <rpc/rawtransaction_util.h>
45#include <rpc/request.h>
46#include <rpc/server.h>
47#include <rpc/server_util.h>
48#include <rpc/util.h>
49#include <script/descriptor.h>
50#include <script/interpreter.h>
51#include <script/script.h>
52#include <script/signingprovider.h>
53#include <serialize.h>
54#include <span.h>
55#include <streams.h>
56#include <sync.h>
57#include <tinyformat.h>
58#include <txdb.h>
59#include <txmempool.h>
60#include <uint256.h>
61#include <undo.h>
62#include <univalue.h>
63#include <util/chaintype.h>
64#include <util/check.h>
65#include <util/expected.h>
66#include <util/fs.h>
67#include <util/log.h>
68#include <util/result.h>
69#include <util/string.h>
70#include <util/syserror.h>
71#include <util/time.h>
72#include <util/translation.h>
73#include <validation.h>
74#include <validationinterface.h>
75#include <versionbits.h>
76
77#include <algorithm>
78#include <array>
79#include <atomic>
80#include <cerrno>
81#include <compare>
82#include <cstddef>
83#include <cstdint>
84#include <cstdio>
85#include <functional>
86#include <ios>
87#include <map>
88#include <memory>
89#include <optional>
90#include <ratio>
91#include <set>
92#include <span>
93#include <stdexcept>
94#include <string>
95#include <string_view>
96#include <tuple>
97#include <vector>
98
99using kernel::CCoinsStats;
100using kernel::CoinStatsHashType;
101
102using interfaces::BlockRef;
103using interfaces::Mining;
104using node::BlockManager;
105using node::NodeContext;
106using node::SnapshotMetadata;
107using util::MakeUnorderedList;
108
109std::tuple<std::unique_ptr<CCoinsViewCursor>, CCoinsStats, const CBlockIndex*>
110PrepareUTXOSnapshot(
111    Chainstate& chainstate,
112    const std::function<void()>& interruption_point = {})
113    EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
114
115UniValue WriteUTXOSnapshot(
116    Chainstate& chainstate,
117    CCoinsViewCursor* pcursor,
118    CCoinsStats* maybe_stats,
119    const CBlockIndex* tip,
120    AutoFile&& afile,
121    const fs::path& path,
122    const fs::path& temppath,
123    const std::function<void()>& interruption_point = {});
124
125UniValue CreateRolledBackUTXOSnapshot(
126    NodeContext& node,
127    Chainstate& chainstate,
128    const CBlockIndex* target,
129    AutoFile&& afile,
130    const fs::path& path,
131    const fs::path& tmppath,
132    bool in_memory);
133
134/* Calculate the difficulty for a given block index.
135 */
136double GetDifficulty(const CBlockIndex& blockindex)
137{
138    int nShift = (blockindex.nBits >> 24) & 0xff;
139    double dDiff =
140        (double)0x0000ffff / (double)(blockindex.nBits & 0x00ffffff);
141
142    while (nShift < 29)
143    {
144        dDiff *= 256.0;
145        nShift++;
146    }
147    while (nShift > 29)
148    {
149        dDiff /= 256.0;
150        nShift--;
151    }
152
153    return dDiff;
154}
155
156static int ComputeNextBlockAndDepth(const CBlockIndex& tip, const CBlockIndex& blockindex, const CBlockIndex*& next)
157{
158    next = tip.GetAncestor(blockindex.nHeight + 1);
159    if (next && next->pprev == &blockindex) {
160        return tip.nHeight - blockindex.nHeight + 1;
161    }
162    next = nullptr;
163    return &blockindex == &tip ? 1 : -1;
164}
165
166static const CBlockIndex* ParseHashOrHeight(const UniValue& param, ChainstateManager& chainman)
167{
168    LOCK(::cs_main);
169    CChain& active_chain = chainman.ActiveChain();
170
171    if (param.isNum()) {
172        const int height{param.getInt<int>()};
173        if (height < 0) {
174            throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Target block height %d is negative", height));
175        }
176        const int current_tip{active_chain.Height()};
177        if (height > current_tip) {
178            throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Target block height %d after current tip %d", height, current_tip));
179        }
180
181        return active_chain[height];
182    } else {
183        const uint256 hash{ParseHashV(param, "hash_or_height")};
184        const CBlockIndex* pindex = chainman.m_blockman.LookupBlockIndex(hash);
185
186        if (!pindex) {
187            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
188        }
189
190        return pindex;
191    }
192}
193
194UniValue blockheaderToJSON(const CBlockIndex& tip, const CBlockIndex& blockindex, const uint256 pow_limit)
195{
196    // Serialize passed information without accessing chain state of the active chain!
197    AssertLockNotHeld(cs_main); // For performance reasons
198
199    UniValue result(UniValue::VOBJ);
200    result.pushKV("hash", blockindex.GetBlockHash().GetHex());
201    const CBlockIndex* pnext;
202    int confirmations = ComputeNextBlockAndDepth(tip, blockindex, pnext);
203    result.pushKV("confirmations", confirmations);
204    result.pushKV("height", blockindex.nHeight);
205    result.pushKV("version", blockindex.nVersion);
206    result.pushKV("versionHex", strprintf("%08x", blockindex.nVersion));
207    result.pushKV("merkleroot", blockindex.hashMerkleRoot.GetHex());
208    result.pushKV("time", blockindex.nTime);
209    result.pushKV("mediantime", blockindex.GetMedianTimePast());
210    result.pushKV("nonce", blockindex.nNonce);
211    result.pushKV("bits", strprintf("%08x", blockindex.nBits));
212    result.pushKV("target", GetTarget(blockindex, pow_limit).GetHex());
213    result.pushKV("difficulty", GetDifficulty(blockindex));
214    result.pushKV("chainwork", blockindex.nChainWork.GetHex());
215    result.pushKV("nTx", blockindex.nTx);
216
217    if (blockindex.pprev)
218        result.pushKV("previousblockhash", blockindex.pprev->GetBlockHash().GetHex());
219    if (pnext)
220        result.pushKV("nextblockhash", pnext->GetBlockHash().GetHex());
221    return result;
222}
223
224/** Serialize coinbase transaction metadata */
225UniValue coinbaseTxToJSON(const CTransaction& coinbase_tx)
226{
227    CHECK_NONFATAL(!coinbase_tx.vin.empty());
228    const CTxIn& vin_0{coinbase_tx.vin[0]};
229    UniValue coinbase_tx_obj(UniValue::VOBJ);
230    coinbase_tx_obj.pushKV("version", coinbase_tx.version);
231    coinbase_tx_obj.pushKV("locktime", coinbase_tx.nLockTime);
232    coinbase_tx_obj.pushKV("sequence", vin_0.nSequence);
233    coinbase_tx_obj.pushKV("coinbase", HexStr(vin_0.scriptSig));
234    const auto& witness_stack{vin_0.scriptWitness.stack};
235    if (!witness_stack.empty()) {
236        CHECK_NONFATAL(witness_stack.size() == 1);
237        coinbase_tx_obj.pushKV("witness", HexStr(witness_stack[0]));
238    }
239    return coinbase_tx_obj;
240}
241
242UniValue blockToJSON(BlockManager& blockman, const CBlock& block, const CBlockIndex& tip, const CBlockIndex& blockindex, TxVerbosity verbosity, const uint256 pow_limit)
243{
244    UniValue result = blockheaderToJSON(tip, blockindex, pow_limit);
245
246    result.pushKV("strippedsize", ::GetSerializeSize(TX_NO_WITNESS(block)));
247    result.pushKV("size", ::GetSerializeSize(TX_WITH_WITNESS(block)));
248    result.pushKV("weight", ::GetBlockWeight(block));
249
250    CHECK_NONFATAL(!block.vtx.empty());

FILE GUIDE · KEY SECTIONS

Blockchain information through RPC

This file registers and implements many blockchain RPC methods. Some are read-only queries while others alter local node state; the method definitions and help text specify their behavior.

Line 194 ↗

Describe a known block header

The helper creates header information using a reference tip and a block index. Confirmations are contextual to the chain view, rather than a permanent number encoded in the header itself.

Line 242 ↗

Select transaction detail level

Block JSON can include different levels of transaction detail. More verbose responses may need block or undo data and cost more resources than a header-only request.

Line 711 ↗

Check retained data

The code distinguishes knowing a block index from having its block or undo data available. A pruned node can know a block exists without retaining all the bytes needed for a particular verbose response.

Line 3667 ↗

Expose named methods

Registration connects method names to their handlers. The registered interface is not safe to expose publicly without access controls merely because some methods are informational.

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.