rpc_decodescript.py
1 #!/usr/bin/env python3 2 # Copyright (c) 2015-2022 The Bitcoin Core developers 3 # Distributed under the MIT software license, see the accompanying 4 # file COPYING or http://www.opensource.org/licenses/mit-license.php. 5 """Test decoding scripts via decodescript RPC command.""" 6 7 import json 8 import os 9 10 from test_framework.messages import ( 11 sha256, 12 tx_from_hex, 13 ) 14 from test_framework.test_framework import BitcoinTestFramework 15 from test_framework.util import ( 16 assert_equal, 17 ) 18 19 20 class DecodeScriptTest(BitcoinTestFramework): 21 def set_test_params(self): 22 self.setup_clean_chain = True 23 self.num_nodes = 1 24 25 def decodescript_script_sig(self): 26 signature = '304502207fa7a6d1e0ee81132a269ad84e68d695483745cde8b541e3bf630749894e342a022100c1f7ab20e13e22fb95281a870f3dcf38d782e53023ee313d741ad0cfbc0c509001' 27 push_signature = '48' + signature 28 public_key = '03b0da749730dc9b4b1f4a14d6902877a92541f5368778853d9c4a0cb7802dcfb2' 29 push_public_key = '21' + public_key 30 31 # below are test cases for all of the standard transaction types 32 33 self.log.info("- P2PK") 34 # the scriptSig of a public key scriptPubKey simply pushes a signature onto the stack 35 rpc_result = self.nodes[0].decodescript(push_signature) 36 assert_equal(signature, rpc_result['asm']) 37 38 self.log.info("- P2PKH") 39 rpc_result = self.nodes[0].decodescript(push_signature + push_public_key) 40 assert_equal(signature + ' ' + public_key, rpc_result['asm']) 41 42 self.log.info("- multisig") 43 # this also tests the leading portion of a P2SH multisig scriptSig 44 # OP_0 <A sig> <B sig> 45 rpc_result = self.nodes[0].decodescript('00' + push_signature + push_signature) 46 assert_equal('0 ' + signature + ' ' + signature, rpc_result['asm']) 47 48 self.log.info("- P2SH") 49 # an empty P2SH redeemScript is valid and makes for a very simple test case. 50 # thus, such a spending scriptSig would just need to pass the outer redeemScript 51 # hash test and leave true on the top of the stack. 52 rpc_result = self.nodes[0].decodescript('5100') 53 assert_equal('1 0', rpc_result['asm']) 54 55 # null data scriptSig - no such thing because null data scripts cannot be spent. 56 # thus, no test case for that standard transaction type is here. 57 58 def decodescript_script_pub_key(self): 59 public_key = '03b0da749730dc9b4b1f4a14d6902877a92541f5368778853d9c4a0cb7802dcfb2' 60 push_public_key = '21' + public_key 61 public_key_hash = '5dd1d3a048119c27b28293056724d9522f26d945' 62 push_public_key_hash = '14' + public_key_hash 63 uncompressed_public_key = '04b0da749730dc9b4b1f4a14d6902877a92541f5368778853d9c4a0cb7802dcfb25e01fc8fde47c96c98a4f3a8123e33a38a50cf9025cc8c4494a518f991792bb7' 64 push_uncompressed_public_key = '41' + uncompressed_public_key 65 p2wsh_p2pk_script_hash = 'd8590cf8ea0674cf3d49fd7ca249b85ef7485dea62c138468bddeb20cd6519f7' 66 67 # below are test cases for all of the standard transaction types 68 69 self.log.info("- P2PK") 70 # <pubkey> OP_CHECKSIG 71 rpc_result = self.nodes[0].decodescript(push_public_key + 'ac') 72 assert_equal(public_key + ' OP_CHECKSIG', rpc_result['asm']) 73 assert_equal('pubkey', rpc_result['type']) 74 # P2PK is translated to P2WPKH 75 assert_equal('0 ' + public_key_hash, rpc_result['segwit']['asm']) 76 77 self.log.info("- P2PKH") 78 # OP_DUP OP_HASH160 <PubKeyHash> OP_EQUALVERIFY OP_CHECKSIG 79 rpc_result = self.nodes[0].decodescript('76a9' + push_public_key_hash + '88ac') 80 assert_equal('pubkeyhash', rpc_result['type']) 81 assert_equal('OP_DUP OP_HASH160 ' + public_key_hash + ' OP_EQUALVERIFY OP_CHECKSIG', rpc_result['asm']) 82 # P2PKH is translated to P2WPKH 83 assert_equal('witness_v0_keyhash', rpc_result['segwit']['type']) 84 assert_equal('0 ' + public_key_hash, rpc_result['segwit']['asm']) 85 86 self.log.info("- multisig") 87 # <m> <A pubkey> <B pubkey> <C pubkey> <n> OP_CHECKMULTISIG 88 # just imagine that the pub keys used below are different. 89 # for our purposes here it does not matter that they are the same even though it is unrealistic. 90 multisig_script = '52' + push_public_key + push_public_key + push_public_key + '53ae' 91 rpc_result = self.nodes[0].decodescript(multisig_script) 92 assert_equal('multisig', rpc_result['type']) 93 assert_equal('2 ' + public_key + ' ' + public_key + ' ' + public_key + ' 3 OP_CHECKMULTISIG', rpc_result['asm']) 94 # multisig in P2WSH 95 multisig_script_hash = sha256(bytes.fromhex(multisig_script)).hex() 96 assert_equal('witness_v0_scripthash', rpc_result['segwit']['type']) 97 assert_equal('0 ' + multisig_script_hash, rpc_result['segwit']['asm']) 98 99 self.log.info ("- P2SH") 100 # OP_HASH160 <Hash160(redeemScript)> OP_EQUAL. 101 # push_public_key_hash here should actually be the hash of a redeem script. 102 # but this works the same for purposes of this test. 103 rpc_result = self.nodes[0].decodescript('a9' + push_public_key_hash + '87') 104 assert_equal('scripthash', rpc_result['type']) 105 assert_equal('OP_HASH160 ' + public_key_hash + ' OP_EQUAL', rpc_result['asm']) 106 # P2SH does not work in segwit secripts. decodescript should not return a result for it. 107 assert 'segwit' not in rpc_result 108 109 self.log.info("- null data") 110 # use a signature look-alike here to make sure that we do not decode random data as a signature. 111 # this matters if/when signature sighash decoding comes along. 112 # would want to make sure that no such decoding takes place in this case. 113 signature_imposter = '48304502207fa7a6d1e0ee81132a269ad84e68d695483745cde8b541e3bf630749894e342a022100c1f7ab20e13e22fb95281a870f3dcf38d782e53023ee313d741ad0cfbc0c509001' 114 # OP_RETURN <data> 115 rpc_result = self.nodes[0].decodescript('6a' + signature_imposter) 116 assert_equal('nulldata', rpc_result['type']) 117 assert_equal('OP_RETURN ' + signature_imposter[2:], rpc_result['asm']) 118 119 self.log.info("- CLTV redeem script") 120 # redeem scripts are in-effect scriptPubKey scripts, so adding a test here. 121 # OP_NOP2 is also known as OP_CHECKLOCKTIMEVERIFY. 122 # just imagine that the pub keys used below are different. 123 # for our purposes here it does not matter that they are the same even though it is unrealistic. 124 # 125 # OP_IF 126 # <receiver-pubkey> OP_CHECKSIGVERIFY 127 # OP_ELSE 128 # <lock-until> OP_CHECKLOCKTIMEVERIFY OP_DROP 129 # OP_ENDIF 130 # <sender-pubkey> OP_CHECKSIG 131 # 132 # lock until block 500,000 133 cltv_script = '63' + push_public_key + 'ad670320a107b17568' + push_public_key + 'ac' 134 rpc_result = self.nodes[0].decodescript(cltv_script) 135 assert_equal('nonstandard', rpc_result['type']) 136 assert_equal('OP_IF ' + public_key + ' OP_CHECKSIGVERIFY OP_ELSE 500000 OP_CHECKLOCKTIMEVERIFY OP_DROP OP_ENDIF ' + public_key + ' OP_CHECKSIG', rpc_result['asm']) 137 # CLTV script in P2WSH 138 cltv_script_hash = sha256(bytes.fromhex(cltv_script)).hex() 139 assert_equal('0 ' + cltv_script_hash, rpc_result['segwit']['asm']) 140 141 self.log.info("- P2PK with uncompressed pubkey") 142 # <pubkey> OP_CHECKSIG 143 rpc_result = self.nodes[0].decodescript(push_uncompressed_public_key + 'ac') 144 assert_equal('pubkey', rpc_result['type']) 145 assert_equal(uncompressed_public_key + ' OP_CHECKSIG', rpc_result['asm']) 146 # uncompressed pubkeys are invalid for checksigs in segwit scripts. 147 # decodescript should not return a P2WPKH equivalent. 148 assert 'segwit' not in rpc_result 149 150 self.log.info("- multisig with uncompressed pubkey") 151 # <m> <A pubkey> <B pubkey> <n> OP_CHECKMULTISIG 152 # just imagine that the pub keys used below are different. 153 # the purpose of this test is to check that a segwit script is not returned for bare multisig scripts 154 # with an uncompressed pubkey in them. 155 rpc_result = self.nodes[0].decodescript('52' + push_public_key + push_uncompressed_public_key +'52ae') 156 assert_equal('multisig', rpc_result['type']) 157 assert_equal('2 ' + public_key + ' ' + uncompressed_public_key + ' 2 OP_CHECKMULTISIG', rpc_result['asm']) 158 # uncompressed pubkeys are invalid for checksigs in segwit scripts. 159 # decodescript should not return a P2WPKH equivalent. 160 assert 'segwit' not in rpc_result 161 162 self.log.info("- P2WPKH") 163 # 0 <PubKeyHash> 164 rpc_result = self.nodes[0].decodescript('00' + push_public_key_hash) 165 assert_equal('witness_v0_keyhash', rpc_result['type']) 166 assert_equal('0 ' + public_key_hash, rpc_result['asm']) 167 # segwit scripts do not work nested into each other. 168 # a nested segwit script should not be returned in the results. 169 assert 'segwit' not in rpc_result 170 171 self.log.info("- P2WSH") 172 # 0 <ScriptHash> 173 # even though this hash is of a P2PK script which is better used as bare P2WPKH, it should not matter 174 # for the purpose of this test. 175 rpc_result = self.nodes[0].decodescript('0020' + p2wsh_p2pk_script_hash) 176 assert_equal('witness_v0_scripthash', rpc_result['type']) 177 assert_equal('0 ' + p2wsh_p2pk_script_hash, rpc_result['asm']) 178 # segwit scripts do not work nested into each other. 179 # a nested segwit script should not be returned in the results. 180 assert 'segwit' not in rpc_result 181 182 self.log.info("- P2TR") 183 # 1 <x-only pubkey> 184 xonly_public_key = '01'*32 # first ever P2TR output on mainnet 185 rpc_result = self.nodes[0].decodescript('5120' + xonly_public_key) 186 assert_equal('witness_v1_taproot', rpc_result['type']) 187 assert_equal('1 ' + xonly_public_key, rpc_result['asm']) 188 assert 'segwit' not in rpc_result 189 190 def decoderawtransaction_asm_sighashtype(self): 191 """Test decoding scripts via RPC command "decoderawtransaction". 192 193 This test is in with the "decodescript" tests because they are testing the same "asm" script decodes. 194 """ 195 196 self.log.info("- various mainnet txs") 197 # this test case uses a mainnet transaction that has a P2SH input and both P2PKH and P2SH outputs. 198 tx = '0100000001696a20784a2c70143f634e95227dbdfdf0ecd51647052e70854512235f5986ca010000008a47304402207174775824bec6c2700023309a168231ec80b82c6069282f5133e6f11cbb04460220570edc55c7c5da2ca687ebd0372d3546ebc3f810516a002350cac72dfe192dfb014104d3f898e6487787910a690410b7a917ef198905c27fb9d3b0a42da12aceae0544fc7088d239d9a48f2828a15a09e84043001f27cc80d162cb95404e1210161536ffffffff0100e1f505000000001976a914eb6c6e0cdb2d256a32d97b8df1fc75d1920d9bca88ac00000000' 199 rpc_result = self.nodes[0].decoderawtransaction(tx) 200 assert_equal('304402207174775824bec6c2700023309a168231ec80b82c6069282f5133e6f11cbb04460220570edc55c7c5da2ca687ebd0372d3546ebc3f810516a002350cac72dfe192dfb[ALL] 04d3f898e6487787910a690410b7a917ef198905c27fb9d3b0a42da12aceae0544fc7088d239d9a48f2828a15a09e84043001f27cc80d162cb95404e1210161536', rpc_result['vin'][0]['scriptSig']['asm']) 201 202 # this test case uses a mainnet transaction that has a P2SH input and both P2PKH and P2SH outputs. 203 # it's from James D'Angelo's awesome introductory videos about multisig: https://www.youtube.com/watch?v=zIbUSaZBJgU and https://www.youtube.com/watch?v=OSA1pwlaypc 204 # verify that we have not altered scriptPubKey decoding. 205 tx = '01000000018d1f5635abd06e2c7e2ddf58dc85b3de111e4ad6e0ab51bb0dcf5e84126d927300000000fdfe0000483045022100ae3b4e589dfc9d48cb82d41008dc5fa6a86f94d5c54f9935531924602730ab8002202f88cf464414c4ed9fa11b773c5ee944f66e9b05cc1e51d97abc22ce098937ea01483045022100b44883be035600e9328a01b66c7d8439b74db64187e76b99a68f7893b701d5380220225bf286493e4c4adcf928c40f785422572eb232f84a0b83b0dea823c3a19c75014c695221020743d44be989540d27b1b4bbbcfd17721c337cb6bc9af20eb8a32520b393532f2102c0120a1dda9e51a938d39ddd9fe0ebc45ea97e1d27a7cbd671d5431416d3dd87210213820eb3d5f509d7438c9eeecb4157b2f595105e7cd564b3cdbb9ead3da41eed53aeffffffff02611e0000000000001976a914dc863734a218bfe83ef770ee9d41a27f824a6e5688acee2a02000000000017a9142a5edea39971049a540474c6a99edf0aa4074c588700000000' 206 rpc_result = self.nodes[0].decoderawtransaction(tx) 207 assert_equal('8e3730608c3b0bb5df54f09076e196bc292a8e39a78e73b44b6ba08c78f5cbb0', rpc_result['txid']) 208 assert_equal('0 3045022100ae3b4e589dfc9d48cb82d41008dc5fa6a86f94d5c54f9935531924602730ab8002202f88cf464414c4ed9fa11b773c5ee944f66e9b05cc1e51d97abc22ce098937ea[ALL] 3045022100b44883be035600e9328a01b66c7d8439b74db64187e76b99a68f7893b701d5380220225bf286493e4c4adcf928c40f785422572eb232f84a0b83b0dea823c3a19c75[ALL] 5221020743d44be989540d27b1b4bbbcfd17721c337cb6bc9af20eb8a32520b393532f2102c0120a1dda9e51a938d39ddd9fe0ebc45ea97e1d27a7cbd671d5431416d3dd87210213820eb3d5f509d7438c9eeecb4157b2f595105e7cd564b3cdbb9ead3da41eed53ae', rpc_result['vin'][0]['scriptSig']['asm']) 209 assert_equal('OP_DUP OP_HASH160 dc863734a218bfe83ef770ee9d41a27f824a6e56 OP_EQUALVERIFY OP_CHECKSIG', rpc_result['vout'][0]['scriptPubKey']['asm']) 210 assert_equal('OP_HASH160 2a5edea39971049a540474c6a99edf0aa4074c58 OP_EQUAL', rpc_result['vout'][1]['scriptPubKey']['asm']) 211 txSave = tx_from_hex(tx) 212 213 self.log.info("- tx not passing DER signature checks") 214 # make sure that a specifically crafted op_return value will not pass all the IsDERSignature checks and then get decoded as a sighash type 215 tx = '01000000015ded05872fdbda629c7d3d02b194763ce3b9b1535ea884e3c8e765d42e316724020000006b48304502204c10d4064885c42638cbff3585915b322de33762598321145ba033fc796971e2022100bb153ad3baa8b757e30a2175bd32852d2e1cb9080f84d7e32fcdfd667934ef1b012103163c0ff73511ea1743fb5b98384a2ff09dd06949488028fd819f4d83f56264efffffffff0200000000000000000b6a0930060201000201000180380100000000001976a9141cabd296e753837c086da7a45a6c2fe0d49d7b7b88ac00000000' 216 rpc_result = self.nodes[0].decoderawtransaction(tx) 217 assert_equal('OP_RETURN 300602010002010001', rpc_result['vout'][0]['scriptPubKey']['asm']) 218 219 self.log.info("- tx passing DER signature checks") 220 # verify that we have not altered scriptPubKey processing even of a specially crafted P2PKH pubkeyhash and P2SH redeem script hash that is made to pass the der signature checks 221 tx = '01000000018d1f5635abd06e2c7e2ddf58dc85b3de111e4ad6e0ab51bb0dcf5e84126d927300000000fdfe0000483045022100ae3b4e589dfc9d48cb82d41008dc5fa6a86f94d5c54f9935531924602730ab8002202f88cf464414c4ed9fa11b773c5ee944f66e9b05cc1e51d97abc22ce098937ea01483045022100b44883be035600e9328a01b66c7d8439b74db64187e76b99a68f7893b701d5380220225bf286493e4c4adcf928c40f785422572eb232f84a0b83b0dea823c3a19c75014c695221020743d44be989540d27b1b4bbbcfd17721c337cb6bc9af20eb8a32520b393532f2102c0120a1dda9e51a938d39ddd9fe0ebc45ea97e1d27a7cbd671d5431416d3dd87210213820eb3d5f509d7438c9eeecb4157b2f595105e7cd564b3cdbb9ead3da41eed53aeffffffff02611e0000000000001976a914301102070101010101010102060101010101010188acee2a02000000000017a91430110207010101010101010206010101010101018700000000' 222 rpc_result = self.nodes[0].decoderawtransaction(tx) 223 assert_equal('OP_DUP OP_HASH160 3011020701010101010101020601010101010101 OP_EQUALVERIFY OP_CHECKSIG', rpc_result['vout'][0]['scriptPubKey']['asm']) 224 assert_equal('OP_HASH160 3011020701010101010101020601010101010101 OP_EQUAL', rpc_result['vout'][1]['scriptPubKey']['asm']) 225 226 # some more full transaction tests of varying specific scriptSigs. used instead of 227 # tests in decodescript_script_sig because the decodescript RPC is specifically 228 # for working on scriptPubKeys (argh!). 229 push_signature = txSave.vin[0].scriptSig.hex()[2:(0x48*2+4)] 230 signature = push_signature[2:] 231 der_signature = signature[:-2] 232 signature_sighash_decoded = der_signature + '[ALL]' 233 signature_2 = der_signature + '82' 234 push_signature_2 = '48' + signature_2 235 signature_2_sighash_decoded = der_signature + '[NONE|ANYONECANPAY]' 236 237 self.log.info("- P2PK scriptSig") 238 txSave.vin[0].scriptSig = bytes.fromhex(push_signature) 239 rpc_result = self.nodes[0].decoderawtransaction(txSave.serialize().hex()) 240 assert_equal(signature_sighash_decoded, rpc_result['vin'][0]['scriptSig']['asm']) 241 242 # make sure that the sighash decodes come out correctly for a more complex / lesser used case. 243 txSave.vin[0].scriptSig = bytes.fromhex(push_signature_2) 244 rpc_result = self.nodes[0].decoderawtransaction(txSave.serialize().hex()) 245 assert_equal(signature_2_sighash_decoded, rpc_result['vin'][0]['scriptSig']['asm']) 246 247 self.log.info("- multisig scriptSig") 248 txSave.vin[0].scriptSig = bytes.fromhex('00' + push_signature + push_signature_2) 249 rpc_result = self.nodes[0].decoderawtransaction(txSave.serialize().hex()) 250 assert_equal('0 ' + signature_sighash_decoded + ' ' + signature_2_sighash_decoded, rpc_result['vin'][0]['scriptSig']['asm']) 251 252 self.log.info("- scriptSig that contains more than push operations") 253 # in fact, it contains an OP_RETURN with data specially crafted to cause improper decode if the code does not catch it. 254 txSave.vin[0].scriptSig = bytes.fromhex('6a143011020701010101010101020601010101010101') 255 rpc_result = self.nodes[0].decoderawtransaction(txSave.serialize().hex()) 256 assert_equal('OP_RETURN 3011020701010101010101020601010101010101', rpc_result['vin'][0]['scriptSig']['asm']) 257 258 def decodescript_datadriven_tests(self): 259 with open(os.path.join(os.path.dirname(os.path.realpath(__file__)), 'data/rpc_decodescript.json'), encoding='utf-8') as f: 260 dd_tests = json.load(f) 261 262 for script, result in dd_tests: 263 rpc_result = self.nodes[0].decodescript(script) 264 assert_equal(result, rpc_result) 265 266 def decodescript_miniscript(self): 267 """Check that a Miniscript is decoded when possible under P2WSH context.""" 268 # Sourced from https://github.com/bitcoin/bitcoin/pull/27037#issuecomment-1416151907. 269 # Miniscript-compatible offered HTLC 270 res = self.nodes[0].decodescript("82012088a914ffffffffffffffffffffffffffffffffffffffff88210250929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ad51b2") 271 assert res["segwit"]["desc"] == "wsh(and_v(and_v(v:hash160(ffffffffffffffffffffffffffffffffffffffff),v:pk(0250929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0)),older(1)))#gm8xz4fl" 272 # Miniscript-incompatible offered HTLC 273 res = self.nodes[0].decodescript("82012088a914ffffffffffffffffffffffffffffffffffffffff882102ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffacb2") 274 assert res["segwit"]["desc"] == "addr(bcrt1q73qyfypp47hvgnkjqnav0j3k2lq3v76wg22dk8tmwuz5sfgv66xsvxg6uu)#9p3q328s" 275 # Miniscript-compatible multisig bigger than 520 byte P2SH limit. 276 res = self.nodes[0].decodescript("5b21020e0338c96a8870479f2396c373cc7696ba124e8635d41b0ea581112b678172612102675333a4e4b8fb51d9d4e22fa5a8eaced3fdac8a8cbf9be8c030f75712e6af992102896807d54bc55c24981f24a453c60ad3e8993d693732288068a23df3d9f50d4821029e51a5ef5db3137051de8323b001749932f2ff0d34c82e96a2c2461de96ae56c2102a4e1a9638d46923272c266631d94d36bdb03a64ee0e14c7518e49d2f29bc401021031c41fdbcebe17bec8d49816e00ca1b5ac34766b91c9f2ac37d39c63e5e008afb2103079e252e85abffd3c401a69b087e590a9b86f33f574f08129ccbd3521ecf516b2103111cf405b627e22135b3b3733a4a34aa5723fb0f58379a16d32861bf576b0ec2210318f331b3e5d38156da6633b31929c5b220349859cc9ca3d33fb4e68aa08401742103230dae6b4ac93480aeab26d000841298e3b8f6157028e47b0897c1e025165de121035abff4281ff00660f99ab27bb53e6b33689c2cd8dcd364bc3c90ca5aea0d71a62103bd45cddfacf2083b14310ae4a84e25de61e451637346325222747b157446614c2103cc297026b06c71cbfa52089149157b5ff23de027ac5ab781800a578192d175462103d3bde5d63bdb3a6379b461be64dad45eabff42f758543a9645afd42f6d4248282103ed1e8d5109c9ed66f7941bc53cc71137baa76d50d274bda8d5e8ffbd6e61fe9a5fae736402c00fb269522103aab896d53a8e7d6433137bbba940f9c521e085dd07e60994579b64a6d992cf79210291b7d0b1b692f8f524516ed950872e5da10fb1b808b5a526dedc6fed1cf29807210386aa9372fbab374593466bc5451dc59954e90787f08060964d95c87ef34ca5bb53ae68") 277 assert_equal(res["segwit"]["desc"], "wsh(or_d(multi(11,020e0338c96a8870479f2396c373cc7696ba124e8635d41b0ea581112b67817261,02675333a4e4b8fb51d9d4e22fa5a8eaced3fdac8a8cbf9be8c030f75712e6af99,02896807d54bc55c24981f24a453c60ad3e8993d693732288068a23df3d9f50d48,029e51a5ef5db3137051de8323b001749932f2ff0d34c82e96a2c2461de96ae56c,02a4e1a9638d46923272c266631d94d36bdb03a64ee0e14c7518e49d2f29bc4010,031c41fdbcebe17bec8d49816e00ca1b5ac34766b91c9f2ac37d39c63e5e008afb,03079e252e85abffd3c401a69b087e590a9b86f33f574f08129ccbd3521ecf516b,03111cf405b627e22135b3b3733a4a34aa5723fb0f58379a16d32861bf576b0ec2,0318f331b3e5d38156da6633b31929c5b220349859cc9ca3d33fb4e68aa0840174,03230dae6b4ac93480aeab26d000841298e3b8f6157028e47b0897c1e025165de1,035abff4281ff00660f99ab27bb53e6b33689c2cd8dcd364bc3c90ca5aea0d71a6,03bd45cddfacf2083b14310ae4a84e25de61e451637346325222747b157446614c,03cc297026b06c71cbfa52089149157b5ff23de027ac5ab781800a578192d17546,03d3bde5d63bdb3a6379b461be64dad45eabff42f758543a9645afd42f6d424828,03ed1e8d5109c9ed66f7941bc53cc71137baa76d50d274bda8d5e8ffbd6e61fe9a),and_v(v:older(4032),multi(2,03aab896d53a8e7d6433137bbba940f9c521e085dd07e60994579b64a6d992cf79,0291b7d0b1b692f8f524516ed950872e5da10fb1b808b5a526dedc6fed1cf29807,0386aa9372fbab374593466bc5451dc59954e90787f08060964d95c87ef34ca5bb))))#7jwwklk4") 278 279 def run_test(self): 280 self.log.info("Test decoding of standard input scripts [scriptSig]") 281 self.decodescript_script_sig() 282 self.log.info("Test decoding of standard output scripts [scriptPubKey]") 283 self.decodescript_script_pub_key() 284 self.log.info("Test 'asm' script decoding of transactions") 285 self.decoderawtransaction_asm_sighashtype() 286 self.log.info("Data-driven tests") 287 self.decodescript_datadriven_tests() 288 self.log.info("Miniscript descriptor decoding") 289 self.decodescript_miniscript() 290 291 if __name__ == '__main__': 292 DecodeScriptTest().main()