The wallet state and lifecycle

2251    }
2252
2253    std::optional<PrecomputedTransactionData> txdata_res = PrecomputePSBTData(psbtx);
2254    if (!txdata_res) {
2255        return PSBTError::INVALID_TX;
2256    }
2257    const PrecomputedTransactionData& txdata = *txdata_res;
2258
2259    // Fill in information from ScriptPubKeyMans
2260    for (ScriptPubKeyMan* spk_man : GetAllScriptPubKeyMans()) {
2261        int n_signed_this_spkm = 0;
2262        const auto error{spk_man->FillPSBT(psbtx, txdata, options, &n_signed_this_spkm)};
2263        if (error) {
2264            return error;
2265        }
2266
2267        if (n_signed) {
2268            (*n_signed) += n_signed_this_spkm;
2269        }
2270    }
2271
2272    RemoveUnnecessaryTransactions(psbtx);
2273
2274    // Complete if every input is now signed
2275    complete = true;
2276    for (size_t i = 0; i < psbtx.inputs.size(); ++i) {
2277        complete &= PSBTInputSignedAndVerified(psbtx, i, &txdata);
2278    }
2279
2280    return {};
2281}
2282
2283SigningResult CWallet::SignMessage(const std::string& message, const PKHash& pkhash, std::string& str_sig) const
2284{
2285    SignatureData sigdata;
2286    CScript script_pub_key = GetScriptForDestination(pkhash);
2287    for (const auto& spk_man_pair : m_spk_managers) {
2288        if (spk_man_pair.second->CanProvide(script_pub_key, sigdata)) {
2289            LOCK(cs_wallet);  // DescriptorScriptPubKeyMan calls IsLocked which can lock cs_wallet in a deadlocking order
2290            return spk_man_pair.second->SignMessage(message, pkhash, str_sig);
2291        }
2292    }
2293    return SigningResult::PRIVATE_KEY_NOT_AVAILABLE;
2294}
2295
2296OutputType CWallet::TransactionChangeType(const std::optional<OutputType>& change_type, const std::vector<CRecipient>& vecSend) const
2297{
2298    // If -changetype is specified, always use that change type.
2299    if (change_type) {
2300        return *change_type;
2301    }
2302
2303    // if m_default_address_type is legacy, use legacy address as change.
2304    if (m_default_address_type == OutputType::LEGACY) {
2305        return OutputType::LEGACY;
2306    }
2307
2308    bool any_tr{false};
2309    bool any_wpkh{false};
2310    bool any_sh{false};
2311    bool any_pkh{false};
2312
2313    for (const auto& recipient : vecSend) {
2314        if (std::get_if<WitnessV1Taproot>(&recipient.dest)) {
2315            any_tr = true;
2316        } else if (std::get_if<WitnessV0KeyHash>(&recipient.dest)) {
2317            any_wpkh = true;
2318        } else if (std::get_if<ScriptHash>(&recipient.dest)) {
2319            any_sh = true;
2320        } else if (std::get_if<PKHash>(&recipient.dest)) {
2321            any_pkh = true;
2322        }
2323    }
2324
2325    const bool has_bech32m_spkman(GetScriptPubKeyMan(OutputType::BECH32M, /*internal=*/true));
2326    if (has_bech32m_spkman && any_tr) {
2327        // Currently tr is the only type supported by the BECH32M spkman
2328        return OutputType::BECH32M;
2329    }
2330    const bool has_bech32_spkman(GetScriptPubKeyMan(OutputType::BECH32, /*internal=*/true));
2331    if (has_bech32_spkman && any_wpkh) {
2332        // Currently wpkh is the only type supported by the BECH32 spkman
2333        return OutputType::BECH32;
2334    }
2335    const bool has_p2sh_segwit_spkman(GetScriptPubKeyMan(OutputType::P2SH_SEGWIT, /*internal=*/true));
2336    if (has_p2sh_segwit_spkman && any_sh) {
2337        // Currently sh_wpkh is the only type supported by the P2SH_SEGWIT spkman
2338        // As of 2021 about 80% of all SH are wrapping WPKH, so use that
2339        return OutputType::P2SH_SEGWIT;
2340    }
2341    const bool has_legacy_spkman(GetScriptPubKeyMan(OutputType::LEGACY, /*internal=*/true));
2342    if (has_legacy_spkman && any_pkh) {
2343        // Currently pkh is the only type supported by the LEGACY spkman
2344        return OutputType::LEGACY;
2345    }
2346
2347    if (has_bech32m_spkman) {
2348        return OutputType::BECH32M;
2349    }
2350    if (has_bech32_spkman) {
2351        return OutputType::BECH32;
2352    }
2353    // else use m_default_address_type for change
2354    return m_default_address_type;
2355}
2356
2357void CWallet::CommitTransaction(
2358    CTransactionRef tx,
2359    std::optional<Txid> replaces_txid,
2360    std::optional<std::string> comment,
2361    std::optional<std::string> comment_to,
2362    const std::vector<std::string>& messages,
2363    const std::vector<std::string>& payment_requests
2364)
2365{
2366    LOCK(cs_wallet);
2367    WalletLogPrintf("CommitTransaction:\n%s\n", util::RemoveSuffixView(tx->ToString(), "\n"));
2368
2369    // Add tx to wallet, because if it has change it's also ours,
2370    // otherwise just for transaction history.
2371    CWalletTx* wtx = AddToWallet(tx, TxStateInactive{}, [&](CWalletTx& wtx, bool new_tx) {
2372        if (replaces_txid) wtx.m_replaces_txid = replaces_txid;
2373        if (comment) wtx.m_comment = comment;
2374        if (comment_to) wtx.m_comment_to = comment_to;
2375        if (!messages.empty()) wtx.m_messages = messages;
2376        if (!payment_requests.empty()) wtx.m_payment_requests = payment_requests;
2377        return true;
2378    });
2379
2380    // wtx can only be null if the db write failed.
2381    if (!wtx) {
2382        throw std::runtime_error(std::string(__func__) + ": Wallet db error, transaction commit failed");
2383    }
2384
2385    // Notify that old coins are spent
2386    for (const CTxIn& txin : tx->vin) {
2387        CWalletTx &coin = mapWallet.at(txin.prevout.hash);
2388        coin.MarkDirty();
2389        NotifyTransactionChanged(coin.GetHash(), CT_UPDATED);
2390    }
2391
2392    if (!fBroadcastTransactions) {
2393        // Don't submit tx to the mempool
2394        return;
2395    }
2396
2397    std::string err_string;
2398    if (!SubmitTxMemoryPoolAndRelay(*wtx, err_string, node::TxBroadcast::MEMPOOL_AND_BROADCAST_TO_ALL)) {
2399        WalletLogPrintf("CommitTransaction(): Transaction cannot be broadcast immediately, %s\n", err_string);
2400        // TODO: if we expect the failure to be long term or permanent, instead delete wtx from the wallet and return failure.
2401    }
2402}
2403
2404DBErrors CWallet::PopulateWalletFromDB(bilingual_str& error, std::vector<bilingual_str>& warnings)
2405{
2406    LOCK(cs_wallet);
2407
2408    Assert(m_spk_managers.empty());
2409    Assert(m_wallet_flags == 0);
2410    DBErrors nLoadWalletRet = WalletBatch(GetDatabase()).LoadWallet(this);
2411
2412    if (m_spk_managers.empty()) {
2413        assert(m_external_spk_managers.empty());
2414        assert(m_internal_spk_managers.empty());
2415    }
2416
2417    const auto wallet_file = m_database->Filename();
2418    switch (nLoadWalletRet) {
2419    case DBErrors::LOAD_OK:
2420        break;
2421    case DBErrors::NONCRITICAL_ERROR:
2422        warnings.push_back(strprintf(_("Error reading %s! All keys read correctly, but transaction data"
2423                                       " or address metadata may be missing or incorrect."),
2424            wallet_file));
2425        break;
2426    case DBErrors::NEED_RESCAN:
2427        warnings.push_back(strprintf(_("Error reading %s! Transaction data may be missing or incorrect."
2428                                       " Rescanning wallet."), wallet_file));
2429        break;
2430    case DBErrors::CORRUPT:
2431        error = strprintf(_("Error loading %s: Wallet corrupted"), wallet_file);
2432        break;
2433    case DBErrors::TOO_NEW:
2434        error = strprintf(_("Error loading %s: Wallet requires newer version of %s"), wallet_file, CLIENT_NAME);
2435        break;
2436    case DBErrors::EXTERNAL_SIGNER_SUPPORT_REQUIRED:
2437        error = strprintf(_("Error loading %s: External signer wallet being loaded without external signer support compiled"), wallet_file);
2438        break;
2439    case DBErrors::UNKNOWN_DESCRIPTOR:
2440        error = strprintf(_("Unrecognized descriptor found. Loading wallet %s\n\n"
2441                            "The wallet might have been created on a newer version.\n"
2442                            "Please try running the latest software version.\n"), wallet_file);
2443        break;
2444    case DBErrors::UNEXPECTED_LEGACY_ENTRY:
2445        error = strprintf(_("Unexpected legacy entry in descriptor wallet found. Loading wallet %s\n\n"
2446                            "The wallet might have been tampered with or created with malicious intent.\n"), wallet_file);
2447        break;
2448    case DBErrors::LEGACY_WALLET:
2449        error = strprintf(_("Error loading %s: Wallet is a legacy wallet. Please migrate to a descriptor wallet using the migration tool (migratewallet RPC)."), wallet_file);
2450        break;
2451    case DBErrors::LOAD_FAIL:
2452        error = strprintf(_("Error loading %s"), wallet_file);
2453        break;
2454    } // no default case, so the compiler can warn about missing cases
2455    return nLoadWalletRet;
2456}
2457
2458util::Result<void> CWallet::RemoveTxs(std::vector<Txid>& txs_to_remove)
2459{
2460    AssertLockHeld(cs_wallet);
2461    bilingual_str str_err;  // future: make RunWithinTxn return a util::Result
2462    bool was_txn_committed = RunWithinTxn(GetDatabase(), /*process_desc=*/"remove transactions", [&](WalletBatch& batch) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
2463        util::Result<void> result{RemoveTxs(batch, txs_to_remove)};
2464        if (!result) str_err = util::ErrorString(result);
2465        return result.has_value();
2466    });
2467    if (!str_err.empty()) return util::Error{str_err};
2468    if (!was_txn_committed) return util::Error{_("Error starting/committing db txn for wallet transactions removal process")};
2469    return {}; // all good
2470}
2471
2472util::Result<void> CWallet::RemoveTxs(WalletBatch& batch, std::vector<Txid>& txs_to_remove)
2473{
2474    AssertLockHeld(cs_wallet);
2475    if (!batch.HasActiveTxn()) return util::Error{strprintf(_("The transactions removal process can only be executed within a db txn"))};
2476
2477    // Check for transaction existence and remove entries from disk
2478    std::vector<decltype(mapWallet)::const_iterator> erased_txs;
2479    bilingual_str str_err;
2480    for (const Txid& hash : txs_to_remove) {
2481        auto it_wtx = mapWallet.find(hash);
2482        if (it_wtx == mapWallet.end()) {
2483            return util::Error{strprintf(_("Transaction %s does not belong to this wallet"), hash.GetHex())};
2484        }
2485        if (!batch.EraseTx(hash)) {
2486            return util::Error{strprintf(_("Failure removing transaction: %s"), hash.GetHex())};
2487        }
2488        erased_txs.emplace_back(it_wtx);
2489    }
2490
2491    // Register callback to update the memory state only when the db txn is actually dumped to disk
2492    batch.RegisterTxnListener({.on_commit=[&, erased_txs]() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
2493        // Update the in-memory state and notify upper layers about the removals
2494        for (const auto& it : erased_txs) {
2495            const Txid hash{it->first};
2496            wtxOrdered.erase(it->second.m_it_wtxOrdered);
2497            for (const auto& txin : it->second.GetTx()->vin) {
2498                auto range = mapTxSpends.equal_range(txin.prevout);
2499                for (auto iter = range.first; iter != range.second; ++iter) {
2500                    if (iter->second == hash) {