Starting and stopping a Bitcoin Core node

1751    // Check for host lookup allowed before parsing any network related parameters
1752    fNameLookup = args.GetBoolArg("-dns", DEFAULT_NAME_LOOKUP);
1753
1754    bool proxyRandomize = args.GetBoolArg("-proxyrandomize", DEFAULT_PROXYRANDOMIZE);
1755    // -proxy sets a proxy for outgoing network traffic, possibly per network.
1756    // -noproxy, -proxy=0 or -proxy="" can be used to remove the proxy setting, this is the default
1757    Proxy ipv4_proxy;
1758    Proxy ipv6_proxy;
1759    Proxy onion_proxy;
1760    Proxy name_proxy;
1761    Proxy cjdns_proxy;
1762    for (const std::string& param_value : args.GetArgs("-proxy")) {
1763        const auto eq_pos{param_value.rfind('=')};
1764        const std::string proxy_str{param_value.substr(0, eq_pos)}; // e.g. 127.0.0.1:9050=ipv4 -> 127.0.0.1:9050
1765        std::string net_str;
1766        if (eq_pos != std::string::npos) {
1767            if (eq_pos + 1 == param_value.length()) {
1768                return InitError(strprintf(_("Invalid -proxy address or hostname, ends with '=': '%s'"), param_value));
1769            }
1770            net_str = param_value.substr(eq_pos + 1); // e.g. 127.0.0.1:9050=ipv4 -> ipv4
1771        }
1772
1773        Proxy proxy;
1774        if (!proxy_str.empty() && proxy_str != "0") {
1775            if (IsUnixSocketPath(proxy_str)) {
1776                proxy = Proxy{proxy_str, /*tor_stream_isolation=*/proxyRandomize};
1777            } else {
1778                const std::optional<CService> addr{Lookup(proxy_str, DEFAULT_TOR_SOCKS_PORT, fNameLookup)};
1779                if (!addr.has_value()) {
1780                    return InitError(strprintf(_("Invalid -proxy address or hostname: '%s'"), proxy_str));
1781                }
1782                proxy = Proxy{addr.value(), /*tor_stream_isolation=*/proxyRandomize};
1783            }
1784            if (!proxy.IsValid()) {
1785                return InitError(strprintf(_("Invalid -proxy address or hostname: '%s'"), proxy_str));
1786            }
1787        }
1788
1789        if (net_str.empty()) { // For all networks.
1790            ipv4_proxy = ipv6_proxy = name_proxy = cjdns_proxy = onion_proxy = proxy;
1791        } else {
1792            switch (ParseNetwork(net_str)) {
1793            case NET_IPV4: ipv4_proxy = name_proxy = proxy; break;
1794            case NET_IPV6: ipv6_proxy = name_proxy = proxy; break;
1795            case NET_ONION: onion_proxy = proxy; break;
1796            case NET_CJDNS: cjdns_proxy = proxy; break;
1797            case NET_UNROUTABLE:
1798            case NET_I2P:
1799            case NET_INTERNAL:
1800            case NET_MAX:
1801                return InitError(strprintf(_("Unrecognized network in -proxy='%s': '%s'"), param_value, net_str));
1802            } // no default case, so the compiler can warn about missing cases
1803        }
1804    }
1805    if (ipv4_proxy.IsValid()) {
1806        SetProxy(NET_IPV4, ipv4_proxy);
1807    }
1808    if (ipv6_proxy.IsValid()) {
1809        SetProxy(NET_IPV6, ipv6_proxy);
1810    }
1811    if (name_proxy.IsValid()) {
1812        SetNameProxy(name_proxy);
1813    }
1814    if (cjdns_proxy.IsValid()) {
1815        SetProxy(NET_CJDNS, cjdns_proxy);
1816    }
1817
1818    const bool onlynet_used_with_onion{!onlynets.empty() && g_reachable_nets.Contains(NET_ONION)};
1819
1820    // -onion can be used to set only a proxy for .onion, or override normal proxy for .onion addresses
1821    // -noonion (or -onion=0) disables connecting to .onion entirely
1822    // An empty string is used to not override the onion proxy (in which case it defaults to -proxy set above, or none)
1823    std::string onionArg = args.GetArg("-onion", "");
1824    if (onionArg != "") {
1825        if (onionArg == "0") { // Handle -noonion/-onion=0
1826            onion_proxy = Proxy{};
1827            if (onlynet_used_with_onion) {
1828                return InitError(
1829                    _("Outbound connections restricted to Tor (-onlynet=onion) but the proxy for "
1830                      "reaching the Tor network is explicitly forbidden: -onion=0"));
1831            }
1832        } else {
1833            if (IsUnixSocketPath(onionArg)) {
1834                onion_proxy = Proxy(onionArg, /*tor_stream_isolation=*/proxyRandomize);
1835            } else {
1836                const std::optional<CService> addr{Lookup(onionArg, DEFAULT_TOR_SOCKS_PORT, fNameLookup)};
1837                if (!addr.has_value() || !addr->IsValid()) {
1838                    return InitError(strprintf(_("Invalid -onion address or hostname: '%s'"), onionArg));
1839                }
1840
1841                onion_proxy = Proxy(addr.value(), /*tor_stream_isolation=*/proxyRandomize);
1842            }
1843        }
1844    }
1845
1846    const bool listenonion{args.GetBoolArg("-listenonion", DEFAULT_LISTEN_ONION)};
1847    if (onion_proxy.IsValid()) {
1848        SetProxy(NET_ONION, onion_proxy);
1849    } else {
1850        // If -listenonion is set, then we will (try to) connect to the Tor control port
1851        // later from the torcontrol thread and may retrieve the onion proxy from there.
1852        if (onlynet_used_with_onion && !listenonion) {
1853            return InitError(
1854                _("Outbound connections restricted to Tor (-onlynet=onion) but the proxy for "
1855                  "reaching the Tor network is not provided: none of -proxy, -onion or "
1856                  "-listenonion is given"));
1857        }
1858        g_reachable_nets.Remove(NET_ONION);
1859    }
1860
1861    for (const std::string& strAddr : args.GetArgs("-externalip")) {
1862        const std::optional<CService> addrLocal{Lookup(strAddr, GetListenPort(), fNameLookup)};
1863        if (addrLocal.has_value() && addrLocal->IsValid())
1864            AddLocal(addrLocal.value(), LOCAL_MANUAL, /*add_even_if_unreachable=*/true);
1865        else
1866            return InitError(ResolveErrMsg("externalip", strAddr));
1867    }
1868
1869#ifdef ENABLE_ZMQ
1870    g_zmq_notification_interface = CZMQNotificationInterface::Create(
1871        [&chainman = node.chainman](std::vector<std::byte>& block, const CBlockIndex& index) {
1872            assert(chainman);
1873            if (auto ret{chainman->m_blockman.ReadRawBlock(WITH_LOCK(cs_main, return index.GetBlockPos()))}) {
1874                block = std::move(*ret);
1875                return true;
1876            }
1877            return false;
1878        });
1879
1880    if (g_zmq_notification_interface) {
1881        validation_signals.RegisterValidationInterface(g_zmq_notification_interface.get());
1882    }
1883#endif
1884
1885    // ********************************************************* Step 7: load block chain
1886
1887    // cache size calculations
1888    node::LogOversizedDbCache(args);
1889    const auto [index_cache_sizes, kernel_cache_sizes] = CalculateCacheSizes(args, g_enabled_filter_types.size());
1890
1891    LogInfo("Cache configuration:");
1892    LogInfo("* Using %.1f MiB for block index database", kernel_cache_sizes.block_tree_db / double(1_MiB));
1893    if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
1894        LogInfo("* Using %.1f MiB for transaction index database", index_cache_sizes.tx_index / double(1_MiB));
1895    }
1896    if (args.GetBoolArg("-txospenderindex", DEFAULT_TXOSPENDERINDEX)) {
1897        LogInfo("* Using %.1f MiB for transaction output spender index database", index_cache_sizes.txospender_index / double(1_MiB));
1898    }
1899    for (BlockFilterType filter_type : g_enabled_filter_types) {
1900        LogInfo("* Using %.1f MiB for %s block filter index database",
1901                  index_cache_sizes.filter_index / double(1_MiB), BlockFilterTypeName(filter_type));
1902    }
1903    LogInfo("* Using %.1f MiB for chain state database", kernel_cache_sizes.coins_db / double(1_MiB));
1904
1905    assert(!node.mempool);
1906    assert(!node.chainman);
1907
1908    bool do_reindex{args.GetBoolArg("-reindex", false)};
1909    const bool do_reindex_chainstate{args.GetBoolArg("-reindex-chainstate", false)};
1910
1911    // Chainstate initialization and loading may be retried once with reindexing by GUI users
1912    auto [status, error] = InitAndLoadChainstate(
1913        node,
1914        do_reindex,
1915        do_reindex_chainstate,
1916        kernel_cache_sizes,
1917        args);
1918    if (status == ChainstateLoadStatus::FAILURE && !do_reindex && !ShutdownRequested(node)) {
1919        // suggest a reindex
1920        bool do_retry{HasTestOption(args, "reindex_after_failure_noninteractive_yes") ||
1921            uiInterface.ThreadSafeQuestion(
1922            error + Untranslated(".\n\n") + _("Do you want to rebuild the databases now?"),
1923            error.original + ".\nPlease restart with -reindex or -reindex-chainstate to recover.",
1924            CClientUIInterface::MSG_ERROR | CClientUIInterface::BTN_ABORT)};
1925        if (!do_retry) {
1926            return false;
1927        }
1928        do_reindex = true;
1929        if (!Assert(node.shutdown_signal)->reset()) {
1930            LogError("Internal error: failed to reset shutdown signal.\n");
1931        }
1932        std::tie(status, error) = InitAndLoadChainstate(
1933            node,
1934            do_reindex,
1935            do_reindex_chainstate,
1936            kernel_cache_sizes,
1937            args);
1938    }
1939    if (status != ChainstateLoadStatus::SUCCESS && status != ChainstateLoadStatus::INTERRUPTED) {
1940        return InitError(error);
1941    }
1942
1943    // As LoadBlockIndex can take several minutes, it's possible the user
1944    // requested to kill the GUI during the last operation. If so, exit.
1945    if (ShutdownRequested(node)) {
1946        LogInfo("Shutdown requested. Exiting.");
1947        return true;
1948    }
1949
1950    ChainstateManager& chainman = *Assert(node.chainman);
1951
1952    assert(!node.fee_estimator_man);
1953    // Don't initialize fee estimation with old data if we don't relay transactions,
1954    // as they would never get updated.
1955    if (!peerman_opts.ignore_incoming_txs) {
1956        bool read_stale_estimates = args.GetBoolArg("-acceptstalefeeestimates", DEFAULT_ACCEPT_STALE_FEE_ESTIMATES);
1957        if (read_stale_estimates && (chainparams.GetChainType() != ChainType::REGTEST)) {
1958            return InitError(strprintf(_("acceptstalefeeestimates is not supported on %s chain."), chainparams.GetChainTypeString()));
1959        }
1960        MaybeMigrateLegacyFeeEstimates(args);
1961        node.fee_estimator_man = std::make_unique<FeeRateEstimatorManager>(BlockPolicyFeeEstPath(args), read_stale_estimates, MempoolPolicyEstimatorPath(args), *Assert(node.mempool), chainman);
1962
1963        // Flush estimates to disk periodically
1964        FeeRateEstimatorManager* fee_estimator_man = node.fee_estimator_man.get();
1965        scheduler.scheduleEvery([fee_estimator_man] { fee_estimator_man->IntervalFlush(); }, FEE_FLUSH_INTERVAL);
1966        validation_signals.RegisterValidationInterface(fee_estimator_man);
1967    }
1968
1969    auto& kernel_notifications{*Assert(node.notifications)};
1970
1971    assert(!node.peerman);
1972    node.peerman = PeerManager::make(*node.connman, *node.addrman,
1973                                     node.banman.get(), chainman,
1974                                     *node.mempool, *node.warnings,
1975                                     peerman_opts);
1976    validation_signals.RegisterValidationInterface(node.peerman.get());
1977
1978    // ********************************************************* Step 8: start indexers
1979
1980    if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
1981        g_txindex = std::make_unique<TxIndex>(interfaces::MakeChain(node), index_cache_sizes.tx_index, false, do_reindex);
1982        node.indexes.emplace_back(g_txindex.get());
1983    }
1984
1985    if (args.GetBoolArg("-txospenderindex", DEFAULT_TXOSPENDERINDEX)) {
1986        g_txospenderindex = std::make_unique<TxoSpenderIndex>(interfaces::MakeChain(node), index_cache_sizes.txospender_index, false, do_reindex);
1987        node.indexes.emplace_back(g_txospenderindex.get());
1988    }
1989
1990    for (const auto& filter_type : g_enabled_filter_types) {
1991        InitBlockFilterIndex([&]{ return interfaces::MakeChain(node); }, filter_type, index_cache_sizes.filter_index, false, do_reindex);
1992        node.indexes.emplace_back(GetBlockFilterIndex(filter_type));
1993    }
1994
1995    if (args.GetBoolArg("-coinstatsindex", DEFAULT_COINSTATSINDEX)) {
1996        g_coin_stats_index = std::make_unique<CoinStatsIndex>(interfaces::MakeChain(node), /*cache_size=*/0, false, do_reindex);
1997        node.indexes.emplace_back(g_coin_stats_index.get());
1998    }
1999
2000    // Init indexes