0a8b7b4b33
8b56fc0b91[qa] Test that v0 segwit outputs can't be spent pre-activation (Suhas Daftuar)ccb8ca42a4Always enforce SCRIPT_VERIFY_WITNESS with P2SH (Suhas Daftuar)5c31b20a35[qa] Remove some pre-activation segwit tests (Suhas Daftuar)95749a5836Separate NULLDUMMY enforcement from SEGWIT enforcement (Suhas Daftuar)ce650182f4Use P2SH consensus rules for all blocks (Suhas Daftuar) Pull request description: As discussed at the IRC meeting back in October (https://botbot.me/freenode/bitcoin-core-dev/2017-10-12/?msg=92231929&page=2), I had looked into the feasibility of enforcing P2SH and SCRIPT_VERIFY_WITNESS back to the genesis block. The P2SH change is pretty straightforward -- there was only one historical block on mainnet that violated the rule, so I carved out an exception to it, similar to the way we have exceptions for the BIP30 violators. The segwit change is not entirely as clear. The code changes themselves are relatively straightforward: we can just always turn on SCRIPT_VERIFY_WITNESS whenever P2SH is active. However conceptually, this amounts to splitting up BIP141 into two parts, the part that implements new script rules, and the part that handles witness commitments in blocks. Arguably though the script rules are really defined in BIP 143 anyway, and so this really amounts to backdating BIP 143 -- script rules for v0 segwit outputs -- back to genesis. So maybe conceptually this isn't so bad... I don't feel strongly about this change in either direction; I started working on it because I was searching for a way to simplify the way we understand and implement the consensus rules around segwit, but I'm not yet sure whether I think this achieves anything toward that goal. ping @TheBlueMatt Tree-SHA512: 73551d4a983eb9792c7ac67f56005822528ac4d1fd52c27cee6d305ebee953f69687ef4ddee8bdc0fec77f77e6b5a9d669750793efee54c076533a095e233042
2034 lines
94 KiB
Python
Executable file
2034 lines
94 KiB
Python
Executable file
#!/usr/bin/env python3
|
|
# Copyright (c) 2016-2017 The Bitcoin Core developers
|
|
# Distributed under the MIT software license, see the accompanying
|
|
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
"""Test segwit transactions and blocks on P2P network."""
|
|
|
|
from test_framework.mininode import *
|
|
from test_framework.test_framework import BitcoinTestFramework
|
|
from test_framework.util import *
|
|
from test_framework.script import *
|
|
from test_framework.blocktools import create_block, create_coinbase, add_witness_commitment, get_witness_script, WITNESS_COMMITMENT_HEADER
|
|
from test_framework.key import CECKey, CPubKey
|
|
import math
|
|
import time
|
|
import random
|
|
from binascii import hexlify
|
|
|
|
# The versionbit bit used to signal activation of SegWit
|
|
VB_WITNESS_BIT = 1
|
|
VB_PERIOD = 144
|
|
VB_TOP_BITS = 0x20000000
|
|
|
|
MAX_SIGOP_COST = 80000
|
|
|
|
|
|
# Calculate the virtual size of a witness block:
|
|
# (base + witness/4)
|
|
def get_virtual_size(witness_block):
|
|
base_size = len(witness_block.serialize(with_witness=False))
|
|
total_size = len(witness_block.serialize(with_witness=True))
|
|
# the "+3" is so we round up
|
|
vsize = int((3*base_size + total_size + 3)/4)
|
|
return vsize
|
|
|
|
def test_transaction_acceptance(rpc, p2p, tx, with_witness, accepted, reason=None):
|
|
"""Send a transaction to the node and check that it's accepted to the mempool
|
|
|
|
- Submit the transaction over the p2p interface
|
|
- use the getrawmempool rpc to check for acceptance."""
|
|
tx_message = msg_tx(tx)
|
|
if with_witness:
|
|
tx_message = msg_witness_tx(tx)
|
|
p2p.send_message(tx_message)
|
|
p2p.sync_with_ping()
|
|
assert_equal(tx.hash in rpc.getrawmempool(), accepted)
|
|
if (reason != None and not accepted):
|
|
# Check the rejection reason as well.
|
|
with mininode_lock:
|
|
assert_equal(p2p.last_message["reject"].reason, reason)
|
|
|
|
def test_witness_block(rpc, p2p, block, accepted, with_witness=True, reason=None):
|
|
"""Send a block to the node and check that it's accepted
|
|
|
|
- Submit the block over the p2p interface
|
|
- use the getbestblockhash rpc to check for acceptance."""
|
|
if with_witness:
|
|
p2p.send_message(msg_witness_block(block))
|
|
else:
|
|
p2p.send_message(msg_block(block))
|
|
p2p.sync_with_ping()
|
|
assert_equal(rpc.getbestblockhash() == block.hash, accepted)
|
|
if (reason != None and not accepted):
|
|
# Check the rejection reason as well.
|
|
with mininode_lock:
|
|
assert_equal(p2p.last_message["reject"].reason, reason)
|
|
|
|
class TestP2PConn(P2PInterface):
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.getdataset = set()
|
|
|
|
def on_getdata(self, message):
|
|
for inv in message.inv:
|
|
self.getdataset.add(inv.hash)
|
|
|
|
def announce_tx_and_wait_for_getdata(self, tx, timeout=60):
|
|
with mininode_lock:
|
|
self.last_message.pop("getdata", None)
|
|
self.send_message(msg_inv(inv=[CInv(1, tx.sha256)]))
|
|
self.wait_for_getdata(timeout)
|
|
|
|
def announce_block_and_wait_for_getdata(self, block, use_header, timeout=60):
|
|
with mininode_lock:
|
|
self.last_message.pop("getdata", None)
|
|
self.last_message.pop("getheaders", None)
|
|
msg = msg_headers()
|
|
msg.headers = [ CBlockHeader(block) ]
|
|
if use_header:
|
|
self.send_message(msg)
|
|
else:
|
|
self.send_message(msg_inv(inv=[CInv(2, block.sha256)]))
|
|
self.wait_for_getheaders()
|
|
self.send_message(msg)
|
|
self.wait_for_getdata()
|
|
|
|
def request_block(self, blockhash, inv_type, timeout=60):
|
|
with mininode_lock:
|
|
self.last_message.pop("block", None)
|
|
self.send_message(msg_getdata(inv=[CInv(inv_type, blockhash)]))
|
|
self.wait_for_block(blockhash, timeout)
|
|
return self.last_message["block"].block
|
|
|
|
# Used to keep track of anyone-can-spend outputs that we can use in the tests
|
|
class UTXO():
|
|
def __init__(self, sha256, n, nValue):
|
|
self.sha256 = sha256
|
|
self.n = n
|
|
self.nValue = nValue
|
|
|
|
# Helper for getting the script associated with a P2PKH
|
|
def GetP2PKHScript(pubkeyhash):
|
|
return CScript([CScriptOp(OP_DUP), CScriptOp(OP_HASH160), pubkeyhash, CScriptOp(OP_EQUALVERIFY), CScriptOp(OP_CHECKSIG)])
|
|
|
|
# Add signature for a P2PK witness program.
|
|
def sign_P2PK_witness_input(script, txTo, inIdx, hashtype, value, key):
|
|
tx_hash = SegwitVersion1SignatureHash(script, txTo, inIdx, hashtype, value)
|
|
signature = key.sign(tx_hash) + chr(hashtype).encode('latin-1')
|
|
txTo.wit.vtxinwit[inIdx].scriptWitness.stack = [signature, script]
|
|
txTo.rehash()
|
|
|
|
|
|
class SegWitTest(BitcoinTestFramework):
|
|
def set_test_params(self):
|
|
self.setup_clean_chain = True
|
|
self.num_nodes = 3
|
|
# This test tests SegWit both pre and post-activation, so use the normal BIP9 activation.
|
|
self.extra_args = [["-whitelist=127.0.0.1", "-vbparams=segwit:0:999999999999"], ["-whitelist=127.0.0.1", "-acceptnonstdtxn=0", "-vbparams=segwit:0:999999999999"], ["-whitelist=127.0.0.1", "-vbparams=segwit:0:0"]]
|
|
|
|
def setup_network(self):
|
|
self.setup_nodes()
|
|
connect_nodes(self.nodes[0], 1)
|
|
connect_nodes(self.nodes[0], 2)
|
|
self.sync_all()
|
|
|
|
''' Helpers '''
|
|
# Build a block on top of node0's tip.
|
|
def build_next_block(self, nVersion=4):
|
|
tip = self.nodes[0].getbestblockhash()
|
|
height = self.nodes[0].getblockcount() + 1
|
|
block_time = self.nodes[0].getblockheader(tip)["mediantime"] + 1
|
|
block = create_block(int(tip, 16), create_coinbase(height), block_time)
|
|
block.nVersion = nVersion
|
|
block.rehash()
|
|
return block
|
|
|
|
# Adds list of transactions to block, adds witness commitment, then solves.
|
|
def update_witness_block_with_transactions(self, block, tx_list, nonce=0):
|
|
block.vtx.extend(tx_list)
|
|
add_witness_commitment(block, nonce)
|
|
block.solve()
|
|
return
|
|
|
|
''' Individual tests '''
|
|
def test_witness_services(self):
|
|
self.log.info("Verifying NODE_WITNESS service bit")
|
|
assert((self.test_node.nServices & NODE_WITNESS) != 0)
|
|
|
|
|
|
# See if sending a regular transaction works, and create a utxo
|
|
# to use in later tests.
|
|
def test_non_witness_transaction(self):
|
|
# Mine a block with an anyone-can-spend coinbase,
|
|
# let it mature, then try to spend it.
|
|
self.log.info("Testing non-witness transaction")
|
|
block = self.build_next_block(nVersion=1)
|
|
block.solve()
|
|
self.test_node.send_message(msg_block(block))
|
|
self.test_node.sync_with_ping() # make sure the block was processed
|
|
txid = block.vtx[0].sha256
|
|
|
|
self.nodes[0].generate(99) # let the block mature
|
|
|
|
# Create a transaction that spends the coinbase
|
|
tx = CTransaction()
|
|
tx.vin.append(CTxIn(COutPoint(txid, 0), b""))
|
|
tx.vout.append(CTxOut(49*100000000, CScript([OP_TRUE])))
|
|
tx.calc_sha256()
|
|
|
|
# Check that serializing it with or without witness is the same
|
|
# This is a sanity check of our testing framework.
|
|
assert_equal(msg_tx(tx).serialize(), msg_witness_tx(tx).serialize())
|
|
|
|
self.test_node.send_message(msg_witness_tx(tx))
|
|
self.test_node.sync_with_ping() # make sure the tx was processed
|
|
assert(tx.hash in self.nodes[0].getrawmempool())
|
|
# Save this transaction for later
|
|
self.utxo.append(UTXO(tx.sha256, 0, 49*100000000))
|
|
self.nodes[0].generate(1)
|
|
|
|
|
|
# Verify that blocks with witnesses are rejected before activation.
|
|
def test_unnecessary_witness_before_segwit_activation(self):
|
|
self.log.info("Testing behavior of unnecessary witnesses")
|
|
# For now, rely on earlier tests to have created at least one utxo for
|
|
# us to use
|
|
assert(len(self.utxo) > 0)
|
|
assert(get_bip9_status(self.nodes[0], 'segwit')['status'] != 'active')
|
|
|
|
tx = CTransaction()
|
|
tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
|
|
tx.vout.append(CTxOut(self.utxo[0].nValue-1000, CScript([OP_TRUE])))
|
|
tx.wit.vtxinwit.append(CTxInWitness())
|
|
tx.wit.vtxinwit[0].scriptWitness.stack = [CScript([CScriptNum(1)])]
|
|
|
|
# Verify the hash with witness differs from the txid
|
|
# (otherwise our testing framework must be broken!)
|
|
tx.rehash()
|
|
assert(tx.sha256 != tx.calc_sha256(with_witness=True))
|
|
|
|
# Construct a segwit-signaling block that includes the transaction.
|
|
block = self.build_next_block(nVersion=(VB_TOP_BITS|(1 << VB_WITNESS_BIT)))
|
|
self.update_witness_block_with_transactions(block, [tx])
|
|
# Sending witness data before activation is not allowed (anti-spam
|
|
# rule).
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=False)
|
|
# TODO: fix synchronization so we can test reject reason
|
|
# Right now, bitcoind delays sending reject messages for blocks
|
|
# until the future, making synchronization here difficult.
|
|
#assert_equal(self.test_node.last_message["reject"].reason, "unexpected-witness")
|
|
|
|
# But it should not be permanently marked bad...
|
|
# Resend without witness information.
|
|
self.test_node.send_message(msg_block(block))
|
|
self.test_node.sync_with_ping()
|
|
assert_equal(self.nodes[0].getbestblockhash(), block.hash)
|
|
|
|
sync_blocks(self.nodes)
|
|
|
|
# Create a p2sh output -- this is so we can pass the standardness
|
|
# rules (an anyone-can-spend OP_TRUE would be rejected, if not wrapped
|
|
# in P2SH).
|
|
p2sh_program = CScript([OP_TRUE])
|
|
p2sh_pubkey = hash160(p2sh_program)
|
|
scriptPubKey = CScript([OP_HASH160, p2sh_pubkey, OP_EQUAL])
|
|
|
|
# Now check that unnecessary witnesses can't be used to blind a node
|
|
# to a transaction, eg by violating standardness checks.
|
|
tx2 = CTransaction()
|
|
tx2.vin.append(CTxIn(COutPoint(tx.sha256, 0), b""))
|
|
tx2.vout.append(CTxOut(tx.vout[0].nValue-1000, scriptPubKey))
|
|
tx2.rehash()
|
|
test_transaction_acceptance(self.nodes[0].rpc, self.test_node, tx2, False, True)
|
|
self.nodes[0].generate(1)
|
|
sync_blocks(self.nodes)
|
|
|
|
# We'll add an unnecessary witness to this transaction that would cause
|
|
# it to be non-standard, to test that violating policy with a witness before
|
|
# segwit activation doesn't blind a node to a transaction. Transactions
|
|
# rejected for having a witness before segwit activation shouldn't be added
|
|
# to the rejection cache.
|
|
tx3 = CTransaction()
|
|
tx3.vin.append(CTxIn(COutPoint(tx2.sha256, 0), CScript([p2sh_program])))
|
|
tx3.vout.append(CTxOut(tx2.vout[0].nValue-1000, scriptPubKey))
|
|
tx3.wit.vtxinwit.append(CTxInWitness())
|
|
tx3.wit.vtxinwit[0].scriptWitness.stack = [b'a'*400000]
|
|
tx3.rehash()
|
|
# Note that this should be rejected for the premature witness reason,
|
|
# rather than a policy check, since segwit hasn't activated yet.
|
|
test_transaction_acceptance(self.nodes[1].rpc, self.std_node, tx3, True, False, b'no-witness-yet')
|
|
|
|
# If we send without witness, it should be accepted.
|
|
test_transaction_acceptance(self.nodes[1].rpc, self.std_node, tx3, False, True)
|
|
|
|
# Now create a new anyone-can-spend utxo for the next test.
|
|
tx4 = CTransaction()
|
|
tx4.vin.append(CTxIn(COutPoint(tx3.sha256, 0), CScript([p2sh_program])))
|
|
tx4.vout.append(CTxOut(tx3.vout[0].nValue-1000, CScript([OP_TRUE])))
|
|
tx4.rehash()
|
|
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)
|
|
|
|
self.nodes[0].generate(1)
|
|
sync_blocks(self.nodes)
|
|
|
|
# Update our utxo list; we spent the first entry.
|
|
self.utxo.pop(0)
|
|
self.utxo.append(UTXO(tx4.sha256, 0, tx4.vout[0].nValue))
|
|
|
|
# ~6 months after segwit activation, the SCRIPT_VERIFY_WITNESS flag was
|
|
# backdated so that it applies to all blocks, going back to the genesis
|
|
# block.
|
|
#
|
|
# Consequently, version 0 witness outputs are never spendable without
|
|
# witness, and so can't be spent before segwit activation (the point at which
|
|
# blocks are permitted to contain witnesses).
|
|
def test_v0_outputs_arent_spendable(self):
|
|
self.log.info("Testing that v0 witness program outputs aren't spendable before activation")
|
|
|
|
assert len(self.utxo), "self.utxo is empty"
|
|
|
|
# Create two outputs, a p2wsh and p2sh-p2wsh
|
|
witness_program = CScript([OP_TRUE])
|
|
witness_hash = sha256(witness_program)
|
|
scriptPubKey = CScript([OP_0, witness_hash])
|
|
|
|
p2sh_pubkey = hash160(scriptPubKey)
|
|
p2sh_scriptPubKey = CScript([OP_HASH160, p2sh_pubkey, OP_EQUAL])
|
|
|
|
value = self.utxo[0].nValue // 3
|
|
|
|
tx = CTransaction()
|
|
tx.vin = [CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b'')]
|
|
tx.vout = [CTxOut(value, scriptPubKey), CTxOut(value, p2sh_scriptPubKey)]
|
|
tx.vout.append(CTxOut(value, CScript([OP_TRUE])))
|
|
tx.rehash()
|
|
txid = tx.sha256
|
|
|
|
# Add it to a block
|
|
block = self.build_next_block()
|
|
self.update_witness_block_with_transactions(block, [tx])
|
|
# Verify that segwit isn't activated. A block serialized with witness
|
|
# should be rejected prior to activation.
|
|
test_witness_block(self.nodes[0], self.test_node, block, accepted=False, with_witness=True, reason = b'unexpected-witness')
|
|
# Now send the block without witness. It should be accepted
|
|
test_witness_block(self.nodes[0], self.test_node, block, accepted=True, with_witness=False)
|
|
|
|
# Now try to spend the outputs. This should fail since SCRIPT_VERIFY_WITNESS is always enabled.
|
|
p2wsh_tx = CTransaction()
|
|
p2wsh_tx.vin = [CTxIn(COutPoint(txid, 0), b'')]
|
|
p2wsh_tx.vout = [CTxOut(value, CScript([OP_TRUE]))]
|
|
p2wsh_tx.wit.vtxinwit.append(CTxInWitness())
|
|
p2wsh_tx.wit.vtxinwit[0].scriptWitness.stack = [CScript([OP_TRUE])]
|
|
p2wsh_tx.rehash()
|
|
|
|
p2sh_p2wsh_tx = CTransaction()
|
|
p2sh_p2wsh_tx.vin = [CTxIn(COutPoint(txid, 1), CScript([scriptPubKey]))]
|
|
p2sh_p2wsh_tx.vout = [CTxOut(value, CScript([OP_TRUE]))]
|
|
p2sh_p2wsh_tx.wit.vtxinwit.append(CTxInWitness())
|
|
p2sh_p2wsh_tx.wit.vtxinwit[0].scriptWitness.stack = [CScript([OP_TRUE])]
|
|
p2sh_p2wsh_tx.rehash()
|
|
|
|
for tx in [p2wsh_tx, p2sh_p2wsh_tx]:
|
|
|
|
block = self.build_next_block()
|
|
self.update_witness_block_with_transactions(block, [tx])
|
|
|
|
# When the block is serialized with a witness, the block will be rejected because witness
|
|
# data isn't allowed in blocks that don't commit to witness data.
|
|
test_witness_block(self.nodes[0], self.test_node, block, accepted=False, with_witness=True, reason=b'unexpected-witness')
|
|
|
|
# When the block is serialized without witness, validation fails because the transaction is
|
|
# invalid (transactions are always validated with SCRIPT_VERIFY_WITNESS so a segwit v0 transaction
|
|
# without a witness is invalid).
|
|
# Note: The reject reason for this failure could be
|
|
# 'block-validation-failed' (if script check threads > 1) or
|
|
# 'non-mandatory-script-verify-flag (Witness program was passed an
|
|
# empty witness)' (otherwise).
|
|
# TODO: support multiple acceptable reject reasons.
|
|
test_witness_block(self.nodes[0], self.test_node, block, accepted=False, with_witness=False)
|
|
|
|
self.utxo.pop(0)
|
|
self.utxo.append(UTXO(txid, 2, value))
|
|
|
|
# Mine enough blocks for segwit's vb state to be 'started'.
|
|
def advance_to_segwit_started(self):
|
|
height = self.nodes[0].getblockcount()
|
|
# Will need to rewrite the tests here if we are past the first period
|
|
assert(height < VB_PERIOD - 1)
|
|
# Genesis block is 'defined'.
|
|
assert_equal(get_bip9_status(self.nodes[0], 'segwit')['status'], 'defined')
|
|
# Advance to end of period, status should now be 'started'
|
|
self.nodes[0].generate(VB_PERIOD-height-1)
|
|
assert_equal(get_bip9_status(self.nodes[0], 'segwit')['status'], 'started')
|
|
|
|
# Mine enough blocks to lock in segwit, but don't activate.
|
|
# TODO: we could verify that lockin only happens at the right threshold of
|
|
# signalling blocks, rather than just at the right period boundary.
|
|
def advance_to_segwit_lockin(self):
|
|
height = self.nodes[0].getblockcount()
|
|
assert_equal(get_bip9_status(self.nodes[0], 'segwit')['status'], 'started')
|
|
# Advance to end of period, and verify lock-in happens at the end
|
|
self.nodes[0].generate(VB_PERIOD-1)
|
|
height = self.nodes[0].getblockcount()
|
|
assert((height % VB_PERIOD) == VB_PERIOD - 2)
|
|
assert_equal(get_bip9_status(self.nodes[0], 'segwit')['status'], 'started')
|
|
self.nodes[0].generate(1)
|
|
assert_equal(get_bip9_status(self.nodes[0], 'segwit')['status'], 'locked_in')
|
|
|
|
|
|
# Mine enough blocks to activate segwit.
|
|
# TODO: we could verify that activation only happens at the right threshold
|
|
# of signalling blocks, rather than just at the right period boundary.
|
|
def advance_to_segwit_active(self):
|
|
assert_equal(get_bip9_status(self.nodes[0], 'segwit')['status'], 'locked_in')
|
|
height = self.nodes[0].getblockcount()
|
|
self.nodes[0].generate(VB_PERIOD - (height%VB_PERIOD) - 2)
|
|
assert_equal(get_bip9_status(self.nodes[0], 'segwit')['status'], 'locked_in')
|
|
self.nodes[0].generate(1)
|
|
assert_equal(get_bip9_status(self.nodes[0], 'segwit')['status'], 'active')
|
|
|
|
|
|
# This test can only be run after segwit has activated
|
|
def test_witness_commitments(self):
|
|
self.log.info("Testing witness commitments")
|
|
|
|
# First try a correct witness commitment.
|
|
block = self.build_next_block()
|
|
add_witness_commitment(block)
|
|
block.solve()
|
|
|
|
# Test the test -- witness serialization should be different
|
|
assert(msg_witness_block(block).serialize() != msg_block(block).serialize())
|
|
|
|
# This empty block should be valid.
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=True)
|
|
|
|
# Try to tweak the nonce
|
|
block_2 = self.build_next_block()
|
|
add_witness_commitment(block_2, nonce=28)
|
|
block_2.solve()
|
|
|
|
# The commitment should have changed!
|
|
assert(block_2.vtx[0].vout[-1] != block.vtx[0].vout[-1])
|
|
|
|
# This should also be valid.
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block_2, accepted=True)
|
|
|
|
# Now test commitments with actual transactions
|
|
assert (len(self.utxo) > 0)
|
|
tx = CTransaction()
|
|
tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
|
|
|
|
# Let's construct a witness program
|
|
witness_program = CScript([OP_TRUE])
|
|
witness_hash = sha256(witness_program)
|
|
scriptPubKey = CScript([OP_0, witness_hash])
|
|
tx.vout.append(CTxOut(self.utxo[0].nValue-1000, scriptPubKey))
|
|
tx.rehash()
|
|
|
|
# tx2 will spend tx1, and send back to a regular anyone-can-spend address
|
|
tx2 = CTransaction()
|
|
tx2.vin.append(CTxIn(COutPoint(tx.sha256, 0), b""))
|
|
tx2.vout.append(CTxOut(tx.vout[0].nValue-1000, witness_program))
|
|
tx2.wit.vtxinwit.append(CTxInWitness())
|
|
tx2.wit.vtxinwit[0].scriptWitness.stack = [witness_program]
|
|
tx2.rehash()
|
|
|
|
block_3 = self.build_next_block()
|
|
self.update_witness_block_with_transactions(block_3, [tx, tx2], nonce=1)
|
|
# Add an extra OP_RETURN output that matches the witness commitment template,
|
|
# even though it has extra data after the incorrect commitment.
|
|
# This block should fail.
|
|
block_3.vtx[0].vout.append(CTxOut(0, CScript([OP_RETURN, WITNESS_COMMITMENT_HEADER + ser_uint256(2), 10])))
|
|
block_3.vtx[0].rehash()
|
|
block_3.hashMerkleRoot = block_3.calc_merkle_root()
|
|
block_3.rehash()
|
|
block_3.solve()
|
|
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block_3, accepted=False)
|
|
|
|
# Add a different commitment with different nonce, but in the
|
|
# right location, and with some funds burned(!).
|
|
# This should succeed (nValue shouldn't affect finding the
|
|
# witness commitment).
|
|
add_witness_commitment(block_3, nonce=0)
|
|
block_3.vtx[0].vout[0].nValue -= 1
|
|
block_3.vtx[0].vout[-1].nValue += 1
|
|
block_3.vtx[0].rehash()
|
|
block_3.hashMerkleRoot = block_3.calc_merkle_root()
|
|
block_3.rehash()
|
|
assert(len(block_3.vtx[0].vout) == 4) # 3 OP_returns
|
|
block_3.solve()
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block_3, accepted=True)
|
|
|
|
# Finally test that a block with no witness transactions can
|
|
# omit the commitment.
|
|
block_4 = self.build_next_block()
|
|
tx3 = CTransaction()
|
|
tx3.vin.append(CTxIn(COutPoint(tx2.sha256, 0), b""))
|
|
tx3.vout.append(CTxOut(tx.vout[0].nValue-1000, witness_program))
|
|
tx3.rehash()
|
|
block_4.vtx.append(tx3)
|
|
block_4.hashMerkleRoot = block_4.calc_merkle_root()
|
|
block_4.solve()
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block_4, with_witness=False, accepted=True)
|
|
|
|
# Update available utxo's for use in later test.
|
|
self.utxo.pop(0)
|
|
self.utxo.append(UTXO(tx3.sha256, 0, tx3.vout[0].nValue))
|
|
|
|
|
|
def test_block_malleability(self):
|
|
self.log.info("Testing witness block malleability")
|
|
|
|
# Make sure that a block that has too big a virtual size
|
|
# because of a too-large coinbase witness is not permanently
|
|
# marked bad.
|
|
block = self.build_next_block()
|
|
add_witness_commitment(block)
|
|
block.solve()
|
|
|
|
block.vtx[0].wit.vtxinwit[0].scriptWitness.stack.append(b'a'*5000000)
|
|
assert(get_virtual_size(block) > MAX_BLOCK_BASE_SIZE)
|
|
|
|
# We can't send over the p2p network, because this is too big to relay
|
|
# TODO: repeat this test with a block that can be relayed
|
|
self.nodes[0].submitblock(bytes_to_hex_str(block.serialize(True)))
|
|
|
|
assert(self.nodes[0].getbestblockhash() != block.hash)
|
|
|
|
block.vtx[0].wit.vtxinwit[0].scriptWitness.stack.pop()
|
|
assert(get_virtual_size(block) < MAX_BLOCK_BASE_SIZE)
|
|
self.nodes[0].submitblock(bytes_to_hex_str(block.serialize(True)))
|
|
|
|
assert(self.nodes[0].getbestblockhash() == block.hash)
|
|
|
|
# Now make sure that malleating the witness reserved value doesn't
|
|
# result in a block permanently marked bad.
|
|
block = self.build_next_block()
|
|
add_witness_commitment(block)
|
|
block.solve()
|
|
|
|
# Change the nonce -- should not cause the block to be permanently
|
|
# failed
|
|
block.vtx[0].wit.vtxinwit[0].scriptWitness.stack = [ ser_uint256(1) ]
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=False)
|
|
|
|
# Changing the witness reserved value doesn't change the block hash
|
|
block.vtx[0].wit.vtxinwit[0].scriptWitness.stack = [ ser_uint256(0) ]
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=True)
|
|
|
|
|
|
def test_witness_block_size(self):
|
|
self.log.info("Testing witness block size limit")
|
|
# TODO: Test that non-witness carrying blocks can't exceed 1MB
|
|
# Skipping this test for now; this is covered in p2p-fullblocktest.py
|
|
|
|
# Test that witness-bearing blocks are limited at ceil(base + wit/4) <= 1MB.
|
|
block = self.build_next_block()
|
|
|
|
assert(len(self.utxo) > 0)
|
|
|
|
# Create a P2WSH transaction.
|
|
# The witness program will be a bunch of OP_2DROP's, followed by OP_TRUE.
|
|
# This should give us plenty of room to tweak the spending tx's
|
|
# virtual size.
|
|
NUM_DROPS = 200 # 201 max ops per script!
|
|
NUM_OUTPUTS = 50
|
|
|
|
witness_program = CScript([OP_2DROP]*NUM_DROPS + [OP_TRUE])
|
|
witness_hash = uint256_from_str(sha256(witness_program))
|
|
scriptPubKey = CScript([OP_0, ser_uint256(witness_hash)])
|
|
|
|
prevout = COutPoint(self.utxo[0].sha256, self.utxo[0].n)
|
|
value = self.utxo[0].nValue
|
|
|
|
parent_tx = CTransaction()
|
|
parent_tx.vin.append(CTxIn(prevout, b""))
|
|
child_value = int(value/NUM_OUTPUTS)
|
|
for i in range(NUM_OUTPUTS):
|
|
parent_tx.vout.append(CTxOut(child_value, scriptPubKey))
|
|
parent_tx.vout[0].nValue -= 50000
|
|
assert(parent_tx.vout[0].nValue > 0)
|
|
parent_tx.rehash()
|
|
|
|
child_tx = CTransaction()
|
|
for i in range(NUM_OUTPUTS):
|
|
child_tx.vin.append(CTxIn(COutPoint(parent_tx.sha256, i), b""))
|
|
child_tx.vout = [CTxOut(value - 100000, CScript([OP_TRUE]))]
|
|
for i in range(NUM_OUTPUTS):
|
|
child_tx.wit.vtxinwit.append(CTxInWitness())
|
|
child_tx.wit.vtxinwit[-1].scriptWitness.stack = [b'a'*195]*(2*NUM_DROPS) + [witness_program]
|
|
child_tx.rehash()
|
|
self.update_witness_block_with_transactions(block, [parent_tx, child_tx])
|
|
|
|
vsize = get_virtual_size(block)
|
|
additional_bytes = (MAX_BLOCK_BASE_SIZE - vsize)*4
|
|
i = 0
|
|
while additional_bytes > 0:
|
|
# Add some more bytes to each input until we hit MAX_BLOCK_BASE_SIZE+1
|
|
extra_bytes = min(additional_bytes+1, 55)
|
|
block.vtx[-1].wit.vtxinwit[int(i/(2*NUM_DROPS))].scriptWitness.stack[i%(2*NUM_DROPS)] = b'a'*(195+extra_bytes)
|
|
additional_bytes -= extra_bytes
|
|
i += 1
|
|
|
|
block.vtx[0].vout.pop() # Remove old commitment
|
|
add_witness_commitment(block)
|
|
block.solve()
|
|
vsize = get_virtual_size(block)
|
|
assert_equal(vsize, MAX_BLOCK_BASE_SIZE + 1)
|
|
# Make sure that our test case would exceed the old max-network-message
|
|
# limit
|
|
assert(len(block.serialize(True)) > 2*1024*1024)
|
|
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=False)
|
|
|
|
# Now resize the second transaction to make the block fit.
|
|
cur_length = len(block.vtx[-1].wit.vtxinwit[0].scriptWitness.stack[0])
|
|
block.vtx[-1].wit.vtxinwit[0].scriptWitness.stack[0] = b'a'*(cur_length-1)
|
|
block.vtx[0].vout.pop()
|
|
add_witness_commitment(block)
|
|
block.solve()
|
|
assert(get_virtual_size(block) == MAX_BLOCK_BASE_SIZE)
|
|
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=True)
|
|
|
|
# Update available utxo's
|
|
self.utxo.pop(0)
|
|
self.utxo.append(UTXO(block.vtx[-1].sha256, 0, block.vtx[-1].vout[0].nValue))
|
|
|
|
|
|
# submitblock will try to add the nonce automatically, so that mining
|
|
# software doesn't need to worry about doing so itself.
|
|
def test_submit_block(self):
|
|
block = self.build_next_block()
|
|
|
|
# Try using a custom nonce and then don't supply it.
|
|
# This shouldn't possibly work.
|
|
add_witness_commitment(block, nonce=1)
|
|
block.vtx[0].wit = CTxWitness() # drop the nonce
|
|
block.solve()
|
|
self.nodes[0].submitblock(bytes_to_hex_str(block.serialize(True)))
|
|
assert(self.nodes[0].getbestblockhash() != block.hash)
|
|
|
|
# Now redo commitment with the standard nonce, but let bitcoind fill it in.
|
|
add_witness_commitment(block, nonce=0)
|
|
block.vtx[0].wit = CTxWitness()
|
|
block.solve()
|
|
self.nodes[0].submitblock(bytes_to_hex_str(block.serialize(True)))
|
|
assert_equal(self.nodes[0].getbestblockhash(), block.hash)
|
|
|
|
# This time, add a tx with non-empty witness, but don't supply
|
|
# the commitment.
|
|
block_2 = self.build_next_block()
|
|
|
|
add_witness_commitment(block_2)
|
|
|
|
block_2.solve()
|
|
|
|
# Drop commitment and nonce -- submitblock should not fill in.
|
|
block_2.vtx[0].vout.pop()
|
|
block_2.vtx[0].wit = CTxWitness()
|
|
|
|
self.nodes[0].submitblock(bytes_to_hex_str(block_2.serialize(True)))
|
|
# Tip should not advance!
|
|
assert(self.nodes[0].getbestblockhash() != block_2.hash)
|
|
|
|
|
|
# Consensus tests of extra witness data in a transaction.
|
|
def test_extra_witness_data(self):
|
|
self.log.info("Testing extra witness data in tx")
|
|
|
|
assert(len(self.utxo) > 0)
|
|
|
|
block = self.build_next_block()
|
|
|
|
witness_program = CScript([OP_DROP, OP_TRUE])
|
|
witness_hash = sha256(witness_program)
|
|
scriptPubKey = CScript([OP_0, witness_hash])
|
|
|
|
# First try extra witness data on a tx that doesn't require a witness
|
|
tx = CTransaction()
|
|
tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
|
|
tx.vout.append(CTxOut(self.utxo[0].nValue-2000, scriptPubKey))
|
|
tx.vout.append(CTxOut(1000, CScript([OP_TRUE]))) # non-witness output
|
|
tx.wit.vtxinwit.append(CTxInWitness())
|
|
tx.wit.vtxinwit[0].scriptWitness.stack = [CScript([])]
|
|
tx.rehash()
|
|
self.update_witness_block_with_transactions(block, [tx])
|
|
|
|
# Extra witness data should not be allowed.
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=False)
|
|
|
|
# Try extra signature data. Ok if we're not spending a witness output.
|
|
block.vtx[1].wit.vtxinwit = []
|
|
block.vtx[1].vin[0].scriptSig = CScript([OP_0])
|
|
block.vtx[1].rehash()
|
|
add_witness_commitment(block)
|
|
block.solve()
|
|
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=True)
|
|
|
|
# Now try extra witness/signature data on an input that DOES require a
|
|
# witness
|
|
tx2 = CTransaction()
|
|
tx2.vin.append(CTxIn(COutPoint(tx.sha256, 0), b"")) # witness output
|
|
tx2.vin.append(CTxIn(COutPoint(tx.sha256, 1), b"")) # non-witness
|
|
tx2.vout.append(CTxOut(tx.vout[0].nValue, CScript([OP_TRUE])))
|
|
tx2.wit.vtxinwit.extend([CTxInWitness(), CTxInWitness()])
|
|
tx2.wit.vtxinwit[0].scriptWitness.stack = [ CScript([CScriptNum(1)]), CScript([CScriptNum(1)]), witness_program ]
|
|
tx2.wit.vtxinwit[1].scriptWitness.stack = [ CScript([OP_TRUE]) ]
|
|
|
|
block = self.build_next_block()
|
|
self.update_witness_block_with_transactions(block, [tx2])
|
|
|
|
# This has extra witness data, so it should fail.
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=False)
|
|
|
|
# Now get rid of the extra witness, but add extra scriptSig data
|
|
tx2.vin[0].scriptSig = CScript([OP_TRUE])
|
|
tx2.vin[1].scriptSig = CScript([OP_TRUE])
|
|
tx2.wit.vtxinwit[0].scriptWitness.stack.pop(0)
|
|
tx2.wit.vtxinwit[1].scriptWitness.stack = []
|
|
tx2.rehash()
|
|
add_witness_commitment(block)
|
|
block.solve()
|
|
|
|
# This has extra signature data for a witness input, so it should fail.
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=False)
|
|
|
|
# Now get rid of the extra scriptsig on the witness input, and verify
|
|
# success (even with extra scriptsig data in the non-witness input)
|
|
tx2.vin[0].scriptSig = b""
|
|
tx2.rehash()
|
|
add_witness_commitment(block)
|
|
block.solve()
|
|
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=True)
|
|
|
|
# Update utxo for later tests
|
|
self.utxo.pop(0)
|
|
self.utxo.append(UTXO(tx2.sha256, 0, tx2.vout[0].nValue))
|
|
|
|
|
|
def test_max_witness_push_length(self):
|
|
''' Should only allow up to 520 byte pushes in witness stack '''
|
|
self.log.info("Testing maximum witness push size")
|
|
MAX_SCRIPT_ELEMENT_SIZE = 520
|
|
assert(len(self.utxo))
|
|
|
|
block = self.build_next_block()
|
|
|
|
witness_program = CScript([OP_DROP, OP_TRUE])
|
|
witness_hash = sha256(witness_program)
|
|
scriptPubKey = CScript([OP_0, witness_hash])
|
|
|
|
tx = CTransaction()
|
|
tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
|
|
tx.vout.append(CTxOut(self.utxo[0].nValue-1000, scriptPubKey))
|
|
tx.rehash()
|
|
|
|
tx2 = CTransaction()
|
|
tx2.vin.append(CTxIn(COutPoint(tx.sha256, 0), b""))
|
|
tx2.vout.append(CTxOut(tx.vout[0].nValue-1000, CScript([OP_TRUE])))
|
|
tx2.wit.vtxinwit.append(CTxInWitness())
|
|
# First try a 521-byte stack element
|
|
tx2.wit.vtxinwit[0].scriptWitness.stack = [ b'a'*(MAX_SCRIPT_ELEMENT_SIZE+1), witness_program ]
|
|
tx2.rehash()
|
|
|
|
self.update_witness_block_with_transactions(block, [tx, tx2])
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=False)
|
|
|
|
# Now reduce the length of the stack element
|
|
tx2.wit.vtxinwit[0].scriptWitness.stack[0] = b'a'*(MAX_SCRIPT_ELEMENT_SIZE)
|
|
|
|
add_witness_commitment(block)
|
|
block.solve()
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=True)
|
|
|
|
# Update the utxo for later tests
|
|
self.utxo.pop()
|
|
self.utxo.append(UTXO(tx2.sha256, 0, tx2.vout[0].nValue))
|
|
|
|
def test_max_witness_program_length(self):
|
|
# Can create witness outputs that are long, but can't be greater than
|
|
# 10k bytes to successfully spend
|
|
self.log.info("Testing maximum witness program length")
|
|
assert(len(self.utxo))
|
|
MAX_PROGRAM_LENGTH = 10000
|
|
|
|
# This program is 19 max pushes (9937 bytes), then 64 more opcode-bytes.
|
|
long_witness_program = CScript([b'a'*520]*19 + [OP_DROP]*63 + [OP_TRUE])
|
|
assert(len(long_witness_program) == MAX_PROGRAM_LENGTH+1)
|
|
long_witness_hash = sha256(long_witness_program)
|
|
long_scriptPubKey = CScript([OP_0, long_witness_hash])
|
|
|
|
block = self.build_next_block()
|
|
|
|
tx = CTransaction()
|
|
tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
|
|
tx.vout.append(CTxOut(self.utxo[0].nValue-1000, long_scriptPubKey))
|
|
tx.rehash()
|
|
|
|
tx2 = CTransaction()
|
|
tx2.vin.append(CTxIn(COutPoint(tx.sha256, 0), b""))
|
|
tx2.vout.append(CTxOut(tx.vout[0].nValue-1000, CScript([OP_TRUE])))
|
|
tx2.wit.vtxinwit.append(CTxInWitness())
|
|
tx2.wit.vtxinwit[0].scriptWitness.stack = [b'a']*44 + [long_witness_program]
|
|
tx2.rehash()
|
|
|
|
self.update_witness_block_with_transactions(block, [tx, tx2])
|
|
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=False)
|
|
|
|
# Try again with one less byte in the witness program
|
|
witness_program = CScript([b'a'*520]*19 + [OP_DROP]*62 + [OP_TRUE])
|
|
assert(len(witness_program) == MAX_PROGRAM_LENGTH)
|
|
witness_hash = sha256(witness_program)
|
|
scriptPubKey = CScript([OP_0, witness_hash])
|
|
|
|
tx.vout[0] = CTxOut(tx.vout[0].nValue, scriptPubKey)
|
|
tx.rehash()
|
|
tx2.vin[0].prevout.hash = tx.sha256
|
|
tx2.wit.vtxinwit[0].scriptWitness.stack = [b'a']*43 + [witness_program]
|
|
tx2.rehash()
|
|
block.vtx = [block.vtx[0]]
|
|
self.update_witness_block_with_transactions(block, [tx, tx2])
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=True)
|
|
|
|
self.utxo.pop()
|
|
self.utxo.append(UTXO(tx2.sha256, 0, tx2.vout[0].nValue))
|
|
|
|
|
|
def test_witness_input_length(self):
|
|
''' Ensure that vin length must match vtxinwit length '''
|
|
self.log.info("Testing witness input length")
|
|
assert(len(self.utxo))
|
|
|
|
witness_program = CScript([OP_DROP, OP_TRUE])
|
|
witness_hash = sha256(witness_program)
|
|
scriptPubKey = CScript([OP_0, witness_hash])
|
|
|
|
# Create a transaction that splits our utxo into many outputs
|
|
tx = CTransaction()
|
|
tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
|
|
nValue = self.utxo[0].nValue
|
|
for i in range(10):
|
|
tx.vout.append(CTxOut(int(nValue/10), scriptPubKey))
|
|
tx.vout[0].nValue -= 1000
|
|
assert(tx.vout[0].nValue >= 0)
|
|
|
|
block = self.build_next_block()
|
|
self.update_witness_block_with_transactions(block, [tx])
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=True)
|
|
|
|
# Try various ways to spend tx that should all break.
|
|
# This "broken" transaction serializer will not normalize
|
|
# the length of vtxinwit.
|
|
class BrokenCTransaction(CTransaction):
|
|
def serialize_with_witness(self):
|
|
flags = 0
|
|
if not self.wit.is_null():
|
|
flags |= 1
|
|
r = b""
|
|
r += struct.pack("<i", self.nVersion)
|
|
if flags:
|
|
dummy = []
|
|
r += ser_vector(dummy)
|
|
r += struct.pack("<B", flags)
|
|
r += ser_vector(self.vin)
|
|
r += ser_vector(self.vout)
|
|
if flags & 1:
|
|
r += self.wit.serialize()
|
|
r += struct.pack("<I", self.nLockTime)
|
|
return r
|
|
|
|
tx2 = BrokenCTransaction()
|
|
for i in range(10):
|
|
tx2.vin.append(CTxIn(COutPoint(tx.sha256, i), b""))
|
|
tx2.vout.append(CTxOut(nValue-3000, CScript([OP_TRUE])))
|
|
|
|
# First try using a too long vtxinwit
|
|
for i in range(11):
|
|
tx2.wit.vtxinwit.append(CTxInWitness())
|
|
tx2.wit.vtxinwit[i].scriptWitness.stack = [b'a', witness_program]
|
|
|
|
block = self.build_next_block()
|
|
self.update_witness_block_with_transactions(block, [tx2])
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=False)
|
|
|
|
# Now try using a too short vtxinwit
|
|
tx2.wit.vtxinwit.pop()
|
|
tx2.wit.vtxinwit.pop()
|
|
|
|
block.vtx = [block.vtx[0]]
|
|
self.update_witness_block_with_transactions(block, [tx2])
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=False)
|
|
|
|
# Now make one of the intermediate witnesses be incorrect
|
|
tx2.wit.vtxinwit.append(CTxInWitness())
|
|
tx2.wit.vtxinwit[-1].scriptWitness.stack = [b'a', witness_program]
|
|
tx2.wit.vtxinwit[5].scriptWitness.stack = [ witness_program ]
|
|
|
|
block.vtx = [block.vtx[0]]
|
|
self.update_witness_block_with_transactions(block, [tx2])
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=False)
|
|
|
|
# Fix the broken witness and the block should be accepted.
|
|
tx2.wit.vtxinwit[5].scriptWitness.stack = [b'a', witness_program]
|
|
block.vtx = [block.vtx[0]]
|
|
self.update_witness_block_with_transactions(block, [tx2])
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=True)
|
|
|
|
self.utxo.pop()
|
|
self.utxo.append(UTXO(tx2.sha256, 0, tx2.vout[0].nValue))
|
|
|
|
|
|
def test_witness_tx_relay_before_segwit_activation(self):
|
|
self.log.info("Testing relay of witness transactions")
|
|
# Generate a transaction that doesn't require a witness, but send it
|
|
# with a witness. Should be rejected for premature-witness, but should
|
|
# not be added to recently rejected list.
|
|
assert(len(self.utxo))
|
|
tx = CTransaction()
|
|
tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
|
|
tx.vout.append(CTxOut(self.utxo[0].nValue-1000, CScript([OP_TRUE])))
|
|
tx.wit.vtxinwit.append(CTxInWitness())
|
|
tx.wit.vtxinwit[0].scriptWitness.stack = [ b'a' ]
|
|
tx.rehash()
|
|
|
|
tx_hash = tx.sha256
|
|
tx_value = tx.vout[0].nValue
|
|
|
|
# Verify that if a peer doesn't set nServices to include NODE_WITNESS,
|
|
# the getdata is just for the non-witness portion.
|
|
self.old_node.announce_tx_and_wait_for_getdata(tx)
|
|
assert(self.old_node.last_message["getdata"].inv[0].type == 1)
|
|
|
|
# Since we haven't delivered the tx yet, inv'ing the same tx from
|
|
# a witness transaction ought not result in a getdata.
|
|
try:
|
|
self.test_node.announce_tx_and_wait_for_getdata(tx, timeout=2)
|
|
self.log.error("Error: duplicate tx getdata!")
|
|
assert(False)
|
|
except AssertionError:
|
|
pass
|
|
|
|
# Delivering this transaction with witness should fail (no matter who
|
|
# its from)
|
|
assert_equal(len(self.nodes[0].getrawmempool()), 0)
|
|
assert_equal(len(self.nodes[1].getrawmempool()), 0)
|
|
test_transaction_acceptance(self.nodes[0].rpc, self.old_node, tx, with_witness=True, accepted=False)
|
|
test_transaction_acceptance(self.nodes[0].rpc, self.test_node, tx, with_witness=True, accepted=False)
|
|
|
|
# But eliminating the witness should fix it
|
|
test_transaction_acceptance(self.nodes[0].rpc, self.test_node, tx, with_witness=False, accepted=True)
|
|
|
|
# Cleanup: mine the first transaction and update utxo
|
|
self.nodes[0].generate(1)
|
|
assert_equal(len(self.nodes[0].getrawmempool()), 0)
|
|
|
|
self.utxo.pop(0)
|
|
self.utxo.append(UTXO(tx_hash, 0, tx_value))
|
|
|
|
|
|
# After segwit activates, verify that mempool:
|
|
# - rejects transactions with unnecessary/extra witnesses
|
|
# - accepts transactions with valid witnesses
|
|
# and that witness transactions are relayed to non-upgraded peers.
|
|
def test_tx_relay_after_segwit_activation(self):
|
|
self.log.info("Testing relay of witness transactions")
|
|
# Generate a transaction that doesn't require a witness, but send it
|
|
# with a witness. Should be rejected because we can't use a witness
|
|
# when spending a non-witness output.
|
|
assert(len(self.utxo))
|
|
tx = CTransaction()
|
|
tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
|
|
tx.vout.append(CTxOut(self.utxo[0].nValue-1000, CScript([OP_TRUE])))
|
|
tx.wit.vtxinwit.append(CTxInWitness())
|
|
tx.wit.vtxinwit[0].scriptWitness.stack = [ b'a' ]
|
|
tx.rehash()
|
|
|
|
tx_hash = tx.sha256
|
|
|
|
# Verify that unnecessary witnesses are rejected.
|
|
self.test_node.announce_tx_and_wait_for_getdata(tx)
|
|
assert_equal(len(self.nodes[0].getrawmempool()), 0)
|
|
test_transaction_acceptance(self.nodes[0].rpc, self.test_node, tx, with_witness=True, accepted=False)
|
|
|
|
# Verify that removing the witness succeeds.
|
|
self.test_node.announce_tx_and_wait_for_getdata(tx)
|
|
test_transaction_acceptance(self.nodes[0].rpc, self.test_node, tx, with_witness=False, accepted=True)
|
|
|
|
# Now try to add extra witness data to a valid witness tx.
|
|
witness_program = CScript([OP_TRUE])
|
|
witness_hash = sha256(witness_program)
|
|
scriptPubKey = CScript([OP_0, witness_hash])
|
|
tx2 = CTransaction()
|
|
tx2.vin.append(CTxIn(COutPoint(tx_hash, 0), b""))
|
|
tx2.vout.append(CTxOut(tx.vout[0].nValue-1000, scriptPubKey))
|
|
tx2.rehash()
|
|
|
|
tx3 = CTransaction()
|
|
tx3.vin.append(CTxIn(COutPoint(tx2.sha256, 0), b""))
|
|
tx3.wit.vtxinwit.append(CTxInWitness())
|
|
|
|
# Add too-large for IsStandard witness and check that it does not enter reject filter
|
|
p2sh_program = CScript([OP_TRUE])
|
|
p2sh_pubkey = hash160(p2sh_program)
|
|
witness_program2 = CScript([b'a'*400000])
|
|
tx3.vout.append(CTxOut(tx2.vout[0].nValue-1000, CScript([OP_HASH160, p2sh_pubkey, OP_EQUAL])))
|
|
tx3.wit.vtxinwit[0].scriptWitness.stack = [witness_program2]
|
|
tx3.rehash()
|
|
|
|
# Node will not be blinded to the transaction
|
|
self.std_node.announce_tx_and_wait_for_getdata(tx3)
|
|
test_transaction_acceptance(self.nodes[1].rpc, self.std_node, tx3, True, False, b'tx-size')
|
|
self.std_node.announce_tx_and_wait_for_getdata(tx3)
|
|
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
|
|
tx3.vout[0] = CTxOut(tx2.vout[0].nValue-1000, CScript([OP_TRUE]))
|
|
tx3.wit.vtxinwit[0].scriptWitness.stack = [CScript([CScriptNum(1)]), witness_program ]
|
|
tx3.rehash()
|
|
|
|
test_transaction_acceptance(self.nodes[0].rpc, self.test_node, tx2, with_witness=True, accepted=True)
|
|
test_transaction_acceptance(self.nodes[0].rpc, self.test_node, tx3, with_witness=True, accepted=False)
|
|
|
|
# Get rid of the extra witness, and verify acceptance.
|
|
tx3.wit.vtxinwit[0].scriptWitness.stack = [ witness_program ]
|
|
# Also check that old_node gets a tx announcement, even though this is
|
|
# a witness transaction.
|
|
self.old_node.wait_for_inv([CInv(1, tx2.sha256)]) # wait until tx2 was inv'ed
|
|
test_transaction_acceptance(self.nodes[0].rpc, self.test_node, tx3, with_witness=True, accepted=True)
|
|
self.old_node.wait_for_inv([CInv(1, tx3.sha256)])
|
|
|
|
# Test that getrawtransaction returns correct witness information
|
|
# hash, size, vsize
|
|
raw_tx = self.nodes[0].getrawtransaction(tx3.hash, 1)
|
|
assert_equal(int(raw_tx["hash"], 16), tx3.calc_sha256(True))
|
|
assert_equal(raw_tx["size"], len(tx3.serialize_with_witness()))
|
|
weight = len(tx3.serialize_with_witness()) + 3*len(tx3.serialize_without_witness())
|
|
vsize = math.ceil(weight / 4)
|
|
assert_equal(raw_tx["vsize"], vsize)
|
|
assert_equal(raw_tx["weight"], weight)
|
|
assert_equal(len(raw_tx["vin"][0]["txinwitness"]), 1)
|
|
assert_equal(raw_tx["vin"][0]["txinwitness"][0], hexlify(witness_program).decode('ascii'))
|
|
assert(vsize != raw_tx["size"])
|
|
|
|
# Cleanup: mine the transactions and update utxo for next test
|
|
self.nodes[0].generate(1)
|
|
assert_equal(len(self.nodes[0].getrawmempool()), 0)
|
|
|
|
self.utxo.pop(0)
|
|
self.utxo.append(UTXO(tx3.sha256, 0, tx3.vout[0].nValue))
|
|
|
|
|
|
# Test that block requests to NODE_WITNESS peer are with MSG_WITNESS_FLAG
|
|
# This is true regardless of segwit activation.
|
|
# Also test that we don't ask for blocks from unupgraded peers
|
|
def test_block_relay(self, segwit_activated):
|
|
self.log.info("Testing block relay")
|
|
|
|
blocktype = 2|MSG_WITNESS_FLAG
|
|
|
|
# test_node has set NODE_WITNESS, so all getdata requests should be for
|
|
# witness blocks.
|
|
# Test announcing a block via inv results in a getdata, and that
|
|
# announcing a version 4 or random VB block with a header results in a getdata
|
|
block1 = self.build_next_block()
|
|
block1.solve()
|
|
|
|
self.test_node.announce_block_and_wait_for_getdata(block1, use_header=False)
|
|
assert(self.test_node.last_message["getdata"].inv[0].type == blocktype)
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block1, True)
|
|
|
|
block2 = self.build_next_block(nVersion=4)
|
|
block2.solve()
|
|
|
|
self.test_node.announce_block_and_wait_for_getdata(block2, use_header=True)
|
|
assert(self.test_node.last_message["getdata"].inv[0].type == blocktype)
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block2, True)
|
|
|
|
block3 = self.build_next_block(nVersion=(VB_TOP_BITS | (1<<15)))
|
|
block3.solve()
|
|
self.test_node.announce_block_and_wait_for_getdata(block3, use_header=True)
|
|
assert(self.test_node.last_message["getdata"].inv[0].type == blocktype)
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block3, True)
|
|
|
|
# Check that we can getdata for witness blocks or regular blocks,
|
|
# and the right thing happens.
|
|
if segwit_activated == False:
|
|
# Before activation, we should be able to request old blocks with
|
|
# or without witness, and they should be the same.
|
|
chain_height = self.nodes[0].getblockcount()
|
|
# Pick 10 random blocks on main chain, and verify that getdata's
|
|
# for MSG_BLOCK, MSG_WITNESS_BLOCK, and rpc getblock() are equal.
|
|
all_heights = list(range(chain_height+1))
|
|
random.shuffle(all_heights)
|
|
all_heights = all_heights[0:10]
|
|
for height in all_heights:
|
|
block_hash = self.nodes[0].getblockhash(height)
|
|
rpc_block = self.nodes[0].getblock(block_hash, False)
|
|
block_hash = int(block_hash, 16)
|
|
block = self.test_node.request_block(block_hash, 2)
|
|
wit_block = self.test_node.request_block(block_hash, 2|MSG_WITNESS_FLAG)
|
|
assert_equal(block.serialize(True), wit_block.serialize(True))
|
|
assert_equal(block.serialize(), hex_str_to_bytes(rpc_block))
|
|
else:
|
|
# After activation, witness blocks and non-witness blocks should
|
|
# be different. Verify rpc getblock() returns witness blocks, while
|
|
# getdata respects the requested type.
|
|
block = self.build_next_block()
|
|
self.update_witness_block_with_transactions(block, [])
|
|
# This gives us a witness commitment.
|
|
assert(len(block.vtx[0].wit.vtxinwit) == 1)
|
|
assert(len(block.vtx[0].wit.vtxinwit[0].scriptWitness.stack) == 1)
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=True)
|
|
# Now try to retrieve it...
|
|
rpc_block = self.nodes[0].getblock(block.hash, False)
|
|
non_wit_block = self.test_node.request_block(block.sha256, 2)
|
|
wit_block = self.test_node.request_block(block.sha256, 2|MSG_WITNESS_FLAG)
|
|
assert_equal(wit_block.serialize(True), hex_str_to_bytes(rpc_block))
|
|
assert_equal(wit_block.serialize(False), non_wit_block.serialize())
|
|
assert_equal(wit_block.serialize(True), block.serialize(True))
|
|
|
|
# Test size, vsize, weight
|
|
rpc_details = self.nodes[0].getblock(block.hash, True)
|
|
assert_equal(rpc_details["size"], len(block.serialize(True)))
|
|
assert_equal(rpc_details["strippedsize"], len(block.serialize(False)))
|
|
weight = 3*len(block.serialize(False)) + len(block.serialize(True))
|
|
assert_equal(rpc_details["weight"], weight)
|
|
|
|
# Upgraded node should not ask for blocks from unupgraded
|
|
block4 = self.build_next_block(nVersion=4)
|
|
block4.solve()
|
|
self.old_node.getdataset = set()
|
|
|
|
# Blocks can be requested via direct-fetch (immediately upon processing the announcement)
|
|
# or via parallel download (with an indeterminate delay from processing the announcement)
|
|
# so to test that a block is NOT requested, we could guess a time period to sleep for,
|
|
# and then check. We can avoid the sleep() by taking advantage of transaction getdata's
|
|
# being processed after block getdata's, and announce a transaction as well,
|
|
# and then check to see if that particular getdata has been received.
|
|
# Since 0.14, inv's will only be responded to with a getheaders, so send a header
|
|
# to announce this block.
|
|
msg = msg_headers()
|
|
msg.headers = [ CBlockHeader(block4) ]
|
|
self.old_node.send_message(msg)
|
|
self.old_node.announce_tx_and_wait_for_getdata(block4.vtx[0])
|
|
assert(block4.sha256 not in self.old_node.getdataset)
|
|
|
|
# V0 segwit outputs should be standard after activation, but not before.
|
|
def test_standardness_v0(self, segwit_activated):
|
|
self.log.info("Testing standardness of v0 outputs (%s activation)" % ("after" if segwit_activated else "before"))
|
|
assert(len(self.utxo))
|
|
|
|
witness_program = CScript([OP_TRUE])
|
|
witness_hash = sha256(witness_program)
|
|
scriptPubKey = CScript([OP_0, witness_hash])
|
|
|
|
p2sh_pubkey = hash160(witness_program)
|
|
p2sh_scriptPubKey = CScript([OP_HASH160, p2sh_pubkey, OP_EQUAL])
|
|
|
|
# First prepare a p2sh output (so that spending it will pass standardness)
|
|
p2sh_tx = CTransaction()
|
|
p2sh_tx.vin = [CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b"")]
|
|
p2sh_tx.vout = [CTxOut(self.utxo[0].nValue-1000, p2sh_scriptPubKey)]
|
|
p2sh_tx.rehash()
|
|
|
|
# Mine it on test_node to create the confirmed output.
|
|
test_transaction_acceptance(self.nodes[0].rpc, self.test_node, p2sh_tx, with_witness=True, accepted=True)
|
|
self.nodes[0].generate(1)
|
|
sync_blocks(self.nodes)
|
|
|
|
# Now test standardness of v0 P2WSH outputs.
|
|
# Start by creating a transaction with two outputs.
|
|
tx = CTransaction()
|
|
tx.vin = [CTxIn(COutPoint(p2sh_tx.sha256, 0), CScript([witness_program]))]
|
|
tx.vout = [CTxOut(p2sh_tx.vout[0].nValue-10000, scriptPubKey)]
|
|
tx.vout.append(CTxOut(8000, scriptPubKey)) # Might burn this later
|
|
tx.rehash()
|
|
|
|
test_transaction_acceptance(self.nodes[1].rpc, self.std_node, tx, with_witness=True, accepted=segwit_activated)
|
|
|
|
# Now create something that looks like a P2PKH output. This won't be spendable.
|
|
scriptPubKey = CScript([OP_0, hash160(witness_hash)])
|
|
tx2 = CTransaction()
|
|
if segwit_activated:
|
|
# if tx was accepted, then we spend the second output.
|
|
tx2.vin = [CTxIn(COutPoint(tx.sha256, 1), b"")]
|
|
tx2.vout = [CTxOut(7000, scriptPubKey)]
|
|
tx2.wit.vtxinwit.append(CTxInWitness())
|
|
tx2.wit.vtxinwit[0].scriptWitness.stack = [witness_program]
|
|
else:
|
|
# if tx wasn't accepted, we just re-spend the p2sh output we started with.
|
|
tx2.vin = [CTxIn(COutPoint(p2sh_tx.sha256, 0), CScript([witness_program]))]
|
|
tx2.vout = [CTxOut(p2sh_tx.vout[0].nValue-1000, scriptPubKey)]
|
|
tx2.rehash()
|
|
|
|
test_transaction_acceptance(self.nodes[1].rpc, self.std_node, tx2, with_witness=True, accepted=segwit_activated)
|
|
|
|
# Now update self.utxo for later tests.
|
|
tx3 = CTransaction()
|
|
if segwit_activated:
|
|
# tx and tx2 were both accepted. Don't bother trying to reclaim the
|
|
# P2PKH output; just send tx's first output back to an anyone-can-spend.
|
|
sync_mempools([self.nodes[0], self.nodes[1]])
|
|
tx3.vin = [CTxIn(COutPoint(tx.sha256, 0), b"")]
|
|
tx3.vout = [CTxOut(tx.vout[0].nValue-1000, CScript([OP_TRUE]))]
|
|
tx3.wit.vtxinwit.append(CTxInWitness())
|
|
tx3.wit.vtxinwit[0].scriptWitness.stack = [witness_program]
|
|
tx3.rehash()
|
|
test_transaction_acceptance(self.nodes[0].rpc, self.test_node, tx3, with_witness=True, accepted=True)
|
|
else:
|
|
# tx and tx2 didn't go anywhere; just clean up the p2sh_tx output.
|
|
tx3.vin = [CTxIn(COutPoint(p2sh_tx.sha256, 0), CScript([witness_program]))]
|
|
tx3.vout = [CTxOut(p2sh_tx.vout[0].nValue-1000, witness_program)]
|
|
tx3.rehash()
|
|
test_transaction_acceptance(self.nodes[0].rpc, self.test_node, tx3, with_witness=True, accepted=True)
|
|
|
|
self.nodes[0].generate(1)
|
|
sync_blocks(self.nodes)
|
|
self.utxo.pop(0)
|
|
self.utxo.append(UTXO(tx3.sha256, 0, tx3.vout[0].nValue))
|
|
assert_equal(len(self.nodes[1].getrawmempool()), 0)
|
|
|
|
|
|
# Verify that future segwit upgraded transactions are non-standard,
|
|
# but valid in blocks. Can run this before and after segwit activation.
|
|
def test_segwit_versions(self):
|
|
self.log.info("Testing standardness/consensus for segwit versions (0-16)")
|
|
assert(len(self.utxo))
|
|
NUM_TESTS = 17 # will test OP_0, OP1, ..., OP_16
|
|
if (len(self.utxo) < NUM_TESTS):
|
|
tx = CTransaction()
|
|
tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
|
|
split_value = (self.utxo[0].nValue - 4000) // NUM_TESTS
|
|
for i in range(NUM_TESTS):
|
|
tx.vout.append(CTxOut(split_value, CScript([OP_TRUE])))
|
|
tx.rehash()
|
|
block = self.build_next_block()
|
|
self.update_witness_block_with_transactions(block, [tx])
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=True)
|
|
self.utxo.pop(0)
|
|
for i in range(NUM_TESTS):
|
|
self.utxo.append(UTXO(tx.sha256, i, split_value))
|
|
|
|
sync_blocks(self.nodes)
|
|
temp_utxo = []
|
|
tx = CTransaction()
|
|
count = 0
|
|
witness_program = CScript([OP_TRUE])
|
|
witness_hash = sha256(witness_program)
|
|
assert_equal(len(self.nodes[1].getrawmempool()), 0)
|
|
for version in list(range(OP_1, OP_16+1)) + [OP_0]:
|
|
count += 1
|
|
# First try to spend to a future version segwit scriptPubKey.
|
|
scriptPubKey = CScript([CScriptOp(version), witness_hash])
|
|
tx.vin = [CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b"")]
|
|
tx.vout = [CTxOut(self.utxo[0].nValue-1000, scriptPubKey)]
|
|
tx.rehash()
|
|
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)
|
|
self.utxo.pop(0)
|
|
temp_utxo.append(UTXO(tx.sha256, 0, tx.vout[0].nValue))
|
|
|
|
self.nodes[0].generate(1) # Mine all the transactions
|
|
sync_blocks(self.nodes)
|
|
assert(len(self.nodes[0].getrawmempool()) == 0)
|
|
|
|
# Finally, verify that version 0 -> version 1 transactions
|
|
# are non-standard
|
|
scriptPubKey = CScript([CScriptOp(OP_1), witness_hash])
|
|
tx2 = CTransaction()
|
|
tx2.vin = [CTxIn(COutPoint(tx.sha256, 0), b"")]
|
|
tx2.vout = [CTxOut(tx.vout[0].nValue-1000, scriptPubKey)]
|
|
tx2.wit.vtxinwit.append(CTxInWitness())
|
|
tx2.wit.vtxinwit[0].scriptWitness.stack = [ witness_program ]
|
|
tx2.rehash()
|
|
# Gets accepted to test_node, because standardness of outputs isn't
|
|
# checked with fRequireStandard
|
|
test_transaction_acceptance(self.nodes[0].rpc, self.test_node, tx2, with_witness=True, accepted=True)
|
|
test_transaction_acceptance(self.nodes[1].rpc, self.std_node, tx2, with_witness=True, accepted=False)
|
|
temp_utxo.pop() # last entry in temp_utxo was the output we just spent
|
|
temp_utxo.append(UTXO(tx2.sha256, 0, tx2.vout[0].nValue))
|
|
|
|
# Spend everything in temp_utxo back to an OP_TRUE output.
|
|
tx3 = CTransaction()
|
|
total_value = 0
|
|
for i in temp_utxo:
|
|
tx3.vin.append(CTxIn(COutPoint(i.sha256, i.n), b""))
|
|
tx3.wit.vtxinwit.append(CTxInWitness())
|
|
total_value += i.nValue
|
|
tx3.wit.vtxinwit[-1].scriptWitness.stack = [witness_program]
|
|
tx3.vout.append(CTxOut(total_value - 1000, CScript([OP_TRUE])))
|
|
tx3.rehash()
|
|
# Spending a higher version witness output is not allowed by policy,
|
|
# even with fRequireStandard=false.
|
|
test_transaction_acceptance(self.nodes[0].rpc, self.test_node, tx3, with_witness=True, accepted=False)
|
|
self.test_node.sync_with_ping()
|
|
with mininode_lock:
|
|
assert(b"reserved for soft-fork upgrades" in self.test_node.last_message["reject"].reason)
|
|
|
|
# Building a block with the transaction must be valid, however.
|
|
block = self.build_next_block()
|
|
self.update_witness_block_with_transactions(block, [tx2, tx3])
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=True)
|
|
sync_blocks(self.nodes)
|
|
|
|
# Add utxo to our list
|
|
self.utxo.append(UTXO(tx3.sha256, 0, tx3.vout[0].nValue))
|
|
|
|
|
|
def test_premature_coinbase_witness_spend(self):
|
|
self.log.info("Testing premature coinbase witness spend")
|
|
block = self.build_next_block()
|
|
# Change the output of the block to be a witness output.
|
|
witness_program = CScript([OP_TRUE])
|
|
witness_hash = sha256(witness_program)
|
|
scriptPubKey = CScript([OP_0, witness_hash])
|
|
block.vtx[0].vout[0].scriptPubKey = scriptPubKey
|
|
# This next line will rehash the coinbase and update the merkle
|
|
# root, and solve.
|
|
self.update_witness_block_with_transactions(block, [])
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=True)
|
|
|
|
spend_tx = CTransaction()
|
|
spend_tx.vin = [CTxIn(COutPoint(block.vtx[0].sha256, 0), b"")]
|
|
spend_tx.vout = [CTxOut(block.vtx[0].vout[0].nValue, witness_program)]
|
|
spend_tx.wit.vtxinwit.append(CTxInWitness())
|
|
spend_tx.wit.vtxinwit[0].scriptWitness.stack = [ witness_program ]
|
|
spend_tx.rehash()
|
|
|
|
# Now test a premature spend.
|
|
self.nodes[0].generate(98)
|
|
sync_blocks(self.nodes)
|
|
block2 = self.build_next_block()
|
|
self.update_witness_block_with_transactions(block2, [spend_tx])
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block2, accepted=False)
|
|
|
|
# Advancing one more block should allow the spend.
|
|
self.nodes[0].generate(1)
|
|
block2 = self.build_next_block()
|
|
self.update_witness_block_with_transactions(block2, [spend_tx])
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block2, accepted=True)
|
|
sync_blocks(self.nodes)
|
|
|
|
|
|
def test_signature_version_1(self):
|
|
self.log.info("Testing segwit signature hash version 1")
|
|
key = CECKey()
|
|
key.set_secretbytes(b"9")
|
|
pubkey = CPubKey(key.get_pubkey())
|
|
|
|
witness_program = CScript([pubkey, CScriptOp(OP_CHECKSIG)])
|
|
witness_hash = sha256(witness_program)
|
|
scriptPubKey = CScript([OP_0, witness_hash])
|
|
|
|
# First create a witness output for use in the tests.
|
|
assert(len(self.utxo))
|
|
tx = CTransaction()
|
|
tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
|
|
tx.vout.append(CTxOut(self.utxo[0].nValue-1000, scriptPubKey))
|
|
tx.rehash()
|
|
|
|
test_transaction_acceptance(self.nodes[0].rpc, self.test_node, tx, with_witness=True, accepted=True)
|
|
# Mine this transaction in preparation for following tests.
|
|
block = self.build_next_block()
|
|
self.update_witness_block_with_transactions(block, [tx])
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=True)
|
|
sync_blocks(self.nodes)
|
|
self.utxo.pop(0)
|
|
|
|
# Test each hashtype
|
|
prev_utxo = UTXO(tx.sha256, 0, tx.vout[0].nValue)
|
|
for sigflag in [ 0, SIGHASH_ANYONECANPAY ]:
|
|
for hashtype in [SIGHASH_ALL, SIGHASH_NONE, SIGHASH_SINGLE]:
|
|
hashtype |= sigflag
|
|
block = self.build_next_block()
|
|
tx = CTransaction()
|
|
tx.vin.append(CTxIn(COutPoint(prev_utxo.sha256, prev_utxo.n), b""))
|
|
tx.vout.append(CTxOut(prev_utxo.nValue - 1000, scriptPubKey))
|
|
tx.wit.vtxinwit.append(CTxInWitness())
|
|
# Too-large input value
|
|
sign_P2PK_witness_input(witness_program, tx, 0, hashtype, prev_utxo.nValue+1, key)
|
|
self.update_witness_block_with_transactions(block, [tx])
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=False)
|
|
|
|
# Too-small input value
|
|
sign_P2PK_witness_input(witness_program, tx, 0, hashtype, prev_utxo.nValue-1, key)
|
|
block.vtx.pop() # remove last tx
|
|
self.update_witness_block_with_transactions(block, [tx])
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=False)
|
|
|
|
# Now try correct value
|
|
sign_P2PK_witness_input(witness_program, tx, 0, hashtype, prev_utxo.nValue, key)
|
|
block.vtx.pop()
|
|
self.update_witness_block_with_transactions(block, [tx])
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=True)
|
|
|
|
prev_utxo = UTXO(tx.sha256, 0, tx.vout[0].nValue)
|
|
|
|
# Test combinations of signature hashes.
|
|
# Split the utxo into a lot of outputs.
|
|
# Randomly choose up to 10 to spend, sign with different hashtypes, and
|
|
# output to a random number of outputs. Repeat NUM_TESTS times.
|
|
# Ensure that we've tested a situation where we use SIGHASH_SINGLE with
|
|
# an input index > number of outputs.
|
|
NUM_TESTS = 500
|
|
temp_utxos = []
|
|
tx = CTransaction()
|
|
tx.vin.append(CTxIn(COutPoint(prev_utxo.sha256, prev_utxo.n), b""))
|
|
split_value = prev_utxo.nValue // NUM_TESTS
|
|
for i in range(NUM_TESTS):
|
|
tx.vout.append(CTxOut(split_value, scriptPubKey))
|
|
tx.wit.vtxinwit.append(CTxInWitness())
|
|
sign_P2PK_witness_input(witness_program, tx, 0, SIGHASH_ALL, prev_utxo.nValue, key)
|
|
for i in range(NUM_TESTS):
|
|
temp_utxos.append(UTXO(tx.sha256, i, split_value))
|
|
|
|
block = self.build_next_block()
|
|
self.update_witness_block_with_transactions(block, [tx])
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=True)
|
|
|
|
block = self.build_next_block()
|
|
used_sighash_single_out_of_bounds = False
|
|
for i in range(NUM_TESTS):
|
|
# Ping regularly to keep the connection alive
|
|
if (not i % 100):
|
|
self.test_node.sync_with_ping()
|
|
# Choose random number of inputs to use.
|
|
num_inputs = random.randint(1, 10)
|
|
# Create a slight bias for producing more utxos
|
|
num_outputs = random.randint(1, 11)
|
|
random.shuffle(temp_utxos)
|
|
assert(len(temp_utxos) > num_inputs)
|
|
tx = CTransaction()
|
|
total_value = 0
|
|
for i in range(num_inputs):
|
|
tx.vin.append(CTxIn(COutPoint(temp_utxos[i].sha256, temp_utxos[i].n), b""))
|
|
tx.wit.vtxinwit.append(CTxInWitness())
|
|
total_value += temp_utxos[i].nValue
|
|
split_value = total_value // num_outputs
|
|
for i in range(num_outputs):
|
|
tx.vout.append(CTxOut(split_value, scriptPubKey))
|
|
for i in range(num_inputs):
|
|
# Now try to sign each input, using a random hashtype.
|
|
anyonecanpay = 0
|
|
if random.randint(0, 1):
|
|
anyonecanpay = SIGHASH_ANYONECANPAY
|
|
hashtype = random.randint(1, 3) | anyonecanpay
|
|
sign_P2PK_witness_input(witness_program, tx, i, hashtype, temp_utxos[i].nValue, key)
|
|
if (hashtype == SIGHASH_SINGLE and i >= num_outputs):
|
|
used_sighash_single_out_of_bounds = True
|
|
tx.rehash()
|
|
for i in range(num_outputs):
|
|
temp_utxos.append(UTXO(tx.sha256, i, split_value))
|
|
temp_utxos = temp_utxos[num_inputs:]
|
|
|
|
block.vtx.append(tx)
|
|
|
|
# Test the block periodically, if we're close to maxblocksize
|
|
if (get_virtual_size(block) > MAX_BLOCK_BASE_SIZE - 1000):
|
|
self.update_witness_block_with_transactions(block, [])
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=True)
|
|
block = self.build_next_block()
|
|
|
|
if (not used_sighash_single_out_of_bounds):
|
|
self.log.info("WARNING: this test run didn't attempt SIGHASH_SINGLE with out-of-bounds index value")
|
|
# Test the transactions we've added to the block
|
|
if (len(block.vtx) > 1):
|
|
self.update_witness_block_with_transactions(block, [])
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=True)
|
|
|
|
# Now test witness version 0 P2PKH transactions
|
|
pubkeyhash = hash160(pubkey)
|
|
scriptPKH = CScript([OP_0, pubkeyhash])
|
|
tx = CTransaction()
|
|
tx.vin.append(CTxIn(COutPoint(temp_utxos[0].sha256, temp_utxos[0].n), b""))
|
|
tx.vout.append(CTxOut(temp_utxos[0].nValue, scriptPKH))
|
|
tx.wit.vtxinwit.append(CTxInWitness())
|
|
sign_P2PK_witness_input(witness_program, tx, 0, SIGHASH_ALL, temp_utxos[0].nValue, key)
|
|
tx2 = CTransaction()
|
|
tx2.vin.append(CTxIn(COutPoint(tx.sha256, 0), b""))
|
|
tx2.vout.append(CTxOut(tx.vout[0].nValue, CScript([OP_TRUE])))
|
|
|
|
script = GetP2PKHScript(pubkeyhash)
|
|
sig_hash = SegwitVersion1SignatureHash(script, tx2, 0, SIGHASH_ALL, tx.vout[0].nValue)
|
|
signature = key.sign(sig_hash) + b'\x01' # 0x1 is SIGHASH_ALL
|
|
|
|
# Check that we can't have a scriptSig
|
|
tx2.vin[0].scriptSig = CScript([signature, pubkey])
|
|
block = self.build_next_block()
|
|
self.update_witness_block_with_transactions(block, [tx, tx2])
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=False)
|
|
|
|
# Move the signature to the witness.
|
|
block.vtx.pop()
|
|
tx2.wit.vtxinwit.append(CTxInWitness())
|
|
tx2.wit.vtxinwit[0].scriptWitness.stack = [signature, pubkey]
|
|
tx2.vin[0].scriptSig = b""
|
|
tx2.rehash()
|
|
|
|
self.update_witness_block_with_transactions(block, [tx2])
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=True)
|
|
|
|
temp_utxos.pop(0)
|
|
|
|
# Update self.utxos for later tests by creating two outputs
|
|
# that consolidate all the coins in temp_utxos.
|
|
output_value = sum(i.nValue for i in temp_utxos) // 2
|
|
|
|
tx = CTransaction()
|
|
index = 0
|
|
# Just spend to our usual anyone-can-spend output
|
|
tx.vout = [CTxOut(output_value, CScript([OP_TRUE]))] * 2
|
|
for i in temp_utxos:
|
|
# Use SIGHASH_ALL|SIGHASH_ANYONECANPAY so we can build up
|
|
# the signatures as we go.
|
|
tx.vin.append(CTxIn(COutPoint(i.sha256, i.n), b""))
|
|
tx.wit.vtxinwit.append(CTxInWitness())
|
|
sign_P2PK_witness_input(witness_program, tx, index, SIGHASH_ALL|SIGHASH_ANYONECANPAY, i.nValue, key)
|
|
index += 1
|
|
block = self.build_next_block()
|
|
self.update_witness_block_with_transactions(block, [tx])
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=True)
|
|
|
|
for i in range(len(tx.vout)):
|
|
self.utxo.append(UTXO(tx.sha256, i, tx.vout[i].nValue))
|
|
|
|
|
|
# Test P2SH wrapped witness programs.
|
|
def test_p2sh_witness(self, segwit_activated):
|
|
self.log.info("Testing P2SH witness transactions")
|
|
|
|
assert(len(self.utxo))
|
|
|
|
# Prepare the p2sh-wrapped witness output
|
|
witness_program = CScript([OP_DROP, OP_TRUE])
|
|
witness_hash = sha256(witness_program)
|
|
p2wsh_pubkey = CScript([OP_0, witness_hash])
|
|
p2sh_witness_hash = hash160(p2wsh_pubkey)
|
|
scriptPubKey = CScript([OP_HASH160, p2sh_witness_hash, OP_EQUAL])
|
|
scriptSig = CScript([p2wsh_pubkey]) # a push of the redeem script
|
|
|
|
# Fund the P2SH output
|
|
tx = CTransaction()
|
|
tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
|
|
tx.vout.append(CTxOut(self.utxo[0].nValue-1000, scriptPubKey))
|
|
tx.rehash()
|
|
|
|
# Verify mempool acceptance and block validity
|
|
test_transaction_acceptance(self.nodes[0].rpc, self.test_node, tx, with_witness=False, accepted=True)
|
|
block = self.build_next_block()
|
|
self.update_witness_block_with_transactions(block, [tx])
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=True, with_witness=segwit_activated)
|
|
sync_blocks(self.nodes)
|
|
|
|
# Now test attempts to spend the output.
|
|
spend_tx = CTransaction()
|
|
spend_tx.vin.append(CTxIn(COutPoint(tx.sha256, 0), scriptSig))
|
|
spend_tx.vout.append(CTxOut(tx.vout[0].nValue-1000, CScript([OP_TRUE])))
|
|
spend_tx.rehash()
|
|
|
|
# This transaction should not be accepted into the mempool pre- or
|
|
# post-segwit. Mempool acceptance will use SCRIPT_VERIFY_WITNESS which
|
|
# will require a witness to spend a witness program regardless of
|
|
# segwit activation. Note that older bitcoind's that are not
|
|
# segwit-aware would also reject this for failing CLEANSTACK.
|
|
test_transaction_acceptance(self.nodes[0].rpc, self.test_node, spend_tx, with_witness=False, accepted=False)
|
|
|
|
# Try to put the witness script in the scriptSig, should also fail.
|
|
spend_tx.vin[0].scriptSig = CScript([p2wsh_pubkey, b'a'])
|
|
spend_tx.rehash()
|
|
test_transaction_acceptance(self.nodes[0].rpc, self.test_node, spend_tx, with_witness=False, accepted=False)
|
|
|
|
# Now put the witness script in the witness, should succeed after
|
|
# segwit activates.
|
|
spend_tx.vin[0].scriptSig = scriptSig
|
|
spend_tx.rehash()
|
|
spend_tx.wit.vtxinwit.append(CTxInWitness())
|
|
spend_tx.wit.vtxinwit[0].scriptWitness.stack = [ b'a', witness_program ]
|
|
|
|
# Verify mempool acceptance
|
|
test_transaction_acceptance(self.nodes[0].rpc, self.test_node, spend_tx, with_witness=True, accepted=segwit_activated)
|
|
block = self.build_next_block()
|
|
self.update_witness_block_with_transactions(block, [spend_tx])
|
|
|
|
# If we're after activation, then sending this with witnesses should be valid.
|
|
# This no longer works before activation, because SCRIPT_VERIFY_WITNESS
|
|
# is always set.
|
|
# TODO: rewrite this test to make clear that it only works after activation.
|
|
if segwit_activated:
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=True)
|
|
else:
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=True, with_witness=False)
|
|
|
|
# Update self.utxo
|
|
self.utxo.pop(0)
|
|
self.utxo.append(UTXO(spend_tx.sha256, 0, spend_tx.vout[0].nValue))
|
|
|
|
# Test the behavior of starting up a segwit-aware node after the softfork
|
|
# has activated. As segwit requires different block data than pre-segwit
|
|
# nodes would have stored, this requires special handling.
|
|
# To enable this test, pass --oldbinary=<path-to-pre-segwit-bitcoind> to
|
|
# the test.
|
|
def test_upgrade_after_activation(self, node_id):
|
|
self.log.info("Testing software upgrade after softfork activation")
|
|
|
|
assert(node_id != 0) # node0 is assumed to be a segwit-active bitcoind
|
|
|
|
# Make sure the nodes are all up
|
|
sync_blocks(self.nodes)
|
|
|
|
# Restart with the new binary
|
|
self.stop_node(node_id)
|
|
self.start_node(node_id, extra_args=["-vbparams=segwit:0:999999999999"])
|
|
connect_nodes(self.nodes[0], node_id)
|
|
|
|
sync_blocks(self.nodes)
|
|
|
|
# Make sure that this peer thinks segwit has activated.
|
|
assert(get_bip9_status(self.nodes[node_id], 'segwit')['status'] == "active")
|
|
|
|
# Make sure this peer's blocks match those of node0.
|
|
height = self.nodes[node_id].getblockcount()
|
|
while height >= 0:
|
|
block_hash = self.nodes[node_id].getblockhash(height)
|
|
assert_equal(block_hash, self.nodes[0].getblockhash(height))
|
|
assert_equal(self.nodes[0].getblock(block_hash), self.nodes[node_id].getblock(block_hash))
|
|
height -= 1
|
|
|
|
|
|
def test_witness_sigops(self):
|
|
'''Ensure sigop counting is correct inside witnesses.'''
|
|
self.log.info("Testing sigops limit")
|
|
|
|
assert(len(self.utxo))
|
|
|
|
# Keep this under MAX_OPS_PER_SCRIPT (201)
|
|
witness_program = CScript([OP_TRUE, OP_IF, OP_TRUE, OP_ELSE] + [OP_CHECKMULTISIG]*5 + [OP_CHECKSIG]*193 + [OP_ENDIF])
|
|
witness_hash = sha256(witness_program)
|
|
scriptPubKey = CScript([OP_0, witness_hash])
|
|
|
|
sigops_per_script = 20*5 + 193*1
|
|
# We'll produce 2 extra outputs, one with a program that would take us
|
|
# over max sig ops, and one with a program that would exactly reach max
|
|
# sig ops
|
|
outputs = (MAX_SIGOP_COST // sigops_per_script) + 2
|
|
extra_sigops_available = MAX_SIGOP_COST % sigops_per_script
|
|
|
|
# We chose the number of checkmultisigs/checksigs to make this work:
|
|
assert(extra_sigops_available < 100) # steer clear of MAX_OPS_PER_SCRIPT
|
|
|
|
# This script, when spent with the first
|
|
# N(=MAX_SIGOP_COST//sigops_per_script) outputs of our transaction,
|
|
# would push us just over the block sigop limit.
|
|
witness_program_toomany = CScript([OP_TRUE, OP_IF, OP_TRUE, OP_ELSE] + [OP_CHECKSIG]*(extra_sigops_available + 1) + [OP_ENDIF])
|
|
witness_hash_toomany = sha256(witness_program_toomany)
|
|
scriptPubKey_toomany = CScript([OP_0, witness_hash_toomany])
|
|
|
|
# If we spend this script instead, we would exactly reach our sigop
|
|
# limit (for witness sigops).
|
|
witness_program_justright = CScript([OP_TRUE, OP_IF, OP_TRUE, OP_ELSE] + [OP_CHECKSIG]*(extra_sigops_available) + [OP_ENDIF])
|
|
witness_hash_justright = sha256(witness_program_justright)
|
|
scriptPubKey_justright = CScript([OP_0, witness_hash_justright])
|
|
|
|
# First split our available utxo into a bunch of outputs
|
|
split_value = self.utxo[0].nValue // outputs
|
|
tx = CTransaction()
|
|
tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
|
|
for i in range(outputs):
|
|
tx.vout.append(CTxOut(split_value, scriptPubKey))
|
|
tx.vout[-2].scriptPubKey = scriptPubKey_toomany
|
|
tx.vout[-1].scriptPubKey = scriptPubKey_justright
|
|
tx.rehash()
|
|
|
|
block_1 = self.build_next_block()
|
|
self.update_witness_block_with_transactions(block_1, [tx])
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block_1, accepted=True)
|
|
|
|
tx2 = CTransaction()
|
|
# If we try to spend the first n-1 outputs from tx, that should be
|
|
# too many sigops.
|
|
total_value = 0
|
|
for i in range(outputs-1):
|
|
tx2.vin.append(CTxIn(COutPoint(tx.sha256, i), b""))
|
|
tx2.wit.vtxinwit.append(CTxInWitness())
|
|
tx2.wit.vtxinwit[-1].scriptWitness.stack = [ witness_program ]
|
|
total_value += tx.vout[i].nValue
|
|
tx2.wit.vtxinwit[-1].scriptWitness.stack = [ witness_program_toomany ]
|
|
tx2.vout.append(CTxOut(total_value, CScript([OP_TRUE])))
|
|
tx2.rehash()
|
|
|
|
block_2 = self.build_next_block()
|
|
self.update_witness_block_with_transactions(block_2, [tx2])
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block_2, accepted=False)
|
|
|
|
# Try dropping the last input in tx2, and add an output that has
|
|
# too many sigops (contributing to legacy sigop count).
|
|
checksig_count = (extra_sigops_available // 4) + 1
|
|
scriptPubKey_checksigs = CScript([OP_CHECKSIG]*checksig_count)
|
|
tx2.vout.append(CTxOut(0, scriptPubKey_checksigs))
|
|
tx2.vin.pop()
|
|
tx2.wit.vtxinwit.pop()
|
|
tx2.vout[0].nValue -= tx.vout[-2].nValue
|
|
tx2.rehash()
|
|
block_3 = self.build_next_block()
|
|
self.update_witness_block_with_transactions(block_3, [tx2])
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block_3, accepted=False)
|
|
|
|
# If we drop the last checksig in this output, the tx should succeed.
|
|
block_4 = self.build_next_block()
|
|
tx2.vout[-1].scriptPubKey = CScript([OP_CHECKSIG]*(checksig_count-1))
|
|
tx2.rehash()
|
|
self.update_witness_block_with_transactions(block_4, [tx2])
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block_4, accepted=True)
|
|
|
|
# Reset the tip back down for the next test
|
|
sync_blocks(self.nodes)
|
|
for x in self.nodes:
|
|
x.invalidateblock(block_4.hash)
|
|
|
|
# Try replacing the last input of tx2 to be spending the last
|
|
# output of tx
|
|
block_5 = self.build_next_block()
|
|
tx2.vout.pop()
|
|
tx2.vin.append(CTxIn(COutPoint(tx.sha256, outputs-1), b""))
|
|
tx2.wit.vtxinwit.append(CTxInWitness())
|
|
tx2.wit.vtxinwit[-1].scriptWitness.stack = [ witness_program_justright ]
|
|
tx2.rehash()
|
|
self.update_witness_block_with_transactions(block_5, [tx2])
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block_5, accepted=True)
|
|
|
|
# TODO: test p2sh sigop counting
|
|
|
|
def test_getblocktemplate_before_lockin(self):
|
|
self.log.info("Testing getblocktemplate setting of segwit versionbit (before lockin)")
|
|
# Node0 is segwit aware, node2 is not.
|
|
for node in [self.nodes[0], self.nodes[2]]:
|
|
gbt_results = node.getblocktemplate()
|
|
block_version = gbt_results['version']
|
|
# If we're not indicating segwit support, we will still be
|
|
# signalling for segwit activation.
|
|
assert_equal((block_version & (1 << VB_WITNESS_BIT) != 0), node == self.nodes[0])
|
|
# If we don't specify the segwit rule, then we won't get a default
|
|
# commitment.
|
|
assert('default_witness_commitment' not in gbt_results)
|
|
|
|
# Workaround:
|
|
# Can either change the tip, or change the mempool and wait 5 seconds
|
|
# to trigger a recomputation of getblocktemplate.
|
|
txid = int(self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), 1), 16)
|
|
# Using mocktime lets us avoid sleep()
|
|
sync_mempools(self.nodes)
|
|
self.nodes[0].setmocktime(int(time.time())+10)
|
|
self.nodes[2].setmocktime(int(time.time())+10)
|
|
|
|
for node in [self.nodes[0], self.nodes[2]]:
|
|
gbt_results = node.getblocktemplate({"rules" : ["segwit"]})
|
|
block_version = gbt_results['version']
|
|
if node == self.nodes[2]:
|
|
# If this is a non-segwit node, we should still not get a witness
|
|
# commitment, nor a version bit signalling segwit.
|
|
assert_equal(block_version & (1 << VB_WITNESS_BIT), 0)
|
|
assert('default_witness_commitment' not in gbt_results)
|
|
else:
|
|
# For segwit-aware nodes, check the version bit and the witness
|
|
# commitment are correct.
|
|
assert(block_version & (1 << VB_WITNESS_BIT) != 0)
|
|
assert('default_witness_commitment' in gbt_results)
|
|
witness_commitment = gbt_results['default_witness_commitment']
|
|
|
|
# Check that default_witness_commitment is present.
|
|
witness_root = CBlock.get_merkle_root([ser_uint256(0),
|
|
ser_uint256(txid)])
|
|
script = get_witness_script(witness_root, 0)
|
|
assert_equal(witness_commitment, bytes_to_hex_str(script))
|
|
|
|
# undo mocktime
|
|
self.nodes[0].setmocktime(0)
|
|
self.nodes[2].setmocktime(0)
|
|
|
|
# Uncompressed pubkeys are no longer supported in default relay policy,
|
|
# but (for now) are still valid in blocks.
|
|
def test_uncompressed_pubkey(self):
|
|
self.log.info("Testing uncompressed pubkeys")
|
|
# Segwit transactions using uncompressed pubkeys are not accepted
|
|
# under default policy, but should still pass consensus.
|
|
key = CECKey()
|
|
key.set_secretbytes(b"9")
|
|
key.set_compressed(False)
|
|
pubkey = CPubKey(key.get_pubkey())
|
|
assert_equal(len(pubkey), 65) # This should be an uncompressed pubkey
|
|
|
|
assert(len(self.utxo) > 0)
|
|
utxo = self.utxo.pop(0)
|
|
|
|
# Test 1: P2WPKH
|
|
# First create a P2WPKH output that uses an uncompressed pubkey
|
|
pubkeyhash = hash160(pubkey)
|
|
scriptPKH = CScript([OP_0, pubkeyhash])
|
|
tx = CTransaction()
|
|
tx.vin.append(CTxIn(COutPoint(utxo.sha256, utxo.n), b""))
|
|
tx.vout.append(CTxOut(utxo.nValue-1000, scriptPKH))
|
|
tx.rehash()
|
|
|
|
# Confirm it in a block.
|
|
block = self.build_next_block()
|
|
self.update_witness_block_with_transactions(block, [tx])
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=True)
|
|
|
|
# Now try to spend it. Send it to a P2WSH output, which we'll
|
|
# use in the next test.
|
|
witness_program = CScript([pubkey, CScriptOp(OP_CHECKSIG)])
|
|
witness_hash = sha256(witness_program)
|
|
scriptWSH = CScript([OP_0, witness_hash])
|
|
|
|
tx2 = CTransaction()
|
|
tx2.vin.append(CTxIn(COutPoint(tx.sha256, 0), b""))
|
|
tx2.vout.append(CTxOut(tx.vout[0].nValue-1000, scriptWSH))
|
|
script = GetP2PKHScript(pubkeyhash)
|
|
sig_hash = SegwitVersion1SignatureHash(script, tx2, 0, SIGHASH_ALL, tx.vout[0].nValue)
|
|
signature = key.sign(sig_hash) + b'\x01' # 0x1 is SIGHASH_ALL
|
|
tx2.wit.vtxinwit.append(CTxInWitness())
|
|
tx2.wit.vtxinwit[0].scriptWitness.stack = [ signature, pubkey ]
|
|
tx2.rehash()
|
|
|
|
# Should fail policy test.
|
|
test_transaction_acceptance(self.nodes[0].rpc, self.test_node, tx2, True, False, b'non-mandatory-script-verify-flag (Using non-compressed keys in segwit)')
|
|
# But passes consensus.
|
|
block = self.build_next_block()
|
|
self.update_witness_block_with_transactions(block, [tx2])
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=True)
|
|
|
|
# Test 2: P2WSH
|
|
# Try to spend the P2WSH output created in last test.
|
|
# Send it to a P2SH(P2WSH) output, which we'll use in the next test.
|
|
p2sh_witness_hash = hash160(scriptWSH)
|
|
scriptP2SH = CScript([OP_HASH160, p2sh_witness_hash, OP_EQUAL])
|
|
scriptSig = CScript([scriptWSH])
|
|
|
|
tx3 = CTransaction()
|
|
tx3.vin.append(CTxIn(COutPoint(tx2.sha256, 0), b""))
|
|
tx3.vout.append(CTxOut(tx2.vout[0].nValue-1000, scriptP2SH))
|
|
tx3.wit.vtxinwit.append(CTxInWitness())
|
|
sign_P2PK_witness_input(witness_program, tx3, 0, SIGHASH_ALL, tx2.vout[0].nValue, key)
|
|
|
|
# Should fail policy test.
|
|
test_transaction_acceptance(self.nodes[0].rpc, self.test_node, tx3, True, False, b'non-mandatory-script-verify-flag (Using non-compressed keys in segwit)')
|
|
# But passes consensus.
|
|
block = self.build_next_block()
|
|
self.update_witness_block_with_transactions(block, [tx3])
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=True)
|
|
|
|
# Test 3: P2SH(P2WSH)
|
|
# Try to spend the P2SH output created in the last test.
|
|
# Send it to a P2PKH output, which we'll use in the next test.
|
|
scriptPubKey = GetP2PKHScript(pubkeyhash)
|
|
tx4 = CTransaction()
|
|
tx4.vin.append(CTxIn(COutPoint(tx3.sha256, 0), scriptSig))
|
|
tx4.vout.append(CTxOut(tx3.vout[0].nValue-1000, scriptPubKey))
|
|
tx4.wit.vtxinwit.append(CTxInWitness())
|
|
sign_P2PK_witness_input(witness_program, tx4, 0, SIGHASH_ALL, tx3.vout[0].nValue, key)
|
|
|
|
# Should fail policy test.
|
|
test_transaction_acceptance(self.nodes[0].rpc, self.test_node, tx4, True, False, b'non-mandatory-script-verify-flag (Using non-compressed keys in segwit)')
|
|
block = self.build_next_block()
|
|
self.update_witness_block_with_transactions(block, [tx4])
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=True)
|
|
|
|
# Test 4: Uncompressed pubkeys should still be valid in non-segwit
|
|
# transactions.
|
|
tx5 = CTransaction()
|
|
tx5.vin.append(CTxIn(COutPoint(tx4.sha256, 0), b""))
|
|
tx5.vout.append(CTxOut(tx4.vout[0].nValue-1000, CScript([OP_TRUE])))
|
|
(sig_hash, err) = SignatureHash(scriptPubKey, tx5, 0, SIGHASH_ALL)
|
|
signature = key.sign(sig_hash) + b'\x01' # 0x1 is SIGHASH_ALL
|
|
tx5.vin[0].scriptSig = CScript([signature, pubkey])
|
|
tx5.rehash()
|
|
# Should pass policy and consensus.
|
|
test_transaction_acceptance(self.nodes[0].rpc, self.test_node, tx5, True, True)
|
|
block = self.build_next_block()
|
|
self.update_witness_block_with_transactions(block, [tx5])
|
|
test_witness_block(self.nodes[0].rpc, self.test_node, block, accepted=True)
|
|
self.utxo.append(UTXO(tx5.sha256, 0, tx5.vout[0].nValue))
|
|
|
|
def test_non_standard_witness(self):
|
|
self.log.info("Testing detection of non-standard P2WSH witness")
|
|
pad = chr(1).encode('latin-1')
|
|
|
|
# Create scripts for tests
|
|
scripts = []
|
|
scripts.append(CScript([OP_DROP] * 100))
|
|
scripts.append(CScript([OP_DROP] * 99))
|
|
scripts.append(CScript([pad * 59] * 59 + [OP_DROP] * 60))
|
|
scripts.append(CScript([pad * 59] * 59 + [OP_DROP] * 61))
|
|
|
|
p2wsh_scripts = []
|
|
|
|
assert(len(self.utxo))
|
|
tx = CTransaction()
|
|
tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
|
|
|
|
# For each script, generate a pair of P2WSH and P2SH-P2WSH output.
|
|
outputvalue = (self.utxo[0].nValue - 1000) // (len(scripts) * 2)
|
|
for i in scripts:
|
|
p2wsh = CScript([OP_0, sha256(i)])
|
|
p2sh = hash160(p2wsh)
|
|
p2wsh_scripts.append(p2wsh)
|
|
tx.vout.append(CTxOut(outputvalue, p2wsh))
|
|
tx.vout.append(CTxOut(outputvalue, CScript([OP_HASH160, p2sh, OP_EQUAL])))
|
|
tx.rehash()
|
|
txid = tx.sha256
|
|
test_transaction_acceptance(self.nodes[0].rpc, self.test_node, tx, with_witness=False, accepted=True)
|
|
|
|
self.nodes[0].generate(1)
|
|
sync_blocks(self.nodes)
|
|
|
|
# Creating transactions for tests
|
|
p2wsh_txs = []
|
|
p2sh_txs = []
|
|
for i in range(len(scripts)):
|
|
p2wsh_tx = CTransaction()
|
|
p2wsh_tx.vin.append(CTxIn(COutPoint(txid,i*2)))
|
|
p2wsh_tx.vout.append(CTxOut(outputvalue - 5000, CScript([OP_0, hash160(hex_str_to_bytes(""))])))
|
|
p2wsh_tx.wit.vtxinwit.append(CTxInWitness())
|
|
p2wsh_tx.rehash()
|
|
p2wsh_txs.append(p2wsh_tx)
|
|
p2sh_tx = CTransaction()
|
|
p2sh_tx.vin.append(CTxIn(COutPoint(txid,i*2+1), CScript([p2wsh_scripts[i]])))
|
|
p2sh_tx.vout.append(CTxOut(outputvalue - 5000, CScript([OP_0, hash160(hex_str_to_bytes(""))])))
|
|
p2sh_tx.wit.vtxinwit.append(CTxInWitness())
|
|
p2sh_tx.rehash()
|
|
p2sh_txs.append(p2sh_tx)
|
|
|
|
# Testing native P2WSH
|
|
# Witness stack size, excluding witnessScript, over 100 is non-standard
|
|
p2wsh_txs[0].wit.vtxinwit[0].scriptWitness.stack = [pad] * 101 + [scripts[0]]
|
|
test_transaction_acceptance(self.nodes[1].rpc, self.std_node, p2wsh_txs[0], True, False, b'bad-witness-nonstandard')
|
|
# Non-standard nodes should accept
|
|
test_transaction_acceptance(self.nodes[0].rpc, self.test_node, p2wsh_txs[0], True, True)
|
|
|
|
# Stack element size over 80 bytes is non-standard
|
|
p2wsh_txs[1].wit.vtxinwit[0].scriptWitness.stack = [pad * 81] * 100 + [scripts[1]]
|
|
test_transaction_acceptance(self.nodes[1].rpc, self.std_node, p2wsh_txs[1], True, False, b'bad-witness-nonstandard')
|
|
# Non-standard nodes should accept
|
|
test_transaction_acceptance(self.nodes[0].rpc, self.test_node, p2wsh_txs[1], True, True)
|
|
# Standard nodes should accept if element size is not over 80 bytes
|
|
p2wsh_txs[1].wit.vtxinwit[0].scriptWitness.stack = [pad * 80] * 100 + [scripts[1]]
|
|
test_transaction_acceptance(self.nodes[1].rpc, self.std_node, p2wsh_txs[1], True, True)
|
|
|
|
# witnessScript size at 3600 bytes is standard
|
|
p2wsh_txs[2].wit.vtxinwit[0].scriptWitness.stack = [pad, pad, scripts[2]]
|
|
test_transaction_acceptance(self.nodes[0].rpc, self.test_node, p2wsh_txs[2], True, True)
|
|
test_transaction_acceptance(self.nodes[1].rpc, self.std_node, p2wsh_txs[2], True, True)
|
|
|
|
# witnessScript size at 3601 bytes is non-standard
|
|
p2wsh_txs[3].wit.vtxinwit[0].scriptWitness.stack = [pad, pad, pad, scripts[3]]
|
|
test_transaction_acceptance(self.nodes[1].rpc, self.std_node, p2wsh_txs[3], True, False, b'bad-witness-nonstandard')
|
|
# Non-standard nodes should accept
|
|
test_transaction_acceptance(self.nodes[0].rpc, self.test_node, p2wsh_txs[3], True, True)
|
|
|
|
# Repeating the same tests with P2SH-P2WSH
|
|
p2sh_txs[0].wit.vtxinwit[0].scriptWitness.stack = [pad] * 101 + [scripts[0]]
|
|
test_transaction_acceptance(self.nodes[1].rpc, self.std_node, p2sh_txs[0], True, False, b'bad-witness-nonstandard')
|
|
test_transaction_acceptance(self.nodes[0].rpc, self.test_node, p2sh_txs[0], True, True)
|
|
p2sh_txs[1].wit.vtxinwit[0].scriptWitness.stack = [pad * 81] * 100 + [scripts[1]]
|
|
test_transaction_acceptance(self.nodes[1].rpc, self.std_node, p2sh_txs[1], True, False, b'bad-witness-nonstandard')
|
|
test_transaction_acceptance(self.nodes[0].rpc, self.test_node, p2sh_txs[1], True, True)
|
|
p2sh_txs[1].wit.vtxinwit[0].scriptWitness.stack = [pad * 80] * 100 + [scripts[1]]
|
|
test_transaction_acceptance(self.nodes[1].rpc, self.std_node, p2sh_txs[1], True, True)
|
|
p2sh_txs[2].wit.vtxinwit[0].scriptWitness.stack = [pad, pad, scripts[2]]
|
|
test_transaction_acceptance(self.nodes[0].rpc, self.test_node, p2sh_txs[2], True, True)
|
|
test_transaction_acceptance(self.nodes[1].rpc, self.std_node, p2sh_txs[2], True, True)
|
|
p2sh_txs[3].wit.vtxinwit[0].scriptWitness.stack = [pad, pad, pad, scripts[3]]
|
|
test_transaction_acceptance(self.nodes[1].rpc, self.std_node, p2sh_txs[3], True, False, b'bad-witness-nonstandard')
|
|
test_transaction_acceptance(self.nodes[0].rpc, self.test_node, p2sh_txs[3], True, True)
|
|
|
|
self.nodes[0].generate(1) # Mine and clean up the mempool of non-standard node
|
|
# Valid but non-standard transactions in a block should be accepted by standard node
|
|
sync_blocks(self.nodes)
|
|
assert_equal(len(self.nodes[0].getrawmempool()), 0)
|
|
assert_equal(len(self.nodes[1].getrawmempool()), 0)
|
|
|
|
self.utxo.pop(0)
|
|
|
|
|
|
def run_test(self):
|
|
# Setup the p2p connections and start up the network thread.
|
|
# self.test_node sets NODE_WITNESS|NODE_NETWORK
|
|
self.test_node = self.nodes[0].add_p2p_connection(TestP2PConn(), services=NODE_NETWORK|NODE_WITNESS)
|
|
# self.old_node sets only NODE_NETWORK
|
|
self.old_node = self.nodes[0].add_p2p_connection(TestP2PConn(), services=NODE_NETWORK)
|
|
# self.std_node is for testing node1 (fRequireStandard=true)
|
|
self.std_node = self.nodes[1].add_p2p_connection(TestP2PConn(), services=NODE_NETWORK|NODE_WITNESS)
|
|
|
|
network_thread_start()
|
|
|
|
# Keep a place to store utxo's that can be used in later tests
|
|
self.utxo = []
|
|
|
|
# Test logic begins here
|
|
self.test_node.wait_for_verack()
|
|
|
|
self.log.info("Starting tests before segwit lock in:")
|
|
|
|
self.test_witness_services() # Verifies NODE_WITNESS
|
|
self.test_non_witness_transaction() # non-witness tx's are accepted
|
|
self.test_unnecessary_witness_before_segwit_activation()
|
|
self.test_v0_outputs_arent_spendable()
|
|
self.test_block_relay(segwit_activated=False)
|
|
|
|
# Advance to segwit being 'started'
|
|
self.advance_to_segwit_started()
|
|
sync_blocks(self.nodes)
|
|
self.test_getblocktemplate_before_lockin()
|
|
|
|
sync_blocks(self.nodes)
|
|
|
|
# At lockin, nothing should change.
|
|
self.log.info("Testing behavior post lockin, pre-activation")
|
|
self.advance_to_segwit_lockin()
|
|
|
|
# Retest unnecessary witnesses
|
|
self.test_unnecessary_witness_before_segwit_activation()
|
|
self.test_witness_tx_relay_before_segwit_activation()
|
|
self.test_block_relay(segwit_activated=False)
|
|
self.test_standardness_v0(segwit_activated=False)
|
|
|
|
sync_blocks(self.nodes)
|
|
|
|
# Now activate segwit
|
|
self.log.info("Testing behavior after segwit activation")
|
|
self.advance_to_segwit_active()
|
|
|
|
sync_blocks(self.nodes)
|
|
|
|
# Test P2SH witness handling again
|
|
self.test_p2sh_witness(segwit_activated=True)
|
|
self.test_witness_commitments()
|
|
self.test_block_malleability()
|
|
self.test_witness_block_size()
|
|
self.test_submit_block()
|
|
self.test_extra_witness_data()
|
|
self.test_max_witness_push_length()
|
|
self.test_max_witness_program_length()
|
|
self.test_witness_input_length()
|
|
self.test_block_relay(segwit_activated=True)
|
|
self.test_tx_relay_after_segwit_activation()
|
|
self.test_standardness_v0(segwit_activated=True)
|
|
self.test_segwit_versions()
|
|
self.test_premature_coinbase_witness_spend()
|
|
self.test_uncompressed_pubkey()
|
|
self.test_signature_version_1()
|
|
self.test_non_standard_witness()
|
|
sync_blocks(self.nodes)
|
|
self.test_upgrade_after_activation(node_id=2)
|
|
self.test_witness_sigops()
|
|
|
|
|
|
if __name__ == '__main__':
|
|
SegWitTest().main()
|