Inside Bitcoin

251        self.std_wtx_node = self.nodes[1].add_p2p_connection(TestP2PConn(wtxidrelay=True), services=P2P_SERVICES)
252
253        assert_not_equal(self.test_node.nServices & NODE_WITNESS, 0)
254
255        # Keep a place to store utxo's that can be used in later tests
256        self.utxo = []
257
258        self.log.info("Starting tests before segwit activation")
259        self.segwit_active = False
260        self.wallet = MiniWallet(self.nodes[0])
261
262        self.test_non_witness_transaction()
263        self.test_v0_outputs_arent_spendable()
264        self.test_block_relay()
265        self.test_unnecessary_witness_before_segwit_activation()
266        self.test_witness_tx_relay_before_segwit_activation()
267        self.test_standardness_v0()
268
269        self.log.info("Advancing to segwit activation")
270        self.advance_to_segwit_active()
271
272        # Segwit status 'active'
273
274        self.test_p2sh_witness()
275        self.test_witness_commitments()
276        self.test_block_malleability()
277        self.test_witness_block_size()
278        self.test_submit_block()
279        self.test_extra_witness_data()
280        self.test_max_witness_push_length()
281        self.test_max_witness_script_length()
282        self.test_witness_input_length()
283        self.test_block_relay()
284        self.test_tx_relay_after_segwit_activation()
285        self.test_standardness_v0()
286        self.test_segwit_versions()
287        self.test_premature_coinbase_witness_spend()
288        self.test_uncompressed_pubkey()
289        self.test_signature_version_1()
290        self.test_non_standard_witness_blinding()
291        self.test_non_standard_witness()
292        self.test_witness_sigops()
293        self.test_superfluous_witness()
294        self.test_wtxid_relay()
295
296    # Individual tests
297
298    @subtest
299    def test_non_witness_transaction(self):
300        """See if sending a regular transaction works, and create a utxo to use in later tests."""
301        # Mine a block with an anyone-can-spend coinbase,
302        # let it mature, then try to spend it.
303
304        block = self.build_next_block()
305        block.solve()
306        self.test_node.send_and_ping(msg_no_witness_block(block))  # make sure the block was processed
307        txid = block.vtx[0].txid_int
308
309        self.generate(self.wallet, 99)  # let the block mature
310
311        # Create a transaction that spends the coinbase
312        tx = CTransaction()
313        tx.vin.append(CTxIn(COutPoint(txid, 0), b""))
314        tx.vout.append(CTxOut(49 * 100000000, CScript([OP_TRUE, OP_DROP] * 15 + [OP_TRUE])))
315
316        # Check that serializing it with or without witness is the same
317        # This is a sanity check of our testing framework.
318        assert_equal(msg_no_witness_tx(tx).serialize(), msg_tx(tx).serialize())
319
320        self.test_node.send_and_ping(msg_tx(tx))  # make sure the block was processed
321        assert tx.txid_hex in self.nodes[0].getrawmempool()
322        # Save this transaction for later
323        self.utxo.append(UTXO(tx.txid_int, 0, 49 * 100000000))
324        self.generate(self.nodes[0], 1)
325
326    @subtest
327    def test_unnecessary_witness_before_segwit_activation(self):
328        """Verify that blocks with witnesses are rejected before activation."""
329
330        tx = CTransaction()
331        tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
332        tx.vout.append(CTxOut(self.utxo[0].nValue - 1000, CScript([OP_TRUE])))
333        tx.wit.vtxinwit.append(CTxInWitness())
334        tx.wit.vtxinwit[0].scriptWitness.stack = [CScript([CScriptNum(1)])]
335
336        # Verify the hash with witness differs from the txid
337        # (otherwise our testing framework must be broken!)
338        assert_not_equal(tx.txid_hex, tx.wtxid_hex)
339
340        # Construct a block that includes the transaction.
341        block = self.build_next_block()
342        self.update_witness_block_with_transactions(block, [tx])
343        # Sending witness data before activation is not allowed (anti-spam
344        # rule).
345        test_witness_block(self.nodes[0], self.test_node, block, accepted=False, reason='unexpected-witness')
346
347        # But it should not be permanently marked bad...
348        # Resend without witness information.
349        self.test_node.send_and_ping(msg_no_witness_block(block))  # make sure the block was processed
350        assert_equal(self.nodes[0].getbestblockhash(), block.hash_hex)
351
352        # Update our utxo list; we spent the first entry.
353        self.utxo.pop(0)
354        self.utxo.append(UTXO(tx.txid_int, 0, tx.vout[0].nValue))
355
356    @subtest
357    def test_block_relay(self):
358        """Test that block requests to NODE_WITNESS peer are with MSG_WITNESS_FLAG.
359
360        This is true regardless of segwit activation.
361        Also test that we don't ask for blocks from unupgraded peers."""
362
363        blocktype = 2 | MSG_WITNESS_FLAG
364
365        # test_node has set NODE_WITNESS, so all getdata requests should be for
366        # witness blocks.
367        # Test announcing a block via inv results in a getdata, and that
368        # announcing a block with a header results in a getdata
369        block1 = self.build_next_block()
370        block1.solve()
371
372        # Send an empty headers message, to clear out any prior getheaders
373        # messages that our peer may be waiting for us on.
374        self.test_node.send_without_ping(msg_headers())
375
376        self.test_node.announce_block_and_wait_for_getdata(block1, use_header=False)
377        assert_equal(self.test_node.last_message["getdata"].inv[0].type, blocktype)
378        test_witness_block(self.nodes[0], self.test_node, block1, True)
379
380        block2 = self.build_next_block()
381        block2.solve()
382
383        self.test_node.announce_block_and_wait_for_getdata(block2, use_header=True)
384        assert_equal(self.test_node.last_message["getdata"].inv[0].type, blocktype)
385        test_witness_block(self.nodes[0], self.test_node, block2, True)
386
387        # Check that we can getdata for witness blocks or regular blocks,
388        # and the right thing happens.
389        if not self.segwit_active:
390            # Before activation, we should be able to request old blocks with
391            # or without witness, and they should be the same.
392            chain_height = self.nodes[0].getblockcount()
393            # Pick 10 random blocks on main chain, and verify that getdata's
394            # for MSG_BLOCK, MSG_WITNESS_BLOCK, and rpc getblock() are equal.
395            all_heights = list(range(chain_height + 1))
396            random.shuffle(all_heights)
397            all_heights = all_heights[0:10]
398            for height in all_heights:
399                block_hash = self.nodes[0].getblockhash(height)
400                rpc_block = self.nodes[0].getblock(block_hash, False)
401                block_hash = int(block_hash, 16)
402                block = self.test_node.request_block(block_hash, 2)
403                wit_block = self.test_node.request_block(block_hash, 2 | MSG_WITNESS_FLAG)
404                assert_equal(block.serialize(), wit_block.serialize())
405                assert_equal(block.serialize(), bytes.fromhex(rpc_block))
406        else:
407            # After activation, witness blocks and non-witness blocks should
408            # be different.  Verify rpc getblock() returns witness blocks, while
409            # getdata respects the requested type.
410            block = self.build_next_block()
411            self.update_witness_block_with_transactions(block, [])
412            # This gives us a witness commitment.
413            assert_equal(len(block.vtx[0].wit.vtxinwit), 1)
414            assert_equal(len(block.vtx[0].wit.vtxinwit[0].scriptWitness.stack), 1)
415            test_witness_block(self.nodes[0], self.test_node, block, accepted=True)
416            # Now try to retrieve it...
417            rpc_block = self.nodes[0].getblock(block.hash_hex, False)
418            non_wit_block = self.test_node.request_block(block.hash_int, 2)
419            wit_block = self.test_node.request_block(block.hash_int, 2 | MSG_WITNESS_FLAG)
420            assert_equal(wit_block.serialize(), bytes.fromhex(rpc_block))
421            assert_equal(wit_block.serialize(False), non_wit_block.serialize())
422            assert_equal(wit_block.serialize(), block.serialize())
423
424            # Test size, vsize, weight
425            rpc_details = self.nodes[0].getblock(block.hash_hex, True)
426            assert_equal(rpc_details["size"], len(block.serialize()))
427            assert_equal(rpc_details["strippedsize"], len(block.serialize(False)))
428            assert_equal(rpc_details["weight"], block.get_weight())
429
430            # Upgraded node should not ask for blocks from unupgraded
431            block4 = self.build_next_block()
432            block4.solve()
433            self.old_node.getdataset = set()
434
435            # Blocks can be requested via direct-fetch (immediately upon processing the announcement)
436            # or via parallel download (with an indeterminate delay from processing the announcement)
437            # so to test that a block is NOT requested, we could guess a time period to sleep for,
438            # and then check. We can avoid the sleep() by taking advantage of transaction getdata's
439            # being processed after block getdata's, and announce a transaction as well,
440            # and then check to see if that particular getdata has been received.
441            # Since 0.14, inv's will only be responded to with a getheaders, so send a header
442            # to announce this block.
443            msg = msg_headers()
444            msg.headers = [CBlockHeader(block4)]
445            self.old_node.send_without_ping(msg)
446            self.old_node.announce_tx_and_wait_for_getdata(block4.vtx[0])
447            assert block4.hash_int not in self.old_node.getdataset
448
449    @subtest
450    def test_v0_outputs_arent_spendable(self):
451        """Test that v0 outputs aren't spendable before segwit activation.
452
453        ~6 months after segwit activation, the SCRIPT_VERIFY_WITNESS flag was
454        backdated so that it applies to all blocks, going back to the genesis
455        block.
456
457        Consequently, version 0 witness outputs are never spendable without
458        witness, and so can't be spent before segwit activation (the point at which
459        blocks are permitted to contain witnesses)."""
460
461        # Create two outputs, a p2wsh and p2sh-p2wsh
462        witness_script = CScript([OP_TRUE])
463        script_pubkey = script_to_p2wsh_script(witness_script)
464        p2sh_script_pubkey = script_to_p2sh_script(script_pubkey)
465
466        value = self.utxo[0].nValue // 3
467
468        tx = CTransaction()
469        tx.vin = [CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b'')]
470        tx.vout = [CTxOut(value, script_pubkey), CTxOut(value, p2sh_script_pubkey)]
471        tx.vout.append(CTxOut(value, CScript([OP_TRUE])))
472        txid = tx.txid_int
473
474        # Add it to a block
475        block = self.build_next_block()
476        self.update_witness_block_with_transactions(block, [tx])
477        # Verify that segwit isn't activated. A block serialized with witness
478        # should be rejected prior to activation.
479        test_witness_block(self.nodes[0], self.test_node, block, accepted=False, with_witness=True, reason='unexpected-witness')
480        # Now send the block without witness. It should be accepted
481        test_witness_block(self.nodes[0], self.test_node, block, accepted=True, with_witness=False)
482
483        # Now try to spend the outputs. This should fail since SCRIPT_VERIFY_WITNESS is always enabled.
484        p2wsh_tx = CTransaction()
485        p2wsh_tx.vin = [CTxIn(COutPoint(txid, 0), b'')]
486        p2wsh_tx.vout = [CTxOut(value, CScript([OP_TRUE]))]
487        p2wsh_tx.wit.vtxinwit.append(CTxInWitness())
488        p2wsh_tx.wit.vtxinwit[0].scriptWitness.stack = [CScript([OP_TRUE])]
489
490        p2sh_p2wsh_tx = CTransaction()
491        p2sh_p2wsh_tx.vin = [CTxIn(COutPoint(txid, 1), CScript([script_pubkey]))]
492        p2sh_p2wsh_tx.vout = [CTxOut(value, CScript([OP_TRUE]))]
493        p2sh_p2wsh_tx.wit.vtxinwit.append(CTxInWitness())
494        p2sh_p2wsh_tx.wit.vtxinwit[0].scriptWitness.stack = [CScript([OP_TRUE])]
495
496        for tx in [p2wsh_tx, p2sh_p2wsh_tx]:
497
498            block = self.build_next_block()
499            self.update_witness_block_with_transactions(block, [tx])
500