Differential D10329 Diff 30534 test/functional/abc-segwit-recovery.py

Changeset View

Standalone View

test/functional/abc-segwit-recovery.py

#!/usr/bin/env python3		#!/usr/bin/env python3
# Copyright (c) 2019 The Bitcoin developers		# Copyright (c) 2019 The Bitcoin developers
# Distributed under the MIT software license, see the accompanying		# Distributed under the MIT software license, see the accompanying
# file COPYING or http://www.opensource.org/licenses/mit-license.php.		# file COPYING or http://www.opensource.org/licenses/mit-license.php.
"""		"""
This test checks that blocks containing segwit recovery transactions will be accepted,		This test checks that blocks containing segwit recovery transactions will be accepted,
that segwit recovery transactions are rejected from mempool acceptance (even with		that segwit recovery transactions are rejected from mempool acceptance (even with
-acceptnonstdtxn=1), and that segwit recovery transactions don't result in bans.		-acceptnonstdtxn=1), and that segwit recovery transactions don't result in bans.
"""		"""

import time		import time
		from typing import Optional, Sequence

from test_framework.blocktools import (		from test_framework.blocktools import (
create_block,		create_block,
create_coinbase,		create_coinbase,
make_conform_to_ctor,		make_conform_to_ctor,
)		)
from test_framework.messages import (		from test_framework.messages import (
COIN,		COIN,
		CBlock,
COutPoint,		COutPoint,
CTransaction,		CTransaction,
CTxIn,		CTxIn,
CTxOut,		CTxOut,
ToHex,		ToHex,
)		)
from test_framework.p2p import P2PDataStore		from test_framework.p2p import P2PDataStore
from test_framework.script import (		from test_framework.script import (
Show All 22 Lines	def __init__(self, tx=CTransaction(), n=-1):
self.n = n		self.n = n


class SegwitRecoveryTest(BitcoinTestFramework):		class SegwitRecoveryTest(BitcoinTestFramework):

def set_test_params(self):		def set_test_params(self):
self.num_nodes = 2		self.num_nodes = 2
self.setup_clean_chain = True		self.setup_clean_chain = True
self.block_heights = {}		self.tip_height = 0
self.tip = None
self.blocks = {}
# We have 2 nodes:		# We have 2 nodes:
# 1) node_nonstd (nodes[0]) accepts non-standard txns. It does not		# 1) node_nonstd (nodes[0]) accepts non-standard txns. It does not
# accept Segwit recovery transactions, since it is included in		# accept Segwit recovery transactions, since it is included in
# standard flags, and transactions that violate these flags are		# standard flags, and transactions that violate these flags are
# never accepted into the mempool.		# never accepted into the mempool.
# 2) node_std (nodes[1]) doesn't accept non-standard txns and		# 2) node_std (nodes[1]) doesn't accept non-standard txns and
# doesn't have us whitelisted. It's used to test for bans, as we		# doesn't have us whitelisted. It's used to test for bans, as we
# connect directly to it via mininode and send a segwit spending		# connect directly to it via mininode and send a segwit spending
# txn. This transaction is non-standard. We check that sending		# txn. This transaction is non-standard. We check that sending
# this transaction doesn't result in a ban.		# this transaction doesn't result in a ban.
# Nodes are connected to each other, so node_std receives blocks and		# Nodes are connected to each other, so node_std receives blocks and
# transactions that node_nonstd has accepted. Since we are checking		# transactions that node_nonstd has accepted. Since we are checking
# that segwit spending txn are not resulting in bans, node_nonstd		# that segwit spending txn are not resulting in bans, node_nonstd
# doesn't get banned when forwarding this kind of transactions to		# doesn't get banned when forwarding this kind of transactions to
# node_std.		# node_std.
self.extra_args = [['-whitelist=noban@127.0.0.1',		self.extra_args = [['-whitelist=noban@127.0.0.1',
"-acceptnonstdtxn"],		"-acceptnonstdtxn"],
["-acceptnonstdtxn=0"]]		["-acceptnonstdtxn=0"]]

def next_block(self, number):		def make_block(self, base_block: Optional[CBlock]) -> CBlock:
if self.tip is None:		"""
		Build a new block and return it.
		Increment the tip_height counter.

		If base_block is None, use the genesis block as base block.
		"""
		if base_block is None:
base_block_hash = self.genesis_hash		base_block_hash = self.genesis_hash
block_time = TEST_TIME		block_time = TEST_TIME
else:		else:
base_block_hash = self.tip.sha256		base_block_hash = base_block.sha256
block_time = self.tip.nTime + 1		block_time = base_block.nTime + 1
# First create the coinbase		# First create the coinbase
height = self.block_heights[base_block_hash] + 1		self.tip_height += 1
coinbase = create_coinbase(height)		coinbase = create_coinbase(self.tip_height)
coinbase.rehash()		coinbase.rehash()
block = create_block(base_block_hash, coinbase, block_time)		block = create_block(base_block_hash, coinbase, block_time)

# Do PoW, which is cheap on regnet		# Do PoW, which is cheap on regnet
block.solve()		block.solve()
self.tip = block
self.block_heights[block.sha256] = height
assert number not in self.blocks
self.blocks[number] = block
return block		return block

def run_test(self):		def run_test(self):
self.genesis_hash = int(self.nodes[0].getbestblockhash(), 16)		self.genesis_hash = int(self.nodes[0].getbestblockhash(), 16)
self.block_heights[self.genesis_hash] = 0
spendable_outputs = []		spendable_outputs = []

# shorthand		# shorthand
block = self.next_block
node_nonstd = self.nodes[0]		node_nonstd = self.nodes[0]
node_std = self.nodes[1]		node_std = self.nodes[1]

peer_nonstd = node_nonstd.add_p2p_connection(P2PDataStore())		peer_nonstd = node_nonstd.add_p2p_connection(P2PDataStore())
peer_std = node_std.add_p2p_connection(P2PDataStore())		peer_std = node_std.add_p2p_connection(P2PDataStore())

# save the current tip so it can be spent by a later block
def save_spendable_output():
spendable_outputs.append(self.tip)

# get an output that we previously marked as spendable
def get_spendable_output():
return PreviousSpendableOutput(spendable_outputs.pop(0).vtx[0], 0)

# adds transactions to the block and updates state		# adds transactions to the block and updates state
def update_block(block_number, new_transactions):		def update_block(block: CBlock,
block = self.blocks[block_number]		new_transactions: Sequence[CTransaction]):
block.vtx.extend(new_transactions)		block.vtx.extend(new_transactions)
old_sha256 = block.sha256
make_conform_to_ctor(block)		make_conform_to_ctor(block)
block.hashMerkleRoot = block.calc_merkle_root()		block.hashMerkleRoot = block.calc_merkle_root()
block.solve()		block.solve()
# Update the internal state just like in next_block
self.tip = block
if block.sha256 != old_sha256:
self.block_heights[
block.sha256] = self.block_heights[old_sha256]
del self.block_heights[old_sha256]
self.blocks[block_number] = block
return block

# checks the mempool has exactly the same txns as in the provided list
def check_mempool_equal(node, txns):
assert set(node.getrawmempool()) == set(tx.hash for tx in txns)

# Returns 2 transactions:		# Returns 2 transactions:
# 1) txfund: create outputs in segwit addresses		# 1) txfund: create outputs in segwit addresses
# 2) txspend: spends outputs from segwit addresses		# 2) txspend: spends outputs from segwit addresses
def create_segwit_fund_and_spend_tx(spend, case0=False):		def create_segwit_fund_and_spend_tx(spend, case0=False):
if not case0:		if not case0:
# Spending from a P2SH-P2WPKH coin,		# Spending from a P2SH-P2WPKH coin,
# txhash:a45698363249312f8d3d93676aa714be59b0bd758e62fa054fb1ea6218480691		# txhash:a45698363249312f8d3d93676aa714be59b0bd758e62fa054fb1ea6218480691
Show All 29 Lines	def run_test(self):
CTxIn(COutPoint(txfund.sha256, i), CScript([redeem_scripts[i]])))		CTxIn(COutPoint(txfund.sha256, i), CScript([redeem_scripts[i]])))
txspend.vout = [CTxOut(50 * COIN - 2000,		txspend.vout = [CTxOut(50 * COIN - 2000,
CScript([OP_HASH160, hash160(CScript([OP_TRUE])), OP_EQUAL]))]		CScript([OP_HASH160, hash160(CScript([OP_TRUE])), OP_EQUAL]))]
txspend.rehash()		txspend.rehash()

return txfund, txspend		return txfund, txspend

# Create a new block		# Create a new block
block(0)		block = self.make_block(base_block=None)
save_spendable_output()		spendable_outputs.append(block)
peer_nonstd.send_blocks_and_test([self.tip], node_nonstd)		peer_nonstd.send_blocks_and_test([block], node_nonstd)

# Now we need that block to mature so we can spend the coinbase.		# Now we need that block to mature so we can spend the coinbase.
matureblocks = []		matureblocks = []
for i in range(199):		for _ in range(199):
block(5000 + i)		block = self.make_block(block)
matureblocks.append(self.tip)		matureblocks.append(block)
save_spendable_output()		spendable_outputs.append(block)
peer_nonstd.send_blocks_and_test(matureblocks, node_nonstd)		peer_nonstd.send_blocks_and_test(matureblocks, node_nonstd)

# collect spendable outputs now to avoid cluttering the code later on		# collect spendable outputs now to avoid cluttering the code later on
out = []		out = []
for i in range(100):		for _ in range(100):
out.append(get_spendable_output())		out.append(
		PreviousSpendableOutput(spendable_outputs.pop(0).vtx[0], 0))

# Create segwit funding and spending transactions		# Create segwit funding and spending transactions
txfund, txspend = create_segwit_fund_and_spend_tx(out[0])		txfund, txspend = create_segwit_fund_and_spend_tx(out[0])
txfund_case0, txspend_case0 = create_segwit_fund_and_spend_tx(		txfund_case0, txspend_case0 = create_segwit_fund_and_spend_tx(
out[1], True)		out[1], True)

# Mine txfund, as it can't go into node_std mempool because it's		# Mine txfund, as it can't go into node_std mempool because it's
# nonstandard.		# nonstandard.
block(5555)		block = self.make_block(block)
update_block(5555, [txfund, txfund_case0])		update_block(block, [txfund, txfund_case0])
peer_nonstd.send_blocks_and_test([self.tip], node_nonstd)		peer_nonstd.send_blocks_and_test([block], node_nonstd)

# Check both nodes are synchronized before continuing.		# Check both nodes are synchronized before continuing.
self.sync_blocks()		self.sync_blocks()

# Check that upgraded nodes checking for standardness are not banning		# Check that upgraded nodes checking for standardness are not banning
# nodes sending segwit spending txns.		# nodes sending segwit spending txns.
peer_nonstd.send_txs_and_test([txspend], node_nonstd, success=False,		peer_nonstd.send_txs_and_test([txspend], node_nonstd, success=False,
reject_reason=CLEANSTACK_ERROR)		reject_reason=CLEANSTACK_ERROR)
Show All 11 Lines	def run_test(self):
assert_raises_rpc_error(-26, RPC_EVAL_FALSE_ERROR,		assert_raises_rpc_error(-26, RPC_EVAL_FALSE_ERROR,
node_nonstd.sendrawtransaction, ToHex(txspend_case0))		node_nonstd.sendrawtransaction, ToHex(txspend_case0))
assert_raises_rpc_error(-26, RPC_CLEANSTACK_ERROR,		assert_raises_rpc_error(-26, RPC_CLEANSTACK_ERROR,
node_std.sendrawtransaction, ToHex(txspend))		node_std.sendrawtransaction, ToHex(txspend))
assert_raises_rpc_error(-26, RPC_EVAL_FALSE_ERROR,		assert_raises_rpc_error(-26, RPC_EVAL_FALSE_ERROR,
node_std.sendrawtransaction, ToHex(txspend_case0))		node_std.sendrawtransaction, ToHex(txspend_case0))

# Blocks containing segwit spending txns are accepted in both nodes.		# Blocks containing segwit spending txns are accepted in both nodes.
block(5)		block = self.make_block(block)
update_block(5, [txspend, txspend_case0])		update_block(block, [txspend, txspend_case0])
peer_nonstd.send_blocks_and_test([self.tip], node_nonstd)		peer_nonstd.send_blocks_and_test([block], node_nonstd)
self.sync_blocks()		self.sync_blocks()


if __name__ == '__main__':		if __name__ == '__main__':
SegwitRecoveryTest().main()		SegwitRecoveryTest().main()