Merge #14454: Add SegWit support to importmulti

c11875c590 Add segwit address tests for importmulti (MeshCollider) 201451b1ca Make getaddressinfo return solvability (MeshCollider) 1753d217ea Add release notes for importmulti segwit change (MeshCollider) 353c064596 Fix typo in test_framework/blocktools (MeshCollider) f6ed748cf0 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
2025-07-13 06:11:27 +02:00 · 2018-10-31 17:33:34 +01:00
parent 29f429dc7d c11875c590
commit b312579c69
5 changed files with 309 additions and 174 deletions
--- 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
--- 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 ()