installer: impl import encrypted backup/descriptor for liana-connect

Author: pythcoiner

liana-gui/src/installer/step/backend.rs

@@ -1,6 +1,11 @@
+use crate::{
+    decrypt::{Decrypt, DecryptModal},
+    hw::HardwareWalletMessage,
+    installer::step::import_descriptor::ImportDescriptorModal,
+};
 use std::str::FromStr;
 
-use iced::{Subscription, Task};
+use iced::Task;
 
 use liana::{descriptors::LianaDescriptor, miniscript::bitcoin::Network};
 use liana_ui::{component::form, widget::Element};
@@ -25,6 +30,8 @@ use crate::{
     },
 };
 
+use super::import_descriptor::BACKUP_NETWORK_NOT_MATCH;
+
 pub struct ChooseBackend {
     network: Network,
     remote_backend_is_selected: bool,
@@ -451,7 +458,7 @@ pub struct ImportRemoteWallet {
     error: Option<String>,
     backend: context::RemoteBackend,
     wallets: Vec<api::Wallet>,
-    modal: Option<ExportModal>,
+    modal: ImportDescriptorModal,
     // wallet alias is stored here to be applied to context
     // and be modified in a following step
     wallet_alias: Option<String>,
@@ -468,7 +475,7 @@ impl ImportRemoteWallet {
             error: None,
             backend: context::RemoteBackend::Undefined,
             wallets: Vec::new(),
-            modal: None,
+            modal: ImportDescriptorModal::None,
             wallet_alias: None,
         }
     }
@@ -505,39 +512,65 @@ impl Step for ImportRemoteWallet {
     }
     // form value is set as valid each time it is edited.
     // Verification of the values is happening when the user click on Next button.
-    fn update(&mut self, _hws: &mut HardwareWallets, message: Message) -> Task<Message> {
+    fn update(&mut self, hws: &mut HardwareWallets, message: Message) -> Task<Message> {
         match message {
             Message::ImportRemoteWallet(message::ImportRemoteWallet::ImportDescriptorFromFile) => {
-                let modal = ExportModal::new(None, ImportExportType::ImportDescriptor);
+                let modal = ExportModal::new(None, ImportExportType::FromBackup);
                 let launch = modal.launch(false);
-                self.modal = Some(modal);
+                self.modal = ImportDescriptorModal::Export(modal);
                 return launch;
             }
             Message::ImportExport(ImportExportMessage::Path(p)) => {
-                if let Some(modal) = self.modal.as_mut() {
-                    return modal.update(ImportExportMessage::Path(p));
+                if self.modal.is_some() {
+                    return self
+                        .modal
+                        .update(Message::ImportExport(ImportExportMessage::Path(p)));
                 }
             }
-            Message::ImportExport(ImportExportMessage::Close) => self.modal = None,
-            Message::ImportRemoteWallet(message::ImportRemoteWallet::ImportExport(m)) => match m {
-                ImportExportMessage::Close => self.modal = None,
-                ImportExportMessage::Progress(Progress::Descriptor(d)) => {
-                    self.modal = None;
-                    return Task::batch([
-                        Task::done(Message::ImportRemoteWallet(
-                            message::ImportRemoteWallet::ImportDescriptor(d.to_string()),
-                        )),
-                        Task::done(Message::ImportRemoteWallet(
-                            message::ImportRemoteWallet::ConfirmDescriptor,
-                        )),
-                    ]);
+            Message::ImportExport(ImportExportMessage::Close) => {
+                self.modal = ImportDescriptorModal::None
+            }
+            Message::ImportExport(ImportExportMessage::Progress(Progress::EncryptedFile(
+                bytes,
+            ))) => {
+                self.modal = ImportDescriptorModal::Decrypt(DecryptModal::new(bytes, self.network));
+            }
+            Message::ImportExport(m) => return self.modal.update(Message::ImportExport(m)),
+            Message::HardwareWallets(HardwareWalletMessage::Update) => {
+                if let ImportDescriptorModal::Decrypt(modal) = &mut self.modal {
+                    return modal.update_devices(hws).unwrap_or(Task::none());
                 }
-                m => {
-                    if let Some(modal) = self.modal.as_mut() {
-                        return modal.update(m);
+            }
+            Message::Decrypt(Decrypt::Close) => {
+                if matches!(self.modal, ImportDescriptorModal::Decrypt(_)) {
+                    self.modal = ImportDescriptorModal::None;
+                }
+            }
+            Message::Decrypt(Decrypt::Backup(mut backup)) => {
+                let descriptor = backup.accounts.first().map(|acc| acc.descriptor.clone());
+                if let Some(desc) = descriptor {
+                    let network_matches = if self.network == Network::Bitcoin {
+                        backup.network == Network::Bitcoin
+                    } else {
+                        backup.network != Network::Bitcoin
+                    };
+                    if network_matches {
+                        // NOTE: we need to overwrite w/ correct network for testnets
+                        // as non Mainnet keys / descriptor are parsed as Signet
+                        backup.network = self.network;
+
+                        self.imported_descriptor.value = desc;
+                        self.modal = ImportDescriptorModal::None;
+                        return Task::perform(async {}, |_| Message::Next);
+                    } else {
+                        self.modal = ImportDescriptorModal::None;
+                        self.error = Some(BACKUP_NETWORK_NOT_MATCH.into());
                     }
+                } else {
+                    self.modal = ImportDescriptorModal::None;
+                    self.error = Some("Backup imported but descriptor missing!".into());
                 }
-            },
+            }
             Message::ImportRemoteWallet(message::ImportRemoteWallet::ImportDescriptor(desc)) => {
                 self.imported_descriptor.value = desc;
                 if !self.imported_descriptor.value.is_empty() {
@@ -679,17 +712,8 @@ impl Step for ImportRemoteWallet {
         Task::none()
     }
 
-    fn subscription(&self, _hws: &HardwareWallets) -> iced::Subscription<Message> {
-        if let Some(modal) = &self.modal {
-            if let Some(sub) = modal.subscription() {
-                return sub.map(|m| {
-                    Message::ImportRemoteWallet(message::ImportRemoteWallet::ImportExport(
-                        ImportExportMessage::Progress(m),
-                    ))
-                });
-            }
-        }
-        Subscription::none()
+    fn subscription(&self, hws: &HardwareWallets) -> iced::Subscription<Message> {
+        self.modal.subscriptions(hws)
     }
 
     fn apply(&mut self, ctx: &mut Context) -> bool {
@@ -725,11 +749,7 @@ impl Step for ImportRemoteWallet {
                 .map(|w| (&w.name, w.metadata.wallet_alias.as_ref()))
                 .collect(),
         );
-        if let Some(modal) = &self.modal {
-            modal.view(content)
-        } else {
-            content
-        }
+        self.modal.view(content)
     }
 }