mirror of
https://github.com/bitcoin/bitcoin.git
synced 2024-11-20 02:25:40 +01:00
f18f9ef4d3
At the end of coin selection reduce the fees by the difference between the individual bump fee estimates and the collective bump fee estimate.
509 lines
26 KiB
Python
Executable File
509 lines
26 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
# Copyright (c) 2022 The Bitcoin Core developers
|
|
# Distributed under the MIT software license, see the accompanying
|
|
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
from decimal import Decimal, getcontext
|
|
|
|
from test_framework.test_framework import BitcoinTestFramework
|
|
from test_framework.util import (
|
|
assert_greater_than_or_equal,
|
|
assert_equal,
|
|
find_vout_for_address,
|
|
)
|
|
|
|
class UnconfirmedInputTest(BitcoinTestFramework):
|
|
def add_options(self, parser):
|
|
self.add_wallet_options(parser)
|
|
|
|
def set_test_params(self):
|
|
getcontext().prec=9
|
|
self.setup_clean_chain = True
|
|
self.num_nodes = 1
|
|
|
|
def setup_and_fund_wallet(self, walletname):
|
|
self.nodes[0].createwallet(walletname)
|
|
wallet = self.nodes[0].get_wallet_rpc(walletname)
|
|
|
|
self.def_wallet.sendtoaddress(address=wallet.getnewaddress(), amount=2)
|
|
self.generate(self.nodes[0], 1) # confirm funding tx
|
|
return wallet
|
|
|
|
def skip_test_if_missing_module(self):
|
|
self.skip_if_no_wallet()
|
|
|
|
def calc_fee_rate(self, tx):
|
|
fee = Decimal(-1e8) * tx["fee"]
|
|
vsize = tx["decoded"]["vsize"]
|
|
return fee / vsize
|
|
|
|
def calc_set_fee_rate(self, txs):
|
|
fees = Decimal(-1e8) * sum([tx["fee"] for tx in txs]) # fee is negative!
|
|
vsizes = sum([tx["decoded"]["vsize"] for tx in txs])
|
|
return fees / vsizes
|
|
|
|
def assert_spends_only_parents(self, tx, parent_txids):
|
|
parent_checklist = parent_txids.copy()
|
|
number_inputs = len(tx["decoded"]["vin"])
|
|
assert_equal(number_inputs, len(parent_txids))
|
|
for i in range(number_inputs):
|
|
txid_of_input = tx["decoded"]["vin"][i]["txid"]
|
|
assert txid_of_input in parent_checklist
|
|
parent_checklist.remove(txid_of_input)
|
|
|
|
def assert_undershoots_target(self, tx):
|
|
resulting_fee_rate = self.calc_fee_rate(tx)
|
|
assert_greater_than_or_equal(self.target_fee_rate, resulting_fee_rate)
|
|
|
|
def assert_beats_target(self, tx):
|
|
resulting_fee_rate = self.calc_fee_rate(tx)
|
|
assert_greater_than_or_equal(resulting_fee_rate, self.target_fee_rate)
|
|
|
|
# Meta-Test: try feerate testing function on confirmed UTXO
|
|
def test_target_feerate_confirmed(self):
|
|
self.log.info("Start test feerate with confirmed input")
|
|
wallet = self.setup_and_fund_wallet("confirmed_wallet")
|
|
|
|
ancestor_aware_txid = wallet.sendtoaddress(address=self.def_wallet.getnewaddress(), amount=0.5, fee_rate=self.target_fee_rate)
|
|
ancestor_aware_tx = wallet.gettransaction(txid=ancestor_aware_txid, verbose=True)
|
|
self.assert_beats_target(ancestor_aware_tx)
|
|
|
|
wallet.unloadwallet()
|
|
|
|
# Spend unconfirmed UTXO from high-feerate parent
|
|
def test_target_feerate_unconfirmed_high(self):
|
|
self.log.info("Start test feerate with high feerate unconfirmed input")
|
|
wallet = self.setup_and_fund_wallet("unconfirmed_high_wallet")
|
|
|
|
# Send unconfirmed transaction with high feerate to testing wallet
|
|
parent_txid = wallet.sendtoaddress(address=wallet.getnewaddress(), amount=1, fee_rate=3*self.target_fee_rate)
|
|
parent_tx = wallet.gettransaction(txid=parent_txid, verbose=True)
|
|
self.assert_beats_target(parent_tx)
|
|
|
|
ancestor_aware_txid = wallet.sendtoaddress(address=self.def_wallet.getnewaddress(), amount=0.5, fee_rate=self.target_fee_rate)
|
|
ancestor_aware_tx = wallet.gettransaction(txid=ancestor_aware_txid, verbose=True)
|
|
|
|
self.assert_spends_only_parents(ancestor_aware_tx, [parent_txid])
|
|
|
|
self.assert_beats_target(ancestor_aware_tx)
|
|
|
|
wallet.unloadwallet()
|
|
|
|
# Spend unconfirmed UTXO from low-feerate parent. Expect that parent gets
|
|
# bumped to target feerate.
|
|
def test_target_feerate_unconfirmed_low(self):
|
|
self.log.info("Start test feerate with low feerate unconfirmed input")
|
|
wallet = self.setup_and_fund_wallet("unconfirmed_low_wallet")
|
|
|
|
parent_txid = wallet.sendtoaddress(address=wallet.getnewaddress(), amount=1, fee_rate=1)
|
|
parent_tx = wallet.gettransaction(txid=parent_txid, verbose=True)
|
|
|
|
self.assert_undershoots_target(parent_tx)
|
|
|
|
ancestor_aware_txid = wallet.sendtoaddress(address=self.def_wallet.getnewaddress(), amount=0.5, fee_rate=self.target_fee_rate)
|
|
ancestor_aware_tx = wallet.gettransaction(txid=ancestor_aware_txid, verbose=True)
|
|
|
|
self.assert_spends_only_parents(ancestor_aware_tx, [parent_txid])
|
|
|
|
self.assert_beats_target(ancestor_aware_tx)
|
|
resulting_ancestry_fee_rate = self.calc_set_fee_rate([parent_tx, ancestor_aware_tx])
|
|
assert_greater_than_or_equal(resulting_ancestry_fee_rate, self.target_fee_rate)
|
|
assert_greater_than_or_equal(self.target_fee_rate*1.01, resulting_ancestry_fee_rate)
|
|
|
|
wallet.unloadwallet()
|
|
|
|
# Spend UTXO with unconfirmed low feerate parent and grandparent
|
|
# txs. Expect that both ancestors get bumped to target feerate.
|
|
def test_chain_of_unconfirmed_low(self):
|
|
self.log.info("Start test with parent and grandparent tx")
|
|
wallet = self.setup_and_fund_wallet("unconfirmed_low_chain_wallet")
|
|
|
|
grandparent_txid = wallet.sendtoaddress(address=wallet.getnewaddress(), amount=1.8, fee_rate=1)
|
|
gp_tx = wallet.gettransaction(txid=grandparent_txid, verbose=True)
|
|
|
|
self.assert_undershoots_target(gp_tx)
|
|
|
|
parent_txid = wallet.sendtoaddress(address=wallet.getnewaddress(), amount=1.5, fee_rate=2)
|
|
p_tx = wallet.gettransaction(txid=parent_txid, verbose=True)
|
|
|
|
self.assert_undershoots_target(p_tx)
|
|
|
|
ancestor_aware_txid = wallet.sendtoaddress(address=self.def_wallet.getnewaddress(), amount=1.3, fee_rate=self.target_fee_rate)
|
|
ancestor_aware_tx = wallet.gettransaction(txid=ancestor_aware_txid, verbose=True)
|
|
self.assert_spends_only_parents(ancestor_aware_tx, [parent_txid])
|
|
|
|
self.assert_beats_target(ancestor_aware_tx)
|
|
resulting_ancestry_fee_rate = self.calc_set_fee_rate([gp_tx, p_tx, ancestor_aware_tx])
|
|
assert_greater_than_or_equal(resulting_ancestry_fee_rate, self.target_fee_rate)
|
|
assert_greater_than_or_equal(self.target_fee_rate*1.01, resulting_ancestry_fee_rate)
|
|
|
|
wallet.unloadwallet()
|
|
|
|
# Spend unconfirmed UTXOs from two low feerate parent txs.
|
|
def test_two_low_feerate_unconfirmed_parents(self):
|
|
self.log.info("Start test with two unconfirmed parent txs")
|
|
wallet = self.setup_and_fund_wallet("two_parents_wallet")
|
|
|
|
# Add second UTXO to tested wallet
|
|
self.def_wallet.sendtoaddress(address=wallet.getnewaddress(), amount=2)
|
|
self.generate(self.nodes[0], 1) # confirm funding tx
|
|
|
|
parent_one_txid = wallet.sendtoaddress(address=wallet.getnewaddress(), amount=1.5, fee_rate=2)
|
|
p_one_tx = wallet.gettransaction(txid=parent_one_txid, verbose=True)
|
|
self.assert_undershoots_target(p_one_tx)
|
|
|
|
parent_two_txid = wallet.sendtoaddress(address=wallet.getnewaddress(), amount=1.5, fee_rate=1)
|
|
p_two_tx = wallet.gettransaction(txid=parent_two_txid, verbose=True)
|
|
self.assert_undershoots_target(p_two_tx)
|
|
|
|
ancestor_aware_txid = wallet.sendtoaddress(address=self.def_wallet.getnewaddress(), amount=2.8, fee_rate=self.target_fee_rate)
|
|
ancestor_aware_tx = wallet.gettransaction(txid=ancestor_aware_txid, verbose=True)
|
|
self.assert_spends_only_parents(ancestor_aware_tx, [parent_one_txid, parent_two_txid])
|
|
|
|
self.assert_beats_target(ancestor_aware_tx)
|
|
resulting_ancestry_fee_rate = self.calc_set_fee_rate([p_one_tx, p_two_tx, ancestor_aware_tx])
|
|
assert_greater_than_or_equal(resulting_ancestry_fee_rate, self.target_fee_rate)
|
|
assert_greater_than_or_equal(self.target_fee_rate*1.01, resulting_ancestry_fee_rate)
|
|
|
|
wallet.unloadwallet()
|
|
|
|
# Spend two unconfirmed inputs, one each from low and high feerate parents
|
|
def test_mixed_feerate_unconfirmed_parents(self):
|
|
self.log.info("Start test with two unconfirmed parent txs one of which has a higher feerate")
|
|
wallet = self.setup_and_fund_wallet("two_mixed_parents_wallet")
|
|
|
|
# Add second UTXO to tested wallet
|
|
self.def_wallet.sendtoaddress(address=wallet.getnewaddress(), amount=2)
|
|
self.generate(self.nodes[0], 1) # confirm funding tx
|
|
|
|
high_parent_txid = wallet.sendtoaddress(address=wallet.getnewaddress(), amount=1.5, fee_rate=self.target_fee_rate*2)
|
|
p_high_tx = wallet.gettransaction(txid=high_parent_txid, verbose=True)
|
|
# This time the parent is greater than the child
|
|
self.assert_beats_target(p_high_tx)
|
|
|
|
parent_low_txid = wallet.sendtoaddress(address=wallet.getnewaddress(), amount=1.5, fee_rate=1)
|
|
p_low_tx = wallet.gettransaction(txid=parent_low_txid, verbose=True)
|
|
# Other parent needs bump
|
|
self.assert_undershoots_target(p_low_tx)
|
|
|
|
ancestor_aware_txid = wallet.sendtoaddress(address=self.def_wallet.getnewaddress(), amount=2.8, fee_rate=self.target_fee_rate)
|
|
ancestor_aware_tx = wallet.gettransaction(txid=ancestor_aware_txid, verbose=True)
|
|
self.assert_spends_only_parents(ancestor_aware_tx, [parent_low_txid, high_parent_txid])
|
|
|
|
self.assert_beats_target(ancestor_aware_tx)
|
|
resulting_ancestry_fee_rate = self.calc_set_fee_rate([p_high_tx, p_low_tx, ancestor_aware_tx])
|
|
assert_greater_than_or_equal(resulting_ancestry_fee_rate, self.target_fee_rate)
|
|
|
|
resulting_bumped_ancestry_fee_rate = self.calc_set_fee_rate([p_low_tx, ancestor_aware_tx])
|
|
assert_greater_than_or_equal(resulting_bumped_ancestry_fee_rate, self.target_fee_rate)
|
|
assert_greater_than_or_equal(self.target_fee_rate*1.01, resulting_bumped_ancestry_fee_rate)
|
|
|
|
wallet.unloadwallet()
|
|
|
|
# Spend from chain with high feerate grandparent and low feerate parent
|
|
def test_chain_of_high_low(self):
|
|
self.log.info("Start test with low parent and high grandparent tx")
|
|
wallet = self.setup_and_fund_wallet("high_low_chain_wallet")
|
|
|
|
grandparent_txid = wallet.sendtoaddress(address=wallet.getnewaddress(), amount=1.8, fee_rate=self.target_fee_rate * 10)
|
|
gp_tx = wallet.gettransaction(txid=grandparent_txid, verbose=True)
|
|
# grandparent has higher feerate
|
|
self.assert_beats_target(gp_tx)
|
|
|
|
parent_txid = wallet.sendtoaddress(address=wallet.getnewaddress(), amount=1.5, fee_rate=1)
|
|
# parent is low feerate
|
|
p_tx = wallet.gettransaction(txid=parent_txid, verbose=True)
|
|
self.assert_undershoots_target(p_tx)
|
|
|
|
ancestor_aware_txid = wallet.sendtoaddress(address=self.def_wallet.getnewaddress(), amount=1.3, fee_rate=self.target_fee_rate)
|
|
ancestor_aware_tx = wallet.gettransaction(txid=ancestor_aware_txid, verbose=True)
|
|
self.assert_spends_only_parents(ancestor_aware_tx, [parent_txid])
|
|
|
|
self.assert_beats_target(ancestor_aware_tx)
|
|
resulting_ancestry_fee_rate = self.calc_set_fee_rate([p_tx, ancestor_aware_tx])
|
|
assert_greater_than_or_equal(resulting_ancestry_fee_rate, self.target_fee_rate)
|
|
assert_greater_than_or_equal(self.target_fee_rate*1.01, resulting_ancestry_fee_rate)
|
|
resulting_ancestry_fee_rate_with_high_feerate_gp = self.calc_set_fee_rate([gp_tx, p_tx, ancestor_aware_tx])
|
|
# Check that we bumped the parent without relying on the grandparent
|
|
assert_greater_than_or_equal(resulting_ancestry_fee_rate_with_high_feerate_gp, self.target_fee_rate*1.1)
|
|
|
|
wallet.unloadwallet()
|
|
|
|
# Spend UTXO from chain of unconfirmed transactions with low feerate
|
|
# grandparent and even lower feerate parent
|
|
def test_chain_of_high_low_below_target_feerate(self):
|
|
self.log.info("Start test with low parent and higher low grandparent tx")
|
|
wallet = self.setup_and_fund_wallet("low_and_lower_chain_wallet")
|
|
|
|
grandparent_txid = wallet.sendtoaddress(address=wallet.getnewaddress(), amount=1.8, fee_rate=5)
|
|
gp_tx = wallet.gettransaction(txid=grandparent_txid, verbose=True)
|
|
|
|
# grandparent has higher feerate, but below target
|
|
self.assert_undershoots_target(gp_tx)
|
|
|
|
parent_txid = wallet.sendtoaddress(address=wallet.getnewaddress(), amount=1.5, fee_rate=1)
|
|
p_tx = wallet.gettransaction(txid=parent_txid, verbose=True)
|
|
# parent even lower
|
|
self.assert_undershoots_target(p_tx)
|
|
|
|
ancestor_aware_txid = wallet.sendtoaddress(address=self.def_wallet.getnewaddress(), amount=1.3, fee_rate=self.target_fee_rate)
|
|
ancestor_aware_tx = wallet.gettransaction(txid=ancestor_aware_txid, verbose=True)
|
|
self.assert_spends_only_parents(ancestor_aware_tx, [parent_txid])
|
|
|
|
self.assert_beats_target(ancestor_aware_tx)
|
|
resulting_ancestry_fee_rate = self.calc_set_fee_rate([gp_tx, p_tx, ancestor_aware_tx])
|
|
assert_greater_than_or_equal(resulting_ancestry_fee_rate, self.target_fee_rate)
|
|
assert_greater_than_or_equal(self.target_fee_rate*1.01, resulting_ancestry_fee_rate)
|
|
|
|
wallet.unloadwallet()
|
|
|
|
# Test fee calculation when bumping while using subtract fee from output (SFFO)
|
|
def test_target_feerate_unconfirmed_low_sffo(self):
|
|
self.log.info("Start test feerate with low feerate unconfirmed input, while subtracting from output")
|
|
wallet = self.setup_and_fund_wallet("unconfirmed_low_wallet_sffo")
|
|
|
|
parent_txid = wallet.sendtoaddress(address=wallet.getnewaddress(), amount=1, fee_rate=1)
|
|
parent_tx = wallet.gettransaction(txid=parent_txid, verbose=True)
|
|
|
|
self.assert_undershoots_target(parent_tx)
|
|
|
|
ancestor_aware_txid = wallet.sendtoaddress(address=self.def_wallet.getnewaddress(), amount=0.5, fee_rate=self.target_fee_rate, subtractfeefromamount=True)
|
|
ancestor_aware_tx = wallet.gettransaction(txid=ancestor_aware_txid, verbose=True)
|
|
|
|
self.assert_spends_only_parents(ancestor_aware_tx, [parent_txid])
|
|
|
|
self.assert_beats_target(ancestor_aware_tx)
|
|
resulting_ancestry_fee_rate = self.calc_set_fee_rate([parent_tx, ancestor_aware_tx])
|
|
assert_greater_than_or_equal(resulting_ancestry_fee_rate, self.target_fee_rate)
|
|
assert_greater_than_or_equal(self.target_fee_rate*1.01, resulting_ancestry_fee_rate)
|
|
|
|
wallet.unloadwallet()
|
|
|
|
# Test that parents of preset unconfirmed inputs get cpfp'ed
|
|
def test_preset_input_cpfp(self):
|
|
self.log.info("Start test with preset input from low feerate unconfirmed transaction")
|
|
wallet = self.setup_and_fund_wallet("preset_input")
|
|
|
|
parent_txid = wallet.sendtoaddress(address=wallet.getnewaddress(), amount=1, fee_rate=1)
|
|
parent_tx = wallet.gettransaction(txid=parent_txid, verbose=True)
|
|
|
|
self.assert_undershoots_target(parent_tx)
|
|
|
|
number_outputs = len(parent_tx["decoded"]["vout"])
|
|
assert_equal(number_outputs, 2)
|
|
|
|
# we don't care which of the two outputs we spent, they're both ours
|
|
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"]
|
|
ancestor_aware_tx = wallet.gettransaction(txid=ancestor_aware_txid, verbose=True)
|
|
|
|
self.assert_spends_only_parents(ancestor_aware_tx, [parent_txid])
|
|
|
|
self.assert_beats_target(ancestor_aware_tx)
|
|
resulting_ancestry_fee_rate = self.calc_set_fee_rate([parent_tx, ancestor_aware_tx])
|
|
assert_greater_than_or_equal(resulting_ancestry_fee_rate, self.target_fee_rate)
|
|
assert_greater_than_or_equal(self.target_fee_rate*1.01, resulting_ancestry_fee_rate)
|
|
|
|
wallet.unloadwallet()
|
|
|
|
# Test that RBFing a transaction with unconfirmed input gets the right feerate
|
|
def test_rbf_bumping(self):
|
|
self.log.info("Start test to rbf a transaction unconfirmed input to bump it")
|
|
wallet = self.setup_and_fund_wallet("bump")
|
|
|
|
parent_txid = wallet.sendtoaddress(address=wallet.getnewaddress(), amount=1, fee_rate=1)
|
|
parent_tx = wallet.gettransaction(txid=parent_txid, verbose=True)
|
|
|
|
self.assert_undershoots_target(parent_tx)
|
|
|
|
to_be_rbfed_ancestor_aware_txid = wallet.sendtoaddress(address=self.def_wallet.getnewaddress(), amount=0.5, fee_rate=self.target_fee_rate)
|
|
ancestor_aware_tx = wallet.gettransaction(txid=to_be_rbfed_ancestor_aware_txid, verbose=True)
|
|
|
|
self.assert_spends_only_parents(ancestor_aware_tx, [parent_txid])
|
|
|
|
self.assert_beats_target(ancestor_aware_tx)
|
|
resulting_ancestry_fee_rate = self.calc_set_fee_rate([parent_tx, ancestor_aware_tx])
|
|
assert_greater_than_or_equal(resulting_ancestry_fee_rate, self.target_fee_rate)
|
|
assert_greater_than_or_equal(self.target_fee_rate*1.01, resulting_ancestry_fee_rate)
|
|
|
|
bumped_ancestor_aware_txid = wallet.bumpfee(txid=to_be_rbfed_ancestor_aware_txid, options={"fee_rate": self.target_fee_rate * 2} )["txid"]
|
|
bumped_ancestor_aware_tx = wallet.gettransaction(txid=bumped_ancestor_aware_txid, verbose=True)
|
|
self.assert_spends_only_parents(ancestor_aware_tx, [parent_txid])
|
|
|
|
resulting_bumped_fee_rate = self.calc_fee_rate(bumped_ancestor_aware_tx)
|
|
assert_greater_than_or_equal(resulting_bumped_fee_rate, 2*self.target_fee_rate)
|
|
resulting_bumped_ancestry_fee_rate = self.calc_set_fee_rate([parent_tx, bumped_ancestor_aware_tx])
|
|
assert_greater_than_or_equal(resulting_bumped_ancestry_fee_rate, 2*self.target_fee_rate)
|
|
assert_greater_than_or_equal(2*self.target_fee_rate*1.01, resulting_bumped_ancestry_fee_rate)
|
|
|
|
wallet.unloadwallet()
|
|
|
|
# Test that transaction spending two UTXOs with overlapping ancestry does not bump shared ancestors twice
|
|
def test_target_feerate_unconfirmed_low_overlapping_ancestry(self):
|
|
self.log.info("Start test where two UTXOs have overlapping ancestry")
|
|
wallet = self.setup_and_fund_wallet("overlapping_ancestry_wallet")
|
|
|
|
parent_txid = wallet.sendtoaddress(address=wallet.getnewaddress(), amount=1, fee_rate=1)
|
|
two_output_parent_tx = wallet.gettransaction(txid=parent_txid, verbose=True)
|
|
|
|
self.assert_undershoots_target(two_output_parent_tx)
|
|
|
|
# spend both outputs from parent transaction
|
|
ancestor_aware_txid = wallet.sendtoaddress(address=self.def_wallet.getnewaddress(), amount=1.5, fee_rate=self.target_fee_rate)
|
|
ancestor_aware_tx = wallet.gettransaction(txid=ancestor_aware_txid, verbose=True)
|
|
self.assert_spends_only_parents(ancestor_aware_tx, [parent_txid, parent_txid])
|
|
|
|
self.assert_beats_target(ancestor_aware_tx)
|
|
resulting_ancestry_fee_rate = self.calc_set_fee_rate([two_output_parent_tx, ancestor_aware_tx])
|
|
assert_greater_than_or_equal(resulting_ancestry_fee_rate, self.target_fee_rate)
|
|
assert_greater_than_or_equal(self.target_fee_rate*1.01, resulting_ancestry_fee_rate)
|
|
|
|
wallet.unloadwallet()
|
|
|
|
# Test that new transaction ignores sibling transaction with low feerate
|
|
def test_sibling_tx_gets_ignored(self):
|
|
self.log.info("Start test where a low-fee sibling tx gets created and check that bumping ignores it")
|
|
wallet = self.setup_and_fund_wallet("ignore-sibling")
|
|
|
|
parent_txid = wallet.sendtoaddress(address=wallet.getnewaddress(), amount=1, fee_rate=2)
|
|
parent_tx = wallet.gettransaction(txid=parent_txid, verbose=True)
|
|
|
|
self.assert_undershoots_target(parent_tx)
|
|
|
|
# create sibling tx
|
|
sibling_txid = wallet.sendtoaddress(address=self.def_wallet.getnewaddress(), amount=0.9, fee_rate=1)
|
|
sibling_tx = wallet.gettransaction(txid=sibling_txid, verbose=True)
|
|
self.assert_undershoots_target(sibling_tx)
|
|
|
|
# spend both outputs from parent transaction
|
|
ancestor_aware_txid = wallet.sendtoaddress(address=self.def_wallet.getnewaddress(), amount=0.5, fee_rate=self.target_fee_rate)
|
|
ancestor_aware_tx = wallet.gettransaction(txid=ancestor_aware_txid, verbose=True)
|
|
|
|
self.assert_spends_only_parents(ancestor_aware_tx, [parent_txid])
|
|
|
|
self.assert_beats_target(ancestor_aware_tx)
|
|
resulting_ancestry_fee_rate = self.calc_set_fee_rate([parent_tx, ancestor_aware_tx])
|
|
assert_greater_than_or_equal(resulting_ancestry_fee_rate, self.target_fee_rate)
|
|
assert_greater_than_or_equal(self.target_fee_rate*1.01, resulting_ancestry_fee_rate)
|
|
|
|
wallet.unloadwallet()
|
|
|
|
# Test that new transaction only pays for itself when high feerate sibling pays for parent
|
|
def test_sibling_tx_bumps_parent(self):
|
|
self.log.info("Start test where a high-fee sibling tx bumps the parent")
|
|
wallet = self.setup_and_fund_wallet("generous-sibling")
|
|
|
|
parent_txid = wallet.sendtoaddress(address=wallet.getnewaddress(), amount=1, fee_rate=1)
|
|
parent_tx = wallet.gettransaction(txid=parent_txid, verbose=True)
|
|
self.assert_undershoots_target(parent_tx)
|
|
|
|
# create sibling tx
|
|
sibling_txid = wallet.sendtoaddress(address=self.def_wallet.getnewaddress(), amount=0.9, fee_rate=3*self.target_fee_rate)
|
|
sibling_tx = wallet.gettransaction(txid=sibling_txid, verbose=True)
|
|
self.assert_beats_target(sibling_tx)
|
|
|
|
# spend both outputs from parent transaction
|
|
ancestor_aware_txid = wallet.sendtoaddress(address=self.def_wallet.getnewaddress(), amount=0.5, fee_rate=self.target_fee_rate)
|
|
ancestor_aware_tx = wallet.gettransaction(txid=ancestor_aware_txid, verbose=True)
|
|
|
|
self.assert_spends_only_parents(ancestor_aware_tx, [parent_txid])
|
|
|
|
self.assert_beats_target(ancestor_aware_tx)
|
|
# Child is only paying for itself…
|
|
resulting_fee_rate = self.calc_fee_rate(ancestor_aware_tx)
|
|
assert_greater_than_or_equal(1.05 * self.target_fee_rate, resulting_fee_rate)
|
|
# …because sibling bumped to parent to ~50 s/vB, while our target is 30 s/vB
|
|
resulting_ancestry_fee_rate_sibling = self.calc_set_fee_rate([parent_tx, sibling_tx])
|
|
assert_greater_than_or_equal(resulting_ancestry_fee_rate_sibling, self.target_fee_rate)
|
|
# and our resulting "ancestry feerate" is therefore BELOW target feerate
|
|
resulting_ancestry_fee_rate = self.calc_set_fee_rate([parent_tx, ancestor_aware_tx])
|
|
assert_greater_than_or_equal(self.target_fee_rate, resulting_ancestry_fee_rate)
|
|
|
|
wallet.unloadwallet()
|
|
|
|
# Spend a confirmed and an unconfirmed input at the same time
|
|
def test_confirmed_and_unconfirmed_parent(self):
|
|
self.log.info("Start test with one unconfirmed and one confirmed input")
|
|
wallet = self.setup_and_fund_wallet("confirmed_and_unconfirmed_wallet")
|
|
confirmed_parent_txid = wallet.sendtoaddress(address=wallet.getnewaddress(), amount=1, fee_rate=self.target_fee_rate)
|
|
self.generate(self.nodes[0], 1) # Wallet has two confirmed UTXOs of ~1BTC each
|
|
unconfirmed_parent_txid = wallet.sendtoaddress(address=wallet.getnewaddress(), amount=0.5, fee_rate=0.5*self.target_fee_rate)
|
|
|
|
# wallet has one confirmed UTXO of 1BTC and two unconfirmed UTXOs of ~0.5BTC each
|
|
ancestor_aware_txid = wallet.sendtoaddress(address=self.def_wallet.getnewaddress(), amount=1.4, fee_rate=self.target_fee_rate)
|
|
ancestor_aware_tx = wallet.gettransaction(txid=ancestor_aware_txid, verbose=True)
|
|
self.assert_spends_only_parents(ancestor_aware_tx, [confirmed_parent_txid, unconfirmed_parent_txid])
|
|
resulting_fee_rate = self.calc_fee_rate(ancestor_aware_tx)
|
|
assert_greater_than_or_equal(resulting_fee_rate, self.target_fee_rate)
|
|
|
|
wallet.unloadwallet()
|
|
|
|
def test_external_input_unconfirmed_low(self):
|
|
self.log.info("Send funds to an external wallet then build tx that bumps parent by spending external input")
|
|
wallet = self.setup_and_fund_wallet("test_external_wallet")
|
|
|
|
external_address = self.def_wallet.getnewaddress()
|
|
address_info = self.def_wallet.getaddressinfo(external_address)
|
|
external_descriptor = address_info["desc"]
|
|
parent_txid = wallet.sendtoaddress(address=external_address, amount=1, fee_rate=1)
|
|
parent_tx = wallet.gettransaction(txid=parent_txid, verbose=True)
|
|
|
|
self.assert_undershoots_target(parent_tx)
|
|
|
|
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]}})
|
|
signed_psbt = self.def_wallet.walletprocesspsbt(spend_res["psbt"])
|
|
external_tx = self.def_wallet.finalizepsbt(signed_psbt["psbt"])
|
|
ancestor_aware_txid = self.def_wallet.sendrawtransaction(external_tx["hex"])
|
|
|
|
ancestor_aware_tx = self.def_wallet.gettransaction(txid=ancestor_aware_txid, verbose=True)
|
|
|
|
self.assert_spends_only_parents(ancestor_aware_tx, [parent_txid])
|
|
|
|
self.assert_beats_target(ancestor_aware_tx)
|
|
resulting_ancestry_fee_rate = self.calc_set_fee_rate([parent_tx, ancestor_aware_tx])
|
|
assert_greater_than_or_equal(resulting_ancestry_fee_rate, self.target_fee_rate)
|
|
assert_greater_than_or_equal(self.target_fee_rate*1.01, resulting_ancestry_fee_rate)
|
|
|
|
wallet.unloadwallet()
|
|
|
|
|
|
def run_test(self):
|
|
self.log.info("Starting UnconfirmedInputTest!")
|
|
self.target_fee_rate = 30
|
|
self.def_wallet = self.nodes[0].get_wallet_rpc(self.default_wallet_name)
|
|
self.generate(self.nodes[0], 110)
|
|
|
|
self.test_target_feerate_confirmed()
|
|
|
|
self.test_target_feerate_unconfirmed_high()
|
|
|
|
self.test_target_feerate_unconfirmed_low()
|
|
|
|
self.test_chain_of_unconfirmed_low()
|
|
|
|
self.test_two_low_feerate_unconfirmed_parents()
|
|
|
|
self.test_mixed_feerate_unconfirmed_parents()
|
|
|
|
self.test_chain_of_high_low()
|
|
|
|
self.test_chain_of_high_low_below_target_feerate()
|
|
|
|
self.test_target_feerate_unconfirmed_low_sffo()
|
|
|
|
self.test_preset_input_cpfp()
|
|
|
|
self.test_rbf_bumping()
|
|
|
|
self.test_target_feerate_unconfirmed_low_overlapping_ancestry()
|
|
|
|
self.test_sibling_tx_gets_ignored()
|
|
|
|
self.test_sibling_tx_bumps_parent()
|
|
|
|
self.test_confirmed_and_unconfirmed_parent()
|
|
|
|
self.test_external_input_unconfirmed_low()
|
|
|
|
if __name__ == '__main__':
|
|
UnconfirmedInputTest().main()
|