You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

segwit.py 39KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633
  1. #!/usr/bin/env python3
  2. # Copyright (c) 2016 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 the SegWit changeover logic."""
  6. from test_framework.test_framework import BitcoinTestFramework
  7. from test_framework.util import *
  8. from test_framework.mininode import sha256, CTransaction, CTxIn, COutPoint, CTxOut, COIN, ToHex, FromHex
  9. from test_framework.address import script_to_p2sh, key_to_p2pkh
  10. from test_framework.script import CScript, OP_HASH160, OP_CHECKSIG, OP_0, hash160, OP_EQUAL, OP_DUP, OP_EQUALVERIFY, OP_1, OP_2, OP_CHECKMULTISIG, OP_TRUE
  11. from io import BytesIO
  12. NODE_0 = 0
  13. NODE_1 = 1
  14. NODE_2 = 2
  15. WIT_V0 = 0
  16. WIT_V1 = 1
  17. # Create a scriptPubKey corresponding to either a P2WPKH output for the
  18. # given pubkey, or a P2WSH output of a 1-of-1 multisig for the given
  19. # pubkey. Returns the hex encoding of the scriptPubKey.
  20. def witness_script(use_p2wsh, pubkey):
  21. if (use_p2wsh == False):
  22. # P2WPKH instead
  23. pubkeyhash = hash160(hex_str_to_bytes(pubkey))
  24. pkscript = CScript([OP_0, pubkeyhash])
  25. else:
  26. # 1-of-1 multisig
  27. witness_program = CScript([OP_1, hex_str_to_bytes(pubkey), OP_1, OP_CHECKMULTISIG])
  28. scripthash = sha256(witness_program)
  29. pkscript = CScript([OP_0, scripthash])
  30. return bytes_to_hex_str(pkscript)
  31. # Return a transaction (in hex) that spends the given utxo to a segwit output,
  32. # optionally wrapping the segwit output using P2SH.
  33. def create_witnessprogram(use_p2wsh, utxo, pubkey, encode_p2sh, amount):
  34. pkscript = hex_str_to_bytes(witness_script(use_p2wsh, pubkey))
  35. if (encode_p2sh):
  36. p2sh_hash = hash160(pkscript)
  37. pkscript = CScript([OP_HASH160, p2sh_hash, OP_EQUAL])
  38. tx = CTransaction()
  39. tx.vin.append(CTxIn(COutPoint(int(utxo["txid"], 16), utxo["vout"]), b""))
  40. tx.vout.append(CTxOut(int(amount*COIN), pkscript))
  41. return ToHex(tx)
  42. # Create a transaction spending a given utxo to a segwit output corresponding
  43. # to the given pubkey: use_p2wsh determines whether to use P2WPKH or P2WSH;
  44. # encode_p2sh determines whether to wrap in P2SH.
  45. # sign=True will have the given node sign the transaction.
  46. # insert_redeem_script will be added to the scriptSig, if given.
  47. def send_to_witness(use_p2wsh, node, utxo, pubkey, encode_p2sh, amount, sign=True, insert_redeem_script=""):
  48. tx_to_witness = create_witnessprogram(use_p2wsh, utxo, pubkey, encode_p2sh, amount)
  49. if (sign):
  50. signed = node.signrawtransaction(tx_to_witness)
  51. assert("errors" not in signed or len(["errors"]) == 0)
  52. return node.sendrawtransaction(signed["hex"])
  53. else:
  54. if (insert_redeem_script):
  55. tx = FromHex(CTransaction(), tx_to_witness)
  56. tx.vin[0].scriptSig += CScript([hex_str_to_bytes(insert_redeem_script)])
  57. tx_to_witness = ToHex(tx)
  58. return node.sendrawtransaction(tx_to_witness)
  59. def getutxo(txid):
  60. utxo = {}
  61. utxo["vout"] = 0
  62. utxo["txid"] = txid
  63. return utxo
  64. def find_unspent(node, min_value):
  65. for utxo in node.listunspent():
  66. if utxo['amount'] >= min_value:
  67. return utxo
  68. class SegWitTest(BitcoinTestFramework):
  69. def set_test_params(self):
  70. self.setup_clean_chain = True
  71. self.num_nodes = 3
  72. self.extra_args = [["-walletprematurewitness", "-rpcserialversion=0"],
  73. ["-blockversion=4", "-promiscuousmempoolflags=517", "-prematurewitness", "-walletprematurewitness", "-rpcserialversion=1"],
  74. ["-blockversion=536870915", "-promiscuousmempoolflags=517", "-prematurewitness", "-walletprematurewitness"]]
  75. def setup_network(self):
  76. super().setup_network()
  77. connect_nodes(self.nodes[0], 2)
  78. self.sync_all()
  79. def success_mine(self, node, txid, sign, redeem_script=""):
  80. send_to_witness(1, node, getutxo(txid), self.pubkey[0], False, Decimal("49.998"), sign, redeem_script)
  81. block = node.generate(1)
  82. assert_equal(len(node.getblock(block[0])["tx"]), 2)
  83. sync_blocks(self.nodes)
  84. def skip_mine(self, node, txid, sign, redeem_script=""):
  85. send_to_witness(1, node, getutxo(txid), self.pubkey[0], False, Decimal("49.998"), sign, redeem_script)
  86. block = node.generate(1)
  87. assert_equal(len(node.getblock(block[0])["tx"]), 1)
  88. sync_blocks(self.nodes)
  89. def fail_accept(self, node, error_msg, txid, sign, redeem_script=""):
  90. assert_raises_rpc_error(-26, error_msg, send_to_witness, 1, node, getutxo(txid), self.pubkey[0], False, Decimal("49.998"), sign, redeem_script)
  91. def fail_mine(self, node, txid, sign, redeem_script=""):
  92. send_to_witness(1, node, getutxo(txid), self.pubkey[0], False, Decimal("49.998"), sign, redeem_script)
  93. assert_raises_rpc_error(-1, "CreateNewBlock: TestBlockValidity failed", node.generate, 1)
  94. sync_blocks(self.nodes)
  95. def run_test(self):
  96. self.nodes[0].generate(161) #block 161
  97. self.log.info("Verify sigops are counted in GBT with pre-BIP141 rules before the fork")
  98. txid = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), 1)
  99. tmpl = self.nodes[0].getblocktemplate({})
  100. assert(tmpl['sizelimit'] == 1000000)
  101. assert('weightlimit' not in tmpl)
  102. assert(tmpl['sigoplimit'] == 20000)
  103. assert(tmpl['transactions'][0]['hash'] == txid)
  104. assert(tmpl['transactions'][0]['sigops'] == 2)
  105. tmpl = self.nodes[0].getblocktemplate({'rules':['segwit']})
  106. assert(tmpl['sizelimit'] == 1000000)
  107. assert('weightlimit' not in tmpl)
  108. assert(tmpl['sigoplimit'] == 20000)
  109. assert(tmpl['transactions'][0]['hash'] == txid)
  110. assert(tmpl['transactions'][0]['sigops'] == 2)
  111. self.nodes[0].generate(1) #block 162
  112. balance_presetup = self.nodes[0].getbalance()
  113. self.pubkey = []
  114. p2sh_ids = [] # p2sh_ids[NODE][VER] is an array of txids that spend to a witness version VER pkscript to an address for NODE embedded in p2sh
  115. wit_ids = [] # wit_ids[NODE][VER] is an array of txids that spend to a witness version VER pkscript to an address for NODE via bare witness
  116. for i in range(3):
  117. newaddress = self.nodes[i].getnewaddress()
  118. self.pubkey.append(self.nodes[i].validateaddress(newaddress)["pubkey"])
  119. multiaddress = self.nodes[i].addmultisigaddress(1, [self.pubkey[-1]])
  120. self.nodes[i].addwitnessaddress(newaddress)
  121. self.nodes[i].addwitnessaddress(multiaddress)
  122. p2sh_ids.append([])
  123. wit_ids.append([])
  124. for v in range(2):
  125. p2sh_ids[i].append([])
  126. wit_ids[i].append([])
  127. for i in range(5):
  128. for n in range(3):
  129. for v in range(2):
  130. wit_ids[n][v].append(send_to_witness(v, self.nodes[0], find_unspent(self.nodes[0], 50), self.pubkey[n], False, Decimal("49.999")))
  131. p2sh_ids[n][v].append(send_to_witness(v, self.nodes[0], find_unspent(self.nodes[0], 50), self.pubkey[n], True, Decimal("49.999")))
  132. self.nodes[0].generate(1) #block 163
  133. sync_blocks(self.nodes)
  134. # Make sure all nodes recognize the transactions as theirs
  135. assert_equal(self.nodes[0].getbalance(), balance_presetup - 60*50 + 20*Decimal("49.999") + 50)
  136. assert_equal(self.nodes[1].getbalance(), 20*Decimal("49.999"))
  137. assert_equal(self.nodes[2].getbalance(), 20*Decimal("49.999"))
  138. self.nodes[0].generate(260) #block 423
  139. sync_blocks(self.nodes)
  140. self.log.info("Verify default node can't accept any witness format txs before fork")
  141. # unsigned, no scriptsig
  142. self.fail_accept(self.nodes[0], "mandatory-script-verify-flag", wit_ids[NODE_0][WIT_V0][0], False)
  143. self.fail_accept(self.nodes[0], "mandatory-script-verify-flag", wit_ids[NODE_0][WIT_V1][0], False)
  144. self.fail_accept(self.nodes[0], "mandatory-script-verify-flag", p2sh_ids[NODE_0][WIT_V0][0], False)
  145. self.fail_accept(self.nodes[0], "mandatory-script-verify-flag", p2sh_ids[NODE_0][WIT_V1][0], False)
  146. # unsigned with redeem script
  147. self.fail_accept(self.nodes[0], "mandatory-script-verify-flag", p2sh_ids[NODE_0][WIT_V0][0], False, witness_script(False, self.pubkey[0]))
  148. self.fail_accept(self.nodes[0], "mandatory-script-verify-flag", p2sh_ids[NODE_0][WIT_V1][0], False, witness_script(True, self.pubkey[0]))
  149. # signed
  150. self.fail_accept(self.nodes[0], "no-witness-yet", wit_ids[NODE_0][WIT_V0][0], True)
  151. self.fail_accept(self.nodes[0], "no-witness-yet", wit_ids[NODE_0][WIT_V1][0], True)
  152. self.fail_accept(self.nodes[0], "no-witness-yet", p2sh_ids[NODE_0][WIT_V0][0], True)
  153. self.fail_accept(self.nodes[0], "no-witness-yet", p2sh_ids[NODE_0][WIT_V1][0], True)
  154. self.log.info("Verify witness txs are skipped for mining before the fork")
  155. self.skip_mine(self.nodes[2], wit_ids[NODE_2][WIT_V0][0], True) #block 424
  156. self.skip_mine(self.nodes[2], wit_ids[NODE_2][WIT_V1][0], True) #block 425
  157. self.skip_mine(self.nodes[2], p2sh_ids[NODE_2][WIT_V0][0], True) #block 426
  158. self.skip_mine(self.nodes[2], p2sh_ids[NODE_2][WIT_V1][0], True) #block 427
  159. # TODO: An old node would see these txs without witnesses and be able to mine them
  160. self.log.info("Verify unsigned bare witness txs in versionbits-setting blocks are valid before the fork")
  161. self.success_mine(self.nodes[2], wit_ids[NODE_2][WIT_V0][1], False) #block 428
  162. self.success_mine(self.nodes[2], wit_ids[NODE_2][WIT_V1][1], False) #block 429
  163. self.log.info("Verify unsigned p2sh witness txs without a redeem script are invalid")
  164. self.fail_accept(self.nodes[2], "mandatory-script-verify-flag", p2sh_ids[NODE_2][WIT_V0][1], False)
  165. self.fail_accept(self.nodes[2], "mandatory-script-verify-flag", p2sh_ids[NODE_2][WIT_V1][1], False)
  166. self.log.info("Verify unsigned p2sh witness txs with a redeem script in versionbits-settings blocks are valid before the fork")
  167. self.success_mine(self.nodes[2], p2sh_ids[NODE_2][WIT_V0][1], False, witness_script(False, self.pubkey[2])) #block 430
  168. self.success_mine(self.nodes[2], p2sh_ids[NODE_2][WIT_V1][1], False, witness_script(True, self.pubkey[2])) #block 431
  169. self.log.info("Verify previous witness txs skipped for mining can now be mined")
  170. assert_equal(len(self.nodes[2].getrawmempool()), 4)
  171. block = self.nodes[2].generate(1) #block 432 (first block with new rules; 432 = 144 * 3)
  172. sync_blocks(self.nodes)
  173. assert_equal(len(self.nodes[2].getrawmempool()), 0)
  174. segwit_tx_list = self.nodes[2].getblock(block[0])["tx"]
  175. assert_equal(len(segwit_tx_list), 5)
  176. self.log.info("Verify block and transaction serialization rpcs return differing serializations depending on rpc serialization flag")
  177. assert(self.nodes[2].getblock(block[0], False) != self.nodes[0].getblock(block[0], False))
  178. assert(self.nodes[1].getblock(block[0], False) == self.nodes[2].getblock(block[0], False))
  179. for i in range(len(segwit_tx_list)):
  180. tx = FromHex(CTransaction(), self.nodes[2].gettransaction(segwit_tx_list[i])["hex"])
  181. assert(self.nodes[2].getrawtransaction(segwit_tx_list[i]) != self.nodes[0].getrawtransaction(segwit_tx_list[i]))
  182. assert(self.nodes[1].getrawtransaction(segwit_tx_list[i], 0) == self.nodes[2].getrawtransaction(segwit_tx_list[i]))
  183. assert(self.nodes[0].getrawtransaction(segwit_tx_list[i]) != self.nodes[2].gettransaction(segwit_tx_list[i])["hex"])
  184. assert(self.nodes[1].getrawtransaction(segwit_tx_list[i]) == self.nodes[2].gettransaction(segwit_tx_list[i])["hex"])
  185. assert(self.nodes[0].getrawtransaction(segwit_tx_list[i]) == bytes_to_hex_str(tx.serialize_without_witness()))
  186. self.log.info("Verify witness txs without witness data are invalid after the fork")
  187. self.fail_mine(self.nodes[2], wit_ids[NODE_2][WIT_V0][2], False)
  188. self.fail_mine(self.nodes[2], wit_ids[NODE_2][WIT_V1][2], False)
  189. self.fail_mine(self.nodes[2], p2sh_ids[NODE_2][WIT_V0][2], False, witness_script(False, self.pubkey[2]))
  190. self.fail_mine(self.nodes[2], p2sh_ids[NODE_2][WIT_V1][2], False, witness_script(True, self.pubkey[2]))
  191. self.log.info("Verify default node can now use witness txs")
  192. self.success_mine(self.nodes[0], wit_ids[NODE_0][WIT_V0][0], True) #block 432
  193. self.success_mine(self.nodes[0], wit_ids[NODE_0][WIT_V1][0], True) #block 433
  194. self.success_mine(self.nodes[0], p2sh_ids[NODE_0][WIT_V0][0], True) #block 434
  195. self.success_mine(self.nodes[0], p2sh_ids[NODE_0][WIT_V1][0], True) #block 435
  196. self.log.info("Verify sigops are counted in GBT with BIP141 rules after the fork")
  197. txid = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), 1)
  198. tmpl = self.nodes[0].getblocktemplate({'rules':['segwit']})
  199. assert(tmpl['sizelimit'] >= 3999577) # actual maximum size is lower due to minimum mandatory non-witness data
  200. assert(tmpl['weightlimit'] == 4000000)
  201. assert(tmpl['sigoplimit'] == 80000)
  202. assert(tmpl['transactions'][0]['txid'] == txid)
  203. assert(tmpl['transactions'][0]['sigops'] == 8)
  204. self.nodes[0].generate(1) # Mine a block to clear the gbt cache
  205. self.log.info("Non-segwit miners are able to use GBT response after activation.")
  206. # Create a 3-tx chain: tx1 (non-segwit input, paying to a segwit output) ->
  207. # tx2 (segwit input, paying to a non-segwit output) ->
  208. # tx3 (non-segwit input, paying to a non-segwit output).
  209. # tx1 is allowed to appear in the block, but no others.
  210. txid1 = send_to_witness(1, self.nodes[0], find_unspent(self.nodes[0], 50), self.pubkey[0], False, Decimal("49.996"))
  211. hex_tx = self.nodes[0].gettransaction(txid)['hex']
  212. tx = FromHex(CTransaction(), hex_tx)
  213. assert(tx.wit.is_null()) # This should not be a segwit input
  214. assert(txid1 in self.nodes[0].getrawmempool())
  215. # Now create tx2, which will spend from txid1.
  216. tx = CTransaction()
  217. tx.vin.append(CTxIn(COutPoint(int(txid1, 16), 0), b''))
  218. tx.vout.append(CTxOut(int(49.99*COIN), CScript([OP_TRUE])))
  219. tx2_hex = self.nodes[0].signrawtransaction(ToHex(tx))['hex']
  220. txid2 = self.nodes[0].sendrawtransaction(tx2_hex)
  221. tx = FromHex(CTransaction(), tx2_hex)
  222. assert(not tx.wit.is_null())
  223. # Now create tx3, which will spend from txid2
  224. tx = CTransaction()
  225. tx.vin.append(CTxIn(COutPoint(int(txid2, 16), 0), b""))
  226. tx.vout.append(CTxOut(int(49.95*COIN), CScript([OP_TRUE]))) # Huge fee
  227. tx.calc_sha256()
  228. txid3 = self.nodes[0].sendrawtransaction(ToHex(tx))
  229. assert(tx.wit.is_null())
  230. assert(txid3 in self.nodes[0].getrawmempool())
  231. # Now try calling getblocktemplate() without segwit support.
  232. template = self.nodes[0].getblocktemplate()
  233. # Check that tx1 is the only transaction of the 3 in the template.
  234. template_txids = [ t['txid'] for t in template['transactions'] ]
  235. assert(txid2 not in template_txids and txid3 not in template_txids)
  236. assert(txid1 in template_txids)
  237. # Check that running with segwit support results in all 3 being included.
  238. template = self.nodes[0].getblocktemplate({"rules": ["segwit"]})
  239. template_txids = [ t['txid'] for t in template['transactions'] ]
  240. assert(txid1 in template_txids)
  241. assert(txid2 in template_txids)
  242. assert(txid3 in template_txids)
  243. # Mine a block to clear the gbt cache again.
  244. self.nodes[0].generate(1)
  245. self.log.info("Verify behaviour of importaddress, addwitnessaddress and listunspent")
  246. # Some public keys to be used later
  247. pubkeys = [
  248. "0363D44AABD0F1699138239DF2F042C3282C0671CC7A76826A55C8203D90E39242", # cPiM8Ub4heR9NBYmgVzJQiUH1if44GSBGiqaeJySuL2BKxubvgwb
  249. "02D3E626B3E616FC8662B489C123349FECBFC611E778E5BE739B257EAE4721E5BF", # cPpAdHaD6VoYbW78kveN2bsvb45Q7G5PhaPApVUGwvF8VQ9brD97
  250. "04A47F2CBCEFFA7B9BCDA184E7D5668D3DA6F9079AD41E422FA5FD7B2D458F2538A62F5BD8EC85C2477F39650BD391EA6250207065B2A81DA8B009FC891E898F0E", # 91zqCU5B9sdWxzMt1ca3VzbtVm2YM6Hi5Rxn4UDtxEaN9C9nzXV
  251. "02A47F2CBCEFFA7B9BCDA184E7D5668D3DA6F9079AD41E422FA5FD7B2D458F2538", # cPQFjcVRpAUBG8BA9hzr2yEzHwKoMgLkJZBBtK9vJnvGJgMjzTbd
  252. "036722F784214129FEB9E8129D626324F3F6716555B603FFE8300BBCB882151228", # cQGtcm34xiLjB1v7bkRa4V3aAc9tS2UTuBZ1UnZGeSeNy627fN66
  253. "0266A8396EE936BF6D99D17920DB21C6C7B1AB14C639D5CD72B300297E416FD2EC", # cTW5mR5M45vHxXkeChZdtSPozrFwFgmEvTNnanCW6wrqwaCZ1X7K
  254. "0450A38BD7F0AC212FEBA77354A9B036A32E0F7C81FC4E0C5ADCA7C549C4505D2522458C2D9AE3CEFD684E039194B72C8A10F9CB9D4764AB26FCC2718D421D3B84", # 92h2XPssjBpsJN5CqSP7v9a7cf2kgDunBC6PDFwJHMACM1rrVBJ
  255. ]
  256. # Import a compressed key and an uncompressed key, generate some multisig addresses
  257. self.nodes[0].importprivkey("92e6XLo5jVAVwrQKPNTs93oQco8f8sDNBcpv73Dsrs397fQtFQn")
  258. uncompressed_spendable_address = ["mvozP4UwyGD2mGZU4D2eMvMLPB9WkMmMQu"]
  259. self.nodes[0].importprivkey("cNC8eQ5dg3mFAVePDX4ddmPYpPbw41r9bm2jd1nLJT77e6RrzTRR")
  260. compressed_spendable_address = ["mmWQubrDomqpgSYekvsU7HWEVjLFHAakLe"]
  261. assert ((self.nodes[0].validateaddress(uncompressed_spendable_address[0])['iscompressed'] == False))
  262. assert ((self.nodes[0].validateaddress(compressed_spendable_address[0])['iscompressed'] == True))
  263. self.nodes[0].importpubkey(pubkeys[0])
  264. compressed_solvable_address = [key_to_p2pkh(pubkeys[0])]
  265. self.nodes[0].importpubkey(pubkeys[1])
  266. compressed_solvable_address.append(key_to_p2pkh(pubkeys[1]))
  267. self.nodes[0].importpubkey(pubkeys[2])
  268. uncompressed_solvable_address = [key_to_p2pkh(pubkeys[2])]
  269. spendable_anytime = [] # These outputs should be seen anytime after importprivkey and addmultisigaddress
  270. spendable_after_importaddress = [] # These outputs should be seen after importaddress
  271. solvable_after_importaddress = [] # These outputs should be seen after importaddress but not spendable
  272. unsolvable_after_importaddress = [] # These outputs should be unsolvable after importaddress
  273. solvable_anytime = [] # These outputs should be solvable after importpubkey
  274. unseen_anytime = [] # These outputs should never be seen
  275. uncompressed_spendable_address.append(self.nodes[0].addmultisigaddress(2, [uncompressed_spendable_address[0], compressed_spendable_address[0]]))
  276. uncompressed_spendable_address.append(self.nodes[0].addmultisigaddress(2, [uncompressed_spendable_address[0], uncompressed_spendable_address[0]]))
  277. compressed_spendable_address.append(self.nodes[0].addmultisigaddress(2, [compressed_spendable_address[0], compressed_spendable_address[0]]))
  278. uncompressed_solvable_address.append(self.nodes[0].addmultisigaddress(2, [compressed_spendable_address[0], uncompressed_solvable_address[0]]))
  279. compressed_solvable_address.append(self.nodes[0].addmultisigaddress(2, [compressed_spendable_address[0], compressed_solvable_address[0]]))
  280. compressed_solvable_address.append(self.nodes[0].addmultisigaddress(2, [compressed_solvable_address[0], compressed_solvable_address[1]]))
  281. unknown_address = ["mtKKyoHabkk6e4ppT7NaM7THqPUt7AzPrT", "2NDP3jLWAFT8NDAiUa9qiE6oBt2awmMq7Dx"]
  282. # Test multisig_without_privkey
  283. # We have 2 public keys without private keys, use addmultisigaddress to add to wallet.
  284. # Money sent to P2SH of multisig of this should only be seen after importaddress with the BASE58 P2SH address.
  285. multisig_without_privkey_address = self.nodes[0].addmultisigaddress(2, [pubkeys[3], pubkeys[4]])
  286. script = CScript([OP_2, hex_str_to_bytes(pubkeys[3]), hex_str_to_bytes(pubkeys[4]), OP_2, OP_CHECKMULTISIG])
  287. solvable_after_importaddress.append(CScript([OP_HASH160, hash160(script), OP_EQUAL]))
  288. for i in compressed_spendable_address:
  289. v = self.nodes[0].validateaddress(i)
  290. if (v['isscript']):
  291. [bare, p2sh, p2wsh, p2sh_p2wsh] = self.p2sh_address_to_script(v)
  292. # bare and p2sh multisig with compressed keys should always be spendable
  293. spendable_anytime.extend([bare, p2sh])
  294. # P2WSH and P2SH(P2WSH) multisig with compressed keys are spendable after direct importaddress
  295. spendable_after_importaddress.extend([p2wsh, p2sh_p2wsh])
  296. else:
  297. [p2wpkh, p2sh_p2wpkh, p2pk, p2pkh, p2sh_p2pk, p2sh_p2pkh, p2wsh_p2pk, p2wsh_p2pkh, p2sh_p2wsh_p2pk, p2sh_p2wsh_p2pkh] = self.p2pkh_address_to_script(v)
  298. # normal P2PKH and P2PK with compressed keys should always be spendable
  299. spendable_anytime.extend([p2pkh, p2pk])
  300. # P2SH_P2PK, P2SH_P2PKH, and witness with compressed keys are spendable after direct importaddress
  301. spendable_after_importaddress.extend([p2wpkh, p2sh_p2wpkh, p2sh_p2pk, p2sh_p2pkh, p2wsh_p2pk, p2wsh_p2pkh, p2sh_p2wsh_p2pk, p2sh_p2wsh_p2pkh])
  302. for i in uncompressed_spendable_address:
  303. v = self.nodes[0].validateaddress(i)
  304. if (v['isscript']):
  305. [bare, p2sh, p2wsh, p2sh_p2wsh] = self.p2sh_address_to_script(v)
  306. # bare and p2sh multisig with uncompressed keys should always be spendable
  307. spendable_anytime.extend([bare, p2sh])
  308. # P2WSH and P2SH(P2WSH) multisig with uncompressed keys are never seen
  309. unseen_anytime.extend([p2wsh, p2sh_p2wsh])
  310. else:
  311. [p2wpkh, p2sh_p2wpkh, p2pk, p2pkh, p2sh_p2pk, p2sh_p2pkh, p2wsh_p2pk, p2wsh_p2pkh, p2sh_p2wsh_p2pk, p2sh_p2wsh_p2pkh] = self.p2pkh_address_to_script(v)
  312. # normal P2PKH and P2PK with uncompressed keys should always be spendable
  313. spendable_anytime.extend([p2pkh, p2pk])
  314. # P2SH_P2PK and P2SH_P2PKH are spendable after direct importaddress
  315. spendable_after_importaddress.extend([p2sh_p2pk, p2sh_p2pkh])
  316. # witness with uncompressed keys are never seen
  317. unseen_anytime.extend([p2wpkh, p2sh_p2wpkh, p2wsh_p2pk, p2wsh_p2pkh, p2sh_p2wsh_p2pk, p2sh_p2wsh_p2pkh])
  318. for i in compressed_solvable_address:
  319. v = self.nodes[0].validateaddress(i)
  320. if (v['isscript']):
  321. # Multisig without private is not seen after addmultisigaddress, but seen after importaddress
  322. [bare, p2sh, p2wsh, p2sh_p2wsh] = self.p2sh_address_to_script(v)
  323. solvable_after_importaddress.extend([bare, p2sh, p2wsh, p2sh_p2wsh])
  324. else:
  325. [p2wpkh, p2sh_p2wpkh, p2pk, p2pkh, p2sh_p2pk, p2sh_p2pkh, p2wsh_p2pk, p2wsh_p2pkh, p2sh_p2wsh_p2pk, p2sh_p2wsh_p2pkh] = self.p2pkh_address_to_script(v)
  326. # normal P2PKH and P2PK with compressed keys should always be seen
  327. solvable_anytime.extend([p2pkh, p2pk])
  328. # P2SH_P2PK, P2SH_P2PKH, and witness with compressed keys are seen after direct importaddress
  329. solvable_after_importaddress.extend([p2wpkh, p2sh_p2wpkh, p2sh_p2pk, p2sh_p2pkh, p2wsh_p2pk, p2wsh_p2pkh, p2sh_p2wsh_p2pk, p2sh_p2wsh_p2pkh])
  330. for i in uncompressed_solvable_address:
  331. v = self.nodes[0].validateaddress(i)
  332. if (v['isscript']):
  333. [bare, p2sh, p2wsh, p2sh_p2wsh] = self.p2sh_address_to_script(v)
  334. # Base uncompressed multisig without private is not seen after addmultisigaddress, but seen after importaddress
  335. solvable_after_importaddress.extend([bare, p2sh])
  336. # P2WSH and P2SH(P2WSH) multisig with uncompressed keys are never seen
  337. unseen_anytime.extend([p2wsh, p2sh_p2wsh])
  338. else:
  339. [p2wpkh, p2sh_p2wpkh, p2pk, p2pkh, p2sh_p2pk, p2sh_p2pkh, p2wsh_p2pk, p2wsh_p2pkh, p2sh_p2wsh_p2pk, p2sh_p2wsh_p2pkh] = self.p2pkh_address_to_script(v)
  340. # normal P2PKH and P2PK with uncompressed keys should always be seen
  341. solvable_anytime.extend([p2pkh, p2pk])
  342. # P2SH_P2PK, P2SH_P2PKH with uncompressed keys are seen after direct importaddress
  343. solvable_after_importaddress.extend([p2sh_p2pk, p2sh_p2pkh])
  344. # witness with uncompressed keys are never seen
  345. unseen_anytime.extend([p2wpkh, p2sh_p2wpkh, p2wsh_p2pk, p2wsh_p2pkh, p2sh_p2wsh_p2pk, p2sh_p2wsh_p2pkh])
  346. op1 = CScript([OP_1])
  347. op0 = CScript([OP_0])
  348. # 2N7MGY19ti4KDMSzRfPAssP6Pxyuxoi6jLe is the P2SH(P2PKH) version of mjoE3sSrb8ByYEvgnC3Aox86u1CHnfJA4V
  349. unsolvable_address = ["mjoE3sSrb8ByYEvgnC3Aox86u1CHnfJA4V", "2N7MGY19ti4KDMSzRfPAssP6Pxyuxoi6jLe", script_to_p2sh(op1), script_to_p2sh(op0)]
  350. unsolvable_address_key = hex_str_to_bytes("02341AEC7587A51CDE5279E0630A531AEA2615A9F80B17E8D9376327BAEAA59E3D")
  351. unsolvablep2pkh = CScript([OP_DUP, OP_HASH160, hash160(unsolvable_address_key), OP_EQUALVERIFY, OP_CHECKSIG])
  352. unsolvablep2wshp2pkh = CScript([OP_0, sha256(unsolvablep2pkh)])
  353. p2shop0 = CScript([OP_HASH160, hash160(op0), OP_EQUAL])
  354. p2wshop1 = CScript([OP_0, sha256(op1)])
  355. unsolvable_after_importaddress.append(unsolvablep2pkh)
  356. unsolvable_after_importaddress.append(unsolvablep2wshp2pkh)
  357. unsolvable_after_importaddress.append(op1) # OP_1 will be imported as script
  358. unsolvable_after_importaddress.append(p2wshop1)
  359. unseen_anytime.append(op0) # OP_0 will be imported as P2SH address with no script provided
  360. unsolvable_after_importaddress.append(p2shop0)
  361. spendable_txid = []
  362. solvable_txid = []
  363. spendable_txid.append(self.mine_and_test_listunspent(spendable_anytime, 2))
  364. solvable_txid.append(self.mine_and_test_listunspent(solvable_anytime, 1))
  365. self.mine_and_test_listunspent(spendable_after_importaddress + solvable_after_importaddress + unseen_anytime + unsolvable_after_importaddress, 0)
  366. importlist = []
  367. for i in compressed_spendable_address + uncompressed_spendable_address + compressed_solvable_address + uncompressed_solvable_address:
  368. v = self.nodes[0].validateaddress(i)
  369. if (v['isscript']):
  370. bare = hex_str_to_bytes(v['hex'])
  371. importlist.append(bytes_to_hex_str(bare))
  372. importlist.append(bytes_to_hex_str(CScript([OP_0, sha256(bare)])))
  373. else:
  374. pubkey = hex_str_to_bytes(v['pubkey'])
  375. p2pk = CScript([pubkey, OP_CHECKSIG])
  376. p2pkh = CScript([OP_DUP, OP_HASH160, hash160(pubkey), OP_EQUALVERIFY, OP_CHECKSIG])
  377. importlist.append(bytes_to_hex_str(p2pk))
  378. importlist.append(bytes_to_hex_str(p2pkh))
  379. importlist.append(bytes_to_hex_str(CScript([OP_0, hash160(pubkey)])))
  380. importlist.append(bytes_to_hex_str(CScript([OP_0, sha256(p2pk)])))
  381. importlist.append(bytes_to_hex_str(CScript([OP_0, sha256(p2pkh)])))
  382. importlist.append(bytes_to_hex_str(unsolvablep2pkh))
  383. importlist.append(bytes_to_hex_str(unsolvablep2wshp2pkh))
  384. importlist.append(bytes_to_hex_str(op1))
  385. importlist.append(bytes_to_hex_str(p2wshop1))
  386. for i in importlist:
  387. # import all generated addresses. The wallet already has the private keys for some of these, so catch JSON RPC
  388. # exceptions and continue.
  389. try_rpc(-4, "The wallet already contains the private key for this address or script", self.nodes[0].importaddress, i, "", False, True)
  390. self.nodes[0].importaddress(script_to_p2sh(op0)) # import OP_0 as address only
  391. self.nodes[0].importaddress(multisig_without_privkey_address) # Test multisig_without_privkey
  392. spendable_txid.append(self.mine_and_test_listunspent(spendable_anytime + spendable_after_importaddress, 2))
  393. solvable_txid.append(self.mine_and_test_listunspent(solvable_anytime + solvable_after_importaddress, 1))
  394. self.mine_and_test_listunspent(unsolvable_after_importaddress, 1)
  395. self.mine_and_test_listunspent(unseen_anytime, 0)
  396. # addwitnessaddress should refuse to return a witness address if an uncompressed key is used
  397. # note that no witness address should be returned by unsolvable addresses
  398. for i in uncompressed_spendable_address + uncompressed_solvable_address + unknown_address + unsolvable_address:
  399. assert_raises_rpc_error(-4, "Public key or redeemscript not known to wallet, or the key is uncompressed", self.nodes[0].addwitnessaddress, i)
  400. # addwitnessaddress should return a witness addresses even if keys are not in the wallet
  401. self.nodes[0].addwitnessaddress(multisig_without_privkey_address)
  402. for i in compressed_spendable_address + compressed_solvable_address:
  403. witaddress = self.nodes[0].addwitnessaddress(i)
  404. # addwitnessaddress should return the same address if it is a known P2SH-witness address
  405. assert_equal(witaddress, self.nodes[0].addwitnessaddress(witaddress))
  406. spendable_txid.append(self.mine_and_test_listunspent(spendable_anytime + spendable_after_importaddress, 2))
  407. solvable_txid.append(self.mine_and_test_listunspent(solvable_anytime + solvable_after_importaddress, 1))
  408. self.mine_and_test_listunspent(unsolvable_after_importaddress, 1)
  409. self.mine_and_test_listunspent(unseen_anytime, 0)
  410. # Repeat some tests. This time we don't add witness scripts with importaddress
  411. # Import a compressed key and an uncompressed key, generate some multisig addresses
  412. self.nodes[0].importprivkey("927pw6RW8ZekycnXqBQ2JS5nPyo1yRfGNN8oq74HeddWSpafDJH")
  413. uncompressed_spendable_address = ["mguN2vNSCEUh6rJaXoAVwY3YZwZvEmf5xi"]
  414. self.nodes[0].importprivkey("cMcrXaaUC48ZKpcyydfFo8PxHAjpsYLhdsp6nmtB3E2ER9UUHWnw")
  415. compressed_spendable_address = ["n1UNmpmbVUJ9ytXYXiurmGPQ3TRrXqPWKL"]
  416. self.nodes[0].importpubkey(pubkeys[5])
  417. compressed_solvable_address = [key_to_p2pkh(pubkeys[5])]
  418. self.nodes[0].importpubkey(pubkeys[6])
  419. uncompressed_solvable_address = [key_to_p2pkh(pubkeys[6])]
  420. spendable_after_addwitnessaddress = [] # These outputs should be seen after importaddress
  421. solvable_after_addwitnessaddress=[] # These outputs should be seen after importaddress but not spendable
  422. unseen_anytime = [] # These outputs should never be seen
  423. uncompressed_spendable_address.append(self.nodes[0].addmultisigaddress(2, [uncompressed_spendable_address[0], compressed_spendable_address[0]]))
  424. uncompressed_spendable_address.append(self.nodes[0].addmultisigaddress(2, [uncompressed_spendable_address[0], uncompressed_spendable_address[0]]))
  425. compressed_spendable_address.append(self.nodes[0].addmultisigaddress(2, [compressed_spendable_address[0], compressed_spendable_address[0]]))
  426. uncompressed_solvable_address.append(self.nodes[0].addmultisigaddress(2, [compressed_solvable_address[0], uncompressed_solvable_address[0]]))
  427. compressed_solvable_address.append(self.nodes[0].addmultisigaddress(2, [compressed_spendable_address[0], compressed_solvable_address[0]]))
  428. premature_witaddress = []
  429. for i in compressed_spendable_address:
  430. v = self.nodes[0].validateaddress(i)
  431. if (v['isscript']):
  432. [bare, p2sh, p2wsh, p2sh_p2wsh] = self.p2sh_address_to_script(v)
  433. # P2WSH and P2SH(P2WSH) multisig with compressed keys are spendable after addwitnessaddress
  434. spendable_after_addwitnessaddress.extend([p2wsh, p2sh_p2wsh])
  435. premature_witaddress.append(script_to_p2sh(p2wsh))
  436. else:
  437. [p2wpkh, p2sh_p2wpkh, p2pk, p2pkh, p2sh_p2pk, p2sh_p2pkh, p2wsh_p2pk, p2wsh_p2pkh, p2sh_p2wsh_p2pk, p2sh_p2wsh_p2pkh] = self.p2pkh_address_to_script(v)
  438. # P2WPKH, P2SH_P2WPKH are spendable after addwitnessaddress
  439. spendable_after_addwitnessaddress.extend([p2wpkh, p2sh_p2wpkh])
  440. premature_witaddress.append(script_to_p2sh(p2wpkh))
  441. for i in uncompressed_spendable_address + uncompressed_solvable_address:
  442. v = self.nodes[0].validateaddress(i)
  443. if (v['isscript']):
  444. [bare, p2sh, p2wsh, p2sh_p2wsh] = self.p2sh_address_to_script(v)
  445. # P2WSH and P2SH(P2WSH) multisig with uncompressed keys are never seen
  446. unseen_anytime.extend([p2wsh, p2sh_p2wsh])
  447. else:
  448. [p2wpkh, p2sh_p2wpkh, p2pk, p2pkh, p2sh_p2pk, p2sh_p2pkh, p2wsh_p2pk, p2wsh_p2pkh, p2sh_p2wsh_p2pk, p2sh_p2wsh_p2pkh] = self.p2pkh_address_to_script(v)
  449. # P2WPKH, P2SH_P2WPKH with uncompressed keys are never seen
  450. unseen_anytime.extend([p2wpkh, p2sh_p2wpkh])
  451. for i in compressed_solvable_address:
  452. v = self.nodes[0].validateaddress(i)
  453. if (v['isscript']):
  454. # P2WSH multisig without private key are seen after addwitnessaddress
  455. [bare, p2sh, p2wsh, p2sh_p2wsh] = self.p2sh_address_to_script(v)
  456. solvable_after_addwitnessaddress.extend([p2wsh, p2sh_p2wsh])
  457. premature_witaddress.append(script_to_p2sh(p2wsh))
  458. else:
  459. [p2wpkh, p2sh_p2wpkh, p2pk, p2pkh, p2sh_p2pk, p2sh_p2pkh, p2wsh_p2pk, p2wsh_p2pkh, p2sh_p2wsh_p2pk, p2sh_p2wsh_p2pkh] = self.p2pkh_address_to_script(v)
  460. # P2SH_P2PK, P2SH_P2PKH with compressed keys are seen after addwitnessaddress
  461. solvable_after_addwitnessaddress.extend([p2wpkh, p2sh_p2wpkh])
  462. premature_witaddress.append(script_to_p2sh(p2wpkh))
  463. self.mine_and_test_listunspent(spendable_after_addwitnessaddress + solvable_after_addwitnessaddress + unseen_anytime, 0)
  464. # addwitnessaddress should refuse to return a witness address if an uncompressed key is used
  465. # note that a multisig address returned by addmultisigaddress is not solvable until it is added with importaddress
  466. # premature_witaddress are not accepted until the script is added with addwitnessaddress first
  467. for i in uncompressed_spendable_address + uncompressed_solvable_address + premature_witaddress:
  468. # This will raise an exception
  469. assert_raises_rpc_error(-4, "Public key or redeemscript not known to wallet, or the key is uncompressed", self.nodes[0].addwitnessaddress, i)
  470. # after importaddress it should pass addwitnessaddress
  471. v = self.nodes[0].validateaddress(compressed_solvable_address[1])
  472. self.nodes[0].importaddress(v['hex'],"",False,True)
  473. for i in compressed_spendable_address + compressed_solvable_address + premature_witaddress:
  474. witaddress = self.nodes[0].addwitnessaddress(i)
  475. assert_equal(witaddress, self.nodes[0].addwitnessaddress(witaddress))
  476. spendable_txid.append(self.mine_and_test_listunspent(spendable_after_addwitnessaddress, 2))
  477. solvable_txid.append(self.mine_and_test_listunspent(solvable_after_addwitnessaddress, 1))
  478. self.mine_and_test_listunspent(unseen_anytime, 0)
  479. # Check that spendable outputs are really spendable
  480. self.create_and_mine_tx_from_txids(spendable_txid)
  481. # import all the private keys so solvable addresses become spendable
  482. self.nodes[0].importprivkey("cPiM8Ub4heR9NBYmgVzJQiUH1if44GSBGiqaeJySuL2BKxubvgwb")
  483. self.nodes[0].importprivkey("cPpAdHaD6VoYbW78kveN2bsvb45Q7G5PhaPApVUGwvF8VQ9brD97")
  484. self.nodes[0].importprivkey("91zqCU5B9sdWxzMt1ca3VzbtVm2YM6Hi5Rxn4UDtxEaN9C9nzXV")
  485. self.nodes[0].importprivkey("cPQFjcVRpAUBG8BA9hzr2yEzHwKoMgLkJZBBtK9vJnvGJgMjzTbd")
  486. self.nodes[0].importprivkey("cQGtcm34xiLjB1v7bkRa4V3aAc9tS2UTuBZ1UnZGeSeNy627fN66")
  487. self.nodes[0].importprivkey("cTW5mR5M45vHxXkeChZdtSPozrFwFgmEvTNnanCW6wrqwaCZ1X7K")
  488. self.create_and_mine_tx_from_txids(solvable_txid)
  489. def mine_and_test_listunspent(self, script_list, ismine):
  490. utxo = find_unspent(self.nodes[0], 50)
  491. tx = CTransaction()
  492. tx.vin.append(CTxIn(COutPoint(int('0x'+utxo['txid'],0), utxo['vout'])))
  493. for i in script_list:
  494. tx.vout.append(CTxOut(10000000, i))
  495. tx.rehash()
  496. signresults = self.nodes[0].signrawtransaction(bytes_to_hex_str(tx.serialize_without_witness()))['hex']
  497. txid = self.nodes[0].sendrawtransaction(signresults, True)
  498. self.nodes[0].generate(1)
  499. sync_blocks(self.nodes)
  500. watchcount = 0
  501. spendcount = 0
  502. for i in self.nodes[0].listunspent():
  503. if (i['txid'] == txid):
  504. watchcount += 1
  505. if (i['spendable'] == True):
  506. spendcount += 1
  507. if (ismine == 2):
  508. assert_equal(spendcount, len(script_list))
  509. elif (ismine == 1):
  510. assert_equal(watchcount, len(script_list))
  511. assert_equal(spendcount, 0)
  512. else:
  513. assert_equal(watchcount, 0)
  514. return txid
  515. def p2sh_address_to_script(self,v):
  516. bare = CScript(hex_str_to_bytes(v['hex']))
  517. p2sh = CScript(hex_str_to_bytes(v['scriptPubKey']))
  518. p2wsh = CScript([OP_0, sha256(bare)])
  519. p2sh_p2wsh = CScript([OP_HASH160, hash160(p2wsh), OP_EQUAL])
  520. return([bare, p2sh, p2wsh, p2sh_p2wsh])
  521. def p2pkh_address_to_script(self,v):
  522. pubkey = hex_str_to_bytes(v['pubkey'])
  523. p2wpkh = CScript([OP_0, hash160(pubkey)])
  524. p2sh_p2wpkh = CScript([OP_HASH160, hash160(p2wpkh), OP_EQUAL])
  525. p2pk = CScript([pubkey, OP_CHECKSIG])
  526. p2pkh = CScript(hex_str_to_bytes(v['scriptPubKey']))
  527. p2sh_p2pk = CScript([OP_HASH160, hash160(p2pk), OP_EQUAL])
  528. p2sh_p2pkh = CScript([OP_HASH160, hash160(p2pkh), OP_EQUAL])
  529. p2wsh_p2pk = CScript([OP_0, sha256(p2pk)])
  530. p2wsh_p2pkh = CScript([OP_0, sha256(p2pkh)])
  531. p2sh_p2wsh_p2pk = CScript([OP_HASH160, hash160(p2wsh_p2pk), OP_EQUAL])
  532. p2sh_p2wsh_p2pkh = CScript([OP_HASH160, hash160(p2wsh_p2pkh), OP_EQUAL])
  533. return [p2wpkh, p2sh_p2wpkh, p2pk, p2pkh, p2sh_p2pk, p2sh_p2pkh, p2wsh_p2pk, p2wsh_p2pkh, p2sh_p2wsh_p2pk, p2sh_p2wsh_p2pkh]
  534. def create_and_mine_tx_from_txids(self, txids, success = True):
  535. tx = CTransaction()
  536. for i in txids:
  537. txtmp = CTransaction()
  538. txraw = self.nodes[0].getrawtransaction(i)
  539. f = BytesIO(hex_str_to_bytes(txraw))
  540. txtmp.deserialize(f)
  541. for j in range(len(txtmp.vout)):
  542. tx.vin.append(CTxIn(COutPoint(int('0x'+i,0), j)))
  543. tx.vout.append(CTxOut(0, CScript()))
  544. tx.rehash()
  545. signresults = self.nodes[0].signrawtransaction(bytes_to_hex_str(tx.serialize_without_witness()))['hex']
  546. self.nodes[0].sendrawtransaction(signresults, True)
  547. self.nodes[0].generate(1)
  548. sync_blocks(self.nodes)
  549. if __name__ == '__main__':
  550. SegWitTest().main()