Inside Bitcoin

251        resulting_ancestry_fee_rate = self.calc_set_fee_rate([gp_tx, p_tx, ancestor_aware_tx])
252        assert_greater_than_or_equal(resulting_ancestry_fee_rate, self.target_fee_rate)
253        assert_greater_than_or_equal(self.target_fee_rate*1.01, resulting_ancestry_fee_rate)
254
255        wallet.unloadwallet()
256
257    # Test fee calculation when bumping while using subtract fee from output (SFFO)
258    def test_target_feerate_unconfirmed_low_sffo(self):
259        self.log.info("Start test feerate with low feerate unconfirmed input, while subtracting from output")
260        wallet = self.setup_and_fund_wallet("unconfirmed_low_wallet_sffo")
261
262        parent_txid = wallet.sendtoaddress(address=wallet.getnewaddress(), amount=1, fee_rate=1)
263        parent_tx = wallet.gettransaction(txid=parent_txid, verbose=True)
264
265        self.assert_undershoots_target(parent_tx)
266
267        ancestor_aware_txid = wallet.sendtoaddress(address=self.def_wallet.getnewaddress(), amount=0.5, fee_rate=self.target_fee_rate, subtractfeefromamount=True)
268        ancestor_aware_tx = wallet.gettransaction(txid=ancestor_aware_txid, verbose=True)
269
270        self.assert_spends_only_parents(ancestor_aware_tx, [parent_txid])
271
272        self.assert_beats_target(ancestor_aware_tx)
273        resulting_ancestry_fee_rate = self.calc_set_fee_rate([parent_tx, ancestor_aware_tx])
274        assert_greater_than_or_equal(resulting_ancestry_fee_rate, self.target_fee_rate)
275        assert_greater_than_or_equal(self.target_fee_rate*1.01, resulting_ancestry_fee_rate)
276
277        wallet.unloadwallet()
278
279    # Test that parents of preset unconfirmed inputs get cpfp'ed
280    def test_preset_input_cpfp(self):
281        self.log.info("Start test with preset input from low feerate unconfirmed transaction")
282        wallet = self.setup_and_fund_wallet("preset_input")
283
284        parent_txid = wallet.sendtoaddress(address=wallet.getnewaddress(), amount=1, fee_rate=1)
285        parent_tx = wallet.gettransaction(txid=parent_txid, verbose=True)
286
287        self.assert_undershoots_target(parent_tx)
288
289        number_outputs = len(parent_tx["decoded"]["vout"])
290        assert_equal(number_outputs, 2)
291
292        # we don't care which of the two outputs we spent, they're both ours
293        ancestor_aware_txid = wallet.send(outputs=[{self.def_wallet.getnewaddress(): 0.5}], fee_rate=self.target_fee_rate, options={"add_inputs": True, "inputs": [{"txid": parent_txid, "vout": 0}]})["txid"]
294        ancestor_aware_tx = wallet.gettransaction(txid=ancestor_aware_txid, verbose=True)
295
296        self.assert_spends_only_parents(ancestor_aware_tx, [parent_txid])
297
298        self.assert_beats_target(ancestor_aware_tx)
299        resulting_ancestry_fee_rate = self.calc_set_fee_rate([parent_tx, ancestor_aware_tx])
300        assert_greater_than_or_equal(resulting_ancestry_fee_rate, self.target_fee_rate)
301        assert_greater_than_or_equal(self.target_fee_rate*1.01, resulting_ancestry_fee_rate)
302
303        wallet.unloadwallet()
304
305    # Test that RBFing a transaction with unconfirmed input gets the right feerate
306    def test_rbf_bumping(self):
307        self.log.info("Start test to rbf a transaction unconfirmed input to bump it")
308        wallet = self.setup_and_fund_wallet("bump")
309
310        parent_txid = wallet.sendtoaddress(address=wallet.getnewaddress(), amount=1, fee_rate=1)
311        parent_tx = wallet.gettransaction(txid=parent_txid, verbose=True)
312
313        self.assert_undershoots_target(parent_tx)
314
315        to_be_rbfed_ancestor_aware_txid = wallet.sendtoaddress(address=self.def_wallet.getnewaddress(), amount=0.5, fee_rate=self.target_fee_rate)
316        ancestor_aware_tx = wallet.gettransaction(txid=to_be_rbfed_ancestor_aware_txid, verbose=True)
317
318        self.assert_spends_only_parents(ancestor_aware_tx, [parent_txid])
319
320        self.assert_beats_target(ancestor_aware_tx)
321        resulting_ancestry_fee_rate = self.calc_set_fee_rate([parent_tx, ancestor_aware_tx])
322        assert_greater_than_or_equal(resulting_ancestry_fee_rate, self.target_fee_rate)
323        assert_greater_than_or_equal(self.target_fee_rate*1.01, resulting_ancestry_fee_rate)
324
325        bumped_ancestor_aware_txid = wallet.bumpfee(txid=to_be_rbfed_ancestor_aware_txid, options={"fee_rate": self.target_fee_rate * 2} )["txid"]
326        bumped_ancestor_aware_tx = wallet.gettransaction(txid=bumped_ancestor_aware_txid, verbose=True)
327        self.assert_spends_only_parents(ancestor_aware_tx, [parent_txid])
328
329        resulting_bumped_fee_rate = self.calc_fee_rate(bumped_ancestor_aware_tx)
330        assert_greater_than_or_equal(resulting_bumped_fee_rate, 2*self.target_fee_rate)
331        resulting_bumped_ancestry_fee_rate = self.calc_set_fee_rate([parent_tx, bumped_ancestor_aware_tx])
332        assert_greater_than_or_equal(resulting_bumped_ancestry_fee_rate, 2*self.target_fee_rate)
333        assert_greater_than_or_equal(2*self.target_fee_rate*1.01, resulting_bumped_ancestry_fee_rate)
334
335        wallet.unloadwallet()
336
337    # Test that transaction spending two UTXOs with overlapping ancestry does not bump shared ancestors twice
338    def test_target_feerate_unconfirmed_low_overlapping_ancestry(self):
339        self.log.info("Start test where two UTXOs have overlapping ancestry")
340        wallet = self.setup_and_fund_wallet("overlapping_ancestry_wallet")
341
342        parent_txid = wallet.sendtoaddress(address=wallet.getnewaddress(), amount=1, fee_rate=1)
343        two_output_parent_tx = wallet.gettransaction(txid=parent_txid, verbose=True)
344
345        self.assert_undershoots_target(two_output_parent_tx)
346
347        # spend both outputs from parent transaction
348        ancestor_aware_txid = wallet.sendtoaddress(address=self.def_wallet.getnewaddress(), amount=1.5, fee_rate=self.target_fee_rate)
349        ancestor_aware_tx = wallet.gettransaction(txid=ancestor_aware_txid, verbose=True)
350        self.assert_spends_only_parents(ancestor_aware_tx, [parent_txid, parent_txid])
351
352        self.assert_beats_target(ancestor_aware_tx)
353        resulting_ancestry_fee_rate = self.calc_set_fee_rate([two_output_parent_tx, ancestor_aware_tx])
354        assert_greater_than_or_equal(resulting_ancestry_fee_rate, self.target_fee_rate)
355        assert_greater_than_or_equal(self.target_fee_rate*1.01, resulting_ancestry_fee_rate)
356
357        wallet.unloadwallet()
358
359    # Test that new transaction ignores sibling transaction with low feerate
360    def test_sibling_tx_gets_ignored(self):
361        self.log.info("Start test where a low-fee sibling tx gets created and check that bumping ignores it")
362        wallet = self.setup_and_fund_wallet("ignore-sibling")
363
364        parent_txid = wallet.sendtoaddress(address=wallet.getnewaddress(), amount=1, fee_rate=2)
365        parent_tx = wallet.gettransaction(txid=parent_txid, verbose=True)
366
367        self.assert_undershoots_target(parent_tx)
368
369        # create sibling tx
370        sibling_txid = wallet.sendtoaddress(address=self.def_wallet.getnewaddress(), amount=0.9, fee_rate=1)
371        sibling_tx = wallet.gettransaction(txid=sibling_txid, verbose=True)
372        self.assert_undershoots_target(sibling_tx)
373
374        # spend both outputs from parent transaction
375        ancestor_aware_txid = wallet.sendtoaddress(address=self.def_wallet.getnewaddress(), amount=0.5, fee_rate=self.target_fee_rate)
376        ancestor_aware_tx = wallet.gettransaction(txid=ancestor_aware_txid, verbose=True)
377
378        self.assert_spends_only_parents(ancestor_aware_tx, [parent_txid])
379
380        self.assert_beats_target(ancestor_aware_tx)
381        resulting_ancestry_fee_rate = self.calc_set_fee_rate([parent_tx, ancestor_aware_tx])
382        assert_greater_than_or_equal(resulting_ancestry_fee_rate, self.target_fee_rate)
383        assert_greater_than_or_equal(self.target_fee_rate*1.01, resulting_ancestry_fee_rate)
384
385        wallet.unloadwallet()
386
387    # Test that new transaction only pays for itself when high feerate sibling pays for parent
388    def test_sibling_tx_bumps_parent(self):
389        self.log.info("Start test where a high-fee sibling tx bumps the parent")
390        wallet = self.setup_and_fund_wallet("generous-sibling")
391
392        parent_txid = wallet.sendtoaddress(address=wallet.getnewaddress(), amount=1, fee_rate=1)
393        parent_tx = wallet.gettransaction(txid=parent_txid, verbose=True)
394        self.assert_undershoots_target(parent_tx)
395
396        # create sibling tx
397        sibling_txid = wallet.sendtoaddress(address=self.def_wallet.getnewaddress(), amount=0.9, fee_rate=3*self.target_fee_rate)
398        sibling_tx = wallet.gettransaction(txid=sibling_txid, verbose=True)
399        self.assert_beats_target(sibling_tx)
400
401        # spend both outputs from parent transaction
402        ancestor_aware_txid = wallet.sendtoaddress(address=self.def_wallet.getnewaddress(), amount=0.5, fee_rate=self.target_fee_rate)
403        ancestor_aware_tx = wallet.gettransaction(txid=ancestor_aware_txid, verbose=True)
404
405        self.assert_spends_only_parents(ancestor_aware_tx, [parent_txid])
406
407        self.assert_beats_target(ancestor_aware_tx)
408        # Child is only paying for itself…
409        resulting_fee_rate = self.calc_fee_rate(ancestor_aware_tx)
410        assert_greater_than_or_equal(1.05 * self.target_fee_rate, resulting_fee_rate)
411        # …because sibling bumped to parent to ~50 s/vB, while our target is 30 s/vB
412        resulting_ancestry_fee_rate_sibling = self.calc_set_fee_rate([parent_tx, sibling_tx])
413        assert_greater_than_or_equal(resulting_ancestry_fee_rate_sibling, self.target_fee_rate)
414        # and our resulting "ancestry feerate" is therefore BELOW target feerate
415        resulting_ancestry_fee_rate = self.calc_set_fee_rate([parent_tx, ancestor_aware_tx])
416        assert_greater_than_or_equal(self.target_fee_rate, resulting_ancestry_fee_rate)
417
418        wallet.unloadwallet()
419
420    # Spend a confirmed and an unconfirmed input at the same time
421    def test_confirmed_and_unconfirmed_parent(self):
422        self.log.info("Start test with one unconfirmed and one confirmed input")
423        wallet = self.setup_and_fund_wallet("confirmed_and_unconfirmed_wallet")
424        confirmed_parent_txid = wallet.sendtoaddress(address=wallet.getnewaddress(), amount=1, fee_rate=self.target_fee_rate)
425        self.generate(self.nodes[0], 1) # Wallet has two confirmed UTXOs of ~1BTC each
426        unconfirmed_parent_txid = wallet.sendtoaddress(address=wallet.getnewaddress(), amount=0.5, fee_rate=0.5*self.target_fee_rate)
427
428        # wallet has one confirmed UTXO of 1BTC and two unconfirmed UTXOs of ~0.5BTC each
429        ancestor_aware_txid = wallet.sendtoaddress(address=self.def_wallet.getnewaddress(), amount=1.4, fee_rate=self.target_fee_rate)
430        ancestor_aware_tx = wallet.gettransaction(txid=ancestor_aware_txid, verbose=True)
431        self.assert_spends_only_parents(ancestor_aware_tx, [confirmed_parent_txid, unconfirmed_parent_txid])
432        resulting_fee_rate = self.calc_fee_rate(ancestor_aware_tx)
433        assert_greater_than_or_equal(resulting_fee_rate, self.target_fee_rate)
434
435        wallet.unloadwallet()
436
437    def test_external_input_unconfirmed_low(self):
438        self.log.info("Send funds to an external wallet then build tx that bumps parent by spending external input")
439        wallet = self.setup_and_fund_wallet("test_external_wallet")
440
441        external_address = self.def_wallet.getnewaddress()
442        address_info = self.def_wallet.getaddressinfo(external_address)
443        external_descriptor = address_info["desc"]
444        parent_txid = wallet.sendtoaddress(address=external_address, amount=1, fee_rate=1)
445        parent_tx = wallet.gettransaction(txid=parent_txid, verbose=True)
446
447        self.assert_undershoots_target(parent_tx)
448
449        spend_res = wallet.send(outputs=[{self.def_wallet.getnewaddress(): 0.5}], fee_rate=self.target_fee_rate, options={"inputs":[{"txid":parent_txid, "vout":find_vout_for_address(self.nodes[0], parent_txid, external_address)}], "solving_data":{"descriptors":[external_descriptor]}})
450        signed_psbt = self.def_wallet.walletprocesspsbt(spend_res["psbt"])
451        external_tx = self.def_wallet.finalizepsbt(signed_psbt["psbt"])
452        ancestor_aware_txid = self.def_wallet.sendrawtransaction(external_tx["hex"])
453
454        ancestor_aware_tx = self.def_wallet.gettransaction(txid=ancestor_aware_txid, verbose=True)
455
456        self.assert_spends_only_parents(ancestor_aware_tx, [parent_txid])
457
458        self.assert_beats_target(ancestor_aware_tx)
459        resulting_ancestry_fee_rate = self.calc_set_fee_rate([parent_tx, ancestor_aware_tx])
460        assert_greater_than_or_equal(resulting_ancestry_fee_rate, self.target_fee_rate)
461        assert_greater_than_or_equal(self.target_fee_rate*1.01, resulting_ancestry_fee_rate)
462
463        wallet.unloadwallet()
464
465
466    def run_test(self):
467        self.log.info("Starting UnconfirmedInputTest!")
468        self.target_fee_rate = 30
469        self.def_wallet  = self.nodes[0].get_wallet_rpc(self.default_wallet_name)
470        self.generate(self.nodes[0], 110)
471
472        self.test_target_feerate_confirmed()
473
474        self.test_target_feerate_unconfirmed_high()
475
476        self.test_target_feerate_unconfirmed_low()
477
478        self.test_chain_of_unconfirmed_low()
479
480        self.test_two_low_feerate_unconfirmed_parents()
481
482        self.test_mixed_feerate_unconfirmed_parents()
483
484        self.test_chain_of_high_low()
485
486        self.test_chain_of_high_low_below_target_feerate()
487
488        self.test_target_feerate_unconfirmed_low_sffo()
489
490        self.test_preset_input_cpfp()
491
492        self.test_rbf_bumping()
493
494        self.test_target_feerate_unconfirmed_low_overlapping_ancestry()
495
496        self.test_sibling_tx_gets_ignored()
497
498        self.test_sibling_tx_bumps_parent()
499
500        self.test_confirmed_and_unconfirmed_parent()