LCOV - code coverage report
Current view: top level - src/test - miner_tests.cpp (source / functions) Coverage Total Hit
Test: total_coverage.info Lines: 98.2 % 507 498
Test Date: 2025-09-13 05:20:27 Functions: 100.0 % 8 8
Branches: 50.6 % 1548 784

             Branch data     Line data    Source code
       1                 :             : // Copyright (c) 2011-2022 The Bitcoin Core developers
       2                 :             : // Distributed under the MIT software license, see the accompanying
       3                 :             : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
       4                 :             : 
       5                 :             : #include <addresstype.h>
       6                 :             : #include <coins.h>
       7                 :             : #include <common/system.h>
       8                 :             : #include <consensus/consensus.h>
       9                 :             : #include <consensus/merkle.h>
      10                 :             : #include <consensus/tx_verify.h>
      11                 :             : #include <interfaces/mining.h>
      12                 :             : #include <node/miner.h>
      13                 :             : #include <policy/policy.h>
      14                 :             : #include <test/util/random.h>
      15                 :             : #include <test/util/transaction_utils.h>
      16                 :             : #include <test/util/txmempool.h>
      17                 :             : #include <txmempool.h>
      18                 :             : #include <uint256.h>
      19                 :             : #include <util/check.h>
      20                 :             : #include <util/feefrac.h>
      21                 :             : #include <util/strencodings.h>
      22                 :             : #include <util/time.h>
      23                 :             : #include <util/translation.h>
      24                 :             : #include <validation.h>
      25                 :             : #include <versionbits.h>
      26                 :             : #include <pow.h>
      27                 :             : 
      28                 :             : #include <test/util/setup_common.h>
      29                 :             : 
      30                 :             : #include <memory>
      31                 :             : #include <vector>
      32                 :             : 
      33                 :             : #include <boost/test/unit_test.hpp>
      34                 :             : 
      35                 :             : using namespace util::hex_literals;
      36                 :             : using interfaces::BlockTemplate;
      37                 :             : using interfaces::Mining;
      38                 :             : using node::BlockAssembler;
      39                 :             : 
      40                 :             : namespace miner_tests {
      41                 :           2 : struct MinerTestingSetup : public TestingSetup {
      42                 :             :     void TestPackageSelection(const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
      43                 :             :     void TestBasicMining(const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst, int baseheight) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
      44                 :             :     void TestPrioritisedMining(const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
      45                 :           8 :     bool TestSequenceLocks(const CTransaction& tx, CTxMemPool& tx_mempool) EXCLUSIVE_LOCKS_REQUIRED(::cs_main)
      46                 :             :     {
      47                 :           8 :         CCoinsViewMemPool view_mempool{&m_node.chainman->ActiveChainstate().CoinsTip(), tx_mempool};
      48   [ +  -  -  + ]:           8 :         CBlockIndex* tip{m_node.chainman->ActiveChain().Tip()};
      49         [ +  - ]:           8 :         const std::optional<LockPoints> lock_points{CalculateLockPointsAtTip(tip, view_mempool, tx)};
      50   [ +  -  +  -  :          16 :         return lock_points.has_value() && CheckSequenceLocksAtTip(tip, *lock_points);
                   +  + ]
      51                 :           8 :     }
      52                 :          11 :     CTxMemPool& MakeMempool()
      53                 :             :     {
      54                 :             :         // Delete the previous mempool to ensure with valgrind that the old
      55                 :             :         // pointer is not accessed, when the new one should be accessed
      56                 :             :         // instead.
      57         [ +  - ]:          11 :         m_node.mempool.reset();
      58         [ +  - ]:          11 :         bilingual_str error;
      59   [ +  -  +  - ]:          11 :         m_node.mempool = std::make_unique<CTxMemPool>(MemPoolOptionsForTest(m_node), error);
      60         [ +  - ]:          11 :         Assert(error.empty());
      61                 :          11 :         return *m_node.mempool;
      62                 :          11 :     }
      63                 :           4 :     std::unique_ptr<Mining> MakeMining()
      64                 :             :     {
      65                 :           4 :         return interfaces::MakeMining(m_node);
      66                 :             :     }
      67                 :             : };
      68                 :             : } // namespace miner_tests
      69                 :             : 
      70                 :             : BOOST_FIXTURE_TEST_SUITE(miner_tests, MinerTestingSetup)
      71                 :             : 
      72                 :             : static CFeeRate blockMinFeeRate = CFeeRate(DEFAULT_BLOCK_MIN_TX_FEE);
      73                 :             : 
      74                 :             : constexpr static struct {
      75                 :             :     unsigned int extranonce;
      76                 :             :     unsigned int nonce;
      77                 :             : } BLOCKINFO[]{{0, 3552706918},   {500, 37506755},   {1000, 948987788}, {400, 524762339},  {800, 258510074},  {300, 102309278},
      78                 :             :               {1300, 54365202},  {600, 1107740426}, {1000, 203094491}, {900, 391178848},  {800, 381177271},  {600, 87188412},
      79                 :             :               {0, 66522866},     {800, 874942736},  {1000, 89200838},  {400, 312638088},  {400, 66263693},   {500, 924648304},
      80                 :             :               {400, 369913599},  {500, 47630099},   {500, 115045364},  {100, 277026602},  {1100, 809621409}, {700, 155345322},
      81                 :             :               {800, 943579953},  {400, 28200730},   {900, 77200495},   {0, 105935488},    {400, 698721821},  {500, 111098863},
      82                 :             :               {1300, 445389594}, {500, 621849894},  {1400, 56010046},  {1100, 370669776}, {1200, 380301940}, {1200, 110654905},
      83                 :             :               {400, 213771024},  {1500, 120014726}, {1200, 835019014}, {1500, 624817237}, {900, 1404297},    {400, 189414558},
      84                 :             :               {400, 293178348},  {1100, 15393789},  {600, 396764180},  {800, 1387046371}, {800, 199368303},  {700, 111496662},
      85                 :             :               {100, 129759616},  {200, 536577982},  {500, 125881300},  {500, 101053391},  {1200, 471590548}, {900, 86957729},
      86                 :             :               {1200, 179604104}, {600, 68658642},   {1000, 203295701}, {500, 139615361},  {900, 233693412},  {300, 153225163},
      87                 :             :               {0, 27616254},     {1200, 9856191},   {100, 220392722},  {200, 66257599},   {1100, 145489641}, {1300, 37859442},
      88                 :             :               {400, 5816075},    {1200, 215752117}, {1400, 32361482},  {1400, 6529223},   {500, 143332977},  {800, 878392},
      89                 :             :               {700, 159290408},  {400, 123197595},  {700, 43988693},   {300, 304224916},  {700, 214771621},  {1100, 274148273},
      90                 :             :               {400, 285632418},  {1100, 923451065}, {600, 12818092},   {1200, 736282054}, {1000, 246683167}, {600, 92950402},
      91                 :             :               {1400, 29223405},  {1000, 841327192}, {700, 174301283},  {1400, 214009854}, {1000, 6989517},   {1200, 278226956},
      92                 :             :               {700, 540219613},  {400, 93663104},   {1100, 152345635}, {1500, 464194499}, {1300, 333850111}, {600, 258311263},
      93                 :             :               {600, 90173162},   {1000, 33590797},  {1500, 332866027}, {100, 204704427},  {1000, 463153545}, {800, 303244785},
      94                 :             :               {600, 88096214},   {0, 137477892},    {1200, 195514506}, {300, 704114595},  {900, 292087369},  {1400, 758684870},
      95                 :             :               {1300, 163493028}, {1200, 53151293}};
      96                 :             : 
      97                 :           2 : static std::unique_ptr<CBlockIndex> CreateBlockIndex(int nHeight, CBlockIndex* active_chain_tip) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
      98                 :             : {
      99                 :           2 :     auto index{std::make_unique<CBlockIndex>()};
     100                 :           2 :     index->nHeight = nHeight;
     101                 :           2 :     index->pprev = active_chain_tip;
     102                 :           2 :     return index;
     103                 :             : }
     104                 :             : 
     105                 :             : // Test suite for ancestor feerate transaction selection.
     106                 :             : // Implemented as an additional function, rather than a separate test case,
     107                 :             : // to allow reusing the blockchain created in CreateNewBlock_validity.
     108                 :           1 : void MinerTestingSetup::TestPackageSelection(const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst)
     109                 :             : {
     110                 :           1 :     CTxMemPool& tx_mempool{MakeMempool()};
     111                 :           1 :     auto mining{MakeMining()};
     112         [ +  - ]:           1 :     BlockAssembler::Options options;
     113                 :           1 :     options.coinbase_output_script = scriptPubKey;
     114                 :             : 
     115         [ +  - ]:           1 :     LOCK(tx_mempool.cs);
     116                 :             :     // Test the ancestor feerate transaction selection.
     117                 :           1 :     TestMemPoolEntryHelper entry;
     118                 :             : 
     119                 :             :     // Test that a medium fee transaction will be selected after a higher fee
     120                 :             :     // rate package with a low fee rate parent.
     121         [ +  - ]:           1 :     CMutableTransaction tx;
     122         [ +  - ]:           1 :     tx.vin.resize(1);
     123         [ +  - ]:           1 :     tx.vin[0].scriptSig = CScript() << OP_1;
     124         [ +  - ]:           1 :     tx.vin[0].prevout.hash = txFirst[0]->GetHash();
     125                 :           1 :     tx.vin[0].prevout.n = 0;
     126         [ +  - ]:           1 :     tx.vout.resize(1);
     127         [ +  - ]:           1 :     tx.vout[0].nValue = 5000000000LL - 1000;
     128                 :             :     // This tx has a low fee: 1000 satoshis
     129         [ +  - ]:           1 :     Txid hashParentTx = tx.GetHash(); // save this txid for later use
     130         [ +  - ]:           1 :     const auto parent_tx{entry.Fee(1000).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx)};
     131         [ +  - ]:           1 :     AddToMempool(tx_mempool, parent_tx);
     132                 :             : 
     133                 :             :     // This tx has a medium fee: 10000 satoshis
     134         [ +  - ]:           1 :     tx.vin[0].prevout.hash = txFirst[1]->GetHash();
     135                 :           1 :     tx.vout[0].nValue = 5000000000LL - 10000;
     136         [ +  - ]:           1 :     Txid hashMediumFeeTx = tx.GetHash();
     137         [ +  - ]:           1 :     const auto medium_fee_tx{entry.Fee(10000).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx)};
     138         [ +  - ]:           1 :     AddToMempool(tx_mempool, medium_fee_tx);
     139                 :             : 
     140                 :             :     // This tx has a high fee, but depends on the first transaction
     141         [ +  - ]:           1 :     tx.vin[0].prevout.hash = hashParentTx;
     142                 :           1 :     tx.vout[0].nValue = 5000000000LL - 1000 - 50000; // 50k satoshi fee
     143         [ +  - ]:           1 :     Txid hashHighFeeTx = tx.GetHash();
     144         [ +  - ]:           1 :     const auto high_fee_tx{entry.Fee(50000).Time(Now<NodeSeconds>()).SpendsCoinbase(false).FromTx(tx)};
     145         [ +  - ]:           1 :     AddToMempool(tx_mempool, high_fee_tx);
     146                 :             : 
     147         [ +  - ]:           1 :     std::unique_ptr<BlockTemplate> block_template = mining->createNewBlock(options);
     148   [ +  -  +  -  :           2 :     BOOST_REQUIRE(block_template);
                   +  - ]
     149         [ +  - ]:           1 :     CBlock block{block_template->getBlock()};
     150   [ +  -  -  +  :           1 :     BOOST_REQUIRE_EQUAL(block.vtx.size(), 4U);
                   +  - ]
     151   [ +  -  +  -  :           2 :     BOOST_CHECK(block.vtx[1]->GetHash() == hashParentTx);
                   +  - ]
     152   [ +  -  +  -  :           2 :     BOOST_CHECK(block.vtx[2]->GetHash() == hashHighFeeTx);
                   +  - ]
     153   [ +  -  +  -  :           2 :     BOOST_CHECK(block.vtx[3]->GetHash() == hashMediumFeeTx);
                   +  - ]
     154                 :             : 
     155                 :             :     // Test the inclusion of package feerates in the block template and ensure they are sequential.
     156   [ +  -  +  -  :           1 :     const auto block_package_feerates = BlockAssembler{m_node.chainman->ActiveChainstate(), &tx_mempool, options}.CreateNewBlock()->m_package_feerates;
             +  -  +  - ]
     157   [ +  -  -  +  :           2 :     BOOST_CHECK(block_package_feerates.size() == 2);
             +  -  +  - ]
     158                 :             : 
     159                 :             :     // parent_tx and high_fee_tx are added to the block as a package.
     160                 :           1 :     const auto combined_txs_fee = parent_tx.GetFee() + high_fee_tx.GetFee();
     161   [ +  -  +  - ]:           1 :     const auto combined_txs_size = parent_tx.GetTxSize() + high_fee_tx.GetTxSize();
     162         [ +  - ]:           1 :     FeeFrac package_feefrac{combined_txs_fee, combined_txs_size};
     163                 :             :     // The package should be added first.
     164   [ +  -  +  -  :           3 :     BOOST_CHECK(block_package_feerates[0] == package_feefrac);
             +  -  +  - ]
     165                 :             : 
     166                 :             :     // The medium_fee_tx should be added next.
     167   [ +  -  +  - ]:           1 :     FeeFrac medium_tx_feefrac{medium_fee_tx.GetFee(), medium_fee_tx.GetTxSize()};
     168   [ +  -  +  -  :           3 :     BOOST_CHECK(block_package_feerates[1] == medium_tx_feefrac);
             +  -  +  - ]
     169                 :             : 
     170                 :             :     // Test that a package below the block min tx fee doesn't get included
     171         [ +  - ]:           1 :     tx.vin[0].prevout.hash = hashHighFeeTx;
     172                 :           1 :     tx.vout[0].nValue = 5000000000LL - 1000 - 50000; // 0 fee
     173         [ +  - ]:           1 :     Txid hashFreeTx = tx.GetHash();
     174   [ +  -  +  - ]:           1 :     AddToMempool(tx_mempool, entry.Fee(0).FromTx(tx));
     175                 :           1 :     size_t freeTxSize = ::GetSerializeSize(TX_WITH_WITNESS(tx));
     176                 :             : 
     177                 :             :     // Calculate a fee on child transaction that will put the package just
     178                 :             :     // below the block min tx fee (assuming 1 child tx of the same size).
     179         [ +  - ]:           1 :     CAmount feeToUse = blockMinFeeRate.GetFee(2*freeTxSize) - 1;
     180                 :             : 
     181         [ +  - ]:           1 :     tx.vin[0].prevout.hash = hashFreeTx;
     182                 :           1 :     tx.vout[0].nValue = 5000000000LL - 1000 - 50000 - feeToUse;
     183         [ +  - ]:           1 :     Txid hashLowFeeTx = tx.GetHash();
     184   [ +  -  +  - ]:           1 :     AddToMempool(tx_mempool, entry.Fee(feeToUse).FromTx(tx));
     185                 :             : 
     186                 :             :     // waitNext() should return nullptr because there is no better template
     187         [ +  - ]:           1 :     auto should_be_nullptr = block_template->waitNext({.timeout = MillisecondsDouble{0}, .fee_threshold = 1});
     188   [ +  -  +  -  :           2 :     BOOST_REQUIRE(should_be_nullptr == nullptr);
                   +  - ]
     189                 :             : 
     190         [ +  - ]:           1 :     block = block_template->getBlock();
     191                 :             :     // Verify that the free tx and the low fee tx didn't get selected
     192   [ -  +  +  + ]:           5 :     for (size_t i=0; i<block.vtx.size(); ++i) {
     193   [ +  -  +  -  :           8 :         BOOST_CHECK(block.vtx[i]->GetHash() != hashFreeTx);
                   +  - ]
     194   [ +  -  +  - ]:           8 :         BOOST_CHECK(block.vtx[i]->GetHash() != hashLowFeeTx);
     195                 :             :     }
     196                 :             : 
     197                 :             :     // Test that packages above the min relay fee do get included, even if one
     198                 :             :     // of the transactions is below the min relay fee
     199                 :             :     // Remove the low fee transaction and replace with a higher fee transaction
     200   [ +  -  +  - ]:           1 :     tx_mempool.removeRecursive(CTransaction(tx), MemPoolRemovalReason::REPLACED);
     201         [ +  - ]:           1 :     tx.vout[0].nValue -= 2; // Now we should be just over the min relay fee
     202         [ +  - ]:           1 :     hashLowFeeTx = tx.GetHash();
     203   [ +  -  +  - ]:           1 :     AddToMempool(tx_mempool, entry.Fee(feeToUse + 2).FromTx(tx));
     204                 :             : 
     205                 :             :     // waitNext() should return if fees for the new template are at least 1 sat up
     206         [ +  - ]:           2 :     block_template = block_template->waitNext({.fee_threshold = 1});
     207   [ +  -  +  -  :           2 :     BOOST_REQUIRE(block_template);
                   +  - ]
     208         [ +  - ]:           1 :     block = block_template->getBlock();
     209   [ +  -  -  +  :           1 :     BOOST_REQUIRE_EQUAL(block.vtx.size(), 6U);
                   +  - ]
     210   [ +  -  +  -  :           2 :     BOOST_CHECK(block.vtx[4]->GetHash() == hashFreeTx);
                   +  - ]
     211   [ +  -  +  -  :           2 :     BOOST_CHECK(block.vtx[5]->GetHash() == hashLowFeeTx);
                   +  - ]
     212                 :             : 
     213                 :             :     // Test that transaction selection properly updates ancestor fee
     214                 :             :     // calculations as ancestor transactions get included in a block.
     215                 :             :     // Add a 0-fee transaction that has 2 outputs.
     216         [ +  - ]:           1 :     tx.vin[0].prevout.hash = txFirst[2]->GetHash();
     217         [ +  - ]:           1 :     tx.vout.resize(2);
     218         [ +  - ]:           1 :     tx.vout[0].nValue = 5000000000LL - 100000000;
     219                 :           1 :     tx.vout[1].nValue = 100000000; // 1BTC output
     220                 :             :     // Increase size to avoid rounding errors: when the feerate is extremely small (i.e. 1sat/kvB), evaluating the fee
     221                 :             :     // at smaller sizes gives us rounded values that are equal to each other, which means we incorrectly include
     222                 :             :     // hashFreeTx2 + hashLowFeeTx2.
     223         [ +  - ]:           1 :     BulkTransaction(tx, 4000);
     224         [ +  - ]:           1 :     Txid hashFreeTx2 = tx.GetHash();
     225   [ +  -  +  - ]:           1 :     AddToMempool(tx_mempool, entry.Fee(0).SpendsCoinbase(true).FromTx(tx));
     226                 :             : 
     227                 :             :     // This tx can't be mined by itself
     228         [ +  - ]:           1 :     tx.vin[0].prevout.hash = hashFreeTx2;
     229         [ +  - ]:           1 :     tx.vout.resize(1);
     230         [ +  - ]:           1 :     feeToUse = blockMinFeeRate.GetFee(freeTxSize);
     231         [ +  - ]:           1 :     tx.vout[0].nValue = 5000000000LL - 100000000 - feeToUse;
     232         [ +  - ]:           1 :     Txid hashLowFeeTx2 = tx.GetHash();
     233   [ +  -  +  - ]:           1 :     AddToMempool(tx_mempool, entry.Fee(feeToUse).SpendsCoinbase(false).FromTx(tx));
     234         [ +  - ]:           2 :     block_template = mining->createNewBlock(options);
     235   [ +  -  +  -  :           2 :     BOOST_REQUIRE(block_template);
                   +  - ]
     236         [ +  - ]:           1 :     block = block_template->getBlock();
     237                 :             : 
     238                 :             :     // Verify that this tx isn't selected.
     239   [ -  +  +  + ]:           7 :     for (size_t i=0; i<block.vtx.size(); ++i) {
     240   [ +  -  +  -  :          12 :         BOOST_CHECK(block.vtx[i]->GetHash() != hashFreeTx2);
                   +  - ]
     241   [ +  -  +  - ]:          12 :         BOOST_CHECK(block.vtx[i]->GetHash() != hashLowFeeTx2);
     242                 :             :     }
     243                 :             : 
     244                 :             :     // This tx will be mineable, and should cause hashLowFeeTx2 to be selected
     245                 :             :     // as well.
     246         [ +  - ]:           1 :     tx.vin[0].prevout.n = 1;
     247                 :           1 :     tx.vout[0].nValue = 100000000 - 10000; // 10k satoshi fee
     248   [ +  -  +  - ]:           1 :     AddToMempool(tx_mempool, entry.Fee(10000).FromTx(tx));
     249         [ +  - ]:           2 :     block_template = mining->createNewBlock(options);
     250   [ +  -  +  -  :           2 :     BOOST_REQUIRE(block_template);
                   +  - ]
     251         [ +  - ]:           1 :     block = block_template->getBlock();
     252   [ +  -  -  +  :           1 :     BOOST_REQUIRE_EQUAL(block.vtx.size(), 9U);
                   +  - ]
     253   [ +  -  +  - ]:           2 :     BOOST_CHECK(block.vtx[8]->GetHash() == hashLowFeeTx2);
     254         [ +  - ]:           3 : }
     255                 :             : 
     256                 :           1 : void MinerTestingSetup::TestBasicMining(const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst, int baseheight)
     257                 :             : {
     258                 :           1 :     Txid hash;
     259                 :           1 :     CMutableTransaction tx;
     260                 :           1 :     TestMemPoolEntryHelper entry;
     261                 :           1 :     entry.nFee = 11;
     262                 :           1 :     entry.nHeight = 11;
     263                 :             : 
     264                 :           1 :     const CAmount BLOCKSUBSIDY = 50 * COIN;
     265                 :           1 :     const CAmount LOWFEE = CENT;
     266                 :           1 :     const CAmount HIGHFEE = COIN;
     267                 :           1 :     const CAmount HIGHERFEE = 4 * COIN;
     268                 :             : 
     269         [ +  - ]:           1 :     auto mining{MakeMining()};
     270   [ +  -  +  -  :           2 :     BOOST_REQUIRE(mining);
                   +  - ]
     271                 :             : 
     272         [ +  - ]:           1 :     BlockAssembler::Options options;
     273                 :           1 :     options.coinbase_output_script = scriptPubKey;
     274                 :             : 
     275                 :           1 :     {
     276         [ +  - ]:           1 :         CTxMemPool& tx_mempool{MakeMempool()};
     277         [ +  - ]:           1 :         LOCK(tx_mempool.cs);
     278                 :             : 
     279                 :             :         // Just to make sure we can still make simple blocks
     280         [ +  - ]:           1 :         auto block_template{mining->createNewBlock(options)};
     281   [ +  -  +  -  :           2 :         BOOST_REQUIRE(block_template);
                   +  - ]
     282         [ +  - ]:           1 :         CBlock block{block_template->getBlock()};
     283                 :             : 
     284                 :             :         // block sigops > limit: 1000 CHECKMULTISIG + 1
     285         [ +  - ]:           1 :         tx.vin.resize(1);
     286                 :             :         // NOTE: OP_NOP is used to force 20 SigOps for the CHECKMULTISIG
     287   [ +  -  +  -  :           1 :         tx.vin[0].scriptSig = CScript() << OP_0 << OP_0 << OP_0 << OP_NOP << OP_CHECKMULTISIG << OP_1;
          +  -  +  -  +  
                -  +  - ]
     288         [ +  - ]:           1 :         tx.vin[0].prevout.hash = txFirst[0]->GetHash();
     289                 :           1 :         tx.vin[0].prevout.n = 0;
     290         [ +  - ]:           1 :         tx.vout.resize(1);
     291                 :           1 :         tx.vout[0].nValue = BLOCKSUBSIDY;
     292         [ +  + ]:        1002 :         for (unsigned int i = 0; i < 1001; ++i) {
     293         [ +  - ]:        1001 :             tx.vout[0].nValue -= LOWFEE;
     294         [ +  - ]:        1001 :             hash = tx.GetHash();
     295                 :        1001 :             bool spendsCoinbase = i == 0; // only first tx spends coinbase
     296                 :             :             // If we don't set the # of sig ops in the CTxMemPoolEntry, template creation fails
     297   [ +  -  +  - ]:        1001 :             AddToMempool(tx_mempool, entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(spendsCoinbase).FromTx(tx));
     298                 :        1001 :             tx.vin[0].prevout.hash = hash;
     299                 :             :         }
     300                 :             : 
     301   [ +  -  -  +  :           2 :         BOOST_CHECK_EXCEPTION(mining->createNewBlock(options), std::runtime_error, HasReason("bad-blk-sigops"));
          -  -  -  -  -  
          +  +  -  +  -  
                   +  - ]
     302         [ +  - ]:           1 :     }
     303                 :             : 
     304                 :           1 :     {
     305         [ +  - ]:           1 :         CTxMemPool& tx_mempool{MakeMempool()};
     306         [ +  - ]:           1 :         LOCK(tx_mempool.cs);
     307                 :             : 
     308                 :           1 :         tx.vin[0].prevout.hash = txFirst[0]->GetHash();
     309                 :           1 :         tx.vout[0].nValue = BLOCKSUBSIDY;
     310         [ +  + ]:        1002 :         for (unsigned int i = 0; i < 1001; ++i) {
     311         [ +  - ]:        1001 :             tx.vout[0].nValue -= LOWFEE;
     312         [ +  - ]:        1001 :             hash = tx.GetHash();
     313                 :        1001 :             bool spendsCoinbase = i == 0; // only first tx spends coinbase
     314                 :             :             // If we do set the # of sig ops in the CTxMemPoolEntry, template creation passes
     315   [ +  -  +  - ]:        1001 :             AddToMempool(tx_mempool, entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(spendsCoinbase).SigOpsCost(80).FromTx(tx));
     316                 :        1001 :             tx.vin[0].prevout.hash = hash;
     317                 :             :         }
     318   [ +  -  +  -  :           2 :         BOOST_REQUIRE(mining->createNewBlock(options));
             +  -  +  - ]
     319                 :           0 :     }
     320                 :             : 
     321                 :           1 :     {
     322         [ +  - ]:           1 :         CTxMemPool& tx_mempool{MakeMempool()};
     323         [ +  - ]:           1 :         LOCK(tx_mempool.cs);
     324                 :             : 
     325                 :             :         // block size > limit
     326                 :           1 :         tx.vin[0].scriptSig = CScript();
     327                 :             :         // 18 * (520char + DROP) + OP_1 = 9433 bytes
     328         [ +  - ]:           1 :         std::vector<unsigned char> vchData(520);
     329         [ +  + ]:          19 :         for (unsigned int i = 0; i < 18; ++i) {
     330   [ -  +  +  - ]:          18 :             tx.vin[0].scriptSig << vchData << OP_DROP;
     331                 :             :         }
     332         [ +  - ]:           1 :         tx.vin[0].scriptSig << OP_1;
     333                 :           1 :         tx.vin[0].prevout.hash = txFirst[0]->GetHash();
     334                 :           1 :         tx.vout[0].nValue = BLOCKSUBSIDY;
     335         [ +  + ]:         129 :         for (unsigned int i = 0; i < 128; ++i) {
     336         [ +  - ]:         128 :             tx.vout[0].nValue -= LOWFEE;
     337         [ +  - ]:         128 :             hash = tx.GetHash();
     338                 :         128 :             bool spendsCoinbase = i == 0; // only first tx spends coinbase
     339   [ +  -  +  - ]:         128 :             AddToMempool(tx_mempool, entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(spendsCoinbase).FromTx(tx));
     340                 :         128 :             tx.vin[0].prevout.hash = hash;
     341                 :             :         }
     342   [ +  -  +  -  :           2 :         BOOST_REQUIRE(mining->createNewBlock(options));
                   +  - ]
     343         [ +  - ]:           1 :     }
     344                 :             : 
     345                 :           1 :     {
     346         [ +  - ]:           1 :         CTxMemPool& tx_mempool{MakeMempool()};
     347         [ +  - ]:           1 :         LOCK(tx_mempool.cs);
     348                 :             : 
     349                 :             :         // orphan in tx_mempool, template creation fails
     350         [ +  - ]:           1 :         hash = tx.GetHash();
     351   [ +  -  +  - ]:           1 :         AddToMempool(tx_mempool, entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).FromTx(tx));
     352   [ +  -  -  +  :           2 :         BOOST_CHECK_EXCEPTION(mining->createNewBlock(options), std::runtime_error, HasReason("bad-txns-inputs-missingorspent"));
          -  -  -  -  +  
          -  -  +  +  -  
             +  -  +  - ]
     353                 :           0 :     }
     354                 :             : 
     355                 :           1 :     {
     356         [ +  - ]:           1 :         CTxMemPool& tx_mempool{MakeMempool()};
     357         [ +  - ]:           1 :         LOCK(tx_mempool.cs);
     358                 :             : 
     359                 :             :         // child with higher feerate than parent
     360         [ +  - ]:           1 :         tx.vin[0].scriptSig = CScript() << OP_1;
     361         [ +  - ]:           1 :         tx.vin[0].prevout.hash = txFirst[1]->GetHash();
     362                 :           1 :         tx.vout[0].nValue = BLOCKSUBSIDY - HIGHFEE;
     363         [ +  - ]:           1 :         hash = tx.GetHash();
     364   [ +  -  +  - ]:           1 :         AddToMempool(tx_mempool, entry.Fee(HIGHFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx));
     365         [ +  - ]:           1 :         tx.vin[0].prevout.hash = hash;
     366         [ +  - ]:           1 :         tx.vin.resize(2);
     367         [ +  - ]:           1 :         tx.vin[1].scriptSig = CScript() << OP_1;
     368         [ +  - ]:           1 :         tx.vin[1].prevout.hash = txFirst[0]->GetHash();
     369                 :           1 :         tx.vin[1].prevout.n = 0;
     370                 :           1 :         tx.vout[0].nValue = tx.vout[0].nValue + BLOCKSUBSIDY - HIGHERFEE; // First txn output + fresh coinbase - new txn fee
     371         [ +  - ]:           1 :         hash = tx.GetHash();
     372   [ +  -  +  - ]:           1 :         AddToMempool(tx_mempool, entry.Fee(HIGHERFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx));
     373   [ +  -  +  -  :           2 :         BOOST_REQUIRE(mining->createNewBlock(options));
             +  -  +  - ]
     374                 :           0 :     }
     375                 :             : 
     376                 :           1 :     {
     377         [ +  - ]:           1 :         CTxMemPool& tx_mempool{MakeMempool()};
     378         [ +  - ]:           1 :         LOCK(tx_mempool.cs);
     379                 :             : 
     380                 :             :         // coinbase in tx_mempool, template creation fails
     381         [ +  - ]:           1 :         tx.vin.resize(1);
     382                 :           1 :         tx.vin[0].prevout.SetNull();
     383   [ +  -  +  - ]:           1 :         tx.vin[0].scriptSig = CScript() << OP_0 << OP_1;
     384         [ +  - ]:           1 :         tx.vout[0].nValue = 0;
     385         [ +  - ]:           1 :         hash = tx.GetHash();
     386                 :             :         // give it a fee so it'll get mined
     387   [ +  -  +  - ]:           1 :         AddToMempool(tx_mempool, entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(false).FromTx(tx));
     388                 :             :         // Should throw bad-cb-multiple
     389   [ +  -  -  +  :           2 :         BOOST_CHECK_EXCEPTION(mining->createNewBlock(options), std::runtime_error, HasReason("bad-cb-multiple"));
          -  -  -  -  +  
          -  -  +  +  -  
             +  -  +  - ]
     390                 :           0 :     }
     391                 :             : 
     392                 :           1 :     {
     393         [ +  - ]:           1 :         CTxMemPool& tx_mempool{MakeMempool()};
     394         [ +  - ]:           1 :         LOCK(tx_mempool.cs);
     395                 :             : 
     396                 :             :         // double spend txn pair in tx_mempool, template creation fails
     397         [ +  - ]:           1 :         tx.vin[0].prevout.hash = txFirst[0]->GetHash();
     398         [ +  - ]:           1 :         tx.vin[0].scriptSig = CScript() << OP_1;
     399         [ +  - ]:           1 :         tx.vout[0].nValue = BLOCKSUBSIDY - HIGHFEE;
     400         [ +  - ]:           1 :         tx.vout[0].scriptPubKey = CScript() << OP_1;
     401         [ +  - ]:           1 :         hash = tx.GetHash();
     402   [ +  -  +  - ]:           1 :         AddToMempool(tx_mempool, entry.Fee(HIGHFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx));
     403         [ +  - ]:           1 :         tx.vout[0].scriptPubKey = CScript() << OP_2;
     404         [ +  - ]:           1 :         hash = tx.GetHash();
     405   [ +  -  +  - ]:           1 :         AddToMempool(tx_mempool, entry.Fee(HIGHFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx));
     406   [ +  -  -  +  :           2 :         BOOST_CHECK_EXCEPTION(mining->createNewBlock(options), std::runtime_error, HasReason("bad-txns-inputs-missingorspent"));
          -  -  -  -  +  
          -  -  +  +  -  
             +  -  +  - ]
     407                 :           0 :     }
     408                 :             : 
     409                 :           1 :     {
     410         [ +  - ]:           1 :         CTxMemPool& tx_mempool{MakeMempool()};
     411         [ +  - ]:           1 :         LOCK(tx_mempool.cs);
     412                 :             : 
     413                 :             :         // subsidy changing
     414   [ +  -  -  + ]:           1 :         int nHeight = m_node.chainman->ActiveChain().Height();
     415                 :             :         // Create an actual 209999-long block chain (without valid blocks).
     416   [ +  -  -  +  :      419780 :         while (m_node.chainman->ActiveChain().Tip()->nHeight < 209999) {
                   +  + ]
     417   [ +  -  -  + ]:      209889 :             CBlockIndex* prev = m_node.chainman->ActiveChain().Tip();
     418         [ +  - ]:      209889 :             CBlockIndex* next = new CBlockIndex();
     419         [ +  - ]:      209889 :             next->phashBlock = new uint256(m_rng.rand256());
     420   [ +  -  +  -  :      209889 :             m_node.chainman->ActiveChainstate().CoinsTip().SetBestBlock(next->GetBlockHash());
                   +  - ]
     421                 :      209889 :             next->pprev = prev;
     422                 :      209889 :             next->nHeight = prev->nHeight + 1;
     423         [ +  - ]:      209889 :             next->BuildSkip();
     424   [ +  -  +  - ]:      209889 :             m_node.chainman->ActiveChain().SetTip(*next);
     425                 :             :         }
     426   [ +  -  +  -  :           2 :         BOOST_REQUIRE(mining->createNewBlock(options));
                   +  - ]
     427                 :             :         // Extend to a 210000-long block chain.
     428   [ +  -  -  +  :           4 :         while (m_node.chainman->ActiveChain().Tip()->nHeight < 210000) {
                   +  + ]
     429   [ +  -  -  + ]:           1 :             CBlockIndex* prev = m_node.chainman->ActiveChain().Tip();
     430         [ +  - ]:           1 :             CBlockIndex* next = new CBlockIndex();
     431         [ +  - ]:           1 :             next->phashBlock = new uint256(m_rng.rand256());
     432   [ +  -  +  -  :           1 :             m_node.chainman->ActiveChainstate().CoinsTip().SetBestBlock(next->GetBlockHash());
                   +  - ]
     433                 :           1 :             next->pprev = prev;
     434                 :           1 :             next->nHeight = prev->nHeight + 1;
     435         [ +  - ]:           1 :             next->BuildSkip();
     436   [ +  -  +  - ]:           1 :             m_node.chainman->ActiveChain().SetTip(*next);
     437                 :             :         }
     438   [ +  -  +  -  :           2 :         BOOST_REQUIRE(mining->createNewBlock(options));
             +  -  +  - ]
     439                 :             : 
     440                 :             :         // invalid p2sh txn in tx_mempool, template creation fails
     441         [ +  - ]:           1 :         tx.vin[0].prevout.hash = txFirst[0]->GetHash();
     442                 :           1 :         tx.vin[0].prevout.n = 0;
     443         [ +  - ]:           1 :         tx.vin[0].scriptSig = CScript() << OP_1;
     444         [ +  - ]:           1 :         tx.vout[0].nValue = BLOCKSUBSIDY - LOWFEE;
     445         [ +  - ]:           1 :         CScript script = CScript() << OP_0;
     446   [ +  -  +  - ]:           1 :         tx.vout[0].scriptPubKey = GetScriptForDestination(ScriptHash(script));
     447         [ +  - ]:           1 :         hash = tx.GetHash();
     448   [ +  -  +  - ]:           1 :         AddToMempool(tx_mempool, entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx));
     449         [ -  + ]:           1 :         tx.vin[0].prevout.hash = hash;
     450   [ -  +  +  - ]:           2 :         tx.vin[0].scriptSig = CScript() << std::vector<unsigned char>(script.begin(), script.end());
     451         [ +  - ]:           1 :         tx.vout[0].nValue -= LOWFEE;
     452         [ +  - ]:           1 :         hash = tx.GetHash();
     453   [ +  -  +  - ]:           1 :         AddToMempool(tx_mempool, entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(false).FromTx(tx));
     454   [ +  -  -  +  :           2 :         BOOST_CHECK_EXCEPTION(mining->createNewBlock(options), std::runtime_error, HasReason("block-script-verify-flag-failed"));
          -  -  -  -  -  
          +  +  -  +  -  
                   +  - ]
     455                 :             : 
     456                 :             :         // Delete the dummy blocks again.
     457   [ +  -  -  +  :      419782 :         while (m_node.chainman->ActiveChain().Tip()->nHeight > nHeight) {
                   +  + ]
     458   [ +  -  -  + ]:      209890 :             CBlockIndex* del = m_node.chainman->ActiveChain().Tip();
     459   [ +  -  +  -  :      209890 :             m_node.chainman->ActiveChain().SetTip(*Assert(del->pprev));
                   +  - ]
     460   [ +  -  +  -  :      209890 :             m_node.chainman->ActiveChainstate().CoinsTip().SetBestBlock(del->pprev->GetBlockHash());
                   +  - ]
     461         [ +  - ]:      209890 :             delete del->phashBlock;
     462         [ +  - ]:      209890 :             delete del;
     463                 :             :         }
     464         [ +  - ]:           1 :     }
     465                 :             : 
     466         [ +  - ]:           1 :     CTxMemPool& tx_mempool{MakeMempool()};
     467         [ +  - ]:           1 :     LOCK(tx_mempool.cs);
     468                 :             : 
     469                 :             :     // non-final txs in mempool
     470   [ +  -  -  +  :           2 :     SetMockTime(m_node.chainman->ActiveChain().Tip()->GetMedianTimePast() + 1);
                   +  - ]
     471                 :           1 :     const int flags{LOCKTIME_VERIFY_SEQUENCE};
     472                 :             :     // height map
     473                 :           1 :     std::vector<int> prevheights;
     474                 :             : 
     475                 :             :     // relative height locked
     476                 :           1 :     tx.version = 2;
     477         [ +  - ]:           1 :     tx.vin.resize(1);
     478         [ +  - ]:           1 :     prevheights.resize(1);
     479         [ +  - ]:           1 :     tx.vin[0].prevout.hash = txFirst[0]->GetHash(); // only 1 transaction
     480                 :           1 :     tx.vin[0].prevout.n = 0;
     481         [ +  - ]:           1 :     tx.vin[0].scriptSig = CScript() << OP_1;
     482   [ +  -  -  +  :           2 :     tx.vin[0].nSequence = m_node.chainman->ActiveChain().Tip()->nHeight + 1; // txFirst[0] is the 2nd block
                   +  - ]
     483                 :           1 :     prevheights[0] = baseheight + 1;
     484         [ +  - ]:           1 :     tx.vout.resize(1);
     485         [ +  - ]:           1 :     tx.vout[0].nValue = BLOCKSUBSIDY-HIGHFEE;
     486         [ +  - ]:           1 :     tx.vout[0].scriptPubKey = CScript() << OP_1;
     487                 :           1 :     tx.nLockTime = 0;
     488         [ +  - ]:           1 :     hash = tx.GetHash();
     489   [ +  -  +  - ]:           1 :     AddToMempool(tx_mempool, entry.Fee(HIGHFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx));
     490   [ +  -  +  -  :           4 :     BOOST_CHECK(CheckFinalTxAtTip(*Assert(m_node.chainman->ActiveChain().Tip()), CTransaction{tx})); // Locktime passes
          +  -  -  +  +  
          -  +  -  +  -  
                   +  - ]
     491   [ +  -  +  -  :           3 :     BOOST_CHECK(!TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks fail
          +  -  +  -  +  
                      - ]
     492                 :             : 
     493                 :           1 :     {
     494   [ +  -  -  + ]:           1 :         CBlockIndex* active_chain_tip = m_node.chainman->ActiveChain().Tip();
     495   [ +  -  +  -  :           3 :         BOOST_CHECK(SequenceLocks(CTransaction(tx), flags, prevheights, *CreateBlockIndex(active_chain_tip->nHeight + 2, active_chain_tip))); // Sequence locks pass on 2nd block
          +  -  +  -  +  
                -  +  - ]
     496                 :             :     }
     497                 :             : 
     498                 :             :     // relative time locked
     499         [ +  - ]:           1 :     tx.vin[0].prevout.hash = txFirst[1]->GetHash();
     500   [ +  -  -  +  :           3 :     tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG | (((m_node.chainman->ActiveChain().Tip()->GetMedianTimePast()+1-m_node.chainman->ActiveChain()[1]->GetMedianTimePast()) >> CTxIn::SEQUENCE_LOCKTIME_GRANULARITY) + 1); // txFirst[1] is the 3rd block
          +  -  -  +  +  
                      - ]
     501                 :           1 :     prevheights[0] = baseheight + 2;
     502         [ +  - ]:           1 :     hash = tx.GetHash();
     503   [ +  -  +  - ]:           1 :     AddToMempool(tx_mempool, entry.Time(Now<NodeSeconds>()).FromTx(tx));
     504   [ +  -  +  -  :           4 :     BOOST_CHECK(CheckFinalTxAtTip(*Assert(m_node.chainman->ActiveChain().Tip()), CTransaction{tx})); // Locktime passes
          +  -  -  +  +  
          -  +  -  +  -  
                   +  - ]
     505   [ +  -  +  -  :           3 :     BOOST_CHECK(!TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks fail
             +  -  +  - ]
     506                 :             : 
     507                 :           1 :     const int SEQUENCE_LOCK_TIME = 512; // Sequence locks pass 512 seconds later
     508         [ +  + ]:          12 :     for (int i = 0; i < CBlockIndex::nMedianTimeSpan; ++i)
     509   [ +  -  -  +  :          33 :         m_node.chainman->ActiveChain().Tip()->GetAncestor(m_node.chainman->ActiveChain().Tip()->nHeight - i)->nTime += SEQUENCE_LOCK_TIME; // Trick the MedianTimePast
          +  -  -  +  +  
                      - ]
     510                 :           1 :     {
     511   [ +  -  -  + ]:           1 :         CBlockIndex* active_chain_tip = m_node.chainman->ActiveChain().Tip();
     512   [ +  -  +  -  :           3 :         BOOST_CHECK(SequenceLocks(CTransaction(tx), flags, prevheights, *CreateBlockIndex(active_chain_tip->nHeight + 1, active_chain_tip)));
          +  -  +  -  +  
                      - ]
     513                 :             :     }
     514                 :             : 
     515         [ +  + ]:          12 :     for (int i = 0; i < CBlockIndex::nMedianTimeSpan; ++i) {
     516   [ +  -  -  +  :          33 :         CBlockIndex* ancestor{Assert(m_node.chainman->ActiveChain().Tip()->GetAncestor(m_node.chainman->ActiveChain().Tip()->nHeight - i))};
          +  -  -  +  +  
                -  +  - ]
     517                 :          11 :         ancestor->nTime -= SEQUENCE_LOCK_TIME; // undo tricked MTP
     518                 :             :     }
     519                 :             : 
     520                 :             :     // absolute height locked
     521         [ +  - ]:           1 :     tx.vin[0].prevout.hash = txFirst[2]->GetHash();
     522                 :           1 :     tx.vin[0].nSequence = CTxIn::MAX_SEQUENCE_NONFINAL;
     523                 :           1 :     prevheights[0] = baseheight + 3;
     524   [ +  -  -  + ]:           1 :     tx.nLockTime = m_node.chainman->ActiveChain().Tip()->nHeight + 1;
     525         [ +  - ]:           1 :     hash = tx.GetHash();
     526   [ +  -  +  - ]:           1 :     AddToMempool(tx_mempool, entry.Time(Now<NodeSeconds>()).FromTx(tx));
     527   [ +  -  +  -  :           4 :     BOOST_CHECK(!CheckFinalTxAtTip(*Assert(m_node.chainman->ActiveChain().Tip()), CTransaction{tx})); // Locktime fails
          +  -  -  +  +  
          -  +  -  +  -  
                   +  - ]
     528   [ +  -  +  -  :           3 :     BOOST_CHECK(TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks pass
          +  -  +  -  +  
                      - ]
     529   [ +  -  +  -  :           5 :     BOOST_CHECK(IsFinalTx(CTransaction(tx), m_node.chainman->ActiveChain().Tip()->nHeight + 2, m_node.chainman->ActiveChain().Tip()->GetMedianTimePast())); // Locktime passes on 2nd block
          -  +  +  -  -  
          +  +  -  +  -  
             +  -  +  - ]
     530                 :             : 
     531                 :             :     // ensure tx is final for a specific case where there is no locktime and block height is zero
     532                 :           1 :     tx.nLockTime = 0;
     533   [ +  -  +  -  :           4 :     BOOST_CHECK(IsFinalTx(CTransaction(tx), /*nBlockHeight=*/0, m_node.chainman->ActiveChain().Tip()->GetMedianTimePast()));
          -  +  +  -  +  
             -  +  -  +  
                      - ]
     534                 :             : 
     535                 :             :     // absolute time locked
     536         [ +  - ]:           1 :     tx.vin[0].prevout.hash = txFirst[3]->GetHash();
     537   [ +  -  -  + ]:           2 :     tx.nLockTime = m_node.chainman->ActiveChain().Tip()->GetMedianTimePast();
     538         [ +  - ]:           1 :     prevheights.resize(1);
     539         [ +  - ]:           1 :     prevheights[0] = baseheight + 4;
     540         [ +  - ]:           1 :     hash = tx.GetHash();
     541   [ +  -  +  - ]:           1 :     AddToMempool(tx_mempool, entry.Time(Now<NodeSeconds>()).FromTx(tx));
     542   [ +  -  +  -  :           4 :     BOOST_CHECK(!CheckFinalTxAtTip(*Assert(m_node.chainman->ActiveChain().Tip()), CTransaction{tx})); // Locktime fails
          +  -  -  +  +  
          -  +  -  +  -  
                   +  - ]
     543   [ +  -  +  -  :           3 :     BOOST_CHECK(TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks pass
          +  -  +  -  +  
                      - ]
     544   [ +  -  +  -  :           5 :     BOOST_CHECK(IsFinalTx(CTransaction(tx), m_node.chainman->ActiveChain().Tip()->nHeight + 2, m_node.chainman->ActiveChain().Tip()->GetMedianTimePast() + 1)); // Locktime passes 1 second later
          -  +  +  -  -  
          +  +  -  +  -  
             +  -  +  - ]
     545                 :             : 
     546                 :             :     // mempool-dependent transactions (not added)
     547         [ +  - ]:           1 :     tx.vin[0].prevout.hash = hash;
     548   [ +  -  -  +  :           2 :     prevheights[0] = m_node.chainman->ActiveChain().Tip()->nHeight + 1;
                   +  - ]
     549                 :           1 :     tx.nLockTime = 0;
     550                 :           1 :     tx.vin[0].nSequence = 0;
     551   [ +  -  +  -  :           4 :     BOOST_CHECK(CheckFinalTxAtTip(*Assert(m_node.chainman->ActiveChain().Tip()), CTransaction{tx})); // Locktime passes
          +  -  -  +  +  
          -  +  -  +  -  
                   +  - ]
     552   [ +  -  +  -  :           3 :     BOOST_CHECK(TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks pass
          +  -  +  -  +  
                      - ]
     553         [ +  - ]:           1 :     tx.vin[0].nSequence = 1;
     554   [ +  -  +  -  :           3 :     BOOST_CHECK(!TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks fail
          +  -  +  -  +  
                      - ]
     555         [ +  - ]:           1 :     tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG;
     556   [ +  -  +  -  :           3 :     BOOST_CHECK(TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks pass
          +  -  +  -  +  
                      - ]
     557         [ +  - ]:           1 :     tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG | 1;
     558   [ +  -  +  -  :           3 :     BOOST_CHECK(!TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks fail
          +  -  +  -  +  
                      - ]
     559                 :             : 
     560         [ +  - ]:           1 :     auto block_template = mining->createNewBlock(options);
     561   [ +  -  +  -  :           2 :     BOOST_REQUIRE(block_template);
                   +  - ]
     562                 :             : 
     563                 :             :     // None of the of the absolute height/time locked tx should have made
     564                 :             :     // it into the template because we still check IsFinalTx in CreateNewBlock,
     565                 :             :     // but relative locked txs will if inconsistently added to mempool.
     566                 :             :     // For now these will still generate a valid template until BIP68 soft fork
     567         [ +  - ]:           1 :     CBlock block{block_template->getBlock()};
     568   [ +  -  -  +  :           1 :     BOOST_CHECK_EQUAL(block.vtx.size(), 3U);
                   +  - ]
     569                 :             :     // However if we advance height by 1 and time by SEQUENCE_LOCK_TIME, all of them should be mined
     570         [ +  + ]:          12 :     for (int i = 0; i < CBlockIndex::nMedianTimeSpan; ++i) {
     571   [ +  -  -  +  :          33 :         CBlockIndex* ancestor{Assert(m_node.chainman->ActiveChain().Tip()->GetAncestor(m_node.chainman->ActiveChain().Tip()->nHeight - i))};
          +  -  -  +  +  
                -  +  - ]
     572                 :          11 :         ancestor->nTime += SEQUENCE_LOCK_TIME; // Trick the MedianTimePast
     573                 :             :     }
     574   [ +  -  -  + ]:           1 :     m_node.chainman->ActiveChain().Tip()->nHeight++;
     575   [ +  -  -  +  :           2 :     SetMockTime(m_node.chainman->ActiveChain().Tip()->GetMedianTimePast() + 1);
                   +  - ]
     576                 :             : 
     577         [ +  - ]:           2 :     block_template = mining->createNewBlock(options);
     578   [ +  -  +  -  :           2 :     BOOST_REQUIRE(block_template);
                   +  - ]
     579         [ +  - ]:           1 :     block = block_template->getBlock();
     580   [ +  -  -  +  :           1 :     BOOST_CHECK_EQUAL(block.vtx.size(), 5U);
                   +  - ]
     581         [ +  - ]:           3 : }
     582                 :             : 
     583                 :           1 : void MinerTestingSetup::TestPrioritisedMining(const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst)
     584                 :             : {
     585                 :           1 :     auto mining{MakeMining()};
     586   [ +  -  +  -  :           2 :     BOOST_REQUIRE(mining);
                   +  - ]
     587                 :             : 
     588         [ +  - ]:           1 :     BlockAssembler::Options options;
     589                 :           1 :     options.coinbase_output_script = scriptPubKey;
     590                 :             : 
     591         [ +  - ]:           1 :     CTxMemPool& tx_mempool{MakeMempool()};
     592         [ +  - ]:           1 :     LOCK(tx_mempool.cs);
     593                 :             : 
     594                 :           1 :     TestMemPoolEntryHelper entry;
     595                 :             : 
     596                 :             :     // Test that a tx below min fee but prioritised is included
     597         [ +  - ]:           1 :     CMutableTransaction tx;
     598         [ +  - ]:           1 :     tx.vin.resize(1);
     599         [ +  - ]:           1 :     tx.vin[0].prevout.hash = txFirst[0]->GetHash();
     600                 :           1 :     tx.vin[0].prevout.n = 0;
     601         [ +  - ]:           1 :     tx.vin[0].scriptSig = CScript() << OP_1;
     602         [ +  - ]:           1 :     tx.vout.resize(1);
     603         [ +  - ]:           1 :     tx.vout[0].nValue = 5000000000LL; // 0 fee
     604         [ +  - ]:           1 :     Txid hashFreePrioritisedTx = tx.GetHash();
     605   [ +  -  +  - ]:           1 :     AddToMempool(tx_mempool, entry.Fee(0).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx));
     606         [ +  - ]:           1 :     tx_mempool.PrioritiseTransaction(hashFreePrioritisedTx, 5 * COIN);
     607                 :             : 
     608         [ +  - ]:           1 :     tx.vin[0].prevout.hash = txFirst[1]->GetHash();
     609                 :           1 :     tx.vin[0].prevout.n = 0;
     610                 :           1 :     tx.vout[0].nValue = 5000000000LL - 1000;
     611                 :             :     // This tx has a low fee: 1000 satoshis
     612         [ +  - ]:           1 :     Txid hashParentTx = tx.GetHash(); // save this txid for later use
     613   [ +  -  +  - ]:           1 :     AddToMempool(tx_mempool, entry.Fee(1000).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx));
     614                 :             : 
     615                 :             :     // This tx has a medium fee: 10000 satoshis
     616         [ +  - ]:           1 :     tx.vin[0].prevout.hash = txFirst[2]->GetHash();
     617                 :           1 :     tx.vout[0].nValue = 5000000000LL - 10000;
     618         [ +  - ]:           1 :     Txid hashMediumFeeTx = tx.GetHash();
     619   [ +  -  +  - ]:           1 :     AddToMempool(tx_mempool, entry.Fee(10000).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx));
     620         [ +  - ]:           1 :     tx_mempool.PrioritiseTransaction(hashMediumFeeTx, -5 * COIN);
     621                 :             : 
     622                 :             :     // This tx also has a low fee, but is prioritised
     623         [ +  - ]:           1 :     tx.vin[0].prevout.hash = hashParentTx;
     624                 :           1 :     tx.vout[0].nValue = 5000000000LL - 1000 - 1000; // 1000 satoshi fee
     625         [ +  - ]:           1 :     Txid hashPrioritsedChild = tx.GetHash();
     626   [ +  -  +  - ]:           1 :     AddToMempool(tx_mempool, entry.Fee(1000).Time(Now<NodeSeconds>()).SpendsCoinbase(false).FromTx(tx));
     627         [ +  - ]:           1 :     tx_mempool.PrioritiseTransaction(hashPrioritsedChild, 2 * COIN);
     628                 :             : 
     629                 :             :     // Test that transaction selection properly updates ancestor fee calculations as prioritised
     630                 :             :     // parents get included in a block. Create a transaction with two prioritised ancestors, each
     631                 :             :     // included by itself: FreeParent <- FreeChild <- FreeGrandchild.
     632                 :             :     // When FreeParent is added, a modified entry will be created for FreeChild + FreeGrandchild
     633                 :             :     // FreeParent's prioritisation should not be included in that entry.
     634                 :             :     // When FreeChild is included, FreeChild's prioritisation should also not be included.
     635         [ +  - ]:           1 :     tx.vin[0].prevout.hash = txFirst[3]->GetHash();
     636                 :           1 :     tx.vout[0].nValue = 5000000000LL; // 0 fee
     637         [ +  - ]:           1 :     Txid hashFreeParent = tx.GetHash();
     638   [ +  -  +  - ]:           1 :     AddToMempool(tx_mempool, entry.Fee(0).SpendsCoinbase(true).FromTx(tx));
     639         [ +  - ]:           1 :     tx_mempool.PrioritiseTransaction(hashFreeParent, 10 * COIN);
     640                 :             : 
     641         [ +  - ]:           1 :     tx.vin[0].prevout.hash = hashFreeParent;
     642                 :           1 :     tx.vout[0].nValue = 5000000000LL; // 0 fee
     643         [ +  - ]:           1 :     Txid hashFreeChild = tx.GetHash();
     644   [ +  -  +  - ]:           1 :     AddToMempool(tx_mempool, entry.Fee(0).SpendsCoinbase(false).FromTx(tx));
     645         [ +  - ]:           1 :     tx_mempool.PrioritiseTransaction(hashFreeChild, 1 * COIN);
     646                 :             : 
     647         [ +  - ]:           1 :     tx.vin[0].prevout.hash = hashFreeChild;
     648                 :           1 :     tx.vout[0].nValue = 5000000000LL; // 0 fee
     649         [ +  - ]:           1 :     Txid hashFreeGrandchild = tx.GetHash();
     650   [ +  -  +  - ]:           1 :     AddToMempool(tx_mempool, entry.Fee(0).SpendsCoinbase(false).FromTx(tx));
     651                 :             : 
     652         [ +  - ]:           1 :     auto block_template = mining->createNewBlock(options);
     653   [ +  -  +  -  :           2 :     BOOST_REQUIRE(block_template);
                   +  - ]
     654         [ +  - ]:           1 :     CBlock block{block_template->getBlock()};
     655   [ +  -  -  +  :           1 :     BOOST_REQUIRE_EQUAL(block.vtx.size(), 6U);
                   +  - ]
     656   [ +  -  +  -  :           2 :     BOOST_CHECK(block.vtx[1]->GetHash() == hashFreeParent);
                   +  - ]
     657   [ +  -  +  -  :           2 :     BOOST_CHECK(block.vtx[2]->GetHash() == hashFreePrioritisedTx);
                   +  - ]
     658   [ +  -  +  -  :           2 :     BOOST_CHECK(block.vtx[3]->GetHash() == hashParentTx);
                   +  - ]
     659   [ +  -  +  -  :           2 :     BOOST_CHECK(block.vtx[4]->GetHash() == hashPrioritsedChild);
                   +  - ]
     660   [ +  -  +  - ]:           2 :     BOOST_CHECK(block.vtx[5]->GetHash() == hashFreeChild);
     661   [ -  +  +  + ]:           7 :     for (size_t i=0; i<block.vtx.size(); ++i) {
     662                 :             :         // The FreeParent and FreeChild's prioritisations should not impact the child.
     663   [ +  -  +  -  :          12 :         BOOST_CHECK(block.vtx[i]->GetHash() != hashFreeGrandchild);
                   +  - ]
     664                 :             :         // De-prioritised transaction should not be included.
     665   [ +  -  +  - ]:          12 :         BOOST_CHECK(block.vtx[i]->GetHash() != hashMediumFeeTx);
     666                 :             :     }
     667         [ +  - ]:           3 : }
     668                 :             : 
     669                 :             : // NOTE: These tests rely on CreateNewBlock doing its own self-validation!
     670   [ +  -  +  -  :           7 : BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
          +  -  +  -  -  
          +  +  -  +  -  
          +  -  +  -  +  
          -  +  -  -  +  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  -  +  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  -  +  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  -  +  +  
                      - ]
     671                 :             : {
     672                 :           1 :     auto mining{MakeMining()};
     673   [ +  -  +  - ]:           2 :     BOOST_REQUIRE(mining);
     674                 :             : 
     675                 :             :     // Note that by default, these tests run with size accounting enabled.
     676         [ +  - ]:           1 :     CScript scriptPubKey = CScript() << "04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f"_hex << OP_CHECKSIG;
     677         [ +  - ]:           1 :     BlockAssembler::Options options;
     678                 :           1 :     options.coinbase_output_script = scriptPubKey;
     679                 :             : 
     680                 :             :     // Create and check a simple template
     681         [ +  - ]:           1 :     std::unique_ptr<BlockTemplate> block_template = mining->createNewBlock(options);
     682   [ +  -  +  -  :           2 :     BOOST_REQUIRE(block_template);
                   +  - ]
     683                 :           1 :     {
     684         [ +  - ]:           1 :         CBlock block{block_template->getBlock()};
     685                 :           1 :         {
     686         [ +  - ]:           1 :             std::string reason;
     687                 :           1 :             std::string debug;
     688   [ +  -  +  -  :           2 :             BOOST_REQUIRE(!mining->checkBlock(block, {.check_pow = false}, reason, debug));
             +  -  +  - ]
     689   [ +  -  +  - ]:           1 :             BOOST_REQUIRE_EQUAL(reason, "bad-txnmrklroot");
     690   [ +  -  +  - ]:           1 :             BOOST_REQUIRE_EQUAL(debug, "hashMerkleRoot mismatch");
     691                 :           1 :         }
     692                 :             : 
     693         [ +  - ]:           1 :         block.hashMerkleRoot = BlockMerkleRoot(block);
     694                 :             : 
     695                 :           1 :         {
     696         [ +  - ]:           1 :             std::string reason;
     697                 :           1 :             std::string debug;
     698   [ +  -  +  -  :           2 :             BOOST_REQUIRE(mining->checkBlock(block, {.check_pow = false}, reason, debug));
             +  -  +  - ]
     699   [ +  -  +  - ]:           1 :             BOOST_REQUIRE_EQUAL(reason, "");
     700   [ +  -  +  - ]:           1 :             BOOST_REQUIRE_EQUAL(debug, "");
     701                 :           1 :         }
     702                 :             : 
     703                 :           1 :         {
     704                 :             :             // A block template does not have proof-of-work, but it might pass
     705                 :             :             // verification by coincidence. Grind the nonce if needed:
     706   [ +  -  +  -  :           1 :             while (CheckProofOfWork(block.GetHash(), block.nBits, Assert(m_node.chainman)->GetParams().GetConsensus())) {
             +  -  -  + ]
     707                 :           0 :                 block.nNonce++;
     708                 :             :             }
     709                 :             : 
     710         [ +  - ]:           1 :             std::string reason;
     711                 :           1 :             std::string debug;
     712   [ +  -  +  -  :           2 :             BOOST_REQUIRE(!mining->checkBlock(block, {.check_pow = true}, reason, debug));
             +  -  +  - ]
     713   [ +  -  +  - ]:           1 :             BOOST_REQUIRE_EQUAL(reason, "high-hash");
     714   [ +  -  +  - ]:           1 :             BOOST_REQUIRE_EQUAL(debug, "proof of work failed");
     715                 :           1 :         }
     716                 :           0 :     }
     717                 :             : 
     718                 :             :     // We can't make transactions until we have inputs
     719                 :             :     // Therefore, load 110 blocks :)
     720                 :           1 :     static_assert(std::size(BLOCKINFO) == 110, "Should have 110 blocks to import");
     721                 :           1 :     int baseheight = 0;
     722                 :           1 :     std::vector<CTransactionRef> txFirst;
     723         [ +  + ]:         111 :     for (const auto& bi : BLOCKINFO) {
     724         [ +  - ]:         110 :         const int current_height{mining->getTip()->height};
     725                 :             : 
     726                 :             :         /**
     727                 :             :          * Simple block creation, nothing special yet.
     728                 :             :          * If current_height is odd, block_template will have already been
     729                 :             :          * set at the end of the previous loop.
     730                 :             :          */
     731         [ +  + ]:         110 :         if (current_height % 2 == 0) {
     732         [ +  - ]:         110 :             block_template = mining->createNewBlock(options);
     733   [ +  -  +  - ]:         110 :             BOOST_REQUIRE(block_template);
     734                 :             :         }
     735                 :             : 
     736         [ +  - ]:         110 :         CBlock block{block_template->getBlock()};
     737         [ +  - ]:         110 :         CMutableTransaction txCoinbase(*block.vtx[0]);
     738                 :         110 :         {
     739         [ +  - ]:         110 :             LOCK(cs_main);
     740                 :         110 :             block.nVersion = VERSIONBITS_TOP_BITS;
     741   [ +  -  +  -  :         220 :             block.nTime = Assert(m_node.chainman)->ActiveChain().Tip()->GetMedianTimePast()+1;
                   -  + ]
     742                 :         110 :             txCoinbase.version = 1;
     743   [ +  -  +  - ]:         110 :             txCoinbase.vin[0].scriptSig = CScript{} << (current_height + 1) << bi.extranonce;
     744         [ +  - ]:         110 :             txCoinbase.vout.resize(1); // Ignore the (optional) segwit commitment added by CreateNewBlock (as the hardcoded nonces don't account for this)
     745                 :         110 :             txCoinbase.vout[0].scriptPubKey = CScript();
     746   [ +  -  -  + ]:         220 :             block.vtx[0] = MakeTransactionRef(txCoinbase);
     747   [ -  +  +  + ]:         110 :             if (txFirst.size() == 0)
     748                 :           1 :                 baseheight = current_height;
     749         [ +  + ]:         110 :             if (txFirst.size() < 4)
     750         [ +  - ]:           4 :                 txFirst.push_back(block.vtx[0]);
     751         [ +  - ]:         110 :             block.hashMerkleRoot = BlockMerkleRoot(block);
     752         [ +  - ]:         110 :             block.nNonce = bi.nonce;
     753                 :           0 :         }
     754         [ +  - ]:         110 :         std::shared_ptr<const CBlock> shared_pblock = std::make_shared<const CBlock>(block);
     755                 :             :         // Alternate calls between Chainman's ProcessNewBlock and submitSolution
     756                 :             :         // via the Mining interface. The former is used by net_processing as well
     757                 :             :         // as the submitblock RPC.
     758         [ +  + ]:         110 :         if (current_height % 2 == 0) {
     759   [ +  -  +  -  :         110 :             BOOST_REQUIRE(Assert(m_node.chainman)->ProcessNewBlock(shared_pblock, /*force_processing=*/true, /*min_pow_checked=*/true, nullptr));
             +  -  +  - ]
     760                 :             :         } else {
     761   [ +  -  +  -  :         165 :             BOOST_REQUIRE(block_template->submitSolution(block.nVersion, block.nTime, block.nNonce, MakeTransactionRef(txCoinbase)));
          +  -  +  -  -  
                      + ]
     762                 :             :         }
     763                 :         110 :         {
     764         [ +  - ]:         110 :             LOCK(cs_main);
     765                 :             :             // The above calls don't guarantee the tip is actually updated, so
     766                 :             :             // we explicitly check this.
     767   [ +  -  +  -  :         110 :             auto maybe_new_tip{Assert(m_node.chainman)->ActiveChain().Tip()};
                   -  + ]
     768   [ +  -  +  -  :         110 :             BOOST_REQUIRE_EQUAL(maybe_new_tip->GetBlockHash(), block.GetHash());
             +  -  +  - ]
     769                 :           0 :         }
     770         [ +  + ]:         110 :         if (current_height % 2 == 0) {
     771         [ +  - ]:         110 :             block_template = block_template->waitNext();
     772   [ +  -  +  - ]:         110 :             BOOST_REQUIRE(block_template);
     773                 :             :         } else {
     774                 :             :             // This just adds coverage
     775         [ +  - ]:          55 :             mining->waitTipChanged(block.hashPrevBlock);
     776                 :             :         }
     777                 :         220 :     }
     778                 :             : 
     779         [ +  - ]:           1 :     LOCK(cs_main);
     780                 :             : 
     781         [ +  - ]:           1 :     TestBasicMining(scriptPubKey, txFirst, baseheight);
     782                 :             : 
     783   [ +  -  -  + ]:           1 :     m_node.chainman->ActiveChain().Tip()->nHeight--;
     784         [ +  - ]:           1 :     SetMockTime(0);
     785                 :             : 
     786         [ +  - ]:           1 :     TestPackageSelection(scriptPubKey, txFirst);
     787                 :             : 
     788   [ +  -  -  + ]:           1 :     m_node.chainman->ActiveChain().Tip()->nHeight--;
     789         [ +  - ]:           1 :     SetMockTime(0);
     790                 :             : 
     791         [ +  - ]:           1 :     TestPrioritisedMining(scriptPubKey, txFirst);
     792                 :           1 : }
     793                 :             : 
     794                 :             : BOOST_AUTO_TEST_SUITE_END()
        

Generated by: LCOV version 2.0-1