Inside Bitcoin

751        # Try to tweak the nonce
752        block_2 = self.build_next_block()
753        add_witness_commitment(block_2, nonce=28)
754        block_2.solve()
755
756        # The commitment should have changed!
757        assert_not_equal(block_2.vtx[0].vout[-1], block.vtx[0].vout[-1])
758
759        # This should also be valid.
760        test_witness_block(self.nodes[0], self.test_node, block_2, accepted=True)
761
762        # Now test commitments with actual transactions
763        tx = CTransaction()
764        tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
765
766        # Let's construct a witness script
767        witness_script = CScript([OP_TRUE])
768        script_pubkey = script_to_p2wsh_script(witness_script)
769        tx.vout.append(CTxOut(self.utxo[0].nValue - 1000, script_pubkey))
770
771        # tx2 will spend tx1, and send back to a regular anyone-can-spend address
772        tx2 = CTransaction()
773        tx2.vin.append(CTxIn(COutPoint(tx.txid_int, 0), b""))
774        tx2.vout.append(CTxOut(tx.vout[0].nValue - 1000, witness_script))
775        tx2.wit.vtxinwit.append(CTxInWitness())
776        tx2.wit.vtxinwit[0].scriptWitness.stack = [witness_script]
777
778        block_3 = self.build_next_block()
779        self.update_witness_block_with_transactions(block_3, [tx, tx2], nonce=1)
780        # Add an extra OP_RETURN output that matches the witness commitment template,
781        # even though it has extra data after the incorrect commitment.
782        # This block should fail.
783        block_3.vtx[0].vout.append(CTxOut(0, CScript([OP_RETURN, WITNESS_COMMITMENT_HEADER + ser_uint256(2), 10])))
784        block_3.hashMerkleRoot = block_3.calc_merkle_root()
785        block_3.solve()
786
787        test_witness_block(self.nodes[0], self.test_node, block_3, accepted=False, reason='bad-witness-merkle-match')
788
789        # Add a different commitment with different nonce, but in the
790        # right location, and with some funds burned(!).
791        # This should succeed (nValue shouldn't affect finding the
792        # witness commitment).
793        add_witness_commitment(block_3, nonce=0)
794        block_3.vtx[0].vout[0].nValue -= 1
795        block_3.vtx[0].vout[-1].nValue += 1
796        block_3.hashMerkleRoot = block_3.calc_merkle_root()
797        assert_equal(len(block_3.vtx[0].vout), 4)  # 3 OP_returns
798        block_3.solve()
799        test_witness_block(self.nodes[0], self.test_node, block_3, accepted=True)
800
801        # Finally test that a block with no witness transactions can
802        # omit the commitment.
803        block_4 = self.build_next_block()
804        tx3 = CTransaction()
805        tx3.vin.append(CTxIn(COutPoint(tx2.txid_int, 0), b""))
806        tx3.vout.append(CTxOut(tx.vout[0].nValue - 1000, witness_script))
807        block_4.vtx.append(tx3)
808        block_4.hashMerkleRoot = block_4.calc_merkle_root()
809        block_4.solve()
810        test_witness_block(self.nodes[0], self.test_node, block_4, with_witness=False, accepted=True)
811
812        # Update available utxo's for use in later test.
813        self.utxo.pop(0)
814        self.utxo.append(UTXO(tx3.txid_int, 0, tx3.vout[0].nValue))
815
816    @subtest
817    def test_block_malleability(self):
818
819        # Make sure that a block that has too big a virtual size
820        # because of a too-large coinbase witness is not permanently
821        # marked bad.
822        block = self.build_next_block()
823        add_witness_commitment(block)
824        block.solve()
825
826        block.vtx[0].wit.vtxinwit[0].scriptWitness.stack.append(b'a' * 5000000)
827        assert block.get_weight() > MAX_BLOCK_WEIGHT
828
829        # We can't send over the p2p network, because this is too big to relay
830        assert_equal('bad-witness-nonce-size', self.nodes[0].submitblock(block.serialize().hex()))
831
832        assert_not_equal(self.nodes[0].getbestblockhash(), block.hash_hex)
833
834        block.vtx[0].wit.vtxinwit[0].scriptWitness.stack.pop()
835        assert block.get_weight() < MAX_BLOCK_WEIGHT
836        assert_equal(None, self.nodes[0].submitblock(block.serialize().hex()))
837
838        assert_equal(self.nodes[0].getbestblockhash(), block.hash_hex)
839
840        # Build a relayable-but-invalid block
841        relayable_block = self.build_next_block()
842        add_witness_commitment(relayable_block)
843        relayable_block.solve()
844
845        # Append extra witness data to the coinbase input that triggers the
846        # same validation rejection but keeps the block under the weight limit
847        # so it can be sent via P2P.
848        relayable_block.vtx[0].wit.vtxinwit[0].scriptWitness.stack.append(b'a' * 100_000)
849
850        # Ensure it's relayable by weight
851        assert_greater_than_or_equal(MAX_BLOCK_WEIGHT, relayable_block.get_weight())
852
853        # Send over P2P and expect rejection for the same reason
854        test_witness_block(self.nodes[0], self.test_node, relayable_block,
855                           accepted=False, reason='bad-witness-nonce-size')
856
857        # Node should still be on the previous tip
858        assert_not_equal(self.nodes[0].getbestblockhash(), relayable_block.hash_hex)
859
860        # Now fix the block by removing the extra witness data
861        relayable_block.vtx[0].wit.vtxinwit[0].scriptWitness.stack.pop()
862
863        # Confirm the block is still relayable by weight
864        assert relayable_block.get_weight() <= MAX_BLOCK_WEIGHT
865
866        # Send the corrected block and expect acceptance
867        test_witness_block(self.nodes[0], self.test_node, relayable_block, accepted=True)
868        assert_equal(self.nodes[0].getbestblockhash(), relayable_block.hash_hex)
869
870        # Now make sure that malleating the witness reserved value doesn't
871        # result in a block permanently marked bad.
872        block = self.build_next_block()
873        add_witness_commitment(block)
874        block.solve()
875
876        # Change the nonce -- should not cause the block to be permanently
877        # failed
878        block.vtx[0].wit.vtxinwit[0].scriptWitness.stack = [ser_uint256(1)]
879        test_witness_block(self.nodes[0], self.test_node, block, accepted=False, reason='bad-witness-merkle-match')
880
881        # Changing the witness reserved value doesn't change the block hash
882        block.vtx[0].wit.vtxinwit[0].scriptWitness.stack = [ser_uint256(0)]
883        test_witness_block(self.nodes[0], self.test_node, block, accepted=True)
884
885    @subtest
886    def test_witness_block_size(self):
887        # TODO: Test that non-witness carrying blocks can't exceed 1MB
888        # Skipping this test for now; this is covered in feature_block.py
889
890        # Test that witness-bearing blocks are limited at ceil(base + wit/4) <= 1MB.
891        block = self.build_next_block()
892
893        assert len(self.utxo) > 0
894
895        # Create a P2WSH transaction.
896        # The witness script will be a bunch of OP_2DROP's, followed by OP_TRUE.
897        # This should give us plenty of room to tweak the spending tx's
898        # virtual size.
899        NUM_DROPS = 200  # 201 max ops per script!
900        NUM_OUTPUTS = 50
901
902        witness_script = CScript([OP_2DROP] * NUM_DROPS + [OP_TRUE])
903        script_pubkey = script_to_p2wsh_script(witness_script)
904
905        prevout = COutPoint(self.utxo[0].sha256, self.utxo[0].n)
906        value = self.utxo[0].nValue
907
908        parent_tx = CTransaction()
909        parent_tx.vin.append(CTxIn(prevout, b""))
910        child_value = int(value / NUM_OUTPUTS)
911        for _ in range(NUM_OUTPUTS):
912            parent_tx.vout.append(CTxOut(child_value, script_pubkey))
913        parent_tx.vout[0].nValue -= 50000
914        assert parent_tx.vout[0].nValue > 0
915
916        child_tx = CTransaction()
917        for i in range(NUM_OUTPUTS):
918            child_tx.vin.append(CTxIn(COutPoint(parent_tx.txid_int, i), b""))
919        child_tx.vout = [CTxOut(value - 100000, CScript([OP_TRUE]))]
920        for _ in range(NUM_OUTPUTS):
921            child_tx.wit.vtxinwit.append(CTxInWitness())
922            child_tx.wit.vtxinwit[-1].scriptWitness.stack = [b'a' * 195] * (2 * NUM_DROPS) + [witness_script]
923        self.update_witness_block_with_transactions(block, [parent_tx, child_tx])
924
925        additional_bytes = MAX_BLOCK_WEIGHT - block.get_weight()
926        i = 0
927        while additional_bytes > 0:
928            # Add some more bytes to each input until we hit MAX_BLOCK_WEIGHT+1
929            extra_bytes = min(additional_bytes + 1, 55)
930            block.vtx[-1].wit.vtxinwit[int(i / (2 * NUM_DROPS))].scriptWitness.stack[i % (2 * NUM_DROPS)] = b'a' * (195 + extra_bytes)
931            additional_bytes -= extra_bytes
932            i += 1
933
934        block.vtx[0].vout.pop()  # Remove old commitment
935        add_witness_commitment(block)
936        block.solve()
937        assert_equal(block.get_weight(), MAX_BLOCK_WEIGHT + 1)
938        # Make sure that our test case would exceed the old max-network-message
939        # limit
940        assert len(block.serialize()) > 2 * 1024 * 1024
941
942        test_witness_block(self.nodes[0], self.test_node, block, accepted=False, reason='bad-blk-weight')
943
944        # Now resize the second transaction to make the block fit.
945        cur_length = len(block.vtx[-1].wit.vtxinwit[0].scriptWitness.stack[0])
946        block.vtx[-1].wit.vtxinwit[0].scriptWitness.stack[0] = b'a' * (cur_length - 1)
947        block.vtx[0].vout.pop()
948        add_witness_commitment(block)
949        block.solve()
950        assert_equal(block.get_weight(), MAX_BLOCK_WEIGHT)
951
952        test_witness_block(self.nodes[0], self.test_node, block, accepted=True)
953
954        # Update available utxo's
955        self.utxo.pop(0)
956        self.utxo.append(UTXO(block.vtx[-1].txid_int, 0, block.vtx[-1].vout[0].nValue))
957
958    @subtest
959    def test_submit_block(self):
960        """Test that submitblock adds the nonce automatically when possible."""
961        block = self.build_next_block()
962
963        # Try using a custom nonce and then don't supply it.
964        # This shouldn't possibly work.
965        add_witness_commitment(block, nonce=1)
966        block.vtx[0].wit = CTxWitness()  # drop the nonce
967        block.solve()
968        assert_equal('bad-witness-merkle-match', self.nodes[0].submitblock(block.serialize().hex()))
969        assert_not_equal(self.nodes[0].getbestblockhash(), block.hash_hex)
970
971        # Now redo commitment with the standard nonce, but let bitcoind fill it in.
972        add_witness_commitment(block, nonce=0)
973        block.vtx[0].wit = CTxWitness()
974        block.solve()
975        assert_equal(None, self.nodes[0].submitblock(block.serialize().hex()))
976        assert_equal(self.nodes[0].getbestblockhash(), block.hash_hex)
977
978        # This time, add a tx with non-empty witness, but don't supply
979        # the commitment.
980        block_2 = self.build_next_block()
981
982        add_witness_commitment(block_2)
983
984        block_2.solve()
985
986        # Drop commitment and nonce -- submitblock should not fill in.
987        block_2.vtx[0].vout.pop()
988        block_2.vtx[0].wit = CTxWitness()
989
990        assert_equal('bad-txnmrklroot', self.nodes[0].submitblock(block_2.serialize().hex()))
991        # Tip should not advance!
992        assert_not_equal(self.nodes[0].getbestblockhash(), block_2.hash_hex)
993
994    @subtest
995    def test_extra_witness_data(self):
996        """Test extra witness data in a transaction."""
997
998        block = self.build_next_block()
999
1000        witness_script = CScript([OP_DROP, OP_TRUE])