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.

54,323 bytes · SHA-256 b7bae647144c79ab… · 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 <bitcoin-build-config.h> // IWYU pragma: keep
7
8#include <wallet/walletdb.h>
9
10#include <common/system.h>
11#include <key_io.h>
12#include <primitives/transaction_identifier.h>
13#include <protocol.h>
14#include <script/script.h>
15#include <serialize.h>
16#include <sync.h>
17#include <util/bip32.h>
18#include <util/check.h>
19#include <util/fs.h>
20#include <util/time.h>
21#include <util/translation.h>
22#include <wallet/migrate.h>
23#include <wallet/sqlite.h>
24#include <wallet/wallet.h>
25
26#include <atomic>
27#include <optional>
28#include <string>
29
30namespace wallet {
31namespace DBKeys {
32const std::string ACENTRY{"acentry"};
33const std::string ACTIVEEXTERNALSPK{"activeexternalspk"};
34const std::string ACTIVEINTERNALSPK{"activeinternalspk"};
35const std::string BESTBLOCK_NOMERKLE{"bestblock_nomerkle"};
36const std::string BESTBLOCK{"bestblock"};
37const std::string CRYPTED_KEY{"ckey"};
38const std::string CSCRIPT{"cscript"};
39const std::string DEFAULTKEY{"defaultkey"};
40const std::string DESTDATA{"destdata"};
41const std::string FLAGS{"flags"};
42const std::string HDCHAIN{"hdchain"};
43const std::string KEYMETA{"keymeta"};
44const std::string KEY{"key"};
45const std::string LOCKED_UTXO{"lockedutxo"};
46const std::string MASTER_KEY{"mkey"};
47const std::string MINVERSION{"minversion"};
48const std::string NAME{"name"};
49const std::string OLD_KEY{"wkey"};
50const std::string ORDERPOSNEXT{"orderposnext"};
51const std::string POOL{"pool"};
52const std::string PURPOSE{"purpose"};
53const std::string SETTINGS{"settings"};
54const std::string TX{"tx"};
55const std::string WTX_VARIANT{"wtxvariant"};
56const std::string VERSION{"version"};
57const std::string WALLETDESCRIPTOR{"walletdescriptor"};
58const std::string WALLETDESCRIPTORCACHE{"walletdescriptorcache"};
59const std::string WALLETDESCRIPTORLHCACHE{"walletdescriptorlhcache"};
60const std::string WALLETDESCRIPTORCKEY{"walletdescriptorckey"};
61const std::string WALLETDESCRIPTORKEY{"walletdescriptorkey"};
62const std::string WATCHMETA{"watchmeta"};
63const std::string WATCHS{"watchs"};
64const std::unordered_set<std::string> LEGACY_TYPES{CRYPTED_KEY, CSCRIPT, DEFAULTKEY, HDCHAIN, KEYMETA, KEY, OLD_KEY, POOL, WATCHMETA, WATCHS};
65} // namespace DBKeys
66
67void LogDBInfo()
68{
69    // Add useful DB information here. This will be printed during startup.
70    LogInfo("Using SQLite Version %s", SQLiteDatabaseVersion());
71}
72
73//
74// WalletBatch
75//
76
77bool WalletBatch::WriteName(const std::string& strAddress, const std::string& strName)
78{
79    return WriteIC(std::make_pair(DBKeys::NAME, strAddress), strName);
80}
81
82bool WalletBatch::EraseName(const std::string& strAddress)
83{
84    // This should only be used for sending addresses, never for receiving addresses,
85    // receiving addresses must always have an address book entry if they're not change return.
86    return EraseIC(std::make_pair(DBKeys::NAME, strAddress));
87}
88
89bool WalletBatch::WritePurpose(const std::string& strAddress, const std::string& strPurpose)
90{
91    return WriteIC(std::make_pair(DBKeys::PURPOSE, strAddress), strPurpose);
92}
93
94bool WalletBatch::ErasePurpose(const std::string& strAddress)
95{
96    return EraseIC(std::make_pair(DBKeys::PURPOSE, strAddress));
97}
98
99bool WalletBatch::WriteFullTx(const CWalletTx& wtx)
100{
101    const Txid txid = wtx.GetHash();
102    // Persist all witness variants. Including the canonical one
103    for (const auto& [wtxid, tx] : wtx.GetTxs()) {
104        if (!WriteWtxVariant(txid, tx)) return false;
105    }
106    return WriteIC(std::make_pair(DBKeys::TX, txid), wtx);
107}
108
109bool WalletBatch::EraseTx(Txid hash)
110{
111    if (!EraseIC(std::make_pair(DBKeys::TX, hash.ToUint256()))) return false;
112    // Drop all witness variant records too, so none are left dangling
113    return m_batch->ErasePrefix(DataStream() << DBKeys::WTX_VARIANT << hash);
114}
115
116bool WalletBatch::WriteWtxVariant(const Txid& txid, const CTransactionRef& tx)
117{
118    return WriteIC(std::make_pair(DBKeys::WTX_VARIANT, std::make_pair(txid, tx->GetWitnessHash())), TX_WITH_WITNESS(tx));
119}
120
121bool WalletBatch::WriteTxMetadata(const CWalletTx& wtx)
122{
123    return WriteIC(std::make_pair(DBKeys::TX, wtx.GetHash()), wtx);
124}
125
126bool WalletBatch::WriteKeyMetadata(const CKeyMetadata& meta, const CPubKey& pubkey, const bool overwrite)
127{
128    return WriteIC(std::make_pair(DBKeys::KEYMETA, pubkey), meta, overwrite);
129}
130
131bool WalletBatch::WriteKey(const CPubKey& vchPubKey, const CPrivKey& vchPrivKey, const CKeyMetadata& keyMeta)
132{
133    if (!WriteKeyMetadata(keyMeta, vchPubKey, false)) {
134        return false;
135    }
136
137    // hash pubkey/privkey to accelerate wallet load
138    const auto keypair_hash = Hash(vchPubKey, vchPrivKey);
139
140    return WriteIC(std::make_pair(DBKeys::KEY, vchPubKey), std::make_pair(vchPrivKey, keypair_hash), false);
141}
142
143bool WalletBatch::WriteCryptedKey(const CPubKey& vchPubKey,
144                                const std::vector<unsigned char>& vchCryptedSecret,
145                                const CKeyMetadata &keyMeta)
146{
147    if (!WriteKeyMetadata(keyMeta, vchPubKey, true)) {
148        return false;
149    }
150
151    // Compute a checksum of the encrypted key
152    uint256 checksum = Hash(vchCryptedSecret);
153
154    const auto key = std::make_pair(DBKeys::CRYPTED_KEY, vchPubKey);
155    if (!WriteIC(key, std::make_pair(vchCryptedSecret, checksum), false)) {
156        // It may already exist, so try writing just the checksum
157        std::vector<unsigned char> val;
158        if (!m_batch->Read(key, val)) {
159            return false;
160        }
161        if (!WriteIC(key, std::make_pair(val, checksum), true)) {
162            return false;
163        }
164    }
165    EraseIC(std::make_pair(DBKeys::KEY, vchPubKey));
166    return true;
167}
168
169bool WalletBatch::WriteMasterKey(unsigned int nID, const CMasterKey& kMasterKey)
170{
171    return WriteIC(std::make_pair(DBKeys::MASTER_KEY, nID), kMasterKey, true);
172}
173
174bool WalletBatch::EraseMasterKey(unsigned int id)
175{
176    return EraseIC(std::make_pair(DBKeys::MASTER_KEY, id));
177}
178
179bool WalletBatch::WriteWatchOnly(const CScript &dest, const CKeyMetadata& keyMeta)
180{
181    if (!WriteIC(std::make_pair(DBKeys::WATCHMETA, dest), keyMeta)) {
182        return false;
183    }
184    return WriteIC(std::make_pair(DBKeys::WATCHS, dest), uint8_t{'1'});
185}
186
187bool WalletBatch::WriteBestBlock(const CBlockLocator& locator)
188{
189    WriteIC(DBKeys::BESTBLOCK, CBlockLocator()); // Write empty block locator so versions that require a merkle branch automatically rescan
190    return WriteIC(DBKeys::BESTBLOCK_NOMERKLE, locator);
191}
192
193bool WalletBatch::ReadBestBlock(CBlockLocator& locator)
194{
195    if (m_batch->Read(DBKeys::BESTBLOCK, locator) && !locator.vHave.empty()) return true;
196    return m_batch->Read(DBKeys::BESTBLOCK_NOMERKLE, locator);
197}
198
199bool WalletBatch::IsEncrypted()
200{
201    DataStream prefix;
202    prefix << DBKeys::MASTER_KEY;
203    if (auto cursor = m_batch->GetNewPrefixCursor(prefix)) {
204        DataStream k, v;
205        if (cursor->Next(k, v) == DatabaseCursor::Status::MORE) return true;
206    }
207    return false;
208}
209
210bool WalletBatch::WriteOrderPosNext(int64_t nOrderPosNext)
211{
212    return WriteIC(DBKeys::ORDERPOSNEXT, nOrderPosNext);
213}
214
215bool WalletBatch::WriteActiveScriptPubKeyMan(uint8_t type, const uint256& id, bool internal)
216{
217    std::string key = internal ? DBKeys::ACTIVEINTERNALSPK : DBKeys::ACTIVEEXTERNALSPK;
218    return WriteIC(make_pair(key, type), id);
219}
220
221bool WalletBatch::EraseActiveScriptPubKeyMan(uint8_t type, bool internal)
222{
223    const std::string key{internal ? DBKeys::ACTIVEINTERNALSPK : DBKeys::ACTIVEEXTERNALSPK};
224    return EraseIC(make_pair(key, type));
225}
226
227bool WalletBatch::WriteDescriptorKey(const uint256& desc_id, const CPubKey& pubkey, const CPrivKey& privkey)
228{
229    // hash pubkey/privkey to accelerate wallet load
230    const auto keypair_hash = Hash(pubkey, privkey);
231
232    return WriteIC(std::make_pair(DBKeys::WALLETDESCRIPTORKEY, std::make_pair(desc_id, pubkey)), std::make_pair(privkey, keypair_hash), false);
233}
234
235bool WalletBatch::WriteCryptedDescriptorKey(const uint256& desc_id, const CPubKey& pubkey, const std::vector<unsigned char>& secret)
236{
237    if (!WriteIC(std::make_pair(DBKeys::WALLETDESCRIPTORCKEY, std::make_pair(desc_id, pubkey)), secret, false)) {
238        return false;
239    }
240    EraseIC(std::make_pair(DBKeys::WALLETDESCRIPTORKEY, std::make_pair(desc_id, pubkey)));
241    return true;
242}
243
244bool WalletBatch::WriteDescriptor(const uint256& desc_id, const WalletDescriptor& descriptor)
245{
246    return WriteIC(make_pair(DBKeys::WALLETDESCRIPTOR, desc_id), descriptor);
247}
248
249bool WalletBatch::WriteDescriptorDerivedCache(const CExtPubKey& xpub, const uint256& desc_id, uint32_t key_exp_index, uint32_t der_index)
250{

FILE GUIDE · KEY SECTIONS

Persisting and loading wallet records

WalletBatch translates wallet objects into typed database records and reconstructs wallet state in a deliberate order. The backend supplies actual storage operations.

Line 99 ↗

Keep witness variants with transaction metadata

Writing a full transaction persists all known witness variants before the transaction record. EraseTx also removes variant records with the matching prefix. This avoids treating one transaction ID as if it could have only one stored witness serialization.

Line 1134 ↗

Load capabilities before dependent records

Loading begins with wallet flags, checks compiled external-signer support, then reads legacy and descriptor records, address book, active managers, decryption keys and transactions. Unknown descriptor types return a specific status instead of continuing into misleading corruption errors. Unhandled read exceptions are treated as corruption.

Line 1228 ↗

Coordinate procedure success with the database transaction

The helper starts a transaction, runs a supplied procedure, aborts on a false result and returns success only after commit succeeds. WalletBatch transaction listeners run after successful commit or abort. In-memory record changes alone should not be reported as durable database completion.

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.