Inside Bitcoin

1751        lasttxid = coinbase.txid_int
1752        amount = 5000000000
1753        for i, spk in enumerate(old_spks + tap_spks):
1754            val = 42000000 * (i + 7)
1755            tx = CTransaction()
1756            tx.version = 1
1757            tx.vin = [CTxIn(COutPoint(lasttxid, i & 1), CScript([]), SEQUENCE_FINAL)]
1758            tx.vout = [CTxOut(val, spk), CTxOut(amount - val, CScript([OP_1]))]
1759            if i & 1:
1760                tx.vout = list(reversed(tx.vout))
1761            tx.nLockTime = 0
1762            amount -= val
1763            lasttxid = tx.txid_int
1764            txn.append(tx)
1765            spend_info[spk]['prevout'] = COutPoint(tx.txid_int, i & 1)
1766            spend_info[spk]['utxo'] = CTxOut(val, spk)
1767        # Mine those transactions
1768        self.init_blockinfo(self.nodes[0])
1769        self.block_submit(self.nodes[0], txn, "Crediting txn", None, sigops_weight=10, accept=True)
1770
1771        # scriptPubKey computation
1772        tests = {"version": 1}
1773        spk_tests = tests.setdefault("scriptPubKey", [])
1774        for i, tap in enumerate(taps):
1775            test_case = {}
1776            given = test_case.setdefault("given", {})
1777            given['internalPubkey'] = tap.internal_pubkey.hex()
1778
1779            def pr(node):
1780                if node is None:
1781                    return None
1782                elif isinstance(node, tuple):
1783                    return {"id": int(node[0]), "script": node[1].hex(), "leafVersion": node[2]}
1784                elif len(node) == 1:
1785                    return pr(node[0])
1786                elif len(node) == 2:
1787                    return [pr(node[0]), pr(node[1])]
1788                else:
1789                    assert False
1790
1791            given['scriptTree'] = pr(script_lists[i])
1792            intermediary = test_case.setdefault("intermediary", {})
1793            if len(tap.leaves):
1794                leafhashes = intermediary.setdefault('leafHashes', [None] * len(tap.leaves))
1795                for leaf in tap.leaves:
1796                    leafhashes[int(leaf)] = tap.leaves[leaf].leaf_hash.hex()
1797            intermediary['merkleRoot'] = tap.merkle_root.hex() if tap.merkle_root else None
1798            intermediary['tweak'] = tap.tweak.hex()
1799            intermediary['tweakedPubkey'] = tap.output_pubkey.hex()
1800            expected = test_case.setdefault("expected", {})
1801            expected['scriptPubKey'] = tap.scriptPubKey.hex()
1802            expected['bip350Address'] = program_to_witness(1, bytes(tap.output_pubkey), True)
1803            if len(tap.leaves):
1804                control_blocks = expected.setdefault("scriptPathControlBlocks", [None] * len(tap.leaves))
1805                for leaf in tap.leaves:
1806                    ctx = {**DEFAULT_CONTEXT, 'tap': tap, 'leaf': leaf}
1807                    control_blocks[int(leaf)] = get(ctx, "controlblock").hex()
1808            spk_tests.append(test_case)
1809
1810        # Construct a deterministic transaction spending all outputs created above.
1811        tx = CTransaction()
1812        tx.version = 2
1813        tx.vin = []
1814        inputs = []
1815        input_spks = [tap_spks[0], tap_spks[1], old_spks[0], tap_spks[2], tap_spks[5], old_spks[2], tap_spks[6], tap_spks[3], tap_spks[4]]
1816        sequences = [0, SEQUENCE_FINAL, SEQUENCE_FINAL, 0xfffffffe, 0xfffffffe, 0, 0, SEQUENCE_FINAL, SEQUENCE_FINAL]
1817        hashtypes = [SIGHASH_SINGLE, SIGHASH_SINGLE|SIGHASH_ANYONECANPAY, SIGHASH_ALL, SIGHASH_ALL, SIGHASH_DEFAULT, SIGHASH_ALL, SIGHASH_NONE, SIGHASH_NONE|SIGHASH_ANYONECANPAY, SIGHASH_ALL|SIGHASH_ANYONECANPAY]
1818        for i, spk in enumerate(input_spks):
1819            tx.vin.append(CTxIn(spend_info[spk]['prevout'], CScript(), sequences[i]))
1820            inputs.append(spend_info[spk]['utxo'])
1821        tx.vout.append(CTxOut(1000000000, old_spks[1]))
1822        tx.vout.append(CTxOut(3410000000, pubs[98]))
1823        tx.nLockTime = 500000000
1824        precomputed = {
1825            "hashAmounts": BIP341_sha_amounts(inputs),
1826            "hashPrevouts": BIP341_sha_prevouts(tx),
1827            "hashScriptPubkeys": BIP341_sha_scriptpubkeys(inputs),
1828            "hashSequences": BIP341_sha_sequences(tx),
1829            "hashOutputs": BIP341_sha_outputs(tx)
1830        }
1831        keypath_tests = tests.setdefault("keyPathSpending", [])
1832        tx_test = {}
1833        global_given = tx_test.setdefault("given", {})
1834        global_given['rawUnsignedTx'] = tx.serialize().hex()
1835        utxos_spent = global_given.setdefault("utxosSpent", [])
1836        for i in range(len(input_spks)):
1837            utxos_spent.append({"scriptPubKey": inputs[i].scriptPubKey.hex(), "amountSats": inputs[i].nValue})
1838        global_intermediary = tx_test.setdefault("intermediary", {})
1839        for key in sorted(precomputed.keys()):
1840            global_intermediary[key] = precomputed[key].hex()
1841        test_list = tx_test.setdefault('inputSpending', [])
1842        for i in range(len(input_spks)):
1843            ctx = {
1844                **DEFAULT_CONTEXT,
1845                **spend_info[input_spks[i]],
1846                'tx': tx,
1847                'utxos': inputs,
1848                'idx': i,
1849                'hashtype': hashtypes[i],
1850                'deterministic': True
1851            }
1852            if ctx['mode'] == 'taproot':
1853                test_case = {}
1854                given = test_case.setdefault("given", {})
1855                given['txinIndex'] = i
1856                given['internalPrivkey'] = get(ctx, 'key').hex()
1857                if get(ctx, "tap").merkle_root != bytes():
1858                    given['merkleRoot'] = get(ctx, "tap").merkle_root.hex()
1859                else:
1860                    given['merkleRoot'] = None
1861                given['hashType'] = get(ctx, "hashtype")
1862                intermediary = test_case.setdefault("intermediary", {})
1863                intermediary['internalPubkey'] = get(ctx, "tap").internal_pubkey.hex()
1864                intermediary['tweak'] = get(ctx, "tap").tweak.hex()
1865                intermediary['tweakedPrivkey'] = get(ctx, "key_tweaked").hex()
1866                sigmsg = get(ctx, "sigmsg")
1867                intermediary['sigMsg'] = sigmsg.hex()
1868                intermediary['precomputedUsed'] = [key for key in sorted(precomputed.keys()) if sigmsg.count(precomputed[key])]
1869                intermediary['sigHash'] = get(ctx, "sighash").hex()
1870                expected = test_case.setdefault("expected", {})
1871                expected['witness'] = [get(ctx, "sign").hex()]
1872                test_list.append(test_case)
1873            tx.wit.vtxinwit.append(CTxInWitness())
1874            tx.vin[i].scriptSig = CScript(flatten(get(ctx, "scriptsig")))
1875            tx.wit.vtxinwit[i].scriptWitness.stack = flatten(get(ctx, "witness"))
1876        aux = tx_test.setdefault("auxiliary", {})
1877        aux['fullySignedTx'] = tx.serialize().hex()
1878        keypath_tests.append(tx_test)
1879        assert_equal(hashlib.sha256(tx.serialize()).hexdigest(), "24bab662cb55a7f3bae29b559f651674c62bcc1cd442d44715c0133939107b38")
1880        # Mine the spending transaction
1881        self.block_submit(self.nodes[0], [tx], "Spending txn", None, sigops_weight=10000, accept=True, witness=True)
1882
1883        if GEN_TEST_VECTORS:
1884            print(json.dumps(tests, indent=4, sort_keys=False))
1885
1886    def run_test(self):
1887        self.nodesigner = NodeSigner(self.nodes[0])
1888        self.gen_test_vectors()
1889
1890        self.log.info("Post-activation tests...")
1891
1892        # New sub-tests not checking standardness can be added to consensus_spenders
1893        # to allow for increased coverage across input types.
1894        # See sample_spenders for a minimal example
1895        consensus_spenders = sample_spenders()
1896        consensus_spenders += spenders_taproot_active()
1897        self.test_spenders(self.nodes[0], consensus_spenders, input_counts=[1, 2, 2, 2, 2, 3])
1898
1899        # Run each test twice; once in isolation, and once combined with others. Testing in isolation
1900        # means that the standardness is verified in every test (as combined transactions are only standard
1901        # when all their inputs are standard).
1902        nonstd_spenders = spenders_taproot_nonstandard()
1903        self.test_spenders(self.nodes[0], nonstd_spenders, input_counts=[1])
1904        self.test_spenders(self.nodes[0], nonstd_spenders, input_counts=[2, 3])
1905
1906
1907if __name__ == '__main__':
1908    TaprootTest(__file__).main()
1909