Modify chain consensus parameters to be height aware (#1396)

* Modify chain consensus parameters to be height aware
* Correct implementation of simplified rewards in parameters
* Correct max money
* Use base block version in IsSuperMajority() instead of full version
* Correct mining of blocks in AuxPoW tests
* Add in missing pre-AuxPoW consensus checks

6 files changed, 67 insertions, 23 deletions

diff --git a/src/test/auxpow_tests.cpp b/src/test/auxpow_tests.cpp
index 5cb2e3269..ca1a93062 100644
--- a/src/test/auxpow_tests.cpp
+++ b/src/test/auxpow_tests.cpp
@@ -181,7 +181,7 @@ CAuxpowBuilder::buildCoinbaseData(bool header, const std::vector<unsigned char>&
 
 BOOST_AUTO_TEST_CASE(check_auxpow)
 {
-    const Consensus::Params& params = Params().GetConsensus();
+    const Consensus::Params& params = Params().GetConsensus(371337);
     CAuxpowBuilder builder(5, 42);
     CAuxPow auxpow;
 
@@ -333,7 +333,7 @@ mineBlock(CBlockHeader& block, bool ok, int nBits = -1)
 
     block.nNonce = 0;
     while (true) {
-        const bool nowOk = (UintToArith256(block.GetHash()) <= target);
+        const bool nowOk = (UintToArith256(block.GetPoWHash()) <= target);
         if ((ok && nowOk) || (!ok && !nowOk))
             break;
 
@@ -341,16 +341,16 @@ mineBlock(CBlockHeader& block, bool ok, int nBits = -1)
     }
 
     if (ok)
-        BOOST_CHECK(CheckProofOfWork(block.GetHash(), nBits, Params().GetConsensus()));
+        BOOST_CHECK(CheckProofOfWork(block.GetPoWHash(), nBits, Params().GetConsensus(0)));
     else
-        BOOST_CHECK(!CheckProofOfWork(block.GetHash(), nBits, Params().GetConsensus()));
+        BOOST_CHECK(!CheckProofOfWork(block.GetPoWHash(), nBits, Params().GetConsensus(0)));
 }
 
 BOOST_AUTO_TEST_CASE(auxpow_pow)
 {
     /* Use regtest parameters to allow mining with easy difficulty.  */
     SelectParams(CBaseChainParams::REGTEST);
-    const Consensus::Params& params = Params().GetConsensus();
+    const Consensus::Params& params = Params().GetConsensus(371337);
 
     const arith_uint256 target = (~arith_uint256(0) >> 1);
     CBlockHeader block;
diff --git a/src/test/blockencodings_tests.cpp b/src/test/blockencodings_tests.cpp
index d8d772f6b..8d5323532 100644
--- a/src/test/blockencodings_tests.cpp
+++ b/src/test/blockencodings_tests.cpp
@@ -47,7 +47,7 @@ static CBlock BuildBlockTestCase() {
     bool mutated;
     block.hashMerkleRoot = BlockMerkleRoot(block, &mutated);
     assert(!mutated);
-    while (!CheckProofOfWork(block.GetPoWHash(), block.nBits, Params().GetConsensus())) ++block.nNonce;
+    while (!CheckProofOfWork(block.GetPoWHash(), block.nBits, Params().GetConsensus(0))) ++block.nNonce;
     return block;
 }
 
@@ -103,6 +103,7 @@ BOOST_AUTO_TEST_CASE(SimpleRoundTripTest)
         BOOST_CHECK(block.hashMerkleRoot != BlockMerkleRoot(block2, &mutated));
 
         CBlock block3;
+        // FIXME: Somehow this seems to be broken by adding chain ID to RegTest
         BOOST_CHECK(partialBlock.FillBlock(block3, {block.vtx[1]}) == READ_STATUS_OK);
         BOOST_CHECK_EQUAL(block.GetHash().ToString(), block3.GetHash().ToString());
         BOOST_CHECK_EQUAL(block.hashMerkleRoot.ToString(), BlockMerkleRoot(block3, &mutated).ToString());
@@ -206,6 +207,7 @@ BOOST_AUTO_TEST_CASE(NonCoinbasePreforwardRTTest)
 
         CBlock block3;
         PartiallyDownloadedBlock partialBlockCopy = partialBlock;
+        // FIXME: Somehow this seems to be broken by adding chain ID to RegTest
         BOOST_CHECK(partialBlock.FillBlock(block3, {block.vtx[0]}) == READ_STATUS_OK);
         BOOST_CHECK_EQUAL(block.GetHash().ToString(), block3.GetHash().ToString());
         BOOST_CHECK_EQUAL(block.hashMerkleRoot.ToString(), BlockMerkleRoot(block3, &mutated).ToString());
@@ -256,6 +258,7 @@ BOOST_AUTO_TEST_CASE(SufficientPreforwardRTTest)
 
         CBlock block2;
         PartiallyDownloadedBlock partialBlockCopy = partialBlock;
+        // FIXME: Somehow this seems to be broken by adding chain ID to RegTest
         BOOST_CHECK(partialBlock.FillBlock(block2, {}) == READ_STATUS_OK);
         BOOST_CHECK_EQUAL(block.GetHash().ToString(), block2.GetHash().ToString());
         bool mutated;
@@ -289,7 +292,7 @@ BOOST_AUTO_TEST_CASE(EmptyBlockRoundTripTest)
     bool mutated;
     block.hashMerkleRoot = BlockMerkleRoot(block, &mutated);
     assert(!mutated);
-    while (!CheckProofOfWork(block.GetPoWHash(), block.nBits, Params().GetConsensus())) ++block.nNonce;
+    while (!CheckProofOfWork(block.GetPoWHash(), block.nBits, Params().GetConsensus(0))) ++block.nNonce;
 
     // Test simple header round-trip with only coinbase
     {
@@ -307,6 +310,7 @@ BOOST_AUTO_TEST_CASE(EmptyBlockRoundTripTest)
 
         CBlock block2;
         std::vector<CTransactionRef> vtx_missing;
+        // FIXME: Somehow this seems to be broken by adding chain ID to RegTest
         BOOST_CHECK(partialBlock.FillBlock(block2, vtx_missing) == READ_STATUS_OK);
         BOOST_CHECK_EQUAL(block.GetHash().ToString(), block2.GetHash().ToString());
         BOOST_CHECK_EQUAL(block.hashMerkleRoot.ToString(), BlockMerkleRoot(block2, &mutated).ToString());
diff --git a/src/test/dogecoin_tests.cpp b/src/test/dogecoin_tests.cpp
index db6d7c89a..3ba86618e 100644
--- a/src/test/dogecoin_tests.cpp
+++ b/src/test/dogecoin_tests.cpp
@@ -62,23 +62,26 @@ BOOST_AUTO_TEST_CASE(subsidy_limit_test)
 {
     int nHeight = 0;
     int nStepSize= 1;
-    const Consensus::Params& params = Params(CBaseChainParams::MAIN).GetConsensus();
+    const CChainParams& mainParams = Params(CBaseChainParams::MAIN);
     CAmount nSum = 0;
     uint256 prevHash = uint256S("0");
 
     for (nHeight = 0; nHeight <= 100000; nHeight++) {
+        const Consensus::Params& params = mainParams.GetConsensus(nHeight);
         CAmount nSubsidy = GetDogecoinBlockSubsidy(nHeight, params, prevHash);
         BOOST_CHECK(MoneyRange(nSubsidy));
         BOOST_CHECK(nSubsidy <= 1000000 * COIN);
         nSum += nSubsidy * nStepSize;
     }
     for (; nHeight <= 145000; nHeight++) {
+        const Consensus::Params& params = mainParams.GetConsensus(nHeight);
         CAmount nSubsidy = GetDogecoinBlockSubsidy(nHeight, params, prevHash);
         BOOST_CHECK(MoneyRange(nSubsidy));
         BOOST_CHECK(nSubsidy <= 500000 * COIN);
         nSum += nSubsidy * nStepSize;
     }
     for (; nHeight < 600000; nHeight++) {
+        const Consensus::Params& params = mainParams.GetConsensus(nHeight);
         CAmount nSubsidy = GetDogecoinBlockSubsidy(nHeight, params, prevHash);
         CAmount nExpectedSubsidy = (500000 >> (nHeight / 100000)) * COIN;
         BOOST_CHECK(MoneyRange(nSubsidy));
@@ -94,7 +97,8 @@ BOOST_AUTO_TEST_CASE(subsidy_limit_test)
     BOOST_CHECK(nSum >= lowerlimit);
 
     // Test reward at 600k+ is constant
-    CAmount nConstantSubsidy = GetDogecoinBlockSubsidy(600000, params, prevHash);
+    const Consensus::Params& params = mainParams.GetConsensus(nHeight);
+    CAmount nConstantSubsidy = GetDogecoinBlockSubsidy(nHeight, params, prevHash);
     BOOST_CHECK_EQUAL(nConstantSubsidy, 10000 * COIN);
 
     nConstantSubsidy = GetDogecoinBlockSubsidy(700000, params, prevHash);
@@ -104,7 +108,7 @@ BOOST_AUTO_TEST_CASE(subsidy_limit_test)
 BOOST_AUTO_TEST_CASE(get_next_work_difficulty_limit)
 {
     SelectParams(CBaseChainParams::MAIN);
-    const Consensus::Params& params = Params().GetConsensus();
+    const Consensus::Params& params = Params().GetConsensus(0);
 
     CBlockIndex pindexLast;
     int64_t nLastRetargetTime = 1386474927; // Block # 1
@@ -118,7 +122,7 @@ BOOST_AUTO_TEST_CASE(get_next_work_difficulty_limit)
 BOOST_AUTO_TEST_CASE(get_next_work_pre_digishield)
 {
     SelectParams(CBaseChainParams::MAIN);
-    const Consensus::Params& params = Params().GetConsensus();
+    const Consensus::Params& params = Params().GetConsensus(0);
     
     CBlockIndex pindexLast;
     int64_t nLastRetargetTime = 1386942008; // Block 9359
@@ -132,7 +136,7 @@ BOOST_AUTO_TEST_CASE(get_next_work_pre_digishield)
 BOOST_AUTO_TEST_CASE(get_next_work_digishield)
 {
     SelectParams(CBaseChainParams::MAIN);
-    const Consensus::Params& params = Params().GetConsensus();
+    const Consensus::Params& params = Params().GetConsensus(145000);
     
     CBlockIndex pindexLast;
     int64_t nLastRetargetTime = 1395094427;
@@ -147,7 +151,7 @@ BOOST_AUTO_TEST_CASE(get_next_work_digishield)
 BOOST_AUTO_TEST_CASE(get_next_work_digishield_modulated_upper)
 {
     SelectParams(CBaseChainParams::MAIN);
-    const Consensus::Params& params = Params().GetConsensus();
+    const Consensus::Params& params = Params().GetConsensus(145000);
     
     CBlockIndex pindexLast;
     int64_t nLastRetargetTime = 1395100835;
@@ -162,7 +166,7 @@ BOOST_AUTO_TEST_CASE(get_next_work_digishield_modulated_upper)
 BOOST_AUTO_TEST_CASE(get_next_work_digishield_modulated_lower)
 {
     SelectParams(CBaseChainParams::MAIN);
-    const Consensus::Params& params = Params().GetConsensus();
+    const Consensus::Params& params = Params().GetConsensus(145000);
     
     CBlockIndex pindexLast;
     int64_t nLastRetargetTime = 1395380517;
@@ -177,7 +181,7 @@ BOOST_AUTO_TEST_CASE(get_next_work_digishield_modulated_lower)
 BOOST_AUTO_TEST_CASE(get_next_work_digishield_rounding)
 {
     SelectParams(CBaseChainParams::MAIN);
-    const Consensus::Params& params = Params().GetConsensus();
+    const Consensus::Params& params = Params().GetConsensus(145000);
     
     CBlockIndex pindexLast;
     int64_t nLastRetargetTime = 1395094679;
@@ -190,4 +194,40 @@ BOOST_AUTO_TEST_CASE(get_next_work_digishield_rounding)
     BOOST_CHECK_EQUAL(CalculateDogecoinNextWorkRequired(&pindexLast, nLastRetargetTime, params), 0x1b6558a4);
 }
 
+BOOST_AUTO_TEST_CASE(hardfork_parameters)
+{
+    SelectParams(CBaseChainParams::MAIN);
+    const Consensus::Params& initialParams = Params().GetConsensus(0);
+
+    BOOST_CHECK_EQUAL(initialParams.nPowTargetTimespan, 14400);
+    BOOST_CHECK_EQUAL(initialParams.fAllowLegacyBlocks, true);
+    BOOST_CHECK_EQUAL(initialParams.fDigishieldDifficultyCalculation, false);
+
+    const Consensus::Params& initialParamsEnd = Params().GetConsensus(144999);
+    BOOST_CHECK_EQUAL(initialParamsEnd.nPowTargetTimespan, 14400);
+    BOOST_CHECK_EQUAL(initialParamsEnd.fAllowLegacyBlocks, true);
+    BOOST_CHECK_EQUAL(initialParamsEnd.fDigishieldDifficultyCalculation, false);
+
+    const Consensus::Params& digishieldParams = Params().GetConsensus(145000);
+    BOOST_CHECK_EQUAL(digishieldParams.nPowTargetTimespan, 60);
+    BOOST_CHECK_EQUAL(digishieldParams.fAllowLegacyBlocks, true);
+    BOOST_CHECK_EQUAL(digishieldParams.fDigishieldDifficultyCalculation, true);
+
+    const Consensus::Params& digishieldParamsEnd = Params().GetConsensus(371336);
+    BOOST_CHECK_EQUAL(digishieldParamsEnd.nPowTargetTimespan, 60);
+    BOOST_CHECK_EQUAL(digishieldParamsEnd.fAllowLegacyBlocks, true);
+    BOOST_CHECK_EQUAL(digishieldParamsEnd.fDigishieldDifficultyCalculation, true);
+
+    const Consensus::Params& auxpowParams = Params().GetConsensus(371337);
+    BOOST_CHECK_EQUAL(auxpowParams.nHeightEffective, 371337);
+    BOOST_CHECK_EQUAL(auxpowParams.nPowTargetTimespan, 60);
+    BOOST_CHECK_EQUAL(auxpowParams.fAllowLegacyBlocks, false);
+    BOOST_CHECK_EQUAL(auxpowParams.fDigishieldDifficultyCalculation, true);
+
+    const Consensus::Params& auxpowHighParams = Params().GetConsensus(700000); // Arbitrary point after last hard-fork
+    BOOST_CHECK_EQUAL(auxpowHighParams.nPowTargetTimespan, 60);
+    BOOST_CHECK_EQUAL(auxpowHighParams.fAllowLegacyBlocks, false);
+    BOOST_CHECK_EQUAL(auxpowHighParams.fDigishieldDifficultyCalculation, true);
+}
+
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/pow_tests.cpp b/src/test/pow_tests.cpp
index a51714ad7..a90e6896b 100644
--- a/src/test/pow_tests.cpp
+++ b/src/test/pow_tests.cpp
@@ -18,7 +18,7 @@ BOOST_FIXTURE_TEST_SUITE(pow_tests, BasicTestingSetup)
 /* BOOST_AUTO_TEST_CASE(get_next_work)
 {
     SelectParams(CBaseChainParams::MAIN);
-    const Consensus::Params& params = Params().GetConsensus();
+    const Consensus::Params& params = Params().GetConsensus(0);
 
     int64_t nLastRetargetTime = 1261130161; // Block #30240
     CBlockIndex pindexLast;
@@ -33,7 +33,7 @@ BOOST_FIXTURE_TEST_SUITE(pow_tests, BasicTestingSetup)
 /* BOOST_AUTO_TEST_CASE(get_next_work_pow_limit)
 {
     SelectParams(CBaseChainParams::MAIN);
-    const Consensus::Params& params = Params().GetConsensus();
+    const Consensus::Params& params = Params().GetConsensus(0);
 
     int64_t nLastRetargetTime = 1231006505; // Block #0
     CBlockIndex pindexLast;
@@ -48,7 +48,7 @@ BOOST_FIXTURE_TEST_SUITE(pow_tests, BasicTestingSetup)
 /* BOOST_AUTO_TEST_CASE(get_next_work_lower_limit_actual)
 {
     SelectParams(CBaseChainParams::MAIN);
-    const Consensus::Params& params = Params().GetConsensus();
+    const Consensus::Params& params = Params().GetConsensus(0);
 
     int64_t nLastRetargetTime = 1279008237; // Block #66528
     CBlockIndex pindexLast;
@@ -63,7 +63,7 @@ BOOST_FIXTURE_TEST_SUITE(pow_tests, BasicTestingSetup)
 /* BOOST_AUTO_TEST_CASE(get_next_work_upper_limit_actual)
 {
     SelectParams(CBaseChainParams::MAIN);
-    const Consensus::Params& params = Params().GetConsensus();
+    const Consensus::Params& params = Params().GetConsensus(0);
 
     int64_t nLastRetargetTime = 1263163443; // NOTE: Not an actual block time
     CBlockIndex pindexLast;
@@ -76,7 +76,7 @@ BOOST_FIXTURE_TEST_SUITE(pow_tests, BasicTestingSetup)
 BOOST_AUTO_TEST_CASE(GetBlockProofEquivalentTime_test)
 {
     SelectParams(CBaseChainParams::MAIN);
-    const Consensus::Params& params = Params().GetConsensus();
+    const Consensus::Params& params = Params().GetConsensus(0);
 
     std::vector<CBlockIndex> blocks(10000);
     for (int i = 0; i < 10000; i++) {
diff --git a/src/test/test_bitcoin.cpp b/src/test/test_bitcoin.cpp
index 9a499357f..9a3eecf99 100644
--- a/src/test/test_bitcoin.cpp
+++ b/src/test/test_bitcoin.cpp
@@ -127,7 +127,7 @@ TestChain240Setup::CreateAndProcessBlock(const std::vector<CMutableTransaction>&
     unsigned int extraNonce = 0;
     IncrementExtraNonce(&block, chainActive.Tip(), extraNonce);
 
-    while (!CheckProofOfWork(block.GetPoWHash(), block.nBits, chainparams.GetConsensus())) ++block.nNonce;
+    while (!CheckProofOfWork(block.GetPoWHash(), block.nBits, chainparams.GetConsensus(0))) ++block.nNonce;
 
     std::shared_ptr<const CBlock> shared_pblock = std::make_shared<const CBlock>(block);
     ProcessNewBlock(chainparams, shared_pblock, true, NULL);
diff --git a/src/test/versionbits_tests.cpp b/src/test/versionbits_tests.cpp
index e2b5573ab..7427a1e57 100644
--- a/src/test/versionbits_tests.cpp
+++ b/src/test/versionbits_tests.cpp
@@ -209,7 +209,7 @@ BOOST_AUTO_TEST_CASE(versionbits_test)
     }
 
     // Sanity checks of version bit deployments
-    const Consensus::Params &mainnetParams = Params(CBaseChainParams::MAIN).GetConsensus();
+    const Consensus::Params &mainnetParams = Params(CBaseChainParams::MAIN).GetConsensus(0);
     for (int i=0; i<(int) Consensus::MAX_VERSION_BITS_DEPLOYMENTS; i++) {
         uint32_t bitmask = VersionBitsMask(mainnetParams, (Consensus::DeploymentPos)i);
         // Make sure that no deployment tries to set an invalid bit.
@@ -235,7 +235,7 @@ BOOST_AUTO_TEST_CASE(versionbits_computeblockversion)
 {
     // Check that ComputeBlockVersion will set the appropriate bit correctly
     // on mainnet.
-    const Consensus::Params &mainnetParams = Params(CBaseChainParams::MAIN).GetConsensus();
+    const Consensus::Params &mainnetParams = Params(CBaseChainParams::MAIN).GetConsensus(0);
 
     // Use the TESTDUMMY deployment for testing purposes.
     int64_t bit = mainnetParams.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit;