Page MenuHomePhabricator
Differential D571 Diff 1485 src/test/pow_tests.cpp

Changeset View

Standalone View

View Options

src/test/pow_tests.cpp

Show First 20 Lines • Show All 78 Lines • ▼ Show 20 LinesBOOST_AUTO_TEST_CASE(GetBlockProofEquivalentTime_test) {
std::vector<CBlockIndex> blocks(10000); std::vector<CBlockIndex> blocks(10000);
for (int i = 0; i < 10000; i++) { for (int i = 0; i < 10000; i++) {
blocks[i].pprev = i ? &blocks[i - 1] : nullptr; blocks[i].pprev = i ? &blocks[i - 1] : nullptr;
blocks[i].nHeight = i; blocks[i].nHeight = i;
blocks[i].nTime = 1269211443 + i * params.nPowTargetSpacing; blocks[i].nTime = 1269211443 + i * params.nPowTargetSpacing;
blocks[i].nBits = 0x207fffff; /* target 0x7fffff000... */ blocks[i].nBits = 0x207fffff; /* target 0x7fffff000... */
blocks[i].nChainWork = blocks[i].nChainWork =
i ? blocks[i - 1].nChainWork + GetBlockProof(blocks[i - 1]) i ? blocks[i - 1].nChainWork + GetBlockProof(blocks[i])
: arith_uint256(0); : arith_uint256(0);
} }
for (int j = 0; j < 1000; j++) { for (int j = 0; j < 1000; j++) {
CBlockIndex *p1 = &blocks[GetRand(10000)]; CBlockIndex *p1 = &blocks[GetRand(10000)];
CBlockIndex *p2 = &blocks[GetRand(10000)]; CBlockIndex *p2 = &blocks[GetRand(10000)];
CBlockIndex *p3 = &blocks[GetRand(10000)]; CBlockIndex *p3 = &blocks[GetRand(10000)];
int64_t tdiff = GetBlockProofEquivalentTime(*p1, *p2, *p3, params); int64_t tdiff = GetBlockProofEquivalentTime(*p1, *p2, *p3, params);
BOOST_CHECK_EQUAL(tdiff, p1->GetBlockTime() - p2->GetBlockTime()); BOOST_CHECK_EQUAL(tdiff, p1->GetBlockTime() - p2->GetBlockTime());
} }
} }
static CBlockIndex GetBlockIndex(CBlockIndex *pindexPrev, int64_t nTimeInterval, static CBlockIndex GetBlockIndex(CBlockIndex *pindexPrev, int64_t nTimeInterval,
uint32_t nBits) { uint32_t nBits) {
CBlockIndex block; CBlockIndex block;
block.pprev = pindexPrev; block.pprev = pindexPrev;
block.nHeight = pindexPrev->nHeight + 1; block.nHeight = pindexPrev->nHeight + 1;
block.nTime = pindexPrev->nTime + nTimeInterval; block.nTime = pindexPrev->nTime + nTimeInterval;
block.nBits = nBits; block.nBits = nBits;
block.nChainWork = pindexPrev->nChainWork + GetBlockProof(block);
return block; return block;
} }
BOOST_AUTO_TEST_CASE(retargeting_test) { BOOST_AUTO_TEST_CASE(retargeting_test) {
SelectParams(CBaseChainParams::MAIN); SelectParams(CBaseChainParams::MAIN);
const Consensus::Params &params = Params().GetConsensus(); const Consensus::Params &params = Params().GetConsensus();
std::vector<CBlockIndex> blocks(115); std::vector<CBlockIndex> blocks(115);
const arith_uint256 powLimit = UintToArith256(params.powLimit); const arith_uint256 powLimit = UintToArith256(params.powLimit);
arith_uint256 currentPow = powLimit >> 1; arith_uint256 currentPow = powLimit >> 1;
uint32_t initialBits = currentPow.GetCompact(); uint32_t initialBits = currentPow.GetCompact();
// Genesis block? // Genesis block.
blocks[0] = CBlockIndex(); blocks[0] = CBlockIndex();
blocks[0].nHeight = 0; blocks[0].nHeight = 0;
blocks[0].nTime = 1269211443; blocks[0].nTime = 1269211443;
blocks[0].nBits = initialBits; blocks[0].nBits = initialBits;
blocks[0].nChainWork = GetBlockProof(blocks[0]);
// Pile up some blocks. // Pile up some blocks.
for (size_t i = 1; i < 100; i++) { for (size_t i = 1; i < 100; i++) {
blocks[i] = GetBlockIndex(&blocks[i - 1], params.nPowTargetSpacing, blocks[i] = GetBlockIndex(&blocks[i - 1], params.nPowTargetSpacing,
initialBits); initialBits);
} }
CBlockHeader blkHeaderDummy; CBlockHeader blkHeaderDummy;
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 LinesBOOST_AUTO_TEST_CASE(retargeting_test) {
// Once we reached the minimal difficulty, we stick with it. // Once we reached the minimal difficulty, we stick with it.
blocks[114] = GetBlockIndex(&blocks[113], 2 * 3600, powLimit.GetCompact()); blocks[114] = GetBlockIndex(&blocks[113], 2 * 3600, powLimit.GetCompact());
BOOST_CHECK(powLimit.GetCompact() != currentPow.GetCompact()); BOOST_CHECK(powLimit.GetCompact() != currentPow.GetCompact());
BOOST_CHECK_EQUAL( BOOST_CHECK_EQUAL(
GetNextWorkRequired(&blocks[114], &blkHeaderDummy, params), GetNextWorkRequired(&blocks[114], &blkHeaderDummy, params),
powLimit.GetCompact()); powLimit.GetCompact());
} }
BOOST_AUTO_TEST_CASE(cash_difficulty_test) {
SelectParams(CBaseChainParams::MAIN);
const Consensus::Params &params = Params().GetConsensus();
std::vector<CBlockIndex> blocks(2500);
const arith_uint256 powLimit = UintToArith256(params.powLimit);
uint32_t powLimitBits = powLimit.GetCompact();
arith_uint256 currentPow = powLimit >> 4;
uint32_t initialBits = currentPow.GetCompact();
// Genesis block.
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;
// Pile up some blocks every 10 mins to establish some history.
for (i = 1; i < 2050; i++) {
blocks[i] = GetBlockIndex(&blocks[i - 1], 600, initialBits);
}
CBlockHeader blkHeaderDummy;
uint32_t nBits =
GetNextCashWorkRequired(&blocks[2049], &blkHeaderDummy, params);
// 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(
GetNextCashWorkRequired(&blocks[i], &blkHeaderDummy, params),
nBits);
}
// Make sure we skip over blocks that are out of wack. To do so, we produce
// a block that is far in the future, and then produce a block with the
// expected timestamp.
blocks[i] = GetBlockIndex(&blocks[i - 1], 6000, nBits);
BOOST_CHECK_EQUAL(
GetNextCashWorkRequired(&blocks[i++], &blkHeaderDummy, params), nBits);
blocks[i] = GetBlockIndex(&blocks[i - 1], 2 * 600 - 6000, nBits);
BOOST_CHECK_EQUAL(
GetNextCashWorkRequired(&blocks[i++], &blkHeaderDummy, params), nBits);
// The system should continue unaffected by the block with a bogous
// timestamps.
for (size_t j = 0; j < 20; i++, j++) {
blocks[i] = GetBlockIndex(&blocks[i - 1], 600, nBits);
BOOST_CHECK_EQUAL(
GetNextCashWorkRequired(&blocks[i], &blkHeaderDummy, params),
nBits);
}
// We start emitting blocks slightly faster. The first block has no impact.
blocks[i] = GetBlockIndex(&blocks[i - 1], 550, nBits);
BOOST_CHECK_EQUAL(
GetNextCashWorkRequired(&blocks[i++], &blkHeaderDummy, params), nBits);
// Now we should see difficulty increase slowly.
for (size_t j = 0; j < 10; i++, j++) {
blocks[i] = GetBlockIndex(&blocks[i - 1], 550, nBits);
const uint32_t nextBits =
GetNextCashWorkRequired(&blocks[i], &blkHeaderDummy, params);
arith_uint256 currentTarget;
currentTarget.SetCompact(nBits);
arith_uint256 nextTarget;
nextTarget.SetCompact(nextBits);
// Make sure that difficulty increases very slowly.
BOOST_CHECK(nextTarget < currentTarget);
BOOST_CHECK((currentTarget - nextTarget) < (currentTarget >> 10));
nBits = nextBits;
}
// Check the actual value.
BOOST_CHECK_EQUAL(nBits, 0x1c0ffe4c);
// If we dramatically shorten block production, difficulty increases within
// bounds. The fast adjustement doesn't kick right away and need a few
// blocks.
for (size_t j = 0; j < 5; i++, j++) {
blocks[i] = GetBlockIndex(&blocks[i - 1], 100, nBits);
const uint32_t nextBits =
GetNextCashWorkRequired(&blocks[i], &blkHeaderDummy, params);
arith_uint256 currentTarget;
currentTarget.SetCompact(nBits);
arith_uint256 nextTarget;
nextTarget.SetCompact(nextBits);
// Make sure that difficulty increases very slowly.
BOOST_CHECK(nextTarget < currentTarget);
BOOST_CHECK((currentTarget - nextTarget) < (currentTarget >> 10));
nBits = nextBits;
}
// Check the actual value.
BOOST_CHECK_EQUAL(nBits, 0x1c0ff759);
// For 3 blocks, we get maximal difficulty adjustement.
for (size_t j = 0; j < 3; i++, j++) {
blocks[i] = GetBlockIndex(&blocks[i - 1], 100, nBits);
const uint32_t nextBits =
GetNextCashWorkRequired(&blocks[i], &blkHeaderDummy, params);
arith_uint256 currentTarget;
currentTarget.SetCompact(nBits);
arith_uint256 nextTarget;
nextTarget.SetCompact(nextBits);
// Because of rounding error, we add a small shift for the lower limit.
const arith_uint256 minTarget = currentTarget - (currentTarget >> 3);
const arith_uint256 minTargetLow = minTarget - (currentTarget >> 12);
const arith_uint256 minTargetHigh = minTarget + (currentTarget >> 12);
// Check the difficulty increase maximally.
BOOST_CHECK(nextTarget < minTargetHigh);
BOOST_CHECK(nextTarget > minTargetLow);
nBits = nextBits;
}
// Check the actual value.
BOOST_CHECK_EQUAL(nBits, 0x1c0ab233);
// If we continue, we adjust a bit slower but continue adjusting.
for (size_t j = 0; j < 10; i++, j++) {
blocks[i] = GetBlockIndex(&blocks[i - 1], 100, nBits);
const uint32_t nextBits =
GetNextCashWorkRequired(&blocks[i], &blkHeaderDummy, params);
arith_uint256 currentTarget;
currentTarget.SetCompact(nBits);
arith_uint256 nextTarget;
nextTarget.SetCompact(nextBits);
// Because of rounding error, we add a small shift for the lower limit.
const arith_uint256 minTarget = currentTarget - (currentTarget >> 3);
// Check the difficulty increase within bounds.
BOOST_CHECK(nextTarget < currentTarget);
BOOST_CHECK(nextTarget > minTarget);
nBits = nextBits;
}
// Check the actual value.
BOOST_CHECK_EQUAL(nBits, 0x1c05df2c);
// We start to emit blocks significantly slower. The first block has no
// impact.
blocks[i] = GetBlockIndex(&blocks[i - 1], 6000, nBits);
nBits = GetNextCashWorkRequired(&blocks[i++], &blkHeaderDummy, params);
// Check the actual value.
BOOST_CHECK_EQUAL(nBits, 0x1c054ca0);
// If we dramatically slow down block production, difficulty decrease within
// bounds.
for (size_t j = 0; j < 32; i++, j++) {
blocks[i] = GetBlockIndex(&blocks[i - 1], 6000, nBits);
const uint32_t nextBits =
GetNextCashWorkRequired(&blocks[i], &blkHeaderDummy, params);
arith_uint256 currentTarget;
currentTarget.SetCompact(nBits);
arith_uint256 nextTarget;
nextTarget.SetCompact(nextBits);
// Check the difficulty decreases within bounds.
BOOST_CHECK(nextTarget <= powLimit);
BOOST_CHECK((nextTarget > currentTarget) || (nextBits == powLimitBits));
BOOST_CHECK(nextTarget <= (currentTarget + (currentTarget >> 3)));
nBits = nextBits;
}
// Check the actual value.
BOOST_CHECK_EQUAL(nBits, 0x1d00e5a8);
// Once the difficulty reached the minimum allowed level, it doesn't get any
// easier.
for (size_t j = 0; j < 5; i++, j++) {
blocks[i] = GetBlockIndex(&blocks[i - 1], 6000, nBits);
const uint32_t nextBits =
GetNextCashWorkRequired(&blocks[i], &blkHeaderDummy, params);
// Check the difficulty stays constant.
BOOST_CHECK_EQUAL(nextBits, powLimitBits);
nBits = nextBits;
}
}
BOOST_AUTO_TEST_SUITE_END() BOOST_AUTO_TEST_SUITE_END()