From cb41ade6b1d9e9b0abea42f7a6946c13ebfb2083 Mon Sep 17 00:00:00 2001 From: John Newbery Date: Fri, 30 Nov 2018 17:47:46 -0500 Subject: [tests] fix flake8 warnings in wallet_importmulti.py --- test/functional/wallet_importmulti.py | 78 ++++++++++++++--------------------- 1 file changed, 32 insertions(+), 46 deletions(-) diff --git a/test/functional/wallet_importmulti.py b/test/functional/wallet_importmulti.py index 5c789b1c03..0e99a6b364 100755 --- a/test/functional/wallet_importmulti.py +++ b/test/functional/wallet_importmulti.py @@ -32,7 +32,7 @@ class ImportMultiTest(BitcoinTestFramework): def setup_network(self): self.setup_nodes() - def run_test (self): + def run_test(self): self.log.info("Mining blocks...") self.nodes[0].generate(1) self.nodes[1].generate(1) @@ -40,18 +40,17 @@ class ImportMultiTest(BitcoinTestFramework): node0_address1 = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) - #Check only one address + # Check only one address assert_equal(node0_address1['ismine'], True) - #Node 1 sync test - assert_equal(self.nodes[1].getblockcount(),1) + # Node 1 sync test + assert_equal(self.nodes[1].getblockcount(), 1) - #Address Test - before import + # Address Test - before import address_info = self.nodes[1].getaddressinfo(node0_address1['address']) assert_equal(address_info['iswatchonly'], False) assert_equal(address_info['ismine'], False) - # RPC importmulti ----------------------------------------------- # Bitcoin Address (implicit non-internal) @@ -127,7 +126,6 @@ class ImportMultiTest(BitcoinTestFramework): assert_equal(address_assert['ismine'], False) assert_equal('timestamp' in address_assert, False) - # Address + Public key + !Internal(explicit) self.log.info("Should import an address with public key") address = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) @@ -136,7 +134,7 @@ class ImportMultiTest(BitcoinTestFramework): "address": address['address'] }, "timestamp": "now", - "pubkeys": [ address['pubkey'] ], + "pubkeys": [address['pubkey']], "internal": False }]) assert_equal(result[0]['success'], True) @@ -145,14 +143,13 @@ class ImportMultiTest(BitcoinTestFramework): assert_equal(address_assert['ismine'], False) assert_equal(address_assert['timestamp'], timestamp) - # ScriptPubKey + Public key + internal self.log.info("Should import a scriptPubKey with internal and with public key") address = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) request = [{ "scriptPubKey": address['scriptPubKey'], "timestamp": "now", - "pubkeys": [ address['pubkey'] ], + "pubkeys": [address['pubkey']], "internal": True }] result = self.nodes[1].importmulti(requests=request) @@ -168,7 +165,7 @@ class ImportMultiTest(BitcoinTestFramework): request = [{ "scriptPubKey": nonstandardScriptPubKey, "timestamp": "now", - "pubkeys": [ address['pubkey'] ] + "pubkeys": [address['pubkey']] }] result = self.nodes[1].importmulti(requests=request) assert_equal(result[0]['success'], False) @@ -187,7 +184,7 @@ class ImportMultiTest(BitcoinTestFramework): "address": address['address'] }, "timestamp": "now", - "keys": [ self.nodes[0].dumpprivkey(address['address']) ] + "keys": [self.nodes[0].dumpprivkey(address['address'])] }]) assert_equal(result[0]['success'], True) address_assert = self.nodes[1].getaddressinfo(address['address']) @@ -201,7 +198,7 @@ class ImportMultiTest(BitcoinTestFramework): "address": address['address'] }, "timestamp": "now", - "keys": [ self.nodes[0].dumpprivkey(address['address']) ] + "keys": [self.nodes[0].dumpprivkey(address['address'])] }]) assert_equal(result[0]['success'], False) assert_equal(result[0]['error']['code'], -4) @@ -215,7 +212,7 @@ class ImportMultiTest(BitcoinTestFramework): "address": address['address'] }, "timestamp": "now", - "keys": [ self.nodes[0].dumpprivkey(address['address']) ], + "keys": [self.nodes[0].dumpprivkey(address['address'])], "watchonly": True }]) assert_equal(result[0]['success'], False) @@ -232,7 +229,7 @@ class ImportMultiTest(BitcoinTestFramework): result = self.nodes[1].importmulti([{ "scriptPubKey": address['scriptPubKey'], "timestamp": "now", - "keys": [ self.nodes[0].dumpprivkey(address['address']) ], + "keys": [self.nodes[0].dumpprivkey(address['address'])], "internal": True }]) assert_equal(result[0]['success'], True) @@ -247,7 +244,7 @@ class ImportMultiTest(BitcoinTestFramework): result = self.nodes[1].importmulti([{ "scriptPubKey": nonstandardScriptPubKey, "timestamp": "now", - "keys": [ self.nodes[0].dumpprivkey(address['address']) ] + "keys": [self.nodes[0].dumpprivkey(address['address'])] }]) assert_equal(result[0]['success'], False) assert_equal(result[0]['error']['code'], -8) @@ -257,7 +254,6 @@ class ImportMultiTest(BitcoinTestFramework): assert_equal(address_assert['ismine'], False) assert_equal('timestamp' in address_assert, False) - # P2SH address sig_address_1 = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) sig_address_2 = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) @@ -280,11 +276,10 @@ class ImportMultiTest(BitcoinTestFramework): assert_equal(address_assert['isscript'], True) assert_equal(address_assert['iswatchonly'], True) assert_equal(address_assert['timestamp'], timestamp) - p2shunspent = self.nodes[1].listunspent(0,999999, [multi_sig_script['address']])[0] + p2shunspent = self.nodes[1].listunspent(0, 999999, [multi_sig_script['address']])[0] assert_equal(p2shunspent['spendable'], False) assert_equal(p2shunspent['solvable'], False) - # P2SH + Redeem script sig_address_1 = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) sig_address_2 = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) @@ -307,11 +302,10 @@ class ImportMultiTest(BitcoinTestFramework): address_assert = self.nodes[1].getaddressinfo(multi_sig_script['address']) assert_equal(address_assert['timestamp'], timestamp) - p2shunspent = self.nodes[1].listunspent(0,999999, [multi_sig_script['address']])[0] + p2shunspent = self.nodes[1].listunspent(0, 999999, [multi_sig_script['address']])[0] assert_equal(p2shunspent['spendable'], False) assert_equal(p2shunspent['solvable'], True) - # P2SH + Redeem script + Private Keys + !Watchonly sig_address_1 = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) sig_address_2 = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) @@ -329,13 +323,13 @@ class ImportMultiTest(BitcoinTestFramework): }, "timestamp": "now", "redeemscript": multi_sig_script['redeemScript'], - "keys": [ self.nodes[0].dumpprivkey(sig_address_1['address']), self.nodes[0].dumpprivkey(sig_address_2['address'])] + "keys": [self.nodes[0].dumpprivkey(sig_address_1['address']), self.nodes[0].dumpprivkey(sig_address_2['address'])] }]) assert_equal(result[0]['success'], True) address_assert = self.nodes[1].getaddressinfo(multi_sig_script['address']) assert_equal(address_assert['timestamp'], timestamp) - p2shunspent = self.nodes[1].listunspent(0,999999, [multi_sig_script['address']])[0] + p2shunspent = self.nodes[1].listunspent(0, 999999, [multi_sig_script['address']])[0] assert_equal(p2shunspent['spendable'], False) assert_equal(p2shunspent['solvable'], True) @@ -356,14 +350,13 @@ class ImportMultiTest(BitcoinTestFramework): }, "timestamp": "now", "redeemscript": multi_sig_script['redeemScript'], - "keys": [ self.nodes[0].dumpprivkey(sig_address_1['address']), self.nodes[0].dumpprivkey(sig_address_2['address'])], + "keys": [self.nodes[0].dumpprivkey(sig_address_1['address']), self.nodes[0].dumpprivkey(sig_address_2['address'])], "watchonly": True }]) assert_equal(result[0]['success'], False) assert_equal(result[0]['error']['code'], -8) assert_equal(result[0]['error']['message'], 'Watch-only addresses should not include private keys') - # Address + Public key + !Internal + Wrong pubkey self.log.info("Should not import an address with a wrong public key") address = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) @@ -373,7 +366,7 @@ class ImportMultiTest(BitcoinTestFramework): "address": address['address'] }, "timestamp": "now", - "pubkeys": [ address2['pubkey'] ] + "pubkeys": [address2['pubkey']] }]) assert_equal(result[0]['success'], False) assert_equal(result[0]['error']['code'], -5) @@ -383,7 +376,6 @@ class ImportMultiTest(BitcoinTestFramework): assert_equal(address_assert['ismine'], False) assert_equal('timestamp' in address_assert, False) - # ScriptPubKey + Public key + internal + Wrong pubkey self.log.info("Should not import a scriptPubKey with internal and with a wrong public key") address = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) @@ -391,7 +383,7 @@ class ImportMultiTest(BitcoinTestFramework): request = [{ "scriptPubKey": address['scriptPubKey'], "timestamp": "now", - "pubkeys": [ address2['pubkey'] ], + "pubkeys": [address2['pubkey']], "internal": True }] result = self.nodes[1].importmulti(request) @@ -403,7 +395,6 @@ class ImportMultiTest(BitcoinTestFramework): assert_equal(address_assert['ismine'], False) assert_equal('timestamp' in address_assert, False) - # Address + Private key + !watchonly + Wrong private key self.log.info("Should not import an address with a wrong private key") address = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) @@ -413,7 +404,7 @@ class ImportMultiTest(BitcoinTestFramework): "address": address['address'] }, "timestamp": "now", - "keys": [ self.nodes[0].dumpprivkey(address2['address']) ] + "keys": [self.nodes[0].dumpprivkey(address2['address'])] }]) assert_equal(result[0]['success'], False) assert_equal(result[0]['error']['code'], -5) @@ -423,7 +414,6 @@ class ImportMultiTest(BitcoinTestFramework): assert_equal(address_assert['ismine'], False) assert_equal('timestamp' in address_assert, False) - # ScriptPubKey + Private key + internal + Wrong private key self.log.info("Should not import a scriptPubKey with internal and with a wrong private key") address = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) @@ -431,7 +421,7 @@ class ImportMultiTest(BitcoinTestFramework): result = self.nodes[1].importmulti([{ "scriptPubKey": address['scriptPubKey'], "timestamp": "now", - "keys": [ self.nodes[0].dumpprivkey(address2['address']) ], + "keys": [self.nodes[0].dumpprivkey(address2['address'])], "internal": True }]) assert_equal(result[0]['success'], False) @@ -442,7 +432,6 @@ class ImportMultiTest(BitcoinTestFramework): assert_equal(address_assert['ismine'], False) assert_equal('timestamp' in address_assert, False) - # Importing existing watch only address with new timestamp should replace saved timestamp. assert_greater_than(timestamp, watchonly_timestamp) self.log.info("Should replace previously saved watch only timestamp.") @@ -459,7 +448,6 @@ class ImportMultiTest(BitcoinTestFramework): assert_equal(address_assert['timestamp'], timestamp) watchonly_timestamp = timestamp - # restart nodes to check for proper serialization/deserialization of watch only address self.stop_nodes() self.start_nodes() @@ -471,14 +459,12 @@ class ImportMultiTest(BitcoinTestFramework): # Bad or missing timestamps self.log.info("Should throw on invalid or missing timestamp values") assert_raises_rpc_error(-3, 'Missing required timestamp field for key', - self.nodes[1].importmulti, [{ - "scriptPubKey": address['scriptPubKey'], - }]) + self.nodes[1].importmulti, [{"scriptPubKey": address['scriptPubKey']}]) assert_raises_rpc_error(-3, 'Expected number or "now" timestamp value for key. got type string', - self.nodes[1].importmulti, [{ - "scriptPubKey": address['scriptPubKey'], - "timestamp": "", - }]) + self.nodes[1].importmulti, [{ + "scriptPubKey": address['scriptPubKey'], + "timestamp": "" + }]) # Import P2WPKH address as watch only self.log.info("Should import a P2WPKH address as watch only") @@ -502,7 +488,7 @@ class ImportMultiTest(BitcoinTestFramework): "address": address['address'] }, "timestamp": "now", - "pubkeys": [ address['pubkey'] ] + "pubkeys": [address['pubkey']] }]) assert_equal(result[0]['success'], True) address_assert = self.nodes[1].getaddressinfo(address['address']) @@ -547,7 +533,7 @@ class ImportMultiTest(BitcoinTestFramework): }, "timestamp": "now", "witnessscript": multi_sig_script['redeemScript'], - "keys": [ self.nodes[0].dumpprivkey(sig_address_1['address']), self.nodes[0].dumpprivkey(sig_address_2['address']) ] + "keys": [self.nodes[0].dumpprivkey(sig_address_1['address']), self.nodes[0].dumpprivkey(sig_address_2['address'])] }]) assert_equal(result[0]['success'], True) address_assert = self.nodes[1].getaddressinfo(multi_sig_script['address']) @@ -579,7 +565,7 @@ class ImportMultiTest(BitcoinTestFramework): }, "timestamp": "now", "redeemscript": bytes_to_hex_str(pkscript), - "pubkeys": [ sig_address_1['pubkey'] ] + "pubkeys": [sig_address_1['pubkey']] }]) assert_equal(result[0]['success'], True) address_assert = self.nodes[1].getaddressinfo(sig_address_1['address']) @@ -597,7 +583,7 @@ class ImportMultiTest(BitcoinTestFramework): }, "timestamp": "now", "redeemscript": bytes_to_hex_str(pkscript), - "keys": [ self.nodes[0].dumpprivkey(sig_address_1['address'])] + "keys": [self.nodes[0].dumpprivkey(sig_address_1['address'])] }]) assert_equal(result[0]['success'], True) address_assert = self.nodes[1].getaddressinfo(sig_address_1['address']) @@ -623,4 +609,4 @@ class ImportMultiTest(BitcoinTestFramework): assert_equal(address_assert['solvable'], True) if __name__ == '__main__': - ImportMultiTest ().main () + ImportMultiTest().main() -- cgit v1.2.3 From e5a8ea8f146393e2a5e7d73a49335f3670bada11 Mon Sep 17 00:00:00 2001 From: John Newbery Date: Fri, 30 Nov 2018 17:49:03 -0500 Subject: [tests] tidy up imports in wallet_importmulti.py --- test/functional/wallet_importmulti.py | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/test/functional/wallet_importmulti.py b/test/functional/wallet_importmulti.py index 0e99a6b364..b6159063e1 100755 --- a/test/functional/wallet_importmulti.py +++ b/test/functional/wallet_importmulti.py @@ -4,7 +4,13 @@ # file COPYING or http://www.opensource.org/licenses/mit-license.php. """Test the importmulti RPC.""" -from test_framework import script +from test_framework.messages import sha256 +from test_framework.script import ( + CScript, + OP_0, + OP_NOP, + hash160 +) from test_framework.test_framework import BitcoinTestFramework from test_framework.util import ( assert_equal, @@ -13,12 +19,6 @@ from test_framework.util import ( bytes_to_hex_str, hex_str_to_bytes ) -from test_framework.script import ( - CScript, - OP_0, - hash160 -) -from test_framework.messages import sha256 class ImportMultiTest(BitcoinTestFramework): def set_test_params(self): @@ -112,7 +112,7 @@ class ImportMultiTest(BitcoinTestFramework): # Nonstandard scriptPubKey + !internal self.log.info("Should not import a nonstandard scriptPubKey without internal flag") - nonstandardScriptPubKey = address['scriptPubKey'] + bytes_to_hex_str(script.CScript([script.OP_NOP])) + nonstandardScriptPubKey = address['scriptPubKey'] + bytes_to_hex_str(CScript([OP_NOP])) address = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) result = self.nodes[1].importmulti([{ "scriptPubKey": nonstandardScriptPubKey, -- cgit v1.2.3 From 7c99614b40301daba5e526c6e3ab281965e869c6 Mon Sep 17 00:00:00 2001 From: John Newbery Date: Wed, 5 Dec 2018 18:28:32 -0500 Subject: [tests] add get_key function to wallet_importmulti.py Adds a new get_key function which generates a new key and returns the public key, private key and all script and address types. --- test/functional/wallet_importmulti.py | 232 +++++++++++++++++++++------------- 1 file changed, 142 insertions(+), 90 deletions(-) diff --git a/test/functional/wallet_importmulti.py b/test/functional/wallet_importmulti.py index b6159063e1..6cf854882e 100755 --- a/test/functional/wallet_importmulti.py +++ b/test/functional/wallet_importmulti.py @@ -3,13 +3,24 @@ # Distributed under the MIT software license, see the accompanying # file COPYING or http://www.opensource.org/licenses/mit-license.php. """Test the importmulti RPC.""" +from collections import namedtuple +from test_framework.address import ( + key_to_p2pkh, + key_to_p2sh_p2wpkh, + key_to_p2wpkh, +) from test_framework.messages import sha256 from test_framework.script import ( CScript, OP_0, + OP_CHECKSIG, + OP_DUP, + OP_EQUAL, + OP_EQUALVERIFY, + OP_HASH160, OP_NOP, - hash160 + hash160, ) from test_framework.test_framework import BitcoinTestFramework from test_framework.util import ( @@ -20,6 +31,16 @@ from test_framework.util import ( hex_str_to_bytes ) +Key = namedtuple('Key', ['privkey', + 'pubkey', + 'p2pkh_script', + 'p2pkh_addr', + 'p2wpkh_script', + 'p2wpkh_addr', + 'p2sh_p2wpkh_script', + 'p2sh_p2wpkh_redeem_script', + 'p2sh_p2wpkh_addr']) + class ImportMultiTest(BitcoinTestFramework): def set_test_params(self): self.num_nodes = 2 @@ -32,6 +53,23 @@ class ImportMultiTest(BitcoinTestFramework): def setup_network(self): self.setup_nodes() + def get_key(self): + """Generate a fresh key on node0 + + Returns a named tuple of privkey, pubkey and all address and scripts.""" + addr = self.nodes[0].getnewaddress() + pubkey = self.nodes[0].getaddressinfo(addr)['pubkey'] + pkh = hash160(hex_str_to_bytes(pubkey)) + return Key(self.nodes[0].dumpprivkey(addr), + pubkey, + CScript([OP_DUP, OP_HASH160, pkh, OP_EQUALVERIFY, OP_CHECKSIG]).hex(), # p2pkh + key_to_p2pkh(pubkey), # p2pkh addr + CScript([OP_0, pkh]).hex(), # p2wpkh + key_to_p2wpkh(pubkey), # p2wpkh addr + CScript([OP_HASH160, hash160(CScript([OP_0, pkh])), OP_EQUAL]).hex(), # p2sh-p2wpkh + CScript([OP_0, pkh]).hex(), # p2sh-p2wpkh redeem script + key_to_p2sh_p2wpkh(pubkey)) # p2sh-p2wpkh addr + def run_test(self): self.log.info("Mining blocks...") self.nodes[0].generate(1) @@ -55,20 +93,21 @@ class ImportMultiTest(BitcoinTestFramework): # Bitcoin Address (implicit non-internal) self.log.info("Should import an address") - address = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) + key = self.get_key() + address = key.p2pkh_addr result = self.nodes[1].importmulti([{ "scriptPubKey": { - "address": address['address'] + "address": address }, "timestamp": "now", }]) assert_equal(result[0]['success'], True) - address_assert = self.nodes[1].getaddressinfo(address['address']) + address_assert = self.nodes[1].getaddressinfo(address) assert_equal(address_assert['iswatchonly'], True) assert_equal(address_assert['ismine'], False) assert_equal(address_assert['timestamp'], timestamp) assert_equal(address_assert['ischange'], False) - watchonly_address = address['address'] + watchonly_address = address watchonly_timestamp = timestamp self.log.info("Should not import an invalid address") @@ -84,14 +123,14 @@ class ImportMultiTest(BitcoinTestFramework): # ScriptPubKey + internal self.log.info("Should import a scriptPubKey with internal flag") - address = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) + key = self.get_key() result = self.nodes[1].importmulti([{ - "scriptPubKey": address['scriptPubKey'], + "scriptPubKey": key.p2pkh_script, "timestamp": "now", "internal": True }]) assert_equal(result[0]['success'], True) - address_assert = self.nodes[1].getaddressinfo(address['address']) + address_assert = self.nodes[1].getaddressinfo(key.p2pkh_addr) assert_equal(address_assert['iswatchonly'], True) assert_equal(address_assert['ismine'], False) assert_equal(address_assert['timestamp'], timestamp) @@ -99,9 +138,9 @@ class ImportMultiTest(BitcoinTestFramework): # ScriptPubKey + internal + label self.log.info("Should not allow a label to be specified when internal is true") - address = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) + key = self.get_key() result = self.nodes[1].importmulti([{ - "scriptPubKey": address['scriptPubKey'], + "scriptPubKey": key.p2pkh_script, "timestamp": "now", "internal": True, "label": "Example label" @@ -112,8 +151,9 @@ class ImportMultiTest(BitcoinTestFramework): # Nonstandard scriptPubKey + !internal self.log.info("Should not import a nonstandard scriptPubKey without internal flag") - nonstandardScriptPubKey = address['scriptPubKey'] + bytes_to_hex_str(CScript([OP_NOP])) - address = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) + nonstandardScriptPubKey = key.p2pkh_script + bytes_to_hex_str(CScript([OP_NOP])) + key = self.get_key() + address = key.p2pkh_addr result = self.nodes[1].importmulti([{ "scriptPubKey": nonstandardScriptPubKey, "timestamp": "now", @@ -121,73 +161,77 @@ class ImportMultiTest(BitcoinTestFramework): assert_equal(result[0]['success'], False) assert_equal(result[0]['error']['code'], -8) assert_equal(result[0]['error']['message'], 'Internal must be set to true for nonstandard scriptPubKey imports.') - address_assert = self.nodes[1].getaddressinfo(address['address']) + address_assert = self.nodes[1].getaddressinfo(address) assert_equal(address_assert['iswatchonly'], False) assert_equal(address_assert['ismine'], False) assert_equal('timestamp' in address_assert, False) # Address + Public key + !Internal(explicit) self.log.info("Should import an address with public key") - address = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) + key = self.get_key() + address = key.p2pkh_addr result = self.nodes[1].importmulti([{ "scriptPubKey": { - "address": address['address'] + "address": address }, "timestamp": "now", - "pubkeys": [address['pubkey']], + "pubkeys": [key.pubkey], "internal": False }]) assert_equal(result[0]['success'], True) - address_assert = self.nodes[1].getaddressinfo(address['address']) + address_assert = self.nodes[1].getaddressinfo(address) assert_equal(address_assert['iswatchonly'], True) assert_equal(address_assert['ismine'], False) assert_equal(address_assert['timestamp'], timestamp) # ScriptPubKey + Public key + internal self.log.info("Should import a scriptPubKey with internal and with public key") - address = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) + key = self.get_key() + address = key.p2pkh_addr request = [{ - "scriptPubKey": address['scriptPubKey'], + "scriptPubKey": key.p2pkh_script, "timestamp": "now", - "pubkeys": [address['pubkey']], + "pubkeys": [key.pubkey], "internal": True }] result = self.nodes[1].importmulti(requests=request) assert_equal(result[0]['success'], True) - address_assert = self.nodes[1].getaddressinfo(address['address']) + address_assert = self.nodes[1].getaddressinfo(address) assert_equal(address_assert['iswatchonly'], True) assert_equal(address_assert['ismine'], False) assert_equal(address_assert['timestamp'], timestamp) # Nonstandard scriptPubKey + Public key + !internal self.log.info("Should not import a nonstandard scriptPubKey without internal and with public key") - address = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) + key = self.get_key() + address = key.p2pkh_addr request = [{ "scriptPubKey": nonstandardScriptPubKey, "timestamp": "now", - "pubkeys": [address['pubkey']] + "pubkeys": [key.pubkey] }] result = self.nodes[1].importmulti(requests=request) assert_equal(result[0]['success'], False) assert_equal(result[0]['error']['code'], -8) assert_equal(result[0]['error']['message'], 'Internal must be set to true for nonstandard scriptPubKey imports.') - address_assert = self.nodes[1].getaddressinfo(address['address']) + address_assert = self.nodes[1].getaddressinfo(address) assert_equal(address_assert['iswatchonly'], False) assert_equal(address_assert['ismine'], False) assert_equal('timestamp' in address_assert, False) # Address + Private key + !watchonly self.log.info("Should import an address with private key") - address = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) + key = self.get_key() + address = key.p2pkh_addr result = self.nodes[1].importmulti([{ "scriptPubKey": { - "address": address['address'] + "address": address }, "timestamp": "now", - "keys": [self.nodes[0].dumpprivkey(address['address'])] + "keys": [key.privkey] }]) assert_equal(result[0]['success'], True) - address_assert = self.nodes[1].getaddressinfo(address['address']) + address_assert = self.nodes[1].getaddressinfo(address) assert_equal(address_assert['iswatchonly'], False) assert_equal(address_assert['ismine'], True) assert_equal(address_assert['timestamp'], timestamp) @@ -195,10 +239,10 @@ class ImportMultiTest(BitcoinTestFramework): self.log.info("Should not import an address with private key if is already imported") result = self.nodes[1].importmulti([{ "scriptPubKey": { - "address": address['address'] + "address": address }, "timestamp": "now", - "keys": [self.nodes[0].dumpprivkey(address['address'])] + "keys": [key.privkey] }]) assert_equal(result[0]['success'], False) assert_equal(result[0]['error']['code'], -4) @@ -206,50 +250,53 @@ class ImportMultiTest(BitcoinTestFramework): # Address + Private key + watchonly self.log.info("Should not import an address with private key and with watchonly") - address = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) + key = self.get_key() + address = key.p2pkh_addr result = self.nodes[1].importmulti([{ "scriptPubKey": { - "address": address['address'] + "address": address }, "timestamp": "now", - "keys": [self.nodes[0].dumpprivkey(address['address'])], + "keys": [key.privkey], "watchonly": True }]) assert_equal(result[0]['success'], False) assert_equal(result[0]['error']['code'], -8) assert_equal(result[0]['error']['message'], 'Watch-only addresses should not include private keys') - address_assert = self.nodes[1].getaddressinfo(address['address']) + address_assert = self.nodes[1].getaddressinfo(address) assert_equal(address_assert['iswatchonly'], False) assert_equal(address_assert['ismine'], False) assert_equal('timestamp' in address_assert, False) # ScriptPubKey + Private key + internal self.log.info("Should import a scriptPubKey with internal and with private key") - address = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) + key = self.get_key() + address = key.p2pkh_addr result = self.nodes[1].importmulti([{ - "scriptPubKey": address['scriptPubKey'], + "scriptPubKey": key.p2pkh_script, "timestamp": "now", - "keys": [self.nodes[0].dumpprivkey(address['address'])], + "keys": [key.privkey], "internal": True }]) assert_equal(result[0]['success'], True) - address_assert = self.nodes[1].getaddressinfo(address['address']) + address_assert = self.nodes[1].getaddressinfo(address) assert_equal(address_assert['iswatchonly'], False) assert_equal(address_assert['ismine'], True) assert_equal(address_assert['timestamp'], timestamp) # Nonstandard scriptPubKey + Private key + !internal self.log.info("Should not import a nonstandard scriptPubKey without internal and with private key") - address = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) + key = self.get_key() + address = key.p2pkh_addr result = self.nodes[1].importmulti([{ "scriptPubKey": nonstandardScriptPubKey, "timestamp": "now", - "keys": [self.nodes[0].dumpprivkey(address['address'])] + "keys": [key.privkey] }]) assert_equal(result[0]['success'], False) assert_equal(result[0]['error']['code'], -8) assert_equal(result[0]['error']['message'], 'Internal must be set to true for nonstandard scriptPubKey imports.') - address_assert = self.nodes[1].getaddressinfo(address['address']) + address_assert = self.nodes[1].getaddressinfo(address) assert_equal(address_assert['iswatchonly'], False) assert_equal(address_assert['ismine'], False) assert_equal('timestamp' in address_assert, False) @@ -359,75 +406,79 @@ class ImportMultiTest(BitcoinTestFramework): # Address + Public key + !Internal + Wrong pubkey self.log.info("Should not import an address with a wrong public key") - address = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) - address2 = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) + key = self.get_key() + address = key.p2pkh_addr + wrong_key = self.get_key().pubkey result = self.nodes[1].importmulti([{ "scriptPubKey": { - "address": address['address'] + "address": address }, "timestamp": "now", - "pubkeys": [address2['pubkey']] + "pubkeys": [wrong_key] }]) assert_equal(result[0]['success'], False) assert_equal(result[0]['error']['code'], -5) assert_equal(result[0]['error']['message'], 'Key does not match address destination') - address_assert = self.nodes[1].getaddressinfo(address['address']) + address_assert = self.nodes[1].getaddressinfo(address) assert_equal(address_assert['iswatchonly'], False) assert_equal(address_assert['ismine'], False) assert_equal('timestamp' in address_assert, False) # ScriptPubKey + Public key + internal + Wrong pubkey self.log.info("Should not import a scriptPubKey with internal and with a wrong public key") - address = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) - address2 = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) + key = self.get_key() + address = key.p2pkh_addr + wrong_key = self.get_key().pubkey request = [{ - "scriptPubKey": address['scriptPubKey'], + "scriptPubKey": key.p2pkh_script, "timestamp": "now", - "pubkeys": [address2['pubkey']], + "pubkeys": [wrong_key], "internal": True }] result = self.nodes[1].importmulti(request) assert_equal(result[0]['success'], False) assert_equal(result[0]['error']['code'], -5) assert_equal(result[0]['error']['message'], 'Key does not match address destination') - address_assert = self.nodes[1].getaddressinfo(address['address']) + address_assert = self.nodes[1].getaddressinfo(address) assert_equal(address_assert['iswatchonly'], False) assert_equal(address_assert['ismine'], False) assert_equal('timestamp' in address_assert, False) # Address + Private key + !watchonly + Wrong private key self.log.info("Should not import an address with a wrong private key") - address = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) - address2 = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) + key = self.get_key() + address = key.p2pkh_addr + wrong_privkey = self.get_key().privkey result = self.nodes[1].importmulti([{ "scriptPubKey": { - "address": address['address'] + "address": address }, "timestamp": "now", - "keys": [self.nodes[0].dumpprivkey(address2['address'])] + "keys": [wrong_privkey] }]) assert_equal(result[0]['success'], False) assert_equal(result[0]['error']['code'], -5) assert_equal(result[0]['error']['message'], 'Key does not match address destination') - address_assert = self.nodes[1].getaddressinfo(address['address']) + address_assert = self.nodes[1].getaddressinfo(address) assert_equal(address_assert['iswatchonly'], False) assert_equal(address_assert['ismine'], False) assert_equal('timestamp' in address_assert, False) # ScriptPubKey + Private key + internal + Wrong private key self.log.info("Should not import a scriptPubKey with internal and with a wrong private key") - address = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) - address2 = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) + key = self.get_key() + address = key.p2pkh_addr + wrong_privkey = self.get_key().privkey result = self.nodes[1].importmulti([{ - "scriptPubKey": address['scriptPubKey'], + "scriptPubKey": key.p2pkh_script, "timestamp": "now", - "keys": [self.nodes[0].dumpprivkey(address2['address'])], + "keys": [wrong_privkey], "internal": True }]) assert_equal(result[0]['success'], False) assert_equal(result[0]['error']['code'], -5) assert_equal(result[0]['error']['message'], 'Key does not match address destination') - address_assert = self.nodes[1].getaddressinfo(address['address']) + address_assert = self.nodes[1].getaddressinfo(address) assert_equal(address_assert['iswatchonly'], False) assert_equal(address_assert['ismine'], False) assert_equal('timestamp' in address_assert, False) @@ -459,54 +510,57 @@ class ImportMultiTest(BitcoinTestFramework): # Bad or missing timestamps self.log.info("Should throw on invalid or missing timestamp values") assert_raises_rpc_error(-3, 'Missing required timestamp field for key', - self.nodes[1].importmulti, [{"scriptPubKey": address['scriptPubKey']}]) + self.nodes[1].importmulti, [{"scriptPubKey": key.p2pkh_script}]) assert_raises_rpc_error(-3, 'Expected number or "now" timestamp value for key. got type string', self.nodes[1].importmulti, [{ - "scriptPubKey": address['scriptPubKey'], + "scriptPubKey": key.p2pkh_script, "timestamp": "" }]) # Import P2WPKH address as watch only self.log.info("Should import a P2WPKH address as watch only") - address = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress(address_type="bech32")) + key = self.get_key() + address = key.p2wpkh_addr result = self.nodes[1].importmulti([{ "scriptPubKey": { - "address": address['address'] + "address": address }, "timestamp": "now", }]) assert_equal(result[0]['success'], True) - address_assert = self.nodes[1].getaddressinfo(address['address']) + address_assert = self.nodes[1].getaddressinfo(address) assert_equal(address_assert['iswatchonly'], True) assert_equal(address_assert['solvable'], False) # Import P2WPKH address with public key but no private key self.log.info("Should import a P2WPKH address and public key as solvable but not spendable") - address = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress(address_type="bech32")) + key = self.get_key() + address = key.p2wpkh_addr result = self.nodes[1].importmulti([{ "scriptPubKey": { - "address": address['address'] + "address": address }, "timestamp": "now", - "pubkeys": [address['pubkey']] + "pubkeys": [key.pubkey] }]) assert_equal(result[0]['success'], True) - address_assert = self.nodes[1].getaddressinfo(address['address']) + address_assert = self.nodes[1].getaddressinfo(address) assert_equal(address_assert['ismine'], False) assert_equal(address_assert['solvable'], True) # Import P2WPKH address with key and check it is spendable self.log.info("Should import a P2WPKH address with key") - address = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress(address_type="bech32")) + key = self.get_key() + address = key.p2wpkh_addr result = self.nodes[1].importmulti([{ "scriptPubKey": { - "address": address['address'] + "address": address }, "timestamp": "now", - "keys": [self.nodes[0].dumpprivkey(address['address'])] + "keys": [key.privkey] }]) assert_equal(result[0]['success'], True) - address_assert = self.nodes[1].getaddressinfo(address['address']) + address_assert = self.nodes[1].getaddressinfo(address) assert_equal(address_assert['iswatchonly'], False) assert_equal(address_assert['ismine'], True) @@ -542,18 +596,17 @@ class ImportMultiTest(BitcoinTestFramework): assert_equal(address_assert['sigsrequired'], 2) # P2SH-P2WPKH address with no redeemscript or public or private key - sig_address_1 = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress(address_type="p2sh-segwit")) - pubkeyhash = hash160(hex_str_to_bytes(sig_address_1['pubkey'])) - pkscript = CScript([OP_0, pubkeyhash]) + key = self.get_key() + address = key.p2sh_p2wpkh_addr self.log.info("Should import a p2sh-p2wpkh without redeem script or keys") result = self.nodes[1].importmulti([{ "scriptPubKey": { - "address": sig_address_1['address'] + "address": address }, "timestamp": "now" }]) assert_equal(result[0]['success'], True) - address_assert = self.nodes[1].getaddressinfo(sig_address_1['address']) + address_assert = self.nodes[1].getaddressinfo(address) assert_equal(address_assert['solvable'], False) assert_equal(address_assert['ismine'], False) @@ -561,32 +614,31 @@ class ImportMultiTest(BitcoinTestFramework): self.log.info("Should import a p2sh-p2wpkh with respective redeem script and pubkey as solvable") result = self.nodes[1].importmulti([{ "scriptPubKey": { - "address": sig_address_1['address'] + "address": address }, "timestamp": "now", - "redeemscript": bytes_to_hex_str(pkscript), - "pubkeys": [sig_address_1['pubkey']] + "redeemscript": key.p2sh_p2wpkh_redeem_script, + "pubkeys": [key.pubkey] }]) assert_equal(result[0]['success'], True) - address_assert = self.nodes[1].getaddressinfo(sig_address_1['address']) + address_assert = self.nodes[1].getaddressinfo(address) assert_equal(address_assert['solvable'], True) assert_equal(address_assert['ismine'], False) # P2SH-P2WPKH address + redeemscript + private key - sig_address_1 = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress(address_type="p2sh-segwit")) - pubkeyhash = hash160(hex_str_to_bytes(sig_address_1['pubkey'])) - pkscript = CScript([OP_0, pubkeyhash]) + key = self.get_key() + address = key.p2sh_p2wpkh_addr self.log.info("Should import a p2sh-p2wpkh with respective redeem script and private keys") result = self.nodes[1].importmulti([{ "scriptPubKey": { - "address": sig_address_1['address'] + "address": address }, "timestamp": "now", - "redeemscript": bytes_to_hex_str(pkscript), - "keys": [self.nodes[0].dumpprivkey(sig_address_1['address'])] + "redeemscript": key.p2sh_p2wpkh_redeem_script, + "keys": [key.privkey] }]) assert_equal(result[0]['success'], True) - address_assert = self.nodes[1].getaddressinfo(sig_address_1['address']) + address_assert = self.nodes[1].getaddressinfo(address) assert_equal(address_assert['solvable'], True) assert_equal(address_assert['ismine'], True) -- cgit v1.2.3 From 08a4a0f70f545e114bc35dc76056282cb04bf013 Mon Sep 17 00:00:00 2001 From: John Newbery Date: Wed, 5 Dec 2018 18:28:32 -0500 Subject: [tests] add get_multisig function to wallet_importmulti.py Adds a new get_multisig function which generates a new multisig and returns the public keys, private keys and all script and address types. --- test/functional/wallet_importmulti.py | 131 ++++++++++++++++++++-------------- 1 file changed, 76 insertions(+), 55 deletions(-) diff --git a/test/functional/wallet_importmulti.py b/test/functional/wallet_importmulti.py index 6cf854882e..39927cfb99 100755 --- a/test/functional/wallet_importmulti.py +++ b/test/functional/wallet_importmulti.py @@ -9,11 +9,16 @@ from test_framework.address import ( key_to_p2pkh, key_to_p2sh_p2wpkh, key_to_p2wpkh, + script_to_p2sh, + script_to_p2sh_p2wsh, + script_to_p2wsh, ) -from test_framework.messages import sha256 from test_framework.script import ( CScript, OP_0, + OP_2, + OP_3, + OP_CHECKMULTISIG, OP_CHECKSIG, OP_DUP, OP_EQUAL, @@ -21,6 +26,7 @@ from test_framework.script import ( OP_HASH160, OP_NOP, hash160, + sha256, ) from test_framework.test_framework import BitcoinTestFramework from test_framework.util import ( @@ -41,6 +47,16 @@ Key = namedtuple('Key', ['privkey', 'p2sh_p2wpkh_redeem_script', 'p2sh_p2wpkh_addr']) +Multisig = namedtuple('Multisig', ['privkeys', + 'pubkeys', + 'p2sh_script', + 'p2sh_addr', + 'redeem_script', + 'p2wsh_script', + 'p2wsh_addr', + 'p2sh_p2wsh_script', + 'p2sh_p2wsh_addr']) + class ImportMultiTest(BitcoinTestFramework): def set_test_params(self): self.num_nodes = 2 @@ -70,6 +86,28 @@ class ImportMultiTest(BitcoinTestFramework): CScript([OP_0, pkh]).hex(), # p2sh-p2wpkh redeem script key_to_p2sh_p2wpkh(pubkey)) # p2sh-p2wpkh addr + def get_multisig(self): + """Generate a fresh multisig on node0 + + Returns a named tuple of privkeys, pubkeys and all address and scripts.""" + addrs = [] + pubkeys = [] + for _ in range(3): + addr = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) + addrs.append(addr['address']) + pubkeys.append(addr['pubkey']) + script_code = CScript([OP_2] + [hex_str_to_bytes(pubkey) for pubkey in pubkeys] + [OP_3, OP_CHECKMULTISIG]) + witness_script = CScript([OP_0, sha256(script_code)]) + return Multisig([self.nodes[0].dumpprivkey(addr) for addr in addrs], + pubkeys, + CScript([OP_HASH160, hash160(script_code), OP_EQUAL]).hex(), # p2sh + script_to_p2sh(script_code), # p2sh addr + script_code.hex(), # redeem script + witness_script.hex(), # p2wsh + script_to_p2wsh(script_code), # p2wsh addr + CScript([OP_HASH160, witness_script, OP_EQUAL]).hex(), # p2sh-p2wsh + script_to_p2sh_p2wsh(script_code)) # p2sh-p2wsh addr + def run_test(self): self.log.info("Mining blocks...") self.nodes[0].generate(1) @@ -302,102 +340,90 @@ class ImportMultiTest(BitcoinTestFramework): assert_equal('timestamp' in address_assert, False) # P2SH address - sig_address_1 = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) - sig_address_2 = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) - sig_address_3 = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) - multi_sig_script = self.nodes[0].createmultisig(2, [sig_address_1['pubkey'], sig_address_2['pubkey'], sig_address_3['pubkey']]) + multisig = self.get_multisig() self.nodes[1].generate(100) - self.nodes[1].sendtoaddress(multi_sig_script['address'], 10.00) + self.nodes[1].sendtoaddress(multisig.p2sh_addr, 10.00) self.nodes[1].generate(1) timestamp = self.nodes[1].getblock(self.nodes[1].getbestblockhash())['mediantime'] self.log.info("Should import a p2sh") result = self.nodes[1].importmulti([{ "scriptPubKey": { - "address": multi_sig_script['address'] + "address": multisig.p2sh_addr }, "timestamp": "now", }]) assert_equal(result[0]['success'], True) - address_assert = self.nodes[1].getaddressinfo(multi_sig_script['address']) + address_assert = self.nodes[1].getaddressinfo(multisig.p2sh_addr) assert_equal(address_assert['isscript'], True) assert_equal(address_assert['iswatchonly'], True) assert_equal(address_assert['timestamp'], timestamp) - p2shunspent = self.nodes[1].listunspent(0, 999999, [multi_sig_script['address']])[0] + p2shunspent = self.nodes[1].listunspent(0, 999999, [multisig.p2sh_addr])[0] assert_equal(p2shunspent['spendable'], False) assert_equal(p2shunspent['solvable'], False) # P2SH + Redeem script - sig_address_1 = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) - sig_address_2 = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) - sig_address_3 = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) - multi_sig_script = self.nodes[0].createmultisig(2, [sig_address_1['pubkey'], sig_address_2['pubkey'], sig_address_3['pubkey']]) + multisig = self.get_multisig() self.nodes[1].generate(100) - self.nodes[1].sendtoaddress(multi_sig_script['address'], 10.00) + self.nodes[1].sendtoaddress(multisig.p2sh_addr, 10.00) self.nodes[1].generate(1) timestamp = self.nodes[1].getblock(self.nodes[1].getbestblockhash())['mediantime'] self.log.info("Should import a p2sh with respective redeem script") result = self.nodes[1].importmulti([{ "scriptPubKey": { - "address": multi_sig_script['address'] + "address": multisig.p2sh_addr }, "timestamp": "now", - "redeemscript": multi_sig_script['redeemScript'] + "redeemscript": multisig.redeem_script }]) assert_equal(result[0]['success'], True) - address_assert = self.nodes[1].getaddressinfo(multi_sig_script['address']) + address_assert = self.nodes[1].getaddressinfo(multisig.p2sh_addr) assert_equal(address_assert['timestamp'], timestamp) - p2shunspent = self.nodes[1].listunspent(0, 999999, [multi_sig_script['address']])[0] + p2shunspent = self.nodes[1].listunspent(0, 999999, [multisig.p2sh_addr])[0] assert_equal(p2shunspent['spendable'], False) assert_equal(p2shunspent['solvable'], True) # P2SH + Redeem script + Private Keys + !Watchonly - sig_address_1 = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) - sig_address_2 = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) - sig_address_3 = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) - multi_sig_script = self.nodes[0].createmultisig(2, [sig_address_1['pubkey'], sig_address_2['pubkey'], sig_address_3['pubkey']]) + multisig = self.get_multisig() self.nodes[1].generate(100) - self.nodes[1].sendtoaddress(multi_sig_script['address'], 10.00) + self.nodes[1].sendtoaddress(multisig.p2sh_addr, 10.00) self.nodes[1].generate(1) timestamp = self.nodes[1].getblock(self.nodes[1].getbestblockhash())['mediantime'] self.log.info("Should import a p2sh with respective redeem script and private keys") result = self.nodes[1].importmulti([{ "scriptPubKey": { - "address": multi_sig_script['address'] + "address": multisig.p2sh_addr }, "timestamp": "now", - "redeemscript": multi_sig_script['redeemScript'], - "keys": [self.nodes[0].dumpprivkey(sig_address_1['address']), self.nodes[0].dumpprivkey(sig_address_2['address'])] + "redeemscript": multisig.redeem_script, + "keys": multisig.privkeys[0:2] }]) assert_equal(result[0]['success'], True) - address_assert = self.nodes[1].getaddressinfo(multi_sig_script['address']) + address_assert = self.nodes[1].getaddressinfo(multisig.p2sh_addr) assert_equal(address_assert['timestamp'], timestamp) - p2shunspent = self.nodes[1].listunspent(0, 999999, [multi_sig_script['address']])[0] + p2shunspent = self.nodes[1].listunspent(0, 999999, [multisig.p2sh_addr])[0] assert_equal(p2shunspent['spendable'], False) assert_equal(p2shunspent['solvable'], True) # P2SH + Redeem script + Private Keys + Watchonly - sig_address_1 = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) - sig_address_2 = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) - sig_address_3 = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) - multi_sig_script = self.nodes[0].createmultisig(2, [sig_address_1['pubkey'], sig_address_2['pubkey'], sig_address_3['pubkey']]) + multisig = self.get_multisig() self.nodes[1].generate(100) - self.nodes[1].sendtoaddress(multi_sig_script['address'], 10.00) + self.nodes[1].sendtoaddress(multisig.p2sh_addr, 10.00) self.nodes[1].generate(1) timestamp = self.nodes[1].getblock(self.nodes[1].getbestblockhash())['mediantime'] self.log.info("Should import a p2sh with respective redeem script and private keys") result = self.nodes[1].importmulti([{ "scriptPubKey": { - "address": multi_sig_script['address'] + "address": multisig.p2sh_addr }, "timestamp": "now", - "redeemscript": multi_sig_script['redeemScript'], - "keys": [self.nodes[0].dumpprivkey(sig_address_1['address']), self.nodes[0].dumpprivkey(sig_address_2['address'])], + "redeemscript": multisig.redeem_script, + "keys": multisig.privkeys[0:2], "watchonly": True }]) assert_equal(result[0]['success'], False) @@ -565,32 +591,30 @@ class ImportMultiTest(BitcoinTestFramework): assert_equal(address_assert['ismine'], True) # P2WSH multisig address without scripts or keys - sig_address_1 = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) - sig_address_2 = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) - multi_sig_script = self.nodes[0].addmultisigaddress(2, [sig_address_1['pubkey'], sig_address_2['pubkey']], "", "bech32") + multisig = self.get_multisig() self.log.info("Should import a p2wsh multisig as watch only without respective redeem script and private keys") result = self.nodes[1].importmulti([{ "scriptPubKey": { - "address": multi_sig_script['address'] + "address": multisig.p2wsh_addr }, "timestamp": "now" }]) assert_equal(result[0]['success'], True) - address_assert = self.nodes[1].getaddressinfo(multi_sig_script['address']) + address_assert = self.nodes[1].getaddressinfo(multisig.p2sh_addr) assert_equal(address_assert['solvable'], False) # Same P2WSH multisig address as above, but now with witnessscript + private keys - self.log.info("Should import a p2wsh with respective redeem script and private keys") + self.log.info("Should import a p2wsh with respective witness script and private keys") result = self.nodes[1].importmulti([{ "scriptPubKey": { - "address": multi_sig_script['address'] + "address": multisig.p2wsh_addr }, "timestamp": "now", - "witnessscript": multi_sig_script['redeemScript'], - "keys": [self.nodes[0].dumpprivkey(sig_address_1['address']), self.nodes[0].dumpprivkey(sig_address_2['address'])] + "witnessscript": multisig.redeem_script, + "keys": multisig.privkeys }]) assert_equal(result[0]['success'], True) - address_assert = self.nodes[1].getaddressinfo(multi_sig_script['address']) + address_assert = self.nodes[1].getaddressinfo(multisig.p2sh_addr) assert_equal(address_assert['solvable'], True) assert_equal(address_assert['ismine'], True) assert_equal(address_assert['sigsrequired'], 2) @@ -642,22 +666,19 @@ class ImportMultiTest(BitcoinTestFramework): assert_equal(address_assert['solvable'], True) assert_equal(address_assert['ismine'], True) - # P2SH-P2WSH 1-of-1 multisig + redeemscript with no private key - sig_address_1 = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress()) - multi_sig_script = self.nodes[0].addmultisigaddress(1, [sig_address_1['pubkey']], "", "p2sh-segwit") - scripthash = sha256(hex_str_to_bytes(multi_sig_script['redeemScript'])) - redeem_script = CScript([OP_0, scripthash]) + # P2SH-P2WSH multisig + redeemscript with no private key + multisig = self.get_multisig() self.log.info("Should import a p2sh-p2wsh with respective redeem script but no private key") result = self.nodes[1].importmulti([{ "scriptPubKey": { - "address": multi_sig_script['address'] + "address": multisig.p2sh_p2wsh_addr }, "timestamp": "now", - "redeemscript": bytes_to_hex_str(redeem_script), - "witnessscript": multi_sig_script['redeemScript'] + "redeemscript": multisig.p2wsh_script, + "witnessscript": multisig.redeem_script, }]) assert_equal(result[0]['success'], True) - address_assert = self.nodes[1].getaddressinfo(multi_sig_script['address']) + address_assert = self.nodes[1].getaddressinfo(multisig.p2sh_addr) assert_equal(address_assert['solvable'], True) if __name__ == '__main__': -- cgit v1.2.3 From fd3a02c381ee136e54579b5a2e3466c016101515 Mon Sep 17 00:00:00 2001 From: John Newbery Date: Thu, 6 Dec 2018 09:52:38 -0500 Subject: [tests] add test_importmulti method to wallet_import.py Adds a new test_importmulti method for testing the importmulti RPC method. --- test/functional/wallet_importmulti.py | 425 +++++++++++++--------------------- 1 file changed, 162 insertions(+), 263 deletions(-) diff --git a/test/functional/wallet_importmulti.py b/test/functional/wallet_importmulti.py index 39927cfb99..d5ff1d2f25 100755 --- a/test/functional/wallet_importmulti.py +++ b/test/functional/wallet_importmulti.py @@ -108,6 +108,14 @@ class ImportMultiTest(BitcoinTestFramework): CScript([OP_HASH160, witness_script, OP_EQUAL]).hex(), # p2sh-p2wsh script_to_p2sh_p2wsh(script_code)) # p2sh-p2wsh addr + def test_importmulti(self, req, success, error_code=None, error_message=None): + """Run importmulti and assert success""" + result = self.nodes[1].importmulti([req]) + assert_equal(result[0]['success'], success) + if error_code is not None: + assert_equal(result[0]['error']['code'], error_code) + assert_equal(result[0]['error']['message'], error_message) + def run_test(self): self.log.info("Mining blocks...") self.nodes[0].generate(1) @@ -133,13 +141,9 @@ class ImportMultiTest(BitcoinTestFramework): self.log.info("Should import an address") key = self.get_key() address = key.p2pkh_addr - result = self.nodes[1].importmulti([{ - "scriptPubKey": { - "address": address - }, - "timestamp": "now", - }]) - assert_equal(result[0]['success'], True) + self.test_importmulti({"scriptPubKey": {"address": address}, + "timestamp": "now"}, + True) address_assert = self.nodes[1].getaddressinfo(address) assert_equal(address_assert['iswatchonly'], True) assert_equal(address_assert['ismine'], False) @@ -149,25 +153,19 @@ class ImportMultiTest(BitcoinTestFramework): watchonly_timestamp = timestamp self.log.info("Should not import an invalid address") - result = self.nodes[1].importmulti([{ - "scriptPubKey": { - "address": "not valid address", - }, - "timestamp": "now", - }]) - assert_equal(result[0]['success'], False) - assert_equal(result[0]['error']['code'], -5) - assert_equal(result[0]['error']['message'], 'Invalid address') + self.test_importmulti({"scriptPubKey": {"address": "not valid address"}, + "timestamp": "now"}, + False, + error_code=-5, + error_message='Invalid address') # ScriptPubKey + internal self.log.info("Should import a scriptPubKey with internal flag") key = self.get_key() - result = self.nodes[1].importmulti([{ - "scriptPubKey": key.p2pkh_script, - "timestamp": "now", - "internal": True - }]) - assert_equal(result[0]['success'], True) + self.test_importmulti({"scriptPubKey": key.p2pkh_script, + "timestamp": "now", + "internal": True}, + True) address_assert = self.nodes[1].getaddressinfo(key.p2pkh_addr) assert_equal(address_assert['iswatchonly'], True) assert_equal(address_assert['ismine'], False) @@ -177,28 +175,24 @@ class ImportMultiTest(BitcoinTestFramework): # ScriptPubKey + internal + label self.log.info("Should not allow a label to be specified when internal is true") key = self.get_key() - result = self.nodes[1].importmulti([{ - "scriptPubKey": key.p2pkh_script, - "timestamp": "now", - "internal": True, - "label": "Example label" - }]) - assert_equal(result[0]['success'], False) - assert_equal(result[0]['error']['code'], -8) - assert_equal(result[0]['error']['message'], 'Internal addresses should not have a label') + self.test_importmulti({"scriptPubKey": key.p2pkh_script, + "timestamp": "now", + "internal": True, + "label": "Example label"}, + False, + error_code=-8, + error_message='Internal addresses should not have a label') # Nonstandard scriptPubKey + !internal self.log.info("Should not import a nonstandard scriptPubKey without internal flag") nonstandardScriptPubKey = key.p2pkh_script + bytes_to_hex_str(CScript([OP_NOP])) key = self.get_key() address = key.p2pkh_addr - result = self.nodes[1].importmulti([{ - "scriptPubKey": nonstandardScriptPubKey, - "timestamp": "now", - }]) - assert_equal(result[0]['success'], False) - assert_equal(result[0]['error']['code'], -8) - assert_equal(result[0]['error']['message'], 'Internal must be set to true for nonstandard scriptPubKey imports.') + self.test_importmulti({"scriptPubKey": nonstandardScriptPubKey, + "timestamp": "now"}, + False, + error_code=-8, + error_message='Internal must be set to true for nonstandard scriptPubKey imports.') address_assert = self.nodes[1].getaddressinfo(address) assert_equal(address_assert['iswatchonly'], False) assert_equal(address_assert['ismine'], False) @@ -208,15 +202,11 @@ class ImportMultiTest(BitcoinTestFramework): self.log.info("Should import an address with public key") key = self.get_key() address = key.p2pkh_addr - result = self.nodes[1].importmulti([{ - "scriptPubKey": { - "address": address - }, - "timestamp": "now", - "pubkeys": [key.pubkey], - "internal": False - }]) - assert_equal(result[0]['success'], True) + self.test_importmulti({"scriptPubKey": {"address": address}, + "timestamp": "now", + "pubkeys": [key.pubkey], + "internal": False}, + True) address_assert = self.nodes[1].getaddressinfo(address) assert_equal(address_assert['iswatchonly'], True) assert_equal(address_assert['ismine'], False) @@ -226,14 +216,11 @@ class ImportMultiTest(BitcoinTestFramework): self.log.info("Should import a scriptPubKey with internal and with public key") key = self.get_key() address = key.p2pkh_addr - request = [{ - "scriptPubKey": key.p2pkh_script, - "timestamp": "now", - "pubkeys": [key.pubkey], - "internal": True - }] - result = self.nodes[1].importmulti(requests=request) - assert_equal(result[0]['success'], True) + self.test_importmulti({"scriptPubKey": key.p2pkh_script, + "timestamp": "now", + "pubkeys": [key.pubkey], + "internal": True}, + True) address_assert = self.nodes[1].getaddressinfo(address) assert_equal(address_assert['iswatchonly'], True) assert_equal(address_assert['ismine'], False) @@ -243,15 +230,12 @@ class ImportMultiTest(BitcoinTestFramework): self.log.info("Should not import a nonstandard scriptPubKey without internal and with public key") key = self.get_key() address = key.p2pkh_addr - request = [{ - "scriptPubKey": nonstandardScriptPubKey, - "timestamp": "now", - "pubkeys": [key.pubkey] - }] - result = self.nodes[1].importmulti(requests=request) - assert_equal(result[0]['success'], False) - assert_equal(result[0]['error']['code'], -8) - assert_equal(result[0]['error']['message'], 'Internal must be set to true for nonstandard scriptPubKey imports.') + self.test_importmulti({"scriptPubKey": nonstandardScriptPubKey, + "timestamp": "now", + "pubkeys": [key.pubkey]}, + False, + error_code=-8, + error_message='Internal must be set to true for nonstandard scriptPubKey imports.') address_assert = self.nodes[1].getaddressinfo(address) assert_equal(address_assert['iswatchonly'], False) assert_equal(address_assert['ismine'], False) @@ -261,46 +245,34 @@ class ImportMultiTest(BitcoinTestFramework): self.log.info("Should import an address with private key") key = self.get_key() address = key.p2pkh_addr - result = self.nodes[1].importmulti([{ - "scriptPubKey": { - "address": address - }, - "timestamp": "now", - "keys": [key.privkey] - }]) - assert_equal(result[0]['success'], True) + self.test_importmulti({"scriptPubKey": {"address": address}, + "timestamp": "now", + "keys": [key.privkey]}, + True) address_assert = self.nodes[1].getaddressinfo(address) assert_equal(address_assert['iswatchonly'], False) assert_equal(address_assert['ismine'], True) assert_equal(address_assert['timestamp'], timestamp) self.log.info("Should not import an address with private key if is already imported") - result = self.nodes[1].importmulti([{ - "scriptPubKey": { - "address": address - }, - "timestamp": "now", - "keys": [key.privkey] - }]) - assert_equal(result[0]['success'], False) - assert_equal(result[0]['error']['code'], -4) - assert_equal(result[0]['error']['message'], 'The wallet already contains the private key for this address or script') + self.test_importmulti({"scriptPubKey": {"address": address}, + "timestamp": "now", + "keys": [key.privkey]}, + False, + error_code=-4, + error_message='The wallet already contains the private key for this address or script') # Address + Private key + watchonly self.log.info("Should not import an address with private key and with watchonly") key = self.get_key() address = key.p2pkh_addr - result = self.nodes[1].importmulti([{ - "scriptPubKey": { - "address": address - }, - "timestamp": "now", - "keys": [key.privkey], - "watchonly": True - }]) - assert_equal(result[0]['success'], False) - assert_equal(result[0]['error']['code'], -8) - assert_equal(result[0]['error']['message'], 'Watch-only addresses should not include private keys') + self.test_importmulti({"scriptPubKey": {"address": address}, + "timestamp": "now", + "keys": [key.privkey], + "watchonly": True}, + False, + error_code=-8, + error_message='Watch-only addresses should not include private keys') address_assert = self.nodes[1].getaddressinfo(address) assert_equal(address_assert['iswatchonly'], False) assert_equal(address_assert['ismine'], False) @@ -310,13 +282,11 @@ class ImportMultiTest(BitcoinTestFramework): self.log.info("Should import a scriptPubKey with internal and with private key") key = self.get_key() address = key.p2pkh_addr - result = self.nodes[1].importmulti([{ - "scriptPubKey": key.p2pkh_script, - "timestamp": "now", - "keys": [key.privkey], - "internal": True - }]) - assert_equal(result[0]['success'], True) + self.test_importmulti({"scriptPubKey": key.p2pkh_script, + "timestamp": "now", + "keys": [key.privkey], + "internal": True}, + True) address_assert = self.nodes[1].getaddressinfo(address) assert_equal(address_assert['iswatchonly'], False) assert_equal(address_assert['ismine'], True) @@ -326,14 +296,12 @@ class ImportMultiTest(BitcoinTestFramework): self.log.info("Should not import a nonstandard scriptPubKey without internal and with private key") key = self.get_key() address = key.p2pkh_addr - result = self.nodes[1].importmulti([{ - "scriptPubKey": nonstandardScriptPubKey, - "timestamp": "now", - "keys": [key.privkey] - }]) - assert_equal(result[0]['success'], False) - assert_equal(result[0]['error']['code'], -8) - assert_equal(result[0]['error']['message'], 'Internal must be set to true for nonstandard scriptPubKey imports.') + self.test_importmulti({"scriptPubKey": nonstandardScriptPubKey, + "timestamp": "now", + "keys": [key.privkey]}, + False, + error_code=-8, + error_message='Internal must be set to true for nonstandard scriptPubKey imports.') address_assert = self.nodes[1].getaddressinfo(address) assert_equal(address_assert['iswatchonly'], False) assert_equal(address_assert['ismine'], False) @@ -347,13 +315,9 @@ class ImportMultiTest(BitcoinTestFramework): timestamp = self.nodes[1].getblock(self.nodes[1].getbestblockhash())['mediantime'] self.log.info("Should import a p2sh") - result = self.nodes[1].importmulti([{ - "scriptPubKey": { - "address": multisig.p2sh_addr - }, - "timestamp": "now", - }]) - assert_equal(result[0]['success'], True) + self.test_importmulti({"scriptPubKey": {"address": multisig.p2sh_addr}, + "timestamp": "now"}, + True) address_assert = self.nodes[1].getaddressinfo(multisig.p2sh_addr) assert_equal(address_assert['isscript'], True) assert_equal(address_assert['iswatchonly'], True) @@ -370,14 +334,10 @@ class ImportMultiTest(BitcoinTestFramework): timestamp = self.nodes[1].getblock(self.nodes[1].getbestblockhash())['mediantime'] self.log.info("Should import a p2sh with respective redeem script") - result = self.nodes[1].importmulti([{ - "scriptPubKey": { - "address": multisig.p2sh_addr - }, - "timestamp": "now", - "redeemscript": multisig.redeem_script - }]) - assert_equal(result[0]['success'], True) + self.test_importmulti({"scriptPubKey": {"address": multisig.p2sh_addr}, + "timestamp": "now", + "redeemscript": multisig.redeem_script}, + True) address_assert = self.nodes[1].getaddressinfo(multisig.p2sh_addr) assert_equal(address_assert['timestamp'], timestamp) @@ -393,15 +353,11 @@ class ImportMultiTest(BitcoinTestFramework): timestamp = self.nodes[1].getblock(self.nodes[1].getbestblockhash())['mediantime'] self.log.info("Should import a p2sh with respective redeem script and private keys") - result = self.nodes[1].importmulti([{ - "scriptPubKey": { - "address": multisig.p2sh_addr - }, - "timestamp": "now", - "redeemscript": multisig.redeem_script, - "keys": multisig.privkeys[0:2] - }]) - assert_equal(result[0]['success'], True) + self.test_importmulti({"scriptPubKey": {"address": multisig.p2sh_addr}, + "timestamp": "now", + "redeemscript": multisig.redeem_script, + "keys": multisig.privkeys[0:2]}, + True) address_assert = self.nodes[1].getaddressinfo(multisig.p2sh_addr) assert_equal(address_assert['timestamp'], timestamp) @@ -417,34 +373,26 @@ class ImportMultiTest(BitcoinTestFramework): timestamp = self.nodes[1].getblock(self.nodes[1].getbestblockhash())['mediantime'] self.log.info("Should import a p2sh with respective redeem script and private keys") - result = self.nodes[1].importmulti([{ - "scriptPubKey": { - "address": multisig.p2sh_addr - }, - "timestamp": "now", - "redeemscript": multisig.redeem_script, - "keys": multisig.privkeys[0:2], - "watchonly": True - }]) - assert_equal(result[0]['success'], False) - assert_equal(result[0]['error']['code'], -8) - assert_equal(result[0]['error']['message'], 'Watch-only addresses should not include private keys') + self.test_importmulti({"scriptPubKey": {"address": multisig.p2sh_addr}, + "timestamp": "now", + "redeemscript": multisig.redeem_script, + "keys": multisig.privkeys[0:2], + "watchonly": True}, + False, + error_code=-8, + error_message='Watch-only addresses should not include private keys') # Address + Public key + !Internal + Wrong pubkey self.log.info("Should not import an address with a wrong public key") key = self.get_key() address = key.p2pkh_addr wrong_key = self.get_key().pubkey - result = self.nodes[1].importmulti([{ - "scriptPubKey": { - "address": address - }, - "timestamp": "now", - "pubkeys": [wrong_key] - }]) - assert_equal(result[0]['success'], False) - assert_equal(result[0]['error']['code'], -5) - assert_equal(result[0]['error']['message'], 'Key does not match address destination') + self.test_importmulti({"scriptPubKey": {"address": address}, + "timestamp": "now", + "pubkeys": [wrong_key]}, + False, + error_code=-5, + error_message='Key does not match address destination') address_assert = self.nodes[1].getaddressinfo(address) assert_equal(address_assert['iswatchonly'], False) assert_equal(address_assert['ismine'], False) @@ -455,16 +403,13 @@ class ImportMultiTest(BitcoinTestFramework): key = self.get_key() address = key.p2pkh_addr wrong_key = self.get_key().pubkey - request = [{ - "scriptPubKey": key.p2pkh_script, - "timestamp": "now", - "pubkeys": [wrong_key], - "internal": True - }] - result = self.nodes[1].importmulti(request) - assert_equal(result[0]['success'], False) - assert_equal(result[0]['error']['code'], -5) - assert_equal(result[0]['error']['message'], 'Key does not match address destination') + self.test_importmulti({"scriptPubKey": key.p2pkh_script, + "timestamp": "now", + "pubkeys": [wrong_key], + "internal": True}, + False, + error_code=-5, + error_message='Key does not match address destination') address_assert = self.nodes[1].getaddressinfo(address) assert_equal(address_assert['iswatchonly'], False) assert_equal(address_assert['ismine'], False) @@ -475,16 +420,12 @@ class ImportMultiTest(BitcoinTestFramework): key = self.get_key() address = key.p2pkh_addr wrong_privkey = self.get_key().privkey - result = self.nodes[1].importmulti([{ - "scriptPubKey": { - "address": address - }, - "timestamp": "now", - "keys": [wrong_privkey] - }]) - assert_equal(result[0]['success'], False) - assert_equal(result[0]['error']['code'], -5) - assert_equal(result[0]['error']['message'], 'Key does not match address destination') + self.test_importmulti({"scriptPubKey": {"address": address}, + "timestamp": "now", + "keys": [wrong_privkey]}, + False, + error_code=-5, + error_message='Key does not match address destination') address_assert = self.nodes[1].getaddressinfo(address) assert_equal(address_assert['iswatchonly'], False) assert_equal(address_assert['ismine'], False) @@ -495,15 +436,13 @@ class ImportMultiTest(BitcoinTestFramework): key = self.get_key() address = key.p2pkh_addr wrong_privkey = self.get_key().privkey - result = self.nodes[1].importmulti([{ - "scriptPubKey": key.p2pkh_script, - "timestamp": "now", - "keys": [wrong_privkey], - "internal": True - }]) - assert_equal(result[0]['success'], False) - assert_equal(result[0]['error']['code'], -5) - assert_equal(result[0]['error']['message'], 'Key does not match address destination') + self.test_importmulti({"scriptPubKey": key.p2pkh_script, + "timestamp": "now", + "keys": [wrong_privkey], + "internal": True}, + False, + error_code=-5, + error_message='Key does not match address destination') address_assert = self.nodes[1].getaddressinfo(address) assert_equal(address_assert['iswatchonly'], False) assert_equal(address_assert['ismine'], False) @@ -512,13 +451,9 @@ class ImportMultiTest(BitcoinTestFramework): # Importing existing watch only address with new timestamp should replace saved timestamp. assert_greater_than(timestamp, watchonly_timestamp) self.log.info("Should replace previously saved watch only timestamp.") - result = self.nodes[1].importmulti([{ - "scriptPubKey": { - "address": watchonly_address, - }, - "timestamp": "now", - }]) - assert_equal(result[0]['success'], True) + self.test_importmulti({"scriptPubKey": {"address": watchonly_address}, + "timestamp": "now"}, + True) address_assert = self.nodes[1].getaddressinfo(watchonly_address) assert_equal(address_assert['iswatchonly'], True) assert_equal(address_assert['ismine'], False) @@ -547,13 +482,9 @@ class ImportMultiTest(BitcoinTestFramework): self.log.info("Should import a P2WPKH address as watch only") key = self.get_key() address = key.p2wpkh_addr - result = self.nodes[1].importmulti([{ - "scriptPubKey": { - "address": address - }, - "timestamp": "now", - }]) - assert_equal(result[0]['success'], True) + self.test_importmulti({"scriptPubKey": {"address": address}, + "timestamp": "now"}, + True) address_assert = self.nodes[1].getaddressinfo(address) assert_equal(address_assert['iswatchonly'], True) assert_equal(address_assert['solvable'], False) @@ -562,14 +493,10 @@ class ImportMultiTest(BitcoinTestFramework): self.log.info("Should import a P2WPKH address and public key as solvable but not spendable") key = self.get_key() address = key.p2wpkh_addr - result = self.nodes[1].importmulti([{ - "scriptPubKey": { - "address": address - }, - "timestamp": "now", - "pubkeys": [key.pubkey] - }]) - assert_equal(result[0]['success'], True) + self.test_importmulti({"scriptPubKey": {"address": address}, + "timestamp": "now", + "pubkeys": [key.pubkey]}, + True) address_assert = self.nodes[1].getaddressinfo(address) assert_equal(address_assert['ismine'], False) assert_equal(address_assert['solvable'], True) @@ -578,14 +505,10 @@ class ImportMultiTest(BitcoinTestFramework): self.log.info("Should import a P2WPKH address with key") key = self.get_key() address = key.p2wpkh_addr - result = self.nodes[1].importmulti([{ - "scriptPubKey": { - "address": address - }, - "timestamp": "now", - "keys": [key.privkey] - }]) - assert_equal(result[0]['success'], True) + self.test_importmulti({"scriptPubKey": {"address": address}, + "timestamp": "now", + "keys": [key.privkey]}, + True) address_assert = self.nodes[1].getaddressinfo(address) assert_equal(address_assert['iswatchonly'], False) assert_equal(address_assert['ismine'], True) @@ -593,27 +516,19 @@ class ImportMultiTest(BitcoinTestFramework): # P2WSH multisig address without scripts or keys multisig = self.get_multisig() self.log.info("Should import a p2wsh multisig as watch only without respective redeem script and private keys") - result = self.nodes[1].importmulti([{ - "scriptPubKey": { - "address": multisig.p2wsh_addr - }, - "timestamp": "now" - }]) - assert_equal(result[0]['success'], True) + self.test_importmulti({"scriptPubKey": {"address": multisig.p2wsh_addr}, + "timestamp": "now"}, + True) address_assert = self.nodes[1].getaddressinfo(multisig.p2sh_addr) assert_equal(address_assert['solvable'], False) # Same P2WSH multisig address as above, but now with witnessscript + private keys self.log.info("Should import a p2wsh with respective witness script and private keys") - result = self.nodes[1].importmulti([{ - "scriptPubKey": { - "address": multisig.p2wsh_addr - }, - "timestamp": "now", - "witnessscript": multisig.redeem_script, - "keys": multisig.privkeys - }]) - assert_equal(result[0]['success'], True) + self.test_importmulti({"scriptPubKey": {"address": multisig.p2wsh_addr}, + "timestamp": "now", + "witnessscript": multisig.redeem_script, + "keys": multisig.privkeys}, + True) address_assert = self.nodes[1].getaddressinfo(multisig.p2sh_addr) assert_equal(address_assert['solvable'], True) assert_equal(address_assert['ismine'], True) @@ -623,28 +538,20 @@ class ImportMultiTest(BitcoinTestFramework): key = self.get_key() address = key.p2sh_p2wpkh_addr self.log.info("Should import a p2sh-p2wpkh without redeem script or keys") - result = self.nodes[1].importmulti([{ - "scriptPubKey": { - "address": address - }, - "timestamp": "now" - }]) - assert_equal(result[0]['success'], True) + self.test_importmulti({"scriptPubKey": {"address": address}, + "timestamp": "now"}, + True) address_assert = self.nodes[1].getaddressinfo(address) assert_equal(address_assert['solvable'], False) assert_equal(address_assert['ismine'], False) # P2SH-P2WPKH address + redeemscript + public key with no private key self.log.info("Should import a p2sh-p2wpkh with respective redeem script and pubkey as solvable") - result = self.nodes[1].importmulti([{ - "scriptPubKey": { - "address": address - }, - "timestamp": "now", - "redeemscript": key.p2sh_p2wpkh_redeem_script, - "pubkeys": [key.pubkey] - }]) - assert_equal(result[0]['success'], True) + self.test_importmulti({"scriptPubKey": {"address": address}, + "timestamp": "now", + "redeemscript": key.p2sh_p2wpkh_redeem_script, + "pubkeys": [key.pubkey]}, + True) address_assert = self.nodes[1].getaddressinfo(address) assert_equal(address_assert['solvable'], True) assert_equal(address_assert['ismine'], False) @@ -653,15 +560,11 @@ class ImportMultiTest(BitcoinTestFramework): key = self.get_key() address = key.p2sh_p2wpkh_addr self.log.info("Should import a p2sh-p2wpkh with respective redeem script and private keys") - result = self.nodes[1].importmulti([{ - "scriptPubKey": { - "address": address - }, - "timestamp": "now", - "redeemscript": key.p2sh_p2wpkh_redeem_script, - "keys": [key.privkey] - }]) - assert_equal(result[0]['success'], True) + self.test_importmulti({"scriptPubKey": {"address": address}, + "timestamp": "now", + "redeemscript": key.p2sh_p2wpkh_redeem_script, + "keys": [key.privkey]}, + True) address_assert = self.nodes[1].getaddressinfo(address) assert_equal(address_assert['solvable'], True) assert_equal(address_assert['ismine'], True) @@ -669,15 +572,11 @@ class ImportMultiTest(BitcoinTestFramework): # P2SH-P2WSH multisig + redeemscript with no private key multisig = self.get_multisig() self.log.info("Should import a p2sh-p2wsh with respective redeem script but no private key") - result = self.nodes[1].importmulti([{ - "scriptPubKey": { - "address": multisig.p2sh_p2wsh_addr - }, - "timestamp": "now", - "redeemscript": multisig.p2wsh_script, - "witnessscript": multisig.redeem_script, - }]) - assert_equal(result[0]['success'], True) + self.test_importmulti({"scriptPubKey": {"address": multisig.p2sh_p2wsh_addr}, + "timestamp": "now", + "redeemscript": multisig.p2wsh_script, + "witnessscript": multisig.redeem_script}, + True) address_assert = self.nodes[1].getaddressinfo(multisig.p2sh_addr) assert_equal(address_assert['solvable'], True) -- cgit v1.2.3 From fbdba40594d549c76aaf15401fe994ac5cfc4f73 Mon Sep 17 00:00:00 2001 From: John Newbery Date: Thu, 6 Dec 2018 10:20:11 -0500 Subject: [tests] add test_address method to wallet_import.py Adds a new test_address method for testing the imported addresses. --- test/functional/wallet_importmulti.py | 209 ++++++++++++++++++---------------- 1 file changed, 109 insertions(+), 100 deletions(-) diff --git a/test/functional/wallet_importmulti.py b/test/functional/wallet_importmulti.py index d5ff1d2f25..cb44cddf83 100755 --- a/test/functional/wallet_importmulti.py +++ b/test/functional/wallet_importmulti.py @@ -116,6 +116,16 @@ class ImportMultiTest(BitcoinTestFramework): assert_equal(result[0]['error']['code'], error_code) assert_equal(result[0]['error']['message'], error_message) + def test_address(self, address, **kwargs): + """Get address info for `address` and test whether the returned values are as expected.""" + addr_info = self.nodes[1].getaddressinfo(address) + for key, value in kwargs.items(): + if value is None: + if key in addr_info.keys(): + raise AssertionError("key {} unexpectedly returned in getaddressinfo.".format(key)) + elif addr_info[key] != value: + raise AssertionError("key {} value {} did not match expected value {}".format(key, addr_info[key], value)) + def run_test(self): self.log.info("Mining blocks...") self.nodes[0].generate(1) @@ -144,11 +154,11 @@ class ImportMultiTest(BitcoinTestFramework): self.test_importmulti({"scriptPubKey": {"address": address}, "timestamp": "now"}, True) - address_assert = self.nodes[1].getaddressinfo(address) - assert_equal(address_assert['iswatchonly'], True) - assert_equal(address_assert['ismine'], False) - assert_equal(address_assert['timestamp'], timestamp) - assert_equal(address_assert['ischange'], False) + self.test_address(address, + iswatchonly=True, + ismine=False, + timestamp=timestamp, + ischange=False) watchonly_address = address watchonly_timestamp = timestamp @@ -166,11 +176,11 @@ class ImportMultiTest(BitcoinTestFramework): "timestamp": "now", "internal": True}, True) - address_assert = self.nodes[1].getaddressinfo(key.p2pkh_addr) - assert_equal(address_assert['iswatchonly'], True) - assert_equal(address_assert['ismine'], False) - assert_equal(address_assert['timestamp'], timestamp) - assert_equal(address_assert['ischange'], True) + self.test_address(key.p2pkh_addr, + iswatchonly=True, + ismine=False, + timestamp=timestamp, + ischange=True) # ScriptPubKey + internal + label self.log.info("Should not allow a label to be specified when internal is true") @@ -193,10 +203,10 @@ class ImportMultiTest(BitcoinTestFramework): False, error_code=-8, error_message='Internal must be set to true for nonstandard scriptPubKey imports.') - address_assert = self.nodes[1].getaddressinfo(address) - assert_equal(address_assert['iswatchonly'], False) - assert_equal(address_assert['ismine'], False) - assert_equal('timestamp' in address_assert, False) + self.test_address(address, + iswatchonly=False, + ismine=False, + timestamp=None) # Address + Public key + !Internal(explicit) self.log.info("Should import an address with public key") @@ -207,10 +217,10 @@ class ImportMultiTest(BitcoinTestFramework): "pubkeys": [key.pubkey], "internal": False}, True) - address_assert = self.nodes[1].getaddressinfo(address) - assert_equal(address_assert['iswatchonly'], True) - assert_equal(address_assert['ismine'], False) - assert_equal(address_assert['timestamp'], timestamp) + self.test_address(address, + iswatchonly=True, + ismine=False, + timestamp=timestamp) # ScriptPubKey + Public key + internal self.log.info("Should import a scriptPubKey with internal and with public key") @@ -221,10 +231,10 @@ class ImportMultiTest(BitcoinTestFramework): "pubkeys": [key.pubkey], "internal": True}, True) - address_assert = self.nodes[1].getaddressinfo(address) - assert_equal(address_assert['iswatchonly'], True) - assert_equal(address_assert['ismine'], False) - assert_equal(address_assert['timestamp'], timestamp) + self.test_address(address, + iswatchonly=True, + ismine=False, + timestamp=timestamp) # Nonstandard scriptPubKey + Public key + !internal self.log.info("Should not import a nonstandard scriptPubKey without internal and with public key") @@ -236,10 +246,10 @@ class ImportMultiTest(BitcoinTestFramework): False, error_code=-8, error_message='Internal must be set to true for nonstandard scriptPubKey imports.') - address_assert = self.nodes[1].getaddressinfo(address) - assert_equal(address_assert['iswatchonly'], False) - assert_equal(address_assert['ismine'], False) - assert_equal('timestamp' in address_assert, False) + self.test_address(address, + iswatchonly=False, + ismine=False, + timestamp=None) # Address + Private key + !watchonly self.log.info("Should import an address with private key") @@ -249,10 +259,10 @@ class ImportMultiTest(BitcoinTestFramework): "timestamp": "now", "keys": [key.privkey]}, True) - address_assert = self.nodes[1].getaddressinfo(address) - assert_equal(address_assert['iswatchonly'], False) - assert_equal(address_assert['ismine'], True) - assert_equal(address_assert['timestamp'], timestamp) + self.test_address(address, + iswatchonly=False, + ismine=True, + timestamp=timestamp) self.log.info("Should not import an address with private key if is already imported") self.test_importmulti({"scriptPubKey": {"address": address}, @@ -273,10 +283,10 @@ class ImportMultiTest(BitcoinTestFramework): False, error_code=-8, error_message='Watch-only addresses should not include private keys') - address_assert = self.nodes[1].getaddressinfo(address) - assert_equal(address_assert['iswatchonly'], False) - assert_equal(address_assert['ismine'], False) - assert_equal('timestamp' in address_assert, False) + self.test_address(address, + iswatchonly=False, + ismine=False, + timestamp=None) # ScriptPubKey + Private key + internal self.log.info("Should import a scriptPubKey with internal and with private key") @@ -287,10 +297,10 @@ class ImportMultiTest(BitcoinTestFramework): "keys": [key.privkey], "internal": True}, True) - address_assert = self.nodes[1].getaddressinfo(address) - assert_equal(address_assert['iswatchonly'], False) - assert_equal(address_assert['ismine'], True) - assert_equal(address_assert['timestamp'], timestamp) + self.test_address(address, + iswatchonly=False, + ismine=True, + timestamp=timestamp) # Nonstandard scriptPubKey + Private key + !internal self.log.info("Should not import a nonstandard scriptPubKey without internal and with private key") @@ -302,10 +312,10 @@ class ImportMultiTest(BitcoinTestFramework): False, error_code=-8, error_message='Internal must be set to true for nonstandard scriptPubKey imports.') - address_assert = self.nodes[1].getaddressinfo(address) - assert_equal(address_assert['iswatchonly'], False) - assert_equal(address_assert['ismine'], False) - assert_equal('timestamp' in address_assert, False) + self.test_address(address, + iswatchonly=False, + ismine=False, + timestamp=None) # P2SH address multisig = self.get_multisig() @@ -318,10 +328,10 @@ class ImportMultiTest(BitcoinTestFramework): self.test_importmulti({"scriptPubKey": {"address": multisig.p2sh_addr}, "timestamp": "now"}, True) - address_assert = self.nodes[1].getaddressinfo(multisig.p2sh_addr) - assert_equal(address_assert['isscript'], True) - assert_equal(address_assert['iswatchonly'], True) - assert_equal(address_assert['timestamp'], timestamp) + self.test_address(multisig.p2sh_addr, + isscript=True, + iswatchonly=True, + timestamp=timestamp) p2shunspent = self.nodes[1].listunspent(0, 999999, [multisig.p2sh_addr])[0] assert_equal(p2shunspent['spendable'], False) assert_equal(p2shunspent['solvable'], False) @@ -338,8 +348,7 @@ class ImportMultiTest(BitcoinTestFramework): "timestamp": "now", "redeemscript": multisig.redeem_script}, True) - address_assert = self.nodes[1].getaddressinfo(multisig.p2sh_addr) - assert_equal(address_assert['timestamp'], timestamp) + self.test_address(multisig.p2sh_addr, timestamp=timestamp) p2shunspent = self.nodes[1].listunspent(0, 999999, [multisig.p2sh_addr])[0] assert_equal(p2shunspent['spendable'], False) @@ -358,8 +367,8 @@ class ImportMultiTest(BitcoinTestFramework): "redeemscript": multisig.redeem_script, "keys": multisig.privkeys[0:2]}, True) - address_assert = self.nodes[1].getaddressinfo(multisig.p2sh_addr) - assert_equal(address_assert['timestamp'], timestamp) + self.test_address(multisig.p2sh_addr, + timestamp=timestamp) p2shunspent = self.nodes[1].listunspent(0, 999999, [multisig.p2sh_addr])[0] assert_equal(p2shunspent['spendable'], False) @@ -393,10 +402,10 @@ class ImportMultiTest(BitcoinTestFramework): False, error_code=-5, error_message='Key does not match address destination') - address_assert = self.nodes[1].getaddressinfo(address) - assert_equal(address_assert['iswatchonly'], False) - assert_equal(address_assert['ismine'], False) - assert_equal('timestamp' in address_assert, False) + self.test_address(address, + iswatchonly=False, + ismine=False, + timestamp=None) # ScriptPubKey + Public key + internal + Wrong pubkey self.log.info("Should not import a scriptPubKey with internal and with a wrong public key") @@ -410,10 +419,10 @@ class ImportMultiTest(BitcoinTestFramework): False, error_code=-5, error_message='Key does not match address destination') - address_assert = self.nodes[1].getaddressinfo(address) - assert_equal(address_assert['iswatchonly'], False) - assert_equal(address_assert['ismine'], False) - assert_equal('timestamp' in address_assert, False) + self.test_address(address, + iswatchonly=False, + ismine=False, + timestamp=None) # Address + Private key + !watchonly + Wrong private key self.log.info("Should not import an address with a wrong private key") @@ -426,10 +435,10 @@ class ImportMultiTest(BitcoinTestFramework): False, error_code=-5, error_message='Key does not match address destination') - address_assert = self.nodes[1].getaddressinfo(address) - assert_equal(address_assert['iswatchonly'], False) - assert_equal(address_assert['ismine'], False) - assert_equal('timestamp' in address_assert, False) + self.test_address(address, + iswatchonly=False, + ismine=False, + timestamp=None) # ScriptPubKey + Private key + internal + Wrong private key self.log.info("Should not import a scriptPubKey with internal and with a wrong private key") @@ -443,10 +452,10 @@ class ImportMultiTest(BitcoinTestFramework): False, error_code=-5, error_message='Key does not match address destination') - address_assert = self.nodes[1].getaddressinfo(address) - assert_equal(address_assert['iswatchonly'], False) - assert_equal(address_assert['ismine'], False) - assert_equal('timestamp' in address_assert, False) + self.test_address(address, + iswatchonly=False, + ismine=False, + timestamp=None) # Importing existing watch only address with new timestamp should replace saved timestamp. assert_greater_than(timestamp, watchonly_timestamp) @@ -454,19 +463,19 @@ class ImportMultiTest(BitcoinTestFramework): self.test_importmulti({"scriptPubKey": {"address": watchonly_address}, "timestamp": "now"}, True) - address_assert = self.nodes[1].getaddressinfo(watchonly_address) - assert_equal(address_assert['iswatchonly'], True) - assert_equal(address_assert['ismine'], False) - assert_equal(address_assert['timestamp'], timestamp) + self.test_address(watchonly_address, + iswatchonly=True, + ismine=False, + timestamp=timestamp) watchonly_timestamp = timestamp # restart nodes to check for proper serialization/deserialization of watch only address self.stop_nodes() self.start_nodes() - address_assert = self.nodes[1].getaddressinfo(watchonly_address) - assert_equal(address_assert['iswatchonly'], True) - assert_equal(address_assert['ismine'], False) - assert_equal(address_assert['timestamp'], watchonly_timestamp) + self.test_address(watchonly_address, + iswatchonly=True, + ismine=False, + timestamp=watchonly_timestamp) # Bad or missing timestamps self.log.info("Should throw on invalid or missing timestamp values") @@ -485,9 +494,9 @@ class ImportMultiTest(BitcoinTestFramework): self.test_importmulti({"scriptPubKey": {"address": address}, "timestamp": "now"}, True) - address_assert = self.nodes[1].getaddressinfo(address) - assert_equal(address_assert['iswatchonly'], True) - assert_equal(address_assert['solvable'], False) + self.test_address(address, + iswatchonly=True, + solvable=False) # Import P2WPKH address with public key but no private key self.log.info("Should import a P2WPKH address and public key as solvable but not spendable") @@ -497,9 +506,9 @@ class ImportMultiTest(BitcoinTestFramework): "timestamp": "now", "pubkeys": [key.pubkey]}, True) - address_assert = self.nodes[1].getaddressinfo(address) - assert_equal(address_assert['ismine'], False) - assert_equal(address_assert['solvable'], True) + self.test_address(address, + ismine=False, + solvable=True) # Import P2WPKH address with key and check it is spendable self.log.info("Should import a P2WPKH address with key") @@ -509,9 +518,9 @@ class ImportMultiTest(BitcoinTestFramework): "timestamp": "now", "keys": [key.privkey]}, True) - address_assert = self.nodes[1].getaddressinfo(address) - assert_equal(address_assert['iswatchonly'], False) - assert_equal(address_assert['ismine'], True) + self.test_address(address, + iswatchonly=False, + ismine=True) # P2WSH multisig address without scripts or keys multisig = self.get_multisig() @@ -519,8 +528,8 @@ class ImportMultiTest(BitcoinTestFramework): self.test_importmulti({"scriptPubKey": {"address": multisig.p2wsh_addr}, "timestamp": "now"}, True) - address_assert = self.nodes[1].getaddressinfo(multisig.p2sh_addr) - assert_equal(address_assert['solvable'], False) + self.test_address(multisig.p2sh_addr, + solvable=False) # Same P2WSH multisig address as above, but now with witnessscript + private keys self.log.info("Should import a p2wsh with respective witness script and private keys") @@ -529,10 +538,10 @@ class ImportMultiTest(BitcoinTestFramework): "witnessscript": multisig.redeem_script, "keys": multisig.privkeys}, True) - address_assert = self.nodes[1].getaddressinfo(multisig.p2sh_addr) - assert_equal(address_assert['solvable'], True) - assert_equal(address_assert['ismine'], True) - assert_equal(address_assert['sigsrequired'], 2) + self.test_address(multisig.p2sh_addr, + solvable=True, + ismine=True, + sigsrequired=2) # P2SH-P2WPKH address with no redeemscript or public or private key key = self.get_key() @@ -541,9 +550,9 @@ class ImportMultiTest(BitcoinTestFramework): self.test_importmulti({"scriptPubKey": {"address": address}, "timestamp": "now"}, True) - address_assert = self.nodes[1].getaddressinfo(address) - assert_equal(address_assert['solvable'], False) - assert_equal(address_assert['ismine'], False) + self.test_address(address, + solvable=False, + ismine=False) # P2SH-P2WPKH address + redeemscript + public key with no private key self.log.info("Should import a p2sh-p2wpkh with respective redeem script and pubkey as solvable") @@ -552,9 +561,9 @@ class ImportMultiTest(BitcoinTestFramework): "redeemscript": key.p2sh_p2wpkh_redeem_script, "pubkeys": [key.pubkey]}, True) - address_assert = self.nodes[1].getaddressinfo(address) - assert_equal(address_assert['solvable'], True) - assert_equal(address_assert['ismine'], False) + self.test_address(address, + solvable=True, + ismine=False) # P2SH-P2WPKH address + redeemscript + private key key = self.get_key() @@ -565,9 +574,9 @@ class ImportMultiTest(BitcoinTestFramework): "redeemscript": key.p2sh_p2wpkh_redeem_script, "keys": [key.privkey]}, True) - address_assert = self.nodes[1].getaddressinfo(address) - assert_equal(address_assert['solvable'], True) - assert_equal(address_assert['ismine'], True) + self.test_address(address, + solvable=True, + ismine=True) # P2SH-P2WSH multisig + redeemscript with no private key multisig = self.get_multisig() @@ -577,8 +586,8 @@ class ImportMultiTest(BitcoinTestFramework): "redeemscript": multisig.p2wsh_script, "witnessscript": multisig.redeem_script}, True) - address_assert = self.nodes[1].getaddressinfo(multisig.p2sh_addr) - assert_equal(address_assert['solvable'], True) + self.test_address(address, + solvable=True) if __name__ == '__main__': ImportMultiTest().main() -- cgit v1.2.3 From ee3b21dccbeb0f9d4e99de869dbfaf625c159c7f Mon Sep 17 00:00:00 2001 From: John Newbery Date: Thu, 6 Dec 2018 13:29:32 -0500 Subject: [tests] Add docstring for wallet_importmulti.py Adds a docstring describing the new importmulti test. --- test/functional/wallet_importmulti.py | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/test/functional/wallet_importmulti.py b/test/functional/wallet_importmulti.py index cb44cddf83..a163f7018c 100755 --- a/test/functional/wallet_importmulti.py +++ b/test/functional/wallet_importmulti.py @@ -2,7 +2,18 @@ # Copyright (c) 2014-2018 The Bitcoin Core developers # Distributed under the MIT software license, see the accompanying # file COPYING or http://www.opensource.org/licenses/mit-license.php. -"""Test the importmulti RPC.""" +"""Test the importmulti RPC. + +Test importmulti by generating keys on node0, importing the scriptPubKeys and +addresses on node1 and then testing the address info for the different address +variants. + +- `get_key()` and `get_multisig()` are called to generate keys on node0 and + return the privkeys, pubkeys and all variants of scriptPubKey and address. +- `test_importmulti()` is called to send an importmulti call to node1, test + success, and (if unsuccessful) test the error code and error message returned. +- `test_address()` is called to call getaddressinfo for an address on node1 + and test the values returned.""" from collections import namedtuple from test_framework.address import ( -- cgit v1.2.3