Remove gArgs global from CreateChainParams to aid testing

MarcoFalke · MarcoFalke · commit fa23308e9aad · 2020-09-29T10:20:05.000+02:00
diff --git a/src/bench/checkblock.cpp b/src/bench/checkblock.cpp
@@ -34,7 +34,8 @@ static void DeserializeAndCheckBlockTest(benchmark::Bench& bench)
     char a = '\0';
     stream.write(&a, 1); // Prevent compaction
 
-    const auto chainParams = CreateChainParams(CBaseChainParams::MAIN);
+    ArgsManager bench_args;
+    const auto chainParams = CreateChainParams(bench_args, CBaseChainParams::MAIN);
 
     bench.unit("block").run([&] {
         CBlock block; // Note that CBlock caches its checked state, so we need to recreate it here
diff --git a/src/chainparams.cpp b/src/chainparams.cpp
@@ -485,22 +485,22 @@ const CChainParams &Params() {
     return *globalChainParams;
 }
 
-std::unique_ptr<const CChainParams> CreateChainParams(const std::string& chain)
+std::unique_ptr<const CChainParams> CreateChainParams(const ArgsManager& args, const std::string& chain)
 {
     if (chain == CBaseChainParams::MAIN) {
         return std::unique_ptr<CChainParams>(new CMainParams());
     } else if (chain == CBaseChainParams::TESTNET) {
         return std::unique_ptr<CChainParams>(new CTestNetParams());
     } else if (chain == CBaseChainParams::SIGNET) {
-        return std::unique_ptr<CChainParams>(new SigNetParams(gArgs));
+        return std::unique_ptr<CChainParams>(new SigNetParams(args));
     } else if (chain == CBaseChainParams::REGTEST) {
-        return std::unique_ptr<CChainParams>(new CRegTestParams(gArgs));
+        return std::unique_ptr<CChainParams>(new CRegTestParams(args));
     }
     throw std::runtime_error(strprintf("%s: Unknown chain %s.", __func__, chain));
 }
 
 void SelectParams(const std::string& network)
 {
     SelectBaseParams(network);
-    globalChainParams = CreateChainParams(network);
+    globalChainParams = CreateChainParams(gArgs, network);
 }
diff --git a/src/chainparams.h b/src/chainparams.h
@@ -119,7 +119,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 std::string& chain);
+std::unique_ptr<const CChainParams> CreateChainParams(const ArgsManager& args, const std::string& chain);
 
 /**
  * Return the currently selected parameters. This won't change after app
diff --git a/src/init.cpp b/src/init.cpp
@@ -380,10 +380,10 @@ void SetupServerArgs(NodeContext& node)
     const auto testnetBaseParams = CreateBaseChainParams(CBaseChainParams::TESTNET);
     const auto signetBaseParams = CreateBaseChainParams(CBaseChainParams::SIGNET);
     const auto regtestBaseParams = CreateBaseChainParams(CBaseChainParams::REGTEST);
-    const auto defaultChainParams = CreateChainParams(CBaseChainParams::MAIN);
-    const auto testnetChainParams = CreateChainParams(CBaseChainParams::TESTNET);
-    const auto signetChainParams = CreateChainParams(CBaseChainParams::SIGNET);
-    const auto regtestChainParams = CreateChainParams(CBaseChainParams::REGTEST);
+    const auto defaultChainParams = CreateChainParams(argsman, CBaseChainParams::MAIN);
+    const auto testnetChainParams = CreateChainParams(argsman, CBaseChainParams::TESTNET);
+    const auto signetChainParams = CreateChainParams(argsman, CBaseChainParams::SIGNET);
+    const auto regtestChainParams = CreateChainParams(argsman, CBaseChainParams::REGTEST);
 
     // Hidden Options
     std::vector<std::string> hidden_args = {
diff --git a/src/qt/paymentserver.cpp b/src/qt/paymentserver.cpp
@@ -94,12 +94,12 @@ void PaymentServer::ipcParseCommandLine(int argc, char* argv[])
             SendCoinsRecipient r;
             if (GUIUtil::parseBitcoinURI(arg, &r) && !r.address.isEmpty())
             {
-                auto tempChainParams = CreateChainParams(CBaseChainParams::MAIN);
+                auto tempChainParams = CreateChainParams(gArgs, CBaseChainParams::MAIN);
 
                 if (IsValidDestinationString(r.address.toStdString(), *tempChainParams)) {
                     SelectParams(CBaseChainParams::MAIN);
                 } else {
-                    tempChainParams = CreateChainParams(CBaseChainParams::TESTNET);
+                    tempChainParams = CreateChainParams(gArgs, CBaseChainParams::TESTNET);
                     if (IsValidDestinationString(r.address.toStdString(), *tempChainParams)) {
                         SelectParams(CBaseChainParams::TESTNET);
                     }
diff --git a/src/test/miner_tests.cpp b/src/test/miner_tests.cpp
@@ -198,7 +198,7 @@ void MinerTestingSetup::TestPackageSelection(const CChainParams& chainparams, co
 BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
 {
     // Note that by default, these tests run with size accounting enabled.
-    const auto chainParams = CreateChainParams(CBaseChainParams::MAIN);
+    const auto chainParams = CreateChainParams(*m_node.args, CBaseChainParams::MAIN);
     const CChainParams& chainparams = *chainParams;
     CScript scriptPubKey = CScript() << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f") << OP_CHECKSIG;
     std::unique_ptr<CBlockTemplate> pblocktemplate;
diff --git a/src/test/pow_tests.cpp b/src/test/pow_tests.cpp
@@ -14,7 +14,7 @@ BOOST_FIXTURE_TEST_SUITE(pow_tests, BasicTestingSetup)
 /* Test calculation of next difficulty target with no constraints applying */
 BOOST_AUTO_TEST_CASE(get_next_work)
 {
-    const auto chainParams = CreateChainParams(CBaseChainParams::MAIN);
+    const auto chainParams = CreateChainParams(*m_node.args, CBaseChainParams::MAIN);
     int64_t nLastRetargetTime = 1261130161; // Block #30240
     CBlockIndex pindexLast;
     pindexLast.nHeight = 32255;
@@ -26,7 +26,7 @@ BOOST_AUTO_TEST_CASE(get_next_work)
 /* Test the constraint on the upper bound for next work */
 BOOST_AUTO_TEST_CASE(get_next_work_pow_limit)
 {
-    const auto chainParams = CreateChainParams(CBaseChainParams::MAIN);
+    const auto chainParams = CreateChainParams(*m_node.args, CBaseChainParams::MAIN);
     int64_t nLastRetargetTime = 1231006505; // Block #0
     CBlockIndex pindexLast;
     pindexLast.nHeight = 2015;
@@ -38,7 +38,7 @@ BOOST_AUTO_TEST_CASE(get_next_work_pow_limit)
 /* Test the constraint on the lower bound for actual time taken */
 BOOST_AUTO_TEST_CASE(get_next_work_lower_limit_actual)
 {
-    const auto chainParams = CreateChainParams(CBaseChainParams::MAIN);
+    const auto chainParams = CreateChainParams(*m_node.args, CBaseChainParams::MAIN);
     int64_t nLastRetargetTime = 1279008237; // Block #66528
     CBlockIndex pindexLast;
     pindexLast.nHeight = 68543;
@@ -50,7 +50,7 @@ BOOST_AUTO_TEST_CASE(get_next_work_lower_limit_actual)
 /* Test the constraint on the upper bound for actual time taken */
 BOOST_AUTO_TEST_CASE(get_next_work_upper_limit_actual)
 {
-    const auto chainParams = CreateChainParams(CBaseChainParams::MAIN);
+    const auto chainParams = CreateChainParams(*m_node.args, CBaseChainParams::MAIN);
     int64_t nLastRetargetTime = 1263163443; // NOTE: Not an actual block time
     CBlockIndex pindexLast;
     pindexLast.nHeight = 46367;
@@ -61,7 +61,7 @@ BOOST_AUTO_TEST_CASE(get_next_work_upper_limit_actual)
 
 BOOST_AUTO_TEST_CASE(CheckProofOfWork_test_negative_target)
 {
-    const auto consensus = CreateChainParams(CBaseChainParams::MAIN)->GetConsensus();
+    const auto consensus = CreateChainParams(*m_node.args, CBaseChainParams::MAIN)->GetConsensus();
     uint256 hash;
     unsigned int nBits;
     nBits = UintToArith256(consensus.powLimit).GetCompact(true);
@@ -71,7 +71,7 @@ BOOST_AUTO_TEST_CASE(CheckProofOfWork_test_negative_target)
 
 BOOST_AUTO_TEST_CASE(CheckProofOfWork_test_overflow_target)
 {
-    const auto consensus = CreateChainParams(CBaseChainParams::MAIN)->GetConsensus();
+    const auto consensus = CreateChainParams(*m_node.args, CBaseChainParams::MAIN)->GetConsensus();
     uint256 hash;
     unsigned int nBits = ~0x00800000;
     hash.SetHex("0x1");
@@ -80,7 +80,7 @@ BOOST_AUTO_TEST_CASE(CheckProofOfWork_test_overflow_target)
 
 BOOST_AUTO_TEST_CASE(CheckProofOfWork_test_too_easy_target)
 {
-    const auto consensus = CreateChainParams(CBaseChainParams::MAIN)->GetConsensus();
+    const auto consensus = CreateChainParams(*m_node.args, CBaseChainParams::MAIN)->GetConsensus();
     uint256 hash;
     unsigned int nBits;
     arith_uint256 nBits_arith = UintToArith256(consensus.powLimit);
@@ -92,7 +92,7 @@ BOOST_AUTO_TEST_CASE(CheckProofOfWork_test_too_easy_target)
 
 BOOST_AUTO_TEST_CASE(CheckProofOfWork_test_biger_hash_than_target)
 {
-    const auto consensus = CreateChainParams(CBaseChainParams::MAIN)->GetConsensus();
+    const auto consensus = CreateChainParams(*m_node.args, CBaseChainParams::MAIN)->GetConsensus();
     uint256 hash;
     unsigned int nBits;
     arith_uint256 hash_arith = UintToArith256(consensus.powLimit);
@@ -104,7 +104,7 @@ BOOST_AUTO_TEST_CASE(CheckProofOfWork_test_biger_hash_than_target)
 
 BOOST_AUTO_TEST_CASE(CheckProofOfWork_test_zero_target)
 {
-    const auto consensus = CreateChainParams(CBaseChainParams::MAIN)->GetConsensus();
+    const auto consensus = CreateChainParams(*m_node.args, CBaseChainParams::MAIN)->GetConsensus();
     uint256 hash;
     unsigned int nBits;
     arith_uint256 hash_arith{0};
@@ -115,7 +115,7 @@ BOOST_AUTO_TEST_CASE(CheckProofOfWork_test_zero_target)
 
 BOOST_AUTO_TEST_CASE(GetBlockProofEquivalentTime_test)
 {
-    const auto chainParams = CreateChainParams(CBaseChainParams::MAIN);
+    const auto chainParams = CreateChainParams(*m_node.args, CBaseChainParams::MAIN);
     std::vector<CBlockIndex> blocks(10000);
     for (int i = 0; i < 10000; i++) {
         blocks[i].pprev = i ? &blocks[i - 1] : nullptr;
@@ -135,9 +135,9 @@ BOOST_AUTO_TEST_CASE(GetBlockProofEquivalentTime_test)
     }
 }
 
-void sanity_check_chainparams(std::string chainName)
+void sanity_check_chainparams(const ArgsManager& args, std::string chainName)
 {
-    const auto chainParams = CreateChainParams(chainName);
+    const auto chainParams = CreateChainParams(args, chainName);
     const auto consensus = chainParams->GetConsensus();
 
     // hash genesis is correct
@@ -164,22 +164,22 @@ void sanity_check_chainparams(std::string chainName)
 
 BOOST_AUTO_TEST_CASE(ChainParams_MAIN_sanity)
 {
-    sanity_check_chainparams(CBaseChainParams::MAIN);
+    sanity_check_chainparams(*m_node.args, CBaseChainParams::MAIN);
 }
 
 BOOST_AUTO_TEST_CASE(ChainParams_REGTEST_sanity)
 {
-    sanity_check_chainparams(CBaseChainParams::REGTEST);
+    sanity_check_chainparams(*m_node.args, CBaseChainParams::REGTEST);
 }
 
 BOOST_AUTO_TEST_CASE(ChainParams_TESTNET_sanity)
 {
-    sanity_check_chainparams(CBaseChainParams::TESTNET);
+    sanity_check_chainparams(*m_node.args, CBaseChainParams::TESTNET);
 }
 
 BOOST_AUTO_TEST_CASE(ChainParams_SIGNET_sanity)
 {
-    sanity_check_chainparams(CBaseChainParams::SIGNET);
+    sanity_check_chainparams(*m_node.args, CBaseChainParams::SIGNET);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/validation_tests.cpp b/src/test/validation_tests.cpp
@@ -39,15 +39,15 @@ static void TestBlockSubsidyHalvings(int nSubsidyHalvingInterval)
 
 BOOST_AUTO_TEST_CASE(block_subsidy_test)
 {
-    const auto chainParams = CreateChainParams(CBaseChainParams::MAIN);
+    const auto chainParams = CreateChainParams(*m_node.args, CBaseChainParams::MAIN);
     TestBlockSubsidyHalvings(chainParams->GetConsensus()); // As in main
     TestBlockSubsidyHalvings(150); // As in regtest
     TestBlockSubsidyHalvings(1000); // Just another interval
 }
 
 BOOST_AUTO_TEST_CASE(subsidy_limit_test)
 {
-    const auto chainParams = CreateChainParams(CBaseChainParams::MAIN);
+    const auto chainParams = CreateChainParams(*m_node.args, CBaseChainParams::MAIN);
     CAmount nSum = 0;
     for (int nHeight = 0; nHeight < 14000000; nHeight += 1000) {
         CAmount nSubsidy = GetBlockSubsidy(nHeight, chainParams->GetConsensus());
diff --git a/src/test/versionbits_tests.cpp b/src/test/versionbits_tests.cpp
@@ -223,7 +223,7 @@ BOOST_AUTO_TEST_CASE(versionbits_test)
     }
 
     // Sanity checks of version bit deployments
-    const auto chainParams = CreateChainParams(CBaseChainParams::MAIN);
+    const auto chainParams = CreateChainParams(*m_node.args, CBaseChainParams::MAIN);
     const Consensus::Params &mainnetParams = chainParams->GetConsensus();
     for (int i=0; i<(int) Consensus::MAX_VERSION_BITS_DEPLOYMENTS; i++) {
         uint32_t bitmask = VersionBitsMask(mainnetParams, static_cast<Consensus::DeploymentPos>(i));
@@ -250,7 +250,7 @@ BOOST_AUTO_TEST_CASE(versionbits_computeblockversion)
 {
     // Check that ComputeBlockVersion will set the appropriate bit correctly
     // on mainnet.
-    const auto chainParams = CreateChainParams(CBaseChainParams::MAIN);
+    const auto chainParams = CreateChainParams(*m_node.args, CBaseChainParams::MAIN);
     const Consensus::Params &mainnetParams = chainParams->GetConsensus();
 
     // Use the TESTDUMMY deployment for testing purposes.

Original file line number	Diff line number	Diff line change
`@@ -485,22 +485,22 @@ const CChainParams &Params() {`
`485`	`485`	`return *globalChainParams;`
`486`	`486`	`}`
`487`	`487`
`488`		`-std::unique_ptr<const CChainParams> CreateChainParams(const std::string& chain)`
	`488`	`+std::unique_ptr<const CChainParams> CreateChainParams(const ArgsManager& args, const std::string& chain)`
`489`	`489`	`{`
`490`	`490`	`if (chain == CBaseChainParams::MAIN) {`
`491`	`491`	`return std::unique_ptr<CChainParams>(new CMainParams());`
`492`	`492`	`} else if (chain == CBaseChainParams::TESTNET) {`
`493`	`493`	`return std::unique_ptr<CChainParams>(new CTestNetParams());`
`494`	`494`	`} else if (chain == CBaseChainParams::SIGNET) {`
`495`		`- return std::unique_ptr<CChainParams>(new SigNetParams(gArgs));`
	`495`	`+ return std::unique_ptr<CChainParams>(new SigNetParams(args));`
`496`	`496`	`} else if (chain == CBaseChainParams::REGTEST) {`
`497`		`- return std::unique_ptr<CChainParams>(new CRegTestParams(gArgs));`
	`497`	`+ return std::unique_ptr<CChainParams>(new CRegTestParams(args));`
`498`	`498`	`}`
`499`	`499`	`throw std::runtime_error(strprintf("%s: Unknown chain %s.", __func__, chain));`
`500`	`500`	`}`
`501`	`501`
`502`	`502`	`void SelectParams(const std::string& network)`
`503`	`503`	`{`
`504`	`504`	`SelectBaseParams(network);`
`505`		`- globalChainParams = CreateChainParams(network);`
	`505`	`+ globalChainParams = CreateChainParams(gArgs, network);`
`506`	`506`	`}`
Original file line number	Diff line number	Diff line change
`@@ -94,12 +94,12 @@ void PaymentServer::ipcParseCommandLine(int argc, char* argv[])`
`94`	`94`	`SendCoinsRecipient r;`
`95`	`95`	`if (GUIUtil::parseBitcoinURI(arg, &r) && !r.address.isEmpty())`
`96`	`96`	`{`
`97`		`- auto tempChainParams = CreateChainParams(CBaseChainParams::MAIN);`
	`97`	`+ auto tempChainParams = CreateChainParams(gArgs, CBaseChainParams::MAIN);`
`98`	`98`
`99`	`99`	`if (IsValidDestinationString(r.address.toStdString(), *tempChainParams)) {`
`100`	`100`	`SelectParams(CBaseChainParams::MAIN);`
`101`	`101`	`} else {`
`102`		`- tempChainParams = CreateChainParams(CBaseChainParams::TESTNET);`
	`102`	`+ tempChainParams = CreateChainParams(gArgs, CBaseChainParams::TESTNET);`
`103`	`103`	`if (IsValidDestinationString(r.address.toStdString(), *tempChainParams)) {`
`104`	`104`	`SelectParams(CBaseChainParams::TESTNET);`
`105`	`105`	`}`
Original file line number	Diff line number	Diff line change
`@@ -198,7 +198,7 @@ void MinerTestingSetup::TestPackageSelection(const CChainParams& chainparams, co`
`198`	`198`	`BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)`
`199`	`199`	`{`
`200`	`200`	`// Note that by default, these tests run with size accounting enabled.`
`201`		`- const auto chainParams = CreateChainParams(CBaseChainParams::MAIN);`
	`201`	`+ const auto chainParams = CreateChainParams(*m_node.args, CBaseChainParams::MAIN);`
`202`	`202`	`const CChainParams& chainparams = *chainParams;`
`203`	`203`	`CScript scriptPubKey = CScript() << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f") << OP_CHECKSIG;`
`204`	`204`	`std::unique_ptr<CBlockTemplate> pblocktemplate;`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ BOOST_FIXTURE_TEST_SUITE(pow_tests, BasicTestingSetup)`
`14`	`14`	`/* Test calculation of next difficulty target with no constraints applying */`
`15`	`15`	`BOOST_AUTO_TEST_CASE(get_next_work)`
`16`	`16`	`{`
`17`		`- const auto chainParams = CreateChainParams(CBaseChainParams::MAIN);`
	`17`	`+ const auto chainParams = CreateChainParams(*m_node.args, CBaseChainParams::MAIN);`
`18`	`18`	`int64_t nLastRetargetTime = 1261130161; // Block #30240`
`19`	`19`	`CBlockIndex pindexLast;`
`20`	`20`	`pindexLast.nHeight = 32255;`
`@@ -26,7 +26,7 @@ BOOST_AUTO_TEST_CASE(get_next_work)`
`26`	`26`	`/* Test the constraint on the upper bound for next work */`
`27`	`27`	`BOOST_AUTO_TEST_CASE(get_next_work_pow_limit)`
`28`	`28`	`{`
`29`		`- const auto chainParams = CreateChainParams(CBaseChainParams::MAIN);`
	`29`	`+ const auto chainParams = CreateChainParams(*m_node.args, CBaseChainParams::MAIN);`
`30`	`30`	`int64_t nLastRetargetTime = 1231006505; // Block #0`
`31`	`31`	`CBlockIndex pindexLast;`
`32`	`32`	`pindexLast.nHeight = 2015;`
`@@ -38,7 +38,7 @@ BOOST_AUTO_TEST_CASE(get_next_work_pow_limit)`
`38`	`38`	`/* Test the constraint on the lower bound for actual time taken */`
`39`	`39`	`BOOST_AUTO_TEST_CASE(get_next_work_lower_limit_actual)`
`40`	`40`	`{`
`41`		`- const auto chainParams = CreateChainParams(CBaseChainParams::MAIN);`
	`41`	`+ const auto chainParams = CreateChainParams(*m_node.args, CBaseChainParams::MAIN);`
`42`	`42`	`int64_t nLastRetargetTime = 1279008237; // Block #66528`
`43`	`43`	`CBlockIndex pindexLast;`
`44`	`44`	`pindexLast.nHeight = 68543;`
`@@ -50,7 +50,7 @@ BOOST_AUTO_TEST_CASE(get_next_work_lower_limit_actual)`
`50`	`50`	`/* Test the constraint on the upper bound for actual time taken */`
`51`	`51`	`BOOST_AUTO_TEST_CASE(get_next_work_upper_limit_actual)`
`52`	`52`	`{`
`53`		`- const auto chainParams = CreateChainParams(CBaseChainParams::MAIN);`
	`53`	`+ const auto chainParams = CreateChainParams(*m_node.args, CBaseChainParams::MAIN);`
`54`	`54`	`int64_t nLastRetargetTime = 1263163443; // NOTE: Not an actual block time`
`55`	`55`	`CBlockIndex pindexLast;`
`56`	`56`	`pindexLast.nHeight = 46367;`
`@@ -61,7 +61,7 @@ BOOST_AUTO_TEST_CASE(get_next_work_upper_limit_actual)`
`61`	`61`
`62`	`62`	`BOOST_AUTO_TEST_CASE(CheckProofOfWork_test_negative_target)`
`63`	`63`	`{`
`64`		`- const auto consensus = CreateChainParams(CBaseChainParams::MAIN)->GetConsensus();`
	`64`	`+ const auto consensus = CreateChainParams(*m_node.args, CBaseChainParams::MAIN)->GetConsensus();`
`65`	`65`	`uint256 hash;`
`66`	`66`	`unsigned int nBits;`
`67`	`67`	`nBits = UintToArith256(consensus.powLimit).GetCompact(true);`
`@@ -71,7 +71,7 @@ BOOST_AUTO_TEST_CASE(CheckProofOfWork_test_negative_target)`
`71`	`71`
`72`	`72`	`BOOST_AUTO_TEST_CASE(CheckProofOfWork_test_overflow_target)`
`73`	`73`	`{`
`74`		`- const auto consensus = CreateChainParams(CBaseChainParams::MAIN)->GetConsensus();`
	`74`	`+ const auto consensus = CreateChainParams(*m_node.args, CBaseChainParams::MAIN)->GetConsensus();`
`75`	`75`	`uint256 hash;`
`76`	`76`	`unsigned int nBits = ~0x00800000;`
`77`	`77`	`hash.SetHex("0x1");`
`@@ -80,7 +80,7 @@ BOOST_AUTO_TEST_CASE(CheckProofOfWork_test_overflow_target)`
`80`	`80`
`81`	`81`	`BOOST_AUTO_TEST_CASE(CheckProofOfWork_test_too_easy_target)`
`82`	`82`	`{`
`83`		`- const auto consensus = CreateChainParams(CBaseChainParams::MAIN)->GetConsensus();`
	`83`	`+ const auto consensus = CreateChainParams(*m_node.args, CBaseChainParams::MAIN)->GetConsensus();`
`84`	`84`	`uint256 hash;`
`85`	`85`	`unsigned int nBits;`
`86`	`86`	`arith_uint256 nBits_arith = UintToArith256(consensus.powLimit);`
`@@ -92,7 +92,7 @@ BOOST_AUTO_TEST_CASE(CheckProofOfWork_test_too_easy_target)`
`92`	`92`
`93`	`93`	`BOOST_AUTO_TEST_CASE(CheckProofOfWork_test_biger_hash_than_target)`
`94`	`94`	`{`
`95`		`- const auto consensus = CreateChainParams(CBaseChainParams::MAIN)->GetConsensus();`
	`95`	`+ const auto consensus = CreateChainParams(*m_node.args, CBaseChainParams::MAIN)->GetConsensus();`
`96`	`96`	`uint256 hash;`
`97`	`97`	`unsigned int nBits;`
`98`	`98`	`arith_uint256 hash_arith = UintToArith256(consensus.powLimit);`
`@@ -104,7 +104,7 @@ BOOST_AUTO_TEST_CASE(CheckProofOfWork_test_biger_hash_than_target)`
`104`	`104`
`105`	`105`	`BOOST_AUTO_TEST_CASE(CheckProofOfWork_test_zero_target)`
`106`	`106`	`{`
`107`		`- const auto consensus = CreateChainParams(CBaseChainParams::MAIN)->GetConsensus();`
	`107`	`+ const auto consensus = CreateChainParams(*m_node.args, CBaseChainParams::MAIN)->GetConsensus();`
`108`	`108`	`uint256 hash;`
`109`	`109`	`unsigned int nBits;`
`110`	`110`	`arith_uint256 hash_arith{0};`
`@@ -115,7 +115,7 @@ BOOST_AUTO_TEST_CASE(CheckProofOfWork_test_zero_target)`
`115`	`115`
`116`	`116`	`BOOST_AUTO_TEST_CASE(GetBlockProofEquivalentTime_test)`
`117`	`117`	`{`
`118`		`- const auto chainParams = CreateChainParams(CBaseChainParams::MAIN);`
	`118`	`+ const auto chainParams = CreateChainParams(*m_node.args, CBaseChainParams::MAIN);`
`119`	`119`	`std::vector<CBlockIndex> blocks(10000);`
`120`	`120`	`for (int i = 0; i < 10000; i++) {`
`121`	`121`	`blocks[i].pprev = i ? &blocks[i - 1] : nullptr;`
`@@ -135,9 +135,9 @@ BOOST_AUTO_TEST_CASE(GetBlockProofEquivalentTime_test)`
`135`	`135`	`}`
`136`	`136`	`}`
`137`	`137`
`138`		`-void sanity_check_chainparams(std::string chainName)`
	`138`	`+void sanity_check_chainparams(const ArgsManager& args, std::string chainName)`
`139`	`139`	`{`
`140`		`- const auto chainParams = CreateChainParams(chainName);`
	`140`	`+ const auto chainParams = CreateChainParams(args, chainName);`
`141`	`141`	`const auto consensus = chainParams->GetConsensus();`
`142`	`142`
`143`	`143`	`// hash genesis is correct`
`@@ -164,22 +164,22 @@ void sanity_check_chainparams(std::string chainName)`
`164`	`164`
`165`	`165`	`BOOST_AUTO_TEST_CASE(ChainParams_MAIN_sanity)`
`166`	`166`	`{`
`167`		`- sanity_check_chainparams(CBaseChainParams::MAIN);`
	`167`	`+ sanity_check_chainparams(*m_node.args, CBaseChainParams::MAIN);`
`168`	`168`	`}`
`169`	`169`
`170`	`170`	`BOOST_AUTO_TEST_CASE(ChainParams_REGTEST_sanity)`
`171`	`171`	`{`
`172`		`- sanity_check_chainparams(CBaseChainParams::REGTEST);`
	`172`	`+ sanity_check_chainparams(*m_node.args, CBaseChainParams::REGTEST);`
`173`	`173`	`}`
`174`	`174`
`175`	`175`	`BOOST_AUTO_TEST_CASE(ChainParams_TESTNET_sanity)`
`176`	`176`	`{`
`177`		`- sanity_check_chainparams(CBaseChainParams::TESTNET);`
	`177`	`+ sanity_check_chainparams(*m_node.args, CBaseChainParams::TESTNET);`
`178`	`178`	`}`
`179`	`179`
`180`	`180`	`BOOST_AUTO_TEST_CASE(ChainParams_SIGNET_sanity)`
`181`	`181`	`{`
`182`		`- sanity_check_chainparams(CBaseChainParams::SIGNET);`
	`182`	`+ sanity_check_chainparams(*m_node.args, CBaseChainParams::SIGNET);`
`183`	`183`	`}`
`184`	`184`
`185`	`185`	`BOOST_AUTO_TEST_SUITE_END()`
Original file line number	Diff line number	Diff line change
`@@ -39,15 +39,15 @@ static void TestBlockSubsidyHalvings(int nSubsidyHalvingInterval)`
`39`	`39`
`40`	`40`	`BOOST_AUTO_TEST_CASE(block_subsidy_test)`
`41`	`41`	`{`
`42`		`- const auto chainParams = CreateChainParams(CBaseChainParams::MAIN);`
	`42`	`+ const auto chainParams = CreateChainParams(*m_node.args, CBaseChainParams::MAIN);`
`43`	`43`	`TestBlockSubsidyHalvings(chainParams->GetConsensus()); // As in main`
`44`	`44`	`TestBlockSubsidyHalvings(150); // As in regtest`
`45`	`45`	`TestBlockSubsidyHalvings(1000); // Just another interval`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`BOOST_AUTO_TEST_CASE(subsidy_limit_test)`
`49`	`49`	`{`
`50`		`- const auto chainParams = CreateChainParams(CBaseChainParams::MAIN);`
	`50`	`+ const auto chainParams = CreateChainParams(*m_node.args, CBaseChainParams::MAIN);`
`51`	`51`	`CAmount nSum = 0;`
`52`	`52`	`for (int nHeight = 0; nHeight < 14000000; nHeight += 1000) {`
`53`	`53`	`CAmount nSubsidy = GetBlockSubsidy(nHeight, chainParams->GetConsensus());`