Inside Bitcoin

1251
1252        # Verify that removing the witness succeeds.
1253        test_transaction_acceptance(self.nodes[0], self.test_node, tx, with_witness=False, accepted=True)
1254
1255        # Now try to add extra witness data to a valid witness tx.
1256        witness_script = CScript([OP_TRUE])
1257        script_pubkey = script_to_p2wsh_script(witness_script)
1258        tx2 = CTransaction()
1259        tx2.vin.append(CTxIn(COutPoint(tx_hash, 0), b""))
1260        tx2.vout.append(CTxOut(tx.vout[0].nValue - 1000, script_pubkey))
1261
1262        tx3 = CTransaction()
1263        tx3.vin.append(CTxIn(COutPoint(tx2.txid_int, 0), b""))
1264        tx3.wit.vtxinwit.append(CTxInWitness())
1265
1266        # Add too-large for IsStandard witness and check that it does not enter reject filter
1267        p2sh_script = CScript([OP_TRUE])
1268        witness_script2 = CScript([b'a' * 400000])
1269        tx3.vout.append(CTxOut(tx2.vout[0].nValue - 1000, script_to_p2sh_script(p2sh_script)))
1270        tx3.wit.vtxinwit[0].scriptWitness.stack = [witness_script2]
1271
1272        # Node will not be blinded to the transaction, requesting it any number of times
1273        # if it is being announced via txid relay.
1274        # Node will be blinded to the transaction via wtxid, however.
1275        self.std_node.announce_tx_and_wait_for_getdata(tx3)
1276        self.std_wtx_node.announce_tx_and_wait_for_getdata(tx3, use_wtxid=True)
1277        test_transaction_acceptance(self.nodes[1], self.std_node, tx3, True, False, 'tx-size')
1278        self.std_node.announce_tx_and_wait_for_getdata(tx3)
1279        self.std_wtx_node.announce_tx_and_wait_for_getdata(tx3, use_wtxid=True, success=False)
1280
1281        # Remove witness stuffing, instead add extra witness push on stack
1282        tx3.vout[0] = CTxOut(tx2.vout[0].nValue - 1000, CScript([OP_TRUE, OP_DROP] * 15 + [OP_TRUE]))
1283        tx3.wit.vtxinwit[0].scriptWitness.stack = [CScript([CScriptNum(1)]), witness_script]
1284
1285        test_transaction_acceptance(self.nodes[0], self.test_node, tx2, with_witness=True, accepted=True)
1286        test_transaction_acceptance(self.nodes[0], self.test_node, tx3, with_witness=True, accepted=False)
1287
1288        # Now do the opposite: strip the witness entirely. This will be detected as witness stripping and
1289        # the (w)txid won't be added to the reject filter: we can try again and get the same error.
1290        tx3.wit.vtxinwit[0].scriptWitness.stack = []
1291        reason = "was not accepted: mempool-script-verify-flag-failed (Witness program was passed an empty witness)"
1292        test_transaction_acceptance(self.nodes[0], self.test_node, tx3, with_witness=False, accepted=False, reason=reason)
1293        test_transaction_acceptance(self.nodes[0], self.test_node, tx3, with_witness=False, accepted=False, reason=reason)
1294
1295        # Get rid of the extra witness, and verify acceptance.
1296        tx3.wit.vtxinwit[0].scriptWitness.stack = [witness_script]
1297        # Also check that old_node gets a tx announcement, even though this is
1298        # a witness transaction.
1299        self.old_node.wait_for_inv([CInv(MSG_TX, tx2.txid_int)])  # wait until tx2 was inv'ed
1300        test_transaction_acceptance(self.nodes[0], self.test_node, tx3, with_witness=True, accepted=True)
1301        self.old_node.wait_for_inv([CInv(MSG_TX, tx3.txid_int)])
1302
1303        # Test that getrawtransaction returns correct witness information
1304        # hash, size, vsize
1305        raw_tx = self.nodes[0].getrawtransaction(tx3.txid_hex, 1)
1306        assert_equal(raw_tx["hash"], tx3.wtxid_hex)
1307        assert_equal(raw_tx["size"], len(tx3.serialize_with_witness()))
1308        vsize = tx3.get_vsize()
1309        assert_equal(raw_tx["vsize"], vsize)
1310        assert_equal(raw_tx["weight"], tx3.get_weight())
1311        assert_equal(len(raw_tx["vin"][0]["txinwitness"]), 1)
1312        assert_equal(raw_tx["vin"][0]["txinwitness"][0], witness_script.hex())
1313        assert_not_equal(vsize, raw_tx["size"])
1314
1315        # Cleanup: mine the transactions and update utxo for next test
1316        self.generate(self.nodes[0], 1)
1317        assert_equal(len(self.nodes[0].getrawmempool()), 0)
1318
1319        self.utxo.pop(0)
1320        self.utxo.append(UTXO(tx3.txid_int, 0, tx3.vout[0].nValue))
1321
1322    @subtest
1323    def test_segwit_versions(self):
1324        """Test validity of future segwit version transactions.
1325
1326        Future segwit versions are non-standard to spend, but valid in blocks.
1327        Sending to future segwit versions is always allowed.
1328        Can run this before and after segwit activation."""
1329
1330        NUM_SEGWIT_VERSIONS = 17  # will test OP_0, OP1, ..., OP_16
1331        if len(self.utxo) < NUM_SEGWIT_VERSIONS:
1332            tx = CTransaction()
1333            tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
1334            split_value = (self.utxo[0].nValue - 4000) // NUM_SEGWIT_VERSIONS
1335            for _ in range(NUM_SEGWIT_VERSIONS):
1336                tx.vout.append(CTxOut(split_value, CScript([OP_TRUE])))
1337            block = self.build_next_block()
1338            self.update_witness_block_with_transactions(block, [tx])
1339            test_witness_block(self.nodes[0], self.test_node, block, accepted=True)
1340            self.utxo.pop(0)
1341            for i in range(NUM_SEGWIT_VERSIONS):
1342                self.utxo.append(UTXO(tx.txid_int, i, split_value))
1343
1344        self.sync_blocks()
1345        temp_utxo = []
1346        tx = CTransaction()
1347        witness_script = CScript([OP_TRUE])
1348        witness_hash = sha256(witness_script)
1349        assert_equal(len(self.nodes[1].getrawmempool()), 0)
1350        for version in list(range(OP_1, OP_16 + 1)) + [OP_0]:
1351            # First try to spend to a future version segwit script_pubkey.
1352            if version == OP_1:
1353                # Don't use 32-byte v1 witness (used by Taproot; see BIP 341)
1354                script_pubkey = CScript([CScriptOp(version), witness_hash + b'\x00'])
1355            else:
1356                script_pubkey = CScript([CScriptOp(version), witness_hash])
1357            tx.vin = [CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b"")]
1358            tx.vout = [CTxOut(self.utxo[0].nValue - 1000, script_pubkey)]
1359            test_transaction_acceptance(self.nodes[1], self.std_node, tx, with_witness=True, accepted=False)
1360            test_transaction_acceptance(self.nodes[0], self.test_node, tx, with_witness=True, accepted=True)
1361            self.utxo.pop(0)
1362            temp_utxo.append(UTXO(tx.txid_int, 0, tx.vout[0].nValue))
1363
1364        self.generate(self.nodes[0], 1)  # Mine all the transactions
1365        assert_equal(len(self.nodes[0].getrawmempool()), 0)
1366
1367        # Finally, verify that version 0 -> version 2 transactions
1368        # are standard
1369        script_pubkey = CScript([CScriptOp(OP_2), witness_hash])
1370        tx2 = CTransaction()
1371        tx2.vin = [CTxIn(COutPoint(tx.txid_int, 0), b"")]
1372        tx2.vout = [CTxOut(tx.vout[0].nValue - 1000, script_pubkey)]
1373        tx2.wit.vtxinwit.append(CTxInWitness())
1374        tx2.wit.vtxinwit[0].scriptWitness.stack = [witness_script]
1375        # Gets accepted to both policy-enforcing nodes and others.
1376        test_transaction_acceptance(self.nodes[0], self.test_node, tx2, with_witness=True, accepted=True)
1377        test_transaction_acceptance(self.nodes[1], self.std_node, tx2, with_witness=True, accepted=True)
1378        temp_utxo.pop()  # last entry in temp_utxo was the output we just spent
1379        temp_utxo.append(UTXO(tx2.txid_int, 0, tx2.vout[0].nValue))
1380
1381        # Spend everything in temp_utxo into an segwit v1 output.
1382        tx3 = CTransaction()
1383        total_value = 0
1384        for i in temp_utxo:
1385            tx3.vin.append(CTxIn(COutPoint(i.sha256, i.n), b""))
1386            tx3.wit.vtxinwit.append(CTxInWitness())
1387            total_value += i.nValue
1388        tx3.wit.vtxinwit[-1].scriptWitness.stack = [witness_script]
1389        tx3.vout.append(CTxOut(total_value - 1000, script_pubkey))
1390
1391        # First we test this transaction against std_node
1392        # making sure the txid is added to the reject filter
1393        self.std_node.announce_tx_and_wait_for_getdata(tx3)
1394        test_transaction_acceptance(self.nodes[1], self.std_node, tx3, with_witness=True, accepted=False, reason="bad-txns-nonstandard-inputs")
1395        # Now the node will no longer ask for getdata of this transaction when advertised by same txid
1396        self.std_node.announce_tx_and_wait_for_getdata(tx3, success=False)
1397
1398        # Spending a higher version witness output is not allowed by policy,
1399        # even with the node that accepts non-standard txs.
1400        test_transaction_acceptance(self.nodes[0], self.test_node, tx3, with_witness=True, accepted=False, reason="reserved for soft-fork upgrades")
1401
1402        # Building a block with the transaction must be valid, however.
1403        block = self.build_next_block()
1404        self.update_witness_block_with_transactions(block, [tx2, tx3])
1405        test_witness_block(self.nodes[0], self.test_node, block, accepted=True)
1406        self.sync_blocks()
1407
1408        # Add utxo to our list
1409        self.utxo.append(UTXO(tx3.txid_int, 0, tx3.vout[0].nValue))
1410
1411    @subtest
1412    def test_premature_coinbase_witness_spend(self):
1413
1414        block = self.build_next_block()
1415        # Change the output of the block to be a witness output.
1416        witness_script = CScript([OP_TRUE])
1417        script_pubkey = script_to_p2wsh_script(witness_script)
1418        block.vtx[0].vout[0].scriptPubKey = script_pubkey
1419        # This next line will rehash the coinbase and update the merkle
1420        # root, and solve.
1421        self.update_witness_block_with_transactions(block, [])
1422        test_witness_block(self.nodes[0], self.test_node, block, accepted=True)
1423
1424        spend_tx = CTransaction()
1425        spend_tx.vin = [CTxIn(COutPoint(block.vtx[0].txid_int, 0), b"")]
1426        spend_tx.vout = [CTxOut(block.vtx[0].vout[0].nValue, witness_script)]
1427        spend_tx.wit.vtxinwit.append(CTxInWitness())
1428        spend_tx.wit.vtxinwit[0].scriptWitness.stack = [witness_script]
1429
1430        # Now test a premature spend.
1431        self.generate(self.nodes[0], 98)
1432        block2 = self.build_next_block()
1433        self.update_witness_block_with_transactions(block2, [spend_tx])
1434        test_witness_block(self.nodes[0], self.test_node, block2, accepted=False, reason='bad-txns-premature-spend-of-coinbase')
1435
1436        # Advancing one more block should allow the spend.
1437        self.generate(self.nodes[0], 1)
1438        block2 = self.build_next_block()
1439        self.update_witness_block_with_transactions(block2, [spend_tx])
1440        test_witness_block(self.nodes[0], self.test_node, block2, accepted=True)
1441        self.sync_blocks()
1442
1443    @subtest
1444    def test_uncompressed_pubkey(self):
1445        """Test uncompressed pubkey validity in segwit transactions.
1446
1447        Uncompressed pubkeys are no longer supported in default relay policy,
1448        but (for now) are still valid in blocks."""
1449
1450        # Segwit transactions using uncompressed pubkeys are not accepted
1451        # under default policy, but should still pass consensus.
1452        key, pubkey = generate_keypair(compressed=False)
1453        assert_equal(len(pubkey), 65)  # This should be an uncompressed pubkey
1454
1455        utxo = self.utxo.pop(0)
1456
1457        # Test 1: P2WPKH
1458        # First create a P2WPKH output that uses an uncompressed pubkey
1459        pubkeyhash = hash160(pubkey)
1460        script_pkh = key_to_p2wpkh_script(pubkey)
1461        tx = CTransaction()
1462        tx.vin.append(CTxIn(COutPoint(utxo.sha256, utxo.n), b""))
1463        tx.vout.append(CTxOut(utxo.nValue - 1000, script_pkh))
1464
1465        # Confirm it in a block.
1466        block = self.build_next_block()
1467        self.update_witness_block_with_transactions(block, [tx])
1468        test_witness_block(self.nodes[0], self.test_node, block, accepted=True)
1469
1470        # Now try to spend it. Send it to a P2WSH output, which we'll
1471        # use in the next test.
1472        witness_script = key_to_p2pk_script(pubkey)
1473        script_wsh = script_to_p2wsh_script(witness_script)
1474
1475        tx2 = CTransaction()
1476        tx2.vin.append(CTxIn(COutPoint(tx.txid_int, 0), b""))
1477        tx2.vout.append(CTxOut(tx.vout[0].nValue - 1000, script_wsh))
1478        script = keyhash_to_p2pkh_script(pubkeyhash)
1479        tx2.wit.vtxinwit.append(CTxInWitness())
1480        tx2.wit.vtxinwit[0].scriptWitness.stack = [pubkey]
1481        sign_input_segwitv0(tx2, 0, script, tx.vout[0].nValue, key)
1482
1483        # Should fail policy test.
1484        test_transaction_acceptance(self.nodes[0], self.test_node, tx2, True, False, 'mempool-script-verify-flag-failed (Using non-compressed keys in segwit)')
1485        # But passes consensus.
1486        block = self.build_next_block()
1487        self.update_witness_block_with_transactions(block, [tx2])
1488        test_witness_block(self.nodes[0], self.test_node, block, accepted=True)
1489
1490        # Test 2: P2WSH
1491        # Try to spend the P2WSH output created in last test.
1492        # Send it to a P2SH(P2WSH) output, which we'll use in the next test.
1493        script_p2sh = script_to_p2sh_script(script_wsh)
1494        script_sig = CScript([script_wsh])
1495
1496        tx3 = CTransaction()
1497        tx3.vin.append(CTxIn(COutPoint(tx2.txid_int, 0), b""))
1498        tx3.vout.append(CTxOut(tx2.vout[0].nValue - 1000, script_p2sh))
1499        tx3.wit.vtxinwit.append(CTxInWitness())
1500        sign_p2pk_witness_input(witness_script, tx3, 0, SIGHASH_ALL, tx2.vout[0].nValue, key)