Inside Bitcoin

1751        # If we send without witness, it should be accepted.
1752        test_transaction_acceptance(self.nodes[1], self.std_node, tx2, False, True)
1753
1754        # Now create a new anyone-can-spend utxo for the next test.
1755        tx3 = CTransaction()
1756        tx3.vin.append(CTxIn(COutPoint(tx2.txid_int, 0), CScript([p2sh_program])))
1757        tx3.vout.append(CTxOut(tx2.vout[0].nValue - 1000, CScript([OP_TRUE, OP_DROP] * 15 + [OP_TRUE])))
1758        test_transaction_acceptance(self.nodes[0], self.test_node, tx2, False, True)
1759        test_transaction_acceptance(self.nodes[0], self.test_node, tx3, False, True)
1760
1761        self.generate(self.nodes[0], 1)
1762
1763        # Update our utxo list; we spent the first entry.
1764        self.utxo.pop(0)
1765        self.utxo.append(UTXO(tx3.txid_int, 0, tx3.vout[0].nValue))
1766
1767    @subtest
1768    def test_non_standard_witness(self):
1769        """Test detection of non-standard P2WSH witness"""
1770        pad = chr(1).encode('latin-1')
1771
1772        # Create scripts for tests
1773        scripts = []
1774        scripts.append(CScript([OP_DROP] * 100))
1775        scripts.append(CScript([OP_DROP] * 99))
1776        scripts.append(CScript([pad * 59] * 59 + [OP_DROP] * 60))
1777        scripts.append(CScript([pad * 59] * 59 + [OP_DROP] * 61))
1778
1779        p2wsh_scripts = []
1780
1781        tx = CTransaction()
1782        tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
1783
1784        # For each script, generate a pair of P2WSH and P2SH-P2WSH output.
1785        outputvalue = (self.utxo[0].nValue - 1000) // (len(scripts) * 2)
1786        for i in scripts:
1787            p2wsh = script_to_p2wsh_script(i)
1788            p2wsh_scripts.append(p2wsh)
1789            tx.vout.append(CTxOut(outputvalue, p2wsh))
1790            tx.vout.append(CTxOut(outputvalue, script_to_p2sh_script(p2wsh)))
1791        txid = tx.txid_int
1792        test_transaction_acceptance(self.nodes[0], self.test_node, tx, with_witness=False, accepted=True)
1793
1794        self.generate(self.nodes[0], 1)
1795
1796        # Creating transactions for tests
1797        p2wsh_txs = []
1798        p2sh_txs = []
1799        for i in range(len(scripts)):
1800            p2wsh_tx = CTransaction()
1801            p2wsh_tx.vin.append(CTxIn(COutPoint(txid, i * 2)))
1802            p2wsh_tx.vout.append(CTxOut(outputvalue - 5000, CScript([OP_0, hash160(b"")])))
1803            p2wsh_tx.wit.vtxinwit.append(CTxInWitness())
1804            p2wsh_txs.append(p2wsh_tx)
1805            p2sh_tx = CTransaction()
1806            p2sh_tx.vin.append(CTxIn(COutPoint(txid, i * 2 + 1), CScript([p2wsh_scripts[i]])))
1807            p2sh_tx.vout.append(CTxOut(outputvalue - 5000, CScript([OP_0, hash160(b"")])))
1808            p2sh_tx.wit.vtxinwit.append(CTxInWitness())
1809            p2sh_txs.append(p2sh_tx)
1810
1811        # Testing native P2WSH
1812        # Witness stack size, excluding witnessScript, over 100 is non-standard
1813        p2wsh_txs[0].wit.vtxinwit[0].scriptWitness.stack = [pad] * 101 + [scripts[0]]
1814        test_transaction_acceptance(self.nodes[1], self.std_node, p2wsh_txs[0], True, False, 'bad-witness-nonstandard')
1815        # Non-standard nodes should accept
1816        test_transaction_acceptance(self.nodes[0], self.test_node, p2wsh_txs[0], True, True)
1817
1818        # Stack element size over 80 bytes is non-standard
1819        p2wsh_txs[1].wit.vtxinwit[0].scriptWitness.stack = [pad * 81] * 100 + [scripts[1]]
1820        test_transaction_acceptance(self.nodes[1], self.std_node, p2wsh_txs[1], True, False, 'bad-witness-nonstandard')
1821        # Non-standard nodes should accept
1822        test_transaction_acceptance(self.nodes[0], self.test_node, p2wsh_txs[1], True, True)
1823        # Standard nodes should accept if element size is not over 80 bytes
1824        p2wsh_txs[1].wit.vtxinwit[0].scriptWitness.stack = [pad * 80] * 100 + [scripts[1]]
1825        test_transaction_acceptance(self.nodes[1], self.std_node, p2wsh_txs[1], True, True)
1826
1827        # witnessScript size at 3600 bytes is standard
1828        p2wsh_txs[2].wit.vtxinwit[0].scriptWitness.stack = [pad, pad, scripts[2]]
1829        test_transaction_acceptance(self.nodes[0], self.test_node, p2wsh_txs[2], True, True)
1830        test_transaction_acceptance(self.nodes[1], self.std_node, p2wsh_txs[2], True, True)
1831
1832        # witnessScript size at 3601 bytes is non-standard
1833        p2wsh_txs[3].wit.vtxinwit[0].scriptWitness.stack = [pad, pad, pad, scripts[3]]
1834        test_transaction_acceptance(self.nodes[1], self.std_node, p2wsh_txs[3], True, False, 'bad-witness-nonstandard')
1835        # Non-standard nodes should accept
1836        test_transaction_acceptance(self.nodes[0], self.test_node, p2wsh_txs[3], True, True)
1837
1838        # Repeating the same tests with P2SH-P2WSH
1839        p2sh_txs[0].wit.vtxinwit[0].scriptWitness.stack = [pad] * 101 + [scripts[0]]
1840        test_transaction_acceptance(self.nodes[1], self.std_node, p2sh_txs[0], True, False, 'bad-witness-nonstandard')
1841        test_transaction_acceptance(self.nodes[0], self.test_node, p2sh_txs[0], True, True)
1842        p2sh_txs[1].wit.vtxinwit[0].scriptWitness.stack = [pad * 81] * 100 + [scripts[1]]
1843        test_transaction_acceptance(self.nodes[1], self.std_node, p2sh_txs[1], True, False, 'bad-witness-nonstandard')
1844        test_transaction_acceptance(self.nodes[0], self.test_node, p2sh_txs[1], True, True)
1845        p2sh_txs[1].wit.vtxinwit[0].scriptWitness.stack = [pad * 80] * 100 + [scripts[1]]
1846        test_transaction_acceptance(self.nodes[1], self.std_node, p2sh_txs[1], True, True)
1847        p2sh_txs[2].wit.vtxinwit[0].scriptWitness.stack = [pad, pad, scripts[2]]
1848        test_transaction_acceptance(self.nodes[0], self.test_node, p2sh_txs[2], True, True)
1849        test_transaction_acceptance(self.nodes[1], self.std_node, p2sh_txs[2], True, True)
1850        p2sh_txs[3].wit.vtxinwit[0].scriptWitness.stack = [pad, pad, pad, scripts[3]]
1851        test_transaction_acceptance(self.nodes[1], self.std_node, p2sh_txs[3], True, False, 'bad-witness-nonstandard')
1852        test_transaction_acceptance(self.nodes[0], self.test_node, p2sh_txs[3], True, True)
1853
1854        self.generate(self.nodes[0], 1)  # Mine and clean up the mempool of non-standard node
1855        # Valid but non-standard transactions in a block should be accepted by standard node
1856        self.sync_blocks()
1857        assert_equal(len(self.nodes[0].getrawmempool()), 0)
1858        assert_equal(len(self.nodes[1].getrawmempool()), 0)
1859
1860        self.utxo.pop(0)
1861
1862    @subtest
1863    def test_witness_sigops(self):
1864        """Test sigop counting is correct inside witnesses."""
1865
1866        # Keep this under MAX_OPS_PER_SCRIPT (201)
1867        witness_script = CScript([OP_TRUE, OP_IF, OP_TRUE, OP_ELSE] + [OP_CHECKMULTISIG] * 5 + [OP_CHECKSIG] * 193 + [OP_ENDIF])
1868        script_pubkey = script_to_p2wsh_script(witness_script)
1869
1870        sigops_per_script = 20 * 5 + 193 * 1
1871        # We'll produce 2 extra outputs, one with a program that would take us
1872        # over max sig ops, and one with a program that would exactly reach max
1873        # sig ops
1874        outputs = (MAX_SIGOP_COST // sigops_per_script) + 2
1875        extra_sigops_available = MAX_SIGOP_COST % sigops_per_script
1876        p2sh_outputs = MAX_SIGOP_COST // (sigops_per_script * WITNESS_SCALE_FACTOR) + 1
1877
1878        # We chose the number of checkmultisigs/checksigs to make this work:
1879        assert extra_sigops_available < 100  # steer clear of MAX_OPS_PER_SCRIPT
1880
1881        # This script, when spent with the first
1882        # N(=MAX_SIGOP_COST//sigops_per_script) outputs of our transaction,
1883        # would push us just over the block sigop limit.
1884        witness_script_toomany = CScript([OP_TRUE, OP_IF, OP_TRUE, OP_ELSE] + [OP_CHECKSIG] * (extra_sigops_available + 1) + [OP_ENDIF])
1885        script_pubkey_toomany = script_to_p2wsh_script(witness_script_toomany)
1886
1887        # If we spend this script instead, we would exactly reach our sigop
1888        # limit (for witness sigops).
1889        witness_script_justright = CScript([OP_TRUE, OP_IF, OP_TRUE, OP_ELSE] + [OP_CHECKSIG] * (extra_sigops_available) + [OP_ENDIF])
1890        script_pubkey_justright = script_to_p2wsh_script(witness_script_justright)
1891
1892        # First split our available utxo into a bunch of outputs
1893        split_value = self.utxo[0].nValue // outputs
1894        tx = CTransaction()
1895        tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
1896        for _ in range(outputs):
1897            tx.vout.append(CTxOut(split_value, script_pubkey))
1898        tx.vout[-2].scriptPubKey = script_pubkey_toomany
1899        tx.vout[-1].scriptPubKey = script_pubkey_justright
1900        tx.vout += [CTxOut(0, script_to_p2sh_script(witness_script)) for _ in range(p2sh_outputs)]
1901
1902        block_1 = self.build_next_block()
1903        self.update_witness_block_with_transactions(block_1, [tx])
1904        test_witness_block(self.nodes[0], self.test_node, block_1, accepted=True)
1905
1906        tx2 = CTransaction()
1907        # If we try to spend the first n-1 outputs from tx, that should be
1908        # too many sigops.
1909        total_value = 0
1910        for i in range(outputs - 1):
1911            tx2.vin.append(CTxIn(COutPoint(tx.txid_int, i), b""))
1912            tx2.wit.vtxinwit.append(CTxInWitness())
1913            tx2.wit.vtxinwit[-1].scriptWitness.stack = [witness_script]
1914            total_value += tx.vout[i].nValue
1915        tx2.wit.vtxinwit[-1].scriptWitness.stack = [witness_script_toomany]
1916        tx2.vout.append(CTxOut(total_value, CScript([OP_TRUE])))
1917
1918        block_2 = self.build_next_block()
1919        self.update_witness_block_with_transactions(block_2, [tx2])
1920        test_witness_block(self.nodes[0], self.test_node, block_2, accepted=False, reason='bad-blk-sigops')
1921
1922        # Try dropping the last input in tx2, and add an output that has
1923        # too many sigops (contributing to legacy sigop count).
1924        checksig_count = (extra_sigops_available // 4) + 1
1925        script_pubkey_checksigs = CScript([OP_CHECKSIG] * checksig_count)
1926        tx2.vout.append(CTxOut(0, script_pubkey_checksigs))
1927        tx2.vin.pop()
1928        tx2.wit.vtxinwit.pop()
1929        tx2.vout[0].nValue -= tx.vout[outputs - 2].nValue
1930        block_3 = self.build_next_block()
1931        self.update_witness_block_with_transactions(block_3, [tx2])
1932        test_witness_block(self.nodes[0], self.test_node, block_3, accepted=False, reason='bad-blk-sigops')
1933
1934        # If we drop the last checksig in this output, the tx should succeed.
1935        block_4 = self.build_next_block()
1936        tx2.vout[-1].scriptPubKey = CScript([OP_CHECKSIG] * (checksig_count - 1))
1937        self.update_witness_block_with_transactions(block_4, [tx2])
1938        test_witness_block(self.nodes[0], self.test_node, block_4, accepted=True)
1939
1940        # Reset the tip back down for the next test
1941        self.sync_blocks()
1942        for x in self.nodes:
1943            x.invalidateblock(block_4.hash_hex)
1944
1945        # Try replacing the last input of tx2 to be spending the last
1946        # output of tx
1947        block_5 = self.build_next_block()
1948        tx2.vout.pop()
1949        tx2.vin.append(CTxIn(COutPoint(tx.txid_int, outputs - 1), b""))
1950        tx2.wit.vtxinwit.append(CTxInWitness())
1951        tx2.wit.vtxinwit[-1].scriptWitness.stack = [witness_script_justright]
1952        self.update_witness_block_with_transactions(block_5, [tx2])
1953        test_witness_block(self.nodes[0], self.test_node, block_5, accepted=True)
1954
1955        p2sh_tx = CTransaction()
1956        p2sh_tx.vin = [CTxIn(COutPoint(tx.txid_int, outputs + i), CScript([witness_script])) for i in range(p2sh_outputs)]
1957        p2sh_tx.vout.append(CTxOut(0, CScript([OP_TRUE])))
1958        block_6 = self.build_next_block()
1959        self.update_witness_block_with_transactions(block_6, [p2sh_tx])
1960        test_witness_block(self.nodes[0], self.test_node, block_6, accepted=False, reason='bad-blk-sigops')
1961
1962        # Add witness data to verify that the transaction's P2SH sigops are still counted.
1963        p2sh_tx.vin.append(CTxIn(COutPoint(tx.txid_int, outputs - 2), b""))
1964        p2sh_tx.wit.vtxinwit = [CTxInWitness() for _ in p2sh_tx.vin]
1965        p2sh_tx.wit.vtxinwit[-1].scriptWitness.stack = [witness_script_toomany]
1966        block_7 = self.build_next_block()
1967        self.update_witness_block_with_transactions(block_7, [p2sh_tx])
1968        test_witness_block(self.nodes[0], self.test_node, block_7, accepted=False, reason='bad-blk-sigops')
1969
1970        # Cleanup and prep for next test
1971        self.utxo.pop(0)
1972        self.utxo.append(UTXO(tx2.txid_int, 0, tx2.vout[0].nValue))
1973
1974    @subtest
1975    def test_superfluous_witness(self):
1976        # Serialization of tx that puts witness flag to 3 always
1977        def serialize_with_bogus_witness(tx):
1978            flags = 3
1979            r = b""
1980            r += tx.version.to_bytes(4, "little")
1981            if flags:
1982                dummy = []
1983                r += ser_vector(dummy)
1984                r += flags.to_bytes(1, "little")
1985            r += ser_vector(tx.vin)
1986            r += ser_vector(tx.vout)
1987            if flags & 1:
1988                if (len(tx.wit.vtxinwit) != len(tx.vin)):
1989                    # vtxinwit must have the same length as vin
1990                    tx.wit.vtxinwit = tx.wit.vtxinwit[:len(tx.vin)]
1991                    for _ in range(len(tx.wit.vtxinwit), len(tx.vin)):
1992                        tx.wit.vtxinwit.append(CTxInWitness())
1993                r += tx.wit.serialize()
1994            r += tx.nLockTime.to_bytes(4, "little")
1995            return r
1996
1997        class msg_bogus_tx(msg_tx):
1998            def serialize(self):
1999                return serialize_with_bogus_witness(self.tx)
2000