Merge #14454: Add SegWit support to importmulti

c11875c5908a17314bb38caa911507dc6401ec49 Add segwit address tests for importmulti (MeshCollider)
201451b1ca3c6db3b13f9491a81db5b120b864bb Make getaddressinfo return solvability (MeshCollider)
1753d217ead7e2de35b3df6cd6573a1c9a068f84 Add release notes for importmulti segwit change (MeshCollider)
353c064596fc2e2c149987ac3b3c11b4c90c4d5f Fix typo in test_framework/blocktools (MeshCollider)
f6ed748cf045d7f0d9a49e15cc0c0001610b9231 Add SegWit support to importmulti with some ProcessImport cleanup (MeshCollider)

Pull request description:

  Add support for segwit to importmulti, supports P2WSH, P2WPKH, P2SH-P2WPKH, P2SH-P2WSH. Adds a new `witnessscript` parameter which must be used for the witness scripts in the relevant situations.

  Also includes some tests for the various import types.

  ~Also makes the change in #14019 redundant, but cherry-picks the test from that PR to test the behavior (@achow101).~

  Fixes #12253, also addresses the second point in #12703, and fixes #14407

Tree-SHA512: 775a755c524d1c387a99acddd772f677d2073876b72403dcfb92c59f9b405ae13ceedcf4dbd2ee1d7a8db91c494f67ca137161032ee3a2071282eeb411be090a

2 files changed, 168 insertions, 8 deletions

diff --git a/test/functional/test_framework/blocktools.py b/test/functional/test_framework/blocktools.py
index 35004fb588..81cce1167b 100644
--- a/test/functional/test_framework/blocktools.py
+++ b/test/functional/test_framework/blocktools.py
@@ -169,7 +169,7 @@ def get_legacy_sigopcount_tx(tx, accurate=True):
     return count
 
 def witness_script(use_p2wsh, pubkey):
-    """Create a scriptPubKey for a pay-to-wtiness TxOut.
+    """Create a scriptPubKey for a pay-to-witness TxOut.
 
     This is either a P2WPKH output for the given pubkey, or a P2WSH output of a
     1-of-1 multisig for the given pubkey. Returns the hex encoding of the
diff --git a/test/functional/wallet_importmulti.py b/test/functional/wallet_importmulti.py
index f78ff19791..9ba6860306 100755
--- a/test/functional/wallet_importmulti.py
+++ b/test/functional/wallet_importmulti.py
@@ -11,8 +11,14 @@ from test_framework.util import (
     assert_greater_than,
     assert_raises_rpc_error,
     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):
@@ -90,6 +96,19 @@ class ImportMultiTest(BitcoinTestFramework):
         assert_equal(address_assert['ismine'], False)
         assert_equal(address_assert['timestamp'], timestamp)
 
+        # 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())
+        result = self.nodes[1].importmulti([{
+            "scriptPubKey": address['scriptPubKey'],
+            "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')
+
         # 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]))
@@ -198,7 +217,7 @@ class ImportMultiTest(BitcoinTestFramework):
         }])
         assert_equal(result[0]['success'], False)
         assert_equal(result[0]['error']['code'], -8)
-        assert_equal(result[0]['error']['message'], 'Incompatibility found between watchonly and keys')
+        assert_equal(result[0]['error']['message'], 'Watch-only addresses should not include private keys')
         address_assert = self.nodes[1].getaddressinfo(address['address'])
         assert_equal(address_assert['iswatchonly'], False)
         assert_equal(address_assert['ismine'], False)
@@ -339,7 +358,7 @@ class ImportMultiTest(BitcoinTestFramework):
         }])
         assert_equal(result[0]['success'], False)
         assert_equal(result[0]['error']['code'], -8)
-        assert_equal(result[0]['error']['message'], 'Incompatibility found between watchonly and keys')
+        assert_equal(result[0]['error']['message'], 'Watch-only addresses should not include private keys')
 
 
         # Address + Public key + !Internal + Wrong pubkey
@@ -355,7 +374,7 @@ class ImportMultiTest(BitcoinTestFramework):
         }])
         assert_equal(result[0]['success'], False)
         assert_equal(result[0]['error']['code'], -5)
-        assert_equal(result[0]['error']['message'], 'Consistency check failed')
+        assert_equal(result[0]['error']['message'], 'Key does not match address destination')
         address_assert = self.nodes[1].getaddressinfo(address['address'])
         assert_equal(address_assert['iswatchonly'], False)
         assert_equal(address_assert['ismine'], False)
@@ -375,7 +394,7 @@ class ImportMultiTest(BitcoinTestFramework):
         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'], 'Consistency check failed')
+        assert_equal(result[0]['error']['message'], 'Key does not match address destination')
         address_assert = self.nodes[1].getaddressinfo(address['address'])
         assert_equal(address_assert['iswatchonly'], False)
         assert_equal(address_assert['ismine'], False)
@@ -395,7 +414,7 @@ class ImportMultiTest(BitcoinTestFramework):
         }])
         assert_equal(result[0]['success'], False)
         assert_equal(result[0]['error']['code'], -5)
-        assert_equal(result[0]['error']['message'], 'Consistency check failed')
+        assert_equal(result[0]['error']['message'], 'Key does not match address destination')
         address_assert = self.nodes[1].getaddressinfo(address['address'])
         assert_equal(address_assert['iswatchonly'], False)
         assert_equal(address_assert['ismine'], False)
@@ -414,7 +433,7 @@ class ImportMultiTest(BitcoinTestFramework):
         }])
         assert_equal(result[0]['success'], False)
         assert_equal(result[0]['error']['code'], -5)
-        assert_equal(result[0]['error']['message'], 'Consistency check failed')
+        assert_equal(result[0]['error']['message'], 'Key does not match address destination')
         address_assert = self.nodes[1].getaddressinfo(address['address'])
         assert_equal(address_assert['iswatchonly'], False)
         assert_equal(address_assert['ismine'], False)
@@ -458,6 +477,147 @@ class ImportMultiTest(BitcoinTestFramework):
                 "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"))
+        result = self.nodes[1].importmulti([{
+            "scriptPubKey": {
+                "address": address['address']
+            },
+            "timestamp": "now",
+        }])
+        assert_equal(result[0]['success'], True)
+        address_assert = self.nodes[1].getaddressinfo(address['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"))
+        result = self.nodes[1].importmulti([{
+            "scriptPubKey": {
+                "address": address['address']
+            },
+            "timestamp": "now",
+            "pubkeys": [ address['pubkey'] ]
+        }])
+        assert_equal(result[0]['success'], True)
+        address_assert = self.nodes[1].getaddressinfo(address['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"))
+        result = self.nodes[1].importmulti([{
+            "scriptPubKey": {
+                "address": address['address']
+            },
+            "timestamp": "now",
+            "keys": [self.nodes[0].dumpprivkey(address['address'])]
+        }])
+        assert_equal(result[0]['success'], True)
+        address_assert = self.nodes[1].getaddressinfo(address['address'])
+        assert_equal(address_assert['iswatchonly'], False)
+        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")
+        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']
+            },
+            "timestamp": "now"
+        }])
+        assert_equal(result[0]['success'], True)
+        address_assert = self.nodes[1].getaddressinfo(multi_sig_script['address'])
+        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")
+        result = self.nodes[1].importmulti([{
+            "scriptPubKey": {
+                "address": multi_sig_script['address']
+            },
+            "timestamp": "now",
+            "witnessscript": multi_sig_script['redeemScript'],
+            "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['solvable'], True)
+        assert_equal(address_assert['ismine'], True)
+        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])
+        self.log.info("Should import a p2sh-p2wpkh without redeem script or keys")
+        result = self.nodes[1].importmulti([{
+            "scriptPubKey": {
+                "address": sig_address_1['address']
+            },
+            "timestamp": "now"
+        }])
+        assert_equal(result[0]['success'], True)
+        address_assert = self.nodes[1].getaddressinfo(sig_address_1['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": sig_address_1['address']
+            },
+            "timestamp": "now",
+            "redeemscript": bytes_to_hex_str(pkscript),
+            "pubkeys": [ sig_address_1['pubkey'] ]
+        }])
+        assert_equal(result[0]['success'], True)
+        address_assert = self.nodes[1].getaddressinfo(sig_address_1['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])
+        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']
+            },
+            "timestamp": "now",
+            "redeemscript": bytes_to_hex_str(pkscript),
+            "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'])
+        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])
+        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']
+            },
+            "timestamp": "now",
+            "redeemscript": bytes_to_hex_str(redeem_script),
+            "witnessscript": multi_sig_script['redeemScript']
+        }])
+        assert_equal(result[0]['success'], True)
+        address_assert = self.nodes[1].getaddressinfo(multi_sig_script['address'])
+        assert_equal(address_assert['solvable'], True)
 
 if __name__ == '__main__':
     ImportMultiTest ().main ()