Inside Bitcoin

251        auto it_giant_tx = result_single_large.m_tx_results.find(giant_ptx->GetWitnessHash());
252        BOOST_CHECK_EQUAL(it_giant_tx->second.m_state.GetRejectReason(), "tx-size");
253    }
254
255    // Check that mempool size hasn't changed.
256    BOOST_CHECK_EQUAL(m_node.mempool->size(), initialPoolSize);
257}
258
259BOOST_AUTO_TEST_CASE(noncontextual_package_tests)
260{
261    // The signatures won't be verified so we can just use a placeholder
262    CKey placeholder_key = GenerateRandomKey();
263    CScript spk = GetScriptForDestination(PKHash(placeholder_key.GetPubKey()));
264    CKey placeholder_key_2 = GenerateRandomKey();
265    CScript spk2 = GetScriptForDestination(PKHash(placeholder_key_2.GetPubKey()));
266
267    // Parent and Child Package
268    {
269        auto mtx_parent = CreateValidMempoolTransaction(m_coinbase_txns[0], 0, 0, coinbaseKey, spk,
270                                                        CAmount(49 * COIN), /*submit=*/false);
271        CTransactionRef tx_parent = MakeTransactionRef(mtx_parent);
272
273        auto mtx_child = CreateValidMempoolTransaction(tx_parent, 0, 101, placeholder_key, spk2,
274                                                       CAmount(48 * COIN), /*submit=*/false);
275        CTransactionRef tx_child = MakeTransactionRef(mtx_child);
276
277        PackageValidationState state;
278        BOOST_CHECK(IsWellFormedPackage({tx_parent, tx_child}, state));
279        BOOST_CHECK(!IsWellFormedPackage({tx_child, tx_parent}, state));
280        BOOST_CHECK_EQUAL(state.GetResult(), PackageValidationResult::PCKG_POLICY);
281        BOOST_CHECK_EQUAL(state.GetRejectReason(), "package-not-sorted");
282        BOOST_CHECK(IsChildWithParents({tx_parent, tx_child}));
283        BOOST_CHECK(IsChildWithParentsTree({tx_parent, tx_child}));
284        BOOST_CHECK(GetPackageHash({tx_parent}) != GetPackageHash({tx_child}));
285        BOOST_CHECK(GetPackageHash({tx_child, tx_child}) != GetPackageHash({tx_child}));
286        BOOST_CHECK(GetPackageHash({tx_child, tx_parent}) != GetPackageHash({tx_child, tx_child}));
287        BOOST_CHECK(!IsChildWithParents({}));
288        BOOST_CHECK(!IsChildWithParentsTree({}));
289    }
290
291    // 24 Parents and 1 Child
292    {
293        Package package;
294        CMutableTransaction child;
295        for (int i{0}; i < 24; ++i) {
296            auto parent = MakeTransactionRef(CreateValidMempoolTransaction(m_coinbase_txns[i + 1],
297                                             0, 0, coinbaseKey, spk, CAmount(48 * COIN), false));
298            package.emplace_back(parent);
299            child.vin.emplace_back(COutPoint(parent->GetHash(), 0));
300        }
301        child.vout.emplace_back(47 * COIN, spk2);
302
303        // The child must be in the package.
304        BOOST_CHECK(!IsChildWithParents(package));
305
306        // The parents can be in any order.
307        FastRandomContext rng;
308        std::shuffle(package.begin(), package.end(), rng);
309        package.push_back(MakeTransactionRef(child));
310
311        PackageValidationState state;
312        BOOST_CHECK(IsWellFormedPackage(package, state));
313        BOOST_CHECK(IsChildWithParents(package));
314        BOOST_CHECK(IsChildWithParentsTree(package));
315
316        package.erase(package.begin());
317        BOOST_CHECK(IsChildWithParents(package));
318
319        // The package cannot have unrelated transactions.
320        package.insert(package.begin(), m_coinbase_txns[0]);
321        BOOST_CHECK(!IsChildWithParents(package));
322    }
323
324    // 2 Parents and 1 Child where one parent depends on the other.
325    {
326        CMutableTransaction mtx_parent;
327        mtx_parent.vin.emplace_back(COutPoint(m_coinbase_txns[0]->GetHash(), 0));
328        mtx_parent.vout.emplace_back(20 * COIN, spk);
329        mtx_parent.vout.emplace_back(20 * COIN, spk2);
330        CTransactionRef tx_parent = MakeTransactionRef(mtx_parent);
331
332        CMutableTransaction mtx_parent_also_child;
333        mtx_parent_also_child.vin.emplace_back(COutPoint(tx_parent->GetHash(), 0));
334        mtx_parent_also_child.vout.emplace_back(20 * COIN, spk);
335        CTransactionRef tx_parent_also_child = MakeTransactionRef(mtx_parent_also_child);
336
337        CMutableTransaction mtx_child;
338        mtx_child.vin.emplace_back(COutPoint(tx_parent->GetHash(), 1));
339        mtx_child.vin.emplace_back(COutPoint(tx_parent_also_child->GetHash(), 0));
340        mtx_child.vout.emplace_back(39 * COIN, spk);
341        CTransactionRef tx_child = MakeTransactionRef(mtx_child);
342
343        PackageValidationState state;
344        BOOST_CHECK(IsChildWithParents({tx_parent, tx_parent_also_child}));
345        BOOST_CHECK(IsChildWithParents({tx_parent, tx_child}));
346        BOOST_CHECK(IsChildWithParents({tx_parent, tx_parent_also_child, tx_child}));
347        BOOST_CHECK(!IsChildWithParentsTree({tx_parent, tx_parent_also_child, tx_child}));
348        // IsChildWithParents does not detect unsorted parents.
349        BOOST_CHECK(IsChildWithParents({tx_parent_also_child, tx_parent, tx_child}));
350        BOOST_CHECK(IsWellFormedPackage({tx_parent, tx_parent_also_child, tx_child}, state));
351        BOOST_CHECK(!IsWellFormedPackage({tx_parent_also_child, tx_parent, tx_child}, state));
352        BOOST_CHECK_EQUAL(state.GetResult(), PackageValidationResult::PCKG_POLICY);
353        BOOST_CHECK_EQUAL(state.GetRejectReason(), "package-not-sorted");
354    }
355}
356
357BOOST_AUTO_TEST_CASE(package_submission_tests)
358{
359    // Mine blocks to mature coinbases.
360    mineBlocks(3);
361    MockMempoolMinFee(CFeeRate(5000), *m_node.mempool);
362    LOCK(cs_main);
363    unsigned int expected_pool_size = m_node.mempool->size();
364    CKey parent_key = GenerateRandomKey();
365    CScript parent_locking_script = GetScriptForDestination(PKHash(parent_key.GetPubKey()));
366
367    // Unrelated transactions are not allowed in package submission.
368    Package package_unrelated;
369    for (size_t i{0}; i < 10; ++i) {
370        auto mtx = CreateValidMempoolTransaction(/*input_transaction=*/m_coinbase_txns[i + 25], /*input_vout=*/0,
371                                                 /*input_height=*/0, /*input_signing_key=*/coinbaseKey,
372                                                 /*output_destination=*/parent_locking_script,
373                                                 /*output_amount=*/CAmount(49 * COIN), /*submit=*/false);
374        package_unrelated.emplace_back(MakeTransactionRef(mtx));
375    }
376    auto result_unrelated_submit = ProcessNewPackage(m_node.chainman->ActiveChainstate(), *m_node.mempool,
377                                                     package_unrelated, /*test_accept=*/false, /*client_maxfeerate=*/{});
378    // We don't expect m_tx_results for each transaction when basic sanity checks haven't passed.
379    BOOST_CHECK(result_unrelated_submit.m_state.IsInvalid());
380    BOOST_CHECK_EQUAL(result_unrelated_submit.m_state.GetResult(), PackageValidationResult::PCKG_POLICY);
381    BOOST_CHECK_EQUAL(result_unrelated_submit.m_state.GetRejectReason(), "package-not-child-with-parents");
382    BOOST_CHECK_EQUAL(m_node.mempool->size(), expected_pool_size);
383
384    // Parent and Child (and Grandchild) Package
385    Package package_parent_child;
386    Package package_3gen;
387    auto mtx_parent = CreateValidMempoolTransaction(/*input_transaction=*/m_coinbase_txns[0], /*input_vout=*/0,
388                                                    /*input_height=*/0, /*input_signing_key=*/coinbaseKey,
389                                                    /*output_destination=*/parent_locking_script,
390                                                    /*output_amount=*/CAmount(49 * COIN), /*submit=*/false);
391    CTransactionRef tx_parent = MakeTransactionRef(mtx_parent);
392    package_parent_child.push_back(tx_parent);
393    package_3gen.push_back(tx_parent);
394
395    CKey child_key = GenerateRandomKey();
396    CScript child_locking_script = GetScriptForDestination(PKHash(child_key.GetPubKey()));
397    auto mtx_child = CreateValidMempoolTransaction(/*input_transaction=*/tx_parent, /*input_vout=*/0,
398                                                   /*input_height=*/101, /*input_signing_key=*/parent_key,
399                                                   /*output_destination=*/child_locking_script,
400                                                   /*output_amount=*/CAmount(48 * COIN), /*submit=*/false);
401    CTransactionRef tx_child = MakeTransactionRef(mtx_child);
402    package_parent_child.push_back(tx_child);
403    package_3gen.push_back(tx_child);
404
405    CKey grandchild_key = GenerateRandomKey();
406    CScript grandchild_locking_script = GetScriptForDestination(PKHash(grandchild_key.GetPubKey()));
407    auto mtx_grandchild = CreateValidMempoolTransaction(/*input_transaction=*/tx_child, /*input_vout=*/0,
408                                                       /*input_height=*/101, /*input_signing_key=*/child_key,
409                                                       /*output_destination=*/grandchild_locking_script,
410                                                       /*output_amount=*/CAmount(47 * COIN), /*submit=*/false);
411    CTransactionRef tx_grandchild = MakeTransactionRef(mtx_grandchild);
412    package_3gen.push_back(tx_grandchild);
413
414    // 3 Generations is not allowed.
415    {
416        auto result_3gen_submit = ProcessNewPackage(m_node.chainman->ActiveChainstate(), *m_node.mempool,
417                                                    package_3gen, /*test_accept=*/false, /*client_maxfeerate=*/{});
418        BOOST_CHECK(result_3gen_submit.m_state.IsInvalid());
419        BOOST_CHECK_EQUAL(result_3gen_submit.m_state.GetResult(), PackageValidationResult::PCKG_POLICY);
420        BOOST_CHECK_EQUAL(result_3gen_submit.m_state.GetRejectReason(), "package-not-child-with-parents");
421        BOOST_CHECK_EQUAL(m_node.mempool->size(), expected_pool_size);
422    }
423
424    // Parent and child package where transactions are invalid for reasons other than fee and
425    // missing inputs, so the package validation isn't expected to happen.
426    {
427        CScriptWitness bad_witness;
428        bad_witness.stack.emplace_back(1);
429        CMutableTransaction mtx_parent_invalid{mtx_parent};
430        mtx_parent_invalid.vin[0].scriptWitness = bad_witness;
431        CTransactionRef tx_parent_invalid = MakeTransactionRef(mtx_parent_invalid);
432        Package package_invalid_parent{tx_parent_invalid, tx_child};
433        auto result_quit_early = ProcessNewPackage(m_node.chainman->ActiveChainstate(), *m_node.mempool,
434                                                   package_invalid_parent, /*test_accept=*/ false, /*client_maxfeerate=*/{});
435        if (auto err_parent_invalid{CheckPackageMempoolAcceptResult(package_invalid_parent, result_quit_early, /*expect_valid=*/false, m_node.mempool.get())}) {
436            BOOST_ERROR(err_parent_invalid.value());
437        } else {
438            auto it_parent = result_quit_early.m_tx_results.find(tx_parent_invalid->GetWitnessHash());
439            auto it_child = result_quit_early.m_tx_results.find(tx_child->GetWitnessHash());
440            BOOST_CHECK_EQUAL(it_parent->second.m_state.GetResult(), TxValidationResult::TX_WITNESS_MUTATED);
441            BOOST_CHECK_EQUAL(it_parent->second.m_state.GetRejectReason(), "bad-witness-nonstandard");
442            BOOST_CHECK_EQUAL(it_child->second.m_state.GetResult(), TxValidationResult::TX_MISSING_INPUTS);
443            BOOST_CHECK_EQUAL(it_child->second.m_state.GetRejectReason(), "bad-txns-inputs-missingorspent");
444        }
445        BOOST_CHECK_EQUAL(result_quit_early.m_state.GetResult(), PackageValidationResult::PCKG_TX);
446    }
447
448    // Submit package with parent + child.
449    {
450        const auto submit_parent_child = ProcessNewPackage(m_node.chainman->ActiveChainstate(), *m_node.mempool,
451                                                           package_parent_child, /*test_accept=*/false, /*client_maxfeerate=*/{});
452        expected_pool_size += 2;
453        BOOST_CHECK_MESSAGE(submit_parent_child.m_state.IsValid(),
454                            "Package validation unexpectedly failed: " << submit_parent_child.m_state.GetRejectReason());
455        BOOST_CHECK_EQUAL(submit_parent_child.m_tx_results.size(), package_parent_child.size());
456        auto it_parent = submit_parent_child.m_tx_results.find(tx_parent->GetWitnessHash());
457        auto it_child = submit_parent_child.m_tx_results.find(tx_child->GetWitnessHash());
458        BOOST_CHECK(it_parent != submit_parent_child.m_tx_results.end());
459        BOOST_CHECK(it_parent->second.m_state.IsValid());
460        BOOST_CHECK(it_parent->second.m_effective_feerate == CFeeRate(1 * COIN, GetVirtualTransactionSize(*tx_parent)));
461        BOOST_CHECK_EQUAL(it_parent->second.m_wtxids_fee_calculations.value().size(), 1);
462        BOOST_CHECK_EQUAL(it_parent->second.m_wtxids_fee_calculations.value().front(), tx_parent->GetWitnessHash());
463        BOOST_CHECK(it_child->second.m_effective_feerate == CFeeRate(1 * COIN, GetVirtualTransactionSize(*tx_child)));
464        BOOST_CHECK_EQUAL(it_child->second.m_wtxids_fee_calculations.value().size(), 1);
465        BOOST_CHECK_EQUAL(it_child->second.m_wtxids_fee_calculations.value().front(), tx_child->GetWitnessHash());
466
467        BOOST_CHECK_EQUAL(m_node.mempool->size(), expected_pool_size);
468    }
469
470    // Already-in-mempool transactions should be detected and de-duplicated.
471    {
472        const auto submit_deduped = ProcessNewPackage(m_node.chainman->ActiveChainstate(), *m_node.mempool,
473                                                      package_parent_child, /*test_accept=*/false, /*client_maxfeerate=*/{});
474        if (auto err_deduped{CheckPackageMempoolAcceptResult(package_parent_child, submit_deduped, /*expect_valid=*/true, m_node.mempool.get())}) {
475            BOOST_ERROR(err_deduped.value());
476        } else {
477            auto it_parent_deduped = submit_deduped.m_tx_results.find(tx_parent->GetWitnessHash());
478            auto it_child_deduped = submit_deduped.m_tx_results.find(tx_child->GetWitnessHash());
479            BOOST_CHECK(it_parent_deduped->second.m_result_type == MempoolAcceptResult::ResultType::MEMPOOL_ENTRY);
480            BOOST_CHECK(it_child_deduped->second.m_result_type == MempoolAcceptResult::ResultType::MEMPOOL_ENTRY);
481        }
482
483        BOOST_CHECK_EQUAL(m_node.mempool->size(), expected_pool_size);
484    }
485
486    // In-mempool parent and child with missing parent.
487    {
488        auto tx_parent_1 = MakeTransactionRef(CreateValidMempoolTransaction(/*input_transaction=*/m_coinbase_txns[1], /*input_vout=*/0,
489                                                                            /*input_height=*/0, /*input_signing_key=*/coinbaseKey,
490                                                                            /*output_destination=*/parent_locking_script,
491                                                                            /*output_amount=*/CAmount(50 * COIN - low_fee_amt), /*submit=*/false));
492        auto tx_parent_2 = MakeTransactionRef(CreateValidMempoolTransaction(/*input_transaction=*/m_coinbase_txns[2], /*input_vout=*/0,
493                                                                            /*input_height=*/0, /*input_signing_key=*/coinbaseKey,
494                                                                            /*output_destination=*/parent_locking_script,
495                                                                            /*output_amount=*/CAmount(50 * COIN - 800), /*submit=*/false));
496
497        auto tx_child_missing_parent = MakeTransactionRef(CreateValidMempoolTransaction({tx_parent_1, tx_parent_2},
498                                                                                        {{tx_parent_1->GetHash(), 0}, {tx_parent_2->GetHash(), 0}},
499                                                                                        /*input_height=*/0, {parent_key},
500                                                                                        {{49 * COIN, child_locking_script}}, /*submit=*/false));