728433911

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/iotaledger/wallet.rs/commit/<a class=hub.com/iotaledger/wallet.rs/commit/0fcf4bca7a8813b19b115e75f0a100a48cad4c52">0fcf4bca7<a href="https://github.com/iotaledger/wallet.rs/commit/0fcf4bca7a8813b19b115e75f0a100a48cad4c52">">Merge </a><a class="double-link" href="https://github.com/iotaledger/wallet.rs/commit/<a class="double-link" href="https://github.com/iotaledger/wallet.rs/commit/c578882a3b46e151be0a7edd158c3dbb82ec3d2f">c578882a3</a>">c578882a3</a><a href="https://github.com/iotaledger/wallet.rs/commit/0fcf4bca7a8813b19b115e75f0a100a48cad4c52"> into 53af1cb5b">53af1cb5b</a>

Pull Request Pull Request #514: feat: migration

Run Details

342 of 342 new or added lines in 5 files covered. (100.0%)

4148 of 8036 relevant lines covered (51.62%)

691326.93 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

7.07

/src/error.rs

// Copyright 2020 IOTA Stiftung
// SPDX-License-Identifier: Apache-2.0

use serde::ser::{SerializeStruct, Serializer};

use std::path::PathBuf;

/// Each of the account initialisation required fields.
#[derive(Debug)]
pub enum AccountInitialiseRequiredField {
    /// `signer_type` field.
    SignerType,
}

impl std::fmt::Display for AccountInitialiseRequiredField {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", format!("{:?}", self).to_lowercase())
    }
}

/// Each of the address builder required fields.
#[derive(Debug)]
pub enum AddressBuildRequiredField {
    /// address field.
    Address,
    /// key_index field.
    KeyIndex,
    /// outputs field.
    Outputs,
}

impl std::fmt::Display for AddressBuildRequiredField {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", format!("{:?}", self).to_lowercase())
    }
}

/// The wallet error type.
#[derive(Debug, thiserror::Error)]
pub enum Error {
    /// IO error. (storage, backup, restore)
    #[error("`{0}`")]
    IoError(#[from] std::io::Error),
    /// serde_json error.
    #[error("`{0}`")]
    JsonError(#[from] serde_json::error::Error),
    /// stronghold client error.
    #[cfg(feature = "stronghold")]
    #[cfg_attr(docsrs, doc(cfg(feature = "stronghold")))]
    #[error("`{0}`")]
    StrongholdError(crate::stronghold::Error),
    /// iota.rs error.
    #[error("`{0}`")]
    ClientError(Box<iota::client::Error>),
    /// url parse error (client options builder).
    #[error("`{0}`")]
    UrlError(#[from] url::ParseError),
    /// Message not found.
    #[error("message not found")]
    MessageNotFound,
    /// Message id length response invalid.
    #[error("unexpected message_id length")]
    InvalidMessageIdLength,
    /// failed to parse address.
    #[error("invalid address")]
    InvalidAddress,
    /// Address length response invalid.
    #[error("invalid address length")]
    InvalidAddressLength,
    /// Tried to backup but storage file doesn't exist.
    #[error("storage file doesn't exist")]
    StorageDoesntExist,
    /// Insufficient funds to send transfer.
    #[error("insufficient funds")]
    InsufficientFunds,
    /// Account isn't empty (has history or balance) - can't delete account.
    #[error("can't delete account: account has history or balance")]
    AccountNotEmpty,
    /// Latest account is empty (doesn't have history and balance) - can't create account.
    #[error("can't create accounts when the latest account doesn't have message history and balance")]
    LatestAccountIsEmpty,
    /// Account not found
    #[error("account not found")]
    RecordNotFound,
    /// invalid remainder value target address defined on `RemainderValueStrategy`.
    /// the address must belong to the account.
    #[error("the remainder value address doesn't belong to the account")]
    InvalidRemainderValueAddress,
    /// Storage access error.
    #[error("error accessing storage: {0}")]
    Storage(String),
    /// Panic error.
    #[error("a panic happened: {0}")]
    Panic(String),
    /// Invalid message identifier.
    #[error("invalid message id received by node")]
    InvalidMessageId,
    /// Invalid transaction identifier.
    #[error("invalid transaction id received by node")]
    InvalidTransactionId,
    /// Address build error: required field not filled.
    #[error("address build error, field `{0}` is required")]
    AddressBuildRequiredField(AddressBuildRequiredField),
    /// Account initialisation error: required field not filled.
    #[error("account initialisation error, field `{0}` is required")]
    AccountInitialiseRequiredField(AccountInitialiseRequiredField),
    /// Error from bee_message crate.
    #[error("{0}")]
    BeeMessage(iota::message::Error),
    /// Path provided to `import_accounts` isn't a valid file
    #[error("provided backup path isn't a valid file")]
    InvalidBackupFile,
    /// Backup `destination` argument is invalid
    #[error("backup destination must be an existing directory or a file on an existing directory")]
    InvalidBackupDestination,
    /// Mnemonic generation error.
    #[error("mnemonic encode error: {0}")]
    MnemonicEncode(String),
    /// Invalid mnemonic error
    #[error("invalid mnemonic: {0}")]
    InvalidMnemonic(String),
    /// Can't import accounts because the storage already exist
    #[error("failed to restore backup: storage file already exists")]
    StorageExists,
    /// Storage adapter not defined for the given storage path.
    #[error(
        "storage adapter not set for path `{0}`; please use the method `with_storage` on the AccountManager builder"
    )]
    StorageAdapterNotSet(PathBuf),
    /// error decrypting stored record using provided encryptionKey
    #[error("failed to decrypt record: {0}")]
    RecordDecrypt(String),
    /// error encrypting stored record using provided encryptionKey
    #[error("failed to encrypt record: {0}")]
    RecordEncrypt(String),
    /// Can't use AccountManager API because the storage is encrypted
    #[error(
        "can't perform operation while storage is encrypted; use AccountManager::set_storage_password to decrypt storage"
    )]
    StorageIsEncrypted,
    /// cannot use index to get account - multiple index sequences found (two or more different signer types stored on
    /// accounts)
    #[error("cannot use index identifier when two signer types are used")]
    CannotUseIndexIdentifier,
    /// Ledger transport error
    #[cfg(any(feature = "ledger-nano", feature = "ledger-nano-simulator"))]
    #[error("ledger transport error")]
    LedgerMiscError,
    /// Dongle Locked
    #[cfg(any(feature = "ledger-nano", feature = "ledger-nano-simulator"))]
    #[error("ledger locked")]
    LedgerDongleLocked,
    /// Denied by User
    #[cfg(any(feature = "ledger-nano", feature = "ledger-nano-simulator"))]
    #[error("denied by user")]
    LedgerDeniedByUser,
    /// Ledger Device not found
    #[cfg(any(feature = "ledger-nano", feature = "ledger-nano-simulator"))]
    #[error("ledger device not found")]
    LedgerDeviceNotFound,
    /// Ledger Essence Too Large
    #[cfg(any(feature = "ledger-nano", feature = "ledger-nano-simulator"))]
    #[error("ledger essence too large")]
    LedgerEssenceTooLarge,
    /// Account alias must be unique.
    #[error("can't create account: account alias already exists")]
    AccountAliasAlreadyExists,
    /// Dust error, for example not enough balance on an address.
    #[error("Dust error: {0}")]
    DustError(String),
    /// Invalid output kind.
    #[error("invalid output kind: {0}")]
    InvalidOutputKind(String),
    /// Node not synced when creating account or updating client options.
    #[error("nodes {0} not synced")]
    NodesNotSynced(String),
    /// iota 1.0 client error
    // #[cfg(feature = "migration")]
    #[error(transparent)]
    LegacyClientError(Box<iota_migration::client::Error>),
    /// Invalid legacy seed.
    #[error("invalid seed")]
    InvalidSeed,
    /// Migration data not found.
    #[error("migration data not found for the provided seed; call `get_migration_data` first.")]
    MigrationDataNotFound,
    /// Migration bundle not found.
    #[error("migration bundle not found with the provided bundle hash")]
    MigrationBundleNotFound,
    /// Input not found with given index.
    #[error("input not found with the provided index")]
    InputNotFound,
    /// Empty input list on migration bundle creation.
    #[error("can't create migration bundle: input list is empty")]
    EmptyInputList,
    /// Cannot create bundle when the number of inputs is larger than 1 and there's a spent input.
    /// Spent addresses must be the only input in a bundle.
    #[error("can't create migration bundle: the bundle has more than one input and one of them are spent")]
    SpentAddressOnBundle,
}

impl Drop for Error {
    fn drop(&mut self) {
        crate::event::emit_error(self);
    }
}

impl From<iota::client::Error> for Error {
    fn from(error: iota::client::Error) -> Self {
        Self::ClientError(Box::new(error))
    }
}

impl From<iota_migration::client::Error> for Error {
    fn from(error: iota_migration::client::Error) -> Self {
        Self::LegacyClientError(Box::new(error))
    }
}

impl From<iota::message::Error> for Error {
    fn from(error: iota::message::Error) -> Self {
        Self::BeeMessage(error)
    }
}

#[cfg(feature = "stronghold")]
impl From<crate::stronghold::Error> for Error {
    fn from(error: crate::stronghold::Error) -> Self {
        match error {
            crate::stronghold::Error::RecordNotFound => Self::RecordNotFound,
            _ => Self::StrongholdError(error),
        }
    }
}

// map most errors to a single error but there are some errors that
// need special care.
// LedgerDongleLocked: Ask the user to unlock the dongle
// LedgerDeniedByUser: The user denied a signing
// LedgerDeviceNotFound: No usable Ledger device was found
// LedgerMiscError: Everything else.
// LedgerEssenceTooLarge: Essence with bip32 input indices need more space then the internal buffer is big
#[cfg(any(feature = "ledger-nano", feature = "ledger-nano-simulator"))]
impl From<iota_ledger::api::errors::APIError> for Error {
    fn from(error: iota_ledger::api::errors::APIError) -> Self {
        log::info!("ledger error: {}", error);
        match error {
            iota_ledger::api::errors::APIError::SecurityStatusNotSatisfied => Error::LedgerDongleLocked,
            iota_ledger::api::errors::APIError::ConditionsOfUseNotSatisfied => Error::LedgerDeniedByUser,
            iota_ledger::api::errors::APIError::TransportError => Error::LedgerDeviceNotFound,
            iota_ledger::api::errors::APIError::EssenceTooLarge => Error::LedgerEssenceTooLarge,
            _ => Error::LedgerMiscError,
        }
    }
}

impl serde::Serialize for Error {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        fn serialize_variant<S: Serializer>(
            error: &Error,
            serializer: S,
            variant_name: &str,
        ) -> std::result::Result<S::Ok, S::Error> {
            let mut state = serializer.serialize_struct("Error", 2)?;
            state.serialize_field("type", variant_name)?;
            state.serialize_field("error", &error.to_string())?;
            state.end()
        }

        match self {
            Self::IoError(_) => serialize_variant(self, serializer, "IoError"),
            Self::JsonError(_) => serialize_variant(self, serializer, "JsonError"),
            #[cfg(feature = "stronghold")]
            Self::StrongholdError(_) => serialize_variant(self, serializer, "StrongholdError"),
            Self::ClientError(_) => serialize_variant(self, serializer, "ClientError"),
            Self::UrlError(_) => serialize_variant(self, serializer, "UrlError"),
            Self::MessageNotFound => serialize_variant(self, serializer, "MessageNotFound"),
            Self::InvalidMessageIdLength => serialize_variant(self, serializer, "InvalidMessageIdLength"),
            Self::InvalidAddress => serialize_variant(self, serializer, "InvalidAddress"),
            Self::InvalidAddressLength => serialize_variant(self, serializer, "InvalidAddressLength"),
            Self::StorageDoesntExist => serialize_variant(self, serializer, "StorageDoesntExist"),
            Self::InsufficientFunds => serialize_variant(self, serializer, "InsufficientFunds"),
            Self::AccountNotEmpty => serialize_variant(self, serializer, "AccountNotEmpty"),
            Self::LatestAccountIsEmpty => serialize_variant(self, serializer, "LatestAccountIsEmpty"),
            Self::RecordNotFound => serialize_variant(self, serializer, "RecordNotFound"),
            Self::InvalidRemainderValueAddress => serialize_variant(self, serializer, "InvalidRemainderValueAddress"),
            Self::Storage(_) => serialize_variant(self, serializer, "Storage"),
            Self::Panic(_) => serialize_variant(self, serializer, "Panic"),
            Self::InvalidMessageId => serialize_variant(self, serializer, "InvalidMessageId"),
            Self::InvalidTransactionId => serialize_variant(self, serializer, "InvalidTransactionId"),
            Self::AddressBuildRequiredField(_) => serialize_variant(self, serializer, "AddressBuildRequiredField"),
            Self::AccountInitialiseRequiredField(_) => {
                serialize_variant(self, serializer, "AccountInitialiseRequiredField")
            }
            Self::BeeMessage(_) => serialize_variant(self, serializer, "BeeMessage"),
            Self::MnemonicEncode(_) => serialize_variant(self, serializer, "MnemonicEncode"),
            Self::InvalidMnemonic(_) => serialize_variant(self, serializer, "InvalidMnemonic"),
            Self::InvalidBackupFile => serialize_variant(self, serializer, "InvalidBackupFile"),
            Self::InvalidBackupDestination => serialize_variant(self, serializer, "InvalidBackupDestination"),
            Self::StorageExists => serialize_variant(self, serializer, "StorageExists"),
            Self::StorageAdapterNotSet(_) => serialize_variant(self, serializer, "StorageAdapterNotSet"),
            Self::RecordDecrypt(_) => serialize_variant(self, serializer, "RecordDecrypt"),
            Self::RecordEncrypt(_) => serialize_variant(self, serializer, "RecordEncrypt"),
            Self::StorageIsEncrypted => serialize_variant(self, serializer, "StorageIsEncrypted"),
            Self::CannotUseIndexIdentifier => serialize_variant(self, serializer, "CannotUseIndexIdentifier"),
            #[cfg(any(feature = "ledger-nano", feature = "ledger-nano-simulator"))]
            Self::LedgerMiscError => serialize_variant(self, serializer, "LedgerMiscError"),
            #[cfg(any(feature = "ledger-nano", feature = "ledger-nano-simulator"))]
            Self::LedgerDongleLocked => serialize_variant(self, serializer, "LedgerDongleLocked"),
            #[cfg(any(feature = "ledger-nano", feature = "ledger-nano-simulator"))]
            Self::LedgerDeniedByUser => serialize_variant(self, serializer, "LedgerDeniedByUser"),
            #[cfg(any(feature = "ledger-nano", feature = "ledger-nano-simulator"))]
            Self::LedgerDeviceNotFound => serialize_variant(self, serializer, "LedgerDeviceNotFound"),
            #[cfg(any(feature = "ledger-nano", feature = "ledger-nano-simulator"))]
            Self::LedgerEssenceTooLarge => serialize_variant(self, serializer, "LedgerEssenceTooLarge"),
            Self::AccountAliasAlreadyExists => serialize_variant(self, serializer, "AccountAliasAlreadyExists"),
            Self::DustError(_) => serialize_variant(self, serializer, "DustError"),
            Self::InvalidOutputKind(_) => serialize_variant(self, serializer, "InvalidOutputKind"),
            Self::NodesNotSynced(_) => serialize_variant(self, serializer, "NodesNotSynced"),
            // #[cfg(feature = "migration")]
            Self::LegacyClientError(_) => serialize_variant(self, serializer, "LegacyClientError"),
            Self::InvalidSeed => serialize_variant(self, serializer, "InvalidSeed"),
            Self::MigrationDataNotFound => serialize_variant(self, serializer, "MigrationDataNotFound"),
            Self::MigrationBundleNotFound => serialize_variant(self, serializer, "MigrationBundleNotFound"),
            Self::InputNotFound => serialize_variant(self, serializer, "InputNotFound"),
            Self::EmptyInputList => serialize_variant(self, serializer, "EmptyInputList"),
            Self::SpentAddressOnBundle => serialize_variant(self, serializer, "SpentAddressOnBundle"),
        }
    }
}

1	// Copyright 2020 IOTA Stiftung
2	// SPDX-License-Identifier: Apache-2.0
3
4	use serde::ser::{SerializeStruct, Serializer};
5
6	use std::path::PathBuf;
7
8	/// Each of the account initialisation required fields.
9	#[derive(Debug)]	×
10	pub enum AccountInitialiseRequiredField {
11	/// `signer_type` field.
12	SignerType,
13	}
14
15	impl std::fmt::Display for AccountInitialiseRequiredField {
16	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {	×
17	write!(f, "{}", format!("{:?}", self).to_lowercase())	×
18	}	×
19	}
20
21	/// Each of the address builder required fields.
22	#[derive(Debug)]	×
23	pub enum AddressBuildRequiredField {
24	/// address field.
25	Address,
26	/// key_index field.
27	KeyIndex,
28	/// outputs field.
29	Outputs,
30	}
31
32	impl std::fmt::Display for AddressBuildRequiredField {
33	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {	×
34	write!(f, "{}", format!("{:?}", self).to_lowercase())	×
35	}	×
36	}
37
38	/// The wallet error type.
39	#[derive(Debug, thiserror::Error)]	3✔
40	pub enum Error {
41	/// IO error. (storage, backup, restore)
42	#[error("`{0}`")]
43	IoError(#[from] std::io::Error),
44	/// serde_json error.
45	#[error("`{0}`")]
46	JsonError(#[from] serde_json::error::Error),
47	/// stronghold client error.
48	#[cfg(feature = "stronghold")]
49	#[cfg_attr(docsrs, doc(cfg(feature = "stronghold")))]
50	#[error("`{0}`")]
51	StrongholdError(crate::stronghold::Error),
52	/// iota.rs error.
53	#[error("`{0}`")]
54	ClientError(Box<iota::client::Error>),
55	/// url parse error (client options builder).
56	#[error("`{0}`")]
57	UrlError(#[from] url::ParseError),
58	/// Message not found.
59	#[error("message not found")]
60	MessageNotFound,
61	/// Message id length response invalid.
62	#[error("unexpected message_id length")]
63	InvalidMessageIdLength,
64	/// failed to parse address.
65	#[error("invalid address")]
66	InvalidAddress,
67	/// Address length response invalid.
68	#[error("invalid address length")]
69	InvalidAddressLength,
70	/// Tried to backup but storage file doesn't exist.
71	#[error("storage file doesn't exist")]
72	StorageDoesntExist,
73	/// Insufficient funds to send transfer.
74	#[error("insufficient funds")]
75	InsufficientFunds,
76	/// Account isn't empty (has history or balance) - can't delete account.
77	#[error("can't delete account: account has history or balance")]
78	AccountNotEmpty,
79	/// Latest account is empty (doesn't have history and balance) - can't create account.
80	#[error("can't create accounts when the latest account doesn't have message history and balance")]
81	LatestAccountIsEmpty,
82	/// Account not found
83	#[error("account not found")]
84	RecordNotFound,
85	/// invalid remainder value target address defined on `RemainderValueStrategy`.
86	/// the address must belong to the account.
87	#[error("the remainder value address doesn't belong to the account")]
88	InvalidRemainderValueAddress,
89	/// Storage access error.
90	#[error("error accessing storage: {0}")]
91	Storage(String),
92	/// Panic error.
93	#[error("a panic happened: {0}")]
94	Panic(String),
95	/// Invalid message identifier.
96	#[error("invalid message id received by node")]
97	InvalidMessageId,
98	/// Invalid transaction identifier.
99	#[error("invalid transaction id received by node")]
100	InvalidTransactionId,
101	/// Address build error: required field not filled.
102	#[error("address build error, field `{0}` is required")]
103	AddressBuildRequiredField(AddressBuildRequiredField),
104	/// Account initialisation error: required field not filled.
105	#[error("account initialisation error, field `{0}` is required")]
106	AccountInitialiseRequiredField(AccountInitialiseRequiredField),
107	/// Error from bee_message crate.
108	#[error("{0}")]
109	BeeMessage(iota::message::Error),
110	/// Path provided to `import_accounts` isn't a valid file
111	#[error("provided backup path isn't a valid file")]
112	InvalidBackupFile,
113	/// Backup `destination` argument is invalid
114	#[error("backup destination must be an existing directory or a file on an existing directory")]
115	InvalidBackupDestination,
116	/// Mnemonic generation error.
117	#[error("mnemonic encode error: {0}")]
118	MnemonicEncode(String),
119	/// Invalid mnemonic error
120	#[error("invalid mnemonic: {0}")]
121	InvalidMnemonic(String),
122	/// Can't import accounts because the storage already exist
123	#[error("failed to restore backup: storage file already exists")]
124	StorageExists,
125	/// Storage adapter not defined for the given storage path.
126	#[error(
127	"storage adapter not set for path `{0}`; please use the method `with_storage` on the AccountManager builder"
128	)]
129	StorageAdapterNotSet(PathBuf),
130	/// error decrypting stored record using provided encryptionKey
131	#[error("failed to decrypt record: {0}")]
132	RecordDecrypt(String),
133	/// error encrypting stored record using provided encryptionKey
134	#[error("failed to encrypt record: {0}")]
135	RecordEncrypt(String),
136	/// Can't use AccountManager API because the storage is encrypted
137	#[error(
138	"can't perform operation while storage is encrypted; use AccountManager::set_storage_password to decrypt storage"
139	)]
140	StorageIsEncrypted,
141	/// cannot use index to get account - multiple index sequences found (two or more different signer types stored on
142	/// accounts)
143	#[error("cannot use index identifier when two signer types are used")]
144	CannotUseIndexIdentifier,
145	/// Ledger transport error
146	#[cfg(any(feature = "ledger-nano", feature = "ledger-nano-simulator"))]
147	#[error("ledger transport error")]
148	LedgerMiscError,
149	/// Dongle Locked
150	#[cfg(any(feature = "ledger-nano", feature = "ledger-nano-simulator"))]
151	#[error("ledger locked")]
152	LedgerDongleLocked,
153	/// Denied by User
154	#[cfg(any(feature = "ledger-nano", feature = "ledger-nano-simulator"))]
155	#[error("denied by user")]
156	LedgerDeniedByUser,
157	/// Ledger Device not found
158	#[cfg(any(feature = "ledger-nano", feature = "ledger-nano-simulator"))]
159	#[error("ledger device not found")]
160	LedgerDeviceNotFound,
161	/// Ledger Essence Too Large
162	#[cfg(any(feature = "ledger-nano", feature = "ledger-nano-simulator"))]
163	#[error("ledger essence too large")]
164	LedgerEssenceTooLarge,
165	/// Account alias must be unique.
166	#[error("can't create account: account alias already exists")]
167	AccountAliasAlreadyExists,
168	/// Dust error, for example not enough balance on an address.
169	#[error("Dust error: {0}")]
170	DustError(String),
171	/// Invalid output kind.
172	#[error("invalid output kind: {0}")]
173	InvalidOutputKind(String),
174	/// Node not synced when creating account or updating client options.
175	#[error("nodes {0} not synced")]
176	NodesNotSynced(String),
177	/// iota 1.0 client error
178	// #[cfg(feature = "migration")]
179	#[error(transparent)]
180	LegacyClientError(Box<iota_migration::client::Error>),
181	/// Invalid legacy seed.
182	#[error("invalid seed")]
183	InvalidSeed,
184	/// Migration data not found.
185	#[error("migration data not found for the provided seed; call `get_migration_data` first.")]
186	MigrationDataNotFound,
187	/// Migration bundle not found.
188	#[error("migration bundle not found with the provided bundle hash")]
189	MigrationBundleNotFound,
190	/// Input not found with given index.
191	#[error("input not found with the provided index")]
192	InputNotFound,
193	/// Empty input list on migration bundle creation.
194	#[error("can't create migration bundle: input list is empty")]
195	EmptyInputList,
196	/// Cannot create bundle when the number of inputs is larger than 1 and there's a spent input.
197	/// Spent addresses must be the only input in a bundle.
198	#[error("can't create migration bundle: the bundle has more than one input and one of them are spent")]
199	SpentAddressOnBundle,
200	}
201
202	impl Drop for Error {
203	fn drop(&mut self) {	6,320✔
204	crate::event::emit_error(self);	6,320✔
205	}	6,320✔
206	}
207
208	impl From<iota::client::Error> for Error {
209	fn from(error: iota::client::Error) -> Self {	×
210	Self::ClientError(Box::new(error))	×
211	}	×
212	}
213
214	impl From<iota_migration::client::Error> for Error {
215	fn from(error: iota_migration::client::Error) -> Self {	×
216	Self::LegacyClientError(Box::new(error))	×
217	}	×
218	}
219
220	impl From<iota::message::Error> for Error {
221	fn from(error: iota::message::Error) -> Self {	21✔
222	Self::BeeMessage(error)	21✔
223	}	21✔
224	}
225
226	#[cfg(feature = "stronghold")]
227	impl From<crate::stronghold::Error> for Error {
228	fn from(error: crate::stronghold::Error) -> Self {	×
229	match error {	×
230	crate::stronghold::Error::RecordNotFound => Self::RecordNotFound,	×
231	_ => Self::StrongholdError(error),	×
232	}
233	}	×
234	}
235
236	// map most errors to a single error but there are some errors that
237	// need special care.
238	// LedgerDongleLocked: Ask the user to unlock the dongle
239	// LedgerDeniedByUser: The user denied a signing
240	// LedgerDeviceNotFound: No usable Ledger device was found
241	// LedgerMiscError: Everything else.
242	// LedgerEssenceTooLarge: Essence with bip32 input indices need more space then the internal buffer is big
243	#[cfg(any(feature = "ledger-nano", feature = "ledger-nano-simulator"))]
244	impl From<iota_ledger::api::errors::APIError> for Error {
245	fn from(error: iota_ledger::api::errors::APIError) -> Self {
246	log::info!("ledger error: {}", error);	×
247	match error {	×
248	iota_ledger::api::errors::APIError::SecurityStatusNotSatisfied => Error::LedgerDongleLocked,	×
249	iota_ledger::api::errors::APIError::ConditionsOfUseNotSatisfied => Error::LedgerDeniedByUser,	×
250	iota_ledger::api::errors::APIError::TransportError => Error::LedgerDeviceNotFound,	×
251	iota_ledger::api::errors::APIError::EssenceTooLarge => Error::LedgerEssenceTooLarge,	×
252	_ => Error::LedgerMiscError,	×
253	}
254	}	×
255	}
256
257	impl serde::Serialize for Error {
258	fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>	×
259	where	×
260	S: Serializer,	×
261	{	×
262	fn serialize_variant<S: Serializer>(	×
263	error: &Error,	×
264	serializer: S,	×
265	variant_name: &str,	×
266	) -> std::result::Result<S::Ok, S::Error> {	×
267	let mut state = serializer.serialize_struct("Error", 2)?;	×
268	state.serialize_field("type", variant_name)?;	×
269	state.serialize_field("error", &error.to_string())?;	×
270	state.end()	×
271	}	×
272		×
273	match self {	×
274	Self::IoError(_) => serialize_variant(self, serializer, "IoError"),	×
275	Self::JsonError(_) => serialize_variant(self, serializer, "JsonError"),	×
276	#[cfg(feature = "stronghold")]
277	Self::StrongholdError(_) => serialize_variant(self, serializer, "StrongholdError"),	×
278	Self::ClientError(_) => serialize_variant(self, serializer, "ClientError"),	×
279	Self::UrlError(_) => serialize_variant(self, serializer, "UrlError"),	×
280	Self::MessageNotFound => serialize_variant(self, serializer, "MessageNotFound"),	×
281	Self::InvalidMessageIdLength => serialize_variant(self, serializer, "InvalidMessageIdLength"),	×
282	Self::InvalidAddress => serialize_variant(self, serializer, "InvalidAddress"),	×
283	Self::InvalidAddressLength => serialize_variant(self, serializer, "InvalidAddressLength"),	×
284	Self::StorageDoesntExist => serialize_variant(self, serializer, "StorageDoesntExist"),	×
285	Self::InsufficientFunds => serialize_variant(self, serializer, "InsufficientFunds"),	×
286	Self::AccountNotEmpty => serialize_variant(self, serializer, "AccountNotEmpty"),	×
287	Self::LatestAccountIsEmpty => serialize_variant(self, serializer, "LatestAccountIsEmpty"),	×
288	Self::RecordNotFound => serialize_variant(self, serializer, "RecordNotFound"),	×
289	Self::InvalidRemainderValueAddress => serialize_variant(self, serializer, "InvalidRemainderValueAddress"),	×
290	Self::Storage(_) => serialize_variant(self, serializer, "Storage"),	×
291	Self::Panic(_) => serialize_variant(self, serializer, "Panic"),	×
292	Self::InvalidMessageId => serialize_variant(self, serializer, "InvalidMessageId"),	×
293	Self::InvalidTransactionId => serialize_variant(self, serializer, "InvalidTransactionId"),	×
294	Self::AddressBuildRequiredField(_) => serialize_variant(self, serializer, "AddressBuildRequiredField"),	×
295	Self::AccountInitialiseRequiredField(_) => {
296	serialize_variant(self, serializer, "AccountInitialiseRequiredField")	×
297	}
298	Self::BeeMessage(_) => serialize_variant(self, serializer, "BeeMessage"),	×
299	Self::MnemonicEncode(_) => serialize_variant(self, serializer, "MnemonicEncode"),	×
300	Self::InvalidMnemonic(_) => serialize_variant(self, serializer, "InvalidMnemonic"),	×
301	Self::InvalidBackupFile => serialize_variant(self, serializer, "InvalidBackupFile"),	×
302	Self::InvalidBackupDestination => serialize_variant(self, serializer, "InvalidBackupDestination"),	×
303	Self::StorageExists => serialize_variant(self, serializer, "StorageExists"),	×
304	Self::StorageAdapterNotSet(_) => serialize_variant(self, serializer, "StorageAdapterNotSet"),	×
305	Self::RecordDecrypt(_) => serialize_variant(self, serializer, "RecordDecrypt"),	×
306	Self::RecordEncrypt(_) => serialize_variant(self, serializer, "RecordEncrypt"),	×
307	Self::StorageIsEncrypted => serialize_variant(self, serializer, "StorageIsEncrypted"),	×
308	Self::CannotUseIndexIdentifier => serialize_variant(self, serializer, "CannotUseIndexIdentifier"),	×
309	#[cfg(any(feature = "ledger-nano", feature = "ledger-nano-simulator"))]
310	Self::LedgerMiscError => serialize_variant(self, serializer, "LedgerMiscError"),	×
311	#[cfg(any(feature = "ledger-nano", feature = "ledger-nano-simulator"))]
312	Self::LedgerDongleLocked => serialize_variant(self, serializer, "LedgerDongleLocked"),	×
313	#[cfg(any(feature = "ledger-nano", feature = "ledger-nano-simulator"))]
314	Self::LedgerDeniedByUser => serialize_variant(self, serializer, "LedgerDeniedByUser"),	×
315	#[cfg(any(feature = "ledger-nano", feature = "ledger-nano-simulator"))]
316	Self::LedgerDeviceNotFound => serialize_variant(self, serializer, "LedgerDeviceNotFound"),	×
317	#[cfg(any(feature = "ledger-nano", feature = "ledger-nano-simulator"))]
318	Self::LedgerEssenceTooLarge => serialize_variant(self, serializer, "LedgerEssenceTooLarge"),	×
319	Self::AccountAliasAlreadyExists => serialize_variant(self, serializer, "AccountAliasAlreadyExists"),	×
320	Self::DustError(_) => serialize_variant(self, serializer, "DustError"),	×
321	Self::InvalidOutputKind(_) => serialize_variant(self, serializer, "InvalidOutputKind"),	×
322	Self::NodesNotSynced(_) => serialize_variant(self, serializer, "NodesNotSynced"),	×
323	// #[cfg(feature = "migration")]
324	Self::LegacyClientError(_) => serialize_variant(self, serializer, "LegacyClientError"),	×
325	Self::InvalidSeed => serialize_variant(self, serializer, "InvalidSeed"),	×
326	Self::MigrationDataNotFound => serialize_variant(self, serializer, "MigrationDataNotFound"),	×
327	Self::MigrationBundleNotFound => serialize_variant(self, serializer, "MigrationBundleNotFound"),	×
328	Self::InputNotFound => serialize_variant(self, serializer, "InputNotFound"),	×
329	Self::EmptyInputList => serialize_variant(self, serializer, "EmptyInputList"),	×
330	Self::SpentAddressOnBundle => serialize_variant(self, serializer, "SpentAddressOnBundle"),	×
331	}
332	}	×
333	}

iotaledger / wallet.rs / 728433911

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous