Inside Bitcoin

251            singleton = self.wallet.send_self_transfer(from_node=node, utxo_to_spend=confirmed_utxo)
252            assert singleton["txid"] in node.getrawmempool()
253            utxos_to_merge.append(singleton["new_utxo"])
254            vsize_remaining -= singleton["tx"].get_vsize()
255
256        assert_greater_than_or_equal(vsize_remaining, 500)
257
258        # Create a transaction spending from all clusters that exceeds the cluster size limit.
259        tx_merger_too_big = self.wallet.create_self_transfer_multi(utxos_to_spend=utxos_to_merge, target_vsize=vsize_remaining + 4, fee_per_output=10000)
260        assert_raises_rpc_error(-26, "too-large-cluster", node.sendrawtransaction, tx_merger_too_big["hex"])
261
262        # A transaction that is slightly smaller should work.
263        tx_merger_small = self.wallet.create_self_transfer_multi(utxos_to_spend=utxos_to_merge[:-1], target_vsize=vsize_remaining - 4, fee_per_output=10000)
264        node.sendrawtransaction(tx_merger_small["hex"])
265        assert tx_merger_small["txid"] in node.getrawmempool()
266
267    @cleanup
268    def test_cluster_limit_rbf(self, max_cluster_count):
269        node = self.nodes[0]
270
271        # Use min feerate for the to-be-replaced transactions. There are many, so replacement cost can be expensive.
272        min_feerate = node.getmempoolinfo()["mempoolminfee"]
273
274        self.log.info("Test that cluster size calculation takes RBF into account")
275        utxos_created_by_parents = []
276        fees_rbf_sats = 0
277        for _ in range(max_cluster_count - 1):
278            parent_tx = self.wallet.send_self_transfer(from_node=node, confirmed_only=True)
279            utxo_to_replace = parent_tx["new_utxo"]
280            child_tx = self.wallet.send_self_transfer(from_node=node, utxo_to_spend=utxo_to_replace, fee_rate=min_feerate)
281
282            fees_rbf_sats += int(child_tx["fee"] * COIN)
283            utxos_created_by_parents.append(utxo_to_replace)
284
285        # This transaction would create a cluster of size max_cluster_count
286        # Importantly, the node should account for the fact that half of the transactions will be replaced.
287        tx_merger_replacer = self.wallet.create_self_transfer_multi(utxos_to_spend=utxos_created_by_parents, fee_per_output=fees_rbf_sats * 2)
288        node.sendrawtransaction(tx_merger_replacer["hex"])
289        assert tx_merger_replacer["txid"] in node.getrawmempool()
290        assert_equal(node.getmempoolcluster(tx_merger_replacer["txid"])['txcount'], max_cluster_count)
291
292        self.log.info("Test that cluster size calculation takes package RBF into account")
293        utxos_to_replace = []
294        fee_rbf_decimal = 0
295        for _ in range(max_cluster_count):
296            confirmed_utxo = self.wallet.get_utxo(confirmed_only=True)
297            tx_to_replace = self.wallet.send_self_transfer(from_node=node, utxo_to_spend=confirmed_utxo, fee_rate=min_feerate)
298            fee_rbf_decimal += tx_to_replace["fee"]
299            utxos_to_replace.append(confirmed_utxo)
300
301        tx_replacer = self.wallet.create_self_transfer_multi(utxos_to_spend=utxos_to_replace)
302        assert tx_replacer["txid"] not in node.getrawmempool()
303        tx_replacer_sponsor = self.wallet.create_self_transfer(utxo_to_spend=tx_replacer["new_utxos"][0], fee=fee_rbf_decimal * 2)
304
305        node.submitpackage([tx_replacer["hex"], tx_replacer_sponsor["hex"]], maxfeerate=0)
306        assert tx_replacer["txid"] in node.getrawmempool()
307        assert tx_replacer_sponsor["txid"] in node.getrawmempool()
308        assert_equal(node.getmempoolcluster(tx_replacer["txid"])['txcount'], 2)
309
310    @cleanup
311    def test_getmempoolcluster(self):
312        node = self.nodes[0]
313
314        self.log.info("Testing getmempoolcluster")
315
316        assert_equal(node.getrawmempool(), [])
317
318        # Key should exist and be trivially optimal
319        assert node.getmempoolinfo()["optimal"]
320
321        # Not in-mempool
322        not_mempool_tx = self.wallet.create_self_transfer()
323        assert_raises_rpc_error(-5, "Transaction not in mempool", node.getmempoolcluster, not_mempool_tx["txid"])
324
325        # Test that chunks are being recomputed properly
326
327        # One chunk with one tx
328        first_chunk_tx = self.wallet.send_self_transfer(from_node=node)
329        first_chunk_info = node.getmempoolcluster(first_chunk_tx["txid"])
330        assert_equal(first_chunk_info, {'clusterweight': first_chunk_tx["tx"].get_weight(), 'txcount': 1, 'chunks': [{'chunkfee': first_chunk_tx["fee"], 'chunkweight': first_chunk_tx["tx"].get_weight(), 'txs': [first_chunk_tx["txid"]]}]})
331
332        # Another unconnected tx, nothing should change
333        self.wallet.send_self_transfer(from_node=node)
334        first_chunk_info = node.getmempoolcluster(first_chunk_tx["txid"])
335        assert_equal(first_chunk_info, {'clusterweight': first_chunk_tx["tx"].get_weight(), 'txcount': 1, 'chunks': [{'chunkfee': first_chunk_tx["fee"], 'chunkweight': first_chunk_tx["tx"].get_weight(), 'txs': [first_chunk_tx["txid"]]}]})
336
337        # Second connected tx, makes one chunk still with high enough fee
338        second_chunk_tx = self.wallet.send_self_transfer(from_node=node, utxo_to_spend=first_chunk_tx["new_utxo"], fee_rate=Decimal("0.01"))
339        first_chunk_info = node.getmempoolcluster(first_chunk_tx["txid"])
340        # output is same across same cluster transactions
341        assert_equal(first_chunk_info, node.getmempoolcluster(second_chunk_tx["txid"]))
342        chunkweight = first_chunk_tx["tx"].get_weight() + second_chunk_tx["tx"].get_weight()
343        chunkfee = first_chunk_tx["fee"] + second_chunk_tx["fee"]
344        assert_equal(first_chunk_info, {'clusterweight': chunkweight, 'txcount': 2, 'chunks': [{'chunkfee': chunkfee, 'chunkweight': chunkweight, 'txs': [first_chunk_tx["txid"], second_chunk_tx["txid"]]}]})
345
346        # Third connected tx, makes one chunk still with high enough fee
347        third_chunk_tx = self.wallet.send_self_transfer(from_node=node, utxo_to_spend=second_chunk_tx["new_utxo"], fee_rate=Decimal("0.1"))
348        first_chunk_info = node.getmempoolcluster(first_chunk_tx["txid"])
349        # output is same across same cluster transactions
350        assert_equal(first_chunk_info, node.getmempoolcluster(third_chunk_tx["txid"]))
351        chunkweight = first_chunk_tx["tx"].get_weight() + second_chunk_tx["tx"].get_weight() + third_chunk_tx["tx"].get_weight()
352        chunkfee = first_chunk_tx["fee"] + second_chunk_tx["fee"] + third_chunk_tx["fee"]
353        assert_equal(first_chunk_info, {'clusterweight': chunkweight, 'txcount': 3, 'chunks': [{'chunkfee': chunkfee, 'chunkweight': chunkweight, 'txs': [first_chunk_tx["txid"], second_chunk_tx["txid"], third_chunk_tx["txid"]]}]})
354
355        # Now test single cluster with each tx being its own chunk
356
357        # One chunk with one tx
358        first_chunk_tx = self.wallet.send_self_transfer(from_node=node)
359        first_chunk_info = node.getmempoolcluster(first_chunk_tx["txid"])
360        assert_equal(first_chunk_info, {'clusterweight': first_chunk_tx["tx"].get_weight(), 'txcount': 1, 'chunks': [{'chunkfee': first_chunk_tx["fee"], 'chunkweight': first_chunk_tx["tx"].get_weight(), 'txs': [first_chunk_tx["txid"]]}]})
361
362        # Second connected tx, lower fee
363        second_chunk_tx = self.wallet.send_self_transfer(from_node=node, utxo_to_spend=first_chunk_tx["new_utxo"], fee_rate=Decimal("0.000002"))
364        first_chunk_info = node.getmempoolcluster(first_chunk_tx["txid"])
365        # output is same across same cluster transactions
366        assert_equal(first_chunk_info, node.getmempoolcluster(second_chunk_tx["txid"]))
367        first_chunkweight = first_chunk_tx["tx"].get_weight()
368        second_chunkweight = second_chunk_tx["tx"].get_weight()
369        assert_equal(first_chunk_info, {'clusterweight': first_chunkweight + second_chunkweight, 'txcount': 2, 'chunks': [{'chunkfee': first_chunk_tx["fee"], 'chunkweight': first_chunkweight, 'txs': [first_chunk_tx["txid"]]}, {'chunkfee': second_chunk_tx["fee"], 'chunkweight': second_chunkweight, 'txs': [second_chunk_tx["txid"]]}]})
370
371        # Third connected tx, even lower fee
372        third_chunk_tx = self.wallet.send_self_transfer(from_node=node, utxo_to_spend=second_chunk_tx["new_utxo"], fee_rate=Decimal("0.000001"))
373        first_chunk_info = node.getmempoolcluster(first_chunk_tx["txid"])
374        # output is same across same cluster transactions
375        assert_equal(first_chunk_info, node.getmempoolcluster(third_chunk_tx["txid"]))
376        first_chunkweight = first_chunk_tx["tx"].get_weight()
377        second_chunkweight = second_chunk_tx["tx"].get_weight()
378        third_chunkweight = third_chunk_tx["tx"].get_weight()
379        chunkfee = first_chunk_tx["fee"] + second_chunk_tx["fee"] + third_chunk_tx["fee"]
380        assert_equal(first_chunk_info, {'clusterweight': first_chunkweight + second_chunkweight + third_chunkweight, 'txcount': 3, 'chunks': [{'chunkfee': first_chunk_tx["fee"], 'chunkweight': first_chunkweight, 'txs': [first_chunk_tx["txid"]]}, {'chunkfee': second_chunk_tx["fee"], 'chunkweight': second_chunkweight, 'txs': [second_chunk_tx["txid"]]}, {'chunkfee': third_chunk_tx["fee"], 'chunkweight': third_chunkweight, 'txs': [third_chunk_tx["txid"]]}]})
381
382        # We expect known optimality directly after txn submission
383        assert node.getmempoolinfo()["optimal"]
384
385        # If we prioritise the last transaction it can join the second transaction's chunk.
386        node.prioritisetransaction(third_chunk_tx["txid"], 0, int(third_chunk_tx["fee"]*COIN) + 1)
387        first_chunk_info = node.getmempoolcluster(first_chunk_tx["txid"])
388        assert_equal(first_chunk_info, {'clusterweight': first_chunkweight + second_chunkweight + third_chunkweight, 'txcount': 3, 'chunks': [{'chunkfee': first_chunk_tx["fee"], 'chunkweight': first_chunkweight, 'txs': [first_chunk_tx["txid"]]}, {'chunkfee': second_chunk_tx["fee"] + 2*third_chunk_tx["fee"] + Decimal("0.00000001"), 'chunkweight': second_chunkweight + third_chunkweight, 'txs': [second_chunk_tx["txid"], third_chunk_tx["txid"]]}]})
389
390    def run_test(self):
391        node = self.nodes[0]
392        self.wallet = MiniWallet(node)
393        self.generate(self.wallet, 400)
394
395        self.test_getmempoolcluster()
396
397        self.test_cluster_limit_rbf(DEFAULT_CLUSTER_LIMIT)
398
399        for cluster_size_limit_kvb in [10, 20, 33, 100, DEFAULT_CLUSTER_SIZE_LIMIT_KVB]:
400            self.log.info(f"-> Resetting node with -limitclustersize={cluster_size_limit_kvb}")
401            self.restart_node(0, extra_args=[f"-limitclustersize={cluster_size_limit_kvb}"])
402
403            cluster_size_limit = cluster_size_limit_kvb * 1000
404            self.test_cluster_size_limit(cluster_size_limit)
405            self.test_cluster_merging_size(cluster_size_limit)
406
407        for cluster_count_limit in [4, 10, 16, 32, DEFAULT_CLUSTER_LIMIT]:
408            self.log.info(f"-> Resetting node with -limitclustercount={cluster_count_limit}")
409            self.restart_node(0, extra_args=[f"-limitclustercount={cluster_count_limit}"])
410
411            self.test_cluster_count_limit(cluster_count_limit)
412            if cluster_count_limit > 10:
413                self.test_cluster_merging(cluster_count_limit)
414
415
416if __name__ == '__main__':
417    MempoolClusterTest(__file__).main()
418