add wallet rename functionality, and add to qml client

electrum/daemon.py

@@ -538,6 +538,21 @@ def get_wallet(self, path: str) -> Optional[Abstract_Wallet]:
     def get_wallets(self) -> Dict[str, Abstract_Wallet]:
         return dict(self._wallets)  # copy
 
+    @with_wallet_lock
+    def rename_wallet(self, wallet: 'Abstract_Wallet', new_basename):
+        if not wallet.db.storage:
+            return
+
+        path = wallet.db.storage.path
+        wallet_key = self._wallet_key_from_path(path)
+        wallet = self._wallets.get(wallet_key)
+        assert wallet
+
+        new_path = wallet.rename_wallet(new_basename)
+        new_wallet_key = self._wallet_key_from_path(new_path)
+        self._wallets.pop(wallet_key)
+        self._wallets[new_wallet_key] = wallet
+
     def delete_wallet(self, path: str) -> bool:
         self.stop_wallet(path)
         if os.path.exists(path):

electrum/gui/qml/components/RenameWalletDialog.qml

@@ -0,0 +1,87 @@
+import QtQuick
+import QtQuick.Layouts
+import QtQuick.Controls
+import QtQuick.Controls.Material
+
+import org.electrum 1.0
+
+import "controls"
+
+ElDialog {
+    id: dialog
+
+    title: qsTr("Enter wallet name")
+    iconSource: Qt.resolvedUrl('../../icons/pen.png')
+
+    property string infotext
+
+    property bool _valid: false
+
+    anchors.centerIn: parent
+    width: parent.width * 4/5
+    padding: 0
+
+    ColumnLayout {
+        id: rootLayout
+        width: parent.width
+        spacing: 0
+
+        ColumnLayout {
+            Layout.leftMargin: constants.paddingXXLarge
+            Layout.rightMargin: constants.paddingXXLarge
+
+            InfoTextArea {
+                visible: infotext
+                text: infotext
+                Layout.bottomMargin: constants.paddingMedium
+                Layout.fillWidth: true
+            }
+
+            Label {
+                Layout.fillWidth: true
+                text: qsTr('Wallet name')
+                color: Material.accentColor
+            }
+
+            TextField {
+                id: wallet_name
+                Layout.fillWidth: true
+                Layout.leftMargin: constants.paddingXLarge
+                Layout.rightMargin: constants.paddingXLarge
+                onTextChanged: {
+                    var name = text.trim()
+                    if (!text || text == Daemon.currentWallet.name) {
+                        _valid = false
+                        infotext = ''
+                    } else {
+                        _valid = Daemon.isValidNewWalletName(name)
+                        if (_valid)
+                            infotext = ''
+                        else
+                            infotext = qsTr('Invalid name')
+                    }
+                }
+            }
+        }
+
+        FlatButton {
+            Layout.fillWidth: true
+            text: qsTr("Ok")
+            icon.source: '../../icons/confirmed.png'
+            enabled: _valid
+            onClicked: {
+                var name = wallet_name.text.trim()
+                if (Daemon.isValidNewWalletName(name)) {
+                    console.log('renaming.. ' + name)
+                    var result = Daemon.renameWallet(Daemon.currentWallet, name)
+                    if (result)
+                        dialog.close()
+                }
+            }
+        }
+    }
+
+    Component.onCompleted: {
+        wallet_name.text = Daemon.currentWallet.name
+    }
+}

electrum/gui/qml/components/WalletDetails.qml

@@ -411,6 +411,16 @@ Pane {
                 onClicked: Daemon.checkThenDeleteWallet(Daemon.currentWallet)
                 icon.source: '../../icons/delete.png'
             }
+            FlatButton {
+                Layout.fillWidth: true
+                Layout.preferredWidth: 1
+                text: qsTr('Rename')
+                onClicked: {
+                    var dialog = renameWalletDialog.createObject(rootItem)
+                    dialog.open()
+                }
+                icon.source: '../../icons/pen.png'
+            }
             FlatButton {
                 Layout.fillWidth: true
                 Layout.preferredWidth: 1
@@ -532,6 +542,13 @@ Pane {
         }
     }
 
+    Component {
+        id: renameWalletDialog
+        RenameWalletDialog {
+            onClosed: destroy()
+        }
+    }
+
     Binding {
         target: AppController
         property: 'secureWindow'

electrum/gui/qml/qedaemon.py

@@ -13,7 +13,7 @@
 from electrum.lnchannel import ChannelState
 from electrum.bitcoin import is_address
 from electrum.bitcoin import verify_usermessage_with_address
-from electrum.storage import StorageReadWriteError
+from electrum.storage import StorageReadWriteError, WalletStorage
 
 from .auth import AuthMixin, auth_protect
 from .qefx import QEFX
@@ -382,3 +382,41 @@ def passwordStrength(self, password):
         if len(password) == 0:
             return 0
         return check_password_strength(password)[0]
+
+    def wallet_path_from_wallet_name(self, wallet_name: str) -> str:
+        return os.path.join(self.daemon.config.get_datadir_wallet_path(), wallet_name)
+
+    @pyqtSlot(str, result=bool)
+    def isValidNewWalletName(self, wallet_name: str) -> bool:
+        if not wallet_name:
+            return False
+        if self.availableWallets.wallet_name_exists(wallet_name):
+            return False
+        wallet_path = self.wallet_path_from_wallet_name(wallet_name)
+        # note: we should probably restrict wallet names to be alphanumeric (plus underscore, etc)...
+        #       wallet_name might contain ".." (etc) and hence sketchy path traversals are possible.
+        #       Anyway, this at least validates that the path looks sane to the filesystem:
+        try:
+            temp_storage = WalletStorage(wallet_path)
+        except (StorageReadWriteError, WalletFileException) as e:
+            return False
+        except Exception as e:
+            self._logger.exception("")
+            return False
+        if temp_storage.file_exists():
+            return False
+        return True
+
+    @pyqtSlot(QEWallet, str, result=bool)
+    def renameWallet(self, wallet, new_name):
+        self._logger.debug(f'renaming wallet to: {new_name}')
+        try:
+            self.daemon.rename_wallet(wallet.wallet, new_name)
+            self.daemon.config.save_last_wallet(wallet.wallet)
+            wallet.nameChanged.emit()
+            if self._available_wallets:
+                self._available_wallets.reload()
+            return True
+        except Exception as e:
+            self._logger.debug(f'renaming err: {str(e)}')
+            return False

electrum/gui/qml/qewizard.py

@@ -119,34 +119,9 @@ def verifySeed(self, seed, seed_variant, wallet_type='standard'):
             'can_passphrase': can_passphrase
         }
 
-    def _wallet_path_from_wallet_name(self, wallet_name: str) -> str:
-        return os.path.join(self._qedaemon.daemon.config.get_datadir_wallet_path(), wallet_name)
-
     @pyqtSlot(str, result=bool)
     def isValidNewWalletName(self, wallet_name: str) -> bool:
-        if not wallet_name:
-            return False
-        if self._qedaemon.availableWallets.wallet_name_exists(wallet_name):
-            return False
-        wallet_path = self._wallet_path_from_wallet_name(wallet_name)
-        # note: we should probably restrict wallet names to be alphanumeric (plus underscore, etc)...
-        # try to prevent sketchy path traversals:
-        for forbidden_char in ("/", "\\", ):
-            if forbidden_char in wallet_name:
-                return False
-        if os.path.basename(wallet_name) != wallet_name:
-            return False
-        # validate that the path looks sane to the filesystem:
-        try:
-            temp_storage = WalletStorage(wallet_path)
-        except (StorageReadWriteError, WalletFileException) as e:
-            return False
-        except Exception as e:
-            self._logger.exception("")
-            return False
-        if temp_storage.file_exists():
-            return False
-        return True
+        return self._qedaemon.isValidNewWalletName(wallet_name)
 
     @pyqtSlot('QJSValue', bool, str)
     def createStorage(self, js_data, single_password_enabled, single_password):
@@ -157,7 +132,7 @@ def createStorage(self, js_data, single_password_enabled, single_password):
             data['encrypt'] = True
             data['password'] = single_password
 
-        path = self._wallet_path_from_wallet_name(data['wallet_name'])
+        path = self._qedaemon.wallet_path_from_wallet_name(data['wallet_name'])
 
         try:
             self.create_storage(path, data)

electrum/wallet.py

@@ -394,7 +394,6 @@ def __init__(self, db: WalletDB, *, config: SimpleConfig):
         self.config = config
         assert self.config is not None, "config must not be None"
         self.db = db
-        self.storage = db.storage  # type: Optional[WalletStorage]
         # load addresses needs to be called before constructor for sanity checks
         db.load_addresses(self.wallet_type)
         self.keystore = None  # type: Optional[KeyStore]  # will be set by load_keystore
@@ -448,6 +447,10 @@ def __init__(self, db: WalletDB, *, config: SimpleConfig):
 
         self.register_callbacks()
 
+    @property
+    def storage(self):
+        return self.db.storage
+
     def _init_lnworker(self):
         self.lnworker = None
 
@@ -497,6 +500,33 @@ def save_backup(self, backup_dir):
         new_db.write()
         return new_path
 
+    def rename_wallet(self, new_basename) -> str:
+        old_storage = self.storage
+        if not old_storage:
+            return
+
+        # new storage path
+        dirname = os.path.dirname(old_storage.path)
+        new_path = os.path.join(dirname, new_basename)
+        assert not os.path.exists(new_path)
+
+        # new storage
+        new_storage = WalletStorage(new_path)
+        new_storage._encryption_version = old_storage._encryption_version
+        new_storage.pubkey = old_storage.pubkey
+
+        with self.db.lock:
+            # keep existing WalletDB instance, as the initialization normally
+            # happens in the wallet constructor, which we don't want to replicate,
+            self.db.storage = new_storage
+            self.db.set_modified(True)
+            self.db.write_and_force_consolidation()
+
+        assert os.path.exists(new_path)
+        os.unlink(old_storage.path)
+
+        return new_path
+
     def has_lightning(self) -> bool:
         return bool(self.lnworker)