The wallet state and lifecycle

1751        if (!spk_man->IsHDEnabled()) return false;
1752        result = true;
1753    }
1754    return result;
1755}
1756
1757bool CWallet::CanGetAddresses(bool internal) const
1758{
1759    LOCK(cs_wallet);
1760    if (m_spk_managers.empty()) return false;
1761    for (OutputType t : OUTPUT_TYPES) {
1762        auto spk_man = GetScriptPubKeyMan(t, internal);
1763        if (spk_man && spk_man->CanGetAddresses(internal)) {
1764            return true;
1765        }
1766    }
1767    return false;
1768}
1769
1770void CWallet::SetWalletFlag(uint64_t flags)
1771{
1772    WalletBatch batch(GetDatabase());
1773    return SetWalletFlagWithDB(batch, flags);
1774}
1775
1776void CWallet::SetWalletFlagWithDB(WalletBatch& batch, uint64_t flags)
1777{
1778    LOCK(cs_wallet);
1779    m_wallet_flags |= flags;
1780    if (!batch.WriteWalletFlags(m_wallet_flags))
1781        throw std::runtime_error(std::string(__func__) + ": writing wallet flags failed");
1782}
1783
1784void CWallet::UnsetWalletFlag(uint64_t flag)
1785{
1786    WalletBatch batch(GetDatabase());
1787    UnsetWalletFlagWithDB(batch, flag);
1788}
1789
1790void CWallet::UnsetWalletFlagWithDB(WalletBatch& batch, uint64_t flag)
1791{
1792    LOCK(cs_wallet);
1793    m_wallet_flags &= ~flag;
1794    if (!batch.WriteWalletFlags(m_wallet_flags))
1795        throw std::runtime_error(std::string(__func__) + ": writing wallet flags failed");
1796}
1797
1798void CWallet::UnsetBlankWalletFlag(WalletBatch& batch)
1799{
1800    UnsetWalletFlagWithDB(batch, WALLET_FLAG_BLANK_WALLET);
1801}
1802
1803bool CWallet::IsWalletFlagSet(uint64_t flag) const
1804{
1805    return (m_wallet_flags & flag);
1806}
1807
1808bool CWallet::LoadWalletFlags(uint64_t flags)
1809{
1810    LOCK(cs_wallet);
1811    if (((flags & KNOWN_WALLET_FLAGS) >> 32) ^ (flags >> 32)) {
1812        // contains unknown non-tolerable wallet flags
1813        return false;
1814    }
1815    m_wallet_flags = flags;
1816
1817    return true;
1818}
1819
1820void CWallet::InitWalletFlags(uint64_t flags)
1821{
1822    LOCK(cs_wallet);
1823
1824    // We should never be writing unknown non-tolerable wallet flags
1825    assert(((flags & KNOWN_WALLET_FLAGS) >> 32) == (flags >> 32));
1826    // This should only be used once, when creating a new wallet - so current flags are expected to be blank
1827    assert(m_wallet_flags == 0);
1828
1829    if (!WalletBatch(GetDatabase()).WriteWalletFlags(flags)) {
1830        throw std::runtime_error(std::string(__func__) + ": writing wallet flags failed");
1831    }
1832
1833    if (!LoadWalletFlags(flags)) assert(false);
1834}
1835
1836uint64_t CWallet::GetWalletFlags() const
1837{
1838    return m_wallet_flags;
1839}
1840
1841void CWallet::MaybeUpdateBirthTime(int64_t time)
1842{
1843    int64_t birthtime = m_birth_time.load();
1844    if (time < birthtime) {
1845        m_birth_time = time;
1846    }
1847}
1848
1849/**
1850 * Scan active chain for relevant transactions after importing keys. This should
1851 * be called whenever new keys are added to the wallet, with the oldest key
1852 * creation time.
1853 *
1854 * @return Earliest timestamp that could be successfully scanned from. Timestamp
1855 * returned will be higher than startTime if relevant blocks could not be read.
1856 */
1857int64_t CWallet::RescanFromTime(int64_t startTime, const WalletRescanReserver& reserver)
1858{
1859    // Find starting block. May be null if nCreateTime is greater than the
1860    // highest blockchain timestamp, in which case there is nothing that needs
1861    // to be scanned.
1862    int start_height = 0;
1863    uint256 start_block;
1864    bool start = chain().findFirstBlockWithTimeAndHeight(startTime - TIMESTAMP_WINDOW, 0, FoundBlock().hash(start_block).height(start_height));
1865    WalletLogPrintf("%s: Rescanning last %i blocks\n", __func__, start ? WITH_LOCK(cs_wallet, return GetLastBlockHeight()) - start_height + 1 : 0);
1866
1867    if (start) {
1868        // TODO: this should take into account failure by ScanResult::USER_ABORT
1869        ScanResult result = ScanForWalletTransactions(start_block, start_height, /*max_height=*/{}, reserver, /*save_progress=*/false);
1870        if (result.status == ScanResult::FAILURE) {
1871            int64_t time_max;
1872            CHECK_NONFATAL(chain().findBlock(result.last_failed_block, FoundBlock().maxTime(time_max)));
1873            return time_max + TIMESTAMP_WINDOW + 1;
1874        }
1875    }
1876    return startTime;
1877}
1878
1879/**
1880 * Scan the block chain (starting in start_block) for transactions
1881 * from or to us. If max_height is not set, the
1882 * mempool will be scanned as well.
1883 *
1884 * @param[in] start_block Scan starting block. If block is not on the active
1885 *                        chain, the scan will return SUCCESS immediately.
1886 * @param[in] start_height Height of start_block
1887 * @param[in] max_height  Optional max scanning height. If unset there is
1888 *                        no maximum and scanning can continue to the tip
1889 *
1890 * @return ScanResult returning scan information and indicating success or
1891 *         failure. Return status will be set to SUCCESS if scan was
1892 *         successful. FAILURE if a complete rescan was not possible (due to
1893 *         pruning or corruption). USER_ABORT if the rescan was aborted before
1894 *         it could complete.
1895 *
1896 * @pre Caller needs to make sure start_block (and the optional stop_block) are on
1897 * the main chain after to the addition of any new keys you want to detect
1898 * transactions for.
1899 */
1900CWallet::ScanResult CWallet::ScanForWalletTransactions(const uint256& start_block, int start_height, std::optional<int> max_height, const WalletRescanReserver& reserver, const bool save_progress)
1901{
1902    constexpr auto INTERVAL_TIME{60s};
1903    auto current_time{reserver.now()};
1904    auto start_time{reserver.now()};
1905
1906    assert(reserver.isReserved());
1907
1908    uint256 block_hash = start_block;
1909    ScanResult result;
1910
1911    std::unique_ptr<FastWalletRescanFilter> fast_rescan_filter;
1912    if (chain().hasBlockFilterIndex(BlockFilterType::BASIC)) fast_rescan_filter = std::make_unique<FastWalletRescanFilter>(*this);
1913
1914    WalletLogPrintf("Rescan started from block %s... (%s)\n", start_block.ToString(),
1915                    fast_rescan_filter ? "fast variant using block filters" : "slow variant inspecting all blocks");
1916
1917    ShowProgress(strprintf("[%s] %s", DisplayName(), _("Rescanning…")), 0); // show rescan progress in GUI as dialog or on splashscreen, if rescan required on startup (e.g. due to corruption)
1918    uint256 tip_hash = WITH_LOCK(cs_wallet, return GetLastBlockHash());
1919    uint256 end_hash = tip_hash;
1920    if (max_height) chain().findAncestorByHeight(tip_hash, *max_height, FoundBlock().hash(end_hash));
1921    double progress_begin = chain().guessVerificationProgress(block_hash);
1922    double progress_end = chain().guessVerificationProgress(end_hash);
1923    double progress_current = progress_begin;
1924    int block_height = start_height;
1925    while (!fAbortRescan && !chain().shutdownRequested()) {
1926        if (progress_end - progress_begin > 0.0) {
1927            m_scanning_progress = (progress_current - progress_begin) / (progress_end - progress_begin);
1928        } else { // avoid divide-by-zero for single block scan range (i.e. start and stop hashes are equal)
1929            m_scanning_progress = 0;
1930        }
1931        if (block_height % 100 == 0 && progress_end - progress_begin > 0.0) {
1932            ShowProgress(strprintf("[%s] %s", DisplayName(), _("Rescanning…")), std::max(1, std::min(99, (int)(m_scanning_progress * 100))));
1933        }
1934
1935        bool next_interval = reserver.now() >= current_time + INTERVAL_TIME;
1936        if (next_interval) {
1937            current_time = reserver.now();
1938            WalletLogPrintf("Still rescanning. At block %d. Progress=%f\n", block_height, progress_current);
1939        }
1940
1941        bool fetch_block{true};
1942        if (fast_rescan_filter) {
1943            fast_rescan_filter->UpdateIfNeeded();
1944            auto matches_block{fast_rescan_filter->MatchesBlock(block_hash)};
1945            if (matches_block.has_value()) {
1946                if (*matches_block) {
1947                    LogDebug(BCLog::SCAN, "Fast rescan: inspect block %d [%s] (filter matched)\n", block_height, block_hash.ToString());
1948                } else {
1949                    result.last_scanned_block = block_hash;
1950                    result.last_scanned_height = block_height;
1951                    fetch_block = false;
1952                }
1953            } else {
1954                LogDebug(BCLog::SCAN, "Fast rescan: inspect block %d [%s] (WARNING: block filter not found!)\n", block_height, block_hash.ToString());
1955            }
1956        }
1957
1958        // Find next block separately from reading data above, because reading
1959        // is slow and there might be a reorg while it is read.
1960        bool block_still_active = false;
1961        bool next_block = false;
1962        uint256 next_block_hash;
1963        chain().findBlock(block_hash, FoundBlock().inActiveChain(block_still_active).nextBlock(FoundBlock().inActiveChain(next_block).hash(next_block_hash)));
1964
1965        if (fetch_block) {
1966            // Read block data and locator if needed (the locator is usually null unless we need to save progress)
1967            CBlock block;
1968            CBlockLocator loc;
1969            // Find block
1970            FoundBlock found_block{FoundBlock().data(block)};
1971            if (save_progress && next_interval) found_block.locator(loc);
1972            chain().findBlock(block_hash, found_block);
1973
1974            if (!block.IsNull()) {
1975                LOCK(cs_wallet);
1976                if (!block_still_active) {
1977                    // Abort scan if current block is no longer active, to prevent
1978                    // marking transactions as coming from the wrong block.
1979                    result.last_failed_block = block_hash;
1980                    result.status = ScanResult::FAILURE;
1981                    break;
1982                }
1983                for (size_t posInBlock = 0; posInBlock < block.vtx.size(); ++posInBlock) {
1984                    SyncTransaction(block.vtx[posInBlock], TxStateConfirmed{block_hash, block_height, static_cast<int>(posInBlock)}, /*rescanning_old_block=*/true);
1985                }
1986                // scan succeeded, record block as most recent successfully scanned
1987                result.last_scanned_block = block_hash;
1988                result.last_scanned_height = block_height;
1989
1990                if (!loc.IsNull()) {
1991                    WalletLogPrintf("Saving scan progress %d.\n", block_height);
1992                    WalletBatch batch(GetDatabase());
1993                    batch.WriteBestBlock(loc);
1994                }
1995            } else {
1996                // could not scan block, keep scanning but record this block as the most recent failure
1997                result.last_failed_block = block_hash;
1998                result.status = ScanResult::FAILURE;
1999            }
2000        }