Merge bitcoin#27491: refactor: Move chain constants to the util library

d168458 scripted-diff: Remove unused chainparamsbase includes (TheCharlatan)
e9ee8aa Add missing definitions in prep for scripted diff (TheCharlatan)
ba8fc7d refactor: Replace string chain name constants with ChainTypes (TheCharlatan)
401453d refactor: Introduce ChainType getters for ArgsManager (TheCharlatan)
bfc21c3 refactor: Create chaintype files (TheCharlatan)

Pull request description:

  This pull request is part of the `libbitcoinkernel` project bitcoin#24303 https://github.com/bitcoin/bitcoin/projects/18 and more specifically its "Step 2: Decouple most non-consensus code from libbitcoinkernel". It is also a follow up to bitcoin#26177.

  It replaces pull request bitcoin#27294, which just moved the constants to a new file, but did not re-declare them as enums.

  The code move of the chain name constants out of the `chainparamsbase` to their own separate header allows the kernel `chainparams` to no longer include `chainparamsbase`. The `chainparamsbase` contain references to the `ArgsManager` and networking related options that should not belong to the kernel library. Besides this move, the constants are re-declared as enums with helper functions facilitating string conversions.

ACKs for top commit:
  ryanofsky:
    Code review ACK d168458. Just suggested changes since last review.

Tree-SHA512: ac2fbe5cbbab4f52eae1e30af1f16700b6589eb4764c328a151a712adfc37f326cc94a65c385534c57d4bc92cc1a13bf1777d92bc924a20dbb30440e7380b316

Author: fanquake

src/Makefile.am

@@ -404,6 +404,7 @@ BITCOIN_CORE_H = \
   util/hash_type.h \
   util/helpers.h \
   util/asmap.h \
+  util/chaintype.h \
   util/getuniquepath.h \
   util/macros.h \
   util/message.h \
@@ -993,6 +994,7 @@ libbitcoin_util_a_SOURCES = \
   util/bip32.cpp \
   util/bytevectorhash.cpp \
   util/check.cpp \
+  util/chaintype.cpp \
   util/edge.cpp \
   util/error.cpp \
   util/fees.cpp \

src/bench/load_external.cpp

@@ -6,6 +6,7 @@
 #include <bench/data.h>
 #include <chainparams.h>
 #include <test/util/setup_common.h>
+#include <util/chaintype.h>
 #include <validation.h>
 
 /**
@@ -22,7 +23,7 @@
  */
 static void LoadExternalBlockFile(benchmark::Bench& bench)
 {
-    const auto testing_setup{MakeNoLogFileContext<const TestingSetup>(CBaseChainParams::MAIN)};
+    const auto testing_setup{MakeNoLogFileContext<const TestingSetup>(ChainType::MAIN)};
 
     // Create a single block as in the blocks files (magic bytes, block size,
     // block data) as a stream object.

src/bench/logging.cpp

@@ -5,6 +5,7 @@
 #include <bench/bench.h>
 #include <logging.h>
 #include <test/util/setup_common.h>
+#include <util/chaintype.h>
 
 // All but 2 of the benchmarks should have roughly similar performance:
 //
@@ -18,7 +19,7 @@ static void Logging(benchmark::Bench& bench, const std::vector<const char*>& ext
     LogInstance().DisableCategory(BCLog::LogFlags::ALL);
 
     TestingSetup test_setup{
-        CBaseChainParams::REGTEST,
+        ChainType::REGTEST,
         extra_args,
     };
 

src/bench/mempool_stress.cpp

@@ -6,6 +6,7 @@
 #include <policy/policy.h>
 #include <test/util/setup_common.h>
 #include <txmempool.h>
+#include <util/chaintype.h>
 #include <validation.h>
 
 #include <vector>
@@ -85,7 +86,7 @@ static void ComplexMemPool(benchmark::Bench& bench)
         childTxs = static_cast<int>(bench.complexityN());
     }
     std::vector<CTransactionRef> ordered_coins = CreateOrderedCoins(det_rand, childTxs, /*min_ancestors=*/1);
-    const auto testing_setup = MakeNoLogFileContext<const TestingSetup>(CBaseChainParams::MAIN);
+    const auto testing_setup = MakeNoLogFileContext<const TestingSetup>(ChainType::MAIN);
     CTxMemPool& pool = *testing_setup.get()->m_node.mempool;
     LOCK2(cs_main, pool.cs);
     bench.run([&]() NO_THREAD_SAFETY_ANALYSIS {
@@ -100,7 +101,7 @@ static void ComplexMemPool(benchmark::Bench& bench)
 static void MempoolCheck(benchmark::Bench& bench)
 {
     FastRandomContext det_rand{true};
-    auto testing_setup = MakeNoLogFileContext<TestChain100Setup>(CBaseChainParams::REGTEST, {"-checkmempool=1"});
+    auto testing_setup = MakeNoLogFileContext<TestChain100Setup>(ChainType::REGTEST, {"-checkmempool=1"});
     CTxMemPool& pool = *testing_setup.get()->m_node.mempool;
     LOCK2(cs_main, pool.cs);
     testing_setup->PopulateMempool(det_rand, 400, true);

src/bench/rpc_blockchain.cpp

@@ -12,14 +12,15 @@
 #include <rpc/blockchain.h>
 #include <streams.h>
 #include <test/util/setup_common.h>
+#include <util/chaintype.h>
 #include <validation.h>
 
 #include <univalue.h>
 
 namespace {
 
 struct TestBlockAndIndex {
-    const std::unique_ptr<const TestingSetup> testing_setup{MakeNoLogFileContext<const TestingSetup>(CBaseChainParams::MAIN)};
+    const std::unique_ptr<const TestingSetup> testing_setup{MakeNoLogFileContext<const TestingSetup>(ChainType::MAIN)};
     CBlock block{};
     uint256 blockHash{};
     CBlockIndex blockindex{};

src/bitcoin-util.cpp

@@ -70,7 +70,7 @@ static int AppInitUtil(ArgsManager& args, int argc, char* argv[])
 
     // Check for chain settings (Params() calls are only valid after this clause)
     try {
-        SelectParams(args.GetChainName());
+        SelectParams(args.GetChainType());
     } catch (const std::exception& e) {
         tfm::format(std::cerr, "Error: %s\n", e.what());
         return EXIT_FAILURE;

src/bitcoin-wallet.cpp

@@ -90,7 +90,7 @@ static std::optional<int> WalletAppInit(ArgsManager& args, int argc, char* argv[
         return EXIT_FAILURE;
     }
     // Check for chain settings (Params() calls are only valid after this clause)
-    SelectParams(args.GetChainName());
+    SelectParams(args.GetChainType());
 
     return std::nullopt;
 }

src/chainparams.cpp

@@ -1349,24 +1349,42 @@ const CChainParams &Params() {
     return *globalChainParams;
 }
 
-std::unique_ptr<const CChainParams> CreateChainParams(const ArgsManager& args, const std::string& chain)
+std::unique_ptr<const CChainParams> CreateChainParams(const ArgsManager& args, const ChainType chain)
 {
-    if (chain == CBaseChainParams::MAIN) {
+    if (chain == ChainType::MAIN) {
         return std::unique_ptr<CChainParams>(new CMainParams());
-    } else if (chain == CBaseChainParams::TESTNET) {
+    } else if (chain == ChainType::TESTNET) {
         return std::unique_ptr<CChainParams>(new CTestNetParams());
-    } else if (chain == CBaseChainParams::DEVNET) {
+    } else if (chain == ChainType::DEVNET) {
         return std::unique_ptr<CChainParams>(new CDevNetParams(args));
-    } else if (chain == CBaseChainParams::REGTEST) {
+    } else if (chain == ChainType::REGTEST) {
         return std::unique_ptr<CChainParams>(new CRegTestParams(args));
     }
-    throw std::runtime_error(strprintf("%s: Unknown chain %s.", __func__, chain));
+    throw std::invalid_argument(strprintf("%s: Invalid ChainType value", __func__));
+}
+
+std::unique_ptr<const CChainParams> CreateChainParams(const ArgsManager& args, const std::string& chain)
+{
+    const auto chain_type{ChainTypeFromString(chain)};
+    if (!chain_type) {
+        throw std::runtime_error(strprintf("%s: Unknown chain %s.", __func__, chain));
+    }
+    return CreateChainParams(args, *chain_type);
 }
 
-void SelectParams(const std::string& network)
+void SelectParams(const ChainType chain)
 {
-    SelectBaseParams(network);
-    globalChainParams = CreateChainParams(gArgs, network);
+    SelectBaseParams(chain);
+    globalChainParams = CreateChainParams(gArgs, chain);
+}
+
+void SelectParams(const std::string& chain)
+{
+    const auto chain_type{ChainTypeFromString(chain)};
+    if (!chain_type) {
+        throw std::runtime_error(strprintf("%s: Unknown chain %s.", __func__, chain));
+    }
+    SelectParams(*chain_type);
 }
 
 void SetupChainParamsOptions(ArgsManager& argsman)

src/chainparams.h

@@ -12,6 +12,7 @@
 #include <netaddress.h>
 #include <primitives/block.h>
 #include <protocol.h>
+#include <util/chaintype.h>
 #include <util/hash_type.h>
 
 #include <memory>
@@ -121,6 +122,8 @@ class CChainParams
     int LLMQConnectionRetryTimeout() const { return nLLMQConnectionRetryTimeout; }
     /** Return the network string */
     std::string NetworkIDString() const { return strNetworkID; }
+    ChainType GetChainType() const { return ChainTypeFromString(strNetworkID).value(); }
+    std::string GetChainTypeString() const { return strNetworkID; }
     /** Return the list of hostnames to look up for DNS seeds */
     const std::vector<std::string>& DNSSeeds() const { return vSeeds; }
     const std::vector<unsigned char>& Base58Prefix(Base58Type type) const { return base58Prefixes[type]; }
@@ -197,6 +200,7 @@ class CChainParams
  * @returns a CChainParams* of the chosen chain.
  * @throws a std::runtime_error if the chain is not supported.
  */
+std::unique_ptr<const CChainParams> CreateChainParams(const ArgsManager& args, const ChainType chain);
 std::unique_ptr<const CChainParams> CreateChainParams(const ArgsManager& args, const std::string& chain);
 
 /**
@@ -209,6 +213,7 @@ const CChainParams &Params();
  * Sets the params returned by Params() to those for the given chain name.
  * @throws std::runtime_error when the chain is not supported.
  */
+void SelectParams(const ChainType chain);
 void SelectParams(const std::string& chain);
 
 /**

src/chainparamsbase.cpp

@@ -36,22 +36,40 @@ const CBaseChainParams& BaseParams()
  * Port numbers for incoming Tor connections (9996, 19996, 19796, 19896) have
  * been chosen arbitrarily to keep ranges of used ports tight.
  */
-std::unique_ptr<CBaseChainParams> CreateBaseChainParams(const std::string& chain)
+std::unique_ptr<CBaseChainParams> CreateBaseChainParams(const ChainType chain)
 {
-    if (chain == CBaseChainParams::MAIN)
+    if (chain == ChainType::MAIN)
         return std::make_unique<CBaseChainParams>("", 9998, 9996);
-    else if (chain == CBaseChainParams::TESTNET)
+    else if (chain == ChainType::TESTNET)
         return std::make_unique<CBaseChainParams>("testnet3", 19998, 19996);
-    else if (chain == CBaseChainParams::DEVNET)
+    else if (chain == ChainType::DEVNET)
         return std::make_unique<CBaseChainParams>(gArgs.GetDevNetName(), 19798, 19796);
-    else if (chain == CBaseChainParams::REGTEST)
+    else if (chain == ChainType::REGTEST)
         return std::make_unique<CBaseChainParams>("regtest", 19898, 19896);
     else
+        throw std::invalid_argument(strprintf("%s: Invalid ChainType value", __func__));
+}
+
+std::unique_ptr<CBaseChainParams> CreateBaseChainParams(const std::string& chain)
+{
+    const auto chain_type{ChainTypeFromString(chain)};
+    if (!chain_type) {
         throw std::runtime_error(strprintf("%s: Unknown chain %s.", __func__, chain));
+    }
+    return CreateBaseChainParams(*chain_type);
 }
 
-void SelectBaseParams(const std::string& chain)
+void SelectBaseParams(const ChainType chain)
 {
     globalChainBaseParams = CreateBaseChainParams(chain);
-    gArgs.SelectConfigNetwork(chain);
+    gArgs.SelectConfigNetwork(ChainTypeToString(chain));
+}
+
+void SelectBaseParams(const std::string& chain)
+{
+    const auto chain_type{ChainTypeFromString(chain)};
+    if (!chain_type) {
+        throw std::runtime_error(strprintf("%s: Unknown chain %s.", __func__, chain));
+    }
+    SelectBaseParams(*chain_type);
 }