The wallet state and lifecycle

501            }
502        } else {
503            // The directory doesn't exist, create it
504            if (!TryCreateDirectories(wallet_path)) {
505                error = Untranslated(strprintf("Failed to restore database path '%s'.", fs::PathToString(wallet_path)));
506                status = DatabaseStatus::FAILED_ALREADY_EXISTS;
507                return nullptr;
508            }
509            created_parent_dir = true;
510        }
511
512        fs::copy_file(backup_file, wallet_file, fs::copy_options::none);
513        wallet_file_copied = true;
514
515        if (load_after_restore) {
516            wallet = LoadWallet(context, wallet_name, load_on_start, options, status, error, warnings);
517        }
518    } catch (const std::exception& e) {
519        assert(!wallet);
520        if (!error.empty()) error += Untranslated("\n");
521        error += Untranslated(strprintf("Unexpected exception: %s", e.what()));
522    }
523
524    // Remove created wallet path only when loading fails
525    if (load_after_restore && !wallet) {
526        if (wallet_file_copied) fs::remove(wallet_file);
527        // Clean up the parent directory if we created it during restoration.
528        // As we have created it, it must be empty after deleting the wallet file.
529        if (created_parent_dir) {
530            Assume(fs::is_empty(wallet_path));
531            fs::remove(wallet_path);
532        }
533    }
534
535    return wallet;
536}
537
538/** @defgroup mapWallet
539 *
540 * @{
541 */
542
543const CWalletTx* CWallet::GetWalletTx(const Txid& hash) const
544{
545    AssertLockHeld(cs_wallet);
546    const auto it = mapWallet.find(hash);
547    if (it == mapWallet.end())
548        return nullptr;
549    return &(it->second);
550}
551
552void CWallet::UpgradeDescriptorCache()
553{
554    if (!IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS) || IsLocked() || IsWalletFlagSet(WALLET_FLAG_LAST_HARDENED_XPUB_CACHED)) {
555        return;
556    }
557
558    for (ScriptPubKeyMan* spkm : GetAllScriptPubKeyMans()) {
559        DescriptorScriptPubKeyMan* desc_spkm = dynamic_cast<DescriptorScriptPubKeyMan*>(spkm);
560        desc_spkm->UpgradeDescriptorCache();
561    }
562    SetWalletFlag(WALLET_FLAG_LAST_HARDENED_XPUB_CACHED);
563}
564
565/* Given a wallet passphrase string and an unencrypted master key, determine the proper key
566 * derivation parameters (should take at least 100ms) and encrypt the master key. */
567static bool EncryptMasterKey(const SecureString& wallet_passphrase, const CKeyingMaterial& plain_master_key, CMasterKey& master_key)
568{
569    constexpr MillisecondsDouble target_time{100};
570    CCrypter crypter;
571    CMasterKey updated_master_key{master_key};
572
573    // Get the weighted average of iterations we can do in 100ms over 2 runs.
574    for (int i = 0; i < 2; i++){
575        auto start_time{NodeClock::now()};
576        const bool key_set{crypter.SetKeyFromPassphrase(wallet_passphrase, updated_master_key.vchSalt, updated_master_key.nDeriveIterations, updated_master_key.nDerivationMethod)};
577        auto elapsed_time{NodeClock::now() - start_time};
578        if (!key_set) {
579            return false;
580        }
581
582        if (elapsed_time <= 0s) {
583            // We are probably in a test with a mocked clock.
584            updated_master_key.nDeriveIterations = CMasterKey::DEFAULT_DERIVE_ITERATIONS;
585            break;
586        }
587
588        // target_iterations : elapsed_iterations :: target_time : elapsed_time
589        const double target_iterations{updated_master_key.nDeriveIterations * target_time / elapsed_time};
590        if (target_iterations < 1 || target_iterations > std::numeric_limits<unsigned int>::max()) {
591            return false;
592        }
593        // Get the weighted average with previous runs. Use 64-bit math so the
594        // sum cannot wrap; the average of two unsigned int values fits in one.
595        updated_master_key.nDeriveIterations = (uint64_t{updated_master_key.nDeriveIterations} * i + static_cast<unsigned int>(target_iterations)) / (i + 1);
596    }
597
598    if (updated_master_key.nDeriveIterations < CMasterKey::DEFAULT_DERIVE_ITERATIONS) {
599        updated_master_key.nDeriveIterations = CMasterKey::DEFAULT_DERIVE_ITERATIONS;
600    }
601
602    if (!crypter.SetKeyFromPassphrase(wallet_passphrase, updated_master_key.vchSalt, updated_master_key.nDeriveIterations, updated_master_key.nDerivationMethod)) {
603        return false;
604    }
605    if (!crypter.Encrypt(plain_master_key, updated_master_key.vchCryptedKey)) {
606        return false;
607    }
608
609    master_key = std::move(updated_master_key);
610    return true;
611}
612
613static bool DecryptMasterKey(const SecureString& wallet_passphrase, const CMasterKey& master_key, CKeyingMaterial& plain_master_key)
614{
615    CCrypter crypter;
616    if (!crypter.SetKeyFromPassphrase(wallet_passphrase, master_key.vchSalt, master_key.nDeriveIterations, master_key.nDerivationMethod)) {
617        return false;
618    }
619    if (!crypter.Decrypt(master_key.vchCryptedKey, plain_master_key)) {
620        return false;
621    }
622
623    return true;
624}
625
626bool CWallet::Unlock(const SecureString& strWalletPassphrase)
627{
628    CKeyingMaterial plain_master_key;
629
630    {
631        LOCK(cs_wallet);
632        for (const auto& [_, master_key] : mapMasterKeys)
633        {
634            if (!DecryptMasterKey(strWalletPassphrase, master_key, plain_master_key)) {
635                continue; // try another master key
636            }
637            if (Unlock(plain_master_key)) {
638                // Now that we've unlocked, upgrade the descriptor cache
639                UpgradeDescriptorCache();
640                return true;
641            }
642        }
643    }
644    return false;
645}
646
647bool CWallet::ChangeWalletPassphrase(const SecureString& strOldWalletPassphrase, const SecureString& strNewWalletPassphrase)
648{
649    bool fWasLocked = IsLocked();
650
651    {
652        LOCK2(m_relock_mutex, cs_wallet);
653        Lock();
654
655        CKeyingMaterial plain_master_key;
656        for (auto& [master_key_id, master_key] : mapMasterKeys)
657        {
658            if (!DecryptMasterKey(strOldWalletPassphrase, master_key, plain_master_key)) {
659                return false;
660            }
661            if (Unlock(plain_master_key))
662            {
663                if (!EncryptMasterKey(strNewWalletPassphrase, plain_master_key, master_key)) {
664                    return false;
665                }
666                WalletLogPrintf("Wallet passphrase changed to an nDeriveIterations of %i\n", master_key.nDeriveIterations);
667
668                WalletBatch(GetDatabase()).WriteMasterKey(master_key_id, master_key);
669                if (fWasLocked)
670                    Lock();
671                return true;
672            }
673        }
674    }
675
676    return false;
677}
678
679void CWallet::SetLastBlockProcessedInMem(int block_height, uint256 block_hash)
680{
681    AssertLockHeld(cs_wallet);
682
683    m_last_block_processed = block_hash;
684    m_last_block_processed_height = block_height;
685}
686
687void CWallet::SetLastBlockProcessed(int block_height, uint256 block_hash)
688{
689    AssertLockHeld(cs_wallet);
690
691    SetLastBlockProcessedInMem(block_height, block_hash);
692    WriteBestBlock();
693}
694
695std::set<Txid> CWallet::GetConflicts(const Txid& txid) const
696{
697    std::set<Txid> result;
698    AssertLockHeld(cs_wallet);
699
700    const auto it = mapWallet.find(txid);
701    if (it == mapWallet.end())
702        return result;
703    const CWalletTx& wtx = it->second;
704
705    std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range;
706
707    for (const CTxIn& txin : wtx.GetTx()->vin)
708    {
709        if (mapTxSpends.count(txin.prevout) <= 1)
710            continue;  // No conflict if zero or one spends
711        range = mapTxSpends.equal_range(txin.prevout);
712        for (TxSpends::const_iterator _it = range.first; _it != range.second; ++_it)
713            result.insert(_it->second);
714    }
715    return result;
716}
717
718bool CWallet::HasWalletSpend(const CTransactionRef& tx) const
719{
720    AssertLockHeld(cs_wallet);
721    const Txid& txid = tx->GetHash();
722    for (unsigned int i = 0; i < tx->vout.size(); ++i) {
723        if (IsSpent(COutPoint(txid, i))) {
724            return true;
725        }
726    }
727    return false;
728}
729
730void CWallet::Close()
731{
732    GetDatabase().Close();
733}
734
735std::set<CWalletTx*, WalletTxOrderComparator> CWallet::GetMalleatedVariants(const CWalletTx& wtx)
736{
737    AssertLockHeld(cs_wallet);
738    std::set<CWalletTx*, WalletTxOrderComparator> txs;
739
740    // Coinbases cannot be malleated
741    if (wtx.IsCoinBase()) return txs;
742
743    // Only transactions that have non-witness inputs can be malleated
744    if (std::ranges::none_of(wtx.GetTx()->vin, [](const CTxIn& in) { return in.scriptWitness.IsNull(); })) {
745        return txs;
746    }
747
748    // All variants spend wtx's first input, so a single lookup finds every candidate
749    bool found_self = false;
750    const auto [begin, end] = mapTxSpends.equal_range(wtx.GetTx()->vin.front().prevout);