The wallet state and lifecycle

1251            }
1252        }
1253
1254        bool fExisted = mapWallet.contains(tx.GetHash());
1255        if (fExisted || IsMine(tx) || IsFromMe(tx))
1256        {
1257            /* Check if any keys in the wallet keypool that were supposed to be unused
1258             * have appeared in a new transaction. If so, remove those keys from the keypool.
1259             * This can happen when restoring an old wallet backup that does not contain
1260             * the mostly recently created transactions from newer versions of the wallet.
1261             */
1262
1263            // loop though all outputs
1264            for (const CTxOut& txout: tx.vout) {
1265                for (const auto& spk_man : GetScriptPubKeyMans(txout.scriptPubKey)) {
1266                    for (auto &dest : spk_man->MarkUnusedAddresses(txout.scriptPubKey)) {
1267                        // If internal flag is not defined try to infer it from the ScriptPubKeyMan
1268                        if (!dest.internal.has_value()) {
1269                            dest.internal = IsInternalScriptPubKeyMan(spk_man);
1270                        }
1271
1272                        // skip if can't determine whether it's a receiving address or not
1273                        if (!dest.internal.has_value()) continue;
1274
1275                        // If this is a receiving address and it's not in the address book yet
1276                        // (e.g. it wasn't generated on this node or we're restoring from backup)
1277                        // add it to the address book for proper transaction accounting
1278                        if (!*dest.internal && !FindAddressBookEntry(dest.dest, /* allow_change= */ false)) {
1279                            SetAddressBook(dest.dest, "", AddressPurpose::RECEIVE);
1280                        }
1281                    }
1282                }
1283            }
1284
1285            // Block disconnection override an abandoned tx as unconfirmed
1286            // which means user may have to call abandontransaction again
1287            TxState tx_state = std::visit([](auto&& s) -> TxState { return s; }, state);
1288            CWalletTx* wtx = AddToWallet(MakeTransactionRef(tx), tx_state, /*update_wtx=*/nullptr, rescanning_old_block);
1289            if (!wtx) {
1290                // Can only be nullptr if there was a db write error (missing db, read-only db or a db engine internal writing error).
1291                // As we only store arriving transaction in this process, and we don't want an inconsistent state, let's throw an error.
1292                throw std::runtime_error("DB error adding transaction to wallet, write failed");
1293            }
1294            return true;
1295        }
1296    }
1297    return false;
1298}
1299
1300bool CWallet::TransactionCanBeAbandoned(const Txid& hashTx) const
1301{
1302    LOCK(cs_wallet);
1303    const CWalletTx* wtx = GetWalletTx(hashTx);
1304    return wtx && !wtx->isAbandoned() && GetTxDepthInMainChain(*wtx) == 0 && !wtx->InMempool();
1305}
1306
1307void CWallet::UpdateTrucSiblingConflicts(const CWalletTx& parent_wtx, const Txid& child_txid, bool add_conflict) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
1308{
1309    // Find all other txs in our wallet that spend utxos from this parent
1310    // so that we can mark them as mempool-conflicted by this new tx.
1311    for (long unsigned int i = 0; i < parent_wtx.GetTx()->vout.size(); i++) {
1312        for (auto range = mapTxSpends.equal_range(COutPoint(parent_wtx.GetTx()->GetHash(), i)); range.first != range.second; range.first++) {
1313            const Txid& sibling_txid = range.first->second;
1314            // Skip the child_tx itself
1315            if (sibling_txid == child_txid) continue;
1316            RecursiveUpdateTxState(/*batch=*/nullptr, sibling_txid, [&child_txid, add_conflict](CWalletTx& wtx) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
1317                return add_conflict ? (wtx.mempool_conflicts.insert(child_txid).second ? TxUpdate::CHANGED : TxUpdate::UNCHANGED)
1318                                    : (wtx.mempool_conflicts.erase(child_txid) ? TxUpdate::CHANGED : TxUpdate::UNCHANGED);
1319            });
1320        }
1321    }
1322}
1323
1324void CWallet::MarkInputsDirty(const CTransactionRef& tx)
1325{
1326    for (const CTxIn& txin : tx->vin) {
1327        auto it = mapWallet.find(txin.prevout.hash);
1328        if (it != mapWallet.end()) {
1329            it->second.MarkDirty();
1330        }
1331    }
1332}
1333
1334bool CWallet::AbandonTransaction(const Txid& hashTx)
1335{
1336    LOCK(cs_wallet);
1337    auto it = mapWallet.find(hashTx);
1338    assert(it != mapWallet.end());
1339    return AbandonTransaction(it->second);
1340}
1341
1342bool CWallet::AbandonTransaction(CWalletTx& tx)
1343{
1344    // Can't mark abandoned if confirmed or in mempool
1345    if (GetTxDepthInMainChain(tx) != 0 || tx.InMempool()) {
1346        return false;
1347    }
1348
1349    auto try_updating_state = [](CWalletTx& wtx) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
1350        // If the orig tx was not in block/mempool, none of its spends can be.
1351        assert(!wtx.isConfirmed());
1352        assert(!wtx.InMempool());
1353        // If already conflicted or abandoned, no need to set abandoned
1354        if (!wtx.isBlockConflicted() && !wtx.isAbandoned()) {
1355            wtx.m_state = TxStateInactive{/*abandoned=*/true};
1356            return TxUpdate::NOTIFY_CHANGED;
1357        }
1358        return TxUpdate::UNCHANGED;
1359    };
1360
1361    // Iterate over all its outputs, and mark transactions in the wallet that spend them abandoned too.
1362    // States are not permanent, so these transactions can become unabandoned if they are re-added to the
1363    // mempool, or confirmed in a block, or conflicted.
1364    // Note: If the reorged coinbase is re-added to the main chain, the descendants that have not had their
1365    // states change will remain abandoned and will require manual broadcast if the user wants them.
1366
1367    RecursiveUpdateTxState(tx.GetHash(), try_updating_state);
1368
1369    return true;
1370}
1371
1372void CWallet::MarkConflicted(const uint256& hashBlock, int conflicting_height, const Txid& hashTx)
1373{
1374    LOCK(cs_wallet);
1375
1376    // If number of conflict confirms cannot be determined, this means
1377    // that the block is still unknown or not yet part of the main chain,
1378    // for example when loading the wallet during a reindex. Do nothing in that
1379    // case.
1380    if (m_last_block_processed_height < 0 || conflicting_height < 0) {
1381        return;
1382    }
1383    int conflictconfirms = (m_last_block_processed_height - conflicting_height + 1) * -1;
1384    if (conflictconfirms >= 0)
1385        return;
1386
1387    auto try_updating_state = [&](CWalletTx& wtx) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
1388        if (conflictconfirms < GetTxDepthInMainChain(wtx)) {
1389            // Block is 'more conflicted' than current confirm; update.
1390            // Mark transaction as conflicted with this block.
1391            wtx.m_state = TxStateBlockConflicted{hashBlock, conflicting_height};
1392            return TxUpdate::CHANGED;
1393        }
1394        return TxUpdate::UNCHANGED;
1395    };
1396
1397    // Iterate over all its outputs, and mark transactions in the wallet that spend them conflicted too.
1398    RecursiveUpdateTxState(hashTx, try_updating_state);
1399
1400}
1401
1402void CWallet::RecursiveUpdateTxState(const Txid& tx_hash, const TryUpdatingStateFn& try_updating_state) {
1403    WalletBatch batch(GetDatabase());
1404    RecursiveUpdateTxState(&batch, tx_hash, try_updating_state);
1405}
1406
1407void CWallet::RecursiveUpdateTxState(WalletBatch* batch, const Txid& tx_hash, const TryUpdatingStateFn& try_updating_state) {
1408    std::set<Txid> todo;
1409    std::set<Txid> done;
1410
1411    todo.insert(tx_hash);
1412
1413    while (!todo.empty()) {
1414        Txid now = *todo.begin();
1415        todo.erase(now);
1416        done.insert(now);
1417        auto it = mapWallet.find(now);
1418        assert(it != mapWallet.end());
1419        CWalletTx& wtx = it->second;
1420
1421        TxUpdate update_state = try_updating_state(wtx);
1422        if (update_state != TxUpdate::UNCHANGED) {
1423            wtx.MarkDirty();
1424            if (batch) batch->WriteTxMetadata(wtx);
1425            // Iterate over all its outputs, and update those tx states as well (if applicable)
1426            for (unsigned int i = 0; i < wtx.GetTx()->vout.size(); ++i) {
1427                std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range = mapTxSpends.equal_range(COutPoint(now, i));
1428                for (TxSpends::const_iterator iter = range.first; iter != range.second; ++iter) {
1429                    if (!done.contains(iter->second)) {
1430                        todo.insert(iter->second);
1431                    }
1432                }
1433            }
1434
1435            if (update_state == TxUpdate::NOTIFY_CHANGED) {
1436                NotifyTransactionChanged(wtx.GetHash(), CT_UPDATED);
1437            }
1438
1439            // If a transaction changes its tx state, that usually changes the balance
1440            // available of the outputs it spends. So force those to be recomputed
1441            MarkInputsDirty(wtx.GetTx());
1442        }
1443    }
1444}
1445
1446bool CWallet::SyncTransaction(const CTransactionRef& ptx, const SyncTxState& state, bool rescanning_old_block)
1447{
1448    if (!AddToWalletIfInvolvingMe(ptx, state, rescanning_old_block))
1449        return false; // Not one of ours
1450
1451    // If a transaction changes 'conflicted' state, that changes the balance
1452    // available of the outputs it spends. So force those to be
1453    // recomputed, also:
1454    MarkInputsDirty(ptx);
1455    return true;
1456}
1457
1458void CWallet::transactionAddedToMempool(const CTransactionRef& tx) {
1459    LOCK(cs_wallet);
1460    SyncTransaction(tx, TxStateInMempool{});
1461
1462    auto it = mapWallet.find(tx->GetHash());
1463    if (it != mapWallet.end()) {
1464        RefreshMempoolStatus(it->second, chain());
1465    }
1466
1467    const Txid& txid = tx->GetHash();
1468
1469    for (const CTxIn& tx_in : tx->vin) {
1470        // For each wallet transaction spending this prevout..
1471        for (auto range = mapTxSpends.equal_range(tx_in.prevout); range.first != range.second; range.first++) {
1472            const Txid& spent_id = range.first->second;
1473            // Skip the recently added tx
1474            if (spent_id == txid) continue;
1475            RecursiveUpdateTxState(/*batch=*/nullptr, spent_id, [&txid](CWalletTx& wtx) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
1476                return wtx.mempool_conflicts.insert(txid).second ? TxUpdate::CHANGED : TxUpdate::UNCHANGED;
1477            });
1478        }
1479
1480    }
1481
1482    if (tx->version == TRUC_VERSION) {
1483        // Unconfirmed TRUC transactions are only allowed a 1-parent-1-child topology.
1484        // For any unconfirmed v3 parents (there should be a maximum of 1 except in reorgs),
1485        // record this child so the wallet doesn't try to spend any other outputs
1486        for (const CTxIn& tx_in : tx->vin) {
1487            auto parent_it = mapWallet.find(tx_in.prevout.hash);
1488            if (parent_it != mapWallet.end()) {
1489                CWalletTx& parent_wtx = parent_it->second;
1490                if (parent_wtx.isUnconfirmed()) {
1491                    parent_wtx.truc_child_in_mempool = tx->GetHash();
1492                    // Even though these siblings do not spend the same utxos, they can't
1493                    // be present in the mempool at the same time because of TRUC policy rules
1494                    UpdateTrucSiblingConflicts(parent_wtx, txid, /*add_conflict=*/true);
1495                }
1496            }
1497        }
1498    }
1499}
1500