The wallet state and lifecycle

1001}
1002
1003bool CWallet::MarkReplaced(const Txid& originalHash, const Txid& newHash)
1004{
1005    LOCK(cs_wallet);
1006
1007    auto mi = mapWallet.find(originalHash);
1008
1009    // There is a bug if MarkReplaced is not called on an existing wallet transaction.
1010    assert(mi != mapWallet.end());
1011
1012    CWalletTx& wtx = (*mi).second;
1013
1014    // Ensure for now that we're not overwriting data
1015    Assert(!wtx.m_replaced_by_txid);
1016
1017    wtx.m_replaced_by_txid = newHash;
1018
1019    // Refresh mempool status without waiting for transactionRemovedFromMempool or transactionAddedToMempool
1020    RefreshMempoolStatus(wtx, chain());
1021
1022    WalletBatch batch(GetDatabase());
1023
1024    bool success = true;
1025    if (!batch.WriteTxMetadata(wtx)) {
1026        WalletLogPrintf("%s: Updating batch tx %s failed\n", __func__, wtx.GetHash().ToString());
1027        success = false;
1028    }
1029
1030    // The new transaction also replaces any malleated variants of wtx,
1031    // so bumpfee refuses to bump them afterwards
1032    for (CWalletTx* variant : GetMalleatedVariants(wtx)) {
1033        if (variant == &wtx) continue;
1034        variant->m_replaced_by_txid = newHash;
1035        if (!batch.WriteTxMetadata(*variant)) {
1036            WalletLogPrintf("%s: Updating variant tx %s failed\n", __func__, variant->GetHash().ToString());
1037            success = false;
1038        }
1039    }
1040
1041    NotifyTransactionChanged(originalHash, CT_UPDATED);
1042
1043    return success;
1044}
1045
1046void CWallet::SetSpentKeyState(WalletBatch& batch, const Txid& hash, unsigned int n, bool used, std::set<CTxDestination>& tx_destinations)
1047{
1048    AssertLockHeld(cs_wallet);
1049    const CWalletTx* srctx = GetWalletTx(hash);
1050    if (!srctx) return;
1051
1052    CTxDestination dst;
1053    if (ExtractDestination(srctx->GetTx()->vout[n].scriptPubKey, dst)) {
1054        if (IsMine(dst)) {
1055            if (used != IsAddressPreviouslySpent(dst)) {
1056                if (used) {
1057                    tx_destinations.insert(dst);
1058                }
1059                SetAddressPreviouslySpent(batch, dst, used);
1060            }
1061        }
1062    }
1063}
1064
1065bool CWallet::IsSpentKey(const CScript& scriptPubKey) const
1066{
1067    AssertLockHeld(cs_wallet);
1068    CTxDestination dest;
1069    if (!ExtractDestination(scriptPubKey, dest)) {
1070        return false;
1071    }
1072    if (IsAddressPreviouslySpent(dest)) {
1073        return true;
1074    }
1075    return false;
1076}
1077
1078CWalletTx* CWallet::AddToWallet(CTransactionRef tx, const TxState& state, const UpdateWalletTxFn& update_wtx, bool rescanning_old_block)
1079{
1080    LOCK(cs_wallet);
1081
1082    WalletBatch batch(GetDatabase());
1083
1084    Txid hash = tx->GetHash();
1085
1086    if (IsWalletFlagSet(WALLET_FLAG_AVOID_REUSE)) {
1087        // Mark used destinations
1088        std::set<CTxDestination> tx_destinations;
1089
1090        for (const CTxIn& txin : tx->vin) {
1091            const COutPoint& op = txin.prevout;
1092            SetSpentKeyState(batch, op.hash, op.n, true, tx_destinations);
1093        }
1094
1095        MarkDestinationsDirty(tx_destinations);
1096    }
1097
1098    // Inserts only if not already there, returns tx inserted or tx found
1099    auto ret = mapWallet.emplace(std::piecewise_construct, std::forward_as_tuple(hash), std::forward_as_tuple(tx, state));
1100    CWalletTx& wtx = (*ret.first).second;
1101    bool fInsertedNew = ret.second;
1102    bool fUpdated = update_wtx && update_wtx(wtx, fInsertedNew);
1103    if (fInsertedNew) {
1104        wtx.nTimeReceived = GetTime();
1105        wtx.nOrderPos = IncOrderPosNext(&batch);
1106        wtx.m_it_wtxOrdered = wtxOrdered.insert(std::make_pair(wtx.nOrderPos, &wtx));
1107        wtx.nTimeSmart = ComputeTimeSmart(wtx, rescanning_old_block);
1108        AddToSpends(wtx);
1109        SyncMalleatedTxMetadata(batch, wtx);
1110
1111        // Update birth time when tx time is older than it.
1112        MaybeUpdateBirthTime(wtx.GetTxTime());
1113
1114        if (!batch.WriteFullTx(wtx)) {
1115            return nullptr;
1116        }
1117    }
1118
1119    if (!fInsertedNew)
1120    {
1121        try {
1122            fUpdated |= wtx.Update(tx, state, batch, fUpdated);
1123        } catch (const std::ios_base::failure& e) {
1124            WalletLogPrintf("Error: Unable to write tx update, %s", e.what());
1125            return nullptr;
1126        }
1127    }
1128
1129    // Mark inactive coinbase transactions and their descendants as abandoned
1130    if (wtx.IsCoinBase() && wtx.isInactive()) {
1131        std::vector<CWalletTx*> txs{&wtx};
1132
1133        TxStateInactive inactive_state = TxStateInactive{/*abandoned=*/true};
1134
1135        while (!txs.empty()) {
1136            CWalletTx* desc_tx = txs.back();
1137            txs.pop_back();
1138            desc_tx->m_state = inactive_state;
1139            // Break caches since we have changed the state
1140            desc_tx->MarkDirty();
1141            batch.WriteTxMetadata(*desc_tx);
1142            MarkInputsDirty(desc_tx->GetTx());
1143            for (unsigned int i = 0; i < desc_tx->GetTx()->vout.size(); ++i) {
1144                COutPoint outpoint(desc_tx->GetHash(), i);
1145                std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range = mapTxSpends.equal_range(outpoint);
1146                for (TxSpends::const_iterator it = range.first; it != range.second; ++it) {
1147                    const auto wit = mapWallet.find(it->second);
1148                    if (wit != mapWallet.end()) {
1149                        txs.push_back(&wit->second);
1150                    }
1151                }
1152            }
1153        }
1154    }
1155
1156    //// debug print
1157    std::string status{"no-change"};
1158    if (fInsertedNew || fUpdated) {
1159        status = fInsertedNew ? (fUpdated ? "new, update" : "new") : "update";
1160    }
1161    WalletLogPrintf("AddToWallet %s %s %s", hash.ToString(), status, TxStateString(state));
1162
1163    // Break debit/credit balance caches:
1164    wtx.MarkDirty();
1165
1166    // Cache the outputs that belong to the wallet
1167    RefreshTXOsFromTx(wtx);
1168
1169    // Notify UI of new or updated transaction
1170    NotifyTransactionChanged(hash, fInsertedNew ? CT_NEW : CT_UPDATED);
1171
1172#if HAVE_SYSTEM
1173    // notify an external script when a wallet transaction comes in or is updated
1174    std::string strCmd = m_notify_tx_changed_script;
1175
1176    if (!strCmd.empty())
1177    {
1178        ReplaceAll(strCmd, "%s", hash.GetHex());
1179        if (auto* conf = wtx.state<TxStateConfirmed>())
1180        {
1181            ReplaceAll(strCmd, "%b", conf->confirmed_block_hash.GetHex());
1182            ReplaceAll(strCmd, "%h", ToString(conf->confirmed_block_height));
1183        } else {
1184            ReplaceAll(strCmd, "%b", "unconfirmed");
1185            ReplaceAll(strCmd, "%h", "-1");
1186        }
1187#ifndef WIN32
1188        // Substituting the wallet name isn't currently supported on windows
1189        // because windows shell escaping has not been implemented yet:
1190        // https://github.com/bitcoin/bitcoin/pull/13339#issuecomment-537384875
1191        // A few ways it could be implemented in the future are described in:
1192        // https://github.com/bitcoin/bitcoin/pull/13339#issuecomment-461288094
1193        ReplaceAll(strCmd, "%w", ShellEscape(GetName()));
1194#endif
1195        std::thread t(runCommand, strCmd);
1196        t.detach(); // thread runs free
1197    }
1198#endif
1199
1200    return &wtx;
1201}
1202
1203bool CWallet::LoadToWallet(CWalletTx&& wtx_in)
1204{
1205    const auto& ins = mapWallet.emplace(wtx_in.GetHash(), std::move(wtx_in));
1206    CWalletTx& wtx = ins.first->second;
1207    if (!ins.second) {
1208        return false;
1209    }
1210    // If wallet doesn't have a chain (e.g when using bitcoin-wallet tool),
1211    // don't bother to update txn.
1212    if (HaveChain()) {
1213      wtx.updateState(chain());
1214    }
1215    wtx.m_it_wtxOrdered = wtxOrdered.insert(std::make_pair(wtx.nOrderPos, &wtx));
1216    AddToSpends(wtx);
1217    for (const CTxIn& txin : wtx.GetTx()->vin) {
1218        auto it = mapWallet.find(txin.prevout.hash);
1219        if (it != mapWallet.end()) {
1220            CWalletTx& prevtx = it->second;
1221            if (auto* prev = prevtx.state<TxStateBlockConflicted>()) {
1222                MarkConflicted(prev->conflicting_block_hash, prev->conflicting_block_height, wtx.GetHash());
1223            }
1224        }
1225    }
1226
1227    // Update birth time when tx time is older than it.
1228    MaybeUpdateBirthTime(wtx.GetTxTime());
1229
1230    // Make sure the tx outputs are known by the wallet
1231    RefreshTXOsFromTx(wtx);
1232    return true;
1233}
1234
1235bool CWallet::AddToWalletIfInvolvingMe(const CTransactionRef& ptx, const SyncTxState& state, bool rescanning_old_block)
1236{
1237    const CTransaction& tx = *ptx;
1238    {
1239        AssertLockHeld(cs_wallet);
1240
1241        if (auto* conf = std::get_if<TxStateConfirmed>(&state)) {
1242            for (const CTxIn& txin : tx.vin) {
1243                std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range = mapTxSpends.equal_range(txin.prevout);
1244                while (range.first != range.second) {
1245                    if (range.first->second != tx.GetHash()) {
1246                        WalletLogPrintf("Transaction %s (in block %s) conflicts with wallet transaction %s (both spend %s:%i)\n", tx.GetHash().ToString(), conf->confirmed_block_hash.ToString(), range.first->second.ToString(), range.first->first.hash.ToString(), range.first->first.n);
1247                        MarkConflicted(conf->confirmed_block_hash, conf->confirmed_block_height, range.first->second);
1248                    }
1249                    range.first++;
1250                }