The wallet state and lifecycle

1501void CWallet::transactionRemovedFromMempool(const CTransactionRef& tx, MemPoolRemovalReason reason) {
1502    LOCK(cs_wallet);
1503    auto it = mapWallet.find(tx->GetHash());
1504    if (it != mapWallet.end()) {
1505        RefreshMempoolStatus(it->second, chain());
1506    }
1507    // Handle transactions that were removed from the mempool because they
1508    // conflict with transactions in a newly connected block.
1509    if (reason == MemPoolRemovalReason::CONFLICT) {
1510        // Trigger external -walletnotify notifications for these transactions.
1511        // Set Status::UNCONFIRMED instead of Status::CONFLICTED for a few reasons:
1512        //
1513        // 1. The transactionRemovedFromMempool callback does not currently
1514        //    provide the conflicting block's hash and height, and for backwards
1515        //    compatibility reasons it may not be not safe to store conflicted
1516        //    wallet transactions with a null block hash. See
1517        //    https://github.com/bitcoin/bitcoin/pull/18600#discussion_r420195993.
1518        // 2. For most of these transactions, the wallet's internal conflict
1519        //    detection in the blockConnected handler will subsequently call
1520        //    MarkConflicted and update them with CONFLICTED status anyway. This
1521        //    applies to any wallet transaction that has inputs spent in the
1522        //    block, or that has ancestors in the wallet with inputs spent by
1523        //    the block.
1524        // 3. Longstanding behavior since the sync implementation in
1525        //    https://github.com/bitcoin/bitcoin/pull/9371 and the prior sync
1526        //    implementation before that was to mark these transactions
1527        //    unconfirmed rather than conflicted.
1528        //
1529        // Nothing described above should be seen as an unchangeable requirement
1530        // when improving this code in the future. The wallet's heuristics for
1531        // distinguishing between conflicted and unconfirmed transactions are
1532        // imperfect, and could be improved in general, see
1533        // https://github.com/bitcoin-core/bitcoin-devwiki/wiki/Wallet-Transaction-Conflict-Tracking
1534        SyncTransaction(tx, TxStateInactive{});
1535    }
1536
1537    const Txid& txid = tx->GetHash();
1538
1539    for (const CTxIn& tx_in : tx->vin) {
1540        // Iterate over all wallet transactions spending txin.prev
1541        // and recursively mark them as no longer conflicting with
1542        // txid
1543        for (auto range = mapTxSpends.equal_range(tx_in.prevout); range.first != range.second; range.first++) {
1544            const Txid& spent_id = range.first->second;
1545
1546            RecursiveUpdateTxState(/*batch=*/nullptr, spent_id, [&txid](CWalletTx& wtx) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
1547                return wtx.mempool_conflicts.erase(txid) ? TxUpdate::CHANGED : TxUpdate::UNCHANGED;
1548            });
1549        }
1550    }
1551
1552    if (tx->version == TRUC_VERSION) {
1553        // If this tx has a parent, unset its truc_child_in_mempool to make it possible
1554        // to spend from the parent again. If this tx was replaced by another
1555        // child of the same parent, transactionAddedToMempool
1556        // will update truc_child_in_mempool
1557        for (const CTxIn& tx_in : tx->vin) {
1558            auto parent_it = mapWallet.find(tx_in.prevout.hash);
1559            if (parent_it != mapWallet.end()) {
1560                CWalletTx& parent_wtx = parent_it->second;
1561                if (parent_wtx.truc_child_in_mempool == tx->GetHash()) {
1562                    parent_wtx.truc_child_in_mempool = std::nullopt;
1563                    UpdateTrucSiblingConflicts(parent_wtx, txid, /*add_conflict=*/false);
1564                }
1565            }
1566        }
1567    }
1568}
1569
1570void CWallet::blockConnected(const ChainstateRole& role, const interfaces::BlockInfo& block)
1571{
1572    if (role.historical) {
1573        return;
1574    }
1575    assert(block.data);
1576    LOCK(cs_wallet);
1577
1578    // Update the best block in memory first. This will set the best block's height, which is
1579    // needed by MarkConflicted.
1580    SetLastBlockProcessedInMem(block.height, block.hash);
1581
1582    // No need to scan block if it was created before the wallet birthday.
1583    // Uses chain max time and twice the grace period to adjust time for block time variability.
1584    if (block.chain_time_max < m_birth_time.load() - (TIMESTAMP_WINDOW * 2)) return;
1585
1586    // Scan block
1587    bool wallet_updated = false;
1588    for (size_t index = 0; index < block.data->vtx.size(); index++) {
1589        wallet_updated |= SyncTransaction(block.data->vtx[index], TxStateConfirmed{block.hash, block.height, static_cast<int>(index)});
1590        transactionRemovedFromMempool(block.data->vtx[index], MemPoolRemovalReason::BLOCK);
1591    }
1592
1593    // Update on disk if this block resulted in us updating a tx, or periodically every 144 blocks (~1 day)
1594    if (wallet_updated || block.height % 144 == 0) {
1595        WriteBestBlock();
1596    }
1597}
1598
1599void CWallet::blockDisconnected(const interfaces::BlockInfo& block)
1600{
1601    assert(block.data);
1602    LOCK(cs_wallet);
1603
1604    // At block disconnection, this will change an abandoned transaction to
1605    // be unconfirmed, whether or not the transaction is added back to the mempool.
1606    // User may have to call abandontransaction again. It may be addressed in the
1607    // future with a stickier abandoned state or even removing abandontransaction call.
1608    int disconnect_height = block.height;
1609
1610    for (size_t index = 0; index < block.data->vtx.size(); index++) {
1611        const CTransactionRef& ptx = block.data->vtx[index];
1612        // Coinbase transactions are not only inactive but also abandoned,
1613        // meaning they should never be relayed standalone via the p2p protocol.
1614        SyncTransaction(ptx, TxStateInactive{/*abandoned=*/index == 0});
1615
1616        for (const CTxIn& tx_in : ptx->vin) {
1617            // No other wallet transactions conflicted with this transaction
1618            if (!mapTxSpends.contains(tx_in.prevout)) continue;
1619
1620            std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range = mapTxSpends.equal_range(tx_in.prevout);
1621
1622            // For all of the spends that conflict with this transaction
1623            for (TxSpends::const_iterator _it = range.first; _it != range.second; ++_it) {
1624                CWalletTx& wtx = mapWallet.find(_it->second)->second;
1625
1626                if (!wtx.isBlockConflicted()) continue;
1627
1628                auto try_updating_state = [&](CWalletTx& tx) {
1629                    if (!tx.isBlockConflicted()) return TxUpdate::UNCHANGED;
1630                    if (tx.state<TxStateBlockConflicted>()->conflicting_block_height >= disconnect_height) {
1631                        tx.m_state = TxStateInactive{};
1632                        return TxUpdate::CHANGED;
1633                    }
1634                    return TxUpdate::UNCHANGED;
1635                };
1636
1637                RecursiveUpdateTxState(wtx.GetTx()->GetHash(), try_updating_state);
1638            }
1639        }
1640    }
1641
1642    // Update the best block
1643    SetLastBlockProcessed(block.height - 1, *Assert(block.prev_hash));
1644}
1645
1646void CWallet::updatedBlockTip()
1647{
1648    m_best_block_time = GetTime();
1649}
1650
1651void CWallet::BlockUntilSyncedToCurrentChain() const {
1652    AssertLockNotHeld(cs_wallet);
1653    // Skip the queue-draining stuff if we know we're caught up with
1654    // chain().Tip(), otherwise put a callback in the validation interface queue and wait
1655    // for the queue to drain enough to execute it (indicating we are caught up
1656    // at least with the time we entered this function).
1657    uint256 last_block_hash = WITH_LOCK(cs_wallet, return m_last_block_processed);
1658    chain().waitForNotificationsIfTipChanged(last_block_hash);
1659}
1660
1661// Note that this function doesn't distinguish between a 0-valued input,
1662// and a not-"is mine" input.
1663CAmount CWallet::GetDebit(const CTxIn &txin) const
1664{
1665    LOCK(cs_wallet);
1666    auto txo = GetTXO(txin.prevout);
1667    if (txo) {
1668        return txo->GetTxOut().nValue;
1669    }
1670    return 0;
1671}
1672
1673bool CWallet::IsMine(const CTxOut& txout) const
1674{
1675    AssertLockHeld(cs_wallet);
1676    return IsMine(txout.scriptPubKey);
1677}
1678
1679bool CWallet::IsMine(const CTxDestination& dest) const
1680{
1681    AssertLockHeld(cs_wallet);
1682    return IsMine(GetScriptForDestination(dest));
1683}
1684
1685bool CWallet::IsMine(const CScript& script) const
1686{
1687    AssertLockHeld(cs_wallet);
1688
1689    // Search the cache so that IsMine is called only on the relevant SPKMs instead of on everything in m_spk_managers
1690    const auto& it = m_cached_spks.find(script);
1691    if (it != m_cached_spks.end()) {
1692        bool res = false;
1693        for (const auto& spkm : it->second) {
1694            res = res || spkm->IsMine(script);
1695        }
1696        Assume(res);
1697        return res;
1698    }
1699
1700    return false;
1701}
1702
1703bool CWallet::IsMine(const CTransaction& tx) const
1704{
1705    AssertLockHeld(cs_wallet);
1706    for (const CTxOut& txout : tx.vout)
1707        if (IsMine(txout))
1708            return true;
1709    return false;
1710}
1711
1712bool CWallet::IsMine(const COutPoint& outpoint) const
1713{
1714    AssertLockHeld(cs_wallet);
1715    auto wtx = GetWalletTx(outpoint.hash);
1716    if (!wtx) {
1717        return false;
1718    }
1719    if (outpoint.n >= wtx->GetTx()->vout.size()) {
1720        return false;
1721    }
1722    return IsMine(wtx->GetTx()->vout[outpoint.n]);
1723}
1724
1725bool CWallet::IsFromMe(const CTransaction& tx) const
1726{
1727    LOCK(cs_wallet);
1728    for (const CTxIn& txin : tx.vin) {
1729        if (GetTXO(txin.prevout)) return true;
1730    }
1731    return false;
1732}
1733
1734CAmount CWallet::GetDebit(const CTransaction& tx) const
1735{
1736    CAmount nDebit = 0;
1737    for (const CTxIn& txin : tx.vin)
1738    {
1739        nDebit += GetDebit(txin);
1740        if (!MoneyRange(nDebit))
1741            throw std::runtime_error(std::string(__func__) + ": value out of range");
1742    }
1743    return nDebit;
1744}
1745
1746bool CWallet::IsHDEnabled() const
1747{
1748    // All Active ScriptPubKeyMans must be HD for this to be true
1749    bool result = false;
1750    for (const auto& spk_man : GetActiveScriptPubKeyMans()) {