Litecoin: Adjust fee system
# Conflicts: # src/policy/policy.h # src/test/transaction_tests.cpp # src/wallet/wallet.h # test/functional/abandonconflict.py # test/functional/bumpfee.py
This commit is contained in:
Adrian Gallagher
parent
ec665bae20
commit
293d7cac1d
@ -43,7 +43,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
|
||||
* only increase the dust limit after prior releases were already not creating
|
||||
* outputs below the new threshold */
|
||||
static const unsigned int DUST_RELAY_TX_FEE = 3000;
|
||||
static const unsigned int DUST_RELAY_TX_FEE = 300000;
|
||||
/**
|
||||
* Standard script verification flags that standard transactions will comply
|
||||
* with. However scripts violating these flags may still be present in valid
|
||||
|
||||
@ -693,7 +693,7 @@ BOOST_AUTO_TEST_CASE(test_IsStandard)
|
||||
|
||||
// Check dust with default relay fee:
|
||||
CAmount nDustThreshold = 182 * dustRelayFee.GetFeePerK()/1000;
|
||||
BOOST_CHECK_EQUAL(nDustThreshold, 546);
|
||||
BOOST_CHECK_EQUAL(nDustThreshold, 54600);
|
||||
// dust:
|
||||
t.vout[0].nValue = nDustThreshold - 1;
|
||||
BOOST_CHECK(!IsStandardTx(t, reason));
|
||||
|
||||
@ -50,7 +50,7 @@ static const bool DEFAULT_WHITELISTRELAY = true;
|
||||
/** Default for DEFAULT_WHITELISTFORCERELAY. */
|
||||
static const bool DEFAULT_WHITELISTFORCERELAY = true;
|
||||
/** 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
|
||||
static const CAmount DEFAULT_TRANSACTION_MAXFEE = 0.1 * COIN;
|
||||
//! Discourage users to set fees higher than this amount (in satoshis) per kB
|
||||
|
||||
@ -44,11 +44,11 @@ static const unsigned int DEFAULT_KEYPOOL_SIZE = 1000;
|
||||
//! -paytxfee default
|
||||
static const CAmount DEFAULT_TRANSACTION_FEE = 0;
|
||||
//! -fallbackfee default
|
||||
static const CAmount DEFAULT_FALLBACK_FEE = 20000;
|
||||
static const CAmount DEFAULT_FALLBACK_FEE = 2000000;
|
||||
//! -m_discard_rate default
|
||||
static const CAmount DEFAULT_DISCARD_FEE = 10000;
|
||||
//! -mintxfee default
|
||||
static const CAmount DEFAULT_TRANSACTION_MINFEE = 1000;
|
||||
static const CAmount DEFAULT_TRANSACTION_MINFEE = 100000;
|
||||
//! minimum recommended increment for BIP 125 replacement txs
|
||||
static const CAmount WALLET_INCREMENTAL_RELAY_FEE = 5000;
|
||||
//! target minimum change amount
|
||||
|
||||
@ -30,7 +30,7 @@ class AbandonConflictTest(BitcoinTestFramework):
|
||||
|
||||
sync_blocks(self.nodes)
|
||||
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
|
||||
|
||||
# Disconnect nodes so node0's transactions don't get into node1's mempool
|
||||
@ -47,32 +47,32 @@ class AbandonConflictTest(BitcoinTestFramework):
|
||||
inputs.append({"txid":txB, "vout":nB})
|
||||
outputs = {}
|
||||
|
||||
outputs[self.nodes[0].getnewaddress()] = Decimal("14.99998")
|
||||
outputs[self.nodes[0].getnewaddress()] = Decimal("14.998")
|
||||
outputs[self.nodes[1].getnewaddress()] = Decimal("5")
|
||||
signed = self.nodes[0].signrawtransaction(self.nodes[0].createrawtransaction(inputs, outputs))
|
||||
txAB1 = self.nodes[0].sendrawtransaction(signed["hex"])
|
||||
|
||||
# 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
|
||||
inputs = []
|
||||
inputs.append({"txid":txAB1, "vout":nAB})
|
||||
inputs.append({"txid":txC, "vout":nC})
|
||||
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))
|
||||
txABC2 = self.nodes[0].sendrawtransaction(signed2["hex"])
|
||||
|
||||
# In mempool txs from self should increase balance from change
|
||||
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
|
||||
|
||||
# Restart the node with a higher min relay fee so the parent tx is no longer in mempool
|
||||
# TODO: redo with eviction
|
||||
self.stop_node(0)
|
||||
self.start_node(0, extra_args=["-minrelaytxfee=0.0001"])
|
||||
self.start_node(0, extra_args=["-minrelaytxfee=0.01"])
|
||||
|
||||
# Verify txs no longer in either node's mempool
|
||||
assert_equal(len(self.nodes[0].getrawmempool()), 0)
|
||||
@ -81,7 +81,7 @@ class AbandonConflictTest(BitcoinTestFramework):
|
||||
# Not in mempool txs from self should only reduce balance
|
||||
# inputs are still spent, but change not received
|
||||
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
|
||||
# up in unconfirmed balance
|
||||
unconfbalance = self.nodes[0].getunconfirmedbalance() + self.nodes[0].getbalance()
|
||||
@ -99,7 +99,7 @@ class AbandonConflictTest(BitcoinTestFramework):
|
||||
|
||||
# Verify that even with a low min relay fee, the tx is not reaccepted from wallet on startup once abandoned
|
||||
self.stop_node(0)
|
||||
self.start_node(0, extra_args=["-minrelaytxfee=0.00001"])
|
||||
self.start_node(0, extra_args=["-minrelaytxfee=0.001"])
|
||||
assert_equal(len(self.nodes[0].getrawmempool()), 0)
|
||||
assert_equal(self.nodes[0].getbalance(), balance)
|
||||
|
||||
@ -108,21 +108,21 @@ class AbandonConflictTest(BitcoinTestFramework):
|
||||
# But its child tx remains abandoned
|
||||
self.nodes[0].sendrawtransaction(signed["hex"])
|
||||
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
|
||||
|
||||
# Send child tx again so its unabandoned
|
||||
self.nodes[0].sendrawtransaction(signed2["hex"])
|
||||
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
|
||||
|
||||
# Remove using high relay fee again
|
||||
self.stop_node(0)
|
||||
self.start_node(0, extra_args=["-minrelaytxfee=0.0001"])
|
||||
self.start_node(0, extra_args=["-minrelaytxfee=0.01"])
|
||||
assert_equal(len(self.nodes[0].getrawmempool()), 0)
|
||||
newbalance = self.nodes[0].getbalance()
|
||||
assert_equal(newbalance, balance - Decimal("24.9996"))
|
||||
assert_equal(newbalance, balance - Decimal("24.96"))
|
||||
balance = newbalance
|
||||
|
||||
# Create a double spend of AB1 by spending again from only A's 10 output
|
||||
@ -130,7 +130,7 @@ class AbandonConflictTest(BitcoinTestFramework):
|
||||
inputs =[]
|
||||
inputs.append({"txid":txA, "vout":nA})
|
||||
outputs = {}
|
||||
outputs[self.nodes[1].getnewaddress()] = Decimal("9.9999")
|
||||
outputs[self.nodes[1].getnewaddress()] = Decimal("9.99")
|
||||
tx = self.nodes[0].createrawtransaction(inputs, outputs)
|
||||
signed = self.nodes[0].signrawtransaction(tx)
|
||||
self.nodes[1].sendrawtransaction(signed["hex"])
|
||||
|
||||
@ -48,16 +48,16 @@ class BumpFeeTest(BitcoinTestFramework):
|
||||
peer_node, rbf_node = self.nodes
|
||||
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)
|
||||
self.log.info("Mining blocks...")
|
||||
peer_node.generate(110)
|
||||
self.sync_all()
|
||||
for i in range(25):
|
||||
peer_node.sendtoaddress(rbf_node_address, 0.001)
|
||||
peer_node.sendtoaddress(rbf_node_address, 0.1)
|
||||
self.sync_all()
|
||||
peer_node.generate(1)
|
||||
self.sync_all()
|
||||
assert_equal(rbf_node.getbalance(), Decimal("0.025"))
|
||||
assert_equal(rbf_node.getbalance(), Decimal("2.5"))
|
||||
|
||||
self.log.info("Running tests")
|
||||
dest_address = peer_node.getnewaddress()
|
||||
@ -103,7 +103,7 @@ def test_segwit_bumpfee_succeeds(rbf_node, dest_address):
|
||||
# Create a transaction with segwit output, then create an RBF transaction
|
||||
# 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())
|
||||
rbf_node.addwitnessaddress(segwit_out["address"])
|
||||
segwitid = send_to_witness(
|
||||
@ -112,15 +112,15 @@ def test_segwit_bumpfee_succeeds(rbf_node, dest_address):
|
||||
utxo=segwit_in,
|
||||
pubkey=segwit_out["pubkey"],
|
||||
encode_p2sh=False,
|
||||
amount=Decimal("0.0009"),
|
||||
amount=Decimal("0.09"),
|
||||
sign=True)
|
||||
|
||||
rbfraw = rbf_node.createrawtransaction([{
|
||||
'txid': segwitid,
|
||||
'vout': 0,
|
||||
"sequence": BIP125_SEQUENCE_NUMBER
|
||||
}], {dest_address: Decimal("0.0005"),
|
||||
rbf_node.getrawchangeaddress(): Decimal("0.0003")})
|
||||
}], {dest_address: Decimal("0.05"),
|
||||
rbf_node.getrawchangeaddress(): Decimal("0.03")})
|
||||
rbfsigned = rbf_node.signrawtransaction(rbfraw)
|
||||
rbfid = rbf_node.sendrawtransaction(rbfsigned["hex"])
|
||||
assert rbfid in rbf_node.getrawmempool()
|
||||
@ -132,7 +132,7 @@ def test_segwit_bumpfee_succeeds(rbf_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)
|
||||
not_rbfid = peer_node.sendtoaddress(dest_address, Decimal("0.00090000"))
|
||||
not_rbfid = peer_node.sendtoaddress(dest_address, Decimal("0.090000"))
|
||||
assert_raises_rpc_error(-4, "not BIP 125 replaceable", peer_node.bumpfee, not_rbfid)
|
||||
|
||||
|
||||
@ -148,7 +148,7 @@ def test_notmine_bumpfee_fails(rbf_node, peer_node, dest_address):
|
||||
"address": utxo["address"],
|
||||
"sequence": BIP125_SEQUENCE_NUMBER
|
||||
} 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})
|
||||
signedtx = rbf_node.signrawtransaction(rawtx)
|
||||
signedtx = peer_node.signrawtransaction(signedtx["hex"])
|
||||
@ -161,7 +161,7 @@ def test_bumpfee_with_descendant_fails(rbf_node, rbf_node_address, dest_address)
|
||||
# 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_id = spend_one_input(rbf_node, rbf_node_address)
|
||||
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)
|
||||
txid = rbf_node.sendrawtransaction(tx["hex"])
|
||||
assert_raises_rpc_error(-8, "Transaction has descendants in the wallet", rbf_node.bumpfee, parent_id)
|
||||
@ -181,9 +181,9 @@ def test_dust_to_fee(rbf_node, dest_address):
|
||||
# the bumped tx sets fee=49,900, but it converts to 50,000
|
||||
rbfid = spend_one_input(rbf_node, dest_address)
|
||||
fulltx = rbf_node.getrawtransaction(rbfid, 1)
|
||||
bumped_tx = rbf_node.bumpfee(rbfid, {"totalFee": 49900})
|
||||
bumped_tx = rbf_node.bumpfee(rbfid, {"totalFee": 4990000})
|
||||
full_bumped_tx = rbf_node.getrawtransaction(bumped_tx["txid"], 1)
|
||||
assert_equal(bumped_tx["fee"], Decimal("0.00050000"))
|
||||
assert_equal(bumped_tx["fee"], Decimal("0.050000"))
|
||||
assert_equal(len(fulltx["vout"]), 2)
|
||||
assert_equal(len(full_bumped_tx["vout"]), 1) #change output is eliminated
|
||||
|
||||
@ -191,7 +191,7 @@ def test_dust_to_fee(rbf_node, dest_address):
|
||||
def test_settxfee(rbf_node, dest_address):
|
||||
# check that bumpfee reacts correctly to the use of settxfee (paytxfee)
|
||||
rbfid = spend_one_input(rbf_node, dest_address)
|
||||
requested_feerate = Decimal("0.00025000")
|
||||
requested_feerate = Decimal("0.025000")
|
||||
rbf_node.settxfee(requested_feerate)
|
||||
bumped_tx = rbf_node.bumpfee(rbfid)
|
||||
actual_feerate = bumped_tx["fee"] * 1000 / rbf_node.getrawtransaction(bumped_tx["txid"], True)["size"]
|
||||
@ -214,7 +214,7 @@ def test_rebumping_not_replaceable(rbf_node, dest_address):
|
||||
rbfid = spend_one_input(rbf_node, dest_address)
|
||||
bumped = rbf_node.bumpfee(rbfid, {"totalFee": 10000, "replaceable": False})
|
||||
assert_raises_rpc_error(-4, "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):
|
||||
@ -254,7 +254,7 @@ def test_unconfirmed_not_spendable(rbf_node, rbf_node_address):
|
||||
|
||||
|
||||
def test_bumpfee_metadata(rbf_node, dest_address):
|
||||
rbfid = rbf_node.sendtoaddress(dest_address, Decimal("0.00100000"), "comment value", "to value")
|
||||
rbfid = rbf_node.sendtoaddress(dest_address, Decimal("0.100000"), "comment value", "to value")
|
||||
bumped_tx = rbf_node.bumpfee(rbfid)
|
||||
bumped_wtx = rbf_node.gettransaction(bumped_tx["txid"])
|
||||
assert_equal(bumped_wtx["comment"], "comment value")
|
||||
|
||||
@ -91,7 +91,8 @@ class ListTransactionsTest(BitcoinTestFramework):
|
||||
{"category":"receive","amount":Decimal("0.1")},
|
||||
{"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
|
||||
# transactions.
|
||||
|
||||
@ -23,7 +23,7 @@ class MempoolLimitTest(BitcoinTestFramework):
|
||||
#create a mempool tx that will be evicted
|
||||
us0 = utxos.pop()
|
||||
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)
|
||||
self.nodes[0].settxfee(relayfee) # specifically fund this tx with low fee
|
||||
txF = self.nodes[0].fundrawtransaction(tx)
|
||||
|
||||
@ -422,7 +422,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
||||
for i in range(num_transactions):
|
||||
tx = CTransaction()
|
||||
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()
|
||||
utxo = [tx.sha256, 0, tx.vout[0].nValue]
|
||||
block.vtx.append(tx)
|
||||
|
||||
@ -225,7 +225,7 @@ class SegWitTest(BitcoinTestFramework):
|
||||
# to a transaction, eg by violating standardness checks.
|
||||
tx2 = CTransaction()
|
||||
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()
|
||||
self.test_node.test_transaction_acceptance(tx2, False, True)
|
||||
self.nodes[0].generate(1)
|
||||
@ -238,7 +238,7 @@ class SegWitTest(BitcoinTestFramework):
|
||||
# to the rejection cache.
|
||||
tx3 = CTransaction()
|
||||
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[0].scriptWitness.stack = [b'a'*400000]
|
||||
tx3.rehash()
|
||||
@ -252,7 +252,7 @@ class SegWitTest(BitcoinTestFramework):
|
||||
# Now create a new anyone-can-spend utxo for the next test.
|
||||
tx4 = CTransaction()
|
||||
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()
|
||||
self.test_node.test_transaction_acceptance(tx3, False, True)
|
||||
self.test_node.test_transaction_acceptance(tx4, False, True)
|
||||
@ -565,7 +565,7 @@ class SegWitTest(BitcoinTestFramework):
|
||||
# First try extra witness data on a tx that doesn't require a witness
|
||||
tx = CTransaction()
|
||||
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.wit.vtxinwit.append(CTxInWitness())
|
||||
tx.wit.vtxinwit[0].scriptWitness.stack = [CScript([])]
|
||||
@ -640,12 +640,12 @@ class SegWitTest(BitcoinTestFramework):
|
||||
|
||||
tx = CTransaction()
|
||||
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()
|
||||
|
||||
tx2 = CTransaction()
|
||||
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())
|
||||
# First try a 521-byte stack element
|
||||
tx2.wit.vtxinwit[0].scriptWitness.stack = [ b'a'*(MAX_SCRIPT_ELEMENT_SIZE+1), witness_program ]
|
||||
@ -682,12 +682,12 @@ class SegWitTest(BitcoinTestFramework):
|
||||
|
||||
tx = CTransaction()
|
||||
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()
|
||||
|
||||
tx2 = CTransaction()
|
||||
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[0].scriptWitness.stack = [b'a']*44 + [long_witness_program]
|
||||
tx2.rehash()
|
||||
@ -807,7 +807,7 @@ class SegWitTest(BitcoinTestFramework):
|
||||
assert(len(self.utxo))
|
||||
tx = CTransaction()
|
||||
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[0].scriptWitness.stack = [ b'a' ]
|
||||
tx.rehash()
|
||||
@ -859,7 +859,7 @@ class SegWitTest(BitcoinTestFramework):
|
||||
assert(len(self.utxo))
|
||||
tx = CTransaction()
|
||||
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[0].scriptWitness.stack = [ b'a' ]
|
||||
tx.rehash()
|
||||
@ -881,7 +881,7 @@ class SegWitTest(BitcoinTestFramework):
|
||||
scriptPubKey = CScript([OP_0, witness_hash])
|
||||
tx2 = CTransaction()
|
||||
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()
|
||||
|
||||
tx3 = CTransaction()
|
||||
@ -892,7 +892,7 @@ class SegWitTest(BitcoinTestFramework):
|
||||
p2sh_program = CScript([OP_TRUE])
|
||||
p2sh_pubkey = hash160(p2sh_program)
|
||||
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.rehash()
|
||||
|
||||
@ -903,7 +903,7 @@ class SegWitTest(BitcoinTestFramework):
|
||||
self.std_node.test_transaction_acceptance(tx3, True, False, b'tx-size')
|
||||
|
||||
# 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.rehash()
|
||||
|
||||
@ -1047,7 +1047,7 @@ class SegWitTest(BitcoinTestFramework):
|
||||
# First prepare a p2sh output (so that spending it will pass standardness)
|
||||
p2sh_tx = CTransaction()
|
||||
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()
|
||||
|
||||
# Mine it on test_node to create the confirmed output.
|
||||
@ -1059,8 +1059,8 @@ class SegWitTest(BitcoinTestFramework):
|
||||
# Start by creating a transaction with two outputs.
|
||||
tx = CTransaction()
|
||||
tx.vin = [CTxIn(COutPoint(p2sh_tx.sha256, 0), CScript([witness_program]))]
|
||||
tx.vout = [CTxOut(p2sh_tx.vout[0].nValue-10000, scriptPubKey)]
|
||||
tx.vout.append(CTxOut(8000, scriptPubKey)) # Might burn this later
|
||||
tx.vout = [CTxOut(p2sh_tx.vout[0].nValue-1000000, scriptPubKey)]
|
||||
tx.vout.append(CTxOut(800000, scriptPubKey)) # Might burn this later
|
||||
tx.rehash()
|
||||
|
||||
self.std_node.test_transaction_acceptance(tx, with_witness=True, accepted=segwit_activated)
|
||||
@ -1071,13 +1071,13 @@ class SegWitTest(BitcoinTestFramework):
|
||||
if segwit_activated:
|
||||
# if tx was accepted, then we spend the second output.
|
||||
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[0].scriptWitness.stack = [witness_program]
|
||||
else:
|
||||
# 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.vout = [CTxOut(p2sh_tx.vout[0].nValue-1000, scriptPubKey)]
|
||||
tx2.vout = [CTxOut(p2sh_tx.vout[0].nValue-100000, scriptPubKey)]
|
||||
tx2.rehash()
|
||||
|
||||
self.std_node.test_transaction_acceptance(tx2, with_witness=True, accepted=segwit_activated)
|
||||
@ -1089,7 +1089,7 @@ class SegWitTest(BitcoinTestFramework):
|
||||
# P2PKH output; just send tx's first output back to an anyone-can-spend.
|
||||
sync_mempools([self.nodes[0], self.nodes[1]])
|
||||
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[0].scriptWitness.stack = [witness_program]
|
||||
tx3.rehash()
|
||||
@ -1097,7 +1097,7 @@ class SegWitTest(BitcoinTestFramework):
|
||||
else:
|
||||
# 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.vout = [CTxOut(p2sh_tx.vout[0].nValue-1000, witness_program)]
|
||||
tx3.vout = [CTxOut(p2sh_tx.vout[0].nValue-100000, witness_program)]
|
||||
tx3.rehash()
|
||||
self.test_node.test_transaction_acceptance(tx3, with_witness=True, accepted=True)
|
||||
|
||||
@ -1117,7 +1117,7 @@ class SegWitTest(BitcoinTestFramework):
|
||||
if (len(self.utxo) < NUM_TESTS):
|
||||
tx = CTransaction()
|
||||
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):
|
||||
tx.vout.append(CTxOut(split_value, CScript([OP_TRUE])))
|
||||
tx.rehash()
|
||||
@ -1140,7 +1140,7 @@ class SegWitTest(BitcoinTestFramework):
|
||||
# First try to spend to a future version segwit scriptPubKey.
|
||||
scriptPubKey = CScript([CScriptOp(version), witness_hash])
|
||||
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()
|
||||
self.std_node.test_transaction_acceptance(tx, with_witness=True, accepted=False)
|
||||
self.test_node.test_transaction_acceptance(tx, with_witness=True, accepted=True)
|
||||
@ -1156,7 +1156,7 @@ class SegWitTest(BitcoinTestFramework):
|
||||
scriptPubKey = CScript([CScriptOp(OP_1), witness_hash])
|
||||
tx2 = CTransaction()
|
||||
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[0].scriptWitness.stack = [ witness_program ]
|
||||
tx2.rehash()
|
||||
@ -1175,7 +1175,7 @@ class SegWitTest(BitcoinTestFramework):
|
||||
tx3.wit.vtxinwit.append(CTxInWitness())
|
||||
total_value += i.nValue
|
||||
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()
|
||||
# Spending a higher version witness output is not allowed by policy,
|
||||
# even with fRequireStandard=false.
|
||||
@ -1243,7 +1243,7 @@ class SegWitTest(BitcoinTestFramework):
|
||||
assert(len(self.utxo))
|
||||
tx = CTransaction()
|
||||
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()
|
||||
|
||||
self.test_node.test_transaction_acceptance(tx, with_witness=True, accepted=True)
|
||||
@ -1262,7 +1262,7 @@ class SegWitTest(BitcoinTestFramework):
|
||||
block = self.build_next_block()
|
||||
tx = CTransaction()
|
||||
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())
|
||||
# Too-large input value
|
||||
sign_P2PK_witness_input(witness_program, tx, 0, hashtype, prev_utxo.nValue+1, key)
|
||||
@ -1427,7 +1427,7 @@ class SegWitTest(BitcoinTestFramework):
|
||||
# Fund the P2SH output
|
||||
tx = CTransaction()
|
||||
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()
|
||||
|
||||
# Verify mempool acceptance and block validity
|
||||
@ -1440,7 +1440,7 @@ class SegWitTest(BitcoinTestFramework):
|
||||
# Now test attempts to spend the output.
|
||||
spend_tx = CTransaction()
|
||||
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()
|
||||
|
||||
# This transaction should not be accepted into the mempool pre- or
|
||||
@ -1682,7 +1682,7 @@ class SegWitTest(BitcoinTestFramework):
|
||||
scriptPKH = CScript([OP_0, pubkeyhash])
|
||||
tx = CTransaction()
|
||||
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()
|
||||
|
||||
# Confirm it in a block.
|
||||
@ -1698,7 +1698,7 @@ class SegWitTest(BitcoinTestFramework):
|
||||
|
||||
tx2 = CTransaction()
|
||||
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)
|
||||
sig_hash = SegwitVersion1SignatureHash(script, tx2, 0, SIGHASH_ALL, tx.vout[0].nValue)
|
||||
signature = key.sign(sig_hash) + b'\x01' # 0x1 is SIGHASH_ALL
|
||||
@ -1722,7 +1722,7 @@ class SegWitTest(BitcoinTestFramework):
|
||||
|
||||
tx3 = CTransaction()
|
||||
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())
|
||||
sign_P2PK_witness_input(witness_program, tx3, 0, SIGHASH_ALL, tx2.vout[0].nValue, key)
|
||||
|
||||
@ -1739,7 +1739,7 @@ class SegWitTest(BitcoinTestFramework):
|
||||
scriptPubKey = GetP2PKHScript(pubkeyhash)
|
||||
tx4 = CTransaction()
|
||||
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())
|
||||
sign_P2PK_witness_input(witness_program, tx4, 0, SIGHASH_ALL, tx3.vout[0].nValue, key)
|
||||
|
||||
@ -1753,7 +1753,7 @@ class SegWitTest(BitcoinTestFramework):
|
||||
# transactions.
|
||||
tx5 = CTransaction()
|
||||
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)
|
||||
signature = key.sign(sig_hash) + b'\x01' # 0x1 is SIGHASH_ALL
|
||||
tx5.vin[0].scriptSig = CScript([signature, pubkey])
|
||||
@ -1783,7 +1783,7 @@ class SegWitTest(BitcoinTestFramework):
|
||||
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.
|
||||
outputvalue = (self.utxo[0].nValue - 1000) // (len(scripts) * 2)
|
||||
outputvalue = (self.utxo[0].nValue - 100000) // (len(scripts) * 2)
|
||||
for i in scripts:
|
||||
p2wsh = CScript([OP_0, sha256(i)])
|
||||
p2sh = hash160(p2wsh)
|
||||
@ -1803,13 +1803,13 @@ class SegWitTest(BitcoinTestFramework):
|
||||
for i in range(len(scripts)):
|
||||
p2wsh_tx = CTransaction()
|
||||
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.rehash()
|
||||
p2wsh_txs.append(p2wsh_tx)
|
||||
p2sh_tx = CTransaction()
|
||||
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.rehash()
|
||||
p2sh_txs.append(p2sh_tx)
|
||||
|
||||
@ -277,14 +277,14 @@ class WalletTest(BitcoinTestFramework):
|
||||
txObj = self.nodes[0].gettransaction(txId)
|
||||
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)
|
||||
assert_equal(txObj['amount'], Decimal('-0.0001'))
|
||||
assert_equal(txObj['amount'], Decimal('-0.001'))
|
||||
|
||||
#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)
|
||||
assert_equal(txObj['amount'], Decimal('-0.0001'))
|
||||
assert_equal(txObj['amount'], Decimal('-0.001'))
|
||||
|
||||
# This will raise an exception because the amount type is wrong
|
||||
assert_raises_rpc_error(-3, "Invalid amount", self.nodes[0].sendtoaddress, self.nodes[2].getnewaddress(), "1f-4")
|
||||
@ -397,13 +397,13 @@ class WalletTest(BitcoinTestFramework):
|
||||
sending_addr = self.nodes[1].getnewaddress()
|
||||
txid_list = []
|
||||
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(len(txid_list), chainlimit*2)
|
||||
|
||||
# Without walletrejectlongchains, we will still generate a txid
|
||||
# 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 in [tx["txid"] for tx in self.nodes[0].listtransactions()])
|
||||
self.nodes[0].abandontransaction(extra_txid)
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user