fix comments

common/src/chain/tokens/tokens_utils.rs

@@ -91,16 +91,16 @@ pub fn is_token_or_nft_issuance(output: &TxOutput) -> bool {
     }
 }
 
-/// Get any referenced token by this output
+/// Get any token referenced by this output
 /// ignore tokens V0
 pub fn get_referenced_token_ids(output: &TxOutput) -> BTreeSet<TokenId> {
     match output {
         TxOutput::Transfer(v, _)
         | TxOutput::LockThenTransfer(v, _, _)
         | TxOutput::Burn(v)
-        | TxOutput::Htlc(v, _) => referenced_token_id(v),
+        | TxOutput::Htlc(v, _) => referenced_token_id(v).into_iter().collect(),
         | TxOutput::CreateOrder(data) => {
-            let mut tokens = referenced_token_id(data.ask());
+            let mut tokens: BTreeSet<_> = referenced_token_id(data.ask()).into_iter().collect();
             tokens.extend(referenced_token_id(data.give()));
             tokens
         }
@@ -114,9 +114,9 @@ pub fn get_referenced_token_ids(output: &TxOutput) -> BTreeSet<TokenId> {
     }
 }
 
-fn referenced_token_id(v: &OutputValue) -> BTreeSet<TokenId> {
+fn referenced_token_id(v: &OutputValue) -> Option<TokenId> {
     match v {
-        OutputValue::Coin(_) | OutputValue::TokenV0(_) => BTreeSet::new(),
-        OutputValue::TokenV1(token_id, _) => BTreeSet::from_iter([*token_id]),
+        OutputValue::Coin(_) | OutputValue::TokenV0(_) => None,
+        OutputValue::TokenV1(token_id, _) => Some(*token_id),
     }
 }

crypto/src/key/signature/mod.rs

@@ -19,6 +19,8 @@ use std::io::BufWriter;
 use num_derive::FromPrimitive;
 use serialization::{hex_encoded::HexEncoded, Decode, DecodeAll, Encode};
 
+use super::SignatureError;
+
 #[derive(FromPrimitive)]
 pub enum SignatureKind {
     Secp256k1Schnorr = 0,
@@ -77,6 +79,12 @@ impl Signature {
         Ok(decoded_sig)
     }
 
+    pub fn from_raw_data<T: AsRef<[u8]>>(data: T) -> Result<Self, SignatureError> {
+        let decoded_sig = secp256k1::schnorr::Signature::from_slice(data.as_ref())
+            .map_err(|_| SignatureError::SignatureConstructionError)?;
+        Ok(Self::Secp256k1Schnorr(decoded_sig))
+    }
+
     pub fn is_aggregable(&self) -> bool {
         match self {
             Self::Secp256k1Schnorr(_) => false,

node-gui/src/backend/backend_impl.rs

@@ -351,26 +351,7 @@ impl Backend {
             }
             #[cfg(feature = "trezor")]
             (WalletType::Trezor, ColdHotNodeController::Cold) => {
-                let client = make_cold_wallet_rpc_client(Arc::clone(&self.chain_config));
-
-                let (wallet_rpc, command_handler, best_block, accounts_info, accounts_data) = self
-                    .create_wallet(
-                        client,
-                        file_path.clone(),
-                        wallet_args,
-                        import,
-                        wallet_events,
-                    )
-                    .await?;
-
-                let wallet_data = WalletData {
-                    controller: GuiHotColdController::Cold(wallet_rpc, command_handler),
-                    accounts: accounts_data,
-                    best_block,
-                    updated: false,
-                };
-
-                (wallet_data, accounts_info, best_block)
+                return Err(BackendError::ColdTrezorNotSupported)
             }
             (WalletType::Hot, ColdHotNodeController::Cold) => {
                 return Err(BackendError::HotNotSupported)
@@ -577,32 +558,7 @@ impl Backend {
                 }
                 #[cfg(feature = "trezor")]
                 (WalletType::Trezor, ColdHotNodeController::Cold) => {
-                    let client = make_cold_wallet_rpc_client(Arc::clone(&self.chain_config));
-
-                    let (
-                        wallet_rpc,
-                        command_handler,
-                        encryption_state,
-                        best_block,
-                        accounts_info,
-                        accounts_data,
-                    ) = self
-                        .open_wallet(
-                            client,
-                            file_path.clone(),
-                            wallet_events,
-                            Some(HardwareWalletType::Trezor),
-                        )
-                        .await?;
-
-                    let wallet_data = WalletData {
-                        controller: GuiHotColdController::Cold(wallet_rpc, command_handler),
-                        accounts: accounts_data,
-                        best_block,
-                        updated: false,
-                    };
-
-                    (wallet_data, accounts_info, best_block, encryption_state)
+                    return Err(BackendError::ColdTrezorNotSupported)
                 }
                 (WalletType::Hot, ColdHotNodeController::Cold) => {
                     return Err(BackendError::HotNotSupported)

node-gui/src/backend/error.rs

@@ -41,6 +41,8 @@ pub enum BackendError {
     ColdWallet,
     #[error("Cannot interact with a hot wallet when in Cold wallet mode")]
     HotNotSupported,
+    #[error("Cannot use a Trezor wallet in a Cold wallet mode")]
+    ColdTrezorNotSupported,
     #[error("Invalid console command: {0}")]
     InvalidConsoleCommand(String),
     #[error("Empty console command")]

node-gui/src/main_window/main_menu.rs

@@ -110,19 +110,19 @@ fn make_menu_file<'a>(wallet_mode: WalletMode) -> Item<'a, MenuMessage, Theme, i
             WalletMode::Hot => {
                 let menu = vec![
                     menu_item(
-                        "Create new Hot wallet",
+                        "Create new Software wallet",
                         MenuMessage::CreateNewWallet {
                             wallet_type: WalletType::Hot,
                         },
                     ),
                     menu_item(
-                        "Recover Hot wallet",
+                        "Recover Software wallet",
                         MenuMessage::RecoverWallet {
                             wallet_type: WalletType::Hot,
                         },
                     ),
                     menu_item(
-                        "Open Hot wallet",
+                        "Open Software wallet",
                         MenuMessage::OpenWallet {
                             wallet_type: WalletType::Hot,
                         },

node-gui/src/main_window/mod.rs

@@ -59,7 +59,7 @@ mod main_widget;
 enum ActiveDialog {
     None,
     WalletCreate {
-        generated_mnemonic: wallet_controller::mnemonic::Mnemonic,
+        wallet_args: WalletArgs,
         wallet_type: WalletType,
     },
     WalletRecover {
@@ -163,7 +163,7 @@ impl ImportOrCreate {
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum WalletArgs {
     Software {
         mnemonic: String,
@@ -276,11 +276,20 @@ impl MainWindow {
             MainWindowMessage::MenuMessage(menu_message) => match menu_message {
                 MenuMessage::NoOp => Command::none(),
                 MenuMessage::CreateNewWallet { wallet_type } => {
-                    let generated_mnemonic =
-                        wallet_controller::mnemonic::generate_new_mnemonic(self.language);
+                    let wallet_args = match wallet_type {
+                        WalletType::Hot | WalletType::Cold => WalletArgs::Software {
+                            mnemonic: wallet_controller::mnemonic::generate_new_mnemonic(
+                                self.language,
+                            )
+                            .to_string(),
+                        },
+                        #[cfg(feature = "trezor")]
+                        WalletType::Trezor => WalletArgs::Trezor,
+                    };
+
                     self.active_dialog = ActiveDialog::WalletCreate {
-                        generated_mnemonic,
                         wallet_type,
+                        wallet_args,
                     };
                     Command::none()
                 }
@@ -801,13 +810,13 @@ impl MainWindow {
                 ActiveDialog::None => Text::new("Nothing to show").into(),
 
                 ActiveDialog::WalletCreate {
-                    generated_mnemonic,
                     wallet_type,
+                    wallet_args,
                 } => {
                     let wallet_type = *wallet_type;
-                    match wallet_type {
-                        WalletType::Hot | WalletType::Cold => wallet_mnemonic_dialog(
-                            Some(generated_mnemonic.clone()),
+                    match wallet_args {
+                        WalletArgs::Software { mnemonic } => wallet_mnemonic_dialog(
+                            Some(mnemonic.clone()),
                             Box::new(move |mnemonic| MainWindowMessage::ImportWalletMnemonic {
                                 args: WalletArgs::Software { mnemonic },
                                 import: ImportOrCreate::Create,
@@ -817,7 +826,7 @@ impl MainWindow {
                         )
                         .into(),
                         #[cfg(feature = "trezor")]
-                        WalletType::Trezor => hw_wallet_create_dialog(
+                        WalletArgs::Trezor => hw_wallet_create_dialog(
                             Box::new(move || MainWindowMessage::ImportWalletMnemonic {
                                 args: WalletArgs::Trezor,
                                 import: ImportOrCreate::Create,

node-gui/src/widgets/wallet_mnemonic.rs

@@ -21,13 +21,13 @@ use iced::{
 use iced_aw::Card;
 
 pub struct WalletMnemonicDialog<Message> {
-    generated_mnemonic_opt: Option<wallet_controller::mnemonic::Mnemonic>,
+    generated_mnemonic_opt: Option<String>,
     on_import: Box<dyn Fn(String) -> Message>,
     on_close: Box<dyn Fn() -> Message>,
 }
 
 pub fn wallet_mnemonic_dialog<Message>(
-    generated_mnemonic_opt: Option<wallet_controller::mnemonic::Mnemonic>,
+    generated_mnemonic_opt: Option<String>,
     on_import: Box<dyn Fn(String) -> Message>,
     on_close: Box<dyn Fn() -> Message>,
 ) -> WalletMnemonicDialog<Message> {
@@ -67,7 +67,7 @@ impl<Message> Component<Message, Theme, iced::Renderer> for WalletMnemonicDialog
             ImportEvent::Ok => {
                 state.importing = true;
                 let mnemonic = match &self.generated_mnemonic_opt {
-                    Some(generated_mnemonic) => generated_mnemonic.to_string(),
+                    Some(generated_mnemonic) => generated_mnemonic.clone(),
                     None => state.entered_mnemonic.clone(),
                 };
                 Some((self.on_import)(mnemonic))
@@ -78,7 +78,7 @@ impl<Message> Component<Message, Theme, iced::Renderer> for WalletMnemonicDialog
 
     fn view(&self, state: &Self::State) -> Element<Self::Event, Theme, iced::Renderer> {
         let (mnemonic, action_text) = match &self.generated_mnemonic_opt {
-            Some(generated_mnemonic) => (generated_mnemonic.to_string(), "Create"),
+            Some(generated_mnemonic) => (generated_mnemonic.clone(), "Create"),
             None => (state.entered_mnemonic.clone(), "Recover"),
         };
 

wallet/src/send_request/mod.rs

@@ -332,7 +332,7 @@ impl SendRequest {
     }
 }
 
-/// Find aditional data for TxOutput, mainly for UI purposes
+/// Find additional data for TxOutput, mainly for UI purposes
 fn find_additional_info(
     utxo: &TxOutput,
     additional_info: &BTreeMap<PoolOrTokenId, UtxoAdditionalInfo>,
@@ -388,7 +388,7 @@ fn find_token_additional_info(
                 UtxoAdditionalInfo::TokenInfo(data) => Ok(Some(data.clone())),
                 UtxoAdditionalInfo::PoolInfo { staker_balance: _ }
                 | UtxoAdditionalInfo::CreateOrder { ask: _, give: _ } => {
-                    Err(WalletError::MissmatchedTokenAdditionalData(*token_id))
+                    Err(WalletError::MismatchedTokenAdditionalData(*token_id))
                 }
             })?,
     }

wallet/src/signer/mod.rs

@@ -15,17 +15,23 @@
 
 use std::sync::Arc;
 
-use common::chain::{
-    signature::{
-        inputsig::{
-            arbitrary_message::{ArbitraryMessageSignature, SignArbitraryMessageError},
-            classical_multisig::multisig_partial_signature::PartiallySignedMultisigStructureError,
+use common::{
+    address::AddressError,
+    chain::{
+        signature::{
+            inputsig::{
+                arbitrary_message::{ArbitraryMessageSignature, SignArbitraryMessageError},
+                classical_multisig::multisig_partial_signature::PartiallySignedMultisigStructureError,
+            },
+            DestinationSigError,
         },
-        DestinationSigError,
+        ChainConfig, Destination,
     },
-    ChainConfig, Destination,
 };
-use crypto::key::hdkd::{derivable::DerivationError, u31::U31};
+use crypto::key::{
+    hdkd::{derivable::DerivationError, u31::U31},
+    SignatureError,
+};
 use wallet_storage::{
     WalletStorageReadLocked, WalletStorageReadUnlocked, WalletStorageWriteUnlocked,
 };
@@ -80,6 +86,10 @@ pub enum SignerError {
     UnsupportedTokensV0,
     #[error("Invalid TxOutput type as UTXO, cannot be spent")]
     InvalidUtxo,
+    #[error("Address error: {0}")]
+    AddressError(#[from] AddressError),
+    #[error("Signature error: {0}")]
+    SignatureError(#[from] SignatureError),
 }
 
 type SignerResult<T> = Result<T, SignerError>;