Inside Bitcoin

251                assert_equal(e.error["code"], -1)
252                assert_equal(e.error["message"], "Rescan aborted by user.")
253
254    def test_musig_private_key_warnings(self, xprv1, acc_xprv2, acc_xpub2, derivation_path):
255        self.log.info("Testing importdescriptors MuSig private key warnings")
256
257        self.nodes[1].createwallet(wallet_name="musig_import_warnings", blank=True)
258        wallet = self.nodes[1].get_wallet_rpc("musig_import_warnings")
259        res = wallet.importdescriptors([
260            {
261                "desc": descsum_create(f"rawtr(musig({xprv1}/{derivation_path}/0,{acc_xprv2}/1))"),
262                "timestamp": "now",
263            },
264            {
265                "desc": descsum_create(f"rawtr(musig({xprv1}/{derivation_path}/2,{acc_xpub2}/3))"),
266                "timestamp": "now",
267            },
268            {
269                "desc": descsum_create(f"rawtr(musig({xprv1}/{derivation_path},{acc_xprv2})/0/*)"),
270                "timestamp": "now",
271                "range": [0, 1],
272            },
273            {
274                "desc": descsum_create(f"rawtr(musig({xprv1}/{derivation_path},{acc_xpub2})/1/*)"),
275                "timestamp": "now",
276                "range": [0, 1],
277            },
278        ])
279
280        assert_equal(res[0]["success"], True)
281        assert "warnings" not in res[0]
282        assert_equal(res[1]["success"], True)
283        assert_equal(res[1]["warnings"], [MISSING_KEYS_WARNING])
284        assert_equal(res[2]["success"], True)
285        assert "warnings" not in res[2]
286        assert_equal(res[3]["success"], True)
287        assert_equal(res[3]["warnings"], [MISSING_KEYS_WARNING])
288
289    def run_test(self):
290        self.log.info('Setting up wallets')
291        self.nodes[0].createwallet(wallet_name='w0', disable_private_keys=False)
292        w0 = self.nodes[0].get_wallet_rpc('w0')
293
294        self.nodes[1].createwallet(wallet_name='w1', disable_private_keys=True, blank=True)
295        w1 = self.nodes[1].get_wallet_rpc('w1')
296        assert_equal(w1.getwalletinfo()['keypoolsize'], 0)
297
298        self.nodes[1].createwallet(wallet_name="wpriv", disable_private_keys=False, blank=True)
299        wpriv = self.nodes[1].get_wallet_rpc("wpriv")
300        assert_equal(wpriv.getwalletinfo()['keypoolsize'], 0)
301
302        self.log.info('Mining coins')
303        self.generatetoaddress(self.nodes[0], COINBASE_MATURITY + 1, w0.getnewaddress())
304
305        # RPC importdescriptors -----------------------------------------------
306
307        # # Test import fails if no descriptor present
308        self.log.info("Import should fail if a descriptor is not provided")
309        self.test_importdesc({"timestamp": "now"},
310                             success=False,
311                             error_code=-8,
312                             error_message='Descriptor not found.')
313
314        # Test import fails if one timestamp is invalid or missing
315        self.log.info("Import should fail if timestamp is missing or an invalid timestamp is present in the request")
316        key = get_generate_key()
317        import_request = {"desc": descsum_create("pkh(" + key.pubkey + ")"), "label": "Descriptor import test"}
318        self.test_importdesc(import_request,
319            success=False,
320            global_error=True,
321            error_code=-3,
322            error_message="Missing required timestamp field for key")
323
324        import_request = {"desc": descsum_create("pkh(" + key.pubkey + ")"),
325            "timestamp": "this_is_not_a_valid_timestamp",
326            "label": "Descriptor import test"}
327        self.test_importdesc(import_request,
328            success=False,
329            global_error=True,
330            error_code=-3,
331            error_message='Expected number or "now" timestamp value for key. got type string')
332
333        # # Test importing of a P2PKH descriptor
334        key = get_generate_key()
335        self.log.info("Should import a p2pkh descriptor")
336        import_request = {"desc": descsum_create("pkh(" + key.pubkey + ")"),
337                 "timestamp": "now",
338                 "label": "Descriptor import test"}
339        self.test_importdesc(import_request, success=True)
340        test_address(w1,
341                     key.p2pkh_addr,
342                     solvable=True,
343                     ismine=True,
344                     labels=["Descriptor import test"])
345        assert_equal(w1.getwalletinfo()['keypoolsize'], 0)
346
347        self.log.info("Test can import same descriptor with public key twice")
348        list_descs = w1.listdescriptors()
349        self.test_importdesc(import_request, success=True)
350        assert_equal(list_descs, w1.listdescriptors())
351
352        self.log.info("Test can update descriptor label")
353        self.test_importdesc({**import_request, "label": "Updated label"}, success=True)
354        test_address(w1, key.p2pkh_addr, solvable=True, ismine=True, labels=["Updated label"])
355        assert_equal(list_descs, w1.listdescriptors())
356
357        self.log.info("Internal addresses cannot have labels")
358        self.test_importdesc({**import_request, "internal": True},
359                             success=False,
360                             error_code=-8,
361                             error_message="Internal addresses should not have a label")
362
363        self.log.info("External non-ranged addresses can have labels")
364        self.test_importdesc({**import_request, "internal": False}, success=True)
365
366        self.log.info("Internal addresses should be detected as such")
367        key = get_generate_key()
368        self.test_importdesc({"desc": descsum_create("pkh(" + key.pubkey + ")"),
369                              "timestamp": "now",
370                              "internal": True},
371                             success=True)
372        info = w1.getaddressinfo(key.p2pkh_addr)
373        assert_equal(info["ismine"], True)
374        assert_equal(info["ischange"], True)
375
376        self.log.info("Should not import a descriptor with an invalid public key due to whitespace")
377        self.test_importdesc({"desc": descsum_create("pkh( " + key.pubkey + ")"),
378                                    "timestamp": "now",
379                                    "internal": True},
380                                    error_code=-5,
381                                    error_message=f"pkh(): Key ' {key.pubkey}' is invalid due to whitespace",
382                                    success=False)
383        self.test_importdesc({"desc": descsum_create("pkh(" + key.pubkey + " )"),
384                                    "timestamp": "now",
385                                    "internal": True},
386                                    error_code=-5,
387                                    error_message=f"pkh(): Key '{key.pubkey} ' is invalid due to whitespace",
388                                    success=False)
389
390        # # Test importing of a P2SH-P2WPKH descriptor
391        key = get_generate_key()
392        self.log.info("Should not import a p2sh-p2wpkh descriptor without checksum")
393        self.test_importdesc({"desc": "sh(wpkh(" + key.pubkey + "))",
394                              "timestamp": "now"
395                              },
396                             success=False,
397                             error_code=-5,
398                             error_message="Missing checksum")
399
400        self.log.info("Should not import a p2sh-p2wpkh descriptor that has range specified")
401        self.test_importdesc({"desc": descsum_create("sh(wpkh(" + key.pubkey + "))"),
402                               "timestamp": "now",
403                               "range": 1,
404                              },
405                              success=False,
406                              error_code=-8,
407                              error_message="Range should not be specified for an un-ranged descriptor")
408
409        self.log.info("Should not import a p2sh-p2wpkh descriptor and have it set to active")
410        self.test_importdesc({"desc": descsum_create("sh(wpkh(" + key.pubkey + "))"),
411                               "timestamp": "now",
412                               "active": True,
413                              },
414                              success=False,
415                              error_code=-8,
416                              error_message="Active descriptors must be ranged")
417
418        self.log.info("Should import a (non-active) p2sh-p2wpkh descriptor")
419        self.test_importdesc({"desc": descsum_create("sh(wpkh(" + key.pubkey + "))"),
420                               "timestamp": "now",
421                               "active": False,
422                              },
423                              success=True)
424        assert_equal(w1.getwalletinfo()['keypoolsize'], 0)
425
426        test_address(w1,
427                     key.p2sh_p2wpkh_addr,
428                     ismine=True,
429                     solvable=True)
430
431        # Check persistence of data and that loading works correctly
432        w1.unloadwallet()
433        self.nodes[1].loadwallet('w1')
434        test_address(w1,
435                     key.p2sh_p2wpkh_addr,
436                     ismine=True,
437                     solvable=True)
438
439        # # Test importing of a multisig descriptor
440        key1 = get_generate_key()
441        key2 = get_generate_key()
442        self.log.info("Should import a 1-of-2 bare multisig from descriptor")
443        self.test_importdesc({"desc": descsum_create("multi(1," + key1.pubkey + "," + key2.pubkey + ")"),
444                              "timestamp": "now"},
445                             success=True)
446        self.log.info("Should not treat individual keys from the imported bare multisig as watchonly")
447        test_address(w1,
448                     key1.p2pkh_addr,
449                     ismine=False)
450
451        # # Test ranged descriptors
452        extended_key = ExtendedPrivateKey.generate()
453        xpriv = extended_key.to_string()
454        xpub = extended_key.pubkey().to_string()
455        pubkeys = [extended_key.derive_path(f"m/0'/0'/{i}'").pubkey().pubkey.get_bytes() for i in range(2)]
456        addresses = [key_to_p2sh_p2wpkh(pubkey) for pubkey in pubkeys] # hdkeypath=m/0'/0'/0' and 1'
457        addresses += [key_to_p2wpkh(pubkey) for pubkey in pubkeys] # wpkh subscripts corresponding to the above addresses
458        desc = "sh(wpkh(" + xpub + "/0/0/*" + "))"
459
460        self.log.info("Ranged descriptors cannot have labels")
461        self.test_importdesc({"desc":descsum_create(desc),
462                              "timestamp": "now",
463                              "range": [0, 100],
464                              "label": "test"},
465                              success=False,
466                              error_code=-8,
467                              error_message='Ranged descriptors should not have a label')
468
469        self.log.info("Ranged descriptors cannot have labels - even if range not provided by user and only implied by asterisk (*)")
470        self.test_importdesc({"desc":descsum_create("wpkh(" + xpub + "/100/0/*)"),
471                              "timestamp": "now",
472                              "label": "test",
473                              "active": True},
474                              success=False,
475                              warnings=['Range not given, using default keypool range'],
476                              error_code=-8,
477                              error_message='Ranged descriptors should not have a label')
478
479        self.log.info("Private keys required for private keys enabled wallet")
480        self.test_importdesc({"desc":descsum_create(desc),
481                              "timestamp": "now",
482                              "range": [0, 100]},
483                              success=False,
484                              error_code=-4,
485                              error_message='Cannot import descriptor without private keys to a wallet with private keys enabled',
486                              wallet=wpriv)
487
488        self.log.info("Ranged descriptor import should warn without a specified range")
489        self.test_importdesc({"desc": descsum_create(desc),
490                               "timestamp": "now"},
491                              success=True,
492                              warnings=['Range not given, using default keypool range'])
493        assert_equal(w1.getwalletinfo()['keypoolsize'], 0)
494
495        # # Test importing of a ranged descriptor with xpriv
496        self.log.info("Should not import a ranged descriptor that includes xpriv into a watch-only wallet")
497        desc = "sh(wpkh(" + xpriv + "/0'/0'/*'" + "))"
498        self.test_importdesc({"desc": descsum_create(desc),
499                              "timestamp": "now",
500                              "range": 1},