mirror of
https://github.com/ElementsProject/elements.git
synced 2026-08-18 13:17:55 +02:00
Merge 5639d71a07 into merged_master (Bitcoin PR #16293)
This commit is contained in:
Andrew Poelstra
commit
224becc171
1 changed files with 92 additions and 65 deletions
|
|
@ -42,11 +42,11 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
connect_nodes_bi(self.nodes, 0, 3)
|
||||
|
||||
def run_test(self):
|
||||
min_relay_tx_fee = self.nodes[0].getnetworkinfo()['relayfee']
|
||||
self.min_relay_tx_fee = self.nodes[0].getnetworkinfo()['relayfee']
|
||||
# This test is not meant to test fee estimation and we'd like
|
||||
# to be sure all txs are sent at a consistent desired feerate
|
||||
for node in self.nodes:
|
||||
node.settxfee(min_relay_tx_fee)
|
||||
node.settxfee(self.min_relay_tx_fee)
|
||||
|
||||
# if the fee's positive delta is higher than this value tests will fail,
|
||||
# neg. delta always fail the tests.
|
||||
|
|
@ -54,7 +54,7 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
# than a minimum sized signature.
|
||||
|
||||
# = 2 bytes * minRelayTxFeePerByte
|
||||
feeTolerance = 2 * min_relay_tx_fee/1000
|
||||
self.fee_tolerance = 2 * self.min_relay_tx_fee/1000
|
||||
# ELEMENTS NOTE: fee deltas will be negative due to blinding and no blinding in rawtransaction
|
||||
|
||||
self.nodes[2].generate(1)
|
||||
|
|
@ -62,6 +62,36 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
self.nodes[0].generate(121)
|
||||
self.sync_all()
|
||||
|
||||
self.test_change_position()
|
||||
self.test_simple()
|
||||
self.test_simple_two_coins()
|
||||
self.test_simple_two_outputs()
|
||||
self.test_change()
|
||||
self.test_no_change()
|
||||
self.test_invalid_option()
|
||||
self.test_invalid_change_address()
|
||||
self.test_valid_change_address()
|
||||
self.test_change_type()
|
||||
self.test_coin_selection()
|
||||
self.test_two_vin()
|
||||
self.test_two_vin_two_vout()
|
||||
self.test_invalid_input()
|
||||
self.test_fee_p2pkh()
|
||||
self.test_fee_p2pkh_multi_out()
|
||||
self.test_fee_p2sh()
|
||||
self.test_fee_4of5()
|
||||
self.test_spend_2of2()
|
||||
self.test_locked_wallet()
|
||||
self.test_many_inputs_fee()
|
||||
self.test_many_inputs_send()
|
||||
self.test_op_return()
|
||||
self.test_watchonly()
|
||||
self.test_all_watched_funds()
|
||||
self.test_option_feerate()
|
||||
self.test_address_reuse()
|
||||
self.test_option_subtract_fee_from_outputs()
|
||||
|
||||
def test_change_position(self):
|
||||
# ensure that setting changePosition in fundraw with an exact match is handled properly
|
||||
rawmatch = self.nodes[2].createrawtransaction([], {self.nodes[2].getnewaddress():50})
|
||||
rawmatch = self.nodes[2].fundrawtransaction(rawmatch, {"changePosition":1, "subtractFeeFromOutputs":[0]})
|
||||
|
|
@ -70,16 +100,16 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
watchonly_address = self.nodes[0].getnewaddress()
|
||||
watchonly_pubkey = self.nodes[0].getaddressinfo(watchonly_address)["pubkey"]
|
||||
watchonly_blindingkey = self.nodes[0].dumpblindingkey(watchonly_address)
|
||||
watchonly_amount = Decimal(200)
|
||||
self.watchonly_amount = Decimal(200)
|
||||
self.nodes[3].importpubkey(watchonly_pubkey, "", True)
|
||||
self.nodes[3].importblindingkey(watchonly_address, watchonly_blindingkey)
|
||||
watchonly_txid = self.nodes[0].sendtoaddress(watchonly_address, watchonly_amount)
|
||||
self.watchonly_txid = self.nodes[0].sendtoaddress(watchonly_address, self.watchonly_amount)
|
||||
|
||||
# Lock UTXO so nodes[0] doesn't accidentally spend it
|
||||
watchonly_vout = find_vout_for_address(self.nodes[0], watchonly_txid, watchonly_address)
|
||||
self.nodes[0].lockunspent(False, [{"txid": watchonly_txid, "vout": watchonly_vout}])
|
||||
self.watchonly_vout = find_vout_for_address(self.nodes[0], self.watchonly_txid, watchonly_address)
|
||||
self.nodes[0].lockunspent(False, [{"txid": self.watchonly_txid, "vout": self.watchonly_vout}])
|
||||
|
||||
self.nodes[0].sendtoaddress(self.nodes[3].getnewaddress(), watchonly_amount / 10)
|
||||
self.nodes[0].sendtoaddress(self.nodes[3].getnewaddress(), self.watchonly_amount / 10)
|
||||
|
||||
self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 1.5)
|
||||
self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 1.0)
|
||||
|
|
@ -88,6 +118,7 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
self.nodes[0].generate(1)
|
||||
self.sync_all()
|
||||
|
||||
def test_simple(self):
|
||||
###############
|
||||
# simple test #
|
||||
###############
|
||||
|
|
@ -96,10 +127,10 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
|
||||
dec_tx = self.nodes[2].decoderawtransaction(rawtx)
|
||||
rawtxfund = self.nodes[2].fundrawtransaction(rawtx)
|
||||
fee = rawtxfund['fee']
|
||||
dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
|
||||
assert len(dec_tx['vin']) > 0 #test that we have enough inputs
|
||||
|
||||
def test_simple_two_coins(self):
|
||||
##############################
|
||||
# simple test with two coins #
|
||||
##############################
|
||||
|
|
@ -109,25 +140,11 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
dec_tx = self.nodes[2].decoderawtransaction(rawtx)
|
||||
|
||||
rawtxfund = self.nodes[2].fundrawtransaction(rawtx)
|
||||
fee = rawtxfund['fee']
|
||||
dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
|
||||
assert len(dec_tx['vin']) > 0 #test if we have enough inputs
|
||||
|
||||
##############################
|
||||
# simple test with two coins #
|
||||
##############################
|
||||
inputs = [ ]
|
||||
outputs = { self.nodes[0].getnewaddress() : 2.6 }
|
||||
rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
|
||||
dec_tx = self.nodes[2].decoderawtransaction(rawtx)
|
||||
|
||||
rawtxfund = self.nodes[2].fundrawtransaction(rawtx)
|
||||
fee = rawtxfund['fee']
|
||||
dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
|
||||
assert len(dec_tx['vin']) > 0
|
||||
assert_equal(dec_tx['vin'][0]['scriptSig']['hex'], '')
|
||||
|
||||
|
||||
def test_simple_two_outputs(self):
|
||||
################################
|
||||
# simple test with two outputs #
|
||||
################################
|
||||
|
|
@ -137,7 +154,6 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
dec_tx = self.nodes[2].decoderawtransaction(rawtx)
|
||||
|
||||
rawtxfund = self.nodes[2].fundrawtransaction(rawtx)
|
||||
fee = rawtxfund['fee']
|
||||
dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
|
||||
totalOut = 0
|
||||
for out in dec_tx['vout']:
|
||||
|
|
@ -146,7 +162,7 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
assert len(dec_tx['vin']) > 0
|
||||
assert_equal(dec_tx['vin'][0]['scriptSig']['hex'], '')
|
||||
|
||||
|
||||
def test_change(self):
|
||||
#########################################################################
|
||||
# test a fundrawtransaction with a VIN greater than the required amount #
|
||||
#########################################################################
|
||||
|
|
@ -160,6 +176,7 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
|
||||
rawtxfund = self.nodes[2].fundrawtransaction(rawtx)
|
||||
fee = rawtxfund['fee']
|
||||
self.test_no_change_fee = fee # Use the same fee for the next tx
|
||||
dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
|
||||
totalOut = 0
|
||||
for out in dec_tx['vout']:
|
||||
|
|
@ -169,14 +186,14 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
|
||||
assert_equal(fee + totalOut, utx['amount']) #compare vin total and totalout+fee
|
||||
|
||||
|
||||
def test_no_change(self):
|
||||
#####################################################################
|
||||
# test a fundrawtransaction with which will not get a change output #
|
||||
#####################################################################
|
||||
utx = get_unspent(self.nodes[2].listunspent(), 5)
|
||||
|
||||
inputs = [ {'txid' : utx['txid'], 'vout' : utx['vout']}]
|
||||
outputs = { self.nodes[0].getnewaddress() : Decimal(5.0) - fee - feeTolerance }
|
||||
outputs = {self.nodes[0].getnewaddress(): Decimal(5.0) - self.test_no_change_fee - self.fee_tolerance}
|
||||
rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
|
||||
dec_tx = self.nodes[2].decoderawtransaction(rawtx)
|
||||
assert_equal(utx['txid'], dec_tx['vin'][0]['txid'])
|
||||
|
|
@ -193,7 +210,7 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
assert_equal(rawtxfund['changepos'], -1)
|
||||
assert_equal(fee + totalOut, utx['amount']) #compare vin total and totalout+fee
|
||||
|
||||
|
||||
def test_invalid_option(self):
|
||||
####################################################
|
||||
# test a fundrawtransaction with an invalid option #
|
||||
####################################################
|
||||
|
|
@ -210,6 +227,7 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
# reserveChangeKey was deprecated and is now removed
|
||||
assert_raises_rpc_error(-3, "Unexpected key reserveChangeKey", lambda: self.nodes[2].fundrawtransaction(hexstring=rawtx, options={'reserveChangeKey': True}))
|
||||
|
||||
def test_invalid_change_address(self):
|
||||
############################################################
|
||||
# test a fundrawtransaction with an invalid change address #
|
||||
############################################################
|
||||
|
|
@ -223,6 +241,7 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
|
||||
assert_raises_rpc_error(-5, "changeAddress must be a valid bitcoin address", self.nodes[2].fundrawtransaction, rawtx, {'changeAddress':'foobar'})
|
||||
|
||||
def test_valid_change_address(self):
|
||||
############################################################
|
||||
# test a fundrawtransaction with a provided change address #
|
||||
############################################################
|
||||
|
|
@ -242,6 +261,7 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
out = dec_tx['vout'][0]
|
||||
assert_equal(change, out['scriptPubKey']['addresses'][0])
|
||||
|
||||
def test_change_type(self):
|
||||
#########################################################
|
||||
# test a fundrawtransaction with a provided change type #
|
||||
#########################################################
|
||||
|
|
@ -256,6 +276,7 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
dec_tx = self.nodes[2].decoderawtransaction(rawtx['hex'])
|
||||
assert_equal('witness_v0_keyhash', dec_tx['vout'][rawtx['changepos']]['scriptPubKey']['type'])
|
||||
|
||||
def test_coin_selection(self):
|
||||
#########################################################################
|
||||
# test a fundrawtransaction with a VIN smaller than the required amount #
|
||||
#########################################################################
|
||||
|
|
@ -274,7 +295,6 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
assert_equal("00", dec_tx['vin'][0]['scriptSig']['hex'])
|
||||
|
||||
rawtxfund = self.nodes[2].fundrawtransaction(rawtx)
|
||||
fee = rawtxfund['fee']
|
||||
dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
|
||||
totalOut = 0
|
||||
matchingOuts = 0
|
||||
|
|
@ -293,7 +313,7 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
assert_equal(matchingOuts, 1)
|
||||
assert_equal(len(dec_tx['vout']), 3)
|
||||
|
||||
|
||||
def test_two_vin(self):
|
||||
###########################################
|
||||
# test a fundrawtransaction with two VINs #
|
||||
###########################################
|
||||
|
|
@ -308,7 +328,6 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
assert_equal(utx['txid'], dec_tx['vin'][0]['txid'])
|
||||
|
||||
rawtxfund = self.nodes[2].fundrawtransaction(rawtx)
|
||||
fee = rawtxfund['fee']
|
||||
dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
|
||||
totalOut = 0
|
||||
matchingOuts = 0
|
||||
|
|
@ -330,6 +349,7 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
|
||||
assert_equal(matchingIns, 2) #we now must see two vins identical to vins given as params
|
||||
|
||||
def test_two_vin_two_vout(self):
|
||||
#########################################################
|
||||
# test a fundrawtransaction with two VINs and two vOUTs #
|
||||
#########################################################
|
||||
|
|
@ -344,7 +364,6 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
assert_equal(utx['txid'], dec_tx['vin'][0]['txid'])
|
||||
|
||||
rawtxfund = self.nodes[2].fundrawtransaction(rawtx)
|
||||
fee = rawtxfund['fee']
|
||||
dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
|
||||
totalOut = 0
|
||||
matchingOuts = 0
|
||||
|
|
@ -358,16 +377,16 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
assert_equal(matchingOuts, 2)
|
||||
assert_equal(len(dec_tx['vout']), 4)
|
||||
|
||||
def test_invalid_input(self):
|
||||
##############################################
|
||||
# test a fundrawtransaction with invalid vin #
|
||||
##############################################
|
||||
inputs = [ {'txid' : "1c7f966dab21119bac53213a2bc7532bff1fa844c124fd750a7d0b1332440bd1", 'vout' : 0} ] #invalid vin!
|
||||
outputs = { self.nodes[0].getnewaddress() : 1.0}
|
||||
rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
|
||||
dec_tx = self.nodes[2].decoderawtransaction(rawtx)
|
||||
|
||||
assert_raises_rpc_error(-4, "Insufficient funds", self.nodes[2].fundrawtransaction, rawtx)
|
||||
|
||||
def test_fee_p2pkh(self):
|
||||
############################################################
|
||||
#compare fee of a standard pubkeyhash transaction
|
||||
inputs = []
|
||||
|
|
@ -381,9 +400,10 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
|
||||
#compare fee
|
||||
feeDelta = Decimal(fundedTx['fee']) - Decimal(signedFee)
|
||||
assert feeDelta <= feeTolerance
|
||||
assert feeDelta <= self.fee_tolerance
|
||||
############################################################
|
||||
|
||||
def test_fee_p2pkh_multi_out(self):
|
||||
############################################################
|
||||
#compare fee of a standard pubkeyhash transaction with multiple outputs
|
||||
inputs = []
|
||||
|
|
@ -396,10 +416,10 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
|
||||
#compare fee
|
||||
feeDelta = Decimal(fundedTx['fee']) - Decimal(signedFee)
|
||||
assert feeDelta <= feeTolerance
|
||||
assert feeDelta <= self.fee_tolerance
|
||||
############################################################
|
||||
|
||||
|
||||
def test_fee_p2sh(self):
|
||||
############################################################
|
||||
#compare fee of a 2of2 multisig p2sh transaction
|
||||
|
||||
|
|
@ -423,10 +443,10 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
|
||||
#compare fee
|
||||
feeDelta = Decimal(fundedTx['fee']) - Decimal(signedFee)
|
||||
assert feeDelta <= feeTolerance
|
||||
assert feeDelta <= self.fee_tolerance
|
||||
############################################################
|
||||
|
||||
|
||||
def test_fee_4of5(self):
|
||||
############################################################
|
||||
#compare fee of a standard pubkeyhash transaction
|
||||
|
||||
|
|
@ -456,10 +476,10 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
|
||||
#compare fee
|
||||
feeDelta = Decimal(fundedTx['fee']) - Decimal(signedFee)
|
||||
assert feeDelta <= feeTolerance
|
||||
assert feeDelta <= self.fee_tolerance
|
||||
############################################################
|
||||
|
||||
|
||||
def test_spend_2of2(self):
|
||||
############################################################
|
||||
# spend a 2of2 multisig transaction over fundraw
|
||||
|
||||
|
|
@ -474,7 +494,7 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
|
||||
|
||||
# send 1.2 BTC to msig addr
|
||||
txId = self.nodes[0].sendtoaddress(mSigObj, 1.2)
|
||||
self.nodes[0].sendtoaddress(mSigObj, 1.2)
|
||||
self.sync_all()
|
||||
self.nodes[1].generate(1)
|
||||
self.sync_all()
|
||||
|
|
@ -487,7 +507,7 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
|
||||
blindedTx = self.nodes[2].blindrawtransaction(fundedTx['hex'])
|
||||
signedTx = self.nodes[2].signrawtransactionwithwallet(blindedTx)
|
||||
txId = self.nodes[2].sendrawtransaction(signedTx['hex'])
|
||||
self.nodes[2].sendrawtransaction(signedTx['hex'])
|
||||
self.sync_all()
|
||||
self.nodes[1].generate(1)
|
||||
self.sync_all()
|
||||
|
|
@ -495,6 +515,7 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
# make sure funds are received at node1
|
||||
assert_equal(oldBalance+Decimal('1.10000000'), self.nodes[1].getbalance()['bitcoin'])
|
||||
|
||||
def test_locked_wallet(self):
|
||||
############################################################
|
||||
# locked wallet test
|
||||
self.nodes[1].encryptwallet("test")
|
||||
|
|
@ -504,7 +525,7 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
# This test is not meant to test fee estimation and we'd like
|
||||
# to be sure all txs are sent at a consistent desired feerate
|
||||
for node in self.nodes:
|
||||
node.settxfee(min_relay_tx_fee)
|
||||
node.settxfee(self.min_relay_tx_fee)
|
||||
|
||||
connect_nodes_bi(self.nodes,0,1)
|
||||
connect_nodes_bi(self.nodes,1,2)
|
||||
|
|
@ -512,7 +533,7 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
connect_nodes_bi(self.nodes,0,3)
|
||||
# Again lock the watchonly UTXO or nodes[0] may spend it, because
|
||||
# lockunspent is memory-only and thus lost on restart
|
||||
self.nodes[0].lockunspent(False, [{"txid": watchonly_txid, "vout": watchonly_vout}])
|
||||
self.nodes[0].lockunspent(False, [{"txid": self.watchonly_txid, "vout": self.watchonly_vout}])
|
||||
self.sync_all()
|
||||
|
||||
# drain the keypool
|
||||
|
|
@ -543,14 +564,14 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
#now we need to unlock
|
||||
self.nodes[1].walletpassphrase("test", 600)
|
||||
signedTx = self.nodes[1].signrawtransactionwithwallet(blindedTx)
|
||||
txId = self.nodes[1].sendrawtransaction(signedTx['hex'])
|
||||
self.nodes[1].sendrawtransaction(signedTx['hex'])
|
||||
self.nodes[1].generate(1)
|
||||
self.sync_all()
|
||||
|
||||
# make sure funds are received at node1
|
||||
assert_equal(oldBalance+Decimal('51.10000000'), self.nodes[0].getbalance()['bitcoin'])
|
||||
|
||||
|
||||
def test_many_inputs_fee(self):
|
||||
###############################################
|
||||
# multiple (~19) inputs tx test | Compare fee #
|
||||
###############################################
|
||||
|
|
@ -579,9 +600,9 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
|
||||
#compare fee
|
||||
feeDelta = Decimal(fundedTx['fee']) - Decimal(signedFee)
|
||||
assert feeDelta <= feeTolerance*19 #~19 inputs
|
||||
|
||||
assert feeDelta <= self.fee_tolerance * 19 #~19 inputs
|
||||
|
||||
def test_many_inputs_send(self):
|
||||
#############################################
|
||||
# multiple (~19) inputs tx test | sign/send #
|
||||
#############################################
|
||||
|
|
@ -606,12 +627,13 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
fundedTx = self.nodes[1].fundrawtransaction(rawtx)
|
||||
blindedTx = self.nodes[1].blindrawtransaction(fundedTx['hex'])
|
||||
fundedAndSignedTx = self.nodes[1].signrawtransactionwithwallet(blindedTx)
|
||||
txId = self.nodes[1].sendrawtransaction(fundedAndSignedTx['hex'])
|
||||
self.nodes[1].sendrawtransaction(fundedAndSignedTx['hex'])
|
||||
self.sync_all()
|
||||
self.nodes[0].generate(1)
|
||||
self.sync_all()
|
||||
assert_equal(oldBalance+Decimal('50.19000000'), self.nodes[0].getbalance()['bitcoin']) #0.19+block reward
|
||||
|
||||
def test_op_return(self):
|
||||
#####################################################
|
||||
# test fundrawtransaction with OP_RETURN and no vin #
|
||||
#####################################################
|
||||
|
|
@ -630,29 +652,30 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
assert_greater_than(len(dec_tx['vin']), 0) # at least one vin
|
||||
assert_equal(len(dec_tx['vout']), 3) # one change output added
|
||||
|
||||
|
||||
def test_watchonly(self):
|
||||
##################################################
|
||||
# test a fundrawtransaction using only watchonly #
|
||||
##################################################
|
||||
|
||||
inputs = []
|
||||
outputs = {self.nodes[2].getnewaddress() : watchonly_amount / 2}
|
||||
outputs = {self.nodes[2].getnewaddress(): self.watchonly_amount / 2}
|
||||
rawtx = self.nodes[3].createrawtransaction(inputs, outputs)
|
||||
|
||||
result = self.nodes[3].fundrawtransaction(rawtx, {'includeWatching': True })
|
||||
res_dec = self.nodes[0].decoderawtransaction(result["hex"])
|
||||
assert_equal(len(res_dec["vin"]), 1)
|
||||
assert_equal(res_dec["vin"][0]["txid"], watchonly_txid)
|
||||
assert_equal(res_dec["vin"][0]["txid"], self.watchonly_txid)
|
||||
|
||||
assert "fee" in result.keys()
|
||||
assert_greater_than(result["changepos"], -1)
|
||||
|
||||
def test_all_watched_funds(self):
|
||||
###############################################################
|
||||
# test fundrawtransaction using the entirety of watched funds #
|
||||
###############################################################
|
||||
|
||||
inputs = []
|
||||
outputs = {self.nodes[2].getnewaddress() : watchonly_amount}
|
||||
outputs = {self.nodes[2].getnewaddress(): self.watchonly_amount}
|
||||
rawtx = self.nodes[3].createrawtransaction(inputs, outputs)
|
||||
|
||||
# Backward compatibility test (2nd param is includeWatching)
|
||||
|
|
@ -662,11 +685,11 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
#res_dec = self.nodes[0].decoderawtransaction(blinded_result)
|
||||
res_dec = self.nodes[0].decoderawtransaction(unblinded_result['hex'])
|
||||
assert_equal(len(res_dec["vin"]), 2)
|
||||
assert res_dec["vin"][0]["txid"] == watchonly_txid or res_dec["vin"][1]["txid"] == watchonly_txid
|
||||
assert res_dec["vin"][0]["txid"] == self.watchonly_txid or res_dec["vin"][1]["txid"] == self.watchonly_txid
|
||||
|
||||
assert_greater_than(result["fee"], 0)
|
||||
assert_greater_than(result["changepos"], -1)
|
||||
assert_equal(result["fee"] + res_dec["vout"][result["changepos"]]["value"], watchonly_amount / 10)
|
||||
assert_equal(result["fee"] + res_dec["vout"][result["changepos"]]["value"], self.watchonly_amount / 10)
|
||||
|
||||
signedtx = self.nodes[3].signrawtransactionwithwallet(blinded_result)
|
||||
assert not signedtx["complete"]
|
||||
|
|
@ -676,6 +699,7 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
self.nodes[0].generate(1)
|
||||
self.sync_all()
|
||||
|
||||
def test_option_feerate(self):
|
||||
#######################
|
||||
# Test feeRate option #
|
||||
#######################
|
||||
|
|
@ -686,18 +710,20 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
inputs = []
|
||||
outputs = {self.nodes[3].getnewaddress() : 1}
|
||||
rawtx = self.nodes[3].createrawtransaction(inputs, outputs)
|
||||
result = self.nodes[3].fundrawtransaction(rawtx) # uses min_relay_tx_fee (set by settxfee)
|
||||
result2 = self.nodes[3].fundrawtransaction(rawtx, {"feeRate": 2*min_relay_tx_fee})
|
||||
result3 = self.nodes[3].fundrawtransaction(rawtx, {"feeRate": 10*min_relay_tx_fee})
|
||||
result = self.nodes[3].fundrawtransaction(rawtx) # uses self.min_relay_tx_fee (set by settxfee)
|
||||
result2 = self.nodes[3].fundrawtransaction(rawtx, {"feeRate": 2 * self.min_relay_tx_fee})
|
||||
result3 = self.nodes[3].fundrawtransaction(rawtx, {"feeRate": 10 * self.min_relay_tx_fee})
|
||||
assert_raises_rpc_error(-4, "Fee exceeds maximum configured by -maxtxfee", self.nodes[3].fundrawtransaction, rawtx, {"feeRate": 1})
|
||||
result_fee_rate = result['fee'] * 1000 / count_bytes(result['hex'])
|
||||
assert_fee_amount(result2['fee'], count_bytes(result2['hex']), 2 * result_fee_rate)
|
||||
assert_fee_amount(result3['fee'], count_bytes(result3['hex']), 10 * result_fee_rate)
|
||||
|
||||
def test_address_reuse(self):
|
||||
################################
|
||||
# Test no address reuse occurs #
|
||||
################################
|
||||
|
||||
rawtx = self.nodes[3].createrawtransaction(inputs=[], outputs={self.nodes[3].getnewaddress(): 1})
|
||||
result3 = self.nodes[3].fundrawtransaction(rawtx)
|
||||
res_dec = self.nodes[0].decoderawtransaction(result3["hex"])
|
||||
changeaddress = ""
|
||||
|
|
@ -709,6 +735,7 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
# Now the change address key should be removed from the keypool
|
||||
assert changeaddress != nextaddr
|
||||
|
||||
def test_option_subtract_fee_from_outputs(self):
|
||||
######################################
|
||||
# Test subtractFeeFromOutputs option #
|
||||
######################################
|
||||
|
|
@ -720,11 +747,11 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
outputs = {self.nodes[2].getnewaddress(): 1}
|
||||
rawtx = self.nodes[3].createrawtransaction(inputs, outputs)
|
||||
|
||||
result = [self.nodes[3].fundrawtransaction(rawtx), # uses min_relay_tx_fee (set by settxfee)
|
||||
self.nodes[3].fundrawtransaction(rawtx, {"subtractFeeFromOutputs": []}), # empty subtraction list
|
||||
self.nodes[3].fundrawtransaction(rawtx, {"subtractFeeFromOutputs": [0]}), # uses min_relay_tx_fee (set by settxfee)
|
||||
self.nodes[3].fundrawtransaction(rawtx, {"feeRate": 2*min_relay_tx_fee}),
|
||||
self.nodes[3].fundrawtransaction(rawtx, {"feeRate": 2*min_relay_tx_fee, "subtractFeeFromOutputs": [0]})]
|
||||
result = [self.nodes[3].fundrawtransaction(rawtx), # uses self.min_relay_tx_fee (set by settxfee)
|
||||
self.nodes[3].fundrawtransaction(rawtx, {"subtractFeeFromOutputs": []}), # empty subtraction list
|
||||
self.nodes[3].fundrawtransaction(rawtx, {"subtractFeeFromOutputs": [0]}), # uses self.min_relay_tx_fee (set by settxfee)
|
||||
self.nodes[3].fundrawtransaction(rawtx, {"feeRate": 2 * self.min_relay_tx_fee}),
|
||||
self.nodes[3].fundrawtransaction(rawtx, {"feeRate": 2 * self.min_relay_tx_fee, "subtractFeeFromOutputs": [0]}),]
|
||||
|
||||
dec_tx = [self.nodes[3].decoderawtransaction(tx_['hex']) for tx_ in result]
|
||||
output = [d['vout'][1 - r['changepos']]['value'] for d, r in zip(dec_tx, result)]
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue