Trezor firmware versioning

Author: ImplOfAnImpl

Cargo.lock

@@ -211,6 +211,7 @@ rlimit = "0.10"
 rstest = "0.24"
 rusqlite = "0.33"
 schnorrkel = "0.11"
+semver = "1.0"
 serde = "1.0"
 serde_json = "1.0"
 serde_test = "1.0"
@@ -248,8 +249,8 @@ zeroize = "1.5"
 
 [workspace.dependencies.trezor-client]
 git = "https://github.com/mintlayer/mintlayer-trezor-firmware"
-# The commit "Remove destination from MintlayerFillOrderV1; fail if the host asks to sign a FillOrder input"
-rev = "198346c2f731e7ff34be03b7a16818008eeeae0d"
+# The commit "Mintlayer firmware versioning"
+rev = "397155e26660993a044e78447dad893852fa44d1"
 features = ["bitcoin", "mintlayer"]
 
 [workspace.metadata.dist.dependencies.apt]

Cargo.toml

@@ -31,6 +31,8 @@ wallet-cli-commands = { path = "../../wallet/wallet-cli-commands"}
 anyhow.workspace = true
 chrono.workspace = true
 futures.workspace = true
+itertools.workspace = true
+semver.workspace = true
 serde = { workspace = true, features = ["derive"] }
 serde_json.workspace = true
 serde_with.workspace = true

node-gui/backend/Cargo.toml

@@ -15,29 +15,30 @@
 
 use std::{collections::BTreeMap, fmt::Debug, path::PathBuf, str::FromStr, sync::Arc};
 
+use futures::{stream::FuturesOrdered, TryStreamExt};
+use tokio::{
+    sync::mpsc::{UnboundedReceiver, UnboundedSender},
+    task::JoinHandle,
+};
+
 use common::{
     address::{Address, RpcAddress},
     chain::{ChainConfig, GenBlock, SignedTransaction},
     primitives::{per_thousand::PerThousand, BlockHeight, Id},
 };
 use crypto::key::hdkd::{child_number::ChildNumber, u31::U31};
-use futures::{stream::FuturesOrdered, TryStreamExt};
 use logging::log;
 use node_comm::rpc_client::ColdWalletClient;
 use node_lib::node_controller::NodeController;
 use serialization::hex_encoded::HexEncoded;
-use tokio::{
-    sync::mpsc::{UnboundedReceiver, UnboundedSender},
-    task::JoinHandle,
-};
 use wallet::{account::transaction_list::TransactionList, wallet::Error, WalletError};
 use wallet_cli_commands::{
     get_repl_command, parse_input, CommandHandler, ConsoleCommand, ManageableWalletCommand,
     WalletCommand,
 };
 use wallet_controller::{
     make_cold_wallet_rpc_client,
-    types::{Balances, WalletCreationOptions, WalletTypeArgs},
+    types::{Balances, WalletCreationOptions, WalletExtraInfo, WalletTypeArgs},
     ControllerConfig, NodeInterface, UtxoState, WalletHandlesClient,
 };
 use wallet_rpc_client::handles_client::WalletRpcHandlesClient;
@@ -361,6 +362,7 @@ impl Backend {
         };
 
         let encryption = EncryptionState::Disabled;
+        let wallet_extra_info = Self::get_wallet_extra_info(&wallet_data.controller).await?;
 
         let wallet_info = WalletInfo {
             wallet_id,
@@ -369,13 +371,31 @@ impl Backend {
             accounts: accounts_info,
             best_block,
             wallet_type,
+            extra_info: wallet_extra_info,
         };
 
         self.wallets.insert(wallet_id, wallet_data);
 
         Ok(wallet_info)
     }
 
+    async fn get_wallet_extra_info(
+        controller: &GuiHotColdController,
+    ) -> Result<WalletExtraInfo, BackendError> {
+        let wallet_info_from_rpc = match controller {
+            GuiHotColdController::Hot(wallet_rpc, _) => wallet_rpc
+                .wallet_info()
+                .await
+                .map_err(|err| BackendError::WalletError(err.to_string()))?,
+            GuiHotColdController::Cold(wallet_rpc, _) => wallet_rpc
+                .wallet_info()
+                .await
+                .map_err(|err| BackendError::WalletError(err.to_string()))?,
+        };
+
+        Ok(wallet_info_from_rpc.extra_info)
+    }
+
     async fn create_wallet<N>(
         &mut self,
         handles_client: N,
@@ -414,10 +434,18 @@ impl Backend {
             overwrite_wallet_file: true,
             scan_blockchain: import.should_scan_blockchain(),
         };
-        wallet_rpc
+        let created_wallet = wallet_rpc
             .create_wallet(file_path, wallet_args, options)
             .await
             .map_err(|err| BackendError::WalletError(err.to_string()))?;
+        match created_wallet {
+            wallet_controller::types::CreatedWallet::UserProvidedMnemonic
+            | wallet_controller::types::CreatedWallet::NewlyGeneratedMnemonic(_) => {}
+            #[cfg(feature = "trezor")]
+            wallet_controller::types::CreatedWallet::TrezorDeviceSelection(found_devices) => {
+                return Err(BackendError::MultipleTrezorDevicesFound(found_devices))
+            }
+        }
         tokio::spawn(forward_events(
             wallet_events,
             wallet_service
@@ -572,13 +600,16 @@ impl Backend {
                 }
             };
 
+        let wallet_extra_info = Self::get_wallet_extra_info(&wallet_data.controller).await?;
+
         let wallet_info = WalletInfo {
             wallet_id,
             path: file_path,
             encryption,
             accounts: accounts_info,
             best_block,
             wallet_type,
+            extra_info: wallet_extra_info,
         };
 
         self.wallets.insert(wallet_id, wallet_data);
@@ -619,7 +650,7 @@ impl Backend {
         let node_rpc = wallet_service.node_rpc().clone();
         let chain_config = wallet_service.chain_config().clone();
         let wallet_rpc = WalletRpc::new(wallet_handle, node_rpc.clone(), chain_config.clone());
-        wallet_rpc
+        let opened_wallet = wallet_rpc
             .open_wallet(
                 file_path,
                 None,
@@ -629,6 +660,13 @@ impl Backend {
             )
             .await
             .map_err(|err| BackendError::WalletError(err.to_string()))?;
+        match opened_wallet {
+            | wallet_controller::types::OpenedWallet::Opened => {}
+            #[cfg(feature = "trezor")]
+            wallet_controller::types::OpenedWallet::TrezorDeviceSelection(found_devices) => {
+                return Err(BackendError::MultipleTrezorDevicesFound(found_devices))
+            }
+        }
         tokio::spawn(forward_events(
             wallet_events,
             wallet_service

node-gui/backend/src/backend_impl.rs

@@ -13,6 +13,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use itertools::Itertools as _;
+
+#[cfg(feature = "trezor")]
+use wallet::signer::trezor_signer;
+
 use super::{account_id::AccountId, messages::WalletId};
 
 #[derive(thiserror::Error, Debug, Clone)]
@@ -47,4 +52,18 @@ pub enum BackendError {
     InvalidConsoleCommand(String),
     #[error("Empty console command")]
     EmptyConsoleCommand,
+
+    #[cfg(feature = "trezor")]
+    #[error(
+        "Multiple Trezor devices found: {}.\nLeave only one of them connected and try again.",
+        format_multiple_trezor_devices_err(_0)
+    )]
+    MultipleTrezorDevicesFound(Vec<trezor_signer::FoundDevice>),
+}
+
+fn format_multiple_trezor_devices_err(devices: &[trezor_signer::FoundDevice]) -> String {
+    devices
+        .iter()
+        .map(|device| format!("{} (device id = {})", device.device_name, device.device_id))
+        .join(", ")
 }

node-gui/backend/src/error.rs

@@ -33,7 +33,7 @@ use p2p::P2pEvent;
 use serialization::hex_encoded::hex_encoded_serialization;
 use wallet::account::transaction_list::TransactionList;
 use wallet_cli_commands::ConsoleCommand;
-use wallet_controller::types::{Balances, WalletTypeArgs};
+use wallet_controller::types::{Balances, WalletExtraInfo, WalletTypeArgs};
 use wallet_rpc_lib::types::PoolInfo;
 use wallet_types::wallet_type::WalletType;
 
@@ -58,6 +58,7 @@ pub struct WalletInfo {
     pub accounts: BTreeMap<AccountId, AccountInfo>,
     pub best_block: (Id<GenBlock>, BlockHeight),
     pub wallet_type: WalletType,
+    pub extra_info: WalletExtraInfo,
 }
 
 #[derive(Debug, Clone, Serialize)]

node-gui/backend/src/messages.rs

@@ -96,15 +96,16 @@ fn labeled_button<'a>(label: &'a str, msg: MenuMessage) -> button::Button<'a, Me
 }
 
 fn menu_item(label: &str, msg: MenuMessage) -> Item<'_, MenuMessage, Theme, iced::Renderer> {
-    Item::new(labeled_button(label, msg).width(Length::Fixed(230.0)))
+    // Note: if this width is smaller than the text, the menu item will drop the whole last word.
+    Item::new(labeled_button(label, msg).width(Length::Fixed(270.0)))
 }
 
 fn make_menu_file<'a>(wallet_mode: WalletMode) -> Item<'a, MenuMessage, Theme, iced::Renderer> {
     let root = Item::with_menu(
         labeled_button("File", MenuMessage::NoOp),
         Menu::new(match wallet_mode {
             WalletMode::Hot => {
-                let menu = vec![
+                let mut menu = vec![
                     menu_item(
                         "Create new Software wallet",
                         MenuMessage::CreateNewWallet {
@@ -123,43 +124,31 @@ fn make_menu_file<'a>(wallet_mode: WalletMode) -> Item<'a, MenuMessage, Theme, i
                             wallet_type: WalletType::Hot,
                         },
                     ),
-                    // TODO: enable setting when needed
-                    // menu_item("Settings", MenuMessage::NoOp),
-                    menu_item("Exit", MenuMessage::Exit),
                 ];
                 #[cfg(feature = "trezor")]
                 {
-                    let mut menu = menu;
-                    menu.insert(
-                        1,
-                        menu_item(
-                            "Create new Trezor wallet",
-                            MenuMessage::CreateNewWallet {
-                                wallet_type: WalletType::Trezor,
-                            },
-                        ),
-                    );
-                    menu.insert(
-                        3,
-                        menu_item(
-                            "Recover from Trezor wallet",
-                            MenuMessage::RecoverWallet {
-                                wallet_type: WalletType::Trezor,
-                            },
-                        ),
-                    );
-                    menu.insert(
-                        5,
-                        menu_item(
-                            "Open Trezor wallet",
-                            MenuMessage::OpenWallet {
-                                wallet_type: WalletType::Trezor,
-                            },
-                        ),
-                    );
-                    menu
+                    menu.push(menu_item(
+                        "(Beta) Create new Trezor wallet",
+                        MenuMessage::CreateNewWallet {
+                            wallet_type: WalletType::Trezor,
+                        },
+                    ));
+                    menu.push(menu_item(
+                        "(Beta) Recover from Trezor wallet",
+                        MenuMessage::RecoverWallet {
+                            wallet_type: WalletType::Trezor,
+                        },
+                    ));
+                    menu.push(menu_item(
+                        "(Beta) Open Trezor wallet",
+                        MenuMessage::OpenWallet {
+                            wallet_type: WalletType::Trezor,
+                        },
+                    ));
                 }
-                #[cfg(not(feature = "trezor"))]
+                // TODO: enable setting when needed
+                // menu.push(menu_item("Settings", MenuMessage::NoOp));
+                menu.push(menu_item("Exit", MenuMessage::Exit));
                 menu
             }
             WalletMode::Cold => {
@@ -188,7 +177,7 @@ fn make_menu_file<'a>(wallet_mode: WalletMode) -> Item<'a, MenuMessage, Theme, i
                 ]
             }
         })
-        .width(260),
+        .width(300),
     );
 
     root

node-gui/src/main_window/main_menu.rs

@@ -40,12 +40,11 @@ fn get_network_type_capitalized(chain_config: &ChainConfig) -> String {
 impl Tab for ColdWalletTab {
     type Message = TabsMessage;
 
-    fn title(&self) -> String {
-        String::from("Cold wallet summary")
-    }
-
-    fn tab_label(&self) -> TabLabel {
-        TabLabel::IconText(iced_fonts::Bootstrap::Info.into(), self.title())
+    fn tab_label(&self, _node_state: &NodeState) -> TabLabel {
+        TabLabel::IconText(
+            iced_fonts::Bootstrap::Info.into(),
+            String::from("Cold wallet summary"),
+        )
     }
 
     fn content(&self, node_state: &NodeState) -> Element<Self::Message> {