Inside Bitcoin

251        w5 = get_wallet(node, "w5")
252        assert_equal(w5.getbalances()["mine"]["immature"], 50)
253
254        competing_wallet_dir = os.path.join(self.options.tmpdir, 'competing_walletdir')
255        os.mkdir(competing_wallet_dir)
256        self.restart_node(0, ['-nowallet', '-walletdir=' + competing_wallet_dir])
257        node.createwallet(self.default_wallet_name)
258        exp_stderr = f"Error: SQLiteDatabase: Unable to obtain an exclusive lock on the database, is it being used by another instance of {self.config['environment']['CLIENT_NAME']}?"
259        self.nodes[1].assert_start_raises_init_error(['-walletdir=' + competing_wallet_dir], exp_stderr, match=ErrorMatch.PARTIAL_REGEX)
260
261    def test_balances_and_fees(self, node, wallet_names, in_wallet_dir):
262        self.log.info("Test balances and fees")
263        self.restart_node(0)
264        for wallet_name in wallet_names:
265            node.loadwallet(wallet_name)
266
267        assert_equal(sorted(map(lambda w: w['name'], node.listwalletdir()['wallets'])), sorted(in_wallet_dir))
268
269        wallets = [get_wallet(node, w) for w in wallet_names]
270        wallet_bad = get_wallet(node, "bad")
271
272        # check wallet names and balances
273        self.generatetoaddress(node, nblocks=1, address=wallets[0].getnewaddress(), sync_fun=self.no_op)
274        for wallet_name, wallet in zip(wallet_names, wallets):
275            info = wallet.getwalletinfo()
276            assert_equal(wallet.getbalances()["mine"]["immature"], 50 if wallet is wallets[0] else 0)
277            assert_equal(info['walletname'], wallet_name)
278
279        # accessing invalid wallet fails
280        assert_raises_rpc_error(-18, "Requested wallet does not exist or is not loaded", wallet_bad.getwalletinfo)
281
282        # accessing wallet RPC without using wallet endpoint fails
283        assert_raises_rpc_error(-19, "Multiple wallets are loaded. Please select which wallet", node.getwalletinfo)
284
285        w1, w2, w3, w4, *_ = wallets
286        self.generatetoaddress(node, nblocks=COINBASE_MATURITY + 1, address=w1.getnewaddress(), sync_fun=self.no_op)
287        assert_equal(w1.getbalance(), 100)
288        assert_equal(w2.getbalance(), 0)
289        assert_equal(w3.getbalance(), 0)
290        assert_equal(w4.getbalance(), 0)
291
292        w1.sendtoaddress(w2.getnewaddress(), 1)
293        w1.sendtoaddress(w3.getnewaddress(), 2)
294        w1.sendtoaddress(w4.getnewaddress(), 3)
295        self.generatetoaddress(node, nblocks=1, address=w1.getnewaddress(), sync_fun=self.no_op)
296        assert_equal(w2.getbalance(), 1)
297        assert_equal(w3.getbalance(), 2)
298        assert_equal(w4.getbalance(), 3)
299
300        batch = w1.batch([w1.getblockchaininfo.get_request(), w1.getwalletinfo.get_request()])
301        assert_equal(batch[0]["result"]["chain"], self.chain)
302        assert_equal(batch[1]["result"]["walletname"], "w1")
303
304    def test_loading(self, node, wallet_names):
305        self.log.info("Test dynamic wallet loading")
306
307        self.restart_node(0, ['-nowallet'])
308        assert_equal(node.listwallets(), [])
309        assert_raises_rpc_error(-18, "No wallet is loaded. Load a wallet using loadwallet or create a new one with createwallet. (Note: A default wallet is no longer automatically created)", node.getwalletinfo)
310
311        self.log.info("Load first wallet")
312        loadwallet_name = node.loadwallet(wallet_names[0])
313        assert_equal(loadwallet_name['name'], wallet_names[0])
314        assert_equal(node.listwallets(), wallet_names[0:1])
315        node.getwalletinfo()
316        w1 = get_wallet(node, wallet_names[0])
317        w1.getwalletinfo()
318
319        self.log.info("Load second wallet")
320        loadwallet_name = node.loadwallet(wallet_names[1])
321        assert_equal(loadwallet_name['name'], wallet_names[1])
322        assert_equal(node.listwallets(), wallet_names[0:2])
323        assert_raises_rpc_error(-19, "Multiple wallets are loaded. Please select which wallet", node.getwalletinfo)
324        w2 = get_wallet(node, wallet_names[1])
325        w2.getwalletinfo()
326
327        self.log.info("Concurrent wallet loading")
328        threads = []
329        for _ in range(3):
330            n = node.create_new_rpc_connection()
331            t = Thread(target=test_load_unload, args=(n, wallet_names[2]))
332            t.start()
333            threads.append(t)
334        for t in threads:
335            t.join()
336        global got_loading_error
337        assert_equal(got_loading_error, True)
338
339        self.log.info("Load remaining wallets")
340        for wallet_name in wallet_names[2:]:
341            loadwallet_name = node.loadwallet(wallet_name)
342            assert_equal(loadwallet_name['name'], wallet_name)
343
344        assert_equal(set(node.listwallets()), set(wallet_names))
345
346        # Fail to load if wallet doesn't exist
347        path = wallet_dir(node, "wallets")
348        assert_raises_rpc_error(-18, "Wallet file verification failed. Failed to load database path '{}'. Path does not exist.".format(path), node.loadwallet, 'wallets')
349
350        # Fail to load duplicate wallets
351        assert_raises_rpc_error(-35, "Wallet \"w1\" is already loaded.", node.loadwallet, wallet_names[0])
352        # Fail to load if wallet file is a symlink
353        if self.check_symlinks:
354            assert_raises_rpc_error(-4, "Wallet file verification failed. Invalid -wallet path 'w8_symlink'", node.loadwallet, 'w8_symlink')
355
356        # Fail to load if a directory is specified that doesn't contain a wallet
357        os.mkdir(wallet_dir(node, 'empty_wallet_dir'))
358        path = wallet_dir(node, "empty_wallet_dir")
359        assert_raises_rpc_error(-18, "Wallet file verification failed. Failed to load database path '{}'. Data is not in recognized format.".format(path), node.loadwallet, 'empty_wallet_dir')
360
361        return w1, w2
362
363    def test_creation(self, node, in_wallet_dir):
364        self.log.info("Test dynamic wallet creation")
365
366        # should raise rpc error if wallet path can't be created
367        err_code = -4
368        assert_raises_rpc_error(err_code, "Wallet file verification failed. ", node.createwallet, "w8/bad")
369
370        # Fail to create a wallet if it already exists.
371        path = wallet_dir(node, "w2")
372        assert_raises_rpc_error(-4, "Failed to create database path '{}'. Database already exists.".format(path), node.createwallet, 'w2')
373
374        # Successfully create a wallet with a new name
375        loadwallet_name = node.createwallet('w9')
376        in_wallet_dir.append('w9')
377        assert_equal(loadwallet_name['name'], 'w9')
378        w9 = get_wallet(node, 'w9')
379        assert_equal(w9.getwalletinfo()['walletname'], 'w9')
380
381        assert 'w9' in node.listwallets()
382
383        # Successfully create a wallet using a full path
384        new_wallet_dir = os.path.join(self.options.tmpdir, 'new_walletdir')
385        new_wallet_name = os.path.join(new_wallet_dir, 'w10')
386        loadwallet_name = node.createwallet(new_wallet_name)
387        assert_equal(loadwallet_name['name'], new_wallet_name)
388        w10 = get_wallet(node, new_wallet_name)
389        assert_equal(w10.getwalletinfo()['walletname'], new_wallet_name)
390
391        assert new_wallet_name in node.listwallets()
392
393    def test_unloading(self, node, in_wallet_dir, w1, w2):
394        self.log.info("Test dynamic wallet unloading")
395
396        # Test `unloadwallet` errors
397        assert_raises_rpc_error(-8, "Either the RPC endpoint wallet or the wallet name parameter must be provided", node.unloadwallet)
398        assert_raises_rpc_error(-18, "Requested wallet does not exist or is not loaded", node.unloadwallet, "dummy")
399        assert_raises_rpc_error(-18, "Requested wallet does not exist or is not loaded", get_wallet(node, "dummy").unloadwallet)
400        assert_raises_rpc_error(-8, "The RPC endpoint wallet and the wallet name parameter specify different wallets", w1.unloadwallet, "w2"),
401
402        # Successfully unload the specified wallet name
403        node.unloadwallet("w1")
404        assert 'w1' not in node.listwallets()
405
406        # Unload w1 again, this time providing the wallet name twice
407        node.loadwallet("w1")
408        assert 'w1' in node.listwallets()
409        w1.unloadwallet("w1")
410        assert 'w1' not in node.listwallets()
411
412        # Successfully unload the wallet referenced by the request endpoint
413        # Also ensure unload works during walletpassphrase timeout
414        w2.encryptwallet('test')
415        w2.walletpassphrase('test', 1)
416        w2.unloadwallet()
417        ensure_for(duration=1.1, f=lambda: 'w2' not in node.listwallets())
418
419        # Successfully unload all wallets
420        for wallet_name in node.listwallets():
421            node.unloadwallet(wallet_name)
422        assert_equal(node.listwallets(), [])
423        assert_raises_rpc_error(-18, "No wallet is loaded. Load a wallet using loadwallet or create a new one with createwallet. (Note: A default wallet is no longer automatically created)", node.getwalletinfo)
424
425        # Successfully load a previously unloaded wallet
426        node.loadwallet('w1')
427        assert_equal(node.listwallets(), ['w1'])
428        assert_equal(w1.getwalletinfo()['walletname'], 'w1')
429
430        assert_equal(sorted(map(lambda w: w['name'], node.listwalletdir()['wallets'])), sorted(in_wallet_dir))
431
432    def test_backup_and_restore(self, node, wallet_names, empty_wallet, empty_created_wallet):
433        self.log.info("Test wallet backup and restore")
434        self.restart_node(0, ['-nowallet'])
435        for wallet_name in wallet_names:
436            node.loadwallet(wallet_name)
437        for wallet_name in wallet_names:
438            rpc = get_wallet(node, wallet_name)
439            addr = rpc.getnewaddress()
440            backup = os.path.join(self.options.tmpdir, 'backup.dat')
441            if os.path.exists(backup):
442                os.unlink(backup)
443            rpc.backupwallet(backup)
444            node.unloadwallet(wallet_name)
445            shutil.copyfile(empty_created_wallet if wallet_name == self.default_wallet_name else empty_wallet, self.wallet_file(node, wallet_name))
446            node.loadwallet(wallet_name)
447            assert_equal(rpc.getaddressinfo(addr)['ismine'], False)
448            node.unloadwallet(wallet_name)
449            shutil.copyfile(backup, self.wallet_file(node, wallet_name))
450            node.loadwallet(wallet_name)
451            assert_equal(rpc.getaddressinfo(addr)['ismine'], True)
452
453    def test_lock_file_closed(self, node):
454        self.log.info("Test wallet lock file is closed")
455        self.start_node(1)
456        wallet = os.path.join(self.options.tmpdir, 'my_wallet')
457        node.createwallet(wallet)
458        assert_raises_rpc_error(-4, "Unable to obtain an exclusive lock", self.nodes[1].loadwallet, wallet)
459        node.unloadwallet(wallet)
460        self.nodes[1].loadwallet(wallet)
461
462    def test_invalid_wallet_names(self):
463        self.log.info("Test weird paths are not allowed as wallet names")
464        NON_NORMALIZED = ["bad/./path", "bad/../path", "/bad/./path", "/bad/../path", "../", "./", "./wallet", "../wallets/../wallets/wallet"]
465        for name in NON_NORMALIZED:
466            assert_raises_rpc_error(-4, "Wallet name given as a path must be normalized", self.nodes[0].createwallet, name)
467
468        INVALID_RELPATH = ["../wallets/wallet", "..", "."]
469        for name in INVALID_RELPATH:
470            assert_raises_rpc_error(-4, "Wallet name given as a relative path cannot begin with ./ or ../", self.nodes[0].createwallet, name)
471
472        INVALID_ROOT = ["/"]
473        if platform.system() == "Windows":
474            INVALID_ROOT.extend(["C:\\", "C:"])
475        for name in INVALID_ROOT:
476            assert_raises_rpc_error(-4, "Wallet name cannot be the root path", self.nodes[0].createwallet, name)
477
478if __name__ == '__main__':
479    MultiWalletTest(__file__).main()
480