The wallet state and lifecycle

3251    }
3252
3253    // Register wallet with validationinterface. It's done before rescan to avoid
3254    // missing block connections during the rescan.
3255    // Because of the wallet lock being held, block connection notifications are going to
3256    // be pending on the validation-side until lock release. Blocks that are connected while the
3257    // rescan is ongoing will not be processed in the rescan but with the block connected notifications,
3258    // so the wallet will only be completeley synced after the notifications delivery.
3259    walletInstance->m_chain_notifications_handler = walletInstance->chain().handleNotifications(walletInstance);
3260
3261    // If rescan_required = true, rescan_height remains equal to 0
3262    int rescan_height = 0;
3263    if (!rescan_required)
3264    {
3265        WalletBatch batch(walletInstance->GetDatabase());
3266        CBlockLocator locator;
3267        if (batch.ReadBestBlock(locator)) {
3268            if (const std::optional<int> fork_height = chain.findLocatorFork(locator)) {
3269                rescan_height = *fork_height;
3270            }
3271        }
3272    }
3273
3274    const std::optional<int> tip_height = chain.getHeight();
3275    if (tip_height) {
3276        walletInstance->SetLastBlockProcessedInMem(*tip_height, chain.getBlockHash(*tip_height));
3277    } else {
3278        walletInstance->SetLastBlockProcessedInMem(-1, uint256());
3279    }
3280
3281    if (tip_height && *tip_height != rescan_height)
3282    {
3283        // No need to read and scan block if block was created before
3284        // our wallet birthday (as adjusted for block time variability)
3285        std::optional<int64_t> time_first_key = walletInstance->m_birth_time.load();
3286        if (time_first_key) {
3287            FoundBlock found = FoundBlock().height(rescan_height);
3288            chain.findFirstBlockWithTimeAndHeight(*time_first_key - TIMESTAMP_WINDOW, rescan_height, found);
3289            if (!found.found) {
3290                // We were unable to find a block that had a time more recent than our earliest timestamp
3291                // or a height higher than the wallet was synced to, indicating that the wallet is newer than the
3292                // current chain tip. Skip rescanning in this case.
3293                rescan_height = *tip_height;
3294            }
3295        }
3296
3297        // Technically we could execute the code below in any case, but performing the
3298        // `while` loop below can make startup very slow, so only check blocks on disk
3299        // if necessary.
3300        if (chain.havePruned() || chain.hasAssumedValidChain()) {
3301            int block_height = *tip_height;
3302            while (block_height > 0 && chain.haveBlockOnDisk(block_height - 1) && rescan_height != block_height) {
3303                --block_height;
3304            }
3305
3306            if (rescan_height != block_height) {
3307                // We can't rescan beyond blocks we don't have data for, stop and throw an error.
3308                // This might happen if a user uses an old wallet within a pruned node
3309                // or if they ran -disablewallet for a longer time, then decided to re-enable
3310                // Exit early and print an error.
3311                // It also may happen if an assumed-valid chain is in use and therefore not
3312                // all block data is available.
3313                // If a block is pruned after this check, we will load the wallet,
3314                // but fail the rescan with a generic error.
3315
3316                error = chain.havePruned() ?
3317                     _("Prune: last wallet synchronisation goes beyond pruned data. You need to -reindex (download the whole blockchain again in case of a pruned node)") :
3318                     strprintf(_(
3319                        "Error loading wallet. Wallet requires blocks to be downloaded, "
3320                        "and software does not currently support loading wallets while "
3321                        "blocks are being downloaded out of order when using assumeutxo "
3322                        "snapshots. Wallet should be able to load successfully after "
3323                        "node sync reaches height %s"), block_height);
3324                return false;
3325            }
3326        }
3327
3328        chain.initMessage(_("Rescanning…"));
3329        walletInstance->WalletLogPrintf("Rescanning last %i blocks (from block %i)...\n", *tip_height - rescan_height, rescan_height);
3330
3331        {
3332            WalletRescanReserver reserver(*walletInstance);
3333            if (!reserver.reserve()) {
3334                error = _("Failed to acquire rescan reserver during wallet initialization");
3335                return false;
3336            }
3337            ScanResult scan_res = walletInstance->ScanForWalletTransactions(chain.getBlockHash(rescan_height), rescan_height, /*max_height=*/{}, reserver, /*save_progress=*/true);
3338            if (ScanResult::SUCCESS != scan_res.status) {
3339                error = _("Failed to rescan the wallet during initialization");
3340                return false;
3341            }
3342            // Set and update the best block record
3343            // Set last block scanned as the last block processed as it may be different in case of a reorg.
3344            // Also save the best block locator because rescanning only updates it intermittently.
3345            walletInstance->SetLastBlockProcessed(*scan_res.last_scanned_height, scan_res.last_scanned_block);
3346        }
3347    }
3348
3349    return true;
3350}
3351
3352const CAddressBookData* CWallet::FindAddressBookEntry(const CTxDestination& dest, bool allow_change) const
3353{
3354    const auto& address_book_it = m_address_book.find(dest);
3355    if (address_book_it == m_address_book.end()) return nullptr;
3356    if ((!allow_change) && address_book_it->second.IsChange()) {
3357        return nullptr;
3358    }
3359    return &address_book_it->second;
3360}
3361
3362void CWallet::postInitProcess()
3363{
3364    // Add wallet transactions that aren't already in a block to mempool
3365    // Do this here as mempool requires genesis block to be loaded
3366    ResubmitWalletTransactions(node::TxBroadcast::MEMPOOL_NO_BROADCAST, /*force=*/true);
3367
3368    // Update wallet transactions with current mempool transactions.
3369    WITH_LOCK(cs_wallet, chain().requestMempoolTransactions(*this));
3370}
3371
3372bool CWallet::BackupWallet(const std::string& strDest) const
3373{
3374    WITH_LOCK(cs_wallet, WriteBestBlock());
3375    return GetDatabase().Backup(strDest);
3376}
3377
3378int CWallet::GetTxDepthInMainChain(const CWalletTx& wtx) const
3379{
3380    AssertLockHeld(cs_wallet);
3381    if (auto* conf = wtx.state<TxStateConfirmed>()) {
3382        assert(conf->confirmed_block_height >= 0);
3383        return GetLastBlockHeight() - conf->confirmed_block_height + 1;
3384    } else if (auto* conf = wtx.state<TxStateBlockConflicted>()) {
3385        assert(conf->conflicting_block_height >= 0);
3386        return -1 * (GetLastBlockHeight() - conf->conflicting_block_height + 1);
3387    } else {
3388        return 0;
3389    }
3390}
3391
3392int CWallet::GetTxBlocksToMaturity(const CWalletTx& wtx) const
3393{
3394    AssertLockHeld(cs_wallet);
3395
3396    if (!wtx.IsCoinBase()) {
3397        return 0;
3398    }
3399    int chain_depth = GetTxDepthInMainChain(wtx);
3400    assert(chain_depth >= 0); // coinbase tx should not be conflicted
3401    return std::max(0, (COINBASE_MATURITY+1) - chain_depth);
3402}
3403
3404bool CWallet::IsTxImmatureCoinBase(const CWalletTx& wtx) const
3405{
3406    AssertLockHeld(cs_wallet);
3407
3408    // note GetBlocksToMaturity is 0 for non-coinbase tx
3409    return GetTxBlocksToMaturity(wtx) > 0;
3410}
3411
3412bool CWallet::IsLocked() const
3413{
3414    if (!HasEncryptionKeys()) {
3415        return false;
3416    }
3417    LOCK(cs_wallet);
3418    return vMasterKey.empty();
3419}
3420
3421bool CWallet::Lock()
3422{
3423    if (!HasEncryptionKeys())
3424        return false;
3425
3426    {
3427        LOCK2(m_relock_mutex, cs_wallet);
3428        if (!vMasterKey.empty()) {
3429            memory_cleanse(vMasterKey.data(), vMasterKey.size() * sizeof(decltype(vMasterKey)::value_type));
3430            vMasterKey.clear();
3431        }
3432    }
3433
3434    NotifyStatusChanged(this);
3435    return true;
3436}
3437
3438bool CWallet::Unlock(const CKeyingMaterial& vMasterKeyIn)
3439{
3440    {
3441        LOCK(cs_wallet);
3442        for (const auto& spk_man_pair : m_spk_managers) {
3443            if (!spk_man_pair.second->CheckDecryptionKey(vMasterKeyIn)) {
3444                return false;
3445            }
3446        }
3447        vMasterKey = vMasterKeyIn;
3448    }
3449    NotifyStatusChanged(this);
3450    return true;
3451}
3452
3453std::set<ScriptPubKeyMan*> CWallet::GetActiveScriptPubKeyMans() const
3454{
3455    std::set<ScriptPubKeyMan*> spk_mans;
3456    for (bool internal : {false, true}) {
3457        for (OutputType t : OUTPUT_TYPES) {
3458            auto spk_man = GetScriptPubKeyMan(t, internal);
3459            if (spk_man) {
3460                spk_mans.insert(spk_man);
3461            }
3462        }
3463    }
3464    return spk_mans;
3465}
3466
3467bool CWallet::IsActiveScriptPubKeyMan(const ScriptPubKeyMan& spkm) const
3468{
3469    for (const auto& [_, ext_spkm] : m_external_spk_managers) {
3470        if (ext_spkm == &spkm) return true;
3471    }
3472    for (const auto& [_, int_spkm] : m_internal_spk_managers) {
3473        if (int_spkm == &spkm) return true;
3474    }
3475    return false;
3476}
3477
3478std::set<ScriptPubKeyMan*> CWallet::GetAllScriptPubKeyMans() const
3479{
3480    std::set<ScriptPubKeyMan*> spk_mans;
3481    for (const auto& spk_man_pair : m_spk_managers) {
3482        spk_mans.insert(spk_man_pair.second.get());
3483    }
3484    return spk_mans;
3485}
3486
3487ScriptPubKeyMan* CWallet::GetScriptPubKeyMan(const OutputType& type, bool internal) const
3488{
3489    const std::map<OutputType, ScriptPubKeyMan*>& spk_managers = internal ? m_internal_spk_managers : m_external_spk_managers;
3490    std::map<OutputType, ScriptPubKeyMan*>::const_iterator it = spk_managers.find(type);
3491    if (it == spk_managers.end()) {
3492        return nullptr;
3493    }
3494    return it->second;
3495}
3496
3497std::set<ScriptPubKeyMan*> CWallet::GetScriptPubKeyMans(const CScript& script) const
3498{
3499    std::set<ScriptPubKeyMan*> spk_mans;
3500