Inside Bitcoin

1001        script_pubkey = script_to_p2wsh_script(witness_script)
1002
1003        # First try extra witness data on a tx that doesn't require a witness
1004        tx = CTransaction()
1005        tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
1006        tx.vout.append(CTxOut(self.utxo[0].nValue - 2000, script_pubkey))
1007        tx.vout.append(CTxOut(1000, CScript([OP_TRUE])))  # non-witness output
1008        tx.wit.vtxinwit.append(CTxInWitness())
1009        tx.wit.vtxinwit[0].scriptWitness.stack = [CScript([])]
1010        self.update_witness_block_with_transactions(block, [tx])
1011
1012        # Extra witness data should not be allowed.
1013        test_witness_block(self.nodes[0], self.test_node, block, accepted=False,
1014                           reason='block-script-verify-flag-failed (Witness provided for non-witness script)')
1015
1016        # Try extra signature data.  Ok if we're not spending a witness output.
1017        block.vtx[1].wit.vtxinwit = []
1018        block.vtx[1].vin[0].scriptSig = CScript([OP_0])
1019        add_witness_commitment(block)
1020        block.solve()
1021
1022        test_witness_block(self.nodes[0], self.test_node, block, accepted=True)
1023
1024        # Now try extra witness/signature data on an input that DOES require a
1025        # witness
1026        tx2 = CTransaction()
1027        tx2.vin.append(CTxIn(COutPoint(tx.txid_int, 0), b""))  # witness output
1028        tx2.vin.append(CTxIn(COutPoint(tx.txid_int, 1), b""))  # non-witness
1029        tx2.vout.append(CTxOut(tx.vout[0].nValue, CScript([OP_TRUE])))
1030        tx2.wit.vtxinwit.extend([CTxInWitness(), CTxInWitness()])
1031        tx2.wit.vtxinwit[0].scriptWitness.stack = [CScript([CScriptNum(1)]), CScript([CScriptNum(1)]), witness_script]
1032        tx2.wit.vtxinwit[1].scriptWitness.stack = []
1033
1034        block = self.build_next_block()
1035        self.update_witness_block_with_transactions(block, [tx2])
1036
1037        # This has extra witness data, so it should fail.
1038        test_witness_block(self.nodes[0], self.test_node, block, accepted=False,
1039                           reason='block-script-verify-flag-failed (Stack size must be exactly one after execution)')
1040
1041        # Now get rid of the extra witness, but add extra scriptSig data
1042        tx2.vin[0].scriptSig = CScript([OP_TRUE])
1043        tx2.vin[1].scriptSig = CScript([OP_TRUE])
1044        tx2.wit.vtxinwit[0].scriptWitness.stack.pop(0)
1045        tx2.wit.vtxinwit[1].scriptWitness.stack = []
1046        add_witness_commitment(block)
1047        block.solve()
1048
1049        # This has extra signature data for a witness input, so it should fail.
1050        test_witness_block(self.nodes[0], self.test_node, block, accepted=False,
1051                           reason='block-script-verify-flag-failed (Witness requires empty scriptSig)')
1052
1053        # Now get rid of the extra scriptsig on the witness input, and verify
1054        # success (even with extra scriptsig data in the non-witness input)
1055        tx2.vin[0].scriptSig = b""
1056        add_witness_commitment(block)
1057        block.solve()
1058
1059        test_witness_block(self.nodes[0], self.test_node, block, accepted=True)
1060
1061        # Update utxo for later tests
1062        self.utxo.pop(0)
1063        self.utxo.append(UTXO(tx2.txid_int, 0, tx2.vout[0].nValue))
1064
1065    @subtest
1066    def test_max_witness_push_length(self):
1067        """Test that witness stack can only allow up to MAX_SCRIPT_ELEMENT_SIZE byte pushes."""
1068
1069        block = self.build_next_block()
1070
1071        witness_script = CScript([OP_DROP, OP_TRUE])
1072        script_pubkey = script_to_p2wsh_script(witness_script)
1073
1074        tx = CTransaction()
1075        tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
1076        tx.vout.append(CTxOut(self.utxo[0].nValue - 1000, script_pubkey))
1077
1078        tx2 = CTransaction()
1079        tx2.vin.append(CTxIn(COutPoint(tx.txid_int, 0), b""))
1080        tx2.vout.append(CTxOut(tx.vout[0].nValue - 1000, CScript([OP_TRUE])))
1081        tx2.wit.vtxinwit.append(CTxInWitness())
1082        # First try a 521-byte stack element
1083        tx2.wit.vtxinwit[0].scriptWitness.stack = [b'a' * (MAX_SCRIPT_ELEMENT_SIZE + 1), witness_script]
1084
1085        self.update_witness_block_with_transactions(block, [tx, tx2])
1086        test_witness_block(self.nodes[0], self.test_node, block, accepted=False,
1087                           reason='block-script-verify-flag-failed (Push value size limit exceeded)')
1088
1089        # Now reduce the length of the stack element
1090        tx2.wit.vtxinwit[0].scriptWitness.stack[0] = b'a' * (MAX_SCRIPT_ELEMENT_SIZE)
1091
1092        add_witness_commitment(block)
1093        block.solve()
1094        test_witness_block(self.nodes[0], self.test_node, block, accepted=True)
1095
1096        # Update the utxo for later tests
1097        self.utxo.pop()
1098        self.utxo.append(UTXO(tx2.txid_int, 0, tx2.vout[0].nValue))
1099
1100    @subtest
1101    def test_max_witness_script_length(self):
1102        """Test that witness outputs greater than 10kB can't be spent."""
1103
1104        MAX_WITNESS_SCRIPT_LENGTH = 10000
1105
1106        # This script is 19 max pushes (9937 bytes), then 64 more opcode-bytes.
1107        long_witness_script = CScript([b'a' * MAX_SCRIPT_ELEMENT_SIZE] * 19 + [OP_DROP] * 63 + [OP_TRUE])
1108        assert_equal(len(long_witness_script), MAX_WITNESS_SCRIPT_LENGTH + 1)
1109        long_script_pubkey = script_to_p2wsh_script(long_witness_script)
1110
1111        block = self.build_next_block()
1112
1113        tx = CTransaction()
1114        tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
1115        tx.vout.append(CTxOut(self.utxo[0].nValue - 1000, long_script_pubkey))
1116
1117        tx2 = CTransaction()
1118        tx2.vin.append(CTxIn(COutPoint(tx.txid_int, 0), b""))
1119        tx2.vout.append(CTxOut(tx.vout[0].nValue - 1000, CScript([OP_TRUE])))
1120        tx2.wit.vtxinwit.append(CTxInWitness())
1121        tx2.wit.vtxinwit[0].scriptWitness.stack = [b'a'] * 44 + [long_witness_script]
1122
1123        self.update_witness_block_with_transactions(block, [tx, tx2])
1124
1125        test_witness_block(self.nodes[0], self.test_node, block, accepted=False,
1126                           reason='block-script-verify-flag-failed (Script is too big)')
1127
1128        # Try again with one less byte in the witness script
1129        witness_script = CScript([b'a' * MAX_SCRIPT_ELEMENT_SIZE] * 19 + [OP_DROP] * 62 + [OP_TRUE])
1130        assert_equal(len(witness_script), MAX_WITNESS_SCRIPT_LENGTH)
1131        script_pubkey = script_to_p2wsh_script(witness_script)
1132
1133        tx.vout[0] = CTxOut(tx.vout[0].nValue, script_pubkey)
1134        tx2.vin[0].prevout.hash = tx.txid_int
1135        tx2.wit.vtxinwit[0].scriptWitness.stack = [b'a'] * 43 + [witness_script]
1136        block.vtx = [block.vtx[0]]
1137        self.update_witness_block_with_transactions(block, [tx, tx2])
1138        test_witness_block(self.nodes[0], self.test_node, block, accepted=True)
1139
1140        self.utxo.pop()
1141        self.utxo.append(UTXO(tx2.txid_int, 0, tx2.vout[0].nValue))
1142
1143    @subtest
1144    def test_witness_input_length(self):
1145        """Test that vin length must match vtxinwit length."""
1146
1147        witness_script = CScript([OP_DROP, OP_TRUE])
1148        script_pubkey = script_to_p2wsh_script(witness_script)
1149
1150        # Create a transaction that splits our utxo into many outputs
1151        tx = CTransaction()
1152        tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
1153        value = self.utxo[0].nValue
1154        for _ in range(10):
1155            tx.vout.append(CTxOut(int(value / 10), script_pubkey))
1156        tx.vout[0].nValue -= 1000
1157        assert tx.vout[0].nValue >= 0
1158
1159        block = self.build_next_block()
1160        self.update_witness_block_with_transactions(block, [tx])
1161        test_witness_block(self.nodes[0], self.test_node, block, accepted=True)
1162
1163        # Try various ways to spend tx that should all break.
1164        # This "broken" transaction serializer will not normalize
1165        # the length of vtxinwit.
1166        class BrokenCTransaction(CTransaction):
1167            def serialize_with_witness(self):
1168                flags = 0
1169                if not self.wit.is_null():
1170                    flags |= 1
1171                r = b""
1172                r += self.version.to_bytes(4, "little")
1173                if flags:
1174                    dummy = []
1175                    r += ser_vector(dummy)
1176                    r += flags.to_bytes(1, "little")
1177                r += ser_vector(self.vin)
1178                r += ser_vector(self.vout)
1179                if flags & 1:
1180                    r += self.wit.serialize()
1181                r += self.nLockTime.to_bytes(4, "little")
1182                return r
1183
1184        tx2 = BrokenCTransaction()
1185        for i in range(10):
1186            tx2.vin.append(CTxIn(COutPoint(tx.txid_int, i), b""))
1187        tx2.vout.append(CTxOut(value - 3000, CScript([OP_TRUE])))
1188
1189        # First try using a too long vtxinwit
1190        for i in range(11):
1191            tx2.wit.vtxinwit.append(CTxInWitness())
1192            tx2.wit.vtxinwit[i].scriptWitness.stack = [b'a', witness_script]
1193
1194        block = self.build_next_block()
1195        self.update_witness_block_with_transactions(block, [tx2])
1196        test_witness_block(self.nodes[0], self.test_node, block, accepted=False, reason='bad-txnmrklroot')
1197
1198        # Now try using a too short vtxinwit
1199        tx2.wit.vtxinwit.pop()
1200        tx2.wit.vtxinwit.pop()
1201
1202        block.vtx = [block.vtx[0]]
1203        self.update_witness_block_with_transactions(block, [tx2])
1204        # This block doesn't result in a specific reject reason, but an iostream exception:
1205        with self.nodes[0].assert_debug_log(["Exception 'DataStream::read(): end of data"]):
1206            test_witness_block(self.nodes[0], self.test_node, block, accepted=False)
1207
1208        # Now make one of the intermediate witnesses be incorrect
1209        tx2.wit.vtxinwit.append(CTxInWitness())
1210        tx2.wit.vtxinwit[-1].scriptWitness.stack = [b'a', witness_script]
1211        tx2.wit.vtxinwit[5].scriptWitness.stack = [witness_script]
1212
1213        block.vtx = [block.vtx[0]]
1214        self.update_witness_block_with_transactions(block, [tx2])
1215        test_witness_block(self.nodes[0], self.test_node, block, accepted=False,
1216                           reason='block-script-verify-flag-failed (Operation not valid with the current stack size)')
1217
1218        # Fix the broken witness and the block should be accepted.
1219        tx2.wit.vtxinwit[5].scriptWitness.stack = [b'a', witness_script]
1220        block.vtx = [block.vtx[0]]
1221        self.update_witness_block_with_transactions(block, [tx2])
1222        test_witness_block(self.nodes[0], self.test_node, block, accepted=True)
1223
1224        self.utxo.pop()
1225        self.utxo.append(UTXO(tx2.txid_int, 0, tx2.vout[0].nValue))
1226
1227    @subtest
1228    def test_tx_relay_after_segwit_activation(self):
1229        """Test transaction relay after segwit activation.
1230
1231        After segwit activates, verify that mempool:
1232        - rejects transactions with unnecessary/extra witnesses
1233        - accepts transactions with valid witnesses
1234        and that witness transactions are relayed to non-upgraded peers."""
1235
1236        # Generate a transaction that doesn't require a witness, but send it
1237        # with a witness.  Should be rejected because we can't use a witness
1238        # when spending a non-witness output.
1239        tx = CTransaction()
1240        tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
1241        tx.vout.append(CTxOut(self.utxo[0].nValue - 1000, CScript([OP_TRUE, OP_DROP] * 15 + [OP_TRUE])))
1242        tx.wit.vtxinwit.append(CTxInWitness())
1243        tx.wit.vtxinwit[0].scriptWitness.stack = [b'a']
1244
1245        tx_hash = tx.txid_int
1246
1247        # Verify that unnecessary witnesses are rejected.
1248        self.test_node.announce_tx_and_wait_for_getdata(tx)
1249        assert_equal(len(self.nodes[0].getrawmempool()), 0)
1250        test_transaction_acceptance(self.nodes[0], self.test_node, tx, with_witness=True, accepted=False)