Differential D7174 Diff 22875 src/pow/test/aserti32d_tests.cpp

Changeset View

Standalone View

src/pow/test/aserti32d_tests.cpp

This file was added.

				// Copyright (c) 2020 The Bitcoin Core developers
				// Distributed under the MIT/X11 software license, see the accompanying
				// file COPYING or http://www.opensource.org/licenses/mit-license.php.

				#include <pow/aserti32d.h>

				#include <chain.h>
				#include <chainparams.h>
				#include <config.h>
				#include <consensus/activation.h>
				#include <pow/pow.h>

				#include <test/util/setup_common.h>

				#include <boost/test/unit_test.hpp>

				#include <cmath>

				BOOST_FIXTURE_TEST_SUITE(aserti32d_tests, BasicTestingSetup)

				static CBlockIndex GetBlockIndex(CBlockIndex *pindexPrev, int64_t nTimeInterval,
				uint32_t nBits) {
				CBlockIndex block;
				block.pprev = pindexPrev;
				block.nHeight = pindexPrev->nHeight + 1;
				block.nTime = pindexPrev->nTime + nTimeInterval;
				block.nBits = nBits;

				block.BuildSkip();
				block.nChainWork = pindexPrev->nChainWork + GetBlockProof(block);
				return block;
				}

				static double TargetFromBits(const uint32_t nBits) {
				return (nBits & 0xff'ff'ff) * pow(256, (nBits >> 24) - 3);
				}

				static double
				GetASERTApproximationError(const CBlockIndex *pindexPrev,
				const uint32_t finalBits,
				const CBlockIndex *pindexReferenceBlock) {
				const int64_t nHeightDiff =
				pindexPrev->nHeight - pindexReferenceBlock->nHeight;
				const int64_t nTimeDiff = pindexPrev->nTime - pindexReferenceBlock->nTime;
				const uint32_t initialBits = pindexReferenceBlock->nBits;

				BOOST_CHECK(nHeightDiff >= 0);
				double dInitialPow = TargetFromBits(initialBits);
				double dFinalPow = TargetFromBits(finalBits);

				double dExponent =
				double(nTimeDiff - nHeightDiff * 600) / double(2 * 24 * 3600);
				double dTarget = dInitialPow * pow(2, dExponent);

				return (dFinalPow - dTarget) / dTarget;
				}

				BOOST_AUTO_TEST_CASE(asert_difficulty_test) {
				DummyConfig config(CBaseChainParams::MAIN);

				std::vector<CBlockIndex> blocks(3000 + 2 * 24 * 3600);

				const Consensus::Params &params = config.GetChainParams().GetConsensus();
				const arith_uint256 powLimit = UintToArith256(params.powLimit);
				arith_uint256 currentPow = powLimit >> 3;
				uint32_t initialBits = currentPow.GetCompact();
				double dMaxErr = 0.0001166792656486;
				jasonbcoxUnsubmitted Not Done Inline Actions const `initialBits` and `dMaxErr` jasonbcox: const `initialBits` and `dMaxErr`

				// Genesis block, also ASERT reference block in this test case.
				blocks[0] = CBlockIndex();
				blocks[0].nHeight = 0;
				blocks[0].nTime = 1269211443;
				blocks[0].nBits = initialBits;

				blocks[0].nChainWork = GetBlockProof(blocks[0]);

				// Block counter.
				size_t i;
				jasonbcoxUnsubmitted Not Done Inline Actions If you have to comment the variable name, it's probably a bad name. Just call it `bidx` or something like you did in the other parts. jasonbcox: If you have to comment the variable name, it's probably a bad name. Just call it `bidx` or…

				// Pile up some blocks every 10 mins to establish some history.
				for (i = 1; i < 150; i++) {
				blocks[i] = GetBlockIndex(&blocks[i - 1], 600, initialBits);
				BOOST_CHECK_EQUAL(blocks[i].nBits, initialBits);
				}

				CBlockHeader blkHeaderDummy;
				uint32_t nBits = GetNextASERTWorkRequired(&blocks[i - 1], &blkHeaderDummy,
				params, &blocks[1]);

				BOOST_CHECK_EQUAL(nBits, initialBits);

				// Difficulty stays the same as long as we produce a block every 10 mins.
				for (size_t j = 0; j < 10; i++, j++) {
				blocks[i] = GetBlockIndex(&blocks[i - 1], 600, nBits);
				BOOST_CHECK_EQUAL(GetNextASERTWorkRequired(&blocks[i], &blkHeaderDummy,
				params, &blocks[1]),
				nBits);
				}

				// If we add a two blocks whose solvetimes together add up to 1200s,
				// then the next block's target should be the same as the one before these
				// blocks (at this point, equal to initialBits).
				blocks[i] = GetBlockIndex(&blocks[i - 1], 300, nBits);
				nBits = GetNextASERTWorkRequired(&blocks[i++], &blkHeaderDummy, params,
				&blocks[1]);
				BOOST_CHECK(fabs(GetASERTApproximationError(&blocks[i - 1], nBits,
				&blocks[0])) < dMaxErr);
				blocks[i] = GetBlockIndex(&blocks[i - 1], 900, nBits);
				nBits = GetNextASERTWorkRequired(&blocks[i++], &blkHeaderDummy, params,
				&blocks[1]);
				BOOST_CHECK(fabs(GetASERTApproximationError(&blocks[i - 1], nBits,
				&blocks[1])) < dMaxErr);
				BOOST_CHECK_EQUAL(nBits, initialBits);
				BOOST_CHECK(nBits != blocks[i - 1].nBits);

				// Same in reverse - this time slower block first, followed by faster block.
				blocks[i] = GetBlockIndex(&blocks[i - 1], 900, nBits);
				nBits = GetNextASERTWorkRequired(&blocks[i++], &blkHeaderDummy, params,
				&blocks[1]);
				BOOST_CHECK(fabs(GetASERTApproximationError(&blocks[i - 1], nBits,
				&blocks[1])) < dMaxErr);
				blocks[i] = GetBlockIndex(&blocks[i - 1], 300, nBits);
				nBits = GetNextASERTWorkRequired(&blocks[i++], &blkHeaderDummy, params,
				&blocks[1]);
				BOOST_CHECK(fabs(GetASERTApproximationError(&blocks[i - 1], nBits,
				&blocks[1])) < dMaxErr);
				BOOST_CHECK_EQUAL(nBits, initialBits);
				BOOST_CHECK(nBits != blocks[i - 1].nBits);

				// Jumping forward 2 days should double the target (halve the difficulty)
				blocks[i] = GetBlockIndex(&blocks[i - 1], 600 + 2 * 24 * 3600, nBits);
				nBits = GetNextASERTWorkRequired(&blocks[i++], &blkHeaderDummy, params,
				&blocks[1]);
				BOOST_CHECK(fabs(GetASERTApproximationError(&blocks[i - 1], nBits,
				&blocks[1])) < dMaxErr);
				currentPow = arith_uint256().SetCompact(nBits) / 2;
				BOOST_CHECK_EQUAL(currentPow.GetCompact(), initialBits);

				// Iterate over the entire -2243600..+2243600 range to check that our
				// integer approximation:
				// 1. Should be monotonic.
				// 2. Should change target at least once every 8 seconds (worst-case:
				// 15-bit precision on nBits).
				// 3. Should never change target by more than XXXX per 1-second step.
				// 4. Never exceeds dMaxError in absolute error vs a double float
				// calculation.
				// 5. Has almost exactly the dMax and dMin errors we expect for the
				// formula.
				double dMin = 0;
				double dMax = 0;
				double dErr;
				double dMaxStep = 0;
				uint32_t nBitsRingBuffer[8];
				double dStep = 0;
				blocks[i] = GetBlockIndex(&blocks[i - 1], -2 * 24 * 3600 - 30, nBits);
				for (size_t j = 0; j < 4 * 24 * 3600 + 660; j++) {
				blocks[i].nTime++;
				nBits = GetNextASERTWorkRequired(&blocks[i], &blkHeaderDummy, params,
				&blocks[1]);

				if (j > 8) {
				// 1: Monotonic
				BOOST_CHECK(
				arith_uint256().SetCompact(nBits) >=
				arith_uint256().SetCompact(nBitsRingBuffer[(j - 1) % 8]));
				// 2: Changes at least once every 8 seconds (worst case: nBits =
				// 1d008000 to 1d008001)
				BOOST_CHECK(arith_uint256().SetCompact(nBits) >
				arith_uint256().SetCompact(nBitsRingBuffer[j % 8]));
				// 3: Check 1-sec step size
				dStep = (TargetFromBits(nBits) -
				TargetFromBits(nBitsRingBuffer[(j - 1) % 8])) /
				TargetFromBits(nBits);

				dMaxStep = std::max(dStep, dMaxStep);
				// from nBits = 1d008000 to 1d008001
				BOOST_CHECK(dStep < 0.0000314812106363);
				}
				nBitsRingBuffer[j % 8] = nBits;

				// 4 and 5: check error vs double precision float calculation
				dErr = GetASERTApproximationError(&blocks[i], nBits, &blocks[1]);
				dMin = std::min(dErr, dMin);
				dMax = std::max(dErr, dMax);
				BOOST_CHECK_MESSAGE(
				fabs(dErr) < dMaxErr,
				strprintf(
				"solveTime: %d\tStep size: %.8f%%\tdErr: %.8f%%\tnBits: %0x\n",
				int64_t(blocks[i].nTime) - blocks[i - 1].nTime, dStep * 100,
				dErr * 100, nBits));
				}
				const auto failMsg = strprintf(
				"Min error: %16.14f%%\tMax error: %16.14f%%\tMax step: %16.14f%%\n",
				dMin * 100, dMax * 100, dMaxStep * 100);
				BOOST_CHECK_MESSAGE(
				dMin < -0.0001013168981059 && dMin > -0.0001013168981060 &&
				dMax > 0.0001166792656485 && dMax < 0.0001166792656486,
				failMsg);

				// Difficulty increases as long as we produce fast blocks
				for (size_t j = 0; j < 100; i++, j++) {
				uint32_t nextBits;
				arith_uint256 currentTarget;
				currentTarget.SetCompact(nBits);

				blocks[i] = GetBlockIndex(&blocks[i - 1], 500, nBits);
				nextBits = GetNextASERTWorkRequired(&blocks[i], &blkHeaderDummy, params,
				&blocks[1]);
				arith_uint256 nextTarget;
				nextTarget.SetCompact(nextBits);

				// Make sure that target is decreased
				BOOST_CHECK(nextTarget <= currentTarget);

				nBits = nextBits;
				}
				}

				// Tests of the CalculateASERT function.
				BOOST_AUTO_TEST_CASE(calculate_asert_test) {
				DummyConfig config(CBaseChainParams::MAIN);
				const Consensus::Params &params = config.GetChainParams().GetConsensus();
				const int64_t nHalfLife = params.nDAAHalfLife;

				const arith_uint256 powLimit = UintToArith256(params.powLimit);
				arith_uint256 initialTarget = powLimit >> 4;
				jasonbcoxUnsubmitted Not Done Inline Actions const jasonbcox: const
				int64_t height = 0;

				// The CalculateASERT function uses the absolute ASERT formulation
				// and adds +1 to the height difference that it receives.
				// The time difference passed to it must factor in the difference
				// to the parent of the reference block.
				// We assume the parent is ideally spaced in time before the reference
				// block.
				static const int64_t parent_time_diff = 600;

				// Steady
				arith_uint256 nextTarget = CalculateASERT(
				initialTarget, params.nPowTargetSpacing,
				parent_time_diff + 600 /* nTimeDiff */, ++height, powLimit, nHalfLife);
				BOOST_CHECK(nextTarget == initialTarget);

				// A block that arrives in half the expected time
				nextTarget = CalculateASERT(initialTarget, params.nPowTargetSpacing,
				parent_time_diff + 600 + 300, ++height,
				powLimit, nHalfLife);
				BOOST_CHECK(nextTarget < initialTarget);

				// A block that makes up for the shortfall of the previous one, restores the
				// target to initial
				arith_uint256 prevTarget = nextTarget;
				nextTarget = CalculateASERT(initialTarget, params.nPowTargetSpacing,
				parent_time_diff + 600 + 300 + 900, ++height,
				powLimit, nHalfLife);
				BOOST_CHECK(nextTarget > prevTarget);
				BOOST_CHECK(nextTarget == initialTarget);

				// Two days ahead of schedule should halve the target (double the
				// difficulty)
				prevTarget = nextTarget;
				nextTarget =
				CalculateASERT(prevTarget, params.nPowTargetSpacing,
				parent_time_diff + 288 * 1200, 288, powLimit, nHalfLife);
				BOOST_CHECK(nextTarget == prevTarget * 2);

				// Two days behind schedule should double the target (halve the difficulty)
				prevTarget = nextTarget;
				nextTarget =
				CalculateASERT(prevTarget, params.nPowTargetSpacing,
				parent_time_diff + 288 * 0, 288, powLimit, nHalfLife);
				BOOST_CHECK(nextTarget == prevTarget / 2);
				BOOST_CHECK(nextTarget == initialTarget);

				// Ramp up from initialTarget to PowLimit - should only take 4 doublings...
				uint32_t powLimit_nBits = powLimit.GetCompact();
				jasonbcoxUnsubmitted Not Done Inline Actions const jasonbcox: const
				uint32_t next_nBits;
				for (size_t k = 0; k < 3; k++) {
				prevTarget = nextTarget;
				nextTarget = CalculateASERT(prevTarget, params.nPowTargetSpacing,
				parent_time_diff + 288 * 1200, 288,
				powLimit, nHalfLife);
				BOOST_CHECK(nextTarget == prevTarget * 2);
				BOOST_CHECK(nextTarget < powLimit);
				next_nBits = nextTarget.GetCompact();
				BOOST_CHECK(next_nBits != powLimit_nBits);
				}

				prevTarget = nextTarget;
				nextTarget =
				CalculateASERT(prevTarget, params.nPowTargetSpacing,
				parent_time_diff + 288 * 1200, 288, powLimit, nHalfLife);
				next_nBits = nextTarget.GetCompact();
				BOOST_CHECK(nextTarget == prevTarget * 2);
				BOOST_CHECK(next_nBits == powLimit_nBits);

				// Fast periods now cannot increase target beyond POW limit, even if we try
				// to overflow nextTarget. prevTarget is a uint256, so 256*2 = 512 days
				// would overflow nextTarget unless CalculateASERT correctly detects this
				// error
				nextTarget = CalculateASERT(prevTarget, params.nPowTargetSpacing,
				parent_time_diff + 512 * 144 * 600, 0, powLimit,
				nHalfLife);
				next_nBits = nextTarget.GetCompact();
				BOOST_CHECK(next_nBits == powLimit_nBits);

				// We also need to watch for underflows on nextTarget. We need to withstand
				// an extra ~446 days worth of blocks. This should bring down a powLimit
				// target to the a minimum target of 1.
				nextTarget = CalculateASERT(powLimit, params.nPowTargetSpacing, 0,
				2 * (256 - 33) * 144, powLimit, nHalfLife);
				next_nBits = nextTarget.GetCompact();
				BOOST_CHECK_EQUAL(next_nBits, arith_uint256(1).GetCompact());

				// Define a structure holding parameters to pass to CalculateASERT.
				// We are going to check some expected results against a vector of
				// possible arguments.
				struct calc_params {
				arith_uint256 refTarget;
				int64_t targetSpacing;
				int64_t timeDiff;
				int64_t heightDiff;
				arith_uint256 expectedTarget;
				uint32_t expectednBits;
				};

				// Define some named input argument values
				const arith_uint256 SINGLE_300_TARGET{
				"00000000ffb1ffffffffffffffffffffffffffffffffffffffffffffffffffff"};
				const arith_uint256 FUNNY_REF_TARGET{
				"000000008000000000000000000fffffffffffffffffffffffffffffffffffff"};

				// Define our expected input and output values.
				// The timeDiff entries exclude the `parent_time_diff` - this is
				// added in the call to CalculateASERT in the test loop.
				const std::vector<calc_params> calculate_args = {

				/* refTarget, targetSpacing, timeDiff, heightDiff, expectedTarget,
				expectednBits */

				{powLimit, 600, 0, 2 * 144, powLimit >> 1, 0x1c7fffff},
				{powLimit, 600, 0, 4 * 144, powLimit >> 2, 0x1c3fffff},
				{powLimit >> 1, 600, 0, 2 * 144, powLimit >> 2, 0x1c3fffff},
				{powLimit >> 2, 600, 0, 2 * 144, powLimit >> 3, 0x1c1fffff},
				{powLimit >> 3, 600, 0, 2 * 144, powLimit >> 4, 0x1c0fffff},
				{powLimit, 600, 0, 2 * (256 - 34) * 144, 3, 0x01030000},
				{powLimit, 600, 0, 2 * (256 - 34) * 144 + 119, 3, 0x01030000},
				{powLimit, 600, 0, 2 * (256 - 34) * 144 + 120, 2, 0x01020000},
				{powLimit, 600, 0, 2 * (256 - 33) * 144 - 1, 2, 0x01020000},
				// 1 bit less since we do not need to shift to 0
				{powLimit, 600, 0, 2 * (256 - 33) * 144, 1, 0x01010000},
				// more will not decrease below 1
				{powLimit, 600, 0, 2 * (256 - 32) * 144, 1, 0x01010000},
				{1, 600, 0, 2 * (256 - 32) * 144, 1, 0x01010000},
				{powLimit, 600, 2 * (512 - 32) * 144, 0, powLimit, powLimit_nBits},
				{1, 600, (512 - 64) * 144 * 600, 0, powLimit, powLimit_nBits},
				// clamps to powLimit
				{powLimit, 600, 300, 1, SINGLE_300_TARGET, 0x1d00ffb1},
				// confuses any attempt to detect overflow by inspecting result
				{FUNNY_REF_TARGET, 600, 600 * 2 * 33 * 144, 0, powLimit,
				powLimit_nBits},
				};

				for (auto &v : calculate_args) {
				nextTarget = CalculateASERT(v.refTarget, v.targetSpacing,
				parent_time_diff + v.timeDiff, v.heightDiff,
				powLimit, nHalfLife);
				next_nBits = nextTarget.GetCompact();
				BOOST_CHECK_EQUAL(next_nBits, v.expectednBits);
				BOOST_CHECK(nextTarget == v.expectedTarget);
				}
				}

				class ChainParamsWithDAAActivation : public CChainParams {
				public:
				ChainParamsWithDAAActivation(const CChainParams &chainParams, int daaHeight)
				: CChainParams(chainParams) {
				consensus.daaHeight = daaHeight;
				}
				};

				/**
				* Test transition of cw144 to ASERT algorithm, which involves the selection
				* of an anchor block.
				*/
				BOOST_AUTO_TEST_CASE(asert_activation_anchor_test) {
				// Make a custom chain params based on mainnet, activating the cw144 DAA
				// at a lower height than usual, so we don't need to waste time making a
				// 504000-long chain.
				const auto mainChainParams = CreateChainParams(CBaseChainParams::MAIN);
				const ChainParamsWithDAAActivation chainParams(*mainChainParams, 2016);
				const Consensus::Params &params = chainParams.GetConsensus();

				const int64_t activationTime =
				gArgs.GetArg("-axionactivationtime", params.axionActivationTime);
				CBlockHeader blkHeaderDummy;

				// an arbitrary compact target for our chain (based on BCH chain ~ Aug 10
				// 2020).
				uint32_t initialBits = 0x1802a842;
				jasonbcoxUnsubmitted Not Done Inline Actions const jasonbcox: const

				// Block store for anonymous blocks; needs to be big enough to fit all
				// generated blocks in this test.
				std::vector<CBlockIndex> blocks(10000);
				int bidx = 1;

				// Genesis block.
				blocks[0].nHeight = 0;
				blocks[0].nTime = 1269211443;
				blocks[0].nBits = initialBits;
				blocks[0].nChainWork = GetBlockProof(blocks[0]);

				// Pile up a random number of blocks to establish some history of random
				// height. cw144 DAA requires us to have height at least 2016, dunno why
				// that much.
				const int initialBlockCount = 2000 + int(InsecureRandRange(1000));
				for (int i = 1; i < initialBlockCount; i++) {
				blocks[bidx] = GetBlockIndex(&blocks[bidx - 1], 600, initialBits);
				bidx++;
				BOOST_REQUIRE(bidx < int(blocks.size()));
				}

				// Start making blocks prior to activation. First, make a block about 1 day
				// before activation. Then put down 145 more blocks with 500 second
				// solvetime each, such that the MTP on the final block is 1 second short of
				// activationTime.
				{
				blocks[bidx] = GetBlockIndex(&blocks[bidx - 1], 600, initialBits);
				blocks[bidx].nTime = activationTime - 140 * 500 - 1;
				bidx++;
				}
				for (int i = 0; i < 145; i++) {
				BOOST_REQUIRE(bidx < int(blocks.size()));
				blocks[bidx] = GetBlockIndex(&blocks[bidx - 1], 500, initialBits);
				bidx++;
				}
				CBlockIndex *pindexPreActivation = &blocks[bidx - 1];
				BOOST_CHECK_EQUAL(pindexPreActivation->nTime, activationTime + 5 * 500 - 1);
				BOOST_CHECK_EQUAL(pindexPreActivation->GetMedianTimePast(),
				activationTime - 1);
				BOOST_CHECK(IsDAAEnabled(params, pindexPreActivation));

				// If we consult DAA, then it uses cw144 which returns a significantly lower
				// target because we have been mining too fast by a ratio 600/500 for a
				// whole day.
				BOOST_CHECK(!IsAxionEnabled(params, pindexPreActivation));
				BOOST_CHECK_EQUAL(
				GetNextWorkRequired(pindexPreActivation, &blkHeaderDummy, chainParams),
				0x180236e1);

				/**
				* Now we'll try adding on blocks to activate ASERT. The activation block
				* is going to be our anchor block. We will make several distinct anchor
				* blocks.
				*/

				// Create an activating block with expected solvetime, taking the cw144
				// difficulty we just saw. Since solvetime is expected the next target is
				// unchanged.
				CBlockIndex indexActivation0 =
				GetBlockIndex(pindexPreActivation, 600, 0x180236e1);
				BOOST_CHECK(IsAxionEnabled(params, &indexActivation0));
				BOOST_CHECK_EQUAL(
				GetNextWorkRequired(&indexActivation0, &blkHeaderDummy, chainParams),
				0x180236e1);
				// second call will have used anchor cache, shouldn't change anything
				BOOST_CHECK_EQUAL(
				GetNextWorkRequired(&indexActivation0, &blkHeaderDummy, chainParams),
				0x180236e1);
				jasonbcoxUnsubmitted Not Done Inline Actions Use `anchorBits0` everywhere this value is present. This makes it obvious that this value shouldn't be changed independently of the others. jasonbcox: Use `anchorBits0` everywhere this value is present. This makes it obvious that this value…
				deadalnixAuthorUnsubmitted Done Inline Actions I don't think this solves any problem. deadalnix: I don't think this solves any problem.
				jasonbcoxUnsubmitted Not Done Inline Actions It does, because the alternative is to Ctrl+F for `0x180236e1` to make sure all of these values are the same, rather than wasting my time verifying that every jumble of characters matches. jasonbcox: It does, because the alternative is to Ctrl+F for `0x180236e1` to make sure all of these values…

				// Now we'll generate some more activations/anchors, using unique targets
				// for each one (if the algo gets confused between different anchors, we
				// will know).

				// Create an activating block with 0 solvetime, which will drop target by
				// ~415/416.
				CBlockIndex indexActivation1 =
				GetBlockIndex(pindexPreActivation, 0, 0x18023456);
				jasonbcoxUnsubmitted Not Done Inline Actions Ditto for `anchorBits1` jasonbcox: Ditto for `anchorBits1`
				deadalnixAuthorUnsubmitted Done Inline Actions dito deadalnix: dito
				BOOST_CHECK(IsAxionEnabled(params, &indexActivation1));
				// cache will be stale here, and we should get the right result regardless:
				BOOST_CHECK_EQUAL(
				GetNextWorkRequired(&indexActivation1, &blkHeaderDummy, chainParams),
				0x180232fd);
				// second call will have used anchor cache, shouldn't change anything
				BOOST_CHECK_EQUAL(
				GetNextWorkRequired(&indexActivation1, &blkHeaderDummy, chainParams),
				0x180232fd);
				// for good measure, try again with wiped cache
				ResetASERTAnchorBlockCache();
				BOOST_CHECK_EQUAL(
				GetNextWorkRequired(&indexActivation1, &blkHeaderDummy, chainParams),
				0x180232fd);
				jasonbcoxUnsubmitted Not Done Inline Actions These three BOOST_CHECK_EQUAL calls can be made into a helper function and used throughout the test. The test isn't consistent about the cache testing, and doing this will make the test much easier to read. jasonbcox: These three BOOST_CHECK_EQUAL calls can be made into a helper function and used throughout the…
				deadalnixAuthorUnsubmitted Done Inline Actions I don't think this is buying very much. deadalnix: I don't think this is buying very much.

				// Try activation with expected solvetime, which will keep target the same.
				uint32_t anchorBits2 = 0x180210fe;
				CBlockIndex indexActivation2 =
				GetBlockIndex(pindexPreActivation, 600, anchorBits2);
				BOOST_CHECK(IsAxionEnabled(params, &indexActivation2));
				BOOST_CHECK_EQUAL(
				GetNextWorkRequired(&indexActivation2, &blkHeaderDummy, chainParams),
				anchorBits2);

				// Try a three-month solvetime which will cause us to hit powLimit.
				uint32_t anchorBits3 = 0x18034567;
				CBlockIndex indexActivation3 =
				GetBlockIndex(pindexPreActivation, 86400 * 90, anchorBits3);
				BOOST_CHECK(IsAxionEnabled(params, &indexActivation2));
				BOOST_CHECK_EQUAL(
				GetNextWorkRequired(&indexActivation3, &blkHeaderDummy, chainParams),
				0x1d00ffff);
				// If the next block jumps back in time, we get back our original difficulty
				// level.
				CBlockIndex indexActivation3_return =
				GetBlockIndex(&indexActivation3, -86400 * 90 + 2 * 600, anchorBits3);
				BOOST_CHECK_EQUAL(GetNextWorkRequired(&indexActivation3_return,
				&blkHeaderDummy, chainParams),
				anchorBits3);
				// Retry for cache
				BOOST_CHECK_EQUAL(GetNextWorkRequired(&indexActivation3_return,
				&blkHeaderDummy, chainParams),
				anchorBits3);

				// Make an activation with MTP == activation exactly. This is a backwards
				// timestamp jump so the resulting target is 1.2% lower.
				CBlockIndex indexActivation4 =
				GetBlockIndex(pindexPreActivation, 0, 0x18011111);
				indexActivation4.nTime = activationTime;
				BOOST_CHECK_EQUAL(indexActivation4.GetMedianTimePast(), activationTime);
				BOOST_CHECK(IsAxionEnabled(params, &indexActivation4));
				BOOST_CHECK_EQUAL(
				GetNextWorkRequired(&indexActivation4, &blkHeaderDummy, chainParams),
				0x18010db3);

				// Finally create a random chain on top of our second activation, using
				// ASERT targets all the way. Erase cache so that this will do a fresh
				// search for anchor at every step (fortauntely this is not too slow, due to
				// the skiplist traversal)
				CBlockIndex *pindexChain2 = &indexActivation2;
				for (int i = 1; i < 1000; i++) {
				BOOST_REQUIRE(bidx < int(blocks.size()));
				ResetASERTAnchorBlockCache();
				uint32_t nextBits =
				GetNextWorkRequired(pindexChain2, &blkHeaderDummy, chainParams);
				blocks[bidx] =
				GetBlockIndex(pindexChain2, InsecureRandRange(1200), nextBits);
				pindexChain2 = &blocks[bidx++];
				}
				// Scan back down to make sure all targets are same when we keep cached
				// anchor.
				for (CBlockIndex *pindex = pindexChain2; pindex != &indexActivation2;
				pindex = pindex->pprev) {
				uint32_t nextBits =
				GetNextWorkRequired(pindex->pprev, &blkHeaderDummy, chainParams);
				BOOST_CHECK_EQUAL(nextBits, pindex->nBits);
				}
				}

				BOOST_AUTO_TEST_SUITE_END()