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