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.

14,683 bytes · SHA-256 45aaa27870da472b… · View upstream ↗

1// Copyright (c) 2021-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 <consensus/amount.h>
6#include <consensus/consensus.h>
7#include <util/check.h>
8#include <wallet/receive.h>
9#include <wallet/transaction.h>
10#include <wallet/wallet.h>
11
12namespace wallet {
13bool InputIsMine(const CWallet& wallet, const CTxIn& txin)
14{
15    AssertLockHeld(wallet.cs_wallet);
16    const CWalletTx* prev = wallet.GetWalletTx(txin.prevout.hash);
17    if (prev && txin.prevout.n < prev->GetTx()->vout.size()) {
18        return wallet.IsMine(prev->GetTx()->vout[txin.prevout.n]);
19    }
20    return false;
21}
22
23bool AllInputsMine(const CWallet& wallet, const CTransaction& tx)
24{
25    LOCK(wallet.cs_wallet);
26    for (const CTxIn& txin : tx.vin) {
27        if (!InputIsMine(wallet, txin)) return false;
28    }
29    return true;
30}
31
32CAmount OutputGetCredit(const CWallet& wallet, const CTxOut& txout)
33{
34    if (!MoneyRange(txout.nValue))
35        throw std::runtime_error(std::string(__func__) + ": value out of range");
36    LOCK(wallet.cs_wallet);
37    return (wallet.IsMine(txout) ? txout.nValue : 0);
38}
39
40CAmount TxGetCredit(const CWallet& wallet, const CTransaction& tx)
41{
42    CAmount nCredit = 0;
43    for (const CTxOut& txout : tx.vout)
44    {
45        nCredit += OutputGetCredit(wallet, txout);
46        if (!MoneyRange(nCredit))
47            throw std::runtime_error(std::string(__func__) + ": value out of range");
48    }
49    return nCredit;
50}
51
52bool ScriptIsChange(const CWallet& wallet, const CScript& script)
53{
54    // TODO: fix handling of 'change' outputs. The assumption is that any
55    // payment to a script that is ours, but is not in the address book
56    // is change. That assumption is likely to break when we implement multisignature
57    // wallets that return change back into a multi-signature-protected address;
58    // a better way of identifying which outputs are 'the send' and which are
59    // 'the change' will need to be implemented (maybe extend CWalletTx to remember
60    // which output, if any, was change).
61    AssertLockHeld(wallet.cs_wallet);
62    if (wallet.IsMine(script))
63    {
64        CTxDestination address;
65        if (!ExtractDestination(script, address))
66            return true;
67        if (!wallet.FindAddressBookEntry(address)) {
68            return true;
69        }
70    }
71    return false;
72}
73
74bool OutputIsChange(const CWallet& wallet, const CTxOut& txout)
75{
76    return ScriptIsChange(wallet, txout.scriptPubKey);
77}
78
79CAmount OutputGetChange(const CWallet& wallet, const CTxOut& txout)
80{
81    AssertLockHeld(wallet.cs_wallet);
82    if (!MoneyRange(txout.nValue))
83        throw std::runtime_error(std::string(__func__) + ": value out of range");
84    return (OutputIsChange(wallet, txout) ? txout.nValue : 0);
85}
86
87CAmount TxGetChange(const CWallet& wallet, const CTransaction& tx)
88{
89    LOCK(wallet.cs_wallet);
90    CAmount nChange = 0;
91    for (const CTxOut& txout : tx.vout)
92    {
93        nChange += OutputGetChange(wallet, txout);
94        if (!MoneyRange(nChange))
95            throw std::runtime_error(std::string(__func__) + ": value out of range");
96    }
97    return nChange;
98}
99
100static CAmount GetCachableAmount(const CWallet& wallet, const CWalletTx& wtx, CWalletTx::AmountType type, bool avoid_reuse)
101{
102    auto& amount = wtx.m_amounts[type];
103    if (!amount.IsCached(avoid_reuse)) {
104        amount.Set(avoid_reuse, type == CWalletTx::DEBIT ? wallet.GetDebit(*wtx.GetTx()) : TxGetCredit(wallet, *wtx.GetTx()));
105        wtx.m_is_cache_empty = false;
106    }
107    return amount.Get(avoid_reuse);
108}
109
110CAmount CachedTxGetCredit(const CWallet& wallet, const CWalletTx& wtx, bool avoid_reuse)
111{
112    AssertLockHeld(wallet.cs_wallet);
113
114    // Must wait until coinbase is safely deep enough in the chain before valuing it
115    if (wallet.IsTxImmatureCoinBase(wtx))
116        return 0;
117
118    // GetBalance can assume transactions in mapWallet won't change
119    return GetCachableAmount(wallet, wtx, CWalletTx::CREDIT, avoid_reuse);
120}
121
122CAmount CachedTxGetDebit(const CWallet& wallet, const CWalletTx& wtx, bool avoid_reuse)
123{
124    if (wtx.GetTx()->vin.empty())
125        return 0;
126
127    return GetCachableAmount(wallet, wtx, CWalletTx::DEBIT, avoid_reuse);
128}
129
130CAmount CachedTxGetChange(const CWallet& wallet, const CWalletTx& wtx)
131{
132    if (wtx.fChangeCached)
133        return wtx.nChangeCached;
134    wtx.nChangeCached = TxGetChange(wallet, *wtx.GetTx());
135    wtx.fChangeCached = true;
136    return wtx.nChangeCached;
137}
138
139void CachedTxGetAmounts(const CWallet& wallet, const CWalletTx& wtx,
140                  std::list<COutputEntry>& listReceived,
141                  std::list<COutputEntry>& listSent, CAmount& nFee,
142                  bool include_change)
143{
144    nFee = 0;
145    listReceived.clear();
146    listSent.clear();
147
148    // Compute fee:
149    CAmount nDebit = CachedTxGetDebit(wallet, wtx, /*avoid_reuse=*/false);
150    if (nDebit > 0) // debit>0 means we signed/sent this transaction
151    {
152        CAmount nValueOut = wtx.GetTx()->GetValueOut();
153        nFee = nDebit - nValueOut;
154    }
155
156    LOCK(wallet.cs_wallet);
157    // Sent/received.
158    for (unsigned int i = 0; i < wtx.GetTx()->vout.size(); ++i)
159    {
160        const CTxOut& txout = wtx.GetTx()->vout[i];
161        bool ismine = wallet.IsMine(txout);
162        // Only need to handle txouts if AT LEAST one of these is true:
163        //   1) they debit from us (sent)
164        //   2) the output is to us (received)
165        if (nDebit > 0)
166        {
167            if (!include_change && OutputIsChange(wallet, txout))
168                continue;
169        }
170        else if (!ismine)
171            continue;
172
173        // In either case, we need to get the destination address
174        CTxDestination address;
175
176        if (!ExtractDestination(txout.scriptPubKey, address) && !txout.scriptPubKey.IsUnspendable())
177        {
178            wallet.WalletLogPrintf("CWalletTx::GetAmounts: Unknown transaction type found, txid %s\n",
179                                    wtx.GetHash().ToString());
180            address = CNoDestination();
181        }
182
183        COutputEntry output = {address, txout.nValue, (int)i};
184
185        // If we are debited by the transaction, add the output as a "sent" entry
186        if (nDebit > 0)
187            listSent.push_back(output);
188
189        // If we are receiving the output, add it as a "received" entry
190        if (ismine)
191            listReceived.push_back(output);
192    }
193
194}
195
196bool CachedTxIsFromMe(const CWallet& wallet, const CWalletTx& wtx)
197{
198    if (!wtx.m_cached_from_me.has_value()) {
199        wtx.m_cached_from_me = wallet.IsFromMe(*wtx.GetTx());
200    }
201    return wtx.m_cached_from_me.value();
202}
203
204// NOLINTNEXTLINE(misc-no-recursion)
205bool CachedTxIsTrusted(const CWallet& wallet, const CWalletTx& wtx, std::set<Txid>& trusted_parents)
206{
207    AssertLockHeld(wallet.cs_wallet);
208
209    // This wtx is already trusted
210    if (trusted_parents.contains(wtx.GetHash())) return true;
211
212    if (wtx.isConfirmed()) return true;
213    if (wtx.isBlockConflicted()) return false;
214    // using wtx's cached debit
215    if (!wallet.m_spend_zero_conf_change || !CachedTxIsFromMe(wallet, wtx)) return false;
216
217    // Don't trust unconfirmed transactions from us unless they are in the mempool.
218    if (!wtx.InMempool()) return false;
219
220    // Trusted if all inputs are from us and are in the mempool:
221    for (const CTxIn& txin : wtx.GetTx()->vin)
222    {
223        // Transactions not sent by us: not trusted
224        const CWalletTx* parent = wallet.GetWalletTx(txin.prevout.hash);
225        if (parent == nullptr) return false;
226        const CTxOut& parentOut = parent->GetTx()->vout[txin.prevout.n];
227        // Check that this specific input being spent is trusted
228        if (!wallet.IsMine(parentOut)) return false;
229        // If we've already trusted this parent, continue
230        if (trusted_parents.contains(parent->GetHash())) continue;
231        // Recurse to check that the parent is also trusted
232        if (!CachedTxIsTrusted(wallet, *parent, trusted_parents)) return false;
233        trusted_parents.insert(parent->GetHash());
234    }
235    return true;
236}
237
238bool CachedTxIsTrusted(const CWallet& wallet, const CWalletTx& wtx)
239{
240    std::set<Txid> trusted_parents;
241    LOCK(wallet.cs_wallet);
242    return CachedTxIsTrusted(wallet, wtx, trusted_parents);
243}
244
245Balance GetBalance(const CWallet& wallet, const int min_depth, bool avoid_reuse, bool include_nonmempool)
246{
247    Balance ret;
248    bool allow_used_addresses = !avoid_reuse || !wallet.IsWalletFlagSet(WALLET_FLAG_AVOID_REUSE);
249    {
250        LOCK(wallet.cs_wallet);

FILE GUIDE · KEY SECTIONS

What the wallet counts as received

These helpers compute wallet credits, debits, change and trust classifications. They depend on wallet knowledge; an outside explorer cannot automatically reproduce private wallet bookkeeping.

Line 13 ↗

Look up the previous output

The wallet determines whether an input spends one of its outputs by examining the referenced wallet transaction. An input does not carry a simple sender-address field.

Line 32 ↗

Count owned outputs

Credit is calculated from outputs recognized by the wallet, with amount-range checks. This is wallet-relative accounting; the same transaction can affect different wallets differently.

Line 52 ↗

Change is a wallet inference

The source explicitly documents limitations in its change heuristic. It checks wallet ownership and address-book knowledge. An explorer should not present this wallet-local inference as public proof of which output is change.

Line 205 ↗

Trusted is not the same as confirmed

Confirmed transactions and certain wallet-created unconfirmed chains are handled differently. The unconfirmed path checks mempool presence and trusted wallet parents. This classification is not a promise that an unconfirmed payment cannot be replaced.

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.