Inside Bitcoin

251        self.restart_node(0, extra_args=["-limitclustercount=1", "-acceptnonstdtxn=1"])
252        assert_raises_rpc_error(-26, "too-large-cluster", node.sendrawtransaction, tx_v3_child_large2["hex"])
253        self.check_mempool([tx_v3_parent_large2["txid"]])
254
255    @cleanup()
256    def test_truc_ancestors_package(self):
257        self.log.info("Test that TRUC ancestor limits are checked within the package")
258        node = self.nodes[0]
259        tx_v3_parent_normal = self.wallet.create_self_transfer(
260            fee_rate=0,
261            target_vsize=1001,
262            version=3
263        )
264        tx_v3_parent_2_normal = self.wallet.create_self_transfer(
265            fee_rate=0,
266            target_vsize=1001,
267            version=3
268        )
269        tx_v3_child_multiparent = self.wallet.create_self_transfer_multi(
270            utxos_to_spend=[tx_v3_parent_normal["new_utxo"], tx_v3_parent_2_normal["new_utxo"]],
271            fee_per_output=10000,
272            version=3
273        )
274        tx_v3_child_heavy = self.wallet.create_self_transfer_multi(
275            utxos_to_spend=[tx_v3_parent_normal["new_utxo"]],
276            target_vsize=TRUC_CHILD_MAX_VSIZE + 1,
277            fee_per_output=10000,
278            version=3
279        )
280
281        self.check_mempool([])
282        result = node.submitpackage([tx_v3_parent_normal["hex"], tx_v3_parent_2_normal["hex"], tx_v3_child_multiparent["hex"]])
283        assert_equal(result['package_msg'], f"TRUC-violation, tx {tx_v3_child_multiparent['txid']} (wtxid={tx_v3_child_multiparent['wtxid']}) would have too many ancestors")
284        self.check_mempool([])
285
286        self.check_mempool([])
287        result = node.submitpackage([tx_v3_parent_normal["hex"], tx_v3_child_heavy["hex"]])
288        # tx_v3_child_heavy is heavy based on vsize, not sigops.
289        assert_equal(result['package_msg'], f"TRUC-violation, version=3 child tx {tx_v3_child_heavy['txid']} (wtxid={tx_v3_child_heavy['wtxid']}) is too big: {tx_v3_child_heavy['tx'].get_vsize()} > 1000 virtual bytes")
290        self.check_mempool([])
291
292        tx_v3_parent = self.wallet.create_self_transfer(version=3)
293        tx_v3_child = self.wallet.create_self_transfer(utxo_to_spend=tx_v3_parent["new_utxo"], version=3)
294        tx_v3_grandchild = self.wallet.create_self_transfer(utxo_to_spend=tx_v3_child["new_utxo"], version=3)
295        result = node.testmempoolaccept([tx_v3_parent["hex"], tx_v3_child["hex"], tx_v3_grandchild["hex"]])
296        for txresult in result:
297            assert_equal(txresult["package-error"], f"TRUC-violation, tx {tx_v3_grandchild['txid']} (wtxid={tx_v3_grandchild['wtxid']}) would have too many ancestors")
298
299    @cleanup(extra_args=None)
300    def test_truc_ancestors_package_and_mempool(self):
301        """
302        A TRUC transaction in a package cannot have 2 TRUC parents.
303        Test that if we have a transaction graph A -> B -> C, where A, B, C are
304        all TRUC transactions, that we cannot use submitpackage to get the
305        transactions all into the mempool.
306
307        Verify, in particular, that if A is already in the mempool, then
308        submitpackage(B, C) will fail.
309        """
310        node = self.nodes[0]
311        self.log.info("Test that TRUC ancestor limits include transactions within the package and all in-mempool ancestors")
312        # This is our transaction "A":
313        tx_in_mempool = self.wallet.send_self_transfer(from_node=node, version=3)
314
315        # Verify that A is in the mempool
316        self.check_mempool([tx_in_mempool["txid"]])
317
318        # tx_0fee_parent is our transaction "B"; just create it.
319        tx_0fee_parent = self.wallet.create_self_transfer(utxo_to_spend=tx_in_mempool["new_utxo"], fee=0, fee_rate=0, version=3)
320
321        # tx_child_violator is our transaction "C"; create it:
322        tx_child_violator = self.wallet.create_self_transfer_multi(utxos_to_spend=[tx_0fee_parent["new_utxo"]], version=3)
323
324        # submitpackage(B, C) should fail
325        result = node.submitpackage([tx_0fee_parent["hex"], tx_child_violator["hex"]])
326        assert_equal(result['package_msg'], f"TRUC-violation, tx {tx_child_violator['txid']} (wtxid={tx_child_violator['wtxid']}) would have too many ancestors")
327        self.check_mempool([tx_in_mempool["txid"]])
328
329    @cleanup(extra_args=None)
330    def test_sibling_eviction_package(self):
331        """
332        When a transaction has a mempool sibling, it may be eligible for sibling eviction.
333        However, this option is only available in single transaction acceptance. It doesn't work in
334        a multi-testmempoolaccept (where RBF is disabled) or when doing package CPFP.
335        """
336        self.log.info("Test TRUC sibling eviction in submitpackage and multi-testmempoolaccept")
337        node = self.nodes[0]
338        # Add a parent + child to mempool
339        tx_mempool_parent = self.wallet.send_self_transfer_multi(
340            from_node=node,
341            utxos_to_spend=[self.wallet.get_utxo()],
342            num_outputs=2,
343            version=3
344        )
345        tx_mempool_sibling = self.wallet.send_self_transfer(
346            from_node=node,
347            utxo_to_spend=tx_mempool_parent["new_utxos"][0],
348            version=3
349        )
350        self.check_mempool([tx_mempool_parent["txid"], tx_mempool_sibling["txid"]])
351
352        tx_sibling_1 = self.wallet.create_self_transfer(
353            utxo_to_spend=tx_mempool_parent["new_utxos"][1],
354            version=3,
355            fee_rate=DEFAULT_FEE*100,
356        )
357        tx_has_mempool_uncle = self.wallet.create_self_transfer(utxo_to_spend=tx_sibling_1["new_utxo"], version=3)
358
359        tx_sibling_2 = self.wallet.create_self_transfer(
360            utxo_to_spend=tx_mempool_parent["new_utxos"][0],
361            version=3,
362            fee_rate=DEFAULT_FEE*200,
363        )
364
365        tx_sibling_3 = self.wallet.create_self_transfer(
366            utxo_to_spend=tx_mempool_parent["new_utxos"][1],
367            version=3,
368            fee_rate=0,
369        )
370        tx_bumps_parent_with_sibling = self.wallet.create_self_transfer(
371            utxo_to_spend=tx_sibling_3["new_utxo"],
372            version=3,
373            fee_rate=DEFAULT_FEE*300,
374        )
375
376        # Fails with another non-related transaction via testmempoolaccept
377        tx_unrelated = self.wallet.create_self_transfer(version=3)
378        result_test_unrelated = node.testmempoolaccept([tx_sibling_1["hex"], tx_unrelated["hex"]])
379        assert_equal(result_test_unrelated[0]["reject-reason"], "TRUC-violation")
380
381        # Fails in a package via testmempoolaccept
382        result_test_1p1c = node.testmempoolaccept([tx_sibling_1["hex"], tx_has_mempool_uncle["hex"]])
383        assert_equal(result_test_1p1c[0]["reject-reason"], "TRUC-violation")
384
385        # Allowed when tx is submitted in a package and evaluated individually.
386        # Note that the child failed since it would be the 3rd generation.
387        result_package_indiv = node.submitpackage([tx_sibling_1["hex"], tx_has_mempool_uncle["hex"]])
388        self.check_mempool([tx_mempool_parent["txid"], tx_sibling_1["txid"]])
389        expected_error_gen3 = f"TRUC-violation, tx {tx_has_mempool_uncle['txid']} (wtxid={tx_has_mempool_uncle['wtxid']}) would have too many ancestors"
390
391        assert_equal(result_package_indiv["tx-results"][tx_has_mempool_uncle['wtxid']]['error'], expected_error_gen3)
392
393        # Allowed when tx is submitted in a package with in-mempool parent (which is deduplicated).
394        node.submitpackage([tx_mempool_parent["hex"], tx_sibling_2["hex"]])
395        self.check_mempool([tx_mempool_parent["txid"], tx_sibling_2["txid"]])
396
397        # Child cannot pay for sibling eviction for parent, as it violates TRUC topology limits
398        result_package_cpfp = node.submitpackage([tx_sibling_3["hex"], tx_bumps_parent_with_sibling["hex"]])
399        self.check_mempool([tx_mempool_parent["txid"], tx_sibling_2["txid"]])
400        expected_error_cpfp = f"TRUC-violation, tx {tx_mempool_parent['txid']} (wtxid={tx_mempool_parent['wtxid']}) would exceed descendant count limit"
401
402        assert_equal(result_package_cpfp["tx-results"][tx_sibling_3['wtxid']]['error'], expected_error_cpfp)
403
404
405    @cleanup()
406    def test_truc_package_inheritance(self):
407        self.log.info("Test that TRUC inheritance is checked within package")
408        node = self.nodes[0]
409        tx_v3_parent = self.wallet.create_self_transfer(
410            fee_rate=0,
411            target_vsize=1001,
412            version=3
413        )
414        tx_v2_child = self.wallet.create_self_transfer_multi(
415            utxos_to_spend=[tx_v3_parent["new_utxo"]],
416            fee_per_output=10000,
417            version=2
418        )
419        self.check_mempool([])
420        result = node.submitpackage([tx_v3_parent["hex"], tx_v2_child["hex"]])
421        assert_equal(result['package_msg'], f"TRUC-violation, non-version=3 tx {tx_v2_child['txid']} (wtxid={tx_v2_child['wtxid']}) cannot spend from version=3 tx {tx_v3_parent['txid']} (wtxid={tx_v3_parent['wtxid']})")
422        self.check_mempool([])
423
424    @cleanup(extra_args=None)
425    def test_truc_in_testmempoolaccept(self):
426        node = self.nodes[0]
427
428        self.log.info("Test that TRUC inheritance is accurately assessed in testmempoolaccept")
429        tx_v2 = self.wallet.create_self_transfer(version=2)
430        tx_v2_from_v2 = self.wallet.create_self_transfer(utxo_to_spend=tx_v2["new_utxo"], version=2)
431        tx_v3_from_v2 = self.wallet.create_self_transfer(utxo_to_spend=tx_v2["new_utxo"], version=3)
432        tx_v3 = self.wallet.create_self_transfer(version=3)
433        tx_v2_from_v3 = self.wallet.create_self_transfer(utxo_to_spend=tx_v3["new_utxo"], version=2)
434        tx_v3_from_v3 = self.wallet.create_self_transfer(utxo_to_spend=tx_v3["new_utxo"], version=3)
435
436        # testmempoolaccept paths don't require child-with-parents topology. Ensure that topology
437        # assumptions aren't made in inheritance checks.
438        test_accept_v2_and_v3 = node.testmempoolaccept([tx_v2["hex"], tx_v3["hex"]])
439        assert all([result["allowed"] for result in test_accept_v2_and_v3])
440
441        test_accept_v3_from_v2 = node.testmempoolaccept([tx_v2["hex"], tx_v3_from_v2["hex"]])
442        expected_error_v3_from_v2 = f"TRUC-violation, version=3 tx {tx_v3_from_v2['txid']} (wtxid={tx_v3_from_v2['wtxid']}) cannot spend from non-version=3 tx {tx_v2['txid']} (wtxid={tx_v2['wtxid']})"
443        for result in test_accept_v3_from_v2:
444            assert_equal(result["package-error"], expected_error_v3_from_v2)
445
446        test_accept_v2_from_v3 = node.testmempoolaccept([tx_v3["hex"], tx_v2_from_v3["hex"]])
447        expected_error_v2_from_v3 = f"TRUC-violation, non-version=3 tx {tx_v2_from_v3['txid']} (wtxid={tx_v2_from_v3['wtxid']}) cannot spend from version=3 tx {tx_v3['txid']} (wtxid={tx_v3['wtxid']})"
448        for result in test_accept_v2_from_v3:
449            assert_equal(result["package-error"], expected_error_v2_from_v3)
450
451        test_accept_pairs = node.testmempoolaccept([tx_v2["hex"], tx_v3["hex"], tx_v2_from_v2["hex"], tx_v3_from_v3["hex"]])
452        assert all([result["allowed"] for result in test_accept_pairs])
453
454        self.log.info("Test that descendant violations are caught in testmempoolaccept")
455        tx_v3_independent = self.wallet.create_self_transfer(version=3)
456        tx_v3_parent = self.wallet.create_self_transfer_multi(num_outputs=2, version=3)
457        tx_v3_child_1 = self.wallet.create_self_transfer(utxo_to_spend=tx_v3_parent["new_utxos"][0], version=3)
458        tx_v3_child_2 = self.wallet.create_self_transfer(utxo_to_spend=tx_v3_parent["new_utxos"][1], version=3)
459        test_accept_2children = node.testmempoolaccept([tx_v3_parent["hex"], tx_v3_child_1["hex"], tx_v3_child_2["hex"]])
460        expected_error_2children = f"TRUC-violation, tx {tx_v3_parent['txid']} (wtxid={tx_v3_parent['wtxid']}) would exceed descendant count limit"
461        for result in test_accept_2children:
462            assert_equal(result["package-error"], expected_error_2children)
463
464        # Extra TRUC transaction does not get incorrectly marked as extra descendant
465        test_accept_1child_with_exra = node.testmempoolaccept([tx_v3_parent["hex"], tx_v3_child_1["hex"], tx_v3_independent["hex"]])
466        assert all([result["allowed"] for result in test_accept_1child_with_exra])
467
468        # Extra TRUC transaction does not make us ignore the extra descendant
469        test_accept_2children_with_exra = node.testmempoolaccept([tx_v3_parent["hex"], tx_v3_child_1["hex"], tx_v3_child_2["hex"], tx_v3_independent["hex"]])
470        expected_error_extra = f"TRUC-violation, tx {tx_v3_parent['txid']} (wtxid={tx_v3_parent['wtxid']}) would exceed descendant count limit"
471        for result in test_accept_2children_with_exra:
472            assert_equal(result["package-error"], expected_error_extra)
473        # Same result if the parent is already in mempool
474        node.sendrawtransaction(tx_v3_parent["hex"])
475        test_accept_2children_with_in_mempool_parent = node.testmempoolaccept([tx_v3_child_1["hex"], tx_v3_child_2["hex"]])
476        for result in test_accept_2children_with_in_mempool_parent:
477            assert_equal(result["package-error"], expected_error_extra)
478
479    @cleanup(extra_args=None)
480    def test_reorg_2child_rbf(self):
481        node = self.nodes[0]
482        self.log.info("Test that children of a TRUC transaction can be replaced individually, even if there are multiple due to reorg")
483
484        # Prep for fork
485        fork_blocks = create_empty_fork(node)
486        ancestor_tx = self.wallet.send_self_transfer_multi(from_node=node, num_outputs=2, version=3)
487        self.check_mempool([ancestor_tx["txid"]])
488
489        self.generate(node, 1)[0]
490        self.check_mempool([])
491
492        child_1 = self.wallet.send_self_transfer(from_node=node, version=3, utxo_to_spend=ancestor_tx["new_utxos"][0])
493        child_2 = self.wallet.send_self_transfer(from_node=node, version=3, utxo_to_spend=ancestor_tx["new_utxos"][1])
494        self.check_mempool([child_1["txid"], child_2["txid"]])
495
496        # Create a reorg, causing ancestor_tx to exceed the 1-child limit
497        self.trigger_reorg(fork_blocks)
498        self.check_mempool([ancestor_tx["txid"], child_1["txid"], child_2["txid"]])
499        assert_equal(node.getmempoolentry(ancestor_tx["txid"])["descendantcount"], 3)
500