Inside Bitcoin

251        # Add a child that spends both at high feerate to submit via submitpackage
252        tx_child = self.wallet.create_self_transfer_multi(
253            fee_per_output=int(DEFAULT_FEE * 5 * COIN),
254            utxos_to_spend=[tx1["new_utxo"], tx2["new_utxo"]],
255        )
256
257        testres = node.testmempoolaccept([tx1["hex"], tx2["hex"], tx_child["hex"]])
258
259        assert_equal(testres, [
260            {"txid": tx1["txid"], "wtxid": tx1["wtxid"], "package-error": "conflict-in-package"},
261            {"txid": tx2["txid"], "wtxid": tx2["wtxid"], "package-error": "conflict-in-package"},
262            {"txid": tx_child["txid"], "wtxid": tx_child["wtxid"], "package-error": "conflict-in-package"}
263        ])
264
265        submitres = node.submitpackage([tx1["hex"], tx2["hex"], tx_child["hex"]])
266        expected = {
267            tx1["wtxid"]: {"txid": tx1["txid"], "error": "package-not-validated"},
268            tx2["wtxid"]: {"txid": tx2["txid"], "error": "package-not-validated"},
269            tx_child["wtxid"]: {"txid": tx_child["txid"], "error": "package-not-validated"},
270        }
271        assert_equal(submitres, {"package_msg": "conflict-in-package", "tx-results": expected,"replaced-transactions": []})
272
273        # Submit tx1 to mempool, then try the same package again
274        node.sendrawtransaction(tx1["hex"])
275
276        submitres = node.submitpackage([tx1["hex"], tx2["hex"], tx_child["hex"]])
277        expected = {
278            tx1["wtxid"]: {"txid": tx1["txid"], "error": "package-not-validated"},
279            tx2["wtxid"]: {"txid": tx2["txid"], "error": "package-not-validated"},
280            tx_child["wtxid"]: {"txid": tx_child["txid"], "error": "package-not-validated"},
281        }
282        assert_equal(submitres, {"package_msg": "conflict-in-package", "tx-results": expected,"replaced-transactions": []})
283        assert tx_child["txid"] not in node.getrawmempool()
284
285        # without the in-mempool ancestor tx1 included in the call, tx2 can be submitted, but
286        # tx_child is missing an input.
287        submitres = node.submitpackage([tx2["hex"], tx_child["hex"]])
288        assert_equal(submitres["tx-results"][tx_child["wtxid"]], {"txid": tx_child["txid"], "error": "bad-txns-inputs-missingorspent"})
289        assert tx2["txid"] in node.getrawmempool()
290
291        # Regardless of error type, the child can never enter the mempool
292        assert tx_child["txid"] not in node.getrawmempool()
293
294    def test_rbf(self):
295        node = self.nodes[0]
296
297        coin = self.wallet.get_utxo()
298        fee = Decimal("0.00125000")
299        replaceable_tx = self.wallet.create_self_transfer(utxo_to_spend=coin, sequence=MAX_BIP125_RBF_SEQUENCE, fee = fee)
300        testres_replaceable = node.testmempoolaccept([replaceable_tx["hex"]])[0]
301        assert_equal(testres_replaceable["txid"], replaceable_tx["txid"])
302        assert_equal(testres_replaceable["wtxid"], replaceable_tx["wtxid"])
303        assert testres_replaceable["allowed"]
304        assert_equal(testres_replaceable["vsize"], replaceable_tx["tx"].get_vsize())
305        assert_equal(testres_replaceable["vsize_bip141"], replaceable_tx["tx"].get_vsize())
306        assert_equal(testres_replaceable["fees"]["base"], fee)
307        assert_fee_amount(fee, replaceable_tx["tx"].get_vsize(), testres_replaceable["fees"]["effective-feerate"])
308        assert_equal(testres_replaceable["fees"]["effective-includes"], [replaceable_tx["wtxid"]])
309
310        # Replacement transaction is identical except has double the fee
311        replacement_tx = self.wallet.create_self_transfer(utxo_to_spend=coin, sequence=MAX_BIP125_RBF_SEQUENCE, fee = 2 * fee)
312        testres_rbf_conflicting = node.testmempoolaccept([replaceable_tx["hex"], replacement_tx["hex"]])
313        assert_equal(testres_rbf_conflicting, [
314            {"txid": replaceable_tx["txid"], "wtxid": replaceable_tx["wtxid"], "package-error": "conflict-in-package"},
315            {"txid": replacement_tx["txid"], "wtxid": replacement_tx["wtxid"], "package-error": "conflict-in-package"}
316        ])
317
318        self.log.info("Test that packages cannot conflict with mempool transactions, even if a valid BIP125 RBF")
319        # This transaction is a valid BIP125 replace-by-fee
320        self.wallet.sendrawtransaction(from_node=node, tx_hex=replaceable_tx["hex"])
321        testres_rbf_single = node.testmempoolaccept([replacement_tx["hex"]])
322        assert testres_rbf_single[0]["allowed"]
323        testres_rbf_package = self.independent_txns_testres_blank + [{
324            "txid": replacement_tx["txid"], "wtxid": replacement_tx["wtxid"], "allowed": False,
325            "reject-reason": "bip125-replacement-disallowed",
326            "reject-details": "bip125-replacement-disallowed"
327        }]
328        self.assert_testres_equal(self.independent_txns_hex + [replacement_tx["hex"]], testres_rbf_package)
329
330    def assert_equal_package_results(self, node, testmempoolaccept_result, submitpackage_result):
331        """Assert that a successful submitpackage result is consistent with testmempoolaccept
332        results and getmempoolentry info. Note that the result structs are different and, due to
333        policy differences between testmempoolaccept and submitpackage (i.e. package feerate),
334        some information may be different.
335        """
336        for testres_tx in testmempoolaccept_result:
337            # Grab this result from the submitpackage_result
338            submitres_tx = submitpackage_result["tx-results"][testres_tx["wtxid"]]
339            assert_equal(submitres_tx["txid"], testres_tx["txid"])
340            # No "allowed" if the tx was already in the mempool
341            if "allowed" in testres_tx and testres_tx["allowed"]:
342                assert_equal(submitres_tx["vsize"], testres_tx["vsize"])
343                assert_equal(submitres_tx["vsize_bip141"], testres_tx["vsize"])
344                assert_equal(submitres_tx["fees"]["base"], testres_tx["fees"]["base"])
345            entry_info = node.getmempoolentry(submitres_tx["txid"])
346            assert_equal(submitres_tx["vsize"], entry_info["vsize"])
347            assert_equal(submitres_tx["vsize_bip141"], entry_info["vsize"])
348            assert_equal(submitres_tx["fees"]["base"], entry_info["fees"]["base"])
349
350    def test_submit_child_with_parents(self, num_parents, partial_submit):
351        node = self.nodes[0]
352        peer = node.add_p2p_connection(P2PTxInvStore())
353
354        package_txns = []
355        presubmitted_wtxids = set()
356        for _ in range(num_parents):
357            parent_tx = self.wallet.create_self_transfer(fee=DEFAULT_FEE)
358            package_txns.append(parent_tx)
359            if partial_submit and random.choice([True, False]):
360                node.sendrawtransaction(parent_tx["hex"])
361                presubmitted_wtxids.add(parent_tx["wtxid"])
362        child_tx = self.wallet.create_self_transfer_multi(utxos_to_spend=[tx["new_utxo"] for tx in package_txns], fee_per_output=10000) #DEFAULT_FEE
363        package_txns.append(child_tx)
364
365        testmempoolaccept_result = node.testmempoolaccept(rawtxs=[tx["hex"] for tx in package_txns])
366        submitpackage_result = node.submitpackage(package=[tx["hex"] for tx in package_txns])
367
368        # Check that each result is present, with the correct size and fees
369        assert_equal(submitpackage_result["package_msg"], "success")
370        for package_txn in package_txns:
371            tx = package_txn["tx"]
372            assert tx.wtxid_hex in submitpackage_result["tx-results"]
373            wtxid = tx.wtxid_hex
374            assert wtxid in submitpackage_result["tx-results"]
375            tx_result = submitpackage_result["tx-results"][wtxid]
376            assert_equal(tx_result["txid"], tx.txid_hex)
377            assert_equal(tx_result["vsize_adjusted"], tx.get_vsize())
378            assert_equal(tx_result["vsize"], tx.get_vsize())
379            assert_equal(tx_result["vsize_bip141"], tx.get_vsize())
380            assert_equal(tx_result["fees"]["base"], DEFAULT_FEE)
381            if wtxid not in presubmitted_wtxids:
382                assert_fee_amount(DEFAULT_FEE, tx.get_vsize(), tx_result["fees"]["effective-feerate"])
383                assert_equal(tx_result["fees"]["effective-includes"], [wtxid])
384
385        # submitpackage result should be consistent with testmempoolaccept and getmempoolentry
386        self.assert_equal_package_results(node, testmempoolaccept_result, submitpackage_result)
387
388        # The node should announce each transaction. No guarantees for propagation.
389        peer.wait_for_broadcast([tx["tx"].wtxid_hex for tx in package_txns])
390        self.generate(node, 1)
391
392    def test_submitpackage(self):
393        node = self.nodes[0]
394
395        self.log.info("Submitpackage only allows valid hex inputs")
396        valid_tx_list = self.wallet.create_self_transfer_chain(chain_length=2)
397        hex_list = [valid_tx_list[0]["hex"][:-1] + 'X', valid_tx_list[1]["hex"]]
398        txid_list = [valid_tx_list[0]["txid"], valid_tx_list[1]["txid"]]
399        assert_raises_rpc_error(-22, "TX decode failed:", node.submitpackage, hex_list)
400        assert txid_list[0] not in node.getrawmempool()
401        assert txid_list[1] not in node.getrawmempool()
402
403        self.log.info("Submitpackage valid packages with 1 child and some number of parents (or none)")
404        for num_parents in [0, 1, 2, 24]:
405            self.test_submit_child_with_parents(num_parents, False)
406            self.test_submit_child_with_parents(num_parents, True)
407
408        self.log.info("Submitpackage only allows packages of 1 child with its parents")
409        # Chain of 3 transactions has too many generations
410        legacy_pool = node.getrawmempool()
411        chain_hex = [t["hex"] for t in self.wallet.create_self_transfer_chain(chain_length=3)]
412        assert_raises_rpc_error(-25, "package topology disallowed", node.submitpackage, chain_hex)
413        assert_equal(legacy_pool, node.getrawmempool())
414
415        assert_raises_rpc_error(-8, f"Array must contain between 1 and {MAX_PACKAGE_COUNT} transactions.", node.submitpackage, [])
416        assert_raises_rpc_error(
417            -8, f"Array must contain between 1 and {MAX_PACKAGE_COUNT} transactions.",
418            node.submitpackage, [chain_hex[0]] * (MAX_PACKAGE_COUNT + 1)
419        )
420
421        # Create a transaction chain such as only the parent gets accepted (by making the child's
422        # version non-standard). Make sure the parent does get broadcast.
423        self.log.info("If a package is partially submitted, transactions included in mempool get broadcast")
424        peer = node.add_p2p_connection(P2PTxInvStore())
425        txs = self.wallet.create_self_transfer_chain(chain_length=2)
426        bad_child = tx_from_hex(txs[1]["hex"])
427        bad_child.version = 0xffffffff
428        hex_partial_acceptance = [txs[0]["hex"], bad_child.serialize().hex()]
429        res = node.submitpackage(hex_partial_acceptance)
430        assert_equal(res["package_msg"], "transaction failed")
431        first_wtxid = txs[0]["tx"].wtxid_hex
432        assert "error" not in res["tx-results"][first_wtxid]
433        sec_wtxid = bad_child.wtxid_hex
434        assert_equal(res["tx-results"][sec_wtxid]["error"], "version")
435        peer.wait_for_broadcast([first_wtxid])
436
437    def test_maxfeerate_submitpackage(self):
438        node = self.nodes[0]
439        # clear mempool
440        deterministic_address = node.get_deterministic_priv_key().address
441        self.generatetoaddress(node, 1, deterministic_address)
442
443        self.log.info("Submitpackage maxfeerate arg testing")
444        chained_txns = self.wallet.create_self_transfer_chain(chain_length=2)
445        minrate_btc_kvb = min([chained_txn["fee"] / chained_txn["tx"].get_vsize() * 1000 for chained_txn in chained_txns])
446        chain_hex = [t["hex"] for t in chained_txns]
447        pkg_result = node.submitpackage(chain_hex, maxfeerate=minrate_btc_kvb - Decimal("0.00000001"))
448
449        # First tx failed in single transaction evaluation, so package message is generic
450        assert_equal(pkg_result["package_msg"], "transaction failed")
451        assert_equal(pkg_result["tx-results"][chained_txns[0]["wtxid"]]["error"], "max feerate exceeded")
452        assert_equal(pkg_result["tx-results"][chained_txns[1]["wtxid"]]["error"], "bad-txns-inputs-missingorspent")
453        assert_equal(node.getrawmempool(), [])
454
455        # Make chain of two transactions where parent doesn't make minfee threshold
456        # but child is too high fee
457        # Lower mempool limit to make it easier to fill_mempool
458        self.restart_node(0, extra_args=[
459            "-maxmempool=5",
460            "-persistmempool=0",
461        ])
462        self.wallet.rescan_utxos()
463
464        fill_mempool(self, node)
465
466        minrelay = node.getmempoolinfo()["minrelaytxfee"]
467        parent = self.wallet.create_self_transfer(
468            fee_rate=minrelay,
469            confirmed_only=True,
470        )
471
472        child = self.wallet.create_self_transfer(
473            fee_rate=DEFAULT_FEE,
474            utxo_to_spend=parent["new_utxo"],
475        )
476
477        pkg_result = node.submitpackage([parent["hex"], child["hex"]], maxfeerate=DEFAULT_FEE - Decimal("0.00000001"))
478
479        # Child is connected even though parent is invalid and still reports fee exceeded
480        # this implies sub-package evaluation of both entries together.
481        assert_equal(pkg_result["package_msg"], "transaction failed")
482        assert "mempool min fee not met" in pkg_result["tx-results"][parent["wtxid"]]["error"]
483        assert_equal(pkg_result["tx-results"][child["wtxid"]]["error"], "max feerate exceeded")
484        assert parent["txid"] not in node.getrawmempool()
485        assert child["txid"] not in node.getrawmempool()
486
487        # Reset maxmempool, reset dynamic mempool minimum feerate, and empty mempool.
488        self.restart_node(0)
489        self.wallet.rescan_utxos()
490
491        assert_equal(node.getrawmempool(), [])
492
493    def test_maxburn_submitpackage(self):
494        node = self.nodes[0]
495
496        assert_equal(node.getrawmempool(), [])
497
498        self.log.info("Submitpackage maxburnamount arg testing")
499        chained_txns_burn = self.wallet.create_self_transfer_chain(
500            chain_length=2,