Inside Bitcoin

251                           .Mine(5999, TestTime(20000), 0).TestStarted().TestStateSinceHeight(3000)
252                           .Mine(6000, TestTime(20000), 0).TestFailed().TestStateSinceHeight(6000)
253                           .Mine(7000, TestTime(20000), 0x100).TestFailed().TestStateSinceHeight(6000)
254                           .Mine(24000, TestTime(20000), 0x100).TestFailed().TestStateSinceHeight(6000) // stay in FAILED no matter how much we signal
255        ;
256    }
257}
258
259struct BlockVersionTest : BasicTestingSetup {
260/** Check that ComputeBlockVersion will set the appropriate bit correctly
261 * Also checks IsActiveAfter() behaviour */
262void check_computeblockversion(VersionBitsCache& versionbitscache, const Consensus::Params& params, Consensus::DeploymentPos dep)
263{
264    // Clear the cache every time
265    versionbitscache.Clear();
266
267    int64_t bit = params.vDeployments[dep].bit;
268    int64_t nStartTime = params.vDeployments[dep].nStartTime;
269    int64_t nTimeout = params.vDeployments[dep].nTimeout;
270    int min_activation_height = params.vDeployments[dep].min_activation_height;
271    uint32_t period = params.vDeployments[dep].period;
272    uint32_t threshold = params.vDeployments[dep].threshold;
273
274    BOOST_REQUIRE(period > 0); // no division by zero, thankyou
275    BOOST_REQUIRE(0 < threshold); // must be able to have a window that doesn't activate
276    BOOST_REQUIRE(threshold < period); // must be able to have a window that does activate
277
278    // should not be any signalling for first block
279    BOOST_CHECK_EQUAL(versionbitscache.ComputeBlockVersion(nullptr, params), VERSIONBITS_TOP_BITS);
280
281    // always/never active deployments shouldn't need to be tested further
282    if (nStartTime == Consensus::BIP9Deployment::ALWAYS_ACTIVE ||
283        nStartTime == Consensus::BIP9Deployment::NEVER_ACTIVE)
284    {
285        if (nStartTime == Consensus::BIP9Deployment::ALWAYS_ACTIVE) {
286            BOOST_CHECK(versionbitscache.IsActiveAfter(nullptr, params, dep));
287        } else {
288            BOOST_CHECK(!versionbitscache.IsActiveAfter(nullptr, params, dep));
289        }
290        BOOST_CHECK_EQUAL(min_activation_height, 0);
291        BOOST_CHECK_EQUAL(nTimeout, Consensus::BIP9Deployment::NO_TIMEOUT);
292        return;
293    }
294
295    BOOST_REQUIRE(nStartTime < nTimeout);
296    BOOST_REQUIRE(nStartTime >= 0);
297    BOOST_REQUIRE(nTimeout <= std::numeric_limits<uint32_t>::max() || nTimeout == Consensus::BIP9Deployment::NO_TIMEOUT);
298    BOOST_REQUIRE(0 <= bit);
299    BOOST_REQUIRE(bit < 32);
300    // Make sure that no deployment tries to set an invalid bit.
301    BOOST_REQUIRE(((1 << bit) & VERSIONBITS_TOP_MASK) == 0);
302    BOOST_REQUIRE(min_activation_height >= 0);
303    // Check min_activation_height is on a retarget boundary
304    BOOST_REQUIRE_EQUAL(min_activation_height % period, 0U);
305
306    // In the first chain, test that the bit is set by CBV until it has failed.
307    // In the second chain, test the bit is set by CBV while STARTED and
308    // LOCKED-IN, and then no longer set while ACTIVE.
309    VersionBitsTester firstChain{m_rng}, secondChain{m_rng};
310
311    int64_t nTime = nStartTime;
312
313    const CBlockIndex *lastBlock = nullptr;
314
315    // Before MedianTimePast of the chain has crossed nStartTime, the bit
316    // should not be set.
317    if (nTime == 0) {
318        // since CBlockIndex::nTime is uint32_t we can't represent any
319        // earlier time, so will transition from DEFINED to STARTED at the
320        // end of the first period by mining blocks at nTime == 0
321        lastBlock = firstChain.Mine(period - 1, nTime, VERSIONBITS_LAST_OLD_BLOCK_VERSION).Tip();
322        BOOST_CHECK_EQUAL(versionbitscache.ComputeBlockVersion(lastBlock, params) & (1 << bit), 0);
323        BOOST_CHECK(!versionbitscache.IsActiveAfter(lastBlock, params, dep));
324        lastBlock = firstChain.Mine(period, nTime, VERSIONBITS_LAST_OLD_BLOCK_VERSION).Tip();
325        BOOST_CHECK((versionbitscache.ComputeBlockVersion(lastBlock, params) & (1 << bit)) != 0);
326        BOOST_CHECK(!versionbitscache.IsActiveAfter(lastBlock, params, dep));
327        // then we'll keep mining at nStartTime...
328    } else {
329        // use a time 1s earlier than start time to check we stay DEFINED
330        --nTime;
331
332        // Start generating blocks before nStartTime
333        lastBlock = firstChain.Mine(period, nTime, VERSIONBITS_LAST_OLD_BLOCK_VERSION).Tip();
334        BOOST_CHECK_EQUAL(versionbitscache.ComputeBlockVersion(lastBlock, params) & (1 << bit), 0);
335        BOOST_CHECK(!versionbitscache.IsActiveAfter(lastBlock, params, dep));
336
337        // Mine more blocks (4 less than the adjustment period) at the old time, and check that CBV isn't setting the bit yet.
338        for (uint32_t i = 1; i < period - 4; i++) {
339            lastBlock = firstChain.Mine(period + i, nTime, VERSIONBITS_LAST_OLD_BLOCK_VERSION).Tip();
340            BOOST_CHECK_EQUAL(versionbitscache.ComputeBlockVersion(lastBlock, params) & (1 << bit), 0);
341            BOOST_CHECK(!versionbitscache.IsActiveAfter(lastBlock, params, dep));
342        }
343        // Now mine 5 more blocks at the start time -- MTP should not have passed yet, so
344        // CBV should still not yet set the bit.
345        nTime = nStartTime;
346        for (uint32_t i = period - 4; i <= period; i++) {
347            lastBlock = firstChain.Mine(period + i, nTime, VERSIONBITS_LAST_OLD_BLOCK_VERSION).Tip();
348            BOOST_CHECK_EQUAL(versionbitscache.ComputeBlockVersion(lastBlock, params) & (1 << bit), 0);
349            BOOST_CHECK(!versionbitscache.IsActiveAfter(lastBlock, params, dep));
350        }
351        // Next we will advance to the next period and transition to STARTED,
352    }
353
354    lastBlock = firstChain.Mine(period * 3, nTime, VERSIONBITS_LAST_OLD_BLOCK_VERSION).Tip();
355    // so ComputeBlockVersion should now set the bit,
356    BOOST_CHECK((versionbitscache.ComputeBlockVersion(lastBlock, params) & (1 << bit)) != 0);
357    // and should also be using the VERSIONBITS_TOP_BITS.
358    BOOST_CHECK_EQUAL(versionbitscache.ComputeBlockVersion(lastBlock, params) & VERSIONBITS_TOP_MASK, VERSIONBITS_TOP_BITS);
359    BOOST_CHECK(!versionbitscache.IsActiveAfter(lastBlock, params, dep));
360
361    // Check that ComputeBlockVersion will set the bit until nTimeout
362    nTime += 600;
363    uint32_t blocksToMine = period * 2; // test blocks for up to 2 time periods
364    uint32_t nHeight = period * 3;
365    // These blocks are all before nTimeout is reached.
366    while (nTime < nTimeout && blocksToMine > 0) {
367        lastBlock = firstChain.Mine(nHeight+1, nTime, VERSIONBITS_LAST_OLD_BLOCK_VERSION).Tip();
368        BOOST_CHECK((versionbitscache.ComputeBlockVersion(lastBlock, params) & (1 << bit)) != 0);
369        BOOST_CHECK_EQUAL(versionbitscache.ComputeBlockVersion(lastBlock, params) & VERSIONBITS_TOP_MASK, VERSIONBITS_TOP_BITS);
370        BOOST_CHECK(!versionbitscache.IsActiveAfter(lastBlock, params, dep));
371        blocksToMine--;
372        nTime += 600;
373        nHeight += 1;
374    }
375
376    if (nTimeout != Consensus::BIP9Deployment::NO_TIMEOUT) {
377        // can reach any nTimeout other than NO_TIMEOUT due to earlier BOOST_REQUIRE
378
379        nTime = nTimeout;
380
381        // finish the last period before we start timing out
382        while (nHeight % period != 0) {
383            lastBlock = firstChain.Mine(nHeight+1, nTime - 1, VERSIONBITS_LAST_OLD_BLOCK_VERSION).Tip();
384            BOOST_CHECK((versionbitscache.ComputeBlockVersion(lastBlock, params) & (1 << bit)) != 0);
385            BOOST_CHECK(!versionbitscache.IsActiveAfter(lastBlock, params, dep));
386            nHeight += 1;
387        }
388
389        // FAILED is only triggered at the end of a period, so CBV should be setting
390        // the bit until the period transition.
391        for (uint32_t i = 0; i < period - 1; i++) {
392            lastBlock = firstChain.Mine(nHeight+1, nTime, VERSIONBITS_LAST_OLD_BLOCK_VERSION).Tip();
393            BOOST_CHECK((versionbitscache.ComputeBlockVersion(lastBlock, params) & (1 << bit)) != 0);
394            BOOST_CHECK(!versionbitscache.IsActiveAfter(lastBlock, params, dep));
395            nHeight += 1;
396        }
397        // The next block should trigger no longer setting the bit.
398        lastBlock = firstChain.Mine(nHeight+1, nTime, VERSIONBITS_LAST_OLD_BLOCK_VERSION).Tip();
399        BOOST_CHECK_EQUAL(versionbitscache.ComputeBlockVersion(lastBlock, params) & (1 << bit), 0);
400        BOOST_CHECK(!versionbitscache.IsActiveAfter(lastBlock, params, dep));
401    }
402
403    // On a new chain:
404    // verify that the bit will be set after lock-in, and then stop being set
405    // after activation.
406    nTime = nStartTime;
407
408    // Mine one period worth of blocks, and check that the bit will be on for the
409    // next period.
410    lastBlock = secondChain.Mine(period, nTime, VERSIONBITS_LAST_OLD_BLOCK_VERSION).Tip();
411    BOOST_CHECK((versionbitscache.ComputeBlockVersion(lastBlock, params) & (1 << bit)) != 0);
412    BOOST_CHECK(!versionbitscache.IsActiveAfter(lastBlock, params, dep));
413
414    // Mine another period worth of blocks, signaling the new bit.
415    lastBlock = secondChain.Mine(period * 2, nTime, VERSIONBITS_TOP_BITS | (1<<bit)).Tip();
416    // After one period of setting the bit on each block, it should have locked in.
417    // We keep setting the bit for one more period though, until activation.
418    BOOST_CHECK((versionbitscache.ComputeBlockVersion(lastBlock, params) & (1 << bit)) != 0);
419    BOOST_CHECK(!versionbitscache.IsActiveAfter(lastBlock, params, dep));
420
421    // Now check that we keep mining the block until the end of this period, and
422    // then stop at the beginning of the next period.
423    lastBlock = secondChain.Mine((period * 3) - 1, nTime, VERSIONBITS_LAST_OLD_BLOCK_VERSION).Tip();
424    BOOST_CHECK((versionbitscache.ComputeBlockVersion(lastBlock, params) & (1 << bit)) != 0);
425    BOOST_CHECK(!versionbitscache.IsActiveAfter(lastBlock, params, dep));
426    lastBlock = secondChain.Mine(period * 3, nTime, VERSIONBITS_LAST_OLD_BLOCK_VERSION).Tip();
427
428    if (lastBlock->nHeight + 1 < min_activation_height) {
429        // check signalling continues while min_activation_height is not reached
430        lastBlock = secondChain.Mine(min_activation_height - 1, nTime, VERSIONBITS_LAST_OLD_BLOCK_VERSION).Tip();
431        BOOST_CHECK((versionbitscache.ComputeBlockVersion(lastBlock, params) & (1 << bit)) != 0);
432        BOOST_CHECK(!versionbitscache.IsActiveAfter(lastBlock, params, dep));
433        // then reach min_activation_height, which was already REQUIRE'd to start a new period
434        lastBlock = secondChain.Mine(min_activation_height, nTime, VERSIONBITS_LAST_OLD_BLOCK_VERSION).Tip();
435    }
436
437    // Check that we don't signal after activation
438    BOOST_CHECK_EQUAL(versionbitscache.ComputeBlockVersion(lastBlock, params) & (1 << bit), 0);
439    BOOST_CHECK(versionbitscache.IsActiveAfter(lastBlock, params, dep));
440}
441}; // struct BlockVersionTest
442
443BOOST_FIXTURE_TEST_CASE(versionbits_computeblockversion, BlockVersionTest)
444{
445    VersionBitsCache vbcache;
446
447    // check that any deployment on any chain can conceivably reach both
448    // ACTIVE and FAILED states in roughly the way we expect
449    for (const auto& chain_type: {ChainType::MAIN, ChainType::TESTNET, ChainType::TESTNET4, ChainType::SIGNET, ChainType::REGTEST}) {
450        const auto chainParams = CreateChainParams(*m_node.args, chain_type);
451        uint32_t chain_all_vbits{0};
452        for (int i = 0; i < (int)Consensus::MAX_VERSION_BITS_DEPLOYMENTS; ++i) {
453            const auto dep = static_cast<Consensus::DeploymentPos>(i);
454            // Check that no bits are reused (within the same chain). This is
455            // disallowed because the transition to FAILED (on timeout) does
456            // not take precedence over STARTED/LOCKED_IN. So all softforks on
457            // the same bit might overlap, even when non-overlapping start-end
458            // times are picked.
459            const auto& dep_info = chainParams->GetConsensus().vDeployments[dep];
460            const uint32_t dep_mask{uint32_t{1} << dep_info.bit};
461            BOOST_CHECK(!(chain_all_vbits & dep_mask));
462            chain_all_vbits |= dep_mask;
463            BOOST_CHECK(0 <= dep_info.bit);
464            BOOST_CHECK(dep_info.bit < VERSIONBITS_MAX_NUM_BITS);
465            if (chain_type != ChainType::REGTEST) {
466                if (dep == Consensus::DEPLOYMENT_TESTDUMMY) {
467                    BOOST_CHECK_EQUAL(dep_info.nStartTime, Consensus::BIP9Deployment::NEVER_ACTIVE);
468                    BOOST_CHECK_EQUAL(dep_info.nTimeout, Consensus::BIP9Deployment::NO_TIMEOUT);
469                } else {
470                    BOOST_CHECK(dep_info.bit < VERSIONBITS_NUM_BITS);
471                }
472            }
473            check_computeblockversion(vbcache, chainParams->GetConsensus(), dep);
474        }
475    }
476
477    {
478        // Use regtest/testdummy to ensure we always exercise some
479        // deployment that's not always/never active
480        ArgsManager args;
481        args.ForceSetArg("-vbparams", "testdummy:1199145601:1230767999"); // January 1, 2008 - December 31, 2008
482        const auto chainParams = CreateChainParams(args, ChainType::REGTEST);
483        check_computeblockversion(vbcache, chainParams->GetConsensus(), Consensus::DEPLOYMENT_TESTDUMMY);
484    }
485
486    {
487        // Use regtest/testdummy to ensure we always exercise the
488        // min_activation_height test, even if we're not using that in a
489        // live deployment
490        ArgsManager args;
491        args.ForceSetArg("-vbparams", "testdummy:1199145601:1230767999:403200"); // January 1, 2008 - December 31, 2008, min act height 403200
492        const auto chainParams = CreateChainParams(args, ChainType::REGTEST);
493        check_computeblockversion(vbcache, chainParams->GetConsensus(), Consensus::DEPLOYMENT_TESTDUMMY);
494    }
495}
496
497BOOST_AUTO_TEST_SUITE_END()
498