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.

27,742 bytes · SHA-256 9c0a974d138e2cff… · View upstream ↗

1// Copyright (c) 2018-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 <interfaces/wallet.h>
6
7#include <common/args.h>
8#include <consensus/amount.h>
9#include <interfaces/chain.h>
10#include <interfaces/handler.h>
11#include <node/types.h>
12#include <primitives/transaction.h>
13#include <rpc/server.h>
14#include <scheduler.h>
15#include <support/allocators/secure.h>
16#include <sync.h>
17#include <uint256.h>
18#include <util/check.h>
19#include <util/translation.h>
20#include <util/ui_change_type.h>
21#include <wallet/coincontrol.h>
22#include <wallet/context.h>
23#include <wallet/export.h>
24#include <wallet/feebumper.h>
25#include <wallet/fees.h>
26#include <wallet/load.h>
27#include <wallet/receive.h>
28#include <wallet/rpc/wallet.h>
29#include <wallet/spend.h>
30#include <wallet/wallet.h>
31
32#include <memory>
33#include <string>
34#include <utility>
35#include <vector>
36
37using common::PSBTError;
38using interfaces::Chain;
39using interfaces::FoundBlock;
40using interfaces::Handler;
41using interfaces::MakeSignalHandler;
42using interfaces::Wallet;
43using interfaces::WalletAddress;
44using interfaces::WalletBalances;
45using interfaces::WalletLoader;
46using interfaces::WalletMigrationResult;
47using interfaces::WalletTx;
48using interfaces::WalletTxOut;
49using interfaces::WalletTxStatus;
50
51namespace wallet {
52// All members of the classes in this namespace are intentionally public, as the
53// classes themselves are private.
54namespace {
55//! Construct wallet tx struct.
56WalletTx MakeWalletTx(CWallet& wallet, const CWalletTx& wtx)
57{
58    LOCK(wallet.cs_wallet);
59    WalletTx result;
60    result.tx = wtx.GetTx();
61    result.txin_is_mine.reserve(result.tx->vin.size());
62    for (const auto& txin : result.tx->vin) {
63        result.txin_is_mine.emplace_back(InputIsMine(wallet, txin));
64    }
65    result.txout_is_mine.reserve(result.tx->vout.size());
66    result.txout_address.reserve(result.tx->vout.size());
67    result.txout_address_is_mine.reserve(result.tx->vout.size());
68    for (const auto& txout : result.tx->vout) {
69        result.txout_is_mine.emplace_back(wallet.IsMine(txout));
70        result.txout_is_change.push_back(OutputIsChange(wallet, txout));
71        result.txout_address.emplace_back();
72        result.txout_address_is_mine.emplace_back(ExtractDestination(txout.scriptPubKey, result.txout_address.back()) ?
73                                                      wallet.IsMine(result.txout_address.back()) :
74                                                      false);
75    }
76    result.credit = CachedTxGetCredit(wallet, wtx, /*avoid_reuse=*/true);
77    result.debit = CachedTxGetDebit(wallet, wtx, /*avoid_reuse=*/true);
78    result.change = CachedTxGetChange(wallet, wtx);
79    result.time = wtx.GetTxTime();
80    result.from = wtx.m_from;
81    result.message = wtx.m_message;
82    result.comment = wtx.m_comment;
83    result.comment_to = wtx.m_comment_to;
84    result.is_coinbase = wtx.IsCoinBase();
85    return result;
86}
87
88//! Construct wallet tx status struct.
89WalletTxStatus MakeWalletTxStatus(const CWallet& wallet, const CWalletTx& wtx)
90    EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet)
91{
92    AssertLockHeld(wallet.cs_wallet);
93
94    WalletTxStatus result;
95    result.block_height =
96        wtx.state<TxStateConfirmed>() ? wtx.state<TxStateConfirmed>()->confirmed_block_height :
97        wtx.state<TxStateBlockConflicted>() ? wtx.state<TxStateBlockConflicted>()->conflicting_block_height :
98        std::numeric_limits<int>::max();
99    result.blocks_to_maturity = wallet.GetTxBlocksToMaturity(wtx);
100    result.depth_in_main_chain = wallet.GetTxDepthInMainChain(wtx);
101    result.time_received = wtx.nTimeReceived;
102    result.lock_time = wtx.GetTx()->nLockTime;
103    result.is_trusted = CachedTxIsTrusted(wallet, wtx);
104    result.is_abandoned = wtx.isAbandoned();
105    result.is_coinbase = wtx.IsCoinBase();
106    result.is_in_main_chain = wtx.isConfirmed();
107    return result;
108}
109
110//! Construct wallet TxOut struct.
111WalletTxOut MakeWalletTxOut(const CWallet& wallet,
112    const CWalletTx& wtx,
113    int n,
114    int depth) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet)
115{
116    WalletTxOut result;
117    result.txout = wtx.GetTx()->vout[n];
118    result.time = wtx.GetTxTime();
119    result.depth_in_main_chain = depth;
120    result.is_spent = wallet.IsSpent(COutPoint(wtx.GetHash(), n));
121    return result;
122}
123
124WalletTxOut MakeWalletTxOut(const CWallet& wallet,
125    const COutput& output) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet)
126{
127    WalletTxOut result;
128    result.txout = output.txout;
129    result.time = output.time;
130    result.depth_in_main_chain = output.depth;
131    result.is_spent = wallet.IsSpent(output.outpoint);
132    return result;
133}
134
135class WalletImpl : public Wallet
136{
137public:
138    explicit WalletImpl(WalletContext& context, const std::shared_ptr<CWallet>& wallet) : m_context(context), m_wallet(wallet) {}
139
140    bool encryptWallet(const SecureString& wallet_passphrase) override
141    {
142        return m_wallet->EncryptWallet(wallet_passphrase);
143    }
144    bool isCrypted() override { return m_wallet->HasEncryptionKeys(); }
145    bool lock() override { return m_wallet->Lock(); }
146    bool unlock(const SecureString& wallet_passphrase) override { return m_wallet->Unlock(wallet_passphrase); }
147    bool isLocked() override { return m_wallet->IsLocked(); }
148    bool changeWalletPassphrase(const SecureString& old_wallet_passphrase,
149        const SecureString& new_wallet_passphrase) override
150    {
151        return m_wallet->ChangeWalletPassphrase(old_wallet_passphrase, new_wallet_passphrase);
152    }
153    void abortRescan() override { m_wallet->AbortRescan(); }
154    bool backupWallet(const std::string& filename) override { return m_wallet->BackupWallet(filename); }
155    std::string getWalletName() override { return m_wallet->GetName(); }
156    util::Result<CTxDestination> getNewDestination(const OutputType type, const std::string& label) override
157    {
158        LOCK(m_wallet->cs_wallet);
159        return m_wallet->GetNewDestination(type, label);
160    }
161    bool getPubKey(const CScript& script, const CKeyID& address, CPubKey& pub_key) override
162    {
163        std::unique_ptr<SigningProvider> provider = m_wallet->GetSolvingProvider(script);
164        if (provider) {
165            return provider->GetPubKey(address, pub_key);
166        }
167        return false;
168    }
169    SigningResult signMessage(const std::string& message, const PKHash& pkhash, std::string& str_sig) override
170    {
171        return m_wallet->SignMessage(message, pkhash, str_sig);
172    }
173    bool isSpendable(const CTxDestination& dest) override
174    {
175        LOCK(m_wallet->cs_wallet);
176        return m_wallet->IsMine(dest);
177    }
178    bool setAddressBook(const CTxDestination& dest, const std::string& name, const std::optional<AddressPurpose>& purpose) override
179    {
180        return m_wallet->SetAddressBook(dest, name, purpose);
181    }
182    bool delAddressBook(const CTxDestination& dest) override
183    {
184        return m_wallet->DelAddressBook(dest);
185    }
186    bool getAddress(const CTxDestination& dest,
187        std::string* name,
188        AddressPurpose* purpose) override
189    {
190        LOCK(m_wallet->cs_wallet);
191        const auto& entry = m_wallet->FindAddressBookEntry(dest, /*allow_change=*/false);
192        if (!entry) return false; // addr not found
193        if (name) {
194            *name = entry->GetLabel();
195        }
196        if (purpose) {
197            // In very old wallets, address purpose may not be recorded so we derive it from IsMine
198            *purpose = entry->purpose.value_or(m_wallet->IsMine(dest) ? AddressPurpose::RECEIVE : AddressPurpose::SEND);
199        }
200        return true;
201    }
202    std::vector<WalletAddress> getAddresses() override
203    {
204        LOCK(m_wallet->cs_wallet);
205        std::vector<WalletAddress> result;
206        m_wallet->ForEachAddrBookEntry([&](const CTxDestination& dest, const std::string& label, bool is_change, const std::optional<AddressPurpose>& purpose) EXCLUSIVE_LOCKS_REQUIRED(m_wallet->cs_wallet) {
207            if (is_change) return;
208            bool is_mine = m_wallet->IsMine(dest);
209            // In very old wallets, address purpose may not be recorded so we derive it from IsMine
210            result.emplace_back(dest, is_mine, purpose.value_or(is_mine ? AddressPurpose::RECEIVE : AddressPurpose::SEND), label);
211        });
212        return result;
213    }
214    std::vector<std::string> getAddressReceiveRequests() override {
215        LOCK(m_wallet->cs_wallet);
216        return m_wallet->GetAddressReceiveRequests();
217    }
218    bool setAddressReceiveRequest(const CTxDestination& dest, const std::string& id, const std::string& value) override {
219        // Note: The setAddressReceiveRequest interface used by the GUI to store
220        // receive requests is a little awkward and could be improved in the
221        // future:
222        //
223        // - The same method is used to save requests and erase them, but
224        //   having separate methods could be clearer and prevent bugs.
225        //
226        // - Request ids are passed as strings even though they are generated as
227        //   integers.
228        //
229        // - Multiple requests can be stored for the same address, but it might
230        //   be better to only allow one request or only keep the current one.
231        LOCK(m_wallet->cs_wallet);
232        WalletBatch batch{m_wallet->GetDatabase()};
233        return value.empty() ? m_wallet->EraseAddressReceiveRequest(batch, dest, id)
234                             : m_wallet->SetAddressReceiveRequest(batch, dest, id, value);
235    }
236    util::Result<void> displayAddress(const CTxDestination& dest) override
237    {
238        LOCK(m_wallet->cs_wallet);
239        return m_wallet->DisplayAddress(dest);
240    }
241    bool lockCoin(const COutPoint& output, const bool write_to_db) override
242    {
243        LOCK(m_wallet->cs_wallet);
244        return m_wallet->LockCoin(output, write_to_db);
245    }
246    bool unlockCoin(const COutPoint& output) override
247    {
248        LOCK(m_wallet->cs_wallet);
249        return m_wallet->UnlockCoin(output);
250    }

FILE GUIDE · KEY SECTIONS

Adapting the wallet for application interfaces

WalletImpl bridges application-facing wallet interfaces to CWallet and related helpers. It adds locking and transforms internal state into view structures rather than implementing a separate wallet.

Line 135 ↗

Delegate capabilities to the underlying wallet

The wrapper retains the shared wallet and context, exposing operations such as encryption, backup, destination allocation and signing. These are capability-bearing local interfaces, not methods that a public explorer should expose without authentication and authorization.

Line 386 ↗

Avoid blocking when wallet state is busy

The method attempts the wallet lock and returns false if it cannot acquire it. On success it returns balances with the corresponding last processed block hash. A failed try-lock is temporarily unavailable data, not a zero balance.

Line 397 ↗

Account for explicit coin-control choices

The method combines selected inputs and additional available coins when permitted. The source explicitly notes that selected-input fetch errors are currently swallowed here. Consumers should not elevate this helper into a proof that a proposed transaction is fully fundable; transaction creation performs further checks.

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.