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.

8,860 bytes · SHA-256 47330a6393b1ba35… · View upstream ↗

1// Copyright (c) 2026-present The Bitcoin Core developers
2// Distributed under the MIT software license, see the accompanying
3// file COPYING or https://www.opensource.org/licenses/mit-license.php.
4
5#include <wallet/export.h>
6
7#include <key_io.h>
8#include <util/fs.h>
9#include <util/expected.h>
10#include <wallet/scriptpubkeyman.h>
11#include <wallet/context.h>
12#include <wallet/sqlite.h>
13#include <wallet/wallet.h>
14
15#include <fstream>
16
17namespace wallet {
18util::Expected<std::vector<WalletDescInfo>, std::string> ExportDescriptors(const CWallet& wallet, bool export_private)
19{
20    AssertLockHeld(wallet.cs_wallet);
21    std::vector<WalletDescInfo> wallet_descriptors;
22    for (const auto& spk_man : wallet.GetAllScriptPubKeyMans()) {
23        const auto desc_spk_man = dynamic_cast<DescriptorScriptPubKeyMan*>(spk_man);
24        if (!desc_spk_man) {
25            return util::Unexpected{"Unexpected ScriptPubKey manager type."};
26        }
27        LOCK(desc_spk_man->cs_desc_man);
28        const auto& wallet_descriptor = desc_spk_man->GetWalletDescriptor();
29        std::string descriptor;
30        if (!Assume(desc_spk_man->GetDescriptorString(descriptor, export_private))) {
31            return util::Unexpected{"Can't get descriptor string."};
32        }
33        const bool is_range = wallet_descriptor.descriptor->IsRange();
34        wallet_descriptors.emplace_back(
35            descriptor,
36            wallet_descriptor.creation_time,
37            wallet.IsActiveScriptPubKeyMan(*desc_spk_man),
38            wallet.IsInternalScriptPubKeyMan(desc_spk_man),
39            is_range ? std::optional(std::make_pair(wallet_descriptor.GetStart(), wallet_descriptor.GetEnd())) : std::nullopt,
40            wallet_descriptor.GetNext(),
41            wallet_descriptor.cache
42        );
43    }
44    return wallet_descriptors;
45}
46
47util::Result<std::string> ExportWatchOnlyWallet(const CWallet& wallet, const fs::path& destination, WalletContext& context)
48{
49    AssertLockHeld(wallet.cs_wallet);
50
51    if (destination.empty()) {
52        return util::Error{_("Error: Export destination cannot be empty")};
53    }
54    if (fs::exists(destination)) {
55        return util::Error{strprintf(_("Error: Export destination '%s' already exists"), fs::PathToString(destination))};
56    }
57    if (!std::ofstream{fs::PathToString(destination)}) {
58        return util::Error{strprintf(_("Error: Could not create file '%s'"), fs::PathToString(destination))};
59    }
60    bool success = false;
61    auto cleanup_destination = interfaces::MakeCleanupHandler([&success, &destination] {
62        if (!success) fs::remove(destination);
63    });
64
65    // Get the descriptors from this wallet
66    util::Expected<std::vector<WalletDescInfo>, std::string> exported = ExportDescriptors(wallet, /*export_private=*/false);
67    if (!exported) {
68        return util::Error{Untranslated(exported.error())};
69    }
70    if (exported->empty()) {
71        return util::Error{_("Error: Wallet has no descriptors to export")};
72    }
73
74    // Make the wallet with the same flags as this wallet, but without private keys
75    const uint64_t create_flags = wallet.GetWalletFlags() | WALLET_FLAG_DISABLE_PRIVATE_KEYS;
76
77    // Create the temporary watchonly wallet in memory to avoid leaving files on disk
78    std::vector<bilingual_str> warnings;
79    bilingual_str error;
80    WalletContext empty_context;
81    empty_context.args = context.args;
82    std::shared_ptr<CWallet> watchonly_wallet = CWallet::CreateNew(empty_context, /*name=*/wallet.GetName() + "_watchonly_temp", MakeInMemoryWalletDatabase(), create_flags, /*born_encrypted=*/false, error, warnings);
83    if (!watchonly_wallet) {
84        return util::Error{strprintf(_("Error: Failed to create new watchonly wallet. %s"), error)};
85    }
86
87    {
88        LOCK(watchonly_wallet->cs_wallet);
89
90        // Parse the descriptors and add them to the new wallet
91        for (const WalletDescInfo& desc_info : *Assert(exported)) {
92            // Parse the descriptor
93            FlatSigningProvider dummy_keys;
94            std::string dummy_err;
95            std::vector<std::unique_ptr<Descriptor>> descs = Parse(desc_info.descriptor, dummy_keys, dummy_err, /*require_checksum=*/true);
96            CHECK_NONFATAL(descs.size() == 1); // All of our descriptors should be valid, and not multipath
97            CHECK_NONFATAL(dummy_keys.keys.size() == 0); // No private keys should be present in our exported descriptors
98
99            // Get the range if there is one
100            int32_t range_start = 0;
101            int32_t range_end = 0;
102            if (desc_info.range) {
103                range_start = desc_info.range->first;
104                range_end = desc_info.range->second;
105            }
106
107            WalletDescriptor w_desc(std::move(descs.at(0)), desc_info.creation_time, range_start, range_end, desc_info.next_index);
108
109            // For descriptors that cannot self expand (i.e. needs private keys or cache), set the cache
110            if (!w_desc.descriptor->CanSelfExpand()) {
111                w_desc.cache = desc_info.cache;
112            }
113
114            // Add to the watchonly wallet
115            auto spkm_res = watchonly_wallet->AddWalletDescriptor(w_desc, dummy_keys, /*label=*/"", /*internal=*/false);
116            if (!spkm_res) {
117                return util::Error{util::ErrorString(spkm_res)};
118            }
119
120            // Set active spkms as active
121            if (desc_info.active) {
122                // Determine whether this descriptor is internal
123                // This is only set for active spkms
124                bool internal = false;
125                if (desc_info.internal) {
126                    internal = *desc_info.internal;
127                }
128                watchonly_wallet->AddActiveScriptPubKeyMan(spkm_res->get().GetID(), *Assert(w_desc.descriptor->GetOutputType()), internal);
129            }
130        }
131
132        // Copy locked coins that are persisted
133        for (const auto& [coin, persisted] : wallet.m_locked_coins) {
134            if (!persisted) continue;
135            watchonly_wallet->LockCoin(coin, persisted);
136        }
137
138        {
139            // Make a WalletBatch for the watchonly wallet so that everything else can be written atomically
140            WalletBatch watchonly_batch(watchonly_wallet->GetDatabase());
141            if (!watchonly_batch.TxnBegin()) {
142                return util::Error{strprintf(_("Error: database transaction cannot be executed for new watchonly wallet %s"), watchonly_wallet->GetName())};
143            }
144
145            // Copy orderPosNext
146            watchonly_batch.WriteOrderPosNext(wallet.nOrderPosNext);
147
148            // Write the best block locator to avoid rescanning on reload
149            CBlockLocator best_block_locator;
150            {
151                WalletBatch local_wallet_batch(wallet.GetDatabase());
152                if (!local_wallet_batch.ReadBestBlock(best_block_locator)) {
153                    return util::Error{_("Error: Unable to read wallet's best block locator record")};
154                }
155            }
156            if (!watchonly_batch.WriteBestBlock(best_block_locator)) {
157                return util::Error{_("Error: Unable to write watchonly wallet best block locator record")};
158            }
159
160            // Copy the transactions
161            for (const auto& [txid, wtx] : wallet.mapWallet) {
162                DataStream wtx_ser;
163                wtx_ser << wtx;
164                CWalletTx copy_wtx(deserialize, wtx_ser, wtx.GetTxs());
165                if (!watchonly_wallet->LoadToWallet(std::move(copy_wtx))) {
166                    return util::Error{strprintf(_("Error: Could not add tx %s to watchonly wallet"), txid.GetHex())};
167                }
168                watchonly_batch.WriteFullTx(watchonly_wallet->mapWallet.at(txid));
169            }
170
171            // Copy address book
172            for (const auto& [dest, entry] : wallet.m_address_book) {
173                auto address{EncodeDestination(dest)};
174                if (entry.purpose) watchonly_batch.WritePurpose(address, PurposeToString(*entry.purpose));
175                if (entry.label) watchonly_batch.WriteName(address, *entry.label);
176                for (const auto& [id, request] : entry.receive_requests) {
177                    watchonly_batch.WriteAddressReceiveRequest(dest, id, request);
178                }
179                if (entry.previously_spent) watchonly_batch.WriteAddressPreviouslySpent(dest, true);
180            }
181
182            if (!watchonly_batch.TxnCommit()) {
183                return util::Error{_("Error: cannot commit db transaction for watchonly wallet export")};
184            }
185        }
186
187        // Make a backup of this wallet at the specified destination directory
188        if (!watchonly_wallet->BackupWallet(fs::PathToString(destination))) {
189            return util::Error{_("Error: Unable to write the exported wallet")};
190        }
191        success = true;
192    }
193
194    return fs::PathToString(destination);
195}
196} // namespace wallet
197

FILE GUIDE · KEY SECTIONS

Exporting a wallet view without private keys

This implementation exports public descriptors and builds a watch-only wallet copy with useful metadata. Removing signing secrets does not remove financial privacy concerns from the exported file.

Line 18 ↗

Collect descriptor state under the required locks

Each descriptor manager contributes its descriptor, creation time, active and internal status, range, next index and cache. The private-export flag controls descriptor text. Unexpected manager types or unavailable descriptor strings produce explicit errors rather than incomplete success.

Line 47 ↗

Build a temporary wallet without signing keys

The destination must be nonempty and not already exist. The code exports public descriptors, creates an in-memory wallet with private keys disabled and checks that parsing those descriptors yields no private keys. It carries descriptor caches when public expansion needs them.

Line 160 ↗

Preserve monitoring state and write the export

The export copies transactions, address-book information and persisted coin locks, writing related database state transactionally before backing up the temporary wallet to the destination. Failed export cleanup removes the unfinished destination. The resulting file can monitor activity but cannot replace a private-key backup needed to spend.

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.