Inside Bitcoin

501            # When the block is serialized with a witness, the block will be rejected because witness
502            # data isn't allowed in blocks that don't commit to witness data.
503            test_witness_block(self.nodes[0], self.test_node, block, accepted=False, with_witness=True, reason='unexpected-witness')
504
505            # When the block is serialized without witness, validation fails because the transaction is
506            # invalid (transactions are always validated with SCRIPT_VERIFY_WITNESS so a segwit v0 transaction
507            # without a witness is invalid).
508            test_witness_block(self.nodes[0], self.test_node, block, accepted=False, with_witness=False,
509                               reason='block-script-verify-flag-failed (Witness program was passed an empty witness)')
510
511        self.utxo.pop(0)
512        self.utxo.append(UTXO(txid, 2, value))
513
514    @subtest
515    def test_witness_tx_relay_before_segwit_activation(self):
516
517        # Generate a transaction that doesn't require a witness, but send it
518        # with a witness.  Should be rejected for premature-witness, but should
519        # not be added to recently rejected list.
520        tx = CTransaction()
521        tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
522        tx.vout.append(CTxOut(self.utxo[0].nValue - 1000, CScript([OP_TRUE, OP_DROP] * 15 + [OP_TRUE])))
523        tx.wit.vtxinwit.append(CTxInWitness())
524        tx.wit.vtxinwit[0].scriptWitness.stack = [b'a']
525
526        tx_hash = tx.txid_int
527        tx_value = tx.vout[0].nValue
528
529        # Verify that if a peer doesn't set nServices to include NODE_WITNESS,
530        # the getdata is just for the non-witness portion.
531        self.old_node.announce_tx_and_wait_for_getdata(tx)
532        assert_equal(self.old_node.last_message["getdata"].inv[0].type, MSG_TX)
533
534        # Since we haven't delivered the tx yet, inv'ing the same tx from
535        # a witness transaction ought not result in a getdata.
536        self.test_node.announce_tx_and_wait_for_getdata(tx, success=False)
537
538        # Delivering this transaction with witness should fail (no matter who
539        # its from)
540        assert_equal(len(self.nodes[0].getrawmempool()), 0)
541        assert_equal(len(self.nodes[1].getrawmempool()), 0)
542        test_transaction_acceptance(self.nodes[0], self.old_node, tx, with_witness=True, accepted=False)
543        test_transaction_acceptance(self.nodes[0], self.test_node, tx, with_witness=True, accepted=False)
544
545        # But eliminating the witness should fix it
546        test_transaction_acceptance(self.nodes[0], self.test_node, tx, with_witness=False, accepted=True)
547
548        # Cleanup: mine the first transaction and update utxo
549        self.generate(self.nodes[0], 1)
550        assert_equal(len(self.nodes[0].getrawmempool()), 0)
551
552        self.utxo.pop(0)
553        self.utxo.append(UTXO(tx_hash, 0, tx_value))
554
555    @subtest
556    def test_standardness_v0(self):
557        """Test V0 txout standardness.
558
559        V0 segwit outputs and inputs are always standard.
560        V0 segwit inputs may only be mined after activation, but not before."""
561
562        witness_script = CScript([OP_TRUE])
563        script_pubkey = script_to_p2wsh_script(witness_script)
564        p2sh_script_pubkey = script_to_p2sh_script(witness_script)
565
566        # First prepare a p2sh output (so that spending it will pass standardness)
567        p2sh_tx = CTransaction()
568        p2sh_tx.vin = [CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b"")]
569        p2sh_tx.vout = [CTxOut(self.utxo[0].nValue - 1000, p2sh_script_pubkey)]
570
571        # Mine it on test_node to create the confirmed output.
572        test_transaction_acceptance(self.nodes[0], self.test_node, p2sh_tx, with_witness=True, accepted=True)
573        self.generate(self.nodes[0], 1)
574
575        # Now test standardness of v0 P2WSH outputs.
576        # Start by creating a transaction with two outputs.
577        tx = CTransaction()
578        tx.vin = [CTxIn(COutPoint(p2sh_tx.txid_int, 0), CScript([witness_script]))]
579        tx.vout = [CTxOut(p2sh_tx.vout[0].nValue - 10000, script_pubkey)]
580        tx.vout.append(CTxOut(8000, script_pubkey))  # Might burn this later
581        tx.vin[0].nSequence = MAX_BIP125_RBF_SEQUENCE  # Just to have the option to bump this tx from the mempool
582
583        # This is always accepted, since the mempool policy is to consider segwit as always active
584        # and thus allow segwit outputs
585        test_transaction_acceptance(self.nodes[1], self.std_node, tx, with_witness=True, accepted=True)
586
587        # Now create something that looks like a P2PKH output. This won't be spendable.
588        witness_hash = sha256(witness_script)
589        script_pubkey = CScript([OP_0, hash160(witness_hash)])
590        tx2 = CTransaction()
591        # tx was accepted, so we spend the second output.
592        tx2.vin = [CTxIn(COutPoint(tx.txid_int, 1), b"")]
593        tx2.vout = [CTxOut(7000, script_pubkey)]
594        tx2.wit.vtxinwit.append(CTxInWitness())
595        tx2.wit.vtxinwit[0].scriptWitness.stack = [witness_script]
596
597        test_transaction_acceptance(self.nodes[1], self.std_node, tx2, with_witness=True, accepted=True)
598
599        # Now update self.utxo for later tests.
600        tx3 = CTransaction()
601        # tx and tx2 were both accepted.  Don't bother trying to reclaim the
602        # P2PKH output; just send tx's first output back to an anyone-can-spend.
603        self.sync_mempools([self.nodes[0], self.nodes[1]])
604        tx3.vin = [CTxIn(COutPoint(tx.txid_int, 0), b"")]
605        tx3.vout = [CTxOut(tx.vout[0].nValue - 1000, CScript([OP_TRUE, OP_DROP] * 15 + [OP_TRUE]))]
606        tx3.wit.vtxinwit.append(CTxInWitness())
607        tx3.wit.vtxinwit[0].scriptWitness.stack = [witness_script]
608        if not self.segwit_active:
609            # Just check mempool acceptance, but don't add the transaction to the mempool, since witness is disallowed
610            # in blocks and the tx is impossible to mine right now.
611            testres3 = self.nodes[0].testmempoolaccept([tx3.serialize_with_witness().hex()])
612            testres3[0]["fees"].pop("effective-feerate")
613            testres3[0]["fees"].pop("effective-includes")
614            assert_equal(testres3,
615                [{
616                    'txid': tx3.txid_hex,
617                    'wtxid': tx3.wtxid_hex,
618                    'allowed': True,
619                    'vsize_adjusted': tx3.get_vsize(),
620                    'vsize': tx3.get_vsize(),
621                    'vsize_bip141': tx3.get_vsize(),
622                    'fees': {
623                        'base': Decimal('0.00001000'),
624                    },
625                }],
626            )
627            # Create the same output as tx3, but by replacing tx
628            tx3_out = tx3.vout[0]
629            tx3 = tx
630            tx3.vout = [tx3_out]
631            testres3_replaced = self.nodes[0].testmempoolaccept([tx3.serialize_with_witness().hex()])
632            testres3_replaced[0]["fees"].pop("effective-feerate")
633            testres3_replaced[0]["fees"].pop("effective-includes")
634            assert_equal(testres3_replaced,
635                [{
636                    'txid': tx3.txid_hex,
637                    'wtxid': tx3.wtxid_hex,
638                    'allowed': True,
639                    'vsize_adjusted': tx3.get_vsize(),
640                    'vsize': tx3.get_vsize(),
641                    'vsize_bip141': tx3.get_vsize(),
642                    'fees': {
643                        'base': Decimal('0.00011000'),
644                    },
645                }],
646            )
647        test_transaction_acceptance(self.nodes[0], self.test_node, tx3, with_witness=True, accepted=True)
648
649        self.generate(self.nodes[0], 1)
650        self.utxo.pop(0)
651        self.utxo.append(UTXO(tx3.txid_int, 0, tx3.vout[0].nValue))
652        assert_equal(len(self.nodes[1].getrawmempool()), 0)
653
654    @subtest
655    def advance_to_segwit_active(self):
656        """Mine enough blocks to activate segwit."""
657        assert not softfork_active(self.nodes[0], 'segwit')
658        height = self.nodes[0].getblockcount()
659        self.generate(self.nodes[0], SEGWIT_HEIGHT - height - 2)
660        assert not softfork_active(self.nodes[0], 'segwit')
661        self.generate(self.nodes[0], 1)
662        assert softfork_active(self.nodes[0], 'segwit')
663        self.segwit_active = True
664
665    @subtest
666    def test_p2sh_witness(self):
667        """Test P2SH wrapped witness programs."""
668
669        # Prepare the p2sh-wrapped witness output
670        witness_script = CScript([OP_DROP, OP_TRUE])
671        p2wsh_pubkey = script_to_p2wsh_script(witness_script)
672        script_pubkey = script_to_p2sh_script(p2wsh_pubkey)
673        script_sig = CScript([p2wsh_pubkey])  # a push of the redeem script
674
675        # Fund the P2SH output
676        tx = CTransaction()
677        tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
678        tx.vout.append(CTxOut(self.utxo[0].nValue - 1000, script_pubkey))
679
680        # Verify mempool acceptance and block validity
681        test_transaction_acceptance(self.nodes[0], self.test_node, tx, with_witness=False, accepted=True)
682        block = self.build_next_block()
683        self.update_witness_block_with_transactions(block, [tx])
684        test_witness_block(self.nodes[0], self.test_node, block, accepted=True, with_witness=True)
685        self.sync_blocks()
686
687        # Now test attempts to spend the output.
688        spend_tx = CTransaction()
689        spend_tx.vin.append(CTxIn(COutPoint(tx.txid_int, 0), script_sig))
690        spend_tx.vout.append(CTxOut(tx.vout[0].nValue - 1000, CScript([OP_TRUE])))
691
692        # This transaction should not be accepted into the mempool pre- or
693        # post-segwit.  Mempool acceptance will use SCRIPT_VERIFY_WITNESS which
694        # will require a witness to spend a witness program regardless of
695        # segwit activation.  Note that older bitcoind's that are not
696        # segwit-aware would also reject this for failing CLEANSTACK.
697        with self.nodes[0].assert_debug_log(
698                expected_msgs=[spend_tx.txid_hex, 'was not accepted: mempool-script-verify-flag-failed (Witness program was passed an empty witness)']):
699            test_transaction_acceptance(self.nodes[0], self.test_node, spend_tx, with_witness=False, accepted=False)
700
701        # The transaction was detected as witness stripped above and not added to the reject
702        # filter. Trying again will check it again and result in the same error.
703        with self.nodes[0].assert_debug_log(
704                expected_msgs=[spend_tx.txid_hex, 'was not accepted: mempool-script-verify-flag-failed (Witness program was passed an empty witness)']):
705            test_transaction_acceptance(self.nodes[0], self.test_node, spend_tx, with_witness=False, accepted=False)
706
707        # Try to put the witness script in the scriptSig, should also fail.
708        spend_tx.vin[0].scriptSig = CScript([p2wsh_pubkey, b'a'])
709        with self.nodes[0].assert_debug_log(
710                expected_msgs=[spend_tx.txid_hex, 'was not accepted: mempool-script-verify-flag-failed (Script evaluated without error but finished with a false/empty top stack element)']):
711            test_transaction_acceptance(self.nodes[0], self.test_node, spend_tx, with_witness=False, accepted=False)
712
713        # Now put the witness script in the witness, should succeed after
714        # segwit activates.
715        spend_tx.vin[0].scriptSig = script_sig
716        spend_tx.wit.vtxinwit.append(CTxInWitness())
717        spend_tx.wit.vtxinwit[0].scriptWitness.stack = [b'a', witness_script]
718
719        # Verify mempool acceptance
720        test_transaction_acceptance(self.nodes[0], self.test_node, spend_tx, with_witness=True, accepted=True)
721        block = self.build_next_block()
722        self.update_witness_block_with_transactions(block, [spend_tx])
723
724        # If we're after activation, then sending this with witnesses should be valid.
725        # This no longer works before activation, because SCRIPT_VERIFY_WITNESS
726        # is always set.
727        # TODO: rewrite this test to make clear that it only works after activation.
728        test_witness_block(self.nodes[0], self.test_node, block, accepted=True)
729
730        # Update self.utxo
731        self.utxo.pop(0)
732        self.utxo.append(UTXO(spend_tx.txid_int, 0, spend_tx.vout[0].nValue))
733
734    @subtest
735    def test_witness_commitments(self):
736        """Test witness commitments.
737
738        This test can only be run after segwit has activated."""
739
740        # First try a correct witness commitment.
741        block = self.build_next_block()
742        add_witness_commitment(block)
743        block.solve()
744
745        # Test the test -- witness serialization should be different
746        assert_not_equal(msg_block(block).serialize(), msg_no_witness_block(block).serialize())
747
748        # This empty block should be valid.
749        test_witness_block(self.nodes[0], self.test_node, block, accepted=True)
750