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,671 bytes · SHA-256 027aa04bcb714056… · View upstream ↗

1// Copyright (c) 2014-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#include <key_io.h>
6
7#include <base58.h>
8#include <bech32.h>
9#include <script/interpreter.h>
10#include <script/solver.h>
11#include <tinyformat.h>
12#include <util/overflow.h>
13#include <util/strencodings.h>
14
15#include <algorithm>
16#include <cassert>
17#include <cstring>
18
19/// Maximum witness length for Bech32 addresses.
20static constexpr std::size_t BECH32_WITNESS_PROG_MAX_LEN = 40;
21
22namespace {
23class DestinationEncoder
24{
25private:
26    const CChainParams& m_params;
27
28public:
29    explicit DestinationEncoder(const CChainParams& params) : m_params(params) {}
30
31    std::string operator()(const PKHash& id) const
32    {
33        std::vector<unsigned char> data = m_params.Base58Prefix(CChainParams::PUBKEY_ADDRESS);
34        data.insert(data.end(), id.begin(), id.end());
35        return EncodeBase58Check(data);
36    }
37
38    std::string operator()(const ScriptHash& id) const
39    {
40        std::vector<unsigned char> data = m_params.Base58Prefix(CChainParams::SCRIPT_ADDRESS);
41        data.insert(data.end(), id.begin(), id.end());
42        return EncodeBase58Check(data);
43    }
44
45    std::string operator()(const WitnessV0KeyHash& id) const
46    {
47        std::vector<unsigned char> data = {0};
48        data.reserve(33);
49        ConvertBits<8, 5, true>([&](unsigned char c) { data.push_back(c); }, id.begin(), id.end());
50        return bech32::Encode(bech32::Encoding::BECH32, m_params.Bech32HRP(), data);
51    }
52
53    std::string operator()(const WitnessV0ScriptHash& id) const
54    {
55        std::vector<unsigned char> data = {0};
56        data.reserve(53);
57        ConvertBits<8, 5, true>([&](unsigned char c) { data.push_back(c); }, id.begin(), id.end());
58        return bech32::Encode(bech32::Encoding::BECH32, m_params.Bech32HRP(), data);
59    }
60
61    std::string operator()(const WitnessV1Taproot& tap) const
62    {
63        std::vector<unsigned char> data = {1};
64        data.reserve(53);
65        ConvertBits<8, 5, true>([&](unsigned char c) { data.push_back(c); }, tap.begin(), tap.end());
66        return bech32::Encode(bech32::Encoding::BECH32M, m_params.Bech32HRP(), data);
67    }
68
69    std::string operator()(const WitnessUnknown& id) const
70    {
71        const std::vector<unsigned char>& program = id.GetWitnessProgram();
72        if (id.GetWitnessVersion() < 1 || id.GetWitnessVersion() > 16 || program.size() < 2 || program.size() > 40) {
73            return {};
74        }
75        std::vector<unsigned char> data = {(unsigned char)id.GetWitnessVersion()};
76        data.reserve(1 + CeilDiv(program.size() * 8, 5u));
77        ConvertBits<8, 5, true>([&](unsigned char c) { data.push_back(c); }, program.begin(), program.end());
78        return bech32::Encode(bech32::Encoding::BECH32M, m_params.Bech32HRP(), data);
79    }
80
81    std::string operator()(const CNoDestination& no) const { return {}; }
82    std::string operator()(const PubKeyDestination& pk) const { return {}; }
83};
84
85CTxDestination DecodeDestination(const std::string& str, const CChainParams& params, std::string& error_str, std::vector<int>* error_locations)
86{
87    std::vector<unsigned char> data;
88    uint160 hash;
89    error_str = "";
90
91    // Note this will be false if it is a valid Bech32 address for a different network
92    bool is_bech32 = (ToLower(str.substr(0, params.Bech32HRP().size())) == params.Bech32HRP());
93
94    if (!is_bech32 && DecodeBase58Check(str, data, 21)) {
95        // base58-encoded Bitcoin addresses.
96        // Public-key-hash-addresses have version 0 (or 111 testnet).
97        // The data vector contains RIPEMD160(SHA256(pubkey)), where pubkey is the serialized public key.
98        const std::vector<unsigned char>& pubkey_prefix = params.Base58Prefix(CChainParams::PUBKEY_ADDRESS);
99        if (data.size() == hash.size() + pubkey_prefix.size() && std::equal(pubkey_prefix.begin(), pubkey_prefix.end(), data.begin())) {
100            std::copy(data.begin() + pubkey_prefix.size(), data.end(), hash.begin());
101            return PKHash(hash);
102        }
103        // Script-hash-addresses have version 5 (or 196 testnet).
104        // The data vector contains RIPEMD160(SHA256(cscript)), where cscript is the serialized redemption script.
105        const std::vector<unsigned char>& script_prefix = params.Base58Prefix(CChainParams::SCRIPT_ADDRESS);
106        if (data.size() == hash.size() + script_prefix.size() && std::equal(script_prefix.begin(), script_prefix.end(), data.begin())) {
107            std::copy(data.begin() + script_prefix.size(), data.end(), hash.begin());
108            return ScriptHash(hash);
109        }
110
111        // If the prefix of data matches either the script or pubkey prefix, the length must have been wrong
112        if ((data.size() >= script_prefix.size() &&
113                std::equal(script_prefix.begin(), script_prefix.end(), data.begin())) ||
114            (data.size() >= pubkey_prefix.size() &&
115                std::equal(pubkey_prefix.begin(), pubkey_prefix.end(), data.begin()))) {
116            error_str = "Invalid length for Base58 address (P2PKH or P2SH)";
117        } else {
118            error_str = "Invalid or unsupported Base58-encoded address.";
119        }
120        return CNoDestination();
121    } else if (!is_bech32) {
122        // Try Base58 decoding without the checksum, using a much larger max length
123        if (!DecodeBase58(str, data, 100)) {
124            error_str = "Invalid or unsupported Segwit (Bech32) or Base58 encoding.";
125        } else {
126            error_str = "Invalid checksum or length of Base58 address (P2PKH or P2SH)";
127        }
128        return CNoDestination();
129    }
130
131    data.clear();
132    const auto dec = bech32::Decode(str);
133    if (dec.encoding == bech32::Encoding::BECH32 || dec.encoding == bech32::Encoding::BECH32M) {
134        if (dec.data.empty()) {
135            error_str = "Empty Bech32 data section";
136            return CNoDestination();
137        }
138        // Bech32 decoding
139        if (dec.hrp != params.Bech32HRP()) {
140            error_str = strprintf("Invalid or unsupported prefix for Segwit (Bech32) address (expected %s, got %s).", params.Bech32HRP(), dec.hrp);
141            return CNoDestination();
142        }
143        int version = dec.data[0]; // The first 5 bit symbol is the witness version (0-16)
144        if (version == 0 && dec.encoding != bech32::Encoding::BECH32) {
145            error_str = "Version 0 witness address must use Bech32 checksum";
146            return CNoDestination();
147        }
148        if (version != 0 && dec.encoding != bech32::Encoding::BECH32M) {
149            error_str = "Version 1+ witness address must use Bech32m checksum";
150            return CNoDestination();
151        }
152        // The rest of the symbols are converted witness program bytes.
153        data.reserve(((dec.data.size() - 1) * 5) / 8);
154        if (ConvertBits<5, 8, false>([&](unsigned char c) { data.push_back(c); }, dec.data.begin() + 1, dec.data.end())) {
155
156            std::string_view byte_str{data.size() == 1 ? "byte" : "bytes"};
157
158            if (version == 0) {
159                {
160                    WitnessV0KeyHash keyid;
161                    if (data.size() == keyid.size()) {
162                        std::copy(data.begin(), data.end(), keyid.begin());
163                        return keyid;
164                    }
165                }
166                {
167                    WitnessV0ScriptHash scriptid;
168                    if (data.size() == scriptid.size()) {
169                        std::copy(data.begin(), data.end(), scriptid.begin());
170                        return scriptid;
171                    }
172                }
173
174                error_str = strprintf("Invalid Bech32 v0 address program size (%d %s), per BIP141", data.size(), byte_str);
175                return CNoDestination();
176            }
177
178            if (version == 1 && data.size() == WITNESS_V1_TAPROOT_SIZE) {
179                static_assert(WITNESS_V1_TAPROOT_SIZE == WitnessV1Taproot::size());
180                WitnessV1Taproot tap;
181                std::copy(data.begin(), data.end(), tap.begin());
182                return tap;
183            }
184
185            if (CScript::IsPayToAnchor(version, data)) {
186                return PayToAnchor();
187            }
188
189            if (version > 16) {
190                error_str = "Invalid Bech32 address witness version";
191                return CNoDestination();
192            }
193
194            if (data.size() < 2 || data.size() > BECH32_WITNESS_PROG_MAX_LEN) {
195                error_str = strprintf("Invalid Bech32 address program size (%d %s)", data.size(), byte_str);
196                return CNoDestination();
197            }
198
199            return WitnessUnknown{version, data};
200        } else {
201            error_str = strprintf("Invalid padding in Bech32 data section");
202            return CNoDestination();
203        }
204    }
205
206    // Perform Bech32 error location
207    auto res = bech32::LocateErrors(str);
208    error_str = res.first;
209    if (error_locations) *error_locations = std::move(res.second);
210    return CNoDestination();
211}
212} // namespace
213
214CKey DecodeSecret(const std::string& str)
215{
216    CKey key;
217    std::vector<unsigned char> data;
218    if (DecodeBase58Check(str, data, 34)) {
219        const std::vector<unsigned char>& privkey_prefix = Params().Base58Prefix(CChainParams::SECRET_KEY);
220        if ((data.size() == 32 + privkey_prefix.size() || (data.size() == 33 + privkey_prefix.size() && data.back() == 1)) &&
221            std::equal(privkey_prefix.begin(), privkey_prefix.end(), data.begin())) {
222            bool compressed = data.size() == 33 + privkey_prefix.size();
223            key.Set(data.begin() + privkey_prefix.size(), data.begin() + privkey_prefix.size() + 32, compressed);
224        }
225    }
226    if (!data.empty()) {
227        memory_cleanse(data.data(), data.size());
228    }
229    return key;
230}
231
232std::string EncodeSecret(const CKey& key)
233{
234    assert(key.IsValid());
235    std::vector<unsigned char> data = Params().Base58Prefix(CChainParams::SECRET_KEY);
236    data.insert(data.end(), UCharCast(key.begin()), UCharCast(key.end()));
237    if (key.IsCompressed()) {
238        data.push_back(1);
239    }
240    std::string ret = EncodeBase58Check(data);
241    memory_cleanse(data.data(), data.size());
242    return ret;
243}
244
245CExtPubKey DecodeExtPubKey(const std::string& str)
246{
247    CExtPubKey key;
248    std::vector<unsigned char> data;
249    if (DecodeBase58Check(str, data, 78)) {
250        const std::vector<unsigned char>& prefix = Params().Base58Prefix(CChainParams::EXT_PUBLIC_KEY);

FILE GUIDE · KEY SECTIONS

Turning addresses into destinations

Address and key encodings are converted here using the selected network parameters. The destination is a spending-condition description, not a balance or owner record.

Line 23 ↗

Encode a destination

The visitor chooses the representation appropriate to a destination type and network. Legacy destinations use network prefixes; witness destinations use the network human-readable prefix and the appropriate Bech32 encoding.

Line 85 ↗

Decode and explain failures

This decoder checks the format, network and witness constraints, producing a destination or an error. Error locations can help users find some typing mistakes. Passing the decoder does not show that an address has been used.

Line 232 ↗

Private-key export is different

EncodeSecret creates a private-key text representation. It is not an address encoder. Its output contains signing material and must not be treated as a harmless public destination.

Line 295 ↗

Use the selected chain

The public helper delegates to the encoder with the current chain parameters. A string suitable for one Bitcoin network can be rejected or interpreted differently under another network configuration.

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.