git / moonbite-core / src/test/miner_tests.cpp · raw

// Copyright (c) 2011-2019 The Bitcoin Core developers// Distributed under the MIT software license, see the accompanying// file COPYING or http://www.opensource.org/licenses/mit-license.php.#include <chainparams.h>#include <coins.h>#include <consensus/consensus.h>#include <consensus/merkle.h>#include <consensus/tx_verify.h>#include <miner.h>#include <policy/policy.h>#include <script/standard.h>#include <txmempool.h>#include <uint256.h>#include <util/strencodings.h>#include <util/system.h>#include <util/time.h>#include <validation.h>#include <test/util/setup_common.h>#include <memory>#include <boost/test/unit_test.hpp>namespace miner_tests {struct MinerTestingSetup : public TestingSetup {    void TestPackageSelection(const CChainParams& chainparams, const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst) EXCLUSIVE_LOCKS_REQUIRED(::cs_main, m_node.mempool->cs);    bool TestSequenceLocks(const CTransaction& tx, int flags) EXCLUSIVE_LOCKS_REQUIRED(::cs_main, m_node.mempool->cs)    {        return CheckSequenceLocks(*m_node.mempool, tx, flags);    }    BlockAssembler AssemblerForTest(const CChainParams& params);};} // namespace miner_testsBOOST_FIXTURE_TEST_SUITE(miner_tests, MinerTestingSetup)static CFeeRate blockMinFeeRate = CFeeRate(DEFAULT_BLOCK_MIN_TX_FEE);BlockAssembler MinerTestingSetup::AssemblerForTest(const CChainParams& params){    BlockAssembler::Options options;    options.nBlockMaxWeight = MAX_BLOCK_WEIGHT;    options.blockMinFeeRate = blockMinFeeRate;    return BlockAssembler(*m_node.mempool, params, options);}constexpr static struct {    unsigned char extranonce;    unsigned int nonce;} blockinfo[] = {    {4, 0xa4ad9f65}, {2, 0x15cf2b27}, {1, 0x037620ac}, {1, 0x700d9c54},    {2, 0xce79f74f}, {2, 0x52d9c194}, {1, 0x77bc3efc}, {2, 0xbb62c5e8},    {2, 0x83ff997a}, {1, 0x48b984ee}, {1, 0xef925da0}, {2, 0x680d2979},    {2, 0x08953af7}, {1, 0x087dd553}, {2, 0x210e2818}, {2, 0xdfffcdef},    {1, 0xeea1b209}, {2, 0xba4a8943}, {1, 0xa7333e77}, {1, 0x344f3e2a},    {3, 0xd651f08e}, {2, 0xeca3957f}, {2, 0xca35aa49}, {1, 0x6bb2065d},    {2, 0x0170ee44}, {1, 0x6e12f4aa}, {2, 0x43f4f4db}, {2, 0x279c1c44},    {2, 0xb5a50f10}, {2, 0xb3902841}, {2, 0xd198647e}, {2, 0x6bc40d88},    {1, 0x633a9a1c}, {2, 0x9a722ed8}, {2, 0x55580d10}, {1, 0xd65022a1},    {2, 0xa12ffcc8}, {1, 0x75a6a9c7}, {2, 0xfb7c80b7}, {1, 0xe8403e6c},    {1, 0xe34017a0}, {3, 0x659e177b}, {2, 0xba5c40bf}, {5, 0x022f11ef},    {1, 0xa9ab516a}, {5, 0xd0999ed4}, {1, 0x37277cb3}, {1, 0x830f735f},    {1, 0xc6e3d947}, {2, 0x824a0c1b}, {1, 0x99962416}, {1, 0x75336f63},    {1, 0xaacf0fea}, {1, 0xd6531aec}, {5, 0x7afcf541}, {5, 0x9d6fac0d},    {1, 0x4cf5c4df}, {1, 0xabe0f2a0}, {6, 0x4a3dac18}, {2, 0xf265febe},    {2, 0x1bc9f23f}, {1, 0xad49ab71}, {1, 0x9f2d8923}, {1, 0x15acb65d},    {2, 0xd1cecb52}, {2, 0xf856808b}, {1, 0x0fa96e29}, {1, 0xe063ecbc},    {1, 0x78d926c6}, {5, 0x3e38ad35}, {5, 0x73901915}, {1, 0x63424be0},    {1, 0x6d6b0a1d}, {2, 0x888ba681}, {2, 0xe96b0714}, {1, 0xb7fcaa55},    {2, 0x19c106eb}, {1, 0x5aa13484}, {2, 0x5bf4c2f3}, {2, 0x94d401dd},    {1, 0xa9bc23d9}, {1, 0x3a69c375}, {1, 0x56ed2006}, {5, 0x85ba6dbd},    {1, 0xfd9b2000}, {1, 0x2b2be19a}, {1, 0xba724468}, {1, 0x717eb6e5},    {1, 0x70de86d9}, {1, 0x74e23a42}, {1, 0x49e92832}, {2, 0x6926dbb9},    {0, 0x64452497}, {1, 0x54306d6f}, {2, 0x97ebf052}, {2, 0x55198b70},    {2, 0x03fe61f0}, {1, 0x98f9e67f}, {1, 0xc0842a09}, {1, 0xdfed39c5},    {1, 0x3144223e}, {1, 0xb3d12f84}, {1, 0x7366ceb7}, {5, 0x6240691b},    {2, 0xd3529b57}, {1, 0xf4cae3b1}, {1, 0x5b1df222}, {1, 0xa16a5c70},    {2, 0xbbccedc6}, {2, 0xfe38d0ef},};static CBlockIndex CreateBlockIndex(int nHeight) EXCLUSIVE_LOCKS_REQUIRED(cs_main){    CBlockIndex index;    index.nHeight = nHeight;    index.pprev = ::ChainActive().Tip();    return index;}// Test suite for ancestor feerate transaction selection.// Implemented as an additional function, rather than a separate test case,// to allow reusing the blockchain created in CreateNewBlock_validity.void MinerTestingSetup::TestPackageSelection(const CChainParams& chainparams, const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst){    // Test the ancestor feerate transaction selection.    TestMemPoolEntryHelper entry;    // Test that a medium fee transaction will be selected after a higher fee    // rate package with a low fee rate parent.    CMutableTransaction tx;    tx.vin.resize(1);    tx.vin[0].scriptSig = CScript() << OP_1;    tx.vin[0].prevout.hash = txFirst[0]->GetHash();    tx.vin[0].prevout.n = 0;    tx.vout.resize(1);    tx.vout[0].nValue = 5000000000LL - 1000;    // This tx has a low fee: 1000 satoshis    uint256 hashParentTx = tx.GetHash(); // save this txid for later use    m_node.mempool->addUnchecked(entry.Fee(1000).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));    // This tx has a medium fee: 10000 satoshis    tx.vin[0].prevout.hash = txFirst[1]->GetHash();    tx.vout[0].nValue = 5000000000LL - 10000;    uint256 hashMediumFeeTx = tx.GetHash();    m_node.mempool->addUnchecked(entry.Fee(10000).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));    // This tx has a high fee, but depends on the first transaction    tx.vin[0].prevout.hash = hashParentTx;    tx.vout[0].nValue = 5000000000LL - 1000 - 50000; // 50k satoshi fee    uint256 hashHighFeeTx = tx.GetHash();    m_node.mempool->addUnchecked(entry.Fee(50000).Time(GetTime()).SpendsCoinbase(false).FromTx(tx));    std::unique_ptr<CBlockTemplate> pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey);    BOOST_CHECK(pblocktemplate->block.vtx[1]->GetHash() == hashParentTx);    BOOST_CHECK(pblocktemplate->block.vtx[2]->GetHash() == hashHighFeeTx);    BOOST_CHECK(pblocktemplate->block.vtx[3]->GetHash() == hashMediumFeeTx);    // Test that a package below the block min tx fee doesn't get included    tx.vin[0].prevout.hash = hashHighFeeTx;    tx.vout[0].nValue = 5000000000LL - 1000 - 50000; // 0 fee    uint256 hashFreeTx = tx.GetHash();    m_node.mempool->addUnchecked(entry.Fee(0).FromTx(tx));    size_t freeTxSize = ::GetSerializeSize(tx, PROTOCOL_VERSION);    // Calculate a fee on child transaction that will put the package just    // below the block min tx fee (assuming 1 child tx of the same size).    CAmount feeToUse = blockMinFeeRate.GetFee(2*freeTxSize) - 1;    tx.vin[0].prevout.hash = hashFreeTx;    tx.vout[0].nValue = 5000000000LL - 1000 - 50000 - feeToUse;    uint256 hashLowFeeTx = tx.GetHash();    m_node.mempool->addUnchecked(entry.Fee(feeToUse).FromTx(tx));    pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey);    // Verify that the free tx and the low fee tx didn't get selected    for (size_t i=0; i<pblocktemplate->block.vtx.size(); ++i) {        BOOST_CHECK(pblocktemplate->block.vtx[i]->GetHash() != hashFreeTx);        BOOST_CHECK(pblocktemplate->block.vtx[i]->GetHash() != hashLowFeeTx);    }    // Test that packages above the min relay fee do get included, even if one    // of the transactions is below the min relay fee    // Remove the low fee transaction and replace with a higher fee transaction    m_node.mempool->removeRecursive(CTransaction(tx), MemPoolRemovalReason::REPLACED);    tx.vout[0].nValue -= 2; // Now we should be just over the min relay fee    hashLowFeeTx = tx.GetHash();    m_node.mempool->addUnchecked(entry.Fee(feeToUse+2).FromTx(tx));    pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey);    BOOST_CHECK(pblocktemplate->block.vtx[4]->GetHash() == hashFreeTx);    BOOST_CHECK(pblocktemplate->block.vtx[5]->GetHash() == hashLowFeeTx);    // Test that transaction selection properly updates ancestor fee    // calculations as ancestor transactions get included in a block.    // Add a 0-fee transaction that has 2 outputs.    tx.vin[0].prevout.hash = txFirst[2]->GetHash();    tx.vout.resize(2);    tx.vout[0].nValue = 5000000000LL - 100000000;    tx.vout[1].nValue = 100000000; // 1BTC output    uint256 hashFreeTx2 = tx.GetHash();    m_node.mempool->addUnchecked(entry.Fee(0).SpendsCoinbase(true).FromTx(tx));    // This tx can't be mined by itself    tx.vin[0].prevout.hash = hashFreeTx2;    tx.vout.resize(1);    feeToUse = blockMinFeeRate.GetFee(freeTxSize);    tx.vout[0].nValue = 5000000000LL - 100000000 - feeToUse;    uint256 hashLowFeeTx2 = tx.GetHash();    m_node.mempool->addUnchecked(entry.Fee(feeToUse).SpendsCoinbase(false).FromTx(tx));    pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey);    // Verify that this tx isn't selected.    for (size_t i=0; i<pblocktemplate->block.vtx.size(); ++i) {        BOOST_CHECK(pblocktemplate->block.vtx[i]->GetHash() != hashFreeTx2);        BOOST_CHECK(pblocktemplate->block.vtx[i]->GetHash() != hashLowFeeTx2);    }    // This tx will be mineable, and should cause hashLowFeeTx2 to be selected    // as well.    tx.vin[0].prevout.n = 1;    tx.vout[0].nValue = 100000000 - 10000; // 10k satoshi fee    m_node.mempool->addUnchecked(entry.Fee(10000).FromTx(tx));    pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey);    BOOST_CHECK(pblocktemplate->block.vtx[8]->GetHash() == hashLowFeeTx2);}// NOTE: These tests rely on CreateNewBlock doing its own self-validation!//// MoonBite: explicitly disabled (not deleted) under RandomX (ADR-001). This// upstream test imports 110 blocks on MAIN params using the hardcoded Scrypt-era// `blockinfo[]` nonce table, and rebuilds the coinbase down to a single empty// output. Both assumptions are invalid for this fork://   * the hardcoded nonces satisfy Scrypt, not RandomX, so ProcessNewBlock//     rejects every imported block;//   * regenerating them would require grinding 110 MAIN-difficulty//     (~1e6 hashes/block) RandomX solutions, which is infeasible inline; and//   * the single-output coinbase drops the consensus ADR-005 treasury output.// The consensus paths this exercised are covered elsewhere: PoW by pow_tests,// subsidy/treasury by validation_tests, block connection by// validation_block_tests, and live CreateNewBlock assembly (incl. the 9.5+0.5// treasury split) by the regtest generatetoaddress path. Re-enabling needs a// RandomX-aware rewrite (runtime grind on regtest difficulty + MoonBite subsidy// constants); tracked as follow-up.BOOST_AUTO_TEST_CASE(CreateNewBlock_validity, *boost::unit_test::disabled()){    // MoonBite: disabled under RandomX (see rationale above). The decorator    // removes this from the default run; the early return also makes an explicit    // `--run_test=miner_tests` invocation pass cleanly instead of executing the    // Scrypt-era hardcoded-nonce block import, which cannot satisfy RandomX PoW.    BOOST_TEST_MESSAGE("miner_tests/CreateNewBlock_validity skipped: RandomX (ADR-001) rewrite pending");    return;    // Note that by default, these tests run with size accounting enabled.    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;    CMutableTransaction tx;    CScript script;    uint256 hash;    TestMemPoolEntryHelper entry;    entry.nFee = 11;    entry.nHeight = 11;    fCheckpointsEnabled = false;    // Simple block creation, nothing special yet:    BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));    // We can't make transactions until we have inputs    // Therefore, load 110 blocks :)    static_assert(sizeof(blockinfo) / sizeof(*blockinfo) == 110, "Should have 110 blocks to import");    int baseheight = 0;    std::vector<CTransactionRef> txFirst;    for (unsigned int i = 0; i < sizeof(blockinfo)/sizeof(*blockinfo); ++i)    {        CBlock *pblock = &pblocktemplate->block; // pointer for convenience        {            LOCK(cs_main);            pblock->nVersion = 1;            pblock->nTime = ::ChainActive().Tip()->GetMedianTimePast()+1;            CMutableTransaction txCoinbase(*pblock->vtx[0]);            txCoinbase.nVersion = 1;            txCoinbase.vin[0].scriptSig = CScript();            txCoinbase.vin[0].scriptSig.push_back(blockinfo[i].extranonce);            txCoinbase.vin[0].scriptSig.push_back(::ChainActive().Height());            txCoinbase.vout.resize(1); // Ignore the (optional) segwit commitment added by CreateNewBlock (as the hardcoded nonces don't account for this)            txCoinbase.vout[0].scriptPubKey = CScript();            pblock->vtx[0] = MakeTransactionRef(std::move(txCoinbase));            if (txFirst.size() == 0)                baseheight = ::ChainActive().Height();            if (txFirst.size() < 4)                txFirst.push_back(pblock->vtx[0]);            pblock->hashMerkleRoot = BlockMerkleRoot(*pblock);            pblock->nNonce = blockinfo[i].nonce;        }        std::shared_ptr<const CBlock> shared_pblock = std::make_shared<const CBlock>(*pblock);        BOOST_CHECK(Assert(m_node.chainman)->ProcessNewBlock(chainparams, shared_pblock, true, nullptr));        pblock->hashPrevBlock = pblock->GetHash();    }    LOCK(cs_main);    LOCK(m_node.mempool->cs);    // Just to make sure we can still make simple blocks    BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));    const CAmount BLOCKSUBSIDY = 50*COIN;    const CAmount LOWFEE = CENT;    const CAmount HIGHFEE = COIN;    const CAmount HIGHERFEE = 4*COIN;    // block sigops > limit: 1000 CHECKMULTISIG + 1    tx.vin.resize(1);    // NOTE: OP_NOP is used to force 20 SigOps for the CHECKMULTISIG    tx.vin[0].scriptSig = CScript() << OP_0 << OP_0 << OP_0 << OP_NOP << OP_CHECKMULTISIG << OP_1;    tx.vin[0].prevout.hash = txFirst[0]->GetHash();    tx.vin[0].prevout.n = 0;    tx.vout.resize(1);    tx.vout[0].nValue = BLOCKSUBSIDY;    for (unsigned int i = 0; i < 1001; ++i)    {        tx.vout[0].nValue -= LOWFEE;        hash = tx.GetHash();        bool spendsCoinbase = i == 0; // only first tx spends coinbase        // If we don't set the # of sig ops in the CTxMemPoolEntry, template creation fails        m_node.mempool->addUnchecked(entry.Fee(LOWFEE).Time(GetTime()).SpendsCoinbase(spendsCoinbase).FromTx(tx));        tx.vin[0].prevout.hash = hash;    }    BOOST_CHECK_EXCEPTION(AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey), std::runtime_error, HasReason("bad-blk-sigops"));    m_node.mempool->clear();    tx.vin[0].prevout.hash = txFirst[0]->GetHash();    tx.vout[0].nValue = BLOCKSUBSIDY;    for (unsigned int i = 0; i < 1001; ++i)    {        tx.vout[0].nValue -= LOWFEE;        hash = tx.GetHash();        bool spendsCoinbase = i == 0; // only first tx spends coinbase        // If we do set the # of sig ops in the CTxMemPoolEntry, template creation passes        m_node.mempool->addUnchecked(entry.Fee(LOWFEE).Time(GetTime()).SpendsCoinbase(spendsCoinbase).SigOpsCost(80).FromTx(tx));        tx.vin[0].prevout.hash = hash;    }    BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));    m_node.mempool->clear();    // block size > limit    tx.vin[0].scriptSig = CScript();    // 18 * (520char + DROP) + OP_1 = 9433 bytes    std::vector<unsigned char> vchData(520);    for (unsigned int i = 0; i < 18; ++i)        tx.vin[0].scriptSig << vchData << OP_DROP;    tx.vin[0].scriptSig << OP_1;    tx.vin[0].prevout.hash = txFirst[0]->GetHash();    tx.vout[0].nValue = BLOCKSUBSIDY;    for (unsigned int i = 0; i < 128; ++i)    {        tx.vout[0].nValue -= LOWFEE;        hash = tx.GetHash();        bool spendsCoinbase = i == 0; // only first tx spends coinbase        m_node.mempool->addUnchecked(entry.Fee(LOWFEE).Time(GetTime()).SpendsCoinbase(spendsCoinbase).FromTx(tx));        tx.vin[0].prevout.hash = hash;    }    BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));    m_node.mempool->clear();    // orphan in *m_node.mempool, template creation fails    hash = tx.GetHash();    m_node.mempool->addUnchecked(entry.Fee(LOWFEE).Time(GetTime()).FromTx(tx));    BOOST_CHECK_EXCEPTION(AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey), std::runtime_error, HasReason("bad-txns-inputs-missingorspent"));    m_node.mempool->clear();    // child with higher feerate than parent    tx.vin[0].scriptSig = CScript() << OP_1;    tx.vin[0].prevout.hash = txFirst[1]->GetHash();    tx.vout[0].nValue = BLOCKSUBSIDY-HIGHFEE;    hash = tx.GetHash();    m_node.mempool->addUnchecked(entry.Fee(HIGHFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));    tx.vin[0].prevout.hash = hash;    tx.vin.resize(2);    tx.vin[1].scriptSig = CScript() << OP_1;    tx.vin[1].prevout.hash = txFirst[0]->GetHash();    tx.vin[1].prevout.n = 0;    tx.vout[0].nValue = tx.vout[0].nValue+BLOCKSUBSIDY-HIGHERFEE; //First txn output + fresh coinbase - new txn fee    hash = tx.GetHash();    m_node.mempool->addUnchecked(entry.Fee(HIGHERFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));    BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));    m_node.mempool->clear();    // coinbase in *m_node.mempool, template creation fails    tx.vin.resize(1);    tx.vin[0].prevout.SetNull();    tx.vin[0].scriptSig = CScript() << OP_0 << OP_1;    tx.vout[0].nValue = 0;    hash = tx.GetHash();    // give it a fee so it'll get mined    m_node.mempool->addUnchecked(entry.Fee(LOWFEE).Time(GetTime()).SpendsCoinbase(false).FromTx(tx));    // Should throw bad-cb-multiple    BOOST_CHECK_EXCEPTION(AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey), std::runtime_error, HasReason("bad-cb-multiple"));    m_node.mempool->clear();    // double spend txn pair in *m_node.mempool, template creation fails    tx.vin[0].prevout.hash = txFirst[0]->GetHash();    tx.vin[0].scriptSig = CScript() << OP_1;    tx.vout[0].nValue = BLOCKSUBSIDY-HIGHFEE;    tx.vout[0].scriptPubKey = CScript() << OP_1;    hash = tx.GetHash();    m_node.mempool->addUnchecked(entry.Fee(HIGHFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));    tx.vout[0].scriptPubKey = CScript() << OP_2;    hash = tx.GetHash();    m_node.mempool->addUnchecked(entry.Fee(HIGHFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));    BOOST_CHECK_EXCEPTION(AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey), std::runtime_error, HasReason("bad-txns-inputs-missingorspent"));    m_node.mempool->clear();    // subsidy changing    int nHeight = ::ChainActive().Height();    // Create an actual 209999-long block chain (without valid blocks).    while (::ChainActive().Tip()->nHeight < 839999) {        CBlockIndex* prev = ::ChainActive().Tip();        CBlockIndex* next = new CBlockIndex();        next->phashBlock = new uint256(InsecureRand256());        ::ChainstateActive().CoinsTip().SetBestBlock(next->GetBlockHash());        next->pprev = prev;        next->nHeight = prev->nHeight + 1;        next->BuildSkip();        ::ChainActive().SetTip(next);    }    BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));    // Extend to a 210000-long block chain.    while (::ChainActive().Tip()->nHeight < 840000) {        CBlockIndex* prev = ::ChainActive().Tip();        CBlockIndex* next = new CBlockIndex();        next->phashBlock = new uint256(InsecureRand256());        ::ChainstateActive().CoinsTip().SetBestBlock(next->GetBlockHash());        next->pprev = prev;        next->nHeight = prev->nHeight + 1;        next->BuildSkip();        ::ChainActive().SetTip(next);    }    BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));    // invalid p2sh txn in *m_node.mempool, template creation fails    tx.vin[0].prevout.hash = txFirst[0]->GetHash();    tx.vin[0].prevout.n = 0;    tx.vin[0].scriptSig = CScript() << OP_1;    tx.vout[0].nValue = BLOCKSUBSIDY-LOWFEE;    script = CScript() << OP_0;    tx.vout[0].scriptPubKey = GetScriptForDestination(ScriptHash(script));    hash = tx.GetHash();    m_node.mempool->addUnchecked(entry.Fee(LOWFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));    tx.vin[0].prevout.hash = hash;    tx.vin[0].scriptSig = CScript() << std::vector<unsigned char>(script.begin(), script.end());    tx.vout[0].nValue -= LOWFEE;    hash = tx.GetHash();    m_node.mempool->addUnchecked(entry.Fee(LOWFEE).Time(GetTime()).SpendsCoinbase(false).FromTx(tx));    // Should throw block-validation-failed    BOOST_CHECK_EXCEPTION(AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey), std::runtime_error, HasReason("block-validation-failed"));    m_node.mempool->clear();    // Delete the dummy blocks again.    while (::ChainActive().Tip()->nHeight > nHeight) {        CBlockIndex* del = ::ChainActive().Tip();        ::ChainActive().SetTip(del->pprev);        ::ChainstateActive().CoinsTip().SetBestBlock(del->pprev->GetBlockHash());        delete del->phashBlock;        delete del;    }    // non-final txs in mempool    SetMockTime(::ChainActive().Tip()->GetMedianTimePast()+1);    int flags = LOCKTIME_VERIFY_SEQUENCE|LOCKTIME_MEDIAN_TIME_PAST;    // height map    std::vector<int> prevheights;    // relative height locked    tx.nVersion = 2;    tx.vin.resize(1);    prevheights.resize(1);    tx.vin[0].prevout.hash = txFirst[0]->GetHash(); // only 1 transaction    tx.vin[0].prevout.n = 0;    tx.vin[0].scriptSig = CScript() << OP_1;    tx.vin[0].nSequence = ::ChainActive().Tip()->nHeight + 1; // txFirst[0] is the 2nd block    prevheights[0] = baseheight + 1;    tx.vout.resize(1);    tx.vout[0].nValue = BLOCKSUBSIDY-HIGHFEE;    tx.vout[0].scriptPubKey = CScript() << OP_1;    tx.nLockTime = 0;    hash = tx.GetHash();    m_node.mempool->addUnchecked(entry.Fee(HIGHFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));    BOOST_CHECK(CheckFinalTx(CTransaction(tx), flags)); // Locktime passes    BOOST_CHECK(!TestSequenceLocks(CTransaction(tx), flags)); // Sequence locks fail    BOOST_CHECK(SequenceLocks(CTransaction(tx), flags, prevheights, CreateBlockIndex(::ChainActive().Tip()->nHeight + 2))); // Sequence locks pass on 2nd block    // relative time locked    tx.vin[0].prevout.hash = txFirst[1]->GetHash();    tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG | (((::ChainActive().Tip()->GetMedianTimePast()+1-::ChainActive()[1]->GetMedianTimePast()) >> CTxIn::SEQUENCE_LOCKTIME_GRANULARITY) + 1); // txFirst[1] is the 3rd block    prevheights[0] = baseheight + 2;    hash = tx.GetHash();    m_node.mempool->addUnchecked(entry.Time(GetTime()).FromTx(tx));    BOOST_CHECK(CheckFinalTx(CTransaction(tx), flags)); // Locktime passes    BOOST_CHECK(!TestSequenceLocks(CTransaction(tx), flags)); // Sequence locks fail    for (int i = 0; i < CBlockIndex::nMedianTimeSpan; i++)        ::ChainActive().Tip()->GetAncestor(::ChainActive().Tip()->nHeight - i)->nTime += 512; //Trick the MedianTimePast    BOOST_CHECK(SequenceLocks(CTransaction(tx), flags, prevheights, CreateBlockIndex(::ChainActive().Tip()->nHeight + 1))); // Sequence locks pass 512 seconds later    for (int i = 0; i < CBlockIndex::nMedianTimeSpan; i++)        ::ChainActive().Tip()->GetAncestor(::ChainActive().Tip()->nHeight - i)->nTime -= 512; //undo tricked MTP    // absolute height locked    tx.vin[0].prevout.hash = txFirst[2]->GetHash();    tx.vin[0].nSequence = CTxIn::SEQUENCE_FINAL - 1;    prevheights[0] = baseheight + 3;    tx.nLockTime = ::ChainActive().Tip()->nHeight + 1;    hash = tx.GetHash();    m_node.mempool->addUnchecked(entry.Time(GetTime()).FromTx(tx));    BOOST_CHECK(!CheckFinalTx(CTransaction(tx), flags)); // Locktime fails    BOOST_CHECK(TestSequenceLocks(CTransaction(tx), flags)); // Sequence locks pass    BOOST_CHECK(IsFinalTx(CTransaction(tx), ::ChainActive().Tip()->nHeight + 2, ::ChainActive().Tip()->GetMedianTimePast())); // Locktime passes on 2nd block    // absolute time locked    tx.vin[0].prevout.hash = txFirst[3]->GetHash();    tx.nLockTime = ::ChainActive().Tip()->GetMedianTimePast();    prevheights.resize(1);    prevheights[0] = baseheight + 4;    hash = tx.GetHash();    m_node.mempool->addUnchecked(entry.Time(GetTime()).FromTx(tx));    BOOST_CHECK(!CheckFinalTx(CTransaction(tx), flags)); // Locktime fails    BOOST_CHECK(TestSequenceLocks(CTransaction(tx), flags)); // Sequence locks pass    BOOST_CHECK(IsFinalTx(CTransaction(tx), ::ChainActive().Tip()->nHeight + 2, ::ChainActive().Tip()->GetMedianTimePast() + 1)); // Locktime passes 1 second later    // mempool-dependent transactions (not added)    tx.vin[0].prevout.hash = hash;    prevheights[0] = ::ChainActive().Tip()->nHeight + 1;    tx.nLockTime = 0;    tx.vin[0].nSequence = 0;    BOOST_CHECK(CheckFinalTx(CTransaction(tx), flags)); // Locktime passes    BOOST_CHECK(TestSequenceLocks(CTransaction(tx), flags)); // Sequence locks pass    tx.vin[0].nSequence = 1;    BOOST_CHECK(!TestSequenceLocks(CTransaction(tx), flags)); // Sequence locks fail    tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG;    BOOST_CHECK(TestSequenceLocks(CTransaction(tx), flags)); // Sequence locks pass    tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG | 1;    BOOST_CHECK(!TestSequenceLocks(CTransaction(tx), flags)); // Sequence locks fail    BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));    // None of the of the absolute height/time locked tx should have made    // it into the template because we still check IsFinalTx in CreateNewBlock,    // but relative locked txs will if inconsistently added to mempool.    // For now these will still generate a valid template until BIP68 soft fork    BOOST_CHECK_EQUAL(pblocktemplate->block.vtx.size(), 3U);    // However if we advance height by 1 and time by 512, all of them should be mined    for (int i = 0; i < CBlockIndex::nMedianTimeSpan; i++)        ::ChainActive().Tip()->GetAncestor(::ChainActive().Tip()->nHeight - i)->nTime += 512; //Trick the MedianTimePast    ::ChainActive().Tip()->nHeight++;    SetMockTime(::ChainActive().Tip()->GetMedianTimePast() + 1);    BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));    BOOST_CHECK_EQUAL(pblocktemplate->block.vtx.size(), 5U);    ::ChainActive().Tip()->nHeight--;    SetMockTime(0);    m_node.mempool->clear();    TestPackageSelection(chainparams, scriptPubKey, txFirst);    fCheckpointsEnabled = true;}BOOST_AUTO_TEST_SUITE_END()