kvazar
/
kevacoin
mirror of https://github.com/kvazar-network/kevacoin.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Litecoin: Adjust fee system

0.14
Adrian Gallagher 7 years ago committed by shaolinfry
parent
13155244a1
commit
3cb9f7aa4b
11 changed files with 105 additions and 104 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 28
      qa/rpc-tests/abandonconflict.py
  2. 80
      qa/rpc-tests/bumpfee.py
  3. 3
      qa/rpc-tests/listtransactions.py
  4. 2
      qa/rpc-tests/mempool_limit.py
  5. 2
      qa/rpc-tests/p2p-compactblocks.py
  6. 72
      qa/rpc-tests/p2p-segwit.py
  7. 12
      qa/rpc-tests/wallet.py
  8. 2
      src/policy/policy.h
  9. 2
      src/test/transaction_tests.cpp
  10. 2
      src/validation.h
  11. 4
      src/wallet/wallet.h

28
qa/rpc-tests/abandonconflict.py
Unescape View File

@ -16,7 +16,7 @@ class AbandonConflictTest(BitcoinTestFramework):
def setup_network(self): def setup_network(self):
self.nodes = [] self.nodes = []
self.nodes.append(start_node(0, self.options.tmpdir, ["-debug","-logtimemicros","-minrelaytxfee=0.00001"])) self.nodes.append(start_node(0, self.options.tmpdir, ["-debug","-logtimemicros","-minrelaytxfee=0.001"]))
self.nodes.append(start_node(1, self.options.tmpdir, ["-debug","-logtimemicros"])) self.nodes.append(start_node(1, self.options.tmpdir, ["-debug","-logtimemicros"]))
connect_nodes(self.nodes[0], 1) connect_nodes(self.nodes[0], 1)
@ -32,7 +32,7 @@ class AbandonConflictTest(BitcoinTestFramework):
sync_blocks(self.nodes) sync_blocks(self.nodes)
newbalance = self.nodes[0].getbalance() newbalance = self.nodes[0].getbalance()
assert(balance - newbalance < Decimal("0.001")) #no more than fees lost assert(balance - newbalance < Decimal("0.1")) #no more than fees lost
balance = newbalance balance = newbalance
url = urllib.parse.urlparse(self.nodes[1].url) url = urllib.parse.urlparse(self.nodes[1].url)
@ -49,33 +49,33 @@ class AbandonConflictTest(BitcoinTestFramework):
inputs.append({"txid":txB, "vout":nB}) inputs.append({"txid":txB, "vout":nB})
outputs = {} outputs = {}
outputs[self.nodes[0].getnewaddress()] = Decimal("14.99998") outputs[self.nodes[0].getnewaddress()] = Decimal("14.998")
outputs[self.nodes[1].getnewaddress()] = Decimal("5") outputs[self.nodes[1].getnewaddress()] = Decimal("5")
signed = self.nodes[0].signrawtransaction(self.nodes[0].createrawtransaction(inputs, outputs)) signed = self.nodes[0].signrawtransaction(self.nodes[0].createrawtransaction(inputs, outputs))
txAB1 = self.nodes[0].sendrawtransaction(signed["hex"]) txAB1 = self.nodes[0].sendrawtransaction(signed["hex"])
# Identify the 14.99998btc output # Identify the 14.99998btc output
nAB = next(i for i, vout in enumerate(self.nodes[0].getrawtransaction(txAB1, 1)["vout"]) if vout["value"] == Decimal("14.99998")) nAB = next(i for i, vout in enumerate(self.nodes[0].getrawtransaction(txAB1, 1)["vout"]) if vout["value"] == Decimal("14.998"))
#Create a child tx spending AB1 and C #Create a child tx spending AB1 and C
inputs = [] inputs = []
inputs.append({"txid":txAB1, "vout":nAB}) inputs.append({"txid":txAB1, "vout":nAB})
inputs.append({"txid":txC, "vout":nC}) inputs.append({"txid":txC, "vout":nC})
outputs = {} outputs = {}
outputs[self.nodes[0].getnewaddress()] = Decimal("24.9996") outputs[self.nodes[0].getnewaddress()] = Decimal("24.96")
signed2 = self.nodes[0].signrawtransaction(self.nodes[0].createrawtransaction(inputs, outputs)) signed2 = self.nodes[0].signrawtransaction(self.nodes[0].createrawtransaction(inputs, outputs))
txABC2 = self.nodes[0].sendrawtransaction(signed2["hex"]) txABC2 = self.nodes[0].sendrawtransaction(signed2["hex"])
# In mempool txs from self should increase balance from change # In mempool txs from self should increase balance from change
newbalance = self.nodes[0].getbalance() newbalance = self.nodes[0].getbalance()
assert_equal(newbalance, balance - Decimal("30") + Decimal("24.9996")) assert_equal(newbalance, balance - Decimal("30") + Decimal("24.96"))
balance = newbalance balance = newbalance
# Restart the node with a higher min relay fee so the parent tx is no longer in mempool # Restart the node with a higher min relay fee so the parent tx is no longer in mempool
# TODO: redo with eviction # TODO: redo with eviction
# Note had to make sure tx did not have AllowFree priority # Note had to make sure tx did not have AllowFree priority
stop_node(self.nodes[0],0) stop_node(self.nodes[0],0)
self.nodes[0]=start_node(0, self.options.tmpdir, ["-debug","-logtimemicros","-minrelaytxfee=0.0001"]) self.nodes[0]=start_node(0, self.options.tmpdir, ["-debug","-logtimemicros","-minrelaytxfee=0.01"])
# Verify txs no longer in mempool # Verify txs no longer in mempool
assert_equal(len(self.nodes[0].getrawmempool()), 0) assert_equal(len(self.nodes[0].getrawmempool()), 0)
@ -83,7 +83,7 @@ class AbandonConflictTest(BitcoinTestFramework):
# Not in mempool txs from self should only reduce balance # Not in mempool txs from self should only reduce balance
# inputs are still spent, but change not received # inputs are still spent, but change not received
newbalance = self.nodes[0].getbalance() newbalance = self.nodes[0].getbalance()
assert_equal(newbalance, balance - Decimal("24.9996")) assert_equal(newbalance, balance - Decimal("24.96"))
# Unconfirmed received funds that are not in mempool, also shouldn't show # Unconfirmed received funds that are not in mempool, also shouldn't show
# up in unconfirmed balance # up in unconfirmed balance
unconfbalance = self.nodes[0].getunconfirmedbalance() + self.nodes[0].getbalance() unconfbalance = self.nodes[0].getunconfirmedbalance() + self.nodes[0].getbalance()
@ -101,7 +101,7 @@ class AbandonConflictTest(BitcoinTestFramework):
# Verify that even with a low min relay fee, the tx is not reaccepted from wallet on startup once abandoned # Verify that even with a low min relay fee, the tx is not reaccepted from wallet on startup once abandoned
stop_node(self.nodes[0],0) stop_node(self.nodes[0],0)
self.nodes[0]=start_node(0, self.options.tmpdir, ["-debug","-logtimemicros","-minrelaytxfee=0.00001"]) self.nodes[0]=start_node(0, self.options.tmpdir, ["-debug","-logtimemicros","-minrelaytxfee=0.001"])
assert_equal(len(self.nodes[0].getrawmempool()), 0) assert_equal(len(self.nodes[0].getrawmempool()), 0)
assert_equal(self.nodes[0].getbalance(), balance) assert_equal(self.nodes[0].getbalance(), balance)
@ -110,21 +110,21 @@ class AbandonConflictTest(BitcoinTestFramework):
# But its child tx remains abandoned # But its child tx remains abandoned
self.nodes[0].sendrawtransaction(signed["hex"]) self.nodes[0].sendrawtransaction(signed["hex"])
newbalance = self.nodes[0].getbalance() newbalance = self.nodes[0].getbalance()
assert_equal(newbalance, balance - Decimal("20") + Decimal("14.99998")) assert_equal(newbalance, balance - Decimal("20") + Decimal("14.998"))
balance = newbalance balance = newbalance
# Send child tx again so its unabandoned # Send child tx again so its unabandoned
self.nodes[0].sendrawtransaction(signed2["hex"]) self.nodes[0].sendrawtransaction(signed2["hex"])
newbalance = self.nodes[0].getbalance() newbalance = self.nodes[0].getbalance()
assert_equal(newbalance, balance - Decimal("10") - Decimal("14.99998") + Decimal("24.9996")) assert_equal(newbalance, balance - Decimal("10") - Decimal("14.998") + Decimal("24.96"))
balance = newbalance balance = newbalance
# Remove using high relay fee again # Remove using high relay fee again
stop_node(self.nodes[0],0) stop_node(self.nodes[0],0)
self.nodes[0]=start_node(0, self.options.tmpdir, ["-debug","-logtimemicros","-minrelaytxfee=0.0001"]) self.nodes[0]=start_node(0, self.options.tmpdir, ["-debug","-logtimemicros","-minrelaytxfee=0.01"])
assert_equal(len(self.nodes[0].getrawmempool()), 0) assert_equal(len(self.nodes[0].getrawmempool()), 0)
newbalance = self.nodes[0].getbalance() newbalance = self.nodes[0].getbalance()
assert_equal(newbalance, balance - Decimal("24.9996")) assert_equal(newbalance, balance - Decimal("24.96"))
balance = newbalance balance = newbalance
# Create a double spend of AB1 by spending again from only A's 10 output # Create a double spend of AB1 by spending again from only A's 10 output
@ -132,7 +132,7 @@ class AbandonConflictTest(BitcoinTestFramework):
inputs =[] inputs =[]
inputs.append({"txid":txA, "vout":nA}) inputs.append({"txid":txA, "vout":nA})
outputs = {} outputs = {}
outputs[self.nodes[1].getnewaddress()] = Decimal("9.9999") outputs[self.nodes[1].getnewaddress()] = Decimal("9.99")
tx = self.nodes[0].createrawtransaction(inputs, outputs) tx = self.nodes[0].createrawtransaction(inputs, outputs)
signed = self.nodes[0].signrawtransaction(tx) signed = self.nodes[0].signrawtransaction(tx)
self.nodes[1].sendrawtransaction(signed["hex"]) self.nodes[1].sendrawtransaction(signed["hex"])

80
qa/rpc-tests/bumpfee.py
Unescape View File

@ -45,16 +45,16 @@ class BumpFeeTest(BitcoinTestFramework):
peer_node, rbf_node = self.nodes peer_node, rbf_node = self.nodes
rbf_node_address = rbf_node.getnewaddress() rbf_node_address = rbf_node.getnewaddress()
# fund rbf node with 10 coins of 0.001 btc (100,000 satoshis) # fund rbf node with 10 coins of 0.1 ltc (10,000,000 satoshis)
print("Mining blocks...") print("Mining blocks...")
peer_node.generate(110) peer_node.generate(110)
self.sync_all() self.sync_all()
for i in range(25): for i in range(25):
peer_node.sendtoaddress(rbf_node_address, 0.001) peer_node.sendtoaddress(rbf_node_address, 0.1)
self.sync_all() self.sync_all()
peer_node.generate(1) peer_node.generate(1)
self.sync_all() self.sync_all()
assert_equal(rbf_node.getbalance(), Decimal("0.025")) assert_equal(rbf_node.getbalance(), Decimal("2.5"))
print("Running tests") print("Running tests")
dest_address = peer_node.getnewaddress() dest_address = peer_node.getnewaddress()
@ -75,7 +75,7 @@ class BumpFeeTest(BitcoinTestFramework):
def test_simple_bumpfee_succeeds(rbf_node, peer_node, dest_address): def test_simple_bumpfee_succeeds(rbf_node, peer_node, dest_address):
rbfid = create_fund_sign_send(rbf_node, {dest_address: 0.00090000}) rbfid = create_fund_sign_send(rbf_node, {dest_address: 0.090000})
rbftx = rbf_node.gettransaction(rbfid) rbftx = rbf_node.gettransaction(rbfid)
sync_mempools((rbf_node, peer_node)) sync_mempools((rbf_node, peer_node))
assert rbfid in rbf_node.getrawmempool() and rbfid in peer_node.getrawmempool() assert rbfid in rbf_node.getrawmempool() and rbfid in peer_node.getrawmempool()
@ -99,7 +99,7 @@ def test_segwit_bumpfee_succeeds(rbf_node, dest_address):
# Create a transaction with segwit output, then create an RBF transaction # Create a transaction with segwit output, then create an RBF transaction
# which spends it, and make sure bumpfee can be called on it. # which spends it, and make sure bumpfee can be called on it.
segwit_in = next(u for u in rbf_node.listunspent() if u["amount"] == Decimal("0.001")) segwit_in = next(u for u in rbf_node.listunspent() if u["amount"] == Decimal("0.1"))
segwit_out = rbf_node.validateaddress(rbf_node.getnewaddress()) segwit_out = rbf_node.validateaddress(rbf_node.getnewaddress())
rbf_node.addwitnessaddress(segwit_out["address"]) rbf_node.addwitnessaddress(segwit_out["address"])
segwitid = send_to_witness( segwitid = send_to_witness(
@ -108,15 +108,15 @@ def test_segwit_bumpfee_succeeds(rbf_node, dest_address):
utxo=segwit_in, utxo=segwit_in,
pubkey=segwit_out["pubkey"], pubkey=segwit_out["pubkey"],
encode_p2sh=False, encode_p2sh=False,
amount=Decimal("0.0009"), amount=Decimal("0.09"),
sign=True) sign=True)
rbfraw = rbf_node.createrawtransaction([{ rbfraw = rbf_node.createrawtransaction([{
'txid': segwitid, 'txid': segwitid,
'vout': 0, 'vout': 0,
"sequence": BIP125_SEQUENCE_NUMBER "sequence": BIP125_SEQUENCE_NUMBER
}], {dest_address: Decimal("0.0005"), }], {dest_address: Decimal("0.05"),
get_change_address(rbf_node): Decimal("0.0003")}) get_change_address(rbf_node): Decimal("0.03")})
rbfsigned = rbf_node.signrawtransaction(rbfraw) rbfsigned = rbf_node.signrawtransaction(rbfraw)
rbfid = rbf_node.sendrawtransaction(rbfsigned["hex"]) rbfid = rbf_node.sendrawtransaction(rbfsigned["hex"])
assert rbfid in rbf_node.getrawmempool() assert rbfid in rbf_node.getrawmempool()
@ -128,7 +128,7 @@ def test_segwit_bumpfee_succeeds(rbf_node, dest_address):
def test_nonrbf_bumpfee_fails(peer_node, dest_address): def test_nonrbf_bumpfee_fails(peer_node, dest_address):
# cannot replace a non RBF transaction (from node which did not enable RBF) # cannot replace a non RBF transaction (from node which did not enable RBF)
not_rbfid = create_fund_sign_send(peer_node, {dest_address: 0.00090000}) not_rbfid = create_fund_sign_send(peer_node, {dest_address: 0.090000})
assert_raises_message(JSONRPCException, "not BIP 125 replaceable", peer_node.bumpfee, not_rbfid) assert_raises_message(JSONRPCException, "not BIP 125 replaceable", peer_node.bumpfee, not_rbfid)
@ -144,7 +144,7 @@ def test_notmine_bumpfee_fails(rbf_node, peer_node, dest_address):
"address": utxo["address"], "address": utxo["address"],
"sequence": BIP125_SEQUENCE_NUMBER "sequence": BIP125_SEQUENCE_NUMBER
} for utxo in utxos] } for utxo in utxos]
output_val = sum(utxo["amount"] for utxo in utxos) - Decimal("0.001") output_val = sum(utxo["amount"] for utxo in utxos) - Decimal("0.1")
rawtx = rbf_node.createrawtransaction(inputs, {dest_address: output_val}) rawtx = rbf_node.createrawtransaction(inputs, {dest_address: output_val})
signedtx = rbf_node.signrawtransaction(rawtx) signedtx = rbf_node.signrawtransaction(rawtx)
signedtx = peer_node.signrawtransaction(signedtx["hex"]) signedtx = peer_node.signrawtransaction(signedtx["hex"])
@ -156,8 +156,8 @@ def test_notmine_bumpfee_fails(rbf_node, peer_node, dest_address):
def test_bumpfee_with_descendant_fails(rbf_node, rbf_node_address, dest_address): def test_bumpfee_with_descendant_fails(rbf_node, rbf_node_address, dest_address):
# cannot bump fee if the transaction has a descendant # cannot bump fee if the transaction has a descendant
# parent is send-to-self, so we don't have to check which output is change when creating the child tx # parent is send-to-self, so we don't have to check which output is change when creating the child tx
parent_id = create_fund_sign_send(rbf_node, {rbf_node_address: 0.00050000}) parent_id = create_fund_sign_send(rbf_node, {rbf_node_address: 0.050000})
tx = rbf_node.createrawtransaction([{"txid": parent_id, "vout": 0}], {dest_address: 0.00020000}) tx = rbf_node.createrawtransaction([{"txid": parent_id, "vout": 0}], {dest_address: 0.020000})
tx = rbf_node.signrawtransaction(tx) tx = rbf_node.signrawtransaction(tx)
txid = rbf_node.sendrawtransaction(tx["hex"]) txid = rbf_node.sendrawtransaction(tx["hex"])
assert_raises_message(JSONRPCException, "Transaction has descendants in the wallet", rbf_node.bumpfee, parent_id) assert_raises_message(JSONRPCException, "Transaction has descendants in the wallet", rbf_node.bumpfee, parent_id)
@ -166,29 +166,29 @@ def test_bumpfee_with_descendant_fails(rbf_node, rbf_node_address, dest_address)
def test_small_output_fails(rbf_node, dest_address): def test_small_output_fails(rbf_node, dest_address):
# cannot bump fee with a too-small output # cannot bump fee with a too-small output
rbfid = spend_one_input(rbf_node, rbfid = spend_one_input(rbf_node,
Decimal("0.00100000"), Decimal("0.100000"),
{dest_address: 0.00080000, {dest_address: 0.080000,
get_change_address(rbf_node): Decimal("0.00010000")}) get_change_address(rbf_node): Decimal("0.010000")})
rbf_node.bumpfee(rbfid, {"totalFee": 20000}) rbf_node.bumpfee(rbfid, {"totalFee": 2000000})
rbfid = spend_one_input(rbf_node, rbfid = spend_one_input(rbf_node,
Decimal("0.00100000"), Decimal("0.100000"),
{dest_address: 0.00080000, {dest_address: 0.080000,
get_change_address(rbf_node): Decimal("0.00010000")}) get_change_address(rbf_node): Decimal("0.010000")})
assert_raises_message(JSONRPCException, "Change output is too small", rbf_node.bumpfee, rbfid, {"totalFee": 20001}) assert_raises_message(JSONRPCException, "Change output is too small", rbf_node.bumpfee, rbfid, {"totalFee": 2000001})
def test_dust_to_fee(rbf_node, dest_address): def test_dust_to_fee(rbf_node, dest_address):
# check that if output is reduced to dust, it will be converted to fee # check that if output is reduced to dust, it will be converted to fee
# the bumped tx sets fee=9900, but it converts to 10,000 # the bumped tx sets fee=9900, but it converts to 10,000
rbfid = spend_one_input(rbf_node, rbfid = spend_one_input(rbf_node,
Decimal("0.00100000"), Decimal("0.100000"),
{dest_address: 0.00080000, {dest_address: 0.080000,
get_change_address(rbf_node): Decimal("0.00010000")}) get_change_address(rbf_node): Decimal("0.010000")})
fulltx = rbf_node.getrawtransaction(rbfid, 1) fulltx = rbf_node.getrawtransaction(rbfid, 1)
bumped_tx = rbf_node.bumpfee(rbfid, {"totalFee": 19900}) bumped_tx = rbf_node.bumpfee(rbfid, {"totalFee": 1990000})
full_bumped_tx = rbf_node.getrawtransaction(bumped_tx["txid"], 1) full_bumped_tx = rbf_node.getrawtransaction(bumped_tx["txid"], 1)
assert_equal(bumped_tx["fee"], Decimal("0.00020000")) assert_equal(bumped_tx["fee"], Decimal("0.020000"))
assert_equal(len(fulltx["vout"]), 2) assert_equal(len(fulltx["vout"]), 2)
assert_equal(len(full_bumped_tx["vout"]), 1) #change output is eliminated assert_equal(len(full_bumped_tx["vout"]), 1) #change output is eliminated
@ -196,10 +196,10 @@ def test_dust_to_fee(rbf_node, dest_address):
def test_settxfee(rbf_node, dest_address): def test_settxfee(rbf_node, dest_address):
# check that bumpfee reacts correctly to the use of settxfee (paytxfee) # check that bumpfee reacts correctly to the use of settxfee (paytxfee)
# increase feerate by 2.5x, test that fee increased at least 2x # increase feerate by 2.5x, test that fee increased at least 2x
rbf_node.settxfee(Decimal("0.00001000")) rbf_node.settxfee(Decimal("0.001000"))
rbfid = create_fund_sign_send(rbf_node, {dest_address: 0.00090000}) rbfid = create_fund_sign_send(rbf_node, {dest_address: 0.090000})
rbftx = rbf_node.gettransaction(rbfid) rbftx = rbf_node.gettransaction(rbfid)
rbf_node.settxfee(Decimal("0.00002500")) rbf_node.settxfee(Decimal("0.002500"))
bumped_tx = rbf_node.bumpfee(rbfid) bumped_tx = rbf_node.bumpfee(rbfid)
assert bumped_tx["fee"] > 2 * abs(rbftx["fee"]) assert bumped_tx["fee"] > 2 * abs(rbftx["fee"])
rbf_node.settxfee(Decimal("0.00000000")) # unset paytxfee rbf_node.settxfee(Decimal("0.00000000")) # unset paytxfee
@ -207,24 +207,24 @@ def test_settxfee(rbf_node, dest_address):
def test_rebumping(rbf_node, dest_address): def test_rebumping(rbf_node, dest_address):
# check that re-bumping the original tx fails, but bumping the bumper succeeds # check that re-bumping the original tx fails, but bumping the bumper succeeds
rbf_node.settxfee(Decimal("0.00001000")) rbf_node.settxfee(Decimal("0.001000"))
rbfid = create_fund_sign_send(rbf_node, {dest_address: 0.00090000}) rbfid = create_fund_sign_send(rbf_node, {dest_address: 0.090000})
bumped = rbf_node.bumpfee(rbfid, {"totalFee": 1000}) bumped = rbf_node.bumpfee(rbfid, {"totalFee": 100000})
assert_raises_message(JSONRPCException, "already bumped", rbf_node.bumpfee, rbfid, {"totalFee": 2000}) assert_raises_message(JSONRPCException, "already bumped", rbf_node.bumpfee, rbfid, {"totalFee": 200000})
rbf_node.bumpfee(bumped["txid"], {"totalFee": 2000}) rbf_node.bumpfee(bumped["txid"], {"totalFee": 200000})
def test_rebumping_not_replaceable(rbf_node, dest_address): def test_rebumping_not_replaceable(rbf_node, dest_address):
# check that re-bumping a non-replaceable bump tx fails # check that re-bumping a non-replaceable bump tx fails
rbfid = create_fund_sign_send(rbf_node, {dest_address: 0.00090000}) rbfid = create_fund_sign_send(rbf_node, {dest_address: 0.090000})
bumped = rbf_node.bumpfee(rbfid, {"totalFee": 10000, "replaceable": False}) bumped = rbf_node.bumpfee(rbfid, {"totalFee": 100000, "replaceable": False})
assert_raises_message(JSONRPCException, "Transaction is not BIP 125 replaceable", rbf_node.bumpfee, bumped["txid"], assert_raises_message(JSONRPCException, "Transaction is not BIP 125 replaceable", rbf_node.bumpfee, bumped["txid"],
{"totalFee": 20000}) {"totalFee": 200000})
def test_unconfirmed_not_spendable(rbf_node, rbf_node_address): def test_unconfirmed_not_spendable(rbf_node, rbf_node_address):
# check that unconfirmed outputs from bumped transactions are not spendable # check that unconfirmed outputs from bumped transactions are not spendable
rbfid = create_fund_sign_send(rbf_node, {rbf_node_address: 0.00090000}) rbfid = create_fund_sign_send(rbf_node, {rbf_node_address: 0.090000})
rbftx = rbf_node.gettransaction(rbfid)["hex"] rbftx = rbf_node.gettransaction(rbfid)["hex"]
assert rbfid in rbf_node.getrawmempool() assert rbfid in rbf_node.getrawmempool()
bumpid = rbf_node.bumpfee(rbfid)["txid"] bumpid = rbf_node.bumpfee(rbfid)["txid"]
@ -259,7 +259,7 @@ def test_unconfirmed_not_spendable(rbf_node, rbf_node_address):
def test_bumpfee_metadata(rbf_node, dest_address): def test_bumpfee_metadata(rbf_node, dest_address):
rbfid = rbf_node.sendtoaddress(dest_address, 0.00090000, "comment value", "to value") rbfid = rbf_node.sendtoaddress(dest_address, 0.090000, "comment value", "to value")
bumped_tx = rbf_node.bumpfee(rbfid) bumped_tx = rbf_node.bumpfee(rbfid)
bumped_wtx = rbf_node.gettransaction(bumped_tx["txid"]) bumped_wtx = rbf_node.gettransaction(bumped_tx["txid"])
assert_equal(bumped_wtx["comment"], "comment value") assert_equal(bumped_wtx["comment"], "comment value")
@ -267,7 +267,7 @@ def test_bumpfee_metadata(rbf_node, dest_address):
def test_locked_wallet_fails(rbf_node, dest_address): def test_locked_wallet_fails(rbf_node, dest_address):
rbfid = create_fund_sign_send(rbf_node, {dest_address: 0.00090000}) rbfid = create_fund_sign_send(rbf_node, {dest_address: 0.090000})
rbf_node.walletlock() rbf_node.walletlock()
assert_raises_message(JSONRPCException, "Please enter the wallet passphrase with walletpassphrase first.", assert_raises_message(JSONRPCException, "Please enter the wallet passphrase with walletpassphrase first.",
rbf_node.bumpfee, rbfid) rbf_node.bumpfee, rbfid)
@ -296,7 +296,7 @@ def get_change_address(node):
dummy transaction, calls fundrawtransaction to give add an input and change dummy transaction, calls fundrawtransaction to give add an input and change
output, then returns the change address.""" output, then returns the change address."""
dest_address = node.getnewaddress() dest_address = node.getnewaddress()
dest_amount = Decimal("0.00012345") dest_amount = Decimal("0.012345")
rawtx = node.createrawtransaction([], {dest_address: dest_amount}) rawtx = node.createrawtransaction([], {dest_address: dest_amount})
fundtx = node.fundrawtransaction(rawtx) fundtx = node.fundrawtransaction(rawtx)
info = node.decoderawtransaction(fundtx["hex"]) info = node.decoderawtransaction(fundtx["hex"])

3
qa/rpc-tests/listtransactions.py
Unescape View File

@ -98,7 +98,8 @@ class ListTransactionsTest(BitcoinTestFramework):
{"category":"receive","amount":Decimal("0.1")}, {"category":"receive","amount":Decimal("0.1")},
{"txid":txid, "account" : "watchonly"} ) {"txid":txid, "account" : "watchonly"} )
self.run_rbf_opt_in_test() #Litecoin: Disabled RBF
#self.run_rbf_opt_in_test()
# Check that the opt-in-rbf flag works properly, for sent and received # Check that the opt-in-rbf flag works properly, for sent and received
# transactions. # transactions.

2
qa/rpc-tests/mempool_limit.py
Unescape View File

@ -31,7 +31,7 @@ class MempoolLimitTest(BitcoinTestFramework):
#create a mempool tx that will be evicted #create a mempool tx that will be evicted
us0 = utxos.pop() us0 = utxos.pop()
inputs = [{ "txid" : us0["txid"], "vout" : us0["vout"]}] inputs = [{ "txid" : us0["txid"], "vout" : us0["vout"]}]
outputs = {self.nodes[0].getnewaddress() : 0.0001} outputs = {self.nodes[0].getnewaddress() : 0.01}
tx = self.nodes[0].createrawtransaction(inputs, outputs) tx = self.nodes[0].createrawtransaction(inputs, outputs)
self.nodes[0].settxfee(self.relayfee) # specifically fund this tx with low fee self.nodes[0].settxfee(self.relayfee) # specifically fund this tx with low fee
txF = self.nodes[0].fundrawtransaction(tx) txF = self.nodes[0].fundrawtransaction(tx)

2
qa/rpc-tests/p2p-compactblocks.py
Unescape View File

@ -460,7 +460,7 @@ class CompactBlocksTest(BitcoinTestFramework):
for i in range(num_transactions): for i in range(num_transactions):
tx = CTransaction() tx = CTransaction()
tx.vin.append(CTxIn(COutPoint(utxo[0], utxo[1]), b'')) tx.vin.append(CTxIn(COutPoint(utxo[0], utxo[1]), b''))
tx.vout.append(CTxOut(utxo[2] - 1000, CScript([OP_TRUE]))) tx.vout.append(CTxOut(utxo[2] - 100000, CScript([OP_TRUE])))
tx.rehash() tx.rehash()
utxo = [tx.sha256, 0, tx.vout[0].nValue] utxo = [tx.sha256, 0, tx.vout[0].nValue]
block.vtx.append(tx) block.vtx.append(tx)

72
qa/rpc-tests/p2p-segwit.py
Unescape View File

@ -311,7 +311,7 @@ class SegWitTest(BitcoinTestFramework):
# to a transaction, eg by violating standardness checks. # to a transaction, eg by violating standardness checks.
tx2 = CTransaction() tx2 = CTransaction()
tx2.vin.append(CTxIn(COutPoint(tx.sha256, 0), b"")) tx2.vin.append(CTxIn(COutPoint(tx.sha256, 0), b""))
tx2.vout.append(CTxOut(tx.vout[0].nValue-1000, scriptPubKey)) tx2.vout.append(CTxOut(tx.vout[0].nValue-100000, scriptPubKey))
tx2.rehash() tx2.rehash()
self.test_node.test_transaction_acceptance(tx2, False, True) self.test_node.test_transaction_acceptance(tx2, False, True)
self.nodes[0].generate(1) self.nodes[0].generate(1)
@ -324,7 +324,7 @@ class SegWitTest(BitcoinTestFramework):
# to the rejection cache. # to the rejection cache.
tx3 = CTransaction() tx3 = CTransaction()
tx3.vin.append(CTxIn(COutPoint(tx2.sha256, 0), CScript([p2sh_program]))) tx3.vin.append(CTxIn(COutPoint(tx2.sha256, 0), CScript([p2sh_program])))
tx3.vout.append(CTxOut(tx2.vout[0].nValue-1000, scriptPubKey)) tx3.vout.append(CTxOut(tx2.vout[0].nValue-100000, scriptPubKey))
tx3.wit.vtxinwit.append(CTxInWitness()) tx3.wit.vtxinwit.append(CTxInWitness())
tx3.wit.vtxinwit[0].scriptWitness.stack = [b'a'*400000] tx3.wit.vtxinwit[0].scriptWitness.stack = [b'a'*400000]
tx3.rehash() tx3.rehash()
@ -338,7 +338,7 @@ class SegWitTest(BitcoinTestFramework):
# Now create a new anyone-can-spend utxo for the next test. # Now create a new anyone-can-spend utxo for the next test.
tx4 = CTransaction() tx4 = CTransaction()
tx4.vin.append(CTxIn(COutPoint(tx3.sha256, 0), CScript([p2sh_program]))) tx4.vin.append(CTxIn(COutPoint(tx3.sha256, 0), CScript([p2sh_program])))
tx4.vout.append(CTxOut(tx3.vout[0].nValue-1000, CScript([OP_TRUE]))) tx4.vout.append(CTxOut(tx3.vout[0].nValue-100000, CScript([OP_TRUE])))
tx4.rehash() tx4.rehash()
self.test_node.test_transaction_acceptance(tx3, False, True) self.test_node.test_transaction_acceptance(tx3, False, True)
self.test_node.test_transaction_acceptance(tx4, False, True) self.test_node.test_transaction_acceptance(tx4, False, True)
@ -651,7 +651,7 @@ class SegWitTest(BitcoinTestFramework):
# First try extra witness data on a tx that doesn't require a witness # First try extra witness data on a tx that doesn't require a witness
tx = CTransaction() tx = CTransaction()
tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b"")) tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
tx.vout.append(CTxOut(self.utxo[0].nValue-2000, scriptPubKey)) tx.vout.append(CTxOut(self.utxo[0].nValue-200000, scriptPubKey))
tx.vout.append(CTxOut(1000, CScript([OP_TRUE]))) # non-witness output tx.vout.append(CTxOut(1000, CScript([OP_TRUE]))) # non-witness output
tx.wit.vtxinwit.append(CTxInWitness()) tx.wit.vtxinwit.append(CTxInWitness())
tx.wit.vtxinwit[0].scriptWitness.stack = [CScript([])] tx.wit.vtxinwit[0].scriptWitness.stack = [CScript([])]
@ -726,12 +726,12 @@ class SegWitTest(BitcoinTestFramework):
tx = CTransaction() tx = CTransaction()
tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b"")) tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
tx.vout.append(CTxOut(self.utxo[0].nValue-1000, scriptPubKey)) tx.vout.append(CTxOut(self.utxo[0].nValue-100000, scriptPubKey))
tx.rehash() tx.rehash()
tx2 = CTransaction() tx2 = CTransaction()
tx2.vin.append(CTxIn(COutPoint(tx.sha256, 0), b"")) tx2.vin.append(CTxIn(COutPoint(tx.sha256, 0), b""))
tx2.vout.append(CTxOut(tx.vout[0].nValue-1000, CScript([OP_TRUE]))) tx2.vout.append(CTxOut(tx.vout[0].nValue-100000, CScript([OP_TRUE])))
tx2.wit.vtxinwit.append(CTxInWitness()) tx2.wit.vtxinwit.append(CTxInWitness())
# First try a 521-byte stack element # First try a 521-byte stack element
tx2.wit.vtxinwit[0].scriptWitness.stack = [ b'a'*(MAX_SCRIPT_ELEMENT_SIZE+1), witness_program ] tx2.wit.vtxinwit[0].scriptWitness.stack = [ b'a'*(MAX_SCRIPT_ELEMENT_SIZE+1), witness_program ]
@ -768,12 +768,12 @@ class SegWitTest(BitcoinTestFramework):
tx = CTransaction() tx = CTransaction()
tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b"")) tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
tx.vout.append(CTxOut(self.utxo[0].nValue-1000, long_scriptPubKey)) tx.vout.append(CTxOut(self.utxo[0].nValue-100000, long_scriptPubKey))
tx.rehash() tx.rehash()
tx2 = CTransaction() tx2 = CTransaction()
tx2.vin.append(CTxIn(COutPoint(tx.sha256, 0), b"")) tx2.vin.append(CTxIn(COutPoint(tx.sha256, 0), b""))
tx2.vout.append(CTxOut(tx.vout[0].nValue-1000, CScript([OP_TRUE]))) tx2.vout.append(CTxOut(tx.vout[0].nValue-100000, CScript([OP_TRUE])))
tx2.wit.vtxinwit.append(CTxInWitness()) tx2.wit.vtxinwit.append(CTxInWitness())
tx2.wit.vtxinwit[0].scriptWitness.stack = [b'a']*44 + [long_witness_program] tx2.wit.vtxinwit[0].scriptWitness.stack = [b'a']*44 + [long_witness_program]
tx2.rehash() tx2.rehash()
@ -893,7 +893,7 @@ class SegWitTest(BitcoinTestFramework):
assert(len(self.utxo)) assert(len(self.utxo))
tx = CTransaction() tx = CTransaction()
tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b"")) tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
tx.vout.append(CTxOut(self.utxo[0].nValue-1000, CScript([OP_TRUE]))) tx.vout.append(CTxOut(self.utxo[0].nValue-100000, CScript([OP_TRUE])))
tx.wit.vtxinwit.append(CTxInWitness()) tx.wit.vtxinwit.append(CTxInWitness())
tx.wit.vtxinwit[0].scriptWitness.stack = [ b'a' ] tx.wit.vtxinwit[0].scriptWitness.stack = [ b'a' ]
tx.rehash() tx.rehash()
@ -945,7 +945,7 @@ class SegWitTest(BitcoinTestFramework):
assert(len(self.utxo)) assert(len(self.utxo))
tx = CTransaction() tx = CTransaction()
tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b"")) tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
tx.vout.append(CTxOut(self.utxo[0].nValue-1000, CScript([OP_TRUE]))) tx.vout.append(CTxOut(self.utxo[0].nValue-100000, CScript([OP_TRUE])))
tx.wit.vtxinwit.append(CTxInWitness()) tx.wit.vtxinwit.append(CTxInWitness())
tx.wit.vtxinwit[0].scriptWitness.stack = [ b'a' ] tx.wit.vtxinwit[0].scriptWitness.stack = [ b'a' ]
tx.rehash() tx.rehash()
@ -967,7 +967,7 @@ class SegWitTest(BitcoinTestFramework):
scriptPubKey = CScript([OP_0, witness_hash]) scriptPubKey = CScript([OP_0, witness_hash])
tx2 = CTransaction() tx2 = CTransaction()
tx2.vin.append(CTxIn(COutPoint(tx_hash, 0), b"")) tx2.vin.append(CTxIn(COutPoint(tx_hash, 0), b""))
tx2.vout.append(CTxOut(tx.vout[0].nValue-1000, scriptPubKey)) tx2.vout.append(CTxOut(tx.vout[0].nValue-100000, scriptPubKey))
tx2.rehash() tx2.rehash()
tx3 = CTransaction() tx3 = CTransaction()
@ -978,7 +978,7 @@ class SegWitTest(BitcoinTestFramework):
p2sh_program = CScript([OP_TRUE]) p2sh_program = CScript([OP_TRUE])
p2sh_pubkey = hash160(p2sh_program) p2sh_pubkey = hash160(p2sh_program)
witness_program2 = CScript([b'a'*400000]) witness_program2 = CScript([b'a'*400000])
tx3.vout.append(CTxOut(tx2.vout[0].nValue-1000, CScript([OP_HASH160, p2sh_pubkey, OP_EQUAL]))) tx3.vout.append(CTxOut(tx2.vout[0].nValue-100000, CScript([OP_HASH160, p2sh_pubkey, OP_EQUAL])))
tx3.wit.vtxinwit[0].scriptWitness.stack = [witness_program2] tx3.wit.vtxinwit[0].scriptWitness.stack = [witness_program2]
tx3.rehash() tx3.rehash()
@ -989,7 +989,7 @@ class SegWitTest(BitcoinTestFramework):
self.std_node.test_transaction_acceptance(tx3, True, False, b'tx-size') self.std_node.test_transaction_acceptance(tx3, True, False, b'tx-size')
# Remove witness stuffing, instead add extra witness push on stack # Remove witness stuffing, instead add extra witness push on stack
tx3.vout[0] = CTxOut(tx2.vout[0].nValue-1000, CScript([OP_TRUE])) tx3.vout[0] = CTxOut(tx2.vout[0].nValue-100000, CScript([OP_TRUE]))
tx3.wit.vtxinwit[0].scriptWitness.stack = [CScript([CScriptNum(1)]), witness_program ] tx3.wit.vtxinwit[0].scriptWitness.stack = [CScript([CScriptNum(1)]), witness_program ]
tx3.rehash() tx3.rehash()
@ -1131,7 +1131,7 @@ class SegWitTest(BitcoinTestFramework):
# First prepare a p2sh output (so that spending it will pass standardness) # First prepare a p2sh output (so that spending it will pass standardness)
p2sh_tx = CTransaction() p2sh_tx = CTransaction()
p2sh_tx.vin = [CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b"")] p2sh_tx.vin = [CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b"")]
p2sh_tx.vout = [CTxOut(self.utxo[0].nValue-1000, p2sh_scriptPubKey)] p2sh_tx.vout = [CTxOut(self.utxo[0].nValue-100000, p2sh_scriptPubKey)]
p2sh_tx.rehash() p2sh_tx.rehash()
# Mine it on test_node to create the confirmed output. # Mine it on test_node to create the confirmed output.
@ -1143,8 +1143,8 @@ class SegWitTest(BitcoinTestFramework):
# Start by creating a transaction with two outputs. # Start by creating a transaction with two outputs.
tx = CTransaction() tx = CTransaction()
tx.vin = [CTxIn(COutPoint(p2sh_tx.sha256, 0), CScript([witness_program]))] tx.vin = [CTxIn(COutPoint(p2sh_tx.sha256, 0), CScript([witness_program]))]
tx.vout = [CTxOut(p2sh_tx.vout[0].nValue-10000, scriptPubKey)] tx.vout = [CTxOut(p2sh_tx.vout[0].nValue-1000000, scriptPubKey)]
tx.vout.append(CTxOut(8000, scriptPubKey)) # Might burn this later tx.vout.append(CTxOut(800000, scriptPubKey)) # Might burn this later
tx.rehash() tx.rehash()
self.std_node.test_transaction_acceptance(tx, with_witness=True, accepted=segwit_activated) self.std_node.test_transaction_acceptance(tx, with_witness=True, accepted=segwit_activated)
@ -1155,13 +1155,13 @@ class SegWitTest(BitcoinTestFramework):
if segwit_activated: if segwit_activated:
# if tx was accepted, then we spend the second output. # if tx was accepted, then we spend the second output.
tx2.vin = [CTxIn(COutPoint(tx.sha256, 1), b"")] tx2.vin = [CTxIn(COutPoint(tx.sha256, 1), b"")]
tx2.vout = [CTxOut(7000, scriptPubKey)] tx2.vout = [CTxOut(700000, scriptPubKey)]
tx2.wit.vtxinwit.append(CTxInWitness()) tx2.wit.vtxinwit.append(CTxInWitness())
tx2.wit.vtxinwit[0].scriptWitness.stack = [witness_program] tx2.wit.vtxinwit[0].scriptWitness.stack = [witness_program]
else: else:
# if tx wasn't accepted, we just re-spend the p2sh output we started with. # if tx wasn't accepted, we just re-spend the p2sh output we started with.
tx2.vin = [CTxIn(COutPoint(p2sh_tx.sha256, 0), CScript([witness_program]))] tx2.vin = [CTxIn(COutPoint(p2sh_tx.sha256, 0), CScript([witness_program]))]
tx2.vout = [CTxOut(p2sh_tx.vout[0].nValue-1000, scriptPubKey)] tx2.vout = [CTxOut(p2sh_tx.vout[0].nValue-100000, scriptPubKey)]
tx2.rehash() tx2.rehash()
self.std_node.test_transaction_acceptance(tx2, with_witness=True, accepted=segwit_activated) self.std_node.test_transaction_acceptance(tx2, with_witness=True, accepted=segwit_activated)
@ -1173,7 +1173,7 @@ class SegWitTest(BitcoinTestFramework):
# P2PKH output; just send tx's first output back to an anyone-can-spend. # P2PKH output; just send tx's first output back to an anyone-can-spend.
sync_mempools([self.nodes[0], self.nodes[1]]) sync_mempools([self.nodes[0], self.nodes[1]])
tx3.vin = [CTxIn(COutPoint(tx.sha256, 0), b"")] tx3.vin = [CTxIn(COutPoint(tx.sha256, 0), b"")]
tx3.vout = [CTxOut(tx.vout[0].nValue-1000, CScript([OP_TRUE]))] tx3.vout = [CTxOut(tx.vout[0].nValue-100000, CScript([OP_TRUE]))]
tx3.wit.vtxinwit.append(CTxInWitness()) tx3.wit.vtxinwit.append(CTxInWitness())
tx3.wit.vtxinwit[0].scriptWitness.stack = [witness_program] tx3.wit.vtxinwit[0].scriptWitness.stack = [witness_program]
tx3.rehash() tx3.rehash()
@ -1181,7 +1181,7 @@ class SegWitTest(BitcoinTestFramework):
else: else:
# tx and tx2 didn't go anywhere; just clean up the p2sh_tx output. # tx and tx2 didn't go anywhere; just clean up the p2sh_tx output.
tx3.vin = [CTxIn(COutPoint(p2sh_tx.sha256, 0), CScript([witness_program]))] tx3.vin = [CTxIn(COutPoint(p2sh_tx.sha256, 0), CScript([witness_program]))]
tx3.vout = [CTxOut(p2sh_tx.vout[0].nValue-1000, witness_program)] tx3.vout = [CTxOut(p2sh_tx.vout[0].nValue-100000, witness_program)]
tx3.rehash() tx3.rehash()
self.test_node.test_transaction_acceptance(tx3, with_witness=True, accepted=True) self.test_node.test_transaction_acceptance(tx3, with_witness=True, accepted=True)
@ -1201,7 +1201,7 @@ class SegWitTest(BitcoinTestFramework):
if (len(self.utxo) < NUM_TESTS): if (len(self.utxo) < NUM_TESTS):
tx = CTransaction() tx = CTransaction()
tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b"")) tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
split_value = (self.utxo[0].nValue - 4000) // NUM_TESTS split_value = (self.utxo[0].nValue - 400000) // NUM_TESTS
for i in range(NUM_TESTS): for i in range(NUM_TESTS):
tx.vout.append(CTxOut(split_value, CScript([OP_TRUE]))) tx.vout.append(CTxOut(split_value, CScript([OP_TRUE])))
tx.rehash() tx.rehash()
@ -1224,7 +1224,7 @@ class SegWitTest(BitcoinTestFramework):
# First try to spend to a future version segwit scriptPubKey. # First try to spend to a future version segwit scriptPubKey.
scriptPubKey = CScript([CScriptOp(version), witness_hash]) scriptPubKey = CScript([CScriptOp(version), witness_hash])
tx.vin = [CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b"")] tx.vin = [CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b"")]
tx.vout = [CTxOut(self.utxo[0].nValue-1000, scriptPubKey)] tx.vout = [CTxOut(self.utxo[0].nValue-100000, scriptPubKey)]
tx.rehash() tx.rehash()
self.std_node.test_transaction_acceptance(tx, with_witness=True, accepted=False) self.std_node.test_transaction_acceptance(tx, with_witness=True, accepted=False)
self.test_node.test_transaction_acceptance(tx, with_witness=True, accepted=True) self.test_node.test_transaction_acceptance(tx, with_witness=True, accepted=True)
@ -1240,7 +1240,7 @@ class SegWitTest(BitcoinTestFramework):
scriptPubKey = CScript([CScriptOp(OP_1), witness_hash]) scriptPubKey = CScript([CScriptOp(OP_1), witness_hash])
tx2 = CTransaction() tx2 = CTransaction()
tx2.vin = [CTxIn(COutPoint(tx.sha256, 0), b"")] tx2.vin = [CTxIn(COutPoint(tx.sha256, 0), b"")]
tx2.vout = [CTxOut(tx.vout[0].nValue-1000, scriptPubKey)] tx2.vout = [CTxOut(tx.vout[0].nValue-100000, scriptPubKey)]
tx2.wit.vtxinwit.append(CTxInWitness()) tx2.wit.vtxinwit.append(CTxInWitness())
tx2.wit.vtxinwit[0].scriptWitness.stack = [ witness_program ] tx2.wit.vtxinwit[0].scriptWitness.stack = [ witness_program ]
tx2.rehash() tx2.rehash()
@ -1259,7 +1259,7 @@ class SegWitTest(BitcoinTestFramework):
tx3.wit.vtxinwit.append(CTxInWitness()) tx3.wit.vtxinwit.append(CTxInWitness())
total_value += i.nValue total_value += i.nValue
tx3.wit.vtxinwit[-1].scriptWitness.stack = [witness_program] tx3.wit.vtxinwit[-1].scriptWitness.stack = [witness_program]
tx3.vout.append(CTxOut(total_value - 1000, CScript([OP_TRUE]))) tx3.vout.append(CTxOut(total_value - 100000, CScript([OP_TRUE])))
tx3.rehash() tx3.rehash()
# Spending a higher version witness output is not allowed by policy, # Spending a higher version witness output is not allowed by policy,
# even with fRequireStandard=false. # even with fRequireStandard=false.
@ -1327,7 +1327,7 @@ class SegWitTest(BitcoinTestFramework):
assert(len(self.utxo)) assert(len(self.utxo))
tx = CTransaction() tx = CTransaction()
tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b"")) tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
tx.vout.append(CTxOut(self.utxo[0].nValue-1000, scriptPubKey)) tx.vout.append(CTxOut(self.utxo[0].nValue-100000, scriptPubKey))
tx.rehash() tx.rehash()
self.test_node.test_transaction_acceptance(tx, with_witness=True, accepted=True) self.test_node.test_transaction_acceptance(tx, with_witness=True, accepted=True)
@ -1346,7 +1346,7 @@ class SegWitTest(BitcoinTestFramework):
block = self.build_next_block() block = self.build_next_block()
tx = CTransaction() tx = CTransaction()
tx.vin.append(CTxIn(COutPoint(prev_utxo.sha256, prev_utxo.n), b"")) tx.vin.append(CTxIn(COutPoint(prev_utxo.sha256, prev_utxo.n), b""))
tx.vout.append(CTxOut(prev_utxo.nValue - 1000, scriptPubKey)) tx.vout.append(CTxOut(prev_utxo.nValue - 100000, scriptPubKey))
tx.wit.vtxinwit.append(CTxInWitness()) tx.wit.vtxinwit.append(CTxInWitness())
# Too-large input value # Too-large input value
sign_P2PK_witness_input(witness_program, tx, 0, hashtype, prev_utxo.nValue+1, key) sign_P2PK_witness_input(witness_program, tx, 0, hashtype, prev_utxo.nValue+1, key)
@ -1511,7 +1511,7 @@ class SegWitTest(BitcoinTestFramework):
# Fund the P2SH output # Fund the P2SH output
tx = CTransaction() tx = CTransaction()
tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b"")) tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
tx.vout.append(CTxOut(self.utxo[0].nValue-1000, scriptPubKey)) tx.vout.append(CTxOut(self.utxo[0].nValue-100000, scriptPubKey))
tx.rehash() tx.rehash()
# Verify mempool acceptance and block validity # Verify mempool acceptance and block validity
@ -1524,7 +1524,7 @@ class SegWitTest(BitcoinTestFramework):
# Now test attempts to spend the output. # Now test attempts to spend the output.
spend_tx = CTransaction() spend_tx = CTransaction()
spend_tx.vin.append(CTxIn(COutPoint(tx.sha256, 0), scriptSig)) spend_tx.vin.append(CTxIn(COutPoint(tx.sha256, 0), scriptSig))
spend_tx.vout.append(CTxOut(tx.vout[0].nValue-1000, CScript([OP_TRUE]))) spend_tx.vout.append(CTxOut(tx.vout[0].nValue-100000, CScript([OP_TRUE])))
spend_tx.rehash() spend_tx.rehash()
# This transaction should not be accepted into the mempool pre- or # This transaction should not be accepted into the mempool pre- or
@ -1771,7 +1771,7 @@ class SegWitTest(BitcoinTestFramework):
scriptPKH = CScript([OP_0, pubkeyhash]) scriptPKH = CScript([OP_0, pubkeyhash])
tx = CTransaction() tx = CTransaction()
tx.vin.append(CTxIn(COutPoint(utxo.sha256, utxo.n), b"")) tx.vin.append(CTxIn(COutPoint(utxo.sha256, utxo.n), b""))
tx.vout.append(CTxOut(utxo.nValue-1000, scriptPKH)) tx.vout.append(CTxOut(utxo.nValue-100000, scriptPKH))
tx.rehash() tx.rehash()
# Confirm it in a block. # Confirm it in a block.
@ -1787,7 +1787,7 @@ class SegWitTest(BitcoinTestFramework):
tx2 = CTransaction() tx2 = CTransaction()
tx2.vin.append(CTxIn(COutPoint(tx.sha256, 0), b"")) tx2.vin.append(CTxIn(COutPoint(tx.sha256, 0), b""))
tx2.vout.append(CTxOut(tx.vout[0].nValue-1000, scriptWSH)) tx2.vout.append(CTxOut(tx.vout[0].nValue-100000, scriptWSH))
script = GetP2PKHScript(pubkeyhash) script = GetP2PKHScript(pubkeyhash)
sig_hash = SegwitVersion1SignatureHash(script, tx2, 0, SIGHASH_ALL, tx.vout[0].nValue) sig_hash = SegwitVersion1SignatureHash(script, tx2, 0, SIGHASH_ALL, tx.vout[0].nValue)
signature = key.sign(sig_hash) + b'\x01' # 0x1 is SIGHASH_ALL signature = key.sign(sig_hash) + b'\x01' # 0x1 is SIGHASH_ALL
@ -1811,7 +1811,7 @@ class SegWitTest(BitcoinTestFramework):
tx3 = CTransaction() tx3 = CTransaction()
tx3.vin.append(CTxIn(COutPoint(tx2.sha256, 0), b"")) tx3.vin.append(CTxIn(COutPoint(tx2.sha256, 0), b""))
tx3.vout.append(CTxOut(tx2.vout[0].nValue-1000, scriptP2SH)) tx3.vout.append(CTxOut(tx2.vout[0].nValue-100000, scriptP2SH))
tx3.wit.vtxinwit.append(CTxInWitness()) tx3.wit.vtxinwit.append(CTxInWitness())
sign_P2PK_witness_input(witness_program, tx3, 0, SIGHASH_ALL, tx2.vout[0].nValue, key) sign_P2PK_witness_input(witness_program, tx3, 0, SIGHASH_ALL, tx2.vout[0].nValue, key)
@ -1828,7 +1828,7 @@ class SegWitTest(BitcoinTestFramework):
scriptPubKey = GetP2PKHScript(pubkeyhash) scriptPubKey = GetP2PKHScript(pubkeyhash)
tx4 = CTransaction() tx4 = CTransaction()
tx4.vin.append(CTxIn(COutPoint(tx3.sha256, 0), scriptSig)) tx4.vin.append(CTxIn(COutPoint(tx3.sha256, 0), scriptSig))
tx4.vout.append(CTxOut(tx3.vout[0].nValue-1000, scriptPubKey)) tx4.vout.append(CTxOut(tx3.vout[0].nValue-100000, scriptPubKey))
tx4.wit.vtxinwit.append(CTxInWitness()) tx4.wit.vtxinwit.append(CTxInWitness())
sign_P2PK_witness_input(witness_program, tx4, 0, SIGHASH_ALL, tx3.vout[0].nValue, key) sign_P2PK_witness_input(witness_program, tx4, 0, SIGHASH_ALL, tx3.vout[0].nValue, key)
@ -1842,7 +1842,7 @@ class SegWitTest(BitcoinTestFramework):
# transactions. # transactions.
tx5 = CTransaction() tx5 = CTransaction()
tx5.vin.append(CTxIn(COutPoint(tx4.sha256, 0), b"")) tx5.vin.append(CTxIn(COutPoint(tx4.sha256, 0), b""))
tx5.vout.append(CTxOut(tx4.vout[0].nValue-1000, CScript([OP_TRUE]))) tx5.vout.append(CTxOut(tx4.vout[0].nValue-100000, CScript([OP_TRUE])))
(sig_hash, err) = SignatureHash(scriptPubKey, tx5, 0, SIGHASH_ALL) (sig_hash, err) = SignatureHash(scriptPubKey, tx5, 0, SIGHASH_ALL)
signature = key.sign(sig_hash) + b'\x01' # 0x1 is SIGHASH_ALL signature = key.sign(sig_hash) + b'\x01' # 0x1 is SIGHASH_ALL
tx5.vin[0].scriptSig = CScript([signature, pubkey]) tx5.vin[0].scriptSig = CScript([signature, pubkey])
@ -1872,7 +1872,7 @@ class SegWitTest(BitcoinTestFramework):
tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b"")) tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
# For each script, generate a pair of P2WSH and P2SH-P2WSH output. # For each script, generate a pair of P2WSH and P2SH-P2WSH output.
outputvalue = (self.utxo[0].nValue - 1000) // (len(scripts) * 2) outputvalue = (self.utxo[0].nValue - 100000) // (len(scripts) * 2)
for i in scripts: for i in scripts:
p2wsh = CScript([OP_0, sha256(i)]) p2wsh = CScript([OP_0, sha256(i)])
p2sh = hash160(p2wsh) p2sh = hash160(p2wsh)
@ -1892,13 +1892,13 @@ class SegWitTest(BitcoinTestFramework):
for i in range(len(scripts)): for i in range(len(scripts)):
p2wsh_tx = CTransaction() p2wsh_tx = CTransaction()
p2wsh_tx.vin.append(CTxIn(COutPoint(txid,i*2))) p2wsh_tx.vin.append(CTxIn(COutPoint(txid,i*2)))
p2wsh_tx.vout.append(CTxOut(outputvalue - 5000, CScript([OP_0, hash160(hex_str_to_bytes(""))]))) p2wsh_tx.vout.append(CTxOut(outputvalue - 500000, CScript([OP_0, hash160(hex_str_to_bytes(""))])))
p2wsh_tx.wit.vtxinwit.append(CTxInWitness()) p2wsh_tx.wit.vtxinwit.append(CTxInWitness())
p2wsh_tx.rehash() p2wsh_tx.rehash()
p2wsh_txs.append(p2wsh_tx) p2wsh_txs.append(p2wsh_tx)
p2sh_tx = CTransaction() p2sh_tx = CTransaction()
p2sh_tx.vin.append(CTxIn(COutPoint(txid,i*2+1), CScript([p2wsh_scripts[i]]))) p2sh_tx.vin.append(CTxIn(COutPoint(txid,i*2+1), CScript([p2wsh_scripts[i]])))
p2sh_tx.vout.append(CTxOut(outputvalue - 5000, CScript([OP_0, hash160(hex_str_to_bytes(""))]))) p2sh_tx.vout.append(CTxOut(outputvalue - 500000, CScript([OP_0, hash160(hex_str_to_bytes(""))])))
p2sh_tx.wit.vtxinwit.append(CTxInWitness()) p2sh_tx.wit.vtxinwit.append(CTxInWitness())
p2sh_tx.rehash() p2sh_tx.rehash()
p2sh_txs.append(p2sh_tx) p2sh_txs.append(p2sh_tx)

12
qa/rpc-tests/wallet.py
Unescape View File

@ -242,14 +242,14 @@ class WalletTest (BitcoinTestFramework):
txObj = self.nodes[0].gettransaction(txId) txObj = self.nodes[0].gettransaction(txId)
assert_equal(txObj['amount'], Decimal('-2')) assert_equal(txObj['amount'], Decimal('-2'))
txId = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), "0.0001") txId = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), "0.001")
txObj = self.nodes[0].gettransaction(txId) txObj = self.nodes[0].gettransaction(txId)
assert_equal(txObj['amount'], Decimal('-0.0001')) assert_equal(txObj['amount'], Decimal('-0.001'))
#check if JSON parser can handle scientific notation in strings #check if JSON parser can handle scientific notation in strings
txId = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), "1e-4") txId = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), "1e-3")
txObj = self.nodes[0].gettransaction(txId) txObj = self.nodes[0].gettransaction(txId)
assert_equal(txObj['amount'], Decimal('-0.0001')) assert_equal(txObj['amount'], Decimal('-0.001'))
try: try:
txId = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), "1f-4") txId = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), "1f-4")
@ -368,13 +368,13 @@ class WalletTest (BitcoinTestFramework):
sending_addr = self.nodes[1].getnewaddress() sending_addr = self.nodes[1].getnewaddress()
txid_list = [] txid_list = []
for i in range(chainlimit*2): for i in range(chainlimit*2):
txid_list.append(self.nodes[0].sendtoaddress(sending_addr, Decimal('0.0001'))) txid_list.append(self.nodes[0].sendtoaddress(sending_addr, Decimal('0.01')))
assert_equal(self.nodes[0].getmempoolinfo()['size'], chainlimit*2) assert_equal(self.nodes[0].getmempoolinfo()['size'], chainlimit*2)
assert_equal(len(txid_list), chainlimit*2) assert_equal(len(txid_list), chainlimit*2)
# Without walletrejectlongchains, we will still generate a txid # Without walletrejectlongchains, we will still generate a txid
# The tx will be stored in the wallet but not accepted to the mempool # The tx will be stored in the wallet but not accepted to the mempool
extra_txid = self.nodes[0].sendtoaddress(sending_addr, Decimal('0.0001')) extra_txid = self.nodes[0].sendtoaddress(sending_addr, Decimal('0.01'))
assert(extra_txid not in self.nodes[0].getrawmempool()) assert(extra_txid not in self.nodes[0].getrawmempool())
assert(extra_txid in [tx["txid"] for tx in self.nodes[0].listtransactions()]) assert(extra_txid in [tx["txid"] for tx in self.nodes[0].listtransactions()])
self.nodes[0].abandontransaction(extra_txid) self.nodes[0].abandontransaction(extra_txid)

2
src/policy/policy.h
Unescape View File

@ -45,7 +45,7 @@ static const unsigned int MAX_STANDARD_P2WSH_SCRIPT_SIZE = 3600;
* standard and should be done with care and ideally rarely. It makes sense to * standard and should be done with care and ideally rarely. It makes sense to
* only increase the dust limit after prior releases were already not creating * only increase the dust limit after prior releases were already not creating
* outputs below the new threshold */ * outputs below the new threshold */
static const unsigned int DUST_RELAY_TX_FEE = 1000; static const unsigned int DUST_RELAY_TX_FEE = 100000;
/** /**
* Standard script verification flags that standard transactions will comply * Standard script verification flags that standard transactions will comply
* with. However scripts violating these flags may still be present in valid * with. However scripts violating these flags may still be present in valid

2
src/test/transaction_tests.cpp
Unescape View File

@ -691,7 +691,7 @@ BOOST_AUTO_TEST_CASE(test_IsStandard)
// Check dust with default relay fee: // Check dust with default relay fee:
CAmount nDustThreshold = 182 * dustRelayFee.GetFeePerK()/1000 * 3; CAmount nDustThreshold = 182 * dustRelayFee.GetFeePerK()/1000 * 3;
BOOST_CHECK_EQUAL(nDustThreshold, 546); BOOST_CHECK_EQUAL(nDustThreshold, 54600);
// dust: // dust:
t.vout[0].nValue = nDustThreshold - 1; t.vout[0].nValue = nDustThreshold - 1;
BOOST_CHECK(!IsStandardTx(t, reason)); BOOST_CHECK(!IsStandardTx(t, reason));

2
src/validation.h
Unescape View File

@ -52,7 +52,7 @@ static const bool DEFAULT_WHITELISTRELAY = true;
/** Default for DEFAULT_WHITELISTFORCERELAY. */ /** Default for DEFAULT_WHITELISTFORCERELAY. */
static const bool DEFAULT_WHITELISTFORCERELAY = true; static const bool DEFAULT_WHITELISTFORCERELAY = true;
/** Default for -minrelaytxfee, minimum relay fee for transactions */ /** Default for -minrelaytxfee, minimum relay fee for transactions */
static const unsigned int DEFAULT_MIN_RELAY_TX_FEE = 1000; static const unsigned int DEFAULT_MIN_RELAY_TX_FEE = 100000;
//! -maxtxfee default //! -maxtxfee default
static const CAmount DEFAULT_TRANSACTION_MAXFEE = 0.1 * COIN; static const CAmount DEFAULT_TRANSACTION_MAXFEE = 0.1 * COIN;
//! Discourage users to set fees higher than this amount (in satoshis) per kB //! Discourage users to set fees higher than this amount (in satoshis) per kB

4
src/wallet/wallet.h
Unescape View File

@ -46,9 +46,9 @@ static const unsigned int DEFAULT_KEYPOOL_SIZE = 100;
//! -paytxfee default //! -paytxfee default
static const CAmount DEFAULT_TRANSACTION_FEE = 0; static const CAmount DEFAULT_TRANSACTION_FEE = 0;
//! -fallbackfee default //! -fallbackfee default
static const CAmount DEFAULT_FALLBACK_FEE = 20000; static const CAmount DEFAULT_FALLBACK_FEE = 2000000;
//! -mintxfee default //! -mintxfee default
static const CAmount DEFAULT_TRANSACTION_MINFEE = 1000; static const CAmount DEFAULT_TRANSACTION_MINFEE = 100000;
//! minimum recommended increment for BIP 125 replacement txs //! minimum recommended increment for BIP 125 replacement txs
static const CAmount WALLET_INCREMENTAL_RELAY_FEE = 5000; static const CAmount WALLET_INCREMENTAL_RELAY_FEE = 5000;
//! target minimum change amount //! target minimum change amount

Write Preview
Loading…
Cancel
Save