sikkienl/dash
1
0
Fork 0
mirror of https://github.com/dashpay/dash.git synced 2024-12-26 04:22:55 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge bitcoin/bitcoin#21178: test: run mempool_reorg.py even with wallet disabled

Browse Source 
a3f0cbf82ddae2dd83001a9cc3a7948dcfb6fa47 test: run mempool_reorg.py even with wallet disabled (Darius Parvin)

Pull request description:

  Run mempool_reorg.py test even when the wallet is disabled, as discussed in #20078.

  As part of this PR I created a new method in `MiniWallet`, `create_self_transfer`, to return a raw tx (without broadcasting it) and its associated utxo.

ACKs for top commit:
  MarcoFalke:
    cr ACK a3f0cbf82ddae2dd83001a9cc3a7948dcfb6fa47

Tree-SHA512: 316a38faffadcb87499c1d6eca21e9696cef65362bbffcf621788a9b771bb1fa2971b1c7835cbd34b952d7612ad83afbca824cd8be39ecd6b994e8963027f991
This commit is contained in:
MarcoFalke 2021-06-01 15:04:55 +02:00 committed by Konstantin Akimov
parent f1f5723fcf
commit fd94de6888
No known key found for this signature in database
GPG Key ID: 2176C4A5D01EA524
2 changed files with 58 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

110
test/functional/mempool_reorg.py
View File

@ -8,13 +8,9 @@ Test re-org scenarios with a mempool that contains transactions
that spend (directly or indirectly) coinbase transactions. that spend (directly or indirectly) coinbase transactions.
""" """
from test_framework.blocktools import (
COINBASE_MATURITY,
create_raw_transaction,
)
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import assert_equal, assert_raises_rpc_error from test_framework.util import assert_equal, assert_raises_rpc_error
from test_framework.wallet import MiniWallet
class MempoolCoinbaseTest(BitcoinTestFramework): class MempoolCoinbaseTest(BitcoinTestFramework):
def set_test_params(self): def set_test_params(self):
@ -26,86 +22,90 @@ class MempoolCoinbaseTest(BitcoinTestFramework):
[] []
] ]
def skip_test_if_missing_module(self):
self.skip_if_no_wallet()
def run_test(self): def run_test(self):
wallet = MiniWallet(self.nodes[0])
# Start with a 200 block chain # Start with a 200 block chain
assert_equal(self.nodes[0].getblockcount(), 200) assert_equal(self.nodes[0].getblockcount(), 200)
# Mine four blocks. After this, nodes[0] blocks self.log.info("Add 4 coinbase utxos to the miniwallet")
# 101, 102, and 103 are spend-able. # Block 76 contains the first spendable coinbase txs.
new_blocks = self.nodes[1].generate(4) first_block = 76
self.sync_all() wallet.scan_blocks(start=first_block, num=4)
node0_address = self.nodes[0].getnewaddress()
node1_address = self.nodes[1].getnewaddress()
# Three scenarios for re-orging coinbase spends in the memory pool: # Three scenarios for re-orging coinbase spends in the memory pool:
# 1. Direct coinbase spend : spend_101 # 1. Direct coinbase spend : spend_1
# 2. Indirect (coinbase spend in chain, child in mempool) : spend_102 and spend_102_1 # 2. Indirect (coinbase spend in chain, child in mempool) : spend_2 and spend_2_1
# 3. Indirect (coinbase and child both in chain) : spend_103 and spend_103_1 # 3. Indirect (coinbase and child both in chain) : spend_3 and spend_3_1
# Use invalidatblock to make all of the above coinbase spends invalid (immature coinbase), # Use invalidateblock to make all of the above coinbase spends invalid (immature coinbase),
# and make sure the mempool code behaves correctly. # and make sure the mempool code behaves correctly.
b = [self.nodes[0].getblockhash(n) for n in range(COINBASE_MATURITY + 1, COINBASE_MATURITY + 5)] b = [self.nodes[0].getblockhash(n) for n in range(first_block, first_block+4)]
coinbase_txids = [self.nodes[0].getblock(h)['tx'][0] for h in b] coinbase_txids = [self.nodes[0].getblock(h)['tx'][0] for h in b]
spend_101_raw = create_raw_transaction(self.nodes[0], coinbase_txids[1], node1_address, amount=499.99) utxo_1 = wallet.get_utxo(txid=coinbase_txids[1])
spend_102_raw = create_raw_transaction(self.nodes[0], coinbase_txids[2], node0_address, amount=499.99) utxo_2 = wallet.get_utxo(txid=coinbase_txids[2])
spend_103_raw = create_raw_transaction(self.nodes[0], coinbase_txids[3], node0_address, amount=499.99) utxo_3 = wallet.get_utxo(txid=coinbase_txids[3])
self.log.info("Create three transactions spending from coinbase utxos: spend_1, spend_2, spend_3")
spend_1 = wallet.create_self_transfer(from_node=self.nodes[0], utxo_to_spend=utxo_1)
spend_2 = wallet.create_self_transfer(from_node=self.nodes[0], utxo_to_spend=utxo_2)
spend_3 = wallet.create_self_transfer(from_node=self.nodes[0], utxo_to_spend=utxo_3)
# Create a transaction which is time-locked to two blocks in the future self.log.info("Create another transaction which is time-locked to two blocks in the future")
timelock_tx = self.nodes[0].createrawtransaction( utxo = wallet.get_utxo(txid=coinbase_txids[0])
inputs=[{ timelock_tx = wallet.create_self_transfer(
"txid": coinbase_txids[0], from_node=self.nodes[0],
"vout": 0, utxo_to_spend=utxo,
}], mempool_valid=False,
outputs={node0_address: 499.99}, locktime=self.nodes[0].getblockcount() + 2
locktime=self.nodes[0].getblockcount() + 2, )['hex']
)
timelock_tx = self.nodes[0].signrawtransactionwithwallet(timelock_tx)["hex"] self.log.info("Check that the time-locked transaction is too immature to spend")
# This will raise an exception because the timelock transaction is too immature to spend
assert_raises_rpc_error(-26, "non-final", self.nodes[0].sendrawtransaction, timelock_tx) assert_raises_rpc_error(-26, "non-final", self.nodes[0].sendrawtransaction, timelock_tx)
# Broadcast and mine spend_102 and 103: self.log.info("Broadcast and mine spend_2 and spend_3")
spend_102_id = self.nodes[0].sendrawtransaction(spend_102_raw) wallet.sendrawtransaction(from_node=self.nodes[0], tx_hex=spend_2['hex'])
spend_103_id = self.nodes[0].sendrawtransaction(spend_103_raw) wallet.sendrawtransaction(from_node=self.nodes[0], tx_hex=spend_3['hex'])
self.log.info("Generate a block")
self.nodes[0].generate(1) self.nodes[0].generate(1)
# Time-locked transaction is still too immature to spend self.log.info("Check that time-locked transaction is still too immature to spend")
assert_raises_rpc_error(-26, 'non-final', self.nodes[0].sendrawtransaction, timelock_tx) assert_raises_rpc_error(-26, 'non-final', self.nodes[0].sendrawtransaction, timelock_tx)
# Create 102_1 and 103_1: self.log.info("Create spend_2_1 and spend_3_1")
spend_102_1_raw = create_raw_transaction(self.nodes[0], spend_102_id, node1_address, amount=499.98) spend_2_utxo = wallet.get_utxo(txid=spend_2['txid'])
spend_103_1_raw = create_raw_transaction(self.nodes[0], spend_103_id, node1_address, amount=499.98) spend_2_1 = wallet.create_self_transfer(from_node=self.nodes[0], utxo_to_spend=spend_2_utxo)
spend_3_utxo = wallet.get_utxo(txid=spend_3['txid'])
spend_3_1 = wallet.create_self_transfer(from_node=self.nodes[0], utxo_to_spend=spend_3_utxo)
# Broadcast and mine 103_1: self.log.info("Broadcast and mine spend_3_1")
spend_103_1_id = self.nodes[0].sendrawtransaction(spend_103_1_raw) spend_3_1_id = self.nodes[0].sendrawtransaction(spend_3_1['hex'])
self.log.info("Generate a block")
last_block = self.nodes[0].generate(1) last_block = self.nodes[0].generate(1)
# Sync blocks, so that peer 1 gets the block before timelock_tx # Sync blocks, so that peer 1 gets the block before timelock_tx
# Otherwise, peer 1 would put the timelock_tx in m_recent_rejects # Otherwise, peer 1 would put the timelock_tx in m_recent_rejects
self.sync_all() self.sync_all()
# Time-locked transaction can now be spent self.log.info("The time-locked transaction can now be spent")
timelock_tx_id = self.nodes[0].sendrawtransaction(timelock_tx) timelock_tx_id = self.nodes[0].sendrawtransaction(timelock_tx)
# ... now put spend_101 and spend_102_1 in memory pools: self.log.info("Add spend_1 and spend_2_1 to the mempool")
spend_101_id = self.nodes[0].sendrawtransaction(spend_101_raw) spend_1_id = self.nodes[0].sendrawtransaction(spend_1['hex'])
spend_102_1_id = self.nodes[0].sendrawtransaction(spend_102_1_raw) spend_2_1_id = self.nodes[0].sendrawtransaction(spend_2_1['hex'])
assert_equal(set(self.nodes[0].getrawmempool()), {spend_101_id, spend_102_1_id, timelock_tx_id}) assert_equal(set(self.nodes[0].getrawmempool()), {spend_1_id, spend_2_1_id, timelock_tx_id})
self.sync_all() self.sync_all()
self.log.info("invalidate the last block")
for node in self.nodes: for node in self.nodes:
node.invalidateblock(last_block[0]) node.invalidateblock(last_block[0])
# Time-locked transaction is now too immature and has been removed from the mempool self.log.info("The time-locked transaction is now too immature and has been removed from the mempool")
# spend_103_1 has been re-orged out of the chain and is back in the mempool self.log.info("spend_3_1 has been re-orged out of the chain and is back in the mempool")
assert_equal(set(self.nodes[0].getrawmempool()), {spend_101_id, spend_102_1_id, spend_103_1_id}) assert_equal(set(self.nodes[0].getrawmempool()), {spend_1_id, spend_2_1_id, spend_3_1_id})
# Use invalidateblock to re-org back and make all those coinbase spends self.log.info("Use invalidateblock to re-org back and make all those coinbase spends immature/invalid")
# immature/invalid: b = self.nodes[0].getblockhash(first_block + 100)
for node in self.nodes: for node in self.nodes:
node.invalidateblock(new_blocks[0]) node.invalidateblock(b)
# mempool should be empty. self.log.info("Check that the mempool is empty")
assert_equal(set(self.nodes[0].getrawmempool()), set()) assert_equal(set(self.nodes[0].getrawmempool()), set())
self.sync_all() self.sync_all()

5
test/functional/test_framework/wallet.py
View File

@ -123,13 +123,13 @@ class MiniWallet:
else: else:
return self._utxos[index] return self._utxos[index]
def send_self_transfer(self, *, fee_rate=Decimal("0.003"), from_node, utxo_to_spend=None): def send_self_transfer(self, *, fee_rate=Decimal("0.003"), from_node, utxo_to_spend=None, locktime=0):
"""Create and send a tx with the specified fee_rate. Fee may be exact or at most one satoshi higher than needed.""" """Create and send a tx with the specified fee_rate. Fee may be exact or at most one satoshi higher than needed."""
tx = self.create_self_transfer(fee_rate=fee_rate, from_node=from_node, utxo_to_spend=utxo_to_spend) tx = self.create_self_transfer(fee_rate=fee_rate, from_node=from_node, utxo_to_spend=utxo_to_spend)
self.sendrawtransaction(from_node=from_node, tx_hex=tx['hex']) self.sendrawtransaction(from_node=from_node, tx_hex=tx['hex'])
return tx return tx
def create_self_transfer(self, *, fee_rate=Decimal("0.003"), from_node, utxo_to_spend=None, mempool_valid=True): def create_self_transfer(self, *, fee_rate=Decimal("0.003"), from_node, utxo_to_spend=None, mempool_valid=True, locktime=0):
"""Create and return a tx with the specified fee_rate. Fee may be exact or at most one satoshi higher than needed.""" """Create and return a tx with the specified fee_rate. Fee may be exact or at most one satoshi higher than needed."""
self._utxos = sorted(self._utxos, key=lambda k: k['value']) self._utxos = sorted(self._utxos, key=lambda k: k['value'])
utxo_to_spend = utxo_to_spend or self._utxos.pop() # Pick the largest utxo (if none provided) and hope it covers the fee utxo_to_spend = utxo_to_spend or self._utxos.pop() # Pick the largest utxo (if none provided) and hope it covers the fee
@ -141,6 +141,7 @@ class MiniWallet:
tx = CTransaction() tx = CTransaction()
tx.vin = [CTxIn(COutPoint(int(utxo_to_spend['txid'], 16), utxo_to_spend['vout']))] tx.vin = [CTxIn(COutPoint(int(utxo_to_spend['txid'], 16), utxo_to_spend['vout']))]
tx.vout = [CTxOut(int(send_value * COIN), self._scriptPubKey)] tx.vout = [CTxOut(int(send_value * COIN), self._scriptPubKey)]
tx.nLockTime = locktime
if not self._address: if not self._address:
# raw script # raw script
if self._priv_key is not None: if self._priv_key is not None: