Bip329 labels export

liana-gui/src/app/message.rs

@@ -11,7 +11,7 @@ use lianad::config::Config as DaemonConfig;
 use crate::{
     app::{cache::Cache, error::Error, view, wallet::Wallet},
     daemon::model::*,
-    export::ExportMessage,
+    export::ImportExportMessage,
     hw::HardwareWalletMessage,
 };
 
@@ -47,5 +47,5 @@ pub enum Message {
     LabelsUpdated(Result<HashMap<String, Option<String>>, Error>),
     BroadcastModal(Result<HashSet<Txid>, Error>),
     RbfModal(Box<HistoryTransaction>, bool, Result<HashSet<Txid>, Error>),
-    Export(ExportMessage),
+    Export(ImportExportMessage),
 }

liana-gui/src/app/state/export.rs

@@ -13,72 +13,106 @@ use crate::{
         view::{self, export::export_modal},
     },
     daemon::Daemon,
-    export::{self, get_path, ExportMessage, ExportProgress, ExportState},
+    export::{self, get_path, ImportExportMessage, ImportExportState, ImportExportType, Progress},
 };
 
 #[derive(Debug)]
 pub struct ExportModal {
     path: Option<PathBuf>,
     handle: Option<Arc<Mutex<JoinHandle<()>>>>,
-    state: ExportState,
+    state: ImportExportState,
     error: Option<export::Error>,
     daemon: Arc<dyn Daemon + Sync + Send>,
+    import_export_type: ImportExportType,
 }
 
 impl ExportModal {
     #[allow(clippy::new_without_default)]
-    pub fn new(daemon: Arc<dyn Daemon + Sync + Send>) -> Self {
+    pub fn new(daemon: Arc<dyn Daemon + Sync + Send>, export_type: ImportExportType) -> Self {
         Self {
             path: None,
             handle: None,
-            state: ExportState::Init,
+            state: ImportExportState::Init,
             error: None,
             daemon,
+            import_export_type: export_type,
+        }
+    }
+
+    pub fn default_filename(&self) -> String {
+        let date = chrono::Local::now().format("%Y-%m-%dT%H-%M-%S");
+        match &self.import_export_type {
+            ImportExportType::Transactions => {
+                format!("liana-txs-{date}.csv")
+            }
+            ImportExportType::ExportPsbt(_) => "psbt.psbt".into(),
+            ImportExportType::Descriptor(descriptor) => {
+                let checksum = descriptor
+                    .to_string()
+                    .split_once('#')
+                    .map(|(_, checksum)| checksum)
+                    .unwrap()
+                    .to_string();
+                format!("liana-{}.descriptor", checksum)
+            }
+            ImportExportType::ImportPsbt => "psbt.psbt".into(),
+            ImportExportType::ImportDescriptor => "descriptor.descriptor".into(),
+            ImportExportType::ExportLabels => format!("liana-labels-{date}.csv"),
         }
     }
 
     pub fn launch(&self) -> Task<Message> {
-        Task::perform(get_path(), |m| {
-            Message::View(view::Message::Export(ExportMessage::Path(m)))
+        Task::perform(get_path(self.default_filename()), |m| {
+            Message::View(view::Message::ImportExport(ImportExportMessage::Path(m)))
         })
     }
 
     pub fn update(&mut self, message: Message) -> Task<Message> {
-        if let Message::View(view::Message::Export(m)) = message {
+        if let Message::View(view::Message::ImportExport(m)) = message {
             match m {
-                ExportMessage::ExportProgress(m) => match m {
-                    ExportProgress::Started(handle) => {
+                ImportExportMessage::Progress(m) => match m {
+                    Progress::Started(handle) => {
                         self.handle = Some(handle);
-                        self.state = ExportState::Progress(0.0);
+                        self.state = ImportExportState::Progress(0.0);
+                    }
+                    Progress::Progress(p) => {
+                        if let ImportExportState::Progress(_) = self.state {
+                            self.state = ImportExportState::Progress(p);
+                        }
                     }
-                    ExportProgress::Progress(p) => {
-                        if let ExportState::Progress(_) = self.state {
-                            self.state = ExportState::Progress(p);
+                    Progress::Finished | Progress::Ended => self.state = ImportExportState::Ended,
+                    Progress::Error(e) => self.error = Some(e),
+                    Progress::None => {}
+                    Progress::Psbt(_) => {
+                        if self.import_export_type == ImportExportType::ImportPsbt {
+                            self.state = ImportExportState::Ended;
                         }
+                        // TODO: forward PSBT
                     }
-                    ExportProgress::Finished | ExportProgress::Ended => {
-                        self.state = ExportState::Ended
+                    Progress::Descriptor(_) => {
+                        if self.import_export_type == ImportExportType::ImportDescriptor {
+                            self.state = ImportExportState::Ended;
+                        }
+                        // TODO: forward Descriptor
                     }
-                    ExportProgress::Error(e) => self.error = Some(e),
-                    ExportProgress::None => {}
                 },
-                ExportMessage::TimedOut => {
-                    self.stop(ExportState::TimedOut);
+                ImportExportMessage::TimedOut => {
+                    self.stop(ImportExportState::TimedOut);
                 }
-                ExportMessage::UserStop => {
-                    self.stop(ExportState::Aborted);
+                ImportExportMessage::UserStop => {
+                    self.stop(ImportExportState::Aborted);
                 }
-                ExportMessage::Path(p) => {
+                ImportExportMessage::Path(p) => {
                     if let Some(path) = p {
                         self.path = Some(path);
                         self.start();
                     } else {
                         return Task::perform(async {}, |_| {
-                            Message::View(view::Message::Export(ExportMessage::Close))
+                            Message::View(view::Message::ImportExport(ImportExportMessage::Close))
                         });
                     }
                 }
-                ExportMessage::Close | ExportMessage::Open => { /* unreachable */ }
+                ImportExportMessage::Close | ImportExportMessage::Open => { /* unreachable */ }
             }
             Task::none()
         } else {
@@ -91,33 +125,37 @@ impl ExportModal {
             export_modal(&self.state, self.error.as_ref(), "Transactions"),
         );
         match self.state {
-            ExportState::TimedOut
-            | ExportState::Aborted
-            | ExportState::Ended
-            | ExportState::Closed => modal.on_blur(Some(view::Message::Close)),
+            ImportExportState::TimedOut
+            | ImportExportState::Aborted
+            | ImportExportState::Ended
+            | ImportExportState::Closed => modal.on_blur(Some(view::Message::Close)),
             _ => modal,
         }
         .into()
     }
 
     pub fn start(&mut self) {
-        self.state = ExportState::Started;
+        self.state = ImportExportState::Started;
     }
 
-    pub fn stop(&mut self, state: ExportState) {
+    pub fn stop(&mut self, state: ImportExportState) {
         if let Some(handle) = self.handle.take() {
             handle.lock().expect("poisoned").abort();
             self.state = state;
         }
     }
 
-    pub fn subscription(&self) -> Option<Subscription<export::ExportProgress>> {
+    pub fn subscription(&self) -> Option<Subscription<export::Progress>> {
         if let Some(path) = &self.path {
             match &self.state {
-                ExportState::Started | ExportState::Progress(_) => {
+                ImportExportState::Started | ImportExportState::Progress(_) => {
                     Some(iced::Subscription::run_with_id(
                         "transactions",
-                        export::export_subscription(self.daemon.clone(), path.to_path_buf()),
+                        export::export_subscription(
+                            self.daemon.clone(),
+                            path.to_path_buf(),
+                            self.import_export_type.clone(),
+                        ),
                     ))
                 }
                 _ => None,

liana-gui/src/app/state/transactions.rs

@@ -28,7 +28,7 @@ use crate::{
         wallet::Wallet,
     },
     daemon::model::{self, LabelsLoader},
-    export::ExportMessage,
+    export::{ImportExportMessage, ImportExportType},
 };
 
 use crate::daemon::{
@@ -266,15 +266,18 @@ impl State for TransactionsPanel {
                     );
                 }
             }
-            Message::View(view::Message::Export(ExportMessage::Open)) => {
+            Message::View(view::Message::ImportExport(ImportExportMessage::Open)) => {
                 if let TransactionsModal::None = &self.modal {
-                    self.modal = TransactionsModal::Export(ExportModal::new(daemon));
+                    self.modal = TransactionsModal::Export(ExportModal::new(
+                        daemon,
+                        ImportExportType::Transactions,
+                    ));
                     if let TransactionsModal::Export(m) = &self.modal {
                         return m.launch();
                     }
                 }
             }
-            Message::View(view::Message::Export(ExportMessage::Close)) => {
+            Message::View(view::Message::ImportExport(ImportExportMessage::Close)) => {
                 if let TransactionsModal::Export(_) = &self.modal {
                     self.modal = TransactionsModal::None;
                 }
@@ -321,7 +324,9 @@ impl State for TransactionsPanel {
         if let TransactionsModal::Export(modal) = &self.modal {
             if let Some(sub) = modal.subscription() {
                 return sub.map(|m| {
-                    Message::View(view::Message::Export(ExportMessage::ExportProgress(m)))
+                    Message::View(view::Message::ImportExport(ImportExportMessage::Progress(
+                        m,
+                    )))
                 });
             }
         }

liana-gui/src/app/view/export.rs

@@ -11,48 +11,51 @@ use liana_ui::{
     widget::Element,
 };
 
-use crate::export::{Error, ExportMessage};
-use crate::{app::view::message::Message, export::ExportState};
+use crate::export::{Error, ImportExportMessage};
+use crate::{app::view::message::Message, export::ImportExportState};
 
 /// Return the modal view for an export task
 pub fn export_modal<'a>(
-    state: &ExportState,
+    state: &ImportExportState,
     error: Option<&'a Error>,
     export_type: &str,
 ) -> Element<'a, Message> {
     let button = match state {
-        ExportState::Started | ExportState::Progress(_) => {
-            Some(button::secondary(None, "Cancel").on_press(ExportMessage::UserStop.into()))
+        ImportExportState::Started | ImportExportState::Progress(_) => {
+            Some(button::secondary(None, "Cancel").on_press(ImportExportMessage::UserStop.into()))
         }
-        ExportState::Ended | ExportState::TimedOut | ExportState::Aborted => {
-            Some(button::secondary(None, "Close").on_press(ExportMessage::Close.into()))
+        ImportExportState::Ended | ImportExportState::TimedOut | ImportExportState::Aborted => {
+            Some(button::secondary(None, "Close").on_press(ImportExportMessage::Close.into()))
         }
         _ => None,
     };
     let msg = if let Some(error) = error {
         format!("{:?}", error)
     } else {
         match state {
-            ExportState::Init => "".to_string(),
-            ExportState::ChoosePath => {
+            ImportExportState::Init => "".to_string(),
+            ImportExportState::ChoosePath => {
                 "Select the path you want to export in the popup window...".into()
             }
-            ExportState::Path(_) => "".into(),
-            ExportState::Started => "Starting export...".into(),
-            ExportState::Progress(p) => format!("Progress: {}%", p.round()),
-            ExportState::TimedOut => "Export failed: timeout".into(),
-            ExportState::Aborted => "Export canceled".into(),
-            ExportState::Ended => "Export successful!".into(),
-            ExportState::Closed => "".into(),
+            ImportExportState::Path(_) => "".into(),
+            ImportExportState::Started => "Starting export...".into(),
+            ImportExportState::Progress(p) => format!("Progress: {}%", p.round()),
+            ImportExportState::TimedOut => "Export failed: timeout".into(),
+            ImportExportState::Aborted => "Export canceled".into(),
+            ImportExportState::Ended => "Export successful!".into(),
+            ImportExportState::Closed => "".into(),
         }
     };
     let p = match state {
-        ExportState::Init => 0.0,
-        ExportState::ChoosePath | ExportState::Path(_) | ExportState::Started => 5.0,
-        ExportState::Progress(p) => *p,
-        ExportState::TimedOut | ExportState::Aborted | ExportState::Ended | ExportState::Closed => {
-            100.0
+        ImportExportState::Init => 0.0,
+        ImportExportState::ChoosePath | ImportExportState::Path(_) | ImportExportState::Started => {
+            5.0
         }
+        ImportExportState::Progress(p) => *p,
+        ImportExportState::TimedOut
+        | ImportExportState::Aborted
+        | ImportExportState::Ended
+        | ImportExportState::Closed => 100.0,
     };
     let progress_bar_row = Row::new()
         .push(Space::with_width(30))

liana-gui/src/app/view/message.rs

@@ -1,4 +1,4 @@
-use crate::{app::menu::Menu, export::ExportMessage, node::bitcoind::RpcAuthType};
+use crate::{app::menu::Menu, export::ImportExportMessage, node::bitcoind::RpcAuthType};
 use liana::miniscript::bitcoin::{bip32::Fingerprint, OutPoint};
 
 #[derive(Debug, Clone)]
@@ -19,7 +19,7 @@ pub enum Message {
     SelectHardwareWallet(usize),
     CreateRbf(CreateRbfMessage),
     ShowQrCode(usize),
-    Export(ExportMessage),
+    ImportExport(ImportExportMessage),
 }
 
 #[derive(Debug, Clone)]

liana-gui/src/app/view/transactions.rs

@@ -26,7 +26,7 @@ use crate::{
         },
     },
     daemon::model::{HistoryTransaction, Txid},
-    export::ExportMessage,
+    export::ImportExportMessage,
 };
 
 pub fn transactions_view<'a>(
@@ -45,7 +45,10 @@ pub fn transactions_view<'a>(
                 Row::new()
                     .push(Container::new(h3("Transactions")))
                     .push(Space::with_width(Length::Fill))
-                    .push(button::secondary(None, "Export").on_press(ExportMessage::Open.into())),
+                    .push(
+                        button::secondary(None, "Export")
+                            .on_press(ImportExportMessage::Open.into()),
+                    ),
             )
             .push(
                 Column::new()

liana-gui/src/daemon/client/mod.rs

@@ -4,6 +4,8 @@ use std::iter::FromIterator;
 use std::path::Path;
 
 use async_trait::async_trait;
+use lianad::bip329::Labels;
+use lianad::commands::DumpLabelsResult;
 use serde::de::DeserializeOwned;
 use serde::{Deserialize, Serialize};
 use serde_json::json;
@@ -205,6 +207,12 @@ impl<C: Client + Send + Sync + Debug> Daemon for Lianad<C> {
         let _res: serde_json::value::Value = self.call("updatelabels", Some(vec![labels]))?;
         Ok(())
     }
+
+    async fn dump_labels(&self, offset: u32, limit: u32) -> Result<Labels, DaemonError> {
+        let res: DumpLabelsResult =
+            self.call("dumplabels", Some(vec![json!(offset), json!(limit)]))?;
+        Ok(res.labels)
+    }
 }
 
 #[derive(Debug, Clone, Deserialize, Serialize)]

liana-gui/src/daemon/embedded.rs

@@ -1,3 +1,4 @@
+use lianad::bip329::Labels;
 use std::collections::{HashMap, HashSet};
 use std::path::Path;
 use tokio::sync::Mutex;
@@ -227,4 +228,9 @@ impl Daemon for EmbeddedDaemon {
         })
         .await
     }
+
+    async fn dump_labels(&self, offset: u32, limit: u32) -> Result<Labels, DaemonError> {
+        self.command(|daemon| Ok(daemon.dump_labels(offset, limit).labels))
+            .await
+    }
 }

liana-gui/src/daemon/mod.rs

@@ -14,6 +14,7 @@ use async_trait::async_trait;
 use liana::miniscript::bitcoin::{
     address, bip32::Fingerprint, psbt::Psbt, secp256k1, Address, Network, OutPoint, Txid,
 };
+use lianad::bip329::Labels;
 use lianad::{
     commands::{CoinStatus, LabelItem, TransactionInfo},
     config::Config,
@@ -125,6 +126,7 @@ pub trait Daemon: Debug {
         &self,
         labels: &HashMap<LabelItem, Option<String>>,
     ) -> Result<(), DaemonError>;
+    async fn dump_labels(&self, offset: u32, limit: u32) -> Result<Labels, DaemonError>;
     async fn send_wallet_invitation(&self, _email: &str) -> Result<(), DaemonError> {
         Ok(())
     }