The big error refactor (#2046)

* The big error refactor * better display derives * no_std * missed * fix the merge 😤 * simplify bindings error handling * re-enable high-level examples * more disabled examples * fix send_all * missed * fill in last display derives * okay really the last one this time * add common conversions * improve signature error * tiny improvement * remove another id error * review * Remove some more * Fix test * review * improve addresses verification * wrap hrp error * fmt --------- Co-authored-by: Thibault Martinez <[email protected]>
iotaledger · Feb 29, 2024 · f459c48 · f459c48
1 parent 7fd9c9b
commit f459c48
Show file tree

Hide file tree

Showing 222 changed files with 2,219 additions and 2,210 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/bindings/core/src/error.rs b/bindings/core/src/error.rs
@@ -1,6 +1,10 @@
 // Copyright 2023 IOTA Stiftung
 // SPDX-License-Identifier: Apache-2.0
 
+use iota_sdk::types::block::{
+    mana::ManaError, output::OutputError, payload::PayloadError, semantic::TransactionFailureReason,
+    signature::SignatureError, BlockError,
+};
 use packable::error::UnexpectedEOF;
 use serde::{Serialize, Serializer};
 
@@ -14,7 +18,22 @@ pub type Result<T> = std::result::Result<T, Error>;
 pub enum Error {
     /// Block errors.
     #[error("{0}")]
-    Block(#[from] iota_sdk::types::block::Error),
+    Block(#[from] BlockError),
+    /// Output errors.
+    #[error("{0}")]
+    Output(#[from] OutputError),
+    /// Payload errors.
+    #[error("{0}")]
+    Payload(#[from] PayloadError),
+    /// Signature errors.
+    #[error("{0}")]
+    Signature(#[from] SignatureError),
+    /// Mana errors.
+    #[error("{0}")]
+    Mana(#[from] ManaError),
+    /// Semantic errors.
+    #[error("{0}")]
+    TransactionSemantic(#[from] TransactionFailureReason),
     /// Client errors.
     #[error("{0}")]
     Client(#[from] iota_sdk::client::Error),
@@ -29,7 +48,7 @@ pub enum Error {
     SerdeJson(#[from] serde_json::error::Error),
     /// Unpack errors.
     #[error("{0}")]
-    Unpack(#[from] packable::error::UnpackError<iota_sdk::types::block::Error, UnexpectedEOF>),
+    Unpack(#[from] packable::error::UnpackError<BlockError, UnexpectedEOF>),
 }
 
 #[cfg(feature = "stronghold")]

diff --git a/bindings/core/src/method_handler/utils.rs b/bindings/core/src/method_handler/utils.rs
@@ -11,7 +11,8 @@ use iota_sdk::{
             output::{AccountId, FoundryId, MinimumOutputAmount, NftId, Output, OutputId, TokenId},
             payload::{signed_transaction::Transaction, SignedTransactionPayload},
             semantic::SemanticValidationContext,
-            Block, Error,
+            signature::SignatureError,
+            Block,
         },
         TryFromDto,
     },
@@ -91,7 +92,7 @@ pub(crate) fn call_utils_method_internal(method: UtilsMethod) -> Result<Response
         }
         UtilsMethod::VerifyEd25519Signature { signature, message } => {
             let message: Vec<u8> = prefix_hex::decode(message)?;
-            Response::Bool(signature.try_verify(&message).map_err(Error::from)?)
+            Response::Bool(signature.try_verify(&message).map_err(iota_sdk::client::Error::from)?)
         }
         UtilsMethod::VerifySecp256k1EcdsaSignature {
             public_key,
@@ -100,9 +101,11 @@ pub(crate) fn call_utils_method_internal(method: UtilsMethod) -> Result<Response
         } => {
             use crypto::signatures::secp256k1_ecdsa;
             let public_key = prefix_hex::decode(public_key)?;
-            let public_key = secp256k1_ecdsa::PublicKey::try_from_bytes(&public_key).map_err(Error::from)?;
+            let public_key = secp256k1_ecdsa::PublicKey::try_from_bytes(&public_key)
+                .map_err(SignatureError::InvalidPublicKeyBytes)?;
             let signature = prefix_hex::decode(signature)?;
-            let signature = secp256k1_ecdsa::Signature::try_from_bytes(&signature).map_err(Error::from)?;
+            let signature = secp256k1_ecdsa::Signature::try_from_bytes(&signature)
+                .map_err(SignatureError::InvalidSignatureBytes)?;
             let message: Vec<u8> = prefix_hex::decode(message)?;
             Response::Bool(public_key.verify_keccak256(&signature, &message))
         }
@@ -129,8 +132,7 @@ pub(crate) fn call_utils_method_internal(method: UtilsMethod) -> Result<Response
                 mana_rewards,
                 protocol_parameters,
             );
-
-            context.validate().map_err(Error::from)?;
+            context.validate()?;
 
             Response::Ok
         }

diff --git a/bindings/core/tests/utils.rs b/bindings/core/tests/utils.rs
@@ -2,11 +2,11 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use iota_sdk::types::block::address::{Bech32Address, Hrp};
-use iota_sdk_bindings_core::{call_utils_method, Response, Result, UtilsMethod};
+use iota_sdk_bindings_core::{call_utils_method, Response, UtilsMethod};
 use pretty_assertions::assert_eq;
 
 #[tokio::test]
-async fn utils() -> Result<()> {
+async fn utils() -> Result<(), Box<dyn std::error::Error>> {
     let response = call_utils_method(UtilsMethod::GenerateMnemonic);
     match response {
         Response::GeneratedMnemonic(mnemonic) => println!("{:?}", serde_json::to_string(&mnemonic)?),

diff --git a/bindings/python/src/error.rs b/bindings/python/src/error.rs
@@ -37,14 +37,6 @@ impl From<std::io::Error> for Error {
     }
 }
 
-impl From<iota_sdk_bindings_core::iota_sdk::types::block::Error> for Error {
-    fn from(err: iota_sdk_bindings_core::iota_sdk::types::block::Error) -> Self {
-        Self {
-            error: PyErr::new::<exceptions::PyValueError, _>(err.to_string()),
-        }
-    }
-}
-
 impl From<iota_sdk_bindings_core::Error> for Error {
     fn from(err: iota_sdk_bindings_core::Error) -> Self {
         Self {

diff --git a/cli/Cargo.toml b/cli/Cargo.toml
@@ -41,6 +41,7 @@ dialoguer = { version = "0.11.0", default-features = false, features = [
     "password",
 ] }
 dotenvy = { version = "0.15.7", default-features = false }
+eyre = { version = "0.6.12", default-features = false }
 fern-logger = { version = "0.5.0", default-features = false }
 log = { version = "0.4.20", default-features = false }
 prefix-hex = { version = "0.7.1", default-features = false, features = ["std"] }

diff --git a/cli/src/cli.rs b/cli/src/cli.rs
@@ -4,6 +4,7 @@
 use std::{path::Path, str::FromStr};
 
 use clap::{builder::BoolishValueParser, Args, CommandFactory, Parser, Subcommand};
+use eyre::{bail, Error};
 use iota_sdk::{
     client::{
         constants::SHIMMER_COIN_TYPE,
@@ -18,7 +19,6 @@ use iota_sdk::{
 use log::LevelFilter;
 
 use crate::{
-    error::Error,
     helper::{
         check_file_exists, enter_or_generate_mnemonic, generate_mnemonic, get_alias, get_decision, get_password,
         import_mnemonic, select_secret_manager, SecretManagerChoice,
@@ -206,21 +206,15 @@ pub async fn new_wallet(cli: Cli) -> Result<Option<Wallet>, Error> {
                             return Ok(None);
                         }
                         LinkedSecretManager::Stronghold { snapshot_path, .. } => {
-                            return Err(Error::Miscellaneous(format!(
-                                "Stronghold snapshot does not exist at '{}'",
-                                snapshot_path.display()
-                            )));
+                            bail!("Stronghold snapshot does not exist at '{}'", snapshot_path.display());
                         }
                         _ => {
                             println_log_info!("only Stronghold backup supported");
                             return Ok(None);
                         }
                     }
                 } else {
-                    return Err(Error::Miscellaneous(format!(
-                        "wallet db does not exist at '{}'",
-                        storage_path.display()
-                    )));
+                    bail!("wallet db does not exist at '{}'", storage_path.display());
                 }
             }
             CliCommand::ChangePassword => {
@@ -234,29 +228,23 @@ pub async fn new_wallet(cli: Cli) -> Result<Option<Wallet>, Error> {
                             Some(wallet)
                         }
                         LinkedSecretManager::Stronghold { snapshot_path, .. } => {
-                            return Err(Error::Miscellaneous(format!(
-                                "Stronghold snapshot does not exist at '{}'",
-                                snapshot_path.display()
-                            )));
+                            bail!("Stronghold snapshot does not exist at '{}'", snapshot_path.display());
                         }
                         _ => {
                             println_log_info!("only Stronghold password change supported");
                             return Ok(None);
                         }
                     }
                 } else {
-                    return Err(Error::Miscellaneous(format!(
-                        "wallet db does not exist at '{}'",
-                        storage_path.display()
-                    )));
+                    bail!("wallet db does not exist at '{}'", storage_path.display());
                 }
             }
             CliCommand::Init(init_parameters) => {
                 if wallet_and_secret_manager.is_some() {
-                    return Err(Error::Miscellaneous(format!(
+                    bail!(
                         "cannot initialize: wallet db at '{}' already exists",
                         storage_path.display()
-                    )));
+                    );
                 }
                 let secret_manager = create_secret_manager(&init_parameters).await?;
                 let secret_manager_variant = secret_manager.to_string();
@@ -281,10 +269,7 @@ pub async fn new_wallet(cli: Cli) -> Result<Option<Wallet>, Error> {
                     crate::wallet_cli::node_info_command(&wallet).await?;
                     return Ok(None);
                 } else {
-                    return Err(Error::Miscellaneous(format!(
-                        "wallet db does not exist at '{}'",
-                        storage_path.display()
-                    )));
+                    bail!("wallet db does not exist at '{}'", storage_path.display());
                 }
             }
             CliCommand::Restore { backup_path } => {
@@ -322,21 +307,15 @@ pub async fn new_wallet(cli: Cli) -> Result<Option<Wallet>, Error> {
                     set_node_url_command(&wallet, url).await?;
                     Some(wallet)
                 } else {
-                    return Err(Error::Miscellaneous(format!(
-                        "wallet db does not exist at '{}'",
-                        storage_path.display()
-                    )));
+                    bail!("wallet db does not exist at '{}'", storage_path.display());
                 }
             }
             CliCommand::Sync => {
                 if let Some((wallet, _)) = wallet_and_secret_manager {
                     sync_command(&wallet).await?;
                     Some(wallet)
                 } else {
-                    return Err(Error::Miscellaneous(format!(
-                        "wallet db does not exist at '{}'",
-                        storage_path.display()
-                    )));
+                    bail!("wallet db does not exist at '{}'", storage_path.display());
                 }
             }
         }
@@ -540,10 +519,7 @@ async fn create_secret_manager(init_params: &InitParameters) -> Result<SecretMan
             let snapshot_path = Path::new(&init_params.stronghold_snapshot_path);
 
             if snapshot_path.exists() {
-                return Err(Error::Miscellaneous(format!(
-                    "cannot initialize: {} already exists",
-                    snapshot_path.display()
-                )));
+                bail!("cannot initialize: {} already exists", snapshot_path.display());
             }
 
             let password = get_password("Stronghold password", true)?;

diff --git a/cli/src/error.rs b/cli/src/error.rs