251        std::set<Txid> trusted_parents;
252        for (const auto& [outpoint, txo] : wallet.GetTXOs()) {
253            const CWalletTx& wtx = txo.GetWalletTx();
254
255            const bool is_trusted{CachedTxIsTrusted(wallet, wtx, trusted_parents)};
256            const int tx_depth{wallet.GetTxDepthInMainChain(wtx)};
257
258            bool nonmempool_spent = false;
259            switch (wallet.HowSpent(outpoint)) {
260            case CWallet::SpendType::CONFIRMED:
261            case CWallet::SpendType::MEMPOOL:
262                // treat as spent; ignore
263                break;
264            case CWallet::SpendType::NONMEMPOOL:
265                if (!include_nonmempool) break;
266                nonmempool_spent = true;
267                [[fallthrough]];
268            case CWallet::SpendType::UNSPENT:
269                CAmount* bucket = nullptr;
270
271                // Set the amounts in the return object
272                if (wallet.IsTxImmatureCoinBase(wtx) && wtx.isConfirmed()) {
273                    bucket = &ret.m_mine_immature;
274                } else if (is_trusted && tx_depth >= min_depth) {
275                    bucket = &ret.m_mine_trusted;
276                } else if (!is_trusted && wtx.InMempool()) {
277                    bucket = &ret.m_mine_untrusted_pending;
278                }
279                if (bucket) {
280                    // Get the amounts for mine
281                    CAmount credit_mine = txo.GetTxOut().nValue;
282
283                    if (!allow_used_addresses && wallet.IsSpentKey(txo.GetTxOut().scriptPubKey)) {
284                        bucket = &ret.m_mine_used;
285                    }
286                    *bucket += credit_mine;
287                    if (nonmempool_spent) {
288                        ret.m_mine_nonmempool -= credit_mine;
289                    }
290                }
291            }
292        }
293    }
294    return ret;
295}
296
297std::map<CTxDestination, CAmount> GetAddressBalances(const CWallet& wallet)
298{
299    std::map<CTxDestination, CAmount> balances;
300
301    {
302        LOCK(wallet.cs_wallet);
303        std::set<Txid> trusted_parents;
304        for (const auto& [outpoint, txo] : wallet.GetTXOs()) {
305            const CWalletTx& wtx = txo.GetWalletTx();
306
307            if (!CachedTxIsTrusted(wallet, wtx, trusted_parents)) continue;
308            if (wallet.IsTxImmatureCoinBase(wtx)) continue;
309
310            int nDepth = wallet.GetTxDepthInMainChain(wtx);
311            if (nDepth < (CachedTxIsFromMe(wallet, wtx) ? 0 : 1)) continue;
312
313            CTxDestination addr;
314            Assume(wallet.IsMine(txo.GetTxOut()));
315            if(!ExtractDestination(txo.GetTxOut().scriptPubKey, addr)) continue;
316
317            CAmount n = wallet.IsSpent(outpoint) ? 0 : txo.GetTxOut().nValue;
318            balances[addr] += n;
319        }
320    }
321
322    return balances;
323}
324
325std::set< std::set<CTxDestination> > GetAddressGroupings(const CWallet& wallet)
326{
327    AssertLockHeld(wallet.cs_wallet);
328    std::set< std::set<CTxDestination> > groupings;
329    std::set<CTxDestination> grouping;
330
331    for (const auto& walletEntry : wallet.mapWallet)
332    {
333        const CWalletTx& wtx = walletEntry.second;
334
335        if (wtx.GetTx()->vin.size() > 0)
336        {
337            bool any_mine = false;
338            // group all input addresses with each other
339            for (const CTxIn& txin : wtx.GetTx()->vin)
340            {
341                CTxDestination address;
342                if(!InputIsMine(wallet, txin)) /* If this input isn't mine, ignore it */
343                    continue;
344                if(!ExtractDestination(wallet.mapWallet.at(txin.prevout.hash).GetTx()->vout[txin.prevout.n].scriptPubKey, address))
345                    continue;
346                grouping.insert(address);
347                any_mine = true;
348            }
349
350            // group change with input addresses
351            if (any_mine)
352            {
353               for (const CTxOut& txout : wtx.GetTx()->vout)
354                   if (OutputIsChange(wallet, txout))
355                   {
356                       CTxDestination txoutAddr;
357                       if(!ExtractDestination(txout.scriptPubKey, txoutAddr))
358                           continue;
359                       grouping.insert(txoutAddr);
360                   }
361            }
362            if (grouping.size() > 0)
363            {
364                groupings.insert(grouping);
365                grouping.clear();
366            }
367        }
368
369        // group lone addrs by themselves
370        for (const auto& txout : wtx.GetTx()->vout)
371            if (wallet.IsMine(txout))
372            {
373                CTxDestination address;
374                if(!ExtractDestination(txout.scriptPubKey, address))
375                    continue;
376                grouping.insert(address);
377                groupings.insert(grouping);
378                grouping.clear();
379            }
380    }
381
382    std::set< std::set<CTxDestination>* > uniqueGroupings; // a set of pointers to groups of addresses
383    std::map< CTxDestination, std::set<CTxDestination>* > setmap;  // map addresses to the unique group containing it
384    for (const std::set<CTxDestination>& _grouping : groupings)
385    {
386        // make a set of all the groups hit by this new group
387        std::set< std::set<CTxDestination>* > hits;
388        std::map< CTxDestination, std::set<CTxDestination>* >::iterator it;
389        for (const CTxDestination& address : _grouping)
390            if ((it = setmap.find(address)) != setmap.end())
391                hits.insert((*it).second);
392
393        // merge all hit groups into a new single group and delete old groups
394        std::set<CTxDestination>* merged = new std::set<CTxDestination>(_grouping);
395        for (std::set<CTxDestination>* hit : hits)
396        {
397            merged->insert(hit->begin(), hit->end());
398            uniqueGroupings.erase(hit);
399            delete hit;
400        }
401        uniqueGroupings.insert(merged);
402
403        // update setmap
404        for (const CTxDestination& element : *merged)
405            setmap[element] = merged;
406    }
407
408    std::set< std::set<CTxDestination> > ret;
409    for (const std::set<CTxDestination>* uniqueGrouping : uniqueGroupings)
410    {
411        ret.insert(*uniqueGrouping);
412        delete uniqueGrouping;
413    }
414
415    return ret;
416}
417} // namespace wallet
418