Branch data Line data Source code
1 : : // Copyright (c) 2021-2022 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 <wallet/receive.h>
8 : : #include <wallet/transaction.h>
9 : : #include <wallet/wallet.h>
10 : :
11 : : namespace wallet {
12 : 473 : isminetype InputIsMine(const CWallet& wallet, const CTxIn& txin)
13 : : {
14 : 473 : AssertLockHeld(wallet.cs_wallet);
15 : 473 : const CWalletTx* prev = wallet.GetWalletTx(txin.prevout.hash);
16 [ + + + - ]: 473 : if (prev && txin.prevout.n < prev->tx->vout.size()) {
17 : 269 : return wallet.IsMine(prev->tx->vout[txin.prevout.n]);
18 : : }
19 : : return ISMINE_NO;
20 : : }
21 : :
22 : 113 : bool AllInputsMine(const CWallet& wallet, const CTransaction& tx, const isminefilter& filter)
23 : : {
24 : 113 : LOCK(wallet.cs_wallet);
25 [ + + ]: 379 : for (const CTxIn& txin : tx.vin) {
26 [ + - + + ]: 267 : if (!(InputIsMine(wallet, txin) & filter)) return false;
27 : : }
28 : : return true;
29 : 113 : }
30 : :
31 : 40536 : CAmount OutputGetCredit(const CWallet& wallet, const CTxOut& txout, const isminefilter& filter)
32 : : {
33 [ - + ]: 40536 : if (!MoneyRange(txout.nValue))
34 [ # # # # ]: 0 : throw std::runtime_error(std::string(__func__) + ": value out of range");
35 : 40536 : LOCK(wallet.cs_wallet);
36 [ + - + + : 40536 : return ((wallet.IsMine(txout) & filter) ? txout.nValue : 0);
+ - ]
37 : 40536 : }
38 : :
39 : 8087 : CAmount TxGetCredit(const CWallet& wallet, const CTransaction& tx, const isminefilter& filter)
40 : : {
41 : 8087 : CAmount nCredit = 0;
42 [ + + ]: 24229 : for (const CTxOut& txout : tx.vout)
43 : : {
44 : 16142 : nCredit += OutputGetCredit(wallet, txout, filter);
45 [ - + ]: 16142 : if (!MoneyRange(nCredit))
46 [ # # # # ]: 0 : throw std::runtime_error(std::string(__func__) + ": value out of range");
47 : : }
48 : 8087 : return nCredit;
49 : : }
50 : :
51 : 1973 : bool ScriptIsChange(const CWallet& wallet, const CScript& script)
52 : : {
53 : : // TODO: fix handling of 'change' outputs. The assumption is that any
54 : : // payment to a script that is ours, but is not in the address book
55 : : // is change. That assumption is likely to break when we implement multisignature
56 : : // wallets that return change back into a multi-signature-protected address;
57 : : // a better way of identifying which outputs are 'the send' and which are
58 : : // 'the change' will need to be implemented (maybe extend CWalletTx to remember
59 : : // which output, if any, was change).
60 : 1973 : AssertLockHeld(wallet.cs_wallet);
61 [ + + ]: 1973 : if (wallet.IsMine(script))
62 : : {
63 : 1355 : CTxDestination address;
64 [ + - + + ]: 1355 : if (!ExtractDestination(script, address))
65 : : return true;
66 [ + - + + ]: 1350 : if (!wallet.FindAddressBookEntry(address)) {
67 : : return true;
68 : : }
69 : 1355 : }
70 : : return false;
71 : : }
72 : :
73 : 1309 : bool OutputIsChange(const CWallet& wallet, const CTxOut& txout)
74 : : {
75 : 1309 : return ScriptIsChange(wallet, txout.scriptPubKey);
76 : : }
77 : :
78 : 0 : CAmount OutputGetChange(const CWallet& wallet, const CTxOut& txout)
79 : : {
80 : 0 : AssertLockHeld(wallet.cs_wallet);
81 [ # # ]: 0 : if (!MoneyRange(txout.nValue))
82 [ # # # # ]: 0 : throw std::runtime_error(std::string(__func__) + ": value out of range");
83 [ # # ]: 0 : return (OutputIsChange(wallet, txout) ? txout.nValue : 0);
84 : : }
85 : :
86 : 0 : CAmount TxGetChange(const CWallet& wallet, const CTransaction& tx)
87 : : {
88 : 0 : LOCK(wallet.cs_wallet);
89 : 0 : CAmount nChange = 0;
90 [ # # ]: 0 : for (const CTxOut& txout : tx.vout)
91 : : {
92 [ # # ]: 0 : nChange += OutputGetChange(wallet, txout);
93 [ # # ]: 0 : if (!MoneyRange(nChange))
94 [ # # # # ]: 0 : throw std::runtime_error(std::string(__func__) + ": value out of range");
95 : : }
96 [ # # ]: 0 : return nChange;
97 : 0 : }
98 : :
99 : 563723 : static CAmount GetCachableAmount(const CWallet& wallet, const CWalletTx& wtx, CWalletTx::AmountType type, const isminefilter& filter)
100 : : {
101 : 563723 : auto& amount = wtx.m_amounts[type];
102 [ + + ]: 563723 : if (!amount.m_cached[filter]) {
103 [ + + ]: 24411 : amount.Set(filter, type == CWalletTx::DEBIT ? wallet.GetDebit(*wtx.tx, filter) : TxGetCredit(wallet, *wtx.tx, filter));
104 : 24411 : wtx.m_is_cache_empty = false;
105 : : }
106 : 563723 : return amount.m_value[filter];
107 : : }
108 : :
109 : 413 : CAmount CachedTxGetCredit(const CWallet& wallet, const CWalletTx& wtx, const isminefilter& filter)
110 : : {
111 : 413 : AssertLockHeld(wallet.cs_wallet);
112 : :
113 : : // Must wait until coinbase is safely deep enough in the chain before valuing it
114 [ + + ]: 413 : if (wallet.IsTxImmatureCoinBase(wtx))
115 : : return 0;
116 : :
117 : 407 : CAmount credit = 0;
118 : 407 : const isminefilter get_amount_filter{filter & ISMINE_ALL};
119 [ + - ]: 407 : if (get_amount_filter) {
120 : : // GetBalance can assume transactions in mapWallet won't change
121 : 407 : credit += GetCachableAmount(wallet, wtx, CWalletTx::CREDIT, get_amount_filter);
122 : : }
123 : : return credit;
124 : : }
125 : :
126 : 511522 : CAmount CachedTxGetDebit(const CWallet& wallet, const CWalletTx& wtx, const isminefilter& filter)
127 : : {
128 [ + - ]: 511522 : if (wtx.tx->vin.empty())
129 : : return 0;
130 : :
131 : 511522 : CAmount debit = 0;
132 : 511522 : const isminefilter get_amount_filter{filter & ISMINE_ALL};
133 [ + - ]: 511522 : if (get_amount_filter) {
134 : 511522 : debit += GetCachableAmount(wallet, wtx, CWalletTx::DEBIT, get_amount_filter);
135 : : }
136 : : return debit;
137 : : }
138 : :
139 : 0 : CAmount CachedTxGetChange(const CWallet& wallet, const CWalletTx& wtx)
140 : : {
141 [ # # ]: 0 : if (wtx.fChangeCached)
142 : 0 : return wtx.nChangeCached;
143 : 0 : wtx.nChangeCached = TxGetChange(wallet, *wtx.tx);
144 : 0 : wtx.fChangeCached = true;
145 : 0 : return wtx.nChangeCached;
146 : : }
147 : :
148 : 185958 : CAmount CachedTxGetImmatureCredit(const CWallet& wallet, const CWalletTx& wtx, const isminefilter& filter)
149 : : {
150 : 185958 : AssertLockHeld(wallet.cs_wallet);
151 : :
152 [ + + ]: 185958 : if (wallet.IsTxImmatureCoinBase(wtx) && wtx.isConfirmed()) {
153 : 51794 : return GetCachableAmount(wallet, wtx, CWalletTx::IMMATURE_CREDIT, filter);
154 : : }
155 : :
156 : : return 0;
157 : : }
158 : :
159 : 185959 : CAmount CachedTxGetAvailableCredit(const CWallet& wallet, const CWalletTx& wtx, const isminefilter& filter)
160 : : {
161 : 185959 : AssertLockHeld(wallet.cs_wallet);
162 : :
163 : : // Avoid caching ismine for NO or ALL cases (could remove this check and simplify in the future).
164 : 185959 : bool allow_cache = (filter & ISMINE_ALL) && (filter & ISMINE_ALL) != ISMINE_ALL;
165 : :
166 : : // Must wait until coinbase is safely deep enough in the chain before valuing it
167 [ + + ]: 185959 : if (wallet.IsTxImmatureCoinBase(wtx))
168 : : return 0;
169 : :
170 [ + - + + : 252309 : if (allow_cache && wtx.m_amounts[CWalletTx::AVAILABLE_CREDIT].m_cached[filter]) {
+ + ]
171 : 118316 : return wtx.m_amounts[CWalletTx::AVAILABLE_CREDIT].m_value[filter];
172 : : }
173 : :
174 [ + + + + ]: 15677 : bool allow_used_addresses = (filter & ISMINE_USED) || !wallet.IsWalletFlagSet(WALLET_FLAG_AVOID_REUSE);
175 : 15677 : CAmount nCredit = 0;
176 : 15677 : Txid hashTx = wtx.GetHash();
177 [ + + ]: 49562 : for (unsigned int i = 0; i < wtx.tx->vout.size(); i++) {
178 : 33885 : const CTxOut& txout = wtx.tx->vout[i];
179 [ + + + + : 33885 : if (!wallet.IsSpent(COutPoint(hashTx, i)) && (allow_used_addresses || !wallet.IsSpentKey(txout.scriptPubKey))) {
+ + ]
180 : 24394 : nCredit += OutputGetCredit(wallet, txout, filter);
181 [ - + ]: 24394 : if (!MoneyRange(nCredit))
182 [ # # # # ]: 0 : throw std::runtime_error(std::string(__func__) + " : value out of range");
183 : : }
184 : : }
185 : :
186 [ + - ]: 15677 : if (allow_cache) {
187 : 15677 : wtx.m_amounts[CWalletTx::AVAILABLE_CREDIT].Set(filter, nCredit);
188 : 15677 : wtx.m_is_cache_empty = false;
189 : : }
190 : :
191 : : return nCredit;
192 : : }
193 : :
194 : 1847 : void CachedTxGetAmounts(const CWallet& wallet, const CWalletTx& wtx,
195 : : std::list<COutputEntry>& listReceived,
196 : : std::list<COutputEntry>& listSent, CAmount& nFee, const isminefilter& filter,
197 : : bool include_change)
198 : : {
199 : 1847 : nFee = 0;
200 : 1847 : listReceived.clear();
201 : 1847 : listSent.clear();
202 : :
203 : : // Compute fee:
204 : 1847 : CAmount nDebit = CachedTxGetDebit(wallet, wtx, filter);
205 [ + + ]: 1847 : if (nDebit > 0) // debit>0 means we signed/sent this transaction
206 : : {
207 : 549 : CAmount nValueOut = wtx.tx->GetValueOut();
208 : 549 : nFee = nDebit - nValueOut;
209 : : }
210 : :
211 : 1847 : LOCK(wallet.cs_wallet);
212 : : // Sent/received.
213 [ + + ]: 5521 : for (unsigned int i = 0; i < wtx.tx->vout.size(); ++i)
214 : : {
215 [ + - ]: 3674 : const CTxOut& txout = wtx.tx->vout[i];
216 [ + - ]: 3674 : isminetype fIsMine = wallet.IsMine(txout);
217 : : // Only need to handle txouts if AT LEAST one of these is true:
218 : : // 1) they debit from us (sent)
219 : : // 2) the output is to us (received)
220 [ + + ]: 3674 : if (nDebit > 0)
221 : : {
222 [ + + + - : 1083 : if (!include_change && OutputIsChange(wallet, txout))
+ + ]
223 : 424 : continue;
224 : : }
225 [ + + ]: 2591 : else if (!(fIsMine & filter))
226 : 1283 : continue;
227 : :
228 : : // In either case, we need to get the destination address
229 : 1967 : CTxDestination address;
230 : :
231 [ + - + + : 1967 : if (!ExtractDestination(txout.scriptPubKey, address) && !txout.scriptPubKey.IsUnspendable())
- + ]
232 : : {
233 [ # # ]: 0 : wallet.WalletLogPrintf("CWalletTx::GetAmounts: Unknown transaction type found, txid %s\n",
234 [ # # # # ]: 0 : wtx.GetHash().ToString());
235 : 0 : address = CNoDestination();
236 : : }
237 : :
238 [ + - ]: 1967 : COutputEntry output = {address, txout.nValue, (int)i};
239 : :
240 : : // If we are debited by the transaction, add the output as a "sent" entry
241 [ + + ]: 1967 : if (nDebit > 0)
242 [ + - ]: 659 : listSent.push_back(output);
243 : :
244 : : // If we are receiving the output, add it as a "received" entry
245 [ + + ]: 1967 : if (fIsMine & filter)
246 [ + - ]: 1513 : listReceived.push_back(output);
247 : 1967 : }
248 : :
249 : 1847 : }
250 : :
251 : 509262 : bool CachedTxIsFromMe(const CWallet& wallet, const CWalletTx& wtx, const isminefilter& filter)
252 : : {
253 : 509262 : return (CachedTxGetDebit(wallet, wtx, filter) > 0);
254 : : }
255 : :
256 : : // NOLINTNEXTLINE(misc-no-recursion)
257 : 591424 : bool CachedTxIsTrusted(const CWallet& wallet, const CWalletTx& wtx, std::set<uint256>& trusted_parents)
258 : : {
259 : 591424 : AssertLockHeld(wallet.cs_wallet);
260 [ + + ]: 591424 : if (wtx.isConfirmed()) return true;
261 [ + + ]: 89901 : if (wtx.isBlockConflicted()) return false;
262 : : // using wtx's cached debit
263 [ + + + + ]: 89828 : if (!wallet.m_spend_zero_conf_change || !CachedTxIsFromMe(wallet, wtx, ISMINE_ALL)) return false;
264 : :
265 : : // Don't trust unconfirmed transactions from us unless they are in the mempool.
266 [ + + ]: 87056 : if (!wtx.InMempool()) return false;
267 : :
268 : : // Trusted if all inputs are from us and are in the mempool:
269 [ + + ]: 179973 : for (const CTxIn& txin : wtx.tx->vin)
270 : : {
271 : : // Transactions not sent by us: not trusted
272 : 93371 : const CWalletTx* parent = wallet.GetWalletTx(txin.prevout.hash);
273 [ + + ]: 93371 : if (parent == nullptr) return false;
274 : 93362 : const CTxOut& parentOut = parent->tx->vout[txin.prevout.n];
275 : : // Check that this specific input being spent is trusted
276 [ + + ]: 93362 : if (wallet.IsMine(parentOut) != ISMINE_SPENDABLE) return false;
277 : : // If we've already trusted this parent, continue
278 [ + + ]: 93356 : if (trusted_parents.count(parent->GetHash())) continue;
279 : : // Recurse to check that the parent is also trusted
280 [ + + ]: 74950 : if (!CachedTxIsTrusted(wallet, *parent, trusted_parents)) return false;
281 : 74606 : trusted_parents.insert(parent->GetHash());
282 : : }
283 : : return true;
284 : : }
285 : :
286 : 624 : bool CachedTxIsTrusted(const CWallet& wallet, const CWalletTx& wtx)
287 : : {
288 [ + - ]: 624 : std::set<uint256> trusted_parents;
289 [ + - ]: 624 : LOCK(wallet.cs_wallet);
290 [ + - + - ]: 624 : return CachedTxIsTrusted(wallet, wtx, trusted_parents);
291 : 624 : }
292 : :
293 : 1556 : Balance GetBalance(const CWallet& wallet, const int min_depth, bool avoid_reuse)
294 : : {
295 : 1556 : Balance ret;
296 [ + + ]: 1556 : isminefilter reuse_filter = avoid_reuse ? ISMINE_NO : ISMINE_USED;
297 : 1556 : {
298 : 1556 : LOCK(wallet.cs_wallet);
299 : 1556 : std::set<uint256> trusted_parents;
300 [ + + ]: 94534 : for (const auto& entry : wallet.mapWallet)
301 : : {
302 : 92978 : const CWalletTx& wtx = entry.second;
303 [ + - ]: 92978 : const bool is_trusted{CachedTxIsTrusted(wallet, wtx, trusted_parents)};
304 [ + - ]: 92978 : const int tx_depth{wallet.GetTxDepthInMainChain(wtx)};
305 [ + - ]: 92978 : const CAmount tx_credit_mine{CachedTxGetAvailableCredit(wallet, wtx, ISMINE_SPENDABLE | reuse_filter)};
306 [ + - ]: 92978 : const CAmount tx_credit_watchonly{CachedTxGetAvailableCredit(wallet, wtx, ISMINE_WATCH_ONLY | reuse_filter)};
307 [ + + ]: 92978 : if (is_trusted && tx_depth >= min_depth) {
308 : 92336 : ret.m_mine_trusted += tx_credit_mine;
309 : 92336 : ret.m_watchonly_trusted += tx_credit_watchonly;
310 : : }
311 [ + + + - : 92978 : if (!is_trusted && tx_depth == 0 && wtx.InMempool()) {
+ + ]
312 : 438 : ret.m_mine_untrusted_pending += tx_credit_mine;
313 : 438 : ret.m_watchonly_untrusted_pending += tx_credit_watchonly;
314 : : }
315 [ + - ]: 92978 : ret.m_mine_immature += CachedTxGetImmatureCredit(wallet, wtx, ISMINE_SPENDABLE);
316 [ + - ]: 92978 : ret.m_watchonly_immature += CachedTxGetImmatureCredit(wallet, wtx, ISMINE_WATCH_ONLY);
317 : : }
318 [ + - ]: 1556 : }
319 : 1556 : return ret;
320 : : }
321 : :
322 : 2 : std::map<CTxDestination, CAmount> GetAddressBalances(const CWallet& wallet)
323 : : {
324 [ + - ]: 2 : std::map<CTxDestination, CAmount> balances;
325 : :
326 : 2 : {
327 [ + - ]: 2 : LOCK(wallet.cs_wallet);
328 : 2 : std::set<uint256> trusted_parents;
329 [ + + ]: 207 : for (const auto& walletEntry : wallet.mapWallet)
330 : : {
331 : 205 : const CWalletTx& wtx = walletEntry.second;
332 : :
333 [ + - - + ]: 205 : if (!CachedTxIsTrusted(wallet, wtx, trusted_parents))
334 : 0 : continue;
335 : :
336 [ + - + + ]: 205 : if (wallet.IsTxImmatureCoinBase(wtx))
337 : 200 : continue;
338 : :
339 [ + - ]: 5 : int nDepth = wallet.GetTxDepthInMainChain(wtx);
340 [ + - + + : 9 : if (nDepth < (CachedTxIsFromMe(wallet, wtx, ISMINE_ALL) ? 0 : 1))
+ - ]
341 : 0 : continue;
342 : :
343 [ + + ]: 14 : for (unsigned int i = 0; i < wtx.tx->vout.size(); i++) {
344 [ + - ]: 9 : const auto& output = wtx.tx->vout[i];
345 : 9 : CTxDestination addr;
346 [ + - + + ]: 9 : if (!wallet.IsMine(output))
347 : 5 : continue;
348 [ + - - + ]: 4 : if(!ExtractDestination(output.scriptPubKey, addr))
349 : 0 : continue;
350 : :
351 [ + - + + ]: 4 : CAmount n = wallet.IsSpent(COutPoint(Txid::FromUint256(walletEntry.first), i)) ? 0 : output.nValue;
352 [ + - ]: 4 : balances[addr] += n;
353 : 9 : }
354 : : }
355 [ + - ]: 2 : }
356 : :
357 : 2 : return balances;
358 : 0 : }
359 : :
360 : 2 : std::set< std::set<CTxDestination> > GetAddressGroupings(const CWallet& wallet)
361 : : {
362 : 2 : AssertLockHeld(wallet.cs_wallet);
363 : 2 : std::set< std::set<CTxDestination> > groupings;
364 : 2 : std::set<CTxDestination> grouping;
365 : :
366 [ + + ]: 207 : for (const auto& walletEntry : wallet.mapWallet)
367 : : {
368 : 205 : const CWalletTx& wtx = walletEntry.second;
369 : :
370 [ + - ]: 205 : if (wtx.tx->vin.size() > 0)
371 : : {
372 : 205 : bool any_mine = false;
373 : : // group all input addresses with each other
374 [ + + ]: 411 : for (const CTxIn& txin : wtx.tx->vin)
375 : : {
376 : 206 : CTxDestination address;
377 [ + - + + ]: 206 : if(!InputIsMine(wallet, txin)) /* If this input isn't mine, ignore it */
378 : 204 : continue;
379 [ + - + - : 2 : if(!ExtractDestination(wallet.mapWallet.at(txin.prevout.hash).tx->vout[txin.prevout.n].scriptPubKey, address))
- + ]
380 : 0 : continue;
381 [ + - ]: 2 : grouping.insert(address);
382 : 2 : any_mine = true;
383 : 206 : }
384 : :
385 : : // group change with input addresses
386 [ + + ]: 205 : if (any_mine)
387 : : {
388 [ + + ]: 2 : for (const CTxOut& txout : wtx.tx->vout)
389 [ + - - + ]: 1 : if (OutputIsChange(wallet, txout))
390 : : {
391 : 0 : CTxDestination txoutAddr;
392 [ # # # # ]: 0 : if(!ExtractDestination(txout.scriptPubKey, txoutAddr))
393 : 0 : continue;
394 [ # # ]: 0 : grouping.insert(txoutAddr);
395 : 0 : }
396 : : }
397 [ + + ]: 205 : if (grouping.size() > 0)
398 : : {
399 [ + - ]: 1 : groupings.insert(grouping);
400 : 1 : grouping.clear();
401 : : }
402 : : }
403 : :
404 : : // group lone addrs by themselves
405 [ + + ]: 614 : for (const auto& txout : wtx.tx->vout)
406 [ + - + + ]: 409 : if (wallet.IsMine(txout))
407 : : {
408 : 204 : CTxDestination address;
409 [ + - - + ]: 204 : if(!ExtractDestination(txout.scriptPubKey, address))
410 : 0 : continue;
411 [ + - ]: 204 : grouping.insert(address);
412 [ + - ]: 204 : groupings.insert(grouping);
413 : 204 : grouping.clear();
414 : 204 : }
415 : : }
416 : :
417 : 2 : std::set< std::set<CTxDestination>* > uniqueGroupings; // a set of pointers to groups of addresses
418 : 2 : std::map< CTxDestination, std::set<CTxDestination>* > setmap; // map addresses to the unique group containing it
419 [ + + ]: 7 : for (const std::set<CTxDestination>& _grouping : groupings)
420 : : {
421 : : // make a set of all the groups hit by this new group
422 : 5 : std::set< std::set<CTxDestination>* > hits;
423 : 5 : std::map< CTxDestination, std::set<CTxDestination>* >::iterator it;
424 [ + + ]: 11 : for (const CTxDestination& address : _grouping)
425 [ + + ]: 6 : if ((it = setmap.find(address)) != setmap.end())
426 [ + - ]: 2 : hits.insert((*it).second);
427 : :
428 : : // merge all hit groups into a new single group and delete old groups
429 [ + - + - ]: 5 : std::set<CTxDestination>* merged = new std::set<CTxDestination>(_grouping);
430 [ + + ]: 7 : for (std::set<CTxDestination>* hit : hits)
431 : : {
432 [ + - ]: 2 : merged->insert(hit->begin(), hit->end());
433 : 2 : uniqueGroupings.erase(hit);
434 [ + - ]: 4 : delete hit;
435 : : }
436 [ + - ]: 5 : uniqueGroupings.insert(merged);
437 : :
438 : : // update setmap
439 [ + + ]: 12 : for (const CTxDestination& element : *merged)
440 [ + - ]: 7 : setmap[element] = merged;
441 : 5 : }
442 : :
443 : 2 : std::set< std::set<CTxDestination> > ret;
444 [ + + ]: 5 : for (const std::set<CTxDestination>* uniqueGrouping : uniqueGroupings)
445 : : {
446 [ + - ]: 3 : ret.insert(*uniqueGrouping);
447 [ + - ]: 6 : delete uniqueGrouping;
448 : : }
449 : :
450 : 2 : return ret;
451 : 2 : }
452 : : } // namespace wallet
|
