Inside Bitcoin

501        # Create a replacement of child_1. It does not conflict with child_2.
502        child_1_conflict = self.wallet.send_self_transfer(from_node=node, version=3, utxo_to_spend=ancestor_tx["new_utxos"][0], fee_rate=Decimal("0.01"))
503
504        # Ensure child_1 and child_1_conflict are different transactions
505        assert_not_equal(child_1_conflict["txid"], child_1["txid"])
506        self.check_mempool([ancestor_tx["txid"], child_1_conflict["txid"], child_2["txid"]])
507        assert_equal(node.getmempoolentry(ancestor_tx["txid"])["descendantcount"], 3)
508
509    @cleanup(extra_args=None)
510    def test_truc_sibling_eviction(self):
511        self.log.info("Test sibling eviction for TRUC")
512        node = self.nodes[0]
513        tx_v3_parent = self.wallet.send_self_transfer_multi(from_node=node, num_outputs=2, version=3)
514        # This is the sibling to replace
515        tx_v3_child_1 = self.wallet.send_self_transfer(
516            from_node=node, utxo_to_spend=tx_v3_parent["new_utxos"][0], fee_rate=DEFAULT_FEE * 2, version=3
517        )
518        assert tx_v3_child_1["txid"] in node.getrawmempool()
519
520        self.log.info("Test tx must be higher feerate than sibling to evict it")
521        tx_v3_child_2_rule6 = self.wallet.create_self_transfer(
522            utxo_to_spend=tx_v3_parent["new_utxos"][1], fee_rate=DEFAULT_FEE, version=3
523        )
524        rule6_str = f"insufficient fee (including sibling eviction), rejecting replacement {tx_v3_child_2_rule6['txid']}"
525        assert_raises_rpc_error(-26, rule6_str, node.sendrawtransaction, tx_v3_child_2_rule6["hex"])
526        self.check_mempool([tx_v3_parent['txid'], tx_v3_child_1['txid']])
527
528        self.log.info("Test tx must meet absolute fee rules to evict sibling")
529        tx_v3_child_2_rule4 = self.wallet.create_self_transfer(
530            utxo_to_spend=tx_v3_parent["new_utxos"][1], fee_rate=2 * DEFAULT_FEE + Decimal("0.00000001"), version=3
531        )
532        rule4_str = f"insufficient fee (including sibling eviction), rejecting replacement {tx_v3_child_2_rule4['txid']}, not enough additional fees to relay"
533        assert_raises_rpc_error(-26, rule4_str, node.sendrawtransaction, tx_v3_child_2_rule4["hex"])
534        self.check_mempool([tx_v3_parent['txid'], tx_v3_child_1['txid']])
535
536        self.log.info("Test tx cannot cause more than 100 evictions including RBF and sibling eviction")
537        # First add 4 groups of 25 transactions.
538        utxos_for_conflict = []
539        txids_v2_100 = []
540        for _ in range(4):
541            confirmed_utxo = self.wallet.get_utxo(confirmed_only=True)
542            utxos_for_conflict.append(confirmed_utxo)
543            # 25 is within descendant limits
544            chain_length = int(MAX_REPLACEMENT_CANDIDATES / 4)
545            chain = self.wallet.create_self_transfer_chain(chain_length=chain_length, utxo_to_spend=confirmed_utxo)
546            for item in chain:
547                txids_v2_100.append(item["txid"])
548                node.sendrawtransaction(item["hex"])
549        self.check_mempool(txids_v2_100 + [tx_v3_parent["txid"], tx_v3_child_1["txid"]])
550
551        # Replacing 100 transactions is fine
552        tx_v3_replacement_only = self.wallet.create_self_transfer_multi(utxos_to_spend=utxos_for_conflict, fee_per_output=4000000)
553        # Override maxfeerate - it costs a lot to replace these 100 transactions.
554        assert node.testmempoolaccept([tx_v3_replacement_only["hex"]], maxfeerate=0)[0]["allowed"]
555        self.check_mempool(txids_v2_100 + [tx_v3_parent["txid"], tx_v3_child_1["txid"]])
556
557        self.log.info("Test sibling eviction is successful if it meets all RBF rules")
558        tx_v3_child_2 = self.wallet.create_self_transfer(
559            utxo_to_spend=tx_v3_parent["new_utxos"][1], fee_rate=DEFAULT_FEE*10, version=3
560        )
561        node.sendrawtransaction(tx_v3_child_2["hex"])
562        self.check_mempool(txids_v2_100 + [tx_v3_parent["txid"], tx_v3_child_2["txid"]])
563
564        self.log.info("Test that it's possible to do a sibling eviction and RBF at the same time")
565        utxo_unrelated_conflict = self.wallet.get_utxo(confirmed_only=True)
566        tx_unrelated_replacee = self.wallet.send_self_transfer(from_node=node, utxo_to_spend=utxo_unrelated_conflict)
567        assert tx_unrelated_replacee["txid"] in node.getrawmempool()
568
569        fee_to_beat = max(int(tx_v3_child_2["fee"] * COIN), int(tx_unrelated_replacee["fee"]*COIN))
570
571        tx_v3_child_3 = self.wallet.create_self_transfer_multi(
572            utxos_to_spend=[tx_v3_parent["new_utxos"][0], utxo_unrelated_conflict], fee_per_output=fee_to_beat*4, version=3
573        )
574        node.sendrawtransaction(tx_v3_child_3["hex"])
575        self.check_mempool(txids_v2_100 + [tx_v3_parent["txid"], tx_v3_child_3["txid"]])
576
577    @cleanup(extra_args=None)
578    def test_reorg_sibling_eviction_1p2c(self):
579        node = self.nodes[0]
580        self.log.info("Test that sibling eviction is not allowed when multiple siblings exist")
581
582        # Prep for fork
583        fork_blocks = create_empty_fork(node)
584        tx_with_multi_children = self.wallet.send_self_transfer_multi(from_node=node, num_outputs=3, version=3, confirmed_only=True)
585        self.check_mempool([tx_with_multi_children["txid"]])
586
587        self.generate(node, 1)
588        self.check_mempool([])
589
590        tx_with_sibling1 = self.wallet.send_self_transfer(from_node=node, version=3, utxo_to_spend=tx_with_multi_children["new_utxos"][0])
591        tx_with_sibling2 = self.wallet.send_self_transfer(from_node=node, version=3, utxo_to_spend=tx_with_multi_children["new_utxos"][1])
592        self.check_mempool([tx_with_sibling1["txid"], tx_with_sibling2["txid"]])
593
594        # Create a reorg, bringing tx_with_multi_children back into the mempool with a descendant count of 3.
595        self.trigger_reorg(fork_blocks)
596        self.check_mempool([tx_with_multi_children["txid"], tx_with_sibling1["txid"], tx_with_sibling2["txid"]])
597        assert_equal(node.getmempoolentry(tx_with_multi_children["txid"])["descendantcount"], 3)
598
599        # Sibling eviction is not allowed because there are two siblings
600        tx_with_sibling3 = self.wallet.create_self_transfer(
601            version=3,
602            utxo_to_spend=tx_with_multi_children["new_utxos"][2],
603            fee_rate=DEFAULT_FEE*50
604        )
605        expected_error_2siblings = f"TRUC-violation, tx {tx_with_multi_children['txid']} (wtxid={tx_with_multi_children['wtxid']}) would exceed descendant count limit"
606        assert_raises_rpc_error(-26, expected_error_2siblings, node.sendrawtransaction, tx_with_sibling3["hex"])
607
608        # However, an RBF (with conflicting inputs) is possible even if the resulting cluster size exceeds 2
609        tx_with_sibling3_rbf = self.wallet.send_self_transfer(
610            from_node=node,
611            version=3,
612            utxo_to_spend=tx_with_multi_children["new_utxos"][0],
613            fee_rate=DEFAULT_FEE*50
614        )
615        self.check_mempool([tx_with_multi_children["txid"], tx_with_sibling3_rbf["txid"], tx_with_sibling2["txid"]])
616
617    @cleanup(extra_args=None)
618    def test_minrelay_in_package_combos(self):
619        node = self.nodes[0]
620        self.log.info("Test that all transaction versions can be under minrelaytxfee for various settings...")
621
622        for minrelay_setting in (0, 5, 10, 100, 500, 1000, 5000, 333333, 2500000):
623            self.log.info(f"-> Test -minrelaytxfee={minrelay_setting}sat/kvB...")
624            setting_decimal = minrelay_setting / Decimal(COIN)
625            self.restart_node(0, extra_args=[f"-minrelaytxfee={setting_decimal:.8f}", "-persistmempool=0"])
626            minrelayfeerate = node.getmempoolinfo()["minrelaytxfee"]
627            high_feerate = minrelayfeerate * 50
628
629            tx_v3_0fee_parent = self.wallet.create_self_transfer(fee=0, fee_rate=0, confirmed_only=True, version=3)
630            tx_v3_child = self.wallet.create_self_transfer(utxo_to_spend=tx_v3_0fee_parent["new_utxo"], fee_rate=high_feerate, version=3)
631            total_v3_fee = tx_v3_child["fee"] + tx_v3_0fee_parent["fee"]
632            total_v3_size = tx_v3_child["tx"].get_vsize() + tx_v3_0fee_parent["tx"].get_vsize()
633            assert_greater_than_or_equal(total_v3_fee, get_fee(total_v3_size, minrelayfeerate))
634            if minrelayfeerate > 0:
635                assert_greater_than(get_fee(tx_v3_0fee_parent["tx"].get_vsize(), minrelayfeerate), 0)
636                # Always need to pay at least 1 satoshi for entry, even if minimum feerate is very low
637                assert_greater_than(total_v3_fee, 0)
638                # Also create a version where the child is at minrelaytxfee
639                tx_v3_child_minrelay = self.wallet.create_self_transfer(utxo_to_spend=tx_v3_0fee_parent["new_utxo"], fee_rate=minrelayfeerate, version=3)
640                result_truc_minrelay = node.submitpackage([tx_v3_0fee_parent["hex"], tx_v3_child_minrelay["hex"]])
641                assert_equal(result_truc_minrelay["package_msg"], "transaction failed")
642
643            tx_v2_0fee_parent = self.wallet.create_self_transfer(fee=0, fee_rate=0, confirmed_only=True, version=2)
644            tx_v2_child = self.wallet.create_self_transfer(utxo_to_spend=tx_v2_0fee_parent["new_utxo"], fee_rate=high_feerate, version=2)
645            total_v2_fee = tx_v2_child["fee"] + tx_v2_0fee_parent["fee"]
646            total_v2_size = tx_v2_child["tx"].get_vsize() + tx_v2_0fee_parent["tx"].get_vsize()
647            assert_greater_than_or_equal(total_v2_fee, get_fee(total_v2_size, minrelayfeerate))
648            if minrelayfeerate > 0:
649                assert_greater_than(get_fee(tx_v2_0fee_parent["tx"].get_vsize(), minrelayfeerate), 0)
650                # Always need to pay at least 1 satoshi for entry, even if minimum feerate is very low
651                assert_greater_than(total_v2_fee, 0)
652
653            result_truc = node.submitpackage([tx_v3_0fee_parent["hex"], tx_v3_child["hex"]], maxfeerate=0)
654            assert_equal(result_truc["package_msg"], "success")
655
656            result_non_truc = node.submitpackage([tx_v2_0fee_parent["hex"], tx_v2_child["hex"]], maxfeerate=0)
657            assert_equal(result_non_truc["package_msg"], "success")
658            self.check_mempool([tx_v2_0fee_parent["txid"], tx_v2_child["txid"], tx_v3_0fee_parent["txid"], tx_v3_child["txid"]])
659
660
661    def run_test(self):
662        self.log.info("Generate blocks to create UTXOs")
663        node = self.nodes[0]
664        self.wallet = MiniWallet(node)
665        self.generate(self.wallet, 200)
666        self.test_truc_max_vsize()
667        self.test_truc_acceptance()
668        self.test_truc_replacement()
669        self.test_truc_reorg()
670        self.test_nondefault_package_limits()
671        self.test_truc_ancestors_package()
672        self.test_truc_ancestors_package_and_mempool()
673        self.test_sibling_eviction_package()
674        self.test_truc_package_inheritance()
675        self.test_truc_in_testmempoolaccept()
676        self.test_reorg_2child_rbf()
677        self.test_truc_sibling_eviction()
678        self.test_reorg_sibling_eviction_1p2c()
679        self.test_minrelay_in_package_combos()
680
681
682if __name__ == "__main__":
683    MempoolTRUC(__file__).main()
684