Merge bitcoin/bitcoin#24623: test: Add diamond-shape prioritisetransaction test

fa0758e1457552e9243bc9663408e88a8cccc8f6 test: Add diamond-shape prioritisetransaction test (MarcoFalke)
fa450c18db7326b2924db435a753620895b41c53 test: Rework create_self_transfer_multi (MarcoFalke)

Pull request description:

  Looks like there is no test for diamonds, only for chains (in `mempool_packages.py`)

ACKs for top commit:
  jamesob:
    ACK fa0758e145

Tree-SHA512: d261184a81df77d24fc256f58ad5ed4a13b7cd4e33f74c8b79495c761ff417817602d8e5d4f63f4bb1000ac63f89bbfa54d8d8994a7b2bb2e8a484c467330984

test/functional/mining_prioritisetransaction.py

@@ -4,11 +4,15 @@
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test the prioritisetransaction mining RPC."""
 
+from decimal import Decimal
 import time
 
+from test_framework.blocktools import COINBASE_MATURITY
 from test_framework.messages import COIN, MAX_BLOCK_WEIGHT
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal, assert_raises_rpc_error, create_confirmed_utxos, create_lots_of_big_transactions, gen_return_txouts
+from test_framework.wallet import MiniWallet
+
 
 class PrioritiseTransactionTest(BitcoinTestFramework):
     def set_test_params(self):
@@ -23,7 +27,84 @@ class PrioritiseTransactionTest(BitcoinTestFramework):
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
+    def test_diamond(self):
+        self.log.info("Test diamond-shape package with priority")
+        self.generate(self.wallet, COINBASE_MATURITY + 1)
+        mock_time = int(time.time())
+        self.nodes[0].setmocktime(mock_time)
+
+        #      tx_a
+        #      / \
+        #     /   \
+        #   tx_b  tx_c
+        #     \   /
+        #      \ /
+        #      tx_d
+
+        tx_o_a = self.wallet.send_self_transfer_multi(
+            from_node=self.nodes[0],
+            num_outputs=2,
+        )
+        txid_a = tx_o_a["txid"]
+
+        tx_o_b, tx_o_c = [self.wallet.send_self_transfer(
+            from_node=self.nodes[0],
+            utxo_to_spend=u,
+        ) for u in tx_o_a["new_utxos"]]
+        txid_b = tx_o_b["txid"]
+        txid_c = tx_o_c["txid"]
+
+        tx_o_d = self.wallet.send_self_transfer_multi(
+            from_node=self.nodes[0],
+            utxos_to_spend=[
+                self.wallet.get_utxo(txid=txid_b),
+                self.wallet.get_utxo(txid=txid_c),
+            ],
+        )
+        txid_d = tx_o_d["txid"]
+
+        self.log.info("Test priority while txs are in mempool")
+        raw_before = self.nodes[0].getrawmempool(verbose=True)
+        fee_delta_b = Decimal(9999) / COIN
+        fee_delta_c_1 = Decimal(-1234) / COIN
+        fee_delta_c_2 = Decimal(8888) / COIN
+        self.nodes[0].prioritisetransaction(txid=txid_b, fee_delta=int(fee_delta_b * COIN))
+        self.nodes[0].prioritisetransaction(txid=txid_c, fee_delta=int(fee_delta_c_1 * COIN))
+        self.nodes[0].prioritisetransaction(txid=txid_c, fee_delta=int(fee_delta_c_2 * COIN))
+        raw_before[txid_a]["fees"]["descendant"] += fee_delta_b + fee_delta_c_1 + fee_delta_c_2
+        raw_before[txid_b]["fees"]["modified"] += fee_delta_b
+        raw_before[txid_b]["fees"]["ancestor"] += fee_delta_b
+        raw_before[txid_b]["fees"]["descendant"] += fee_delta_b
+        raw_before[txid_c]["fees"]["modified"] += fee_delta_c_1 + fee_delta_c_2
+        raw_before[txid_c]["fees"]["ancestor"] += fee_delta_c_1 + fee_delta_c_2
+        raw_before[txid_c]["fees"]["descendant"] += fee_delta_c_1 + fee_delta_c_2
+        raw_before[txid_d]["fees"]["ancestor"] += fee_delta_b + fee_delta_c_1 + fee_delta_c_2
+        raw_after = self.nodes[0].getrawmempool(verbose=True)
+        assert_equal(raw_before[txid_a], raw_after[txid_a])
+        assert_equal(raw_before, raw_after)
+
+        self.log.info("Test priority while txs are not in mempool")
+        self.restart_node(0, extra_args=["-nopersistmempool"])
+        self.nodes[0].setmocktime(mock_time)
+        assert_equal(self.nodes[0].getmempoolinfo()["size"], 0)
+        self.nodes[0].prioritisetransaction(txid=txid_b, fee_delta=int(fee_delta_b * COIN))
+        self.nodes[0].prioritisetransaction(txid=txid_c, fee_delta=int(fee_delta_c_1 * COIN))
+        self.nodes[0].prioritisetransaction(txid=txid_c, fee_delta=int(fee_delta_c_2 * COIN))
+        for t in [tx_o_a["hex"], tx_o_b["hex"], tx_o_c["hex"], tx_o_d["hex"]]:
+            self.nodes[0].sendrawtransaction(t)
+        raw_after = self.nodes[0].getrawmempool(verbose=True)
+        assert_equal(raw_before[txid_a], raw_after[txid_a])
+        assert_equal(raw_before, raw_after)
+
+        # Clear mempool
+        self.generate(self.nodes[0], 1)
+
+        # Use default extra_args
+        self.restart_node(0)
+
     def run_test(self):
+        self.wallet = MiniWallet(self.nodes[0])
+
         # Test `prioritisetransaction` required parameters
         assert_raises_rpc_error(-1, "prioritisetransaction", self.nodes[0].prioritisetransaction)
         assert_raises_rpc_error(-1, "prioritisetransaction", self.nodes[0].prioritisetransaction, '')
@@ -44,6 +125,8 @@ class PrioritiseTransactionTest(BitcoinTestFramework):
         # Test `prioritisetransaction` invalid `fee_delta`
         assert_raises_rpc_error(-1, "JSON value is not an integer as expected", self.nodes[0].prioritisetransaction, txid=txid, fee_delta='foo')
 
+        self.test_diamond()
+
         self.txouts = gen_return_txouts()
         self.relayfee = self.nodes[0].getnetworkinfo()['relayfee']
 

test/functional/test_framework/wallet.py

@@ -207,11 +207,12 @@ class MiniWallet:
         return {'new_utxos': [self.get_utxo(txid=txid, vout=vout) for vout in range(len(tx.vout))],
                 'txid': txid, 'hex': tx.serialize().hex(), 'tx': tx}
 
-    def create_self_transfer_multi(self, *, from_node, utxos_to_spend, num_outputs=1, fee_per_output=1000):
+    def create_self_transfer_multi(self, *, from_node, utxos_to_spend=None, num_outputs=1, fee_per_output=1000):
         """
         Create and return a transaction that spends the given UTXOs and creates a
         certain number of outputs with equal amounts.
         """
+        utxos_to_spend = utxos_to_spend or [self.get_utxo()]
         # create simple tx template (1 input, 1 output)
         tx = self.create_self_transfer(fee_rate=0, from_node=from_node, utxo_to_spend=utxos_to_spend[0], mempool_valid=False)['tx']
 
@@ -227,8 +228,8 @@ class MiniWallet:
         # adapt output amounts (use fixed fee per output)
         inputs_value_total = sum([int(COIN * utxo['value']) for utxo in utxos_to_spend])
         outputs_value_total = inputs_value_total - fee_per_output * num_outputs
-        for i in range(num_outputs):
+        for o in tx.vout:
-            tx.vout[i].nValue = outputs_value_total // num_outputs
+            o.nValue = outputs_value_total // num_outputs
         return tx
 
     def create_self_transfer(self, *, fee_rate=Decimal("0.003"), from_node=None, utxo_to_spend=None, mempool_valid=True, locktime=0, sequence=0):