Branch data     Line data    Source code

       1                 :            : #include <test/fuzz/FuzzedDataProvider.h>
       2                 :            : #include <test/fuzz/fuzz.h>
       3                 :            : #include <test/fuzz/util.h>
       4                 :            : #include <test/fuzz/util/mempool.h>
       5                 :            : #include <test/util/script.h>
       6                 :            : #include <test/util/setup_common.h>
       7                 :            : #include <test/util/txmempool.h>
       8                 :            : #include <test/util/mining.h>
       9                 :            : 
      10                 :            : #include <node/mini_miner.h>
      11         [ +  - ]:          2 : #include <node/miner.h>
      12         [ +  - ]:          2 : #include <primitives/transaction.h>
      13                 :          2 : #include <random.h>
      14         [ +  - ]:          2 : #include <txmempool.h>
      15   [ +  -  +  -  :          2 : 
                   +  - ]
      16                 :            : #include <deque>
      17         [ +  - ]:          2 : #include <vector>
      18         [ +  - ]:          2 : 
      19                 :            : namespace {
      20                 :            : 
      21                 :            : const TestingSetup* g_setup;
      22                 :          2 : std::deque<COutPoint> g_available_coins;
      23                 :          0 : void initialize_miner()
      24                 :            : {
      25   [ #  #  #  #  :          0 :     static const auto testing_setup = MakeNoLogFileContext<const TestingSetup>();
                   #  # ]
      26                 :          0 :     g_setup = testing_setup.get();
      27         [ #  # ]:          0 :     for (uint32_t i = 0; i < uint32_t{100}; ++i) {
      28                 :          0 :         g_available_coins.push_back(COutPoint{uint256::ZERO, i});
      29                 :          0 :     }
      30                 :          0 : }
      31                 :            : 
      32                 :            : // Test that the MiniMiner can run with various outpoints and feerates.
      33   [ +  -  -  + ]:          4 : FUZZ_TARGET(mini_miner, .init = initialize_miner)
      34                 :            : {
      35                 :          0 :     FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
      36                 :          0 :     CTxMemPool pool{CTxMemPool::Options{}};
      37                 :          0 :     std::vector<COutPoint> outpoints;
      38         [ #  # ]:          0 :     std::deque<COutPoint> available_coins = g_available_coins;
      39   [ #  #  #  #  :          0 :     LOCK2(::cs_main, pool.cs);
             #  #  #  # ]
      40                 :            :     // Cluster size cannot exceed 500
      41   [ #  #  #  # ]:          0 :     LIMITED_WHILE(!available_coins.empty(), 500)
      42                 :            :     {
      43         [ #  # ]:          0 :         CMutableTransaction mtx = CMutableTransaction();
      44         [ #  # ]:          0 :         const size_t num_inputs = fuzzed_data_provider.ConsumeIntegralInRange<size_t>(1, available_coins.size());
      45         [ #  # ]:          0 :         const size_t num_outputs = fuzzed_data_provider.ConsumeIntegralInRange<size_t>(1, 50);
      46         [ #  # ]:          0 :         for (size_t n{0}; n < num_inputs; ++n) {
      47                 :          0 :             auto prevout = available_coins.front();
      48   [ #  #  #  #  :          0 :             mtx.vin.push_back(CTxIn(prevout, CScript()));
                   #  # ]
      49                 :          0 :             available_coins.pop_front();
      50                 :          0 :         }
      51         [ #  # ]:          0 :         for (uint32_t n{0}; n < num_outputs; ++n) {
      52   [ #  #  #  #  :          0 :             mtx.vout.push_back(CTxOut(100, P2WSH_OP_TRUE));
                   #  # ]
      53                 :          0 :         }
      54         [ #  # ]:          0 :         CTransactionRef tx = MakeTransactionRef(mtx);
      55   [ #  #  #  #  :          0 :         TestMemPoolEntryHelper entry;
                   #  # ]
      56         [ #  # ]:          0 :         const CAmount fee{ConsumeMoney(fuzzed_data_provider, /*max=*/MAX_MONEY/100000)};
      57   [ #  #  #  # ]:          0 :         assert(MoneyRange(fee));
      58   [ #  #  #  #  :          0 :         pool.addUnchecked(entry.Fee(fee).FromTx(tx));
                   #  # ]
      59                 :          0 : 
      60                 :            :         // All outputs are available to spend
      61         [ #  # ]:          0 :         for (uint32_t n{0}; n < num_outputs; ++n) {
      62   [ #  #  #  # ]:          0 :             if (fuzzed_data_provider.ConsumeBool()) {
      63   [ #  #  #  #  :          0 :                 available_coins.push_back(COutPoint{tx->GetHash(), n});
                   #  # ]
      64                 :          0 :             }
      65                 :          0 :         }
      66                 :            : 
      67   [ #  #  #  #  :          0 :         if (fuzzed_data_provider.ConsumeBool() && !tx->vout.empty()) {
                   #  # ]
      68                 :            :             // Add outpoint from this tx (may or not be spent by a later tx)
      69   [ #  #  #  #  :          0 :             outpoints.push_back(COutPoint{tx->GetHash(),
                   #  # ]
      70         [ #  # ]:          0 :                                           (uint32_t)fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, tx->vout.size())});
      71                 :          0 :         } else {
      72                 :            :             // Add some random outpoint (will be interpreted as confirmed or not yet submitted
      73                 :            :             // to mempool).
      74                 :          2 :             auto outpoint = ConsumeDeserializable<COutPoint>(fuzzed_data_provider);
      75   [ #  #  #  #  :          0 :             if (outpoint.has_value() && std::find(outpoints.begin(), outpoints.end(), *outpoint) == outpoints.end()) {
             #  #  #  # ]
      76   [ #  #  #  # ]:          0 :                 outpoints.push_back(*outpoint);
      77                 :          0 :             }
      78                 :            :         }
      79                 :            : 
      80                 :          0 :     }
      81                 :            : 
      82   [ #  #  #  # ]:          0 :     const CFeeRate target_feerate{CFeeRate{ConsumeMoney(fuzzed_data_provider, /*max=*/MAX_MONEY/1000)}};
      83                 :          0 :     std::optional<CAmount> total_bumpfee;
      84                 :          0 :     CAmount sum_fees = 0;
      85                 :            :     {
      86         [ #  # ]:          0 :         node::MiniMiner mini_miner{pool, outpoints};
      87   [ #  #  #  # ]:          0 :         assert(mini_miner.IsReadyToCalculate());
      88         [ #  # ]:          0 :         const auto bump_fees = mini_miner.CalculateBumpFees(target_feerate);
      89         [ #  # ]:          0 :         for (const auto& outpoint : outpoints) {
      90         [ #  # ]:          0 :             auto it = bump_fees.find(outpoint);
      91         [ #  # ]:          0 :             assert(it != bump_fees.end());
      92         [ #  # ]:          0 :             assert(it->second >= 0);
      93                 :          0 :             sum_fees += it->second;
      94                 :            :         }
      95   [ #  #  #  # ]:          0 :         assert(!mini_miner.IsReadyToCalculate());
      96                 :          0 :     }
      97                 :            :     {
      98         [ #  # ]:          0 :         node::MiniMiner mini_miner{pool, outpoints};
      99   [ #  #  #  # ]:          0 :         assert(mini_miner.IsReadyToCalculate());
     100         [ #  # ]:          0 :         total_bumpfee = mini_miner.CalculateTotalBumpFees(target_feerate);
     101         [ #  # ]:          0 :         assert(total_bumpfee.has_value());
     102   [ #  #  #  # ]:          0 :         assert(!mini_miner.IsReadyToCalculate());
     103                 :          0 :     }
     104                 :            :     // Overlapping ancestry across multiple outpoints can only reduce the total bump fee.
     105   [ #  #  #  # ]:          0 :     assert (sum_fees >= *total_bumpfee);
     106                 :          0 : }
     107                 :            : 
     108                 :            : // Test that MiniMiner and BlockAssembler build the same block given the same transactions and constraints.
     109   [ +  -  -  + ]:          4 : FUZZ_TARGET(mini_miner_selection, .init = initialize_miner)
     110                 :            : {
     111                 :          0 :     FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
     112                 :          0 :     CTxMemPool pool{CTxMemPool::Options{}};
     113                 :            :     // Make a copy to preserve determinism.
     114         [ #  # ]:          0 :     std::deque<COutPoint> available_coins = g_available_coins;
     115                 :          0 :     std::vector<CTransactionRef> transactions;
     116                 :            : 
     117   [ #  #  #  # ]:          0 :     LOCK2(::cs_main, pool.cs);
     118   [ #  #  #  #  :          0 :     LIMITED_WHILE(fuzzed_data_provider.ConsumeBool(), 100)
                   #  # ]
     119                 :            :     {
     120         [ #  # ]:          0 :         CMutableTransaction mtx = CMutableTransaction();
     121         [ #  # ]:          0 :         assert(!available_coins.empty());
     122                 :          0 :         const size_t num_inputs = std::min(size_t{2}, available_coins.size());
     123                 :          0 :         const size_t num_outputs = fuzzed_data_provider.ConsumeIntegralInRange<size_t>(2, 5);
     124         [ #  # ]:          0 :         for (size_t n{0}; n < num_inputs; ++n) {
     125         [ #  # ]:          0 :             auto prevout = available_coins.at(0);
     126   [ #  #  #  #  :          0 :             mtx.vin.push_back(CTxIn(prevout, CScript()));
                   #  # ]
     127                 :          0 :             available_coins.pop_front();
     128                 :          0 :         }
     129         [ #  # ]:          0 :         for (uint32_t n{0}; n < num_outputs; ++n) {
     130   [ #  #  #  #  :          0 :             mtx.vout.push_back(CTxOut(100, P2WSH_OP_TRUE));
                   #  # ]
     131                 :          0 :         }
     132         [ #  # ]:          0 :         CTransactionRef tx = MakeTransactionRef(mtx);
     133                 :            : 
     134                 :            :         // First 2 outputs are available to spend. The rest are added to outpoints to calculate bumpfees.
     135                 :            :         // There is no overlap between spendable coins and outpoints passed to MiniMiner because the
     136                 :            :         // MiniMiner interprets spent coins as to-be-replaced and excludes them.
     137         [ #  # ]:          0 :         for (uint32_t n{0}; n < num_outputs - 1; ++n) {
     138   [ #  #  #  # ]:          0 :             if (fuzzed_data_provider.ConsumeBool()) {
     139   [ #  #  #  # ]:          0 :                 available_coins.push_front(COutPoint{tx->GetHash(), n});
     140                 :          0 :             } else {
     141   [ #  #  #  # ]:          0 :                 available_coins.push_back(COutPoint{tx->GetHash(), n});
     142                 :            :             }
     143                 :          0 :         }
     144                 :            : 
     145                 :            :         // Stop if pool reaches DEFAULT_BLOCK_MAX_WEIGHT because BlockAssembler will stop when the
     146                 :            :         // block template reaches that, but the MiniMiner will keep going.
     147   [ #  #  #  #  :          0 :         if (pool.GetTotalTxSize() + GetVirtualTransactionSize(*tx) >= DEFAULT_BLOCK_MAX_WEIGHT) break;
                   #  # ]
     148         [ #  # ]:          0 :         TestMemPoolEntryHelper entry;
     149         [ #  # ]:          0 :         const CAmount fee{ConsumeMoney(fuzzed_data_provider, /*max=*/MAX_MONEY/100000)};
     150         [ #  # ]:          0 :         assert(MoneyRange(fee));
     151   [ #  #  #  # ]:          0 :         pool.addUnchecked(entry.Fee(fee).FromTx(tx));
     152         [ #  # ]:          0 :         transactions.push_back(tx);
     153      [ #  #  # ]:          0 :     }
     154                 :          0 :     std::vector<COutPoint> outpoints;
     155         [ #  # ]:          0 :     for (const auto& coin : g_available_coins) {
     156   [ #  #  #  #  :          0 :         if (!pool.GetConflictTx(coin)) outpoints.push_back(coin);
                   #  # ]
     157                 :            :     }
     158         [ #  # ]:          0 :     for (const auto& tx : transactions) {
     159   [ #  #  #  #  :          0 :         assert(pool.exists(GenTxid::Txid(tx->GetHash())));
                   #  # ]
     160         [ #  # ]:          0 :         for (uint32_t n{0}; n < tx->vout.size(); ++n) {
     161         [ #  # ]:          0 :             COutPoint coin{tx->GetHash(), n};
     162   [ #  #  #  #  :          0 :             if (!pool.GetConflictTx(coin)) outpoints.push_back(coin);
                   #  # ]
     163                 :          0 :         }
     164                 :            :     }
     165   [ #  #  #  # ]:          0 :     const CFeeRate target_feerate{ConsumeMoney(fuzzed_data_provider, /*max=*/MAX_MONEY/100000)};
     166                 :            : 
     167         [ #  # ]:          0 :     node::BlockAssembler::Options miner_options;
     168                 :          0 :     miner_options.blockMinFeeRate = target_feerate;
     169                 :          0 :     miner_options.nBlockMaxWeight = DEFAULT_BLOCK_MAX_WEIGHT;
     170                 :          0 :     miner_options.test_block_validity = false;
     171                 :            : 
     172   [ #  #  #  # ]:          0 :     node::BlockAssembler miner{g_setup->m_node.chainman->ActiveChainstate(), &pool, miner_options};
     173         [ #  # ]:          0 :     node::MiniMiner mini_miner{pool, outpoints};
     174         [ #  # ]:          0 :     assert(mini_miner.IsReadyToCalculate());
     175                 :            : 
     176   [ #  #  #  #  :          0 :     CScript spk_placeholder = CScript() << OP_0;
                   #  # ]
     177                 :            :     // Use BlockAssembler as oracle. BlockAssembler and MiniMiner should select the same
     178                 :            :     // transactions, stopping once packages do not meet target_feerate.
     179         [ #  # ]:          0 :     const auto blocktemplate{miner.CreateNewBlock(spk_placeholder)};
     180         [ #  # ]:          0 :     mini_miner.BuildMockTemplate(target_feerate);
     181         [ #  # ]:          0 :     assert(!mini_miner.IsReadyToCalculate());
     182         [ #  # ]:          0 :     auto mock_template_txids = mini_miner.GetMockTemplateTxids();
     183                 :            :     // MiniMiner doesn't add a coinbase tx.
     184   [ #  #  #  # ]:          0 :     assert(mock_template_txids.count(blocktemplate->block.vtx[0]->GetHash()) == 0);
     185         [ #  # ]:          0 :     mock_template_txids.emplace(blocktemplate->block.vtx[0]->GetHash());
     186         [ #  # ]:          0 :     assert(mock_template_txids.size() <= blocktemplate->block.vtx.size());
     187         [ #  # ]:          0 :     assert(mock_template_txids.size() >= blocktemplate->block.vtx.size());
     188         [ #  # ]:          0 :     assert(mock_template_txids.size() == blocktemplate->block.vtx.size());
     189         [ #  # ]:          0 :     for (const auto& tx : blocktemplate->block.vtx) {
     190   [ #  #  #  # ]:          0 :         assert(mock_template_txids.count(tx->GetHash()));
     191                 :            :     }
     192                 :          0 : }
     193                 :            : } // namespace