Inside Bitcoin

251
252        # Higher fee, but the fee per KB is much lower, so the replacement is
253        # rejected.
254        tx1b_hex = self.wallet.create_self_transfer_multi(
255            utxos_to_spend=[tx0_outpoint],
256            sequence=0,
257            num_outputs=100,
258            amount_per_output=1000,
259        )["hex"]
260
261        # This will raise an exception due to insufficient fee
262        assert_raises_rpc_error(-26, "does not improve feerate diagram", self.nodes[0].sendrawtransaction, tx1b_hex, 0)
263
264    def test_spends_of_conflicting_outputs(self):
265        """Replacements that spend conflicting tx outputs are rejected"""
266        utxo1 = self.make_utxo(self.nodes[0], int(1.2 * COIN))
267        utxo2 = self.make_utxo(self.nodes[0], 3 * COIN)
268
269        tx1a = self.wallet.send_self_transfer(
270            from_node=self.nodes[0],
271            utxo_to_spend=utxo1,
272            sequence=0,
273            fee=Decimal("0.1"),
274        )
275        tx1a_utxo = tx1a["new_utxo"]
276
277        # Direct spend an output of the transaction we're replacing.
278        tx2 = self.wallet.create_self_transfer_multi(
279            utxos_to_spend=[utxo1, utxo2, tx1a_utxo],
280            sequence=0,
281            amount_per_output=int(COIN * tx1a_utxo["value"]),
282        )["tx"]
283        tx2_hex = tx2.serialize().hex()
284
285        # This will raise an exception
286        reject_reason = "bad-txns-spends-conflicting-tx"
287        reject_details = f"{reject_reason}, {tx2.txid_hex} spends conflicting transaction {tx1a['tx'].txid_hex}"
288        res = self.nodes[0].testmempoolaccept(rawtxs=[tx2_hex])[0]
289        assert_equal(res["reject-reason"], reject_reason)
290        assert_equal(res["reject-details"], reject_details)
291        assert_raises_rpc_error(-26, f"{reject_details}", self.nodes[0].sendrawtransaction, tx2_hex, 0)
292
293
294        # Spend tx1a's output to test the indirect case.
295        tx1b_utxo = self.wallet.send_self_transfer(
296            from_node=self.nodes[0],
297            utxo_to_spend=tx1a_utxo,
298            sequence=0,
299            fee=Decimal("0.1"),
300        )["new_utxo"]
301
302        tx2_hex = self.wallet.create_self_transfer_multi(
303            utxos_to_spend=[utxo1, utxo2, tx1b_utxo],
304            sequence=0,
305            amount_per_output=int(COIN * tx1a_utxo["value"]),
306        )["hex"]
307
308        # This will raise an exception
309        assert_raises_rpc_error(-26, "bad-txns-spends-conflicting-tx", self.nodes[0].sendrawtransaction, tx2_hex, 0)
310
311    def test_new_unconfirmed_inputs(self):
312        """Replacements that add new unconfirmed inputs may be accepted"""
313        confirmed_utxo = self.make_utxo(self.nodes[0], int(1.1 * COIN))
314        unconfirmed_utxo = self.make_utxo(self.nodes[0], int(0.2 * COIN), confirmed=False)
315
316        self.wallet.send_self_transfer(
317            from_node=self.nodes[0],
318            utxo_to_spend=confirmed_utxo,
319            sequence=0,
320            fee=Decimal("0.1"),
321        )
322
323        tx2 = self.wallet.create_self_transfer_multi(
324            utxos_to_spend=[confirmed_utxo, unconfirmed_utxo],
325            sequence=0,
326            amount_per_output=1 * COIN,
327        )["tx"]
328        tx2_hex = tx2.serialize().hex()
329
330        # This will not raise an exception
331        tx2_id = self.nodes[0].sendrawtransaction(tx2_hex, 0)
332        assert tx2_id in self.nodes[0].getrawmempool()
333
334    def test_new_unconfirmed_input_with_low_feerate(self):
335        """Replacements that add new unconfirmed inputs are allowed, but must pass the feerate diagram check"""
336        confirmed_utxos = [self.make_utxo(self.nodes[0], int(1.1 * COIN)) for _ in range(3)]
337        large_low_feerate = self.wallet.create_self_transfer(utxo_to_spend=confirmed_utxos[0], target_vsize=10000, fee=Decimal("0.00001000"))
338        self.nodes[0].sendrawtransaction(large_low_feerate['hex'])
339        unconfirmed_utxo = large_low_feerate['new_utxo']
340
341        # These two transactions are approximately the same size. The replacement tx pays twice the fee.
342        tx_to_replace = self.wallet.create_self_transfer_multi(utxos_to_spend=[confirmed_utxos[1], confirmed_utxos[2]], fee_per_output=2000)
343        tx_replacement = self.wallet.create_self_transfer_multi(utxos_to_spend=[confirmed_utxos[1], unconfirmed_utxo], fee_per_output=4000)
344        assert_greater_than(tx_replacement['fee']*tx_to_replace['tx'].get_vsize(), tx_to_replace['fee']*tx_replacement['tx'].get_vsize())
345
346        self.nodes[0].sendrawtransaction(tx_to_replace['hex'])
347        assert_raises_rpc_error(-26, "insufficient feerate: does not improve feerate diagram", self.nodes[0].sendrawtransaction, tx_replacement['hex'])
348
349
350    def test_too_many_replacements(self):
351        """Replacements that conflict with too many clusters are rejected"""
352        # Try directly replacing transactions in more than MAX_REPLACEMENT_LIMIT
353        # distinct clusters
354
355        # Start by creating a single transaction with many outputs
356        initial_nValue = 10 * COIN
357        utxo = self.make_utxo(self.nodes[0], initial_nValue)
358        fee = int(0.0001 * COIN)
359        split_value = int((initial_nValue - fee) / (MAX_REPLACEMENT_LIMIT + 1))
360
361        splitting_tx_utxos = self.wallet.send_self_transfer_multi(
362            from_node=self.nodes[0],
363            utxos_to_spend=[utxo],
364            sequence=0,
365            num_outputs=MAX_REPLACEMENT_LIMIT + 1,
366            amount_per_output=split_value,
367        )["new_utxos"]
368
369        self.generate(self.nodes[0], 1)
370
371        # Now spend each of those outputs individually
372        for utxo in splitting_tx_utxos:
373            self.wallet.send_self_transfer(
374                from_node=self.nodes[0],
375                utxo_to_spend=utxo,
376                sequence=0,
377                fee=Decimal(fee) / COIN,
378            )
379
380        # Now create doublespend of the whole lot; should fail.
381        # Need a big enough fee to cover all spending transactions and have
382        # a higher fee rate
383        double_spend_value = (split_value - 100 * fee) * (MAX_REPLACEMENT_LIMIT + 1)
384        double_tx = self.wallet.create_self_transfer_multi(
385            utxos_to_spend=splitting_tx_utxos,
386            sequence=0,
387            amount_per_output=double_spend_value,
388        )["tx"]
389        double_tx_hex = double_tx.serialize().hex()
390
391        # This will raise an exception
392        reject_reason = "too many potential replacements"
393        reject_details = f"{reject_reason}, rejecting replacement {double_tx.txid_hex}; too many conflicting clusters ({MAX_REPLACEMENT_LIMIT + 1} > {MAX_REPLACEMENT_LIMIT})"
394        res = self.nodes[0].testmempoolaccept(rawtxs=[double_tx_hex])[0]
395        assert_equal(res["reject-reason"], reject_reason)
396        assert_equal(res["reject-details"], reject_details)
397        assert_raises_rpc_error(-26, f"{reject_details}", self.nodes[0].sendrawtransaction, double_tx_hex, 0)
398
399
400        # If we remove an input, it should pass
401        double_tx.vin.pop()
402        double_tx_hex = double_tx.serialize().hex()
403        self.nodes[0].sendrawtransaction(double_tx_hex, 0)
404
405    def test_prioritised_transactions(self):
406        # Ensure that fee deltas used via prioritisetransaction are
407        # correctly used by replacement logic
408
409        # 1. Check that feeperkb uses modified fees
410        tx0_outpoint = self.make_utxo(self.nodes[0], int(1.1 * COIN))
411
412        tx1a_txid = self.wallet.send_self_transfer(
413            from_node=self.nodes[0],
414            utxo_to_spend=tx0_outpoint,
415            sequence=0,
416            fee=Decimal("0.1"),
417        )["txid"]
418
419        # Higher fee, but the actual fee per KB is much lower.
420        tx1b_hex = self.wallet.create_self_transfer_multi(
421            utxos_to_spend=[tx0_outpoint],
422            sequence=0,
423            num_outputs=100,
424            amount_per_output=int(0.00001 * COIN),
425        )["hex"]
426
427        # Verify tx1b cannot replace tx1a.
428        assert_raises_rpc_error(-26, "does not improve feerate diagram", self.nodes[0].sendrawtransaction, tx1b_hex, 0)
429
430        # Use prioritisetransaction to set tx1a's fee to 0.
431        self.nodes[0].prioritisetransaction(txid=tx1a_txid, fee_delta=int(-0.1 * COIN))
432
433        # Now tx1b should be able to replace tx1a
434        tx1b_txid = self.nodes[0].sendrawtransaction(tx1b_hex, 0)
435
436        assert tx1b_txid in self.nodes[0].getrawmempool()
437
438        # 2. Check that absolute fee checks use modified fee.
439        tx1_outpoint = self.make_utxo(self.nodes[0], int(1.1 * COIN))
440
441        # tx2a
442        self.wallet.send_self_transfer(
443            from_node=self.nodes[0],
444            utxo_to_spend=tx1_outpoint,
445            sequence=0,
446            fee=Decimal("0.1"),
447        )
448
449        # Lower fee, but we'll prioritise it
450        tx2b = self.wallet.create_self_transfer(
451            utxo_to_spend=tx1_outpoint,
452            sequence=0,
453            fee=Decimal("0.09"),
454        )
455
456        # Verify tx2b cannot replace tx2a.
457        assert_raises_rpc_error(-26, "insufficient fee", self.nodes[0].sendrawtransaction, tx2b["hex"], 0)
458
459        # Now prioritise tx2b to have a higher modified fee
460        self.nodes[0].prioritisetransaction(txid=tx2b["txid"], fee_delta=int(0.1 * COIN))
461
462        # tx2b should now be accepted
463        tx2b_txid = self.nodes[0].sendrawtransaction(tx2b["hex"], 0)
464
465        assert tx2b_txid in self.nodes[0].getrawmempool()
466
467    def test_rpc(self):
468        us0 = self.wallet.get_utxo()
469        ins = [us0]
470        outs = {ADDRESS_BCRT1_UNSPENDABLE: Decimal(1.0000000)}
471        rawtx0 = self.nodes[0].createrawtransaction(ins, outs, 0, True)
472        rawtx1 = self.nodes[0].createrawtransaction(ins, outs, 0, False)
473        json0 = self.nodes[0].decoderawtransaction(rawtx0)
474        json1 = self.nodes[0].decoderawtransaction(rawtx1)
475        assert_equal(json0["vin"][0]["sequence"], 4294967293)
476        assert_equal(json1["vin"][0]["sequence"], 4294967295)
477
478        if self.is_wallet_compiled():
479            self.init_wallet(node=0)
480            rawtx2 = self.nodes[0].createrawtransaction([], outs)
481            frawtx2a = self.nodes[0].fundrawtransaction(rawtx2, {"replaceable": True})
482            frawtx2b = self.nodes[0].fundrawtransaction(rawtx2, {"replaceable": False})
483
484            json0 = self.nodes[0].decoderawtransaction(frawtx2a['hex'])
485            json1 = self.nodes[0].decoderawtransaction(frawtx2b['hex'])
486            assert_equal(json0["vin"][0]["sequence"], 4294967293)
487            assert_equal(json1["vin"][0]["sequence"], 4294967294)
488
489    def test_replacement_relay_fee(self):
490        tx = self.wallet.send_self_transfer(from_node=self.nodes[0])['tx']
491
492        # Higher fee, higher feerate, different txid, but the replacement does not provide a relay
493        # fee conforming to node's `incrementalrelayfee` policy of 100 sat per KB.
494        assert_equal(self.nodes[0].getmempoolinfo()["incrementalrelayfee"], Decimal("0.000001"))
495        tx.vout[0].nValue -= 1
496        assert_raises_rpc_error(-26, "insufficient fee", self.nodes[0].sendrawtransaction, tx.serialize().hex())
497
498    def test_incremental_relay_feerates(self):
499        self.log.info("Test that incremental relay fee is applied correctly in RBF for various settings...")
500        node = self.nodes[0]