Inside Bitcoin

1#!/usr/bin/env python3
2# Copyright (c) 2016-present The Bitcoin Core developers
3# Distributed under the MIT software license, see the accompanying
4# file COPYING or http://www.opensource.org/licenses/mit-license.php.
5"""Test segwit transactions and blocks on P2P network."""
6from decimal import Decimal
7import random
8
9from test_framework.blocktools import (
10    WITNESS_COMMITMENT_HEADER,
11    add_witness_commitment,
12    create_block,
13)
14from test_framework.messages import (
15    MAX_BIP125_RBF_SEQUENCE,
16    CBlockHeader,
17    CInv,
18    COutPoint,
19    CTransaction,
20    CTxIn,
21    CTxInWitness,
22    CTxOut,
23    CTxWitness,
24    MAX_BLOCK_WEIGHT,
25    MSG_BLOCK,
26    MSG_TX,
27    MSG_WITNESS_FLAG,
28    MSG_WITNESS_TX,
29    MSG_WTX,
30    NODE_NETWORK,
31    NODE_WITNESS,
32    WITNESS_SCALE_FACTOR,
33    msg_no_witness_block,
34    msg_getdata,
35    msg_headers,
36    msg_inv,
37    msg_tx,
38    msg_block,
39    msg_no_witness_tx,
40    ser_uint256,
41    ser_vector,
42    sha256,
43)
44from test_framework.p2p import (
45    P2PInterface,
46    p2p_lock,
47    P2P_SERVICES,
48)
49from test_framework.script import (
50    CScript,
51    CScriptNum,
52    CScriptOp,
53    MAX_SCRIPT_ELEMENT_SIZE,
54    OP_0,
55    OP_1,
56    OP_2,
57    OP_16,
58    OP_2DROP,
59    OP_CHECKMULTISIG,
60    OP_CHECKSIG,
61    OP_DROP,
62    OP_ELSE,
63    OP_ENDIF,
64    OP_IF,
65    OP_RETURN,
66    OP_TRUE,
67    SIGHASH_ALL,
68    SIGHASH_ANYONECANPAY,
69    SIGHASH_NONE,
70    SIGHASH_SINGLE,
71    hash160,
72    sign_input_legacy,
73    sign_input_segwitv0,
74)
75from test_framework.script_util import (
76    key_to_p2pk_script,
77    key_to_p2wpkh_script,
78    keyhash_to_p2pkh_script,
79    script_to_p2sh_script,
80    script_to_p2wsh_script,
81)
82from test_framework.test_framework import BitcoinTestFramework
83from test_framework.util import (
84    assert_not_equal,
85    assert_greater_than_or_equal,
86    assert_equal,
87    assert_raises_rpc_error,
88    ensure_for,
89    softfork_active,
90)
91from test_framework.wallet import MiniWallet
92from test_framework.wallet_util import generate_keypair
93
94
95MAX_SIGOP_COST = 80000
96
97SEGWIT_HEIGHT = 120
98
99class UTXO():
100    """Used to keep track of anyone-can-spend outputs that we can use in the tests."""
101    def __init__(self, sha256, n, value):
102        self.sha256 = sha256
103        self.n = n
104        self.nValue = value
105
106
107def subtest(func):
108    """Wraps the subtests for logging and state assertions."""
109    def func_wrapper(self, *args, **kwargs):
110        self.log.info("Subtest: {} (Segwit active = {})".format(func.__name__, self.segwit_active))
111        # Assert segwit status is as expected
112        assert_equal(softfork_active(self.nodes[0], 'segwit'), self.segwit_active)
113        func(self, *args, **kwargs)
114        # Each subtest should leave some utxos for the next subtest
115        assert self.utxo
116        self.sync_blocks()
117        # Assert segwit status is as expected at end of subtest
118        assert_equal(softfork_active(self.nodes[0], 'segwit'), self.segwit_active)
119
120    return func_wrapper
121
122
123def sign_p2pk_witness_input(script, tx_to, in_idx, hashtype, value, key):
124    """Add signature for a P2PK witness script."""
125    tx_to.wit.vtxinwit[in_idx].scriptWitness.stack = [script]
126    sign_input_segwitv0(tx_to, in_idx, script, value, key, hashtype)
127
128def test_transaction_acceptance(node, p2p, tx, with_witness, accepted, reason=None):
129    """Send a transaction to the node and check that it's accepted to the mempool
130
131    - Submit the transaction over the p2p interface
132    - use the getrawmempool rpc to check for acceptance."""
133    reason = [reason] if reason else []
134    with node.assert_debug_log(expected_msgs=reason):
135        p2p.send_and_ping(msg_tx(tx) if with_witness else msg_no_witness_tx(tx))
136        assert_equal(tx.txid_hex in node.getrawmempool(), accepted)
137
138
139def test_witness_block(node, p2p, block, accepted, with_witness=True, reason=None):
140    """Send a block to the node and check that it's accepted
141
142    - Submit the block over the p2p interface
143    - use the getbestblockhash rpc to check for acceptance."""
144    reason = [reason] if reason else []
145    with node.assert_debug_log(expected_msgs=reason):
146        p2p.send_and_ping(msg_block(block) if with_witness else msg_no_witness_block(block))
147        assert_equal(node.getbestblockhash() == block.hash_hex, accepted)
148
149
150class TestP2PConn(P2PInterface):
151    def __init__(self, wtxidrelay=False):
152        super().__init__(wtxidrelay=wtxidrelay)
153        self.getdataset = set()
154        self.last_wtxidrelay = []
155        self.lastgetdata = []
156        self.wtxidrelay = wtxidrelay
157
158    # Don't send getdata message replies to invs automatically.
159    # We'll send the getdata messages explicitly in the test logic.
160    def on_inv(self, message):
161        pass
162
163    def on_getdata(self, message):
164        self.lastgetdata = message.inv
165        for inv in message.inv:
166            self.getdataset.add(inv.hash)
167
168    def on_wtxidrelay(self, message):
169        self.last_wtxidrelay.append(message)
170
171    def announce_tx_and_wait_for_getdata(self, tx, success=True, use_wtxid=False):
172        if success:
173            # sanity check
174            assert (self.wtxidrelay and use_wtxid) or (not self.wtxidrelay and not use_wtxid)
175        with p2p_lock:
176            self.last_message.pop("getdata", None)
177        if use_wtxid:
178            wtxid = tx.wtxid_int
179            self.send_without_ping(msg_inv(inv=[CInv(MSG_WTX, wtxid)]))
180        else:
181            self.send_without_ping(msg_inv(inv=[CInv(MSG_TX, tx.txid_int)]))
182
183        if success:
184            if use_wtxid:
185                self.wait_for_getdata([wtxid])
186            else:
187                self.wait_for_getdata([tx.txid_int])
188        else:
189            ensure_for(duration=5, f=lambda: not self.last_message.get("getdata"))
190
191    def announce_block_and_wait_for_getdata(self, block, use_header, timeout=60):
192        with p2p_lock:
193            self.last_message.pop("getdata", None)
194        msg = msg_headers()
195        msg.headers = [CBlockHeader(block)]
196        if use_header:
197            self.send_without_ping(msg)
198        else:
199            self.send_without_ping(msg_inv(inv=[CInv(MSG_BLOCK, block.hash_int)]))
200            self.wait_for_getheaders(block_hash=block.hashPrevBlock, timeout=timeout)
201            self.send_without_ping(msg)
202        self.wait_for_getdata([block.hash_int], timeout=timeout)
203
204    def request_block(self, blockhash, inv_type, timeout=60):
205        with p2p_lock:
206            self.last_message.pop("block", None)
207        self.send_without_ping(msg_getdata(inv=[CInv(inv_type, blockhash)]))
208        self.wait_for_block(blockhash, timeout=timeout)
209        return self.last_message["block"].block
210
211class SegWitTest(BitcoinTestFramework):
212    def set_test_params(self):
213        self.setup_clean_chain = True
214        self.num_nodes = 2
215        # whitelist peers to speed up tx relay / mempool sync
216        self.noban_tx_relay = True
217        # This test tests SegWit both pre and post-activation, so use the normal BIP9 activation.
218        self.extra_args = [
219            # -par=1 should not affect validation outcome or logging/reported failures. It is kept
220            # here to exercise the code path still (as it is distinct for multithread script
221            # validation).
222            ["-acceptnonstdtxn=1", f"-testactivationheight=segwit@{SEGWIT_HEIGHT}", "-par=1"],
223            ["-acceptnonstdtxn=0", f"-testactivationheight=segwit@{SEGWIT_HEIGHT}"],
224        ]
225
226    # Helper functions
227
228    def build_next_block(self):
229        """Build a block on top of node0's tip."""
230        tip = self.nodes[0].getbestblockhash()
231        height = self.nodes[0].getblockcount() + 1
232        block_time = self.nodes[0].getblockheader(tip)["mediantime"] + 1
233        block = create_block(int(tip, 16), height=height, ntime=block_time)
234        return block
235
236    def update_witness_block_with_transactions(self, block, tx_list, nonce=0):
237        """Add list of transactions to block, adds witness commitment, then solves."""
238        block.vtx.extend(tx_list)
239        add_witness_commitment(block, nonce)
240        block.solve()
241
242    def run_test(self):
243        # Setup the p2p connections
244        # self.test_node sets P2P_SERVICES, i.e. NODE_WITNESS | NODE_NETWORK
245        self.test_node = self.nodes[0].add_p2p_connection(TestP2PConn(), services=P2P_SERVICES)
246        # self.old_node sets only NODE_NETWORK
247        self.old_node = self.nodes[0].add_p2p_connection(TestP2PConn(), services=NODE_NETWORK)
248        # self.std_node is for testing node1 (requires standard txs)
249        self.std_node = self.nodes[1].add_p2p_connection(TestP2PConn(), services=P2P_SERVICES)
250        # self.std_wtx_node is for testing node1 with wtxid relay