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.

7,752 bytes · SHA-256 0eff25367070d696… · 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 <wallet/load.h>
7
8#include <common/args.h>
9#include <interfaces/chain.h>
10#include <scheduler.h>
11#include <util/check.h>
12#include <util/fs.h>
13#include <util/string.h>
14#include <util/translation.h>
15#include <wallet/context.h>
16#include <wallet/spend.h>
17#include <wallet/wallet.h>
18#include <wallet/walletdb.h>
19
20#include <univalue.h>
21
22#include <system_error>
23
24using util::Join;
25
26namespace wallet {
27bool VerifyWallets(WalletContext& context)
28{
29    interfaces::Chain& chain = *context.chain;
30    ArgsManager& args = *Assert(context.args);
31
32    if (args.IsArgSet("-walletdir")) {
33        const fs::path wallet_dir{args.GetPathArg("-walletdir")};
34        std::error_code error;
35        // The canonical path cleans the path, preventing >1 Berkeley environment instances for the same directory
36        // It also lets the fs::exists and fs::is_directory checks below pass on windows, since they return false
37        // if a path has trailing slashes, and it strips trailing slashes.
38        fs::path canonical_wallet_dir = fs::canonical(wallet_dir, error);
39        if (error || !fs::exists(canonical_wallet_dir)) {
40            chain.initError(strprintf(_("Specified -walletdir \"%s\" does not exist"), fs::PathToString(wallet_dir)));
41            return false;
42        } else if (!fs::is_directory(canonical_wallet_dir)) {
43            chain.initError(strprintf(_("Specified -walletdir \"%s\" is not a directory"), fs::PathToString(wallet_dir)));
44            return false;
45        // The canonical path transforms relative paths into absolute ones, so we check the non-canonical version
46        } else if (!wallet_dir.is_absolute()) {
47            chain.initError(strprintf(_("Specified -walletdir \"%s\" is a relative path"), fs::PathToString(wallet_dir)));
48            return false;
49        }
50        args.ForceSetArg("-walletdir", fs::PathToString(canonical_wallet_dir));
51    }
52
53    LogInfo("Using wallet directory %s", fs::PathToString(GetWalletDir()));
54    // Print general DB information
55    LogDBInfo();
56
57    chain.initMessage(_("Verifying wallet(s)…"));
58
59    // For backwards compatibility if an unnamed top level wallet exists in the
60    // wallets directory, include it in the default list of wallets to load.
61    if (!args.IsArgSet("wallet")) {
62        DatabaseOptions options;
63        DatabaseStatus status;
64        ReadDatabaseArgs(args, options);
65        bilingual_str error_string;
66        options.require_existing = true;
67        options.verify = false;
68        if (MakeWalletDatabase("", options, status, error_string)) {
69            common::SettingsValue wallets(common::SettingsValue::VARR);
70            wallets.push_back(""); // Default wallet name is ""
71            // Pass write=false because no need to write file and probably
72            // better not to. If unnamed wallet needs to be added next startup
73            // and the setting is empty, this code will just run again.
74            chain.overwriteRwSetting("wallet", std::move(wallets), interfaces::SettingsAction::SKIP_WRITE);
75        }
76    }
77
78    // Keep track of each wallet absolute path to detect duplicates.
79    std::set<fs::path> wallet_paths;
80
81    for (const auto& wallet : chain.getSettingsList("wallet")) {
82        if (!wallet.isStr()) {
83            chain.initError(_("Invalid value detected for '-wallet' or '-nowallet'. "
84                              "'-wallet' requires a string value, while '-nowallet' accepts only '1' to disable all wallets"));
85            return false;
86        }
87        const auto& wallet_file = wallet.get_str();
88        const fs::path path = fsbridge::AbsPathJoin(GetWalletDir(), fs::PathFromString(wallet_file));
89
90        if (!wallet_paths.insert(path).second) {
91            chain.initWarning(strprintf(_("Ignoring duplicate -wallet %s."), wallet_file));
92            continue;
93        }
94
95        DatabaseOptions options;
96        DatabaseStatus status;
97        ReadDatabaseArgs(args, options);
98        options.require_existing = true;
99        options.verify = true;
100        bilingual_str error_string;
101        if (!MakeWalletDatabase(wallet_file, options, status, error_string)) {
102            if (status == DatabaseStatus::FAILED_NOT_FOUND) {
103                chain.initWarning(Untranslated(strprintf("Skipping -wallet path that doesn't exist. %s", error_string.original)));
104            } else if (status == DatabaseStatus::FAILED_LEGACY_DISABLED) {
105                // Skipping legacy wallets as they will not be loaded.
106                // This will be properly communicated to the user during the loading process.
107                continue;
108            } else {
109                chain.initError(error_string);
110                return false;
111            }
112        }
113    }
114
115    return true;
116}
117
118bool LoadWallets(WalletContext& context)
119{
120    interfaces::Chain& chain = *context.chain;
121    try {
122        std::set<fs::path> wallet_paths;
123        for (const auto& wallet : chain.getSettingsList("wallet")) {
124            if (!wallet.isStr()) {
125                chain.initError(_("Invalid value detected for '-wallet' or '-nowallet'. "
126                                  "'-wallet' requires a string value, while '-nowallet' accepts only '1' to disable all wallets"));
127                return false;
128            }
129            const auto& name = wallet.get_str();
130            if (!wallet_paths.insert(fs::PathFromString(name)).second) {
131                continue;
132            }
133            DatabaseOptions options;
134            DatabaseStatus status;
135            ReadDatabaseArgs(*context.args, options);
136            options.require_existing = true;
137            options.verify = false; // No need to verify, assuming verified earlier in VerifyWallets()
138            bilingual_str error;
139            std::vector<bilingual_str> warnings;
140            std::unique_ptr<WalletDatabase> database = MakeWalletDatabase(name, options, status, error);
141            if (!database) {
142                if (status == DatabaseStatus::FAILED_NOT_FOUND) continue;
143                if (status == DatabaseStatus::FAILED_LEGACY_DISABLED) {
144                    // Inform user that legacy wallet is not loaded and suggest upgrade options
145                    chain.initWarning(error);
146                    continue;
147                }
148            }
149            chain.initMessage(_("Loading wallet…"));
150            std::shared_ptr<CWallet> pwallet = database ? CWallet::LoadExisting(context, name, std::move(database), error, warnings) : nullptr;
151            if (!warnings.empty()) chain.initWarning(Join(warnings, Untranslated("\n")));
152            if (!pwallet) {
153                chain.initError(error);
154                return false;
155            }
156
157            NotifyWalletLoaded(context, pwallet);
158            AddWallet(context, pwallet);
159        }
160        return true;
161    } catch (const std::runtime_error& e) {
162        chain.initError(Untranslated(e.what()));
163        return false;
164    }
165}
166
167void StartWallets(WalletContext& context)
168{
169    for (const std::shared_ptr<CWallet>& pwallet : GetWallets(context)) {
170        pwallet->postInitProcess();
171    }
172
173    context.scheduler->scheduleEvery([&context] { MaybeResendWalletTxs(context); }, 1min);
174}
175
176void UnloadWallets(WalletContext& context)
177{
178    auto wallets = GetWallets(context);
179    while (!wallets.empty()) {
180        auto wallet = wallets.back();
181        wallets.pop_back();
182        std::vector<bilingual_str> warnings;
183        RemoveWallet(context, wallet, /* load_on_start= */ std::nullopt, warnings);
184        WaitForDeleteWallet(std::move(wallet));
185    }
186}
187} // namespace wallet
188

FILE GUIDE · KEY SECTIONS

Loading wallets at startup

Wallet startup separates verification, loading, post-initialization and unloading. Opening a wallet database is different from creating a new seed or restoring its entire history.

Line 27 ↗

Verify wallet configuration

The verification path checks the configured wallet directory and selected wallet paths and reports setup errors. Canonical-path handling helps avoid treating aliases of the same directory as distinct environments.

Line 118 ↗

Load configured wallet objects

The loader interprets the wallet settings and calls the appropriate wallet-loading path. Loading can fail with an initialization error; it should not silently invent a replacement wallet.

Line 167 ↗

Start post-initialization work

Loaded wallets receive their post-initialization processing, and the scheduler registers periodic resend work. This stage runs after loading rather than proving the chain is already fully synchronized.

Line 176 ↗

Release wallets safely

The unload path removes wallets and waits for their release as required. The lifecycle must coordinate outstanding references so an in-use wallet is not simply discarded.

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.