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.16
Adrian Gallagher 7 years ago
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
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. 10
      src/qt/forms/sendcoinsdialog.ui
  2. 13
      src/qt/sendcoinsdialog.cpp
  3. 15
      src/qt/test/wallettests.cpp
  4. 2
      src/validation.h
  5. 4
      src/wallet/wallet.h
  6. 4
      test/functional/mempool_limit.py
  7. 2
      test/functional/p2p_compactblocks.py
  8. 72
      test/functional/p2p_segwit.py
  9. 2
      test/functional/rpc_fundrawtransaction.py
  10. 4
      test/functional/rpc_listtransactions.py
  11. 26
      test/functional/wallet_abandonconflict.py
  12. 12
      test/functional/wallet_basic.py
  13. 34
      test/functional/wallet_bumpfee.py

10
src/qt/forms/sendcoinsdialog.ui
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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")

Write Preview
Loading…
Cancel
Save