Inside Bitcoin

251    Txid hashLowFeeTx = tx.GetHash();
252    TryAddToMempool(tx_mempool, entry.Fee(feeToUse).FromTx(tx));
253
254    // waitNext() should return nullptr because there is no better template
255    should_be_nullptr = block_template->waitNext({.timeout = MillisecondsDouble{0}, .fee_threshold = 1});
256    BOOST_REQUIRE(should_be_nullptr == nullptr);
257
258    block = block_template->getBlock();
259    // Verify that the free tx and the low fee tx didn't get selected
260    for (size_t i=0; i<block.vtx.size(); ++i) {
261        BOOST_CHECK(block.vtx[i]->GetHash() != hashFreeTx);
262        BOOST_CHECK(block.vtx[i]->GetHash() != hashLowFeeTx);
263    }
264
265    // Test that packages above the min relay fee do get included, even if one
266    // of the transactions is below the min relay fee
267    // Remove the low fee transaction and replace with a higher fee transaction
268    tx_mempool.removeRecursive(CTransaction(tx), MemPoolRemovalReason::REPLACED);
269    tx.vout[0].nValue -= 2; // Now we should be just over the min relay fee
270    hashLowFeeTx = tx.GetHash();
271    TryAddToMempool(tx_mempool, entry.Fee(feeToUse + 2).FromTx(tx));
272
273    // waitNext() should return if fees for the new template are at least 1 sat up
274    block_template = block_template->waitNext({.fee_threshold = 1});
275    BOOST_REQUIRE(block_template);
276    block = block_template->getBlock();
277    BOOST_REQUIRE_EQUAL(block.vtx.size(), 6U);
278    BOOST_CHECK(block.vtx[4]->GetHash() == hashFreeTx);
279    BOOST_CHECK(block.vtx[5]->GetHash() == hashLowFeeTx);
280
281    // Test that transaction selection properly updates ancestor fee
282    // calculations as ancestor transactions get included in a block.
283    // Add a 0-fee transaction that has 2 outputs.
284    tx.vin[0].prevout.hash = txFirst[2]->GetHash();
285    tx.vout.resize(2);
286    tx.vout[0].nValue = 5000000000LL - 100000000;
287    tx.vout[1].nValue = 100000000; // 1BTC output
288    // Increase size to avoid rounding errors: when the feerate is extremely small (i.e. 1sat/kvB), evaluating the fee
289    // at smaller sizes gives us rounded values that are equal to each other, which means we incorrectly include
290    // hashFreeTx2 + hashLowFeeTx2.
291    BulkTransaction(tx, 4000);
292    Txid hashFreeTx2 = tx.GetHash();
293    TryAddToMempool(tx_mempool, entry.Fee(0).SpendsCoinbase(true).FromTx(tx));
294
295    // This tx can't be mined by itself
296    tx.vin[0].prevout.hash = hashFreeTx2;
297    tx.vout.resize(1);
298    feeToUse = blockMinFeeRate.GetFee(freeTxSize);
299    tx.vout[0].nValue = 5000000000LL - 100000000 - feeToUse;
300    Txid hashLowFeeTx2 = tx.GetHash();
301    TryAddToMempool(tx_mempool, entry.Fee(feeToUse).SpendsCoinbase(false).FromTx(tx));
302    block_template = mining->createNewBlock(options, /*cooldown=*/false);
303    BOOST_REQUIRE(block_template);
304    block = block_template->getBlock();
305
306    // Verify that this tx isn't selected.
307    for (size_t i=0; i<block.vtx.size(); ++i) {
308        BOOST_CHECK(block.vtx[i]->GetHash() != hashFreeTx2);
309        BOOST_CHECK(block.vtx[i]->GetHash() != hashLowFeeTx2);
310    }
311
312    // This tx will be mineable, and should cause hashLowFeeTx2 to be selected
313    // as well.
314    tx.vin[0].prevout.n = 1;
315    tx.vout[0].nValue = 100000000 - 10000; // 10k satoshi fee
316    TryAddToMempool(tx_mempool, entry.Fee(10000).FromTx(tx));
317    block_template = mining->createNewBlock(options, /*cooldown=*/false);
318    BOOST_REQUIRE(block_template);
319    block = block_template->getBlock();
320    BOOST_REQUIRE_EQUAL(block.vtx.size(), 9U);
321    BOOST_CHECK(block.vtx[8]->GetHash() == hashLowFeeTx2);
322}
323
324// One sigop-dense tx spending `input`: num_outputs bare CHECKMULTISIG outputs,
325// i.e. 20 * num_outputs legacy sigops (OP_NOP forces the inaccurate max-20 count).
326static CMutableTransaction CreateBigSigOpsTx(const COutPoint& input, unsigned int num_outputs)
327{
328    CMutableTransaction tx;
329    tx.vin.resize(1);
330    tx.vin[0].prevout = input;
331    tx.vin[0].scriptSig = CScript() << OP_1;
332    tx.vout.resize(num_outputs);
333    for (auto& out : tx.vout) {
334        out.nValue = 0;
335        out.scriptPubKey = CScript() << OP_0 << OP_0 << OP_0 << OP_NOP << OP_CHECKMULTISIG << OP_1;
336    }
337    return tx;
338}
339
340std::vector<CTransactionRef> CreateBigSigOpsCluster(const CTransactionRef& first_tx)
341{
342    std::vector<CTransactionRef> ret;
343
344    CMutableTransaction tx;
345    // block sigops > limit: 1000 CHECKMULTISIG + 1
346    tx.vin.resize(1);
347    // NOTE: OP_NOP is used to force 20 SigOps for the CHECKMULTISIG
348    tx.vin[0].scriptSig = CScript() << OP_0 << OP_0 << OP_CHECKSIG << OP_1;
349    tx.vin[0].prevout.hash = first_tx->GetHash();
350    tx.vin[0].prevout.n = 0;
351    tx.vout.resize(50);
352    for (auto &out : tx.vout) {
353        out.nValue = first_tx->vout[0].nValue / 50;
354        out.scriptPubKey = CScript() << OP_1;
355    }
356
357    tx.vout[0].nValue -= CENT;
358    CTransactionRef parent_tx = MakeTransactionRef(tx);
359    ret.push_back(parent_tx);
360    assert(GetLegacySigOpCount(*parent_tx) == 1);
361
362    // Tx1 has 1 sigops, 1 input, 50 outputs.
363    // Tx2-51 has 400 sigops: 1 input, 20 CHECKMULTISIG outputs
364    // Total: 1000 CHECKMULTISIG + 1
365    for (unsigned int i = 0; i < 50; ++i) {
366        ret.push_back(MakeTransactionRef(CreateBigSigOpsTx(COutPoint{parent_tx->GetHash(), i}, /*num_outputs=*/20)));
367    }
368    return ret;
369}
370
371void MinerTestingSetup::TestSigOpsAdjustedWeightChunkLimit(const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst)
372{
373    auto mining{MakeMining()};
374    BOOST_REQUIRE(mining);
375
376    CTxMemPool& tx_mempool{MakeMempool()};
377    LOCK(tx_mempool.cs);
378    TestMemPoolEntryHelper entry;
379
380    const auto tx{CreateBigSigOpsTx(COutPoint{txFirst[0]->GetHash(), 0}, /*num_outputs=*/50)};
381    const auto sigop_entry{entry.Fee(COIN).SpendsCoinbase(true).SigOpsCost(GetLegacySigOpCount(CTransaction(tx)) * WITNESS_SCALE_FACTOR).FromTx(tx)};
382    BOOST_REQUIRE(sigop_entry.GetAdjustedWeight() > sigop_entry.GetTxWeight());
383    BOOST_REQUIRE(sigop_entry.GetSigOpCost() < MAX_BLOCK_SIGOPS_COST);
384    TryAddToMempool(tx_mempool, sigop_entry);
385
386    BlockCreateOptions options{
387        // +1 because TestChunkBlockLimits rejects on >= (exact fit doesn't count).
388        .block_max_weight = DEFAULT_BLOCK_RESERVED_WEIGHT + sigop_entry.GetTxWeight() + 1,
389        .coinbase_output_script = scriptPubKey,
390    };
391    const CBlock block{mining->createNewBlock(options, /*cooldown=*/false)->getBlock()};
392    BOOST_CHECK_EQUAL(block.vtx.size(), 2U);
393    BOOST_CHECK(block.vtx[1]->GetHash() == tx.GetHash());
394}
395
396void MinerTestingSetup::TestBasicMining(const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst, int baseheight)
397{
398    FakeNodeClock clock{};
399
400    Txid hash;
401    CMutableTransaction tx;
402    TestMemPoolEntryHelper entry;
403    entry.nFee = 11;
404    entry.nHeight = 11;
405
406    const CAmount BLOCKSUBSIDY = 50 * COIN;
407    const CAmount LOWFEE = CENT;
408    const CAmount HIGHFEE = COIN;
409    const CAmount HIGHERFEE = 4 * COIN;
410
411    auto mining{MakeMining()};
412    BOOST_REQUIRE(mining);
413
414    BlockCreateOptions options{
415        .coinbase_output_script = scriptPubKey,
416    };
417
418    {
419        CTxMemPool& tx_mempool{MakeMempool()};
420        LOCK(tx_mempool.cs);
421
422        // Just to make sure we can still make simple blocks
423        auto block_template{mining->createNewBlock(options, /*cooldown=*/false)};
424        BOOST_REQUIRE(block_template);
425        CBlock block{block_template->getBlock()};
426
427        auto txs = CreateBigSigOpsCluster(txFirst[0]);
428
429        int64_t legacy_sigops = 0;
430        for (auto& t : txs) {
431            // If we don't set the number of sigops in the CTxMemPoolEntry,
432            // template creation fails during sanity checks.
433            TryAddToMempool(tx_mempool, entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(t));
434            legacy_sigops += GetLegacySigOpCount(*t);
435            BOOST_CHECK(tx_mempool.GetIter(t->GetHash()).has_value());
436        }
437        assert(tx_mempool.mapTx.size() == 51);
438        assert(legacy_sigops == 20001);
439        BOOST_CHECK_EXCEPTION(mining->createNewBlock(options, /*cooldown=*/false), std::runtime_error, HasReason("bad-blk-sigops"));
440    }
441
442    {
443        CTxMemPool& tx_mempool{MakeMempool()};
444        LOCK(tx_mempool.cs);
445
446        // Check that the mempool is empty.
447        assert(tx_mempool.mapTx.empty());
448
449        // Just to make sure we can still make simple blocks
450        auto block_template{mining->createNewBlock(options, /*cooldown=*/false)};
451        BOOST_REQUIRE(block_template);
452        CBlock block{block_template->getBlock()};
453
454        auto txs = CreateBigSigOpsCluster(txFirst[0]);
455
456        int64_t legacy_sigops = 0;
457        for (auto& t : txs) {
458            TryAddToMempool(tx_mempool, entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(true).SigOpsCost(GetLegacySigOpCount(*t)*WITNESS_SCALE_FACTOR).FromTx(t));
459            legacy_sigops += GetLegacySigOpCount(*t);
460            BOOST_CHECK(tx_mempool.GetIter(t->GetHash()).has_value());
461        }
462        assert(tx_mempool.mapTx.size() == 51);
463        assert(legacy_sigops == 20001);
464
465        BOOST_REQUIRE(mining->createNewBlock(options, /*cooldown=*/false));
466    }
467
468    {
469        CTxMemPool& tx_mempool{MakeMempool()};
470        LOCK(tx_mempool.cs);
471
472        // block size > limit
473        tx.vin.resize(1);
474        tx.vout.resize(1);
475        tx.vout[0].nValue = BLOCKSUBSIDY;
476        // 36 * (520char + DROP) + OP_1 = 18757 bytes
477        std::vector<unsigned char> vchData(520);
478        for (unsigned int i = 0; i < 18; ++i) {
479            tx.vin[0].scriptSig << vchData << OP_DROP;
480            tx.vout[0].scriptPubKey << vchData << OP_DROP;
481        }
482        tx.vin[0].scriptSig << OP_1;
483        tx.vout[0].scriptPubKey << OP_1;
484        tx.vin[0].prevout.hash = txFirst[0]->GetHash();
485        tx.vin[0].prevout.n = 0;
486        tx.vout[0].nValue = BLOCKSUBSIDY;
487        for (unsigned int i = 0; i < 63; ++i) {
488            tx.vout[0].nValue -= LOWFEE;
489            hash = tx.GetHash();
490            bool spendsCoinbase = i == 0; // only first tx spends coinbase
491            TryAddToMempool(tx_mempool, entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(spendsCoinbase).FromTx(tx));
492            BOOST_CHECK(tx_mempool.GetIter(hash).has_value());
493            tx.vin[0].prevout.hash = hash;
494        }
495        BOOST_REQUIRE(mining->createNewBlock(options, /*cooldown=*/false));
496    }
497
498    {
499        CTxMemPool& tx_mempool{MakeMempool()};
500        LOCK(tx_mempool.cs);