kvazar/kevacoin
1
0
Fork 0
mirror of https://github.com/kvazar-network/kevacoin.git synced 2025-01-11 15:48:05 +00:00
Code Issues Projects Releases Wiki Activity

Litecoin: Adjust fee system

Browse Source
This commit is contained in:
Adrian Gallagher 2018-02-14 15:08:46 -08:00
parent 9ceb94dcff
commit f117e96e0f
No known key found for this signature in database
GPG Key ID: FE3348877809386C
13 changed files with 102 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/qt/forms/sendcoinsdialog.ui
View File

@ -1105,16 +1105,6 @@
</item> </item>
</layout> </layout>
</item> </item>
<item>
<widget class="QCheckBox" name="optInRBF">
<property name="text">
<string>Enable Replace-By-Fee</string>
</property>
<property name="toolTip">
<string>With Replace-By-Fee (BIP-125) you can increase a transaction's fee after it is sent. Without this, a higher fee may be recommended to compensate for increased transaction delay risk.</string>
</property>
</widget>
</item>
</layout> </layout>
</widget> </widget>
</item> </item>

13
src/qt/sendcoinsdialog.cpp
View File

@ -173,15 +173,17 @@ void SendCoinsDialog::setModel(WalletModel *_model)
connect(ui->checkBoxMinimumFee, SIGNAL(stateChanged(int)), this, SLOT(setMinimumFee())); connect(ui->checkBoxMinimumFee, SIGNAL(stateChanged(int)), this, SLOT(setMinimumFee()));
connect(ui->checkBoxMinimumFee, SIGNAL(stateChanged(int)), this, SLOT(updateFeeSectionControls())); connect(ui->checkBoxMinimumFee, SIGNAL(stateChanged(int)), this, SLOT(updateFeeSectionControls()));
connect(ui->checkBoxMinimumFee, SIGNAL(stateChanged(int)), this, SLOT(coinControlUpdateLabels())); connect(ui->checkBoxMinimumFee, SIGNAL(stateChanged(int)), this, SLOT(coinControlUpdateLabels()));
connect(ui->optInRBF, SIGNAL(stateChanged(int)), this, SLOT(updateSmartFeeLabel())); // Litecoin: Disable RBF
connect(ui->optInRBF, SIGNAL(stateChanged(int)), this, SLOT(coinControlUpdateLabels())); // connect(ui->optInRBF, SIGNAL(stateChanged(int)), this, SLOT(updateSmartFeeLabel()));
// connect(ui->optInRBF, SIGNAL(stateChanged(int)), this, SLOT(coinControlUpdateLabels()));
ui->customFee->setSingleStep(GetRequiredFee(1000)); ui->customFee->setSingleStep(GetRequiredFee(1000));
updateFeeSectionControls(); updateFeeSectionControls();
updateMinFeeLabel(); updateMinFeeLabel();
updateSmartFeeLabel(); updateSmartFeeLabel();
// set default rbf checkbox state // set default rbf checkbox state
ui->optInRBF->setCheckState(Qt::Checked); // Litecoin: Disable RBF
// ui->optInRBF->setCheckState(Qt::Checked);
// set the smartfee-sliders default value (wallets default conf.target or last stored value) // set the smartfee-sliders default value (wallets default conf.target or last stored value)
QSettings settings; QSettings settings;
@ -339,6 +341,7 @@ void SendCoinsDialog::on_sendButton_clicked()
questionString.append(QString("<span style='font-size:10pt;font-weight:normal;'><br />(=%1)</span>") questionString.append(QString("<span style='font-size:10pt;font-weight:normal;'><br />(=%1)</span>")
.arg(alternativeUnits.join(" " + tr("or") + "<br />"))); .arg(alternativeUnits.join(" " + tr("or") + "<br />")));
/* Litecoin: Disable RBF
questionString.append("<hr /><span>"); questionString.append("<hr /><span>");
if (ui->optInRBF->isChecked()) { if (ui->optInRBF->isChecked()) {
questionString.append(tr("You can increase the fee later (signals Replace-By-Fee, BIP-125).")); questionString.append(tr("You can increase the fee later (signals Replace-By-Fee, BIP-125)."));
@ -346,6 +349,7 @@ void SendCoinsDialog::on_sendButton_clicked()
questionString.append(tr("Not signalling Replace-By-Fee, BIP-125.")); questionString.append(tr("Not signalling Replace-By-Fee, BIP-125."));
} }
questionString.append("</span>"); questionString.append("</span>");
*/
SendConfirmationDialog confirmationDialog(tr("Confirm send coins"), SendConfirmationDialog confirmationDialog(tr("Confirm send coins"),
@ -672,7 +676,8 @@ void SendCoinsDialog::updateCoinControlState(CCoinControl& ctrl)
// Avoid using global defaults when sending money from the GUI // Avoid using global defaults when sending money from the GUI
// Either custom fee will be used or if not selected, the confirmation target from dropdown box // Either custom fee will be used or if not selected, the confirmation target from dropdown box
ctrl.m_confirm_target = getConfTargetForIndex(ui->confTargetSelector->currentIndex()); ctrl.m_confirm_target = getConfTargetForIndex(ui->confTargetSelector->currentIndex());
ctrl.signalRbf = ui->optInRBF->isChecked(); // Litecoin: Disabled RBF UI
//ctrl.signalRbf = ui->optInRBF->isChecked();
} }
void SendCoinsDialog::updateSmartFeeLabel() void SendCoinsDialog::updateSmartFeeLabel()

15
src/qt/test/wallettests.cpp
View File

@ -32,6 +32,7 @@
namespace namespace
{ {
//! Press "Ok" button in message box dialog. //! Press "Ok" button in message box dialog.
/* Litecoin: Disable RBF
void ConfirmMessage(QString* text = nullptr) void ConfirmMessage(QString* text = nullptr)
{ {
QTimer::singleShot(0, makeCallback([text](Callback* callback) { QTimer::singleShot(0, makeCallback([text](Callback* callback) {
@ -45,6 +46,7 @@ void ConfirmMessage(QString* text = nullptr)
delete callback; delete callback;
}), SLOT(call())); }), SLOT(call()));
} }
*/
//! Press "Yes" or "Cancel" buttons in modal send confirmation dialog. //! Press "Yes" or "Cancel" buttons in modal send confirmation dialog.
void ConfirmSend(QString* text = nullptr, bool cancel = false) void ConfirmSend(QString* text = nullptr, bool cancel = false)
@ -70,10 +72,12 @@ uint256 SendCoins(CWallet& wallet, SendCoinsDialog& sendCoinsDialog, const CTxDe
SendCoinsEntry* entry = qobject_cast<SendCoinsEntry*>(entries->itemAt(0)->widget()); SendCoinsEntry* entry = qobject_cast<SendCoinsEntry*>(entries->itemAt(0)->widget());
entry->findChild<QValidatedLineEdit*>("payTo")->setText(QString::fromStdString(EncodeDestination(address))); entry->findChild<QValidatedLineEdit*>("payTo")->setText(QString::fromStdString(EncodeDestination(address)));
entry->findChild<BitcoinAmountField*>("payAmount")->setValue(amount); entry->findChild<BitcoinAmountField*>("payAmount")->setValue(amount);
/* Litecoin: Disabled RBF UI
sendCoinsDialog.findChild<QFrame*>("frameFee") sendCoinsDialog.findChild<QFrame*>("frameFee")
->findChild<QFrame*>("frameFeeSelection") ->findChild<QFrame*>("frameFeeSelection")
->findChild<QCheckBox*>("optInRBF") ->findChild<QCheckBox*>("optInRBF")
->setCheckState(rbf ? Qt::Checked : Qt::Unchecked); ->setCheckState(rbf ? Qt::Checked : Qt::Unchecked);
*/
uint256 txid; uint256 txid;
boost::signals2::scoped_connection c(wallet.NotifyTransactionChanged.connect([&txid](CWallet*, const uint256& hash, ChangeType status) { boost::signals2::scoped_connection c(wallet.NotifyTransactionChanged.connect([&txid](CWallet*, const uint256& hash, ChangeType status) {
if (status == CT_NEW) txid = hash; if (status == CT_NEW) txid = hash;
@ -98,6 +102,7 @@ QModelIndex FindTx(const QAbstractItemModel& model, const uint256& txid)
} }
//! Request context menu (call method that is public in qt5, but protected in qt4). //! Request context menu (call method that is public in qt5, but protected in qt4).
/* Litecoin: Disable RBF
void RequestContextMenu(QWidget* widget) void RequestContextMenu(QWidget* widget)
{ {
class Qt4Hack : public QWidget class Qt4Hack : public QWidget
@ -133,6 +138,7 @@ void BumpFee(TransactionView& view, const uint256& txid, bool expectDisabled, st
action->trigger(); action->trigger();
QVERIFY(text.indexOf(QString::fromStdString(expectError)) != -1); QVERIFY(text.indexOf(QString::fromStdString(expectError)) != -1);
} }
*/
//! Simple qt wallet tests. //! Simple qt wallet tests.
// //
@ -194,10 +200,11 @@ void TestGUI()
QVERIFY(FindTx(*transactionTableModel, txid2).isValid()); QVERIFY(FindTx(*transactionTableModel, txid2).isValid());
// Call bumpfee. Test disabled, canceled, enabled, then failing cases. // Call bumpfee. Test disabled, canceled, enabled, then failing cases.
BumpFee(transactionView, txid1, true /* expect disabled */, "not BIP 125 replaceable" /* expected error */, false /* cancel */); // Litecoin: Disable BumpFee tests
BumpFee(transactionView, txid2, false /* expect disabled */, {} /* expected error */, true /* cancel */); // BumpFee(transactionView, txid1, true /* expect disabled */, "not BIP 125 replaceable" /* expected error */, false /* cancel */);
BumpFee(transactionView, txid2, false /* expect disabled */, {} /* expected error */, false /* cancel */); // BumpFee(transactionView, txid2, false /* expect disabled */, {} /* expected error */, true /* cancel */);
BumpFee(transactionView, txid2, true /* expect disabled */, "already bumped" /* expected error */, false /* cancel */); // BumpFee(transactionView, txid2, false /* expect disabled */, {} /* expected error */, false /* cancel */);
// BumpFee(transactionView, txid2, true /* expect disabled */, "already bumped" /* expected error */, false /* cancel */);
// Check current balance on OverviewPage // Check current balance on OverviewPage
OverviewPage overviewPage(platformStyle.get()); OverviewPage overviewPage(platformStyle.get());

2
src/validation.h
View File

@ -134,7 +134,7 @@ static const unsigned int DEFAULT_BANSCORE_THRESHOLD = 100;
/** Default for -persistmempool */ /** Default for -persistmempool */
static const bool DEFAULT_PERSIST_MEMPOOL = true; static const bool DEFAULT_PERSIST_MEMPOOL = true;
/** Default for -mempoolreplacement */ /** Default for -mempoolreplacement */
static const bool DEFAULT_ENABLE_REPLACEMENT = true; static const bool DEFAULT_ENABLE_REPLACEMENT = false;
/** Default for using fee filter */ /** Default for using fee filter */
static const bool DEFAULT_FEEFILTER = true; static const bool DEFAULT_FEEFILTER = true;

4
src/wallet/wallet.h
View File

@ -44,11 +44,11 @@ static const unsigned int DEFAULT_KEYPOOL_SIZE = 1000;
//! -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;
//! -m_discard_rate default //! -m_discard_rate default
static const CAmount DEFAULT_DISCARD_FEE = 10000; static const CAmount DEFAULT_DISCARD_FEE = 10000;
//! -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

4
test/functional/mempool_limit.py
View File

@ -11,7 +11,7 @@ class MempoolLimitTest(BitcoinTestFramework):
def set_test_params(self): def set_test_params(self):
self.setup_clean_chain = True self.setup_clean_chain = True
self.num_nodes = 1 self.num_nodes = 1
self.extra_args = [["-maxmempool=5", "-spendzeroconfchange=0"]] self.extra_args = [["-maxmempool=5", "-mintxfee=0.00001", "-spendzeroconfchange=0"]]
def run_test(self): def run_test(self):
txouts = gen_return_txouts() txouts = gen_return_txouts()
@ -27,7 +27,7 @@ class MempoolLimitTest(BitcoinTestFramework):
self.log.info('Create a mempool tx that will be evicted') self.log.info('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(relayfee) # specifically fund this tx with low fee self.nodes[0].settxfee(relayfee) # specifically fund this tx with low fee
txF = self.nodes[0].fundrawtransaction(tx) txF = self.nodes[0].fundrawtransaction(tx)

2
test/functional/p2p_compactblocks.py
View File

@ -425,7 +425,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
test/functional/p2p_segwit.py
View File

@ -232,7 +232,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()
test_transaction_acceptance(self.nodes[0].rpc, self.test_node, tx2, False, True) test_transaction_acceptance(self.nodes[0].rpc, self.test_node, tx2, False, True)
self.nodes[0].generate(1) self.nodes[0].generate(1)
@ -245,7 +245,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()
@ -259,7 +259,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()
test_transaction_acceptance(self.nodes[0].rpc, self.test_node, tx3, False, True) test_transaction_acceptance(self.nodes[0].rpc, self.test_node, tx3, False, True)
test_transaction_acceptance(self.nodes[0].rpc, self.test_node, tx4, False, True) test_transaction_acceptance(self.nodes[0].rpc, self.test_node, tx4, False, True)
@ -572,7 +572,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([])]
@ -647,12 +647,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 ]
@ -689,12 +689,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()
@ -814,7 +814,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()
@ -866,7 +866,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()
@ -888,7 +888,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()
@ -899,7 +899,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()
@ -910,7 +910,7 @@ class SegWitTest(BitcoinTestFramework):
test_transaction_acceptance(self.nodes[1].rpc, self.std_node, tx3, True, False, b'tx-size') test_transaction_acceptance(self.nodes[1].rpc, self.std_node, 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()
@ -1054,7 +1054,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.
@ -1066,8 +1066,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()
test_transaction_acceptance(self.nodes[1].rpc, self.std_node, tx, with_witness=True, accepted=segwit_activated) test_transaction_acceptance(self.nodes[1].rpc, self.std_node, tx, with_witness=True, accepted=segwit_activated)
@ -1078,13 +1078,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()
test_transaction_acceptance(self.nodes[1].rpc, self.std_node, tx2, with_witness=True, accepted=segwit_activated) test_transaction_acceptance(self.nodes[1].rpc, self.std_node, tx2, with_witness=True, accepted=segwit_activated)
@ -1096,7 +1096,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()
@ -1104,7 +1104,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()
test_transaction_acceptance(self.nodes[0].rpc, self.test_node, tx3, with_witness=True, accepted=True) test_transaction_acceptance(self.nodes[0].rpc, self.test_node, tx3, with_witness=True, accepted=True)
@ -1124,7 +1124,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()
@ -1147,7 +1147,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()
test_transaction_acceptance(self.nodes[1].rpc, self.std_node, tx, with_witness=True, accepted=False) test_transaction_acceptance(self.nodes[1].rpc, self.std_node, tx, with_witness=True, accepted=False)
test_transaction_acceptance(self.nodes[0].rpc, self.test_node, tx, with_witness=True, accepted=True) test_transaction_acceptance(self.nodes[0].rpc, self.test_node, tx, with_witness=True, accepted=True)
@ -1163,7 +1163,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()
@ -1182,7 +1182,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.
@ -1250,7 +1250,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()
test_transaction_acceptance(self.nodes[0].rpc, self.test_node, tx, with_witness=True, accepted=True) test_transaction_acceptance(self.nodes[0].rpc, self.test_node, tx, with_witness=True, accepted=True)
@ -1269,7 +1269,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)
@ -1436,7 +1436,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
@ -1449,7 +1449,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
@ -1691,7 +1691,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.
@ -1707,7 +1707,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
@ -1731,7 +1731,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)
@ -1748,7 +1748,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)
@ -1762,7 +1762,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])
@ -1792,7 +1792,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)
@ -1812,13 +1812,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)

2
test/functional/rpc_fundrawtransaction.py
View File

@ -637,7 +637,7 @@ class RawTransactionsTest(BitcoinTestFramework):
inputs = [] inputs = []
outputs = {self.nodes[3].getnewaddress() : 1} outputs = {self.nodes[3].getnewaddress() : 1}
rawtx = self.nodes[3].createrawtransaction(inputs, outputs) rawtx = self.nodes[3].createrawtransaction(inputs, outputs)
result = self.nodes[3].fundrawtransaction(rawtx) # uses min_relay_tx_fee (set by settxfee) result = self.nodes[3].fundrawtransaction(rawtx, {"feeRate": 1*min_relay_tx_fee}) # uses min_relay_tx_fee (set by settxfee)
result2 = self.nodes[3].fundrawtransaction(rawtx, {"feeRate": 2*min_relay_tx_fee}) result2 = self.nodes[3].fundrawtransaction(rawtx, {"feeRate": 2*min_relay_tx_fee})
result3 = self.nodes[3].fundrawtransaction(rawtx, {"feeRate": 10*min_relay_tx_fee}) result3 = self.nodes[3].fundrawtransaction(rawtx, {"feeRate": 10*min_relay_tx_fee})
result_fee_rate = result['fee'] * 1000 / count_bytes(result['hex']) result_fee_rate = result['fee'] * 1000 / count_bytes(result['hex'])

4
test/functional/rpc_listtransactions.py
View File

@ -91,8 +91,8 @@ class ListTransactionsTest(BitcoinTestFramework):
assert_array_result(self.nodes[0].listtransactions("watchonly", 100, 0, True), assert_array_result(self.nodes[0].listtransactions("watchonly", 100, 0, True),
{"category":"receive","amount":Decimal("0.1")}, {"category":"receive","amount":Decimal("0.1")},
{"txid":txid, "account" : "watchonly"} ) {"txid":txid, "account" : "watchonly"} )
# Litecoin has RBF disabled
self.run_rbf_opt_in_test() # 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.

26
test/functional/wallet_abandonconflict.py
View File

@ -30,7 +30,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
# Disconnect nodes so node0's transactions don't get into node1's mempool # 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}) 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
self.stop_node(0) 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 # Verify txs no longer in either node's mempool
assert_equal(len(self.nodes[0].getrawmempool()), 0) 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 # 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()
@ -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 # 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.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(len(self.nodes[0].getrawmempool()), 0)
assert_equal(self.nodes[0].getbalance(), balance) assert_equal(self.nodes[0].getbalance(), balance)
@ -108,21 +108,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
self.stop_node(0) 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) 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
@ -130,7 +130,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"])

12
test/functional/wallet_basic.py
View File

@ -291,14 +291,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'))
# This will raise an exception because the amount type is wrong # 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") assert_raises_rpc_error(-3, "Invalid amount", self.nodes[0].sendtoaddress, self.nodes[2].getnewaddress(), "1f-4")
@ -411,13 +411,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)

34
test/functional/wallet_bumpfee.py
View File

@ -15,7 +15,7 @@ make assumptions about execution order.
""" """
from test_framework.blocktools import send_to_witness from test_framework.blocktools import send_to_witness
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework, SkipTest
from test_framework import blocktools from test_framework import blocktools
from test_framework.mininode import CTransaction from test_framework.mininode import CTransaction
from test_framework.util import * from test_framework.util import *
@ -37,6 +37,8 @@ class BumpFeeTest(BitcoinTestFramework):
for i in range(self.num_nodes)] for i in range(self.num_nodes)]
def run_test(self): def run_test(self):
raise SkipTest("Litecoin doesn't support RBF.")
# Encrypt wallet for test_locked_wallet_fails test # Encrypt wallet for test_locked_wallet_fails test
self.nodes[1].node_encrypt_wallet(WALLET_PASSPHRASE) self.nodes[1].node_encrypt_wallet(WALLET_PASSPHRASE)
self.start_node(1) self.start_node(1)
@ -48,16 +50,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)
self.log.info("Mining blocks...") self.log.info("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"))
self.log.info("Running tests") self.log.info("Running tests")
dest_address = peer_node.getnewaddress() dest_address = peer_node.getnewaddress()
@ -103,7 +105,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(
@ -112,15 +114,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"),
rbf_node.getrawchangeaddress(): Decimal("0.0003")}) rbf_node.getrawchangeaddress(): 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()
@ -132,7 +134,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 = 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) assert_raises_rpc_error(-4, "not BIP 125 replaceable", peer_node.bumpfee, not_rbfid)
@ -148,7 +150,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"])
@ -161,7 +163,7 @@ 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 = spend_one_input(rbf_node, rbf_node_address) 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) tx = rbf_node.signrawtransaction(tx)
rbf_node.sendrawtransaction(tx["hex"]) rbf_node.sendrawtransaction(tx["hex"])
assert_raises_rpc_error(-8, "Transaction has descendants in the wallet", rbf_node.bumpfee, parent_id) assert_raises_rpc_error(-8, "Transaction has descendants in the wallet", rbf_node.bumpfee, parent_id)
@ -181,9 +183,9 @@ def test_dust_to_fee(rbf_node, dest_address):
# the bumped tx sets fee=49,900, but it converts to 50,000 # the bumped tx sets fee=49,900, but it converts to 50,000
rbfid = spend_one_input(rbf_node, dest_address) rbfid = spend_one_input(rbf_node, dest_address)
fulltx = rbf_node.getrawtransaction(rbfid, 1) 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) 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(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
@ -191,7 +193,7 @@ 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)
rbfid = spend_one_input(rbf_node, dest_address) rbfid = spend_one_input(rbf_node, dest_address)
requested_feerate = Decimal("0.00025000") requested_feerate = Decimal("0.025000")
rbf_node.settxfee(requested_feerate) rbf_node.settxfee(requested_feerate)
bumped_tx = rbf_node.bumpfee(rbfid) bumped_tx = rbf_node.bumpfee(rbfid)
actual_feerate = bumped_tx["fee"] * 1000 / rbf_node.getrawtransaction(bumped_tx["txid"], True)["vsize"] actual_feerate = bumped_tx["fee"] * 1000 / rbf_node.getrawtransaction(bumped_tx["txid"], True)["vsize"]
@ -214,7 +216,7 @@ def test_rebumping_not_replaceable(rbf_node, dest_address):
rbfid = spend_one_input(rbf_node, dest_address) rbfid = spend_one_input(rbf_node, dest_address)
bumped = rbf_node.bumpfee(rbfid, {"totalFee": 10000, "replaceable": False}) 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"], 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): def test_unconfirmed_not_spendable(rbf_node, rbf_node_address):
@ -254,7 +256,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, 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_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")