refactor: cleanup usages of the anyhow! macro

- Remove redundant `.map_err(|err| anyhow!(err))` when used before a
  `with_context` as it does the error conversion.
- Remove redundant `format!` in `anyhow!(format!(..))` as the anyhow
  macro already support formatting.
- Prefer usage of `with_context` instead of `ok_or(anyhow!(..))` or
  `ok_or_else(|| anyhow!(..))` when working with options, so the
  error conversion is gracefully done by the anyhow crate instead of
  our code, and this often results in leaner code.
- Simplify `anyhow::anyhow!(e).context(..)` to `e.context(..)` when
  the error is already an anyhow error.
- When using the macro is unavoidable and it print the error in its
  message, add another context layer by wrapping the error first then
  adding the previous message as context.
  e.g: from `anyhow!("Error context: {e}")` to
  `anyhow!(e.to_string()).context("Error context")`.
- Add a anyhow context to some errors.

Note: Some macro usage are unavoidable, e.g when the inner error can't
be implicitly converted to `anyhow::Error`.

Author: Alenar

examples/client-cardano-database-v2/src/main.rs

@@ -75,16 +75,20 @@ async fn main() -> MithrilResult<()> {
 
     let latest_hash = cardano_database_snapshots
         .first()
-        .ok_or(anyhow!(
-            "No Cardano database snapshot could be listed from aggregator: '{}'",
-            args.aggregator_endpoint
-        ))?
+        .with_context(|| {
+            format!(
+                "No Cardano database snapshot could be listed from aggregator: '{}'",
+                args.aggregator_endpoint
+            )
+        })?
         .hash
         .as_ref();
 
-    let cardano_database_snapshot = client.cardano_database_v2().get(latest_hash).await?.ok_or(
-        anyhow!("A Cardano database should exist for hash '{latest_hash}'"),
-    )?;
+    let cardano_database_snapshot = client
+        .cardano_database_v2()
+        .get(latest_hash)
+        .await?
+        .with_context(|| format!("A Cardano database should exist for hash '{latest_hash}'"))?;
 
     let unpacked_dir = work_dir.join("unpack");
     std::fs::create_dir(&unpacked_dir).unwrap();

examples/client-cardano-database/src/main.rs

@@ -74,18 +74,20 @@ async fn main() -> MithrilResult<()> {
 
     let last_digest = snapshots
         .first()
-        .ok_or(anyhow!(
-            "No snapshots could be listed from aggregator: '{}'",
-            args.aggregator_endpoint
-        ))?
+        .with_context(|| {
+            format!(
+                "No snapshots could be listed from aggregator: '{}'",
+                args.aggregator_endpoint
+            )
+        })?
         .digest
         .as_ref();
 
     let snapshot = client
         .cardano_database()
         .get(last_digest)
         .await?
-        .ok_or(anyhow!("A snapshot should exist for hash '{last_digest}'"))?;
+        .with_context(|| format!("A snapshot should exist for hash '{last_digest}'"))?;
 
     let unpacked_dir = work_dir.join("unpack");
     std::fs::create_dir(&unpacked_dir).unwrap();

examples/client-cardano-stake-distribution/src/main.rs

@@ -2,7 +2,7 @@
 //!
 //! In this example, the client interacts by default with a real aggregator (`release-preprod`) to get the data.
 
-use anyhow::anyhow;
+use anyhow::Context;
 use clap::Parser;
 use slog::info;
 use std::{str::FromStr, sync::Arc};
@@ -57,19 +57,21 @@ async fn main() -> MithrilResult<()> {
 
     let last_epoch = cardano_stake_distributions
         .first()
-        .ok_or(anyhow!(
-            "No Cardano stake distributions could be listed from aggregator: '{}'",
-            args.aggregator_endpoint
-        ))?
+        .with_context(|| {
+            format!(
+                "No Cardano stake distributions could be listed from aggregator: '{}'",
+                args.aggregator_endpoint
+            )
+        })?
         .epoch;
 
     let cardano_stake_distribution = client
         .cardano_stake_distribution()
         .get_by_epoch(last_epoch)
         .await?
-        .ok_or(anyhow!(
-            "A Cardano stake distribution should exist for hash '{last_epoch}'"
-        ))?;
+        .with_context(|| {
+            format!("A Cardano stake distribution should exist for hash '{last_epoch}'")
+        })?;
     info!(
         logger,
         "Fetched details of last Cardano stake distribution:\n{cardano_stake_distribution:#?}",

examples/client-mithril-stake-distribution/src/main.rs

@@ -2,7 +2,7 @@
 //!
 //! In this example, the client interacts by default with a real aggregator (`release-preprod`) to get the data.
 
-use anyhow::anyhow;
+use anyhow::Context;
 use clap::Parser;
 use slog::info;
 use std::{str::FromStr, sync::Arc};
@@ -57,20 +57,22 @@ async fn main() -> MithrilResult<()> {
 
     let last_hash = mithril_stake_distributions
         .first()
-        .ok_or(anyhow!(
-            "No Mithril stake distributions could be listed from aggregator: '{}'",
-            args.aggregator_endpoint
-        ))?
+        .with_context(|| {
+            format!(
+                "No Mithril stake distributions could be listed from aggregator: '{}'",
+                args.aggregator_endpoint
+            )
+        })?
         .hash
         .as_ref();
 
     let mithril_stake_distribution = client
         .mithril_stake_distribution()
         .get(last_hash)
         .await?
-        .ok_or(anyhow!(
-            "A Mithril stake distribution should exist for hash '{last_hash}'"
-        ))?;
+        .with_context(|| {
+            format!("A Mithril stake distribution should exist for hash '{last_hash}'")
+        })?;
     info!(
         logger,
         "Fetched details of last Mithril stake distribution:\n{mithril_stake_distribution:#?}",

internal/cardano-node/mithril-cardano-node-chain/src/chain_observer/pallas_observer.rs

@@ -66,7 +66,6 @@ impl PallasChainObserver {
     async fn get_client(&self) -> StdResult<NodeClient> {
         self.new_client()
             .await
-            .map_err(|err| anyhow!(err))
             .with_context(|| "PallasChainObserver failed to create new client")
     }
 
@@ -75,12 +74,10 @@ impl PallasChainObserver {
         statequery
             .acquire(None)
             .await
-            .map_err(|err| anyhow!(err))
             .with_context(|| "PallasChainObserver failed to acquire statequery")?;
 
         let era = queries_v16::get_current_era(statequery)
             .await
-            .map_err(|err| anyhow!(err))
             .with_context(|| "PallasChainObserver failed to get current era")?;
 
         Ok(era)
@@ -91,17 +88,14 @@ impl PallasChainObserver {
         statequery
             .acquire(None)
             .await
-            .map_err(|err| anyhow!(err))
             .with_context(|| "PallasChainObserver failed to acquire statequery")?;
 
         let era = queries_v16::get_current_era(statequery)
             .await
-            .map_err(|err| anyhow!(err))
             .with_context(|| "PallasChainObserver failed to get current era")?;
 
         let epoch = queries_v16::get_block_epoch_number(statequery, era)
             .await
-            .map_err(|err| anyhow!(err))
             .with_context(|| "PallasChainObserver failed to get block epoch number")?;
 
         Ok(epoch)
@@ -129,7 +123,6 @@ impl PallasChainObserver {
     fn serialize_datum(&self, utxo: &PostAlonsoTransactionOutput) -> StdResult<TxDatum> {
         let datum = self.inspect_datum(utxo)?;
         let serialized = serde_json::to_string(&datum.to_json())
-            .map_err(|err| anyhow!(err))
             .with_context(|| "PallasChainObserver failed to serialize datum")?;
 
         Ok(TxDatum(serialized))
@@ -170,23 +163,19 @@ impl PallasChainObserver {
         statequery
             .acquire(None)
             .await
-            .map_err(|err| anyhow!(err))
             .with_context(|| "PallasChainObserver failed to acquire statequery")?;
 
         let era = queries_v16::get_current_era(statequery)
             .await
-            .map_err(|err| anyhow!(err))
             .with_context(|| "PallasChainObserver failed to get current era")?;
 
         let addr: Address = Address::from_bech32(address)
-            .map_err(|err| anyhow!(err))
             .with_context(|| "PallasChainObserver failed to parse address")?;
 
         let addr: Addr = addr.to_vec().into();
         let addrs: Addrs = vec![addr];
         let utxo = queries_v16::get_utxo_by_address(statequery, era, addrs)
             .await
-            .map_err(|err| anyhow!(err))
             .with_context(|| "PallasChainObserver failed to get utxo")?;
 
         Ok(utxo)
@@ -200,17 +189,14 @@ impl PallasChainObserver {
         statequery
             .acquire(None)
             .await
-            .map_err(|err| anyhow!(err))
             .with_context(|| "PallasChainObserver failed to acquire statequery")?;
 
         let era = queries_v16::get_current_era(statequery)
             .await
-            .map_err(|err| anyhow!(err))
             .with_context(|| "PallasChainObserver failed to get current era")?;
 
         let state_snapshot = queries_v16::get_stake_snapshots(statequery, era, BTreeSet::new())
             .await
-            .map_err(|err| anyhow!(err))
             .with_context(|| "PallasChainObserver failed to get stake snapshot")?;
 
         Ok(state_snapshot)
@@ -219,7 +205,6 @@ impl PallasChainObserver {
     /// Returns the stake pool hash from the given bytestring.
     fn get_stake_pool_hash(&self, key: &Bytes) -> Result<String, ChainObserverError> {
         let pool_id_bech32 = encode_bech32("pool", key)
-            .map_err(|err| anyhow!(err))
             .with_context(|| "PallasChainObserver failed to encode stake pool hash")?;
         Ok(pool_id_bech32)
     }
@@ -282,15 +267,13 @@ impl PallasChainObserver {
 
         let current_kes_period = chain_point.slot_or_default() / slots_per_kes_period;
         Ok(u32::try_from(current_kes_period)
-            .map_err(|err| anyhow!(err))
             .with_context(|| "PallasChainObserver failed to convert kes period")?)
     }
 
     /// Fetches the current chain point using the provided `statequery` client.
     async fn do_get_chain_point_state_query(&self, statequery: &mut Client) -> StdResult<Point> {
         let chain_point = queries_v16::get_chain_point(statequery)
             .await
-            .map_err(|err| anyhow!(err))
             .with_context(|| "PallasChainObserver failed to get chain point")?;
 
         Ok(chain_point)
@@ -300,7 +283,6 @@ impl PallasChainObserver {
     async fn do_get_chain_block_no(&self, statequery: &mut Client) -> StdResult<ChainBlockNumber> {
         let chain_block_number = queries_v16::get_chain_block_no(statequery)
             .await
-            .map_err(|err| anyhow!(err))
             .with_context(|| "PallasChainObserver failed to get chain block number")?;
 
         Ok(chain_block_number)
@@ -310,7 +292,6 @@ impl PallasChainObserver {
     async fn do_get_current_era_state_query(&self, statequery: &mut Client) -> StdResult<u16> {
         let era = queries_v16::get_current_era(statequery)
             .await
-            .map_err(|err| anyhow!(err))
             .with_context(|| "PallasChainObserver failed to get current era")?;
 
         Ok(era)
@@ -324,7 +305,6 @@ impl PallasChainObserver {
         let era = self.do_get_current_era_state_query(statequery).await?;
         let genesis_config = queries_v16::get_genesis_config(statequery, era)
             .await
-            .map_err(|err| anyhow!(err))
             .with_context(|| "PallasChainObserver failed to get genesis config")?;
 
         Ok(genesis_config)
@@ -335,7 +315,6 @@ impl PallasChainObserver {
         statequery
             .acquire(None)
             .await
-            .map_err(|err| anyhow!(err))
             .with_context(|| "PallasChainObserver failed to acquire statequery")?;
 
         let chain_point = self.do_get_chain_point_state_query(statequery).await?;
@@ -365,7 +344,6 @@ impl PallasChainObserver {
         statequery
             .acquire(None)
             .await
-            .map_err(|err| anyhow!(err))
             .with_context(|| "PallasChainObserver failed to acquire statequery")?;
 
         let chain_point = self.do_get_chain_point_state_query(statequery).await?;
@@ -389,13 +367,11 @@ impl PallasChainObserver {
         statequery
             .send_release()
             .await
-            .map_err(|err| anyhow!(err))
             .with_context(|| "PallasChainObserver send release failed")?;
 
         statequery
             .send_done()
             .await
-            .map_err(|err| anyhow!(err))
             .with_context(|| "PallasChainObserver send done failed")?;
 
         Ok(())
@@ -407,7 +383,6 @@ impl PallasChainObserver {
             .chainsync()
             .send_done()
             .await
-            .map_err(|err| anyhow!(err))
             .with_context(|| "PallasChainObserver chainsync send done failed")?;
         Ok(())
     }

internal/cardano-node/mithril-cardano-node-chain/src/chain_reader/pallas_chain_reader.rs

@@ -1,6 +1,6 @@
 use std::path::{Path, PathBuf};
 
-use anyhow::{Context, anyhow};
+use anyhow::Context;
 use async_trait::async_trait;
 use pallas_network::{
     facades::NodeClient,
@@ -41,7 +41,6 @@ impl PallasChainReader {
         let magic = self.network.magic_id();
         NodeClient::connect(&self.socket, magic)
             .await
-            .map_err(|err| anyhow!(err))
             .with_context(|| "PallasChainReader failed to create a new client")
     }
 

internal/cardano-node/mithril-cardano-node-chain/src/entities/datum.rs

@@ -1,4 +1,4 @@
-use anyhow::{Context, anyhow};
+use anyhow::Context;
 use pallas_codec::minicbor::{Decode, Decoder, decode};
 use pallas_primitives::{ToCanonicalJson, alonzo::PlutusData};
 use serde::{Deserialize, Serialize};
@@ -31,9 +31,7 @@ pub fn try_inspect<R>(inner: Vec<u8>) -> StdResult<R>
 where
     for<'b> R: Decode<'b, ()>,
 {
-    decode(&inner)
-        .map_err(|e| anyhow!(e))
-        .with_context(|| format!("failed to decode datum: {}", hex::encode(&inner)))
+    decode(&inner).with_context(|| format!("failed to decode datum: {}", hex::encode(&inner)))
 }
 
 /// [Datums] represents a list of [TxDatum].
@@ -60,25 +58,24 @@ impl TxDatum {
     pub fn get_fields_by_type(&self, type_name: &TxDatumFieldTypeName) -> StdResult<Vec<Value>> {
         let tx_datum_raw = &self.0;
         // 1- Parse the Utxo raw data to a hashmap
-        let v: HashMap<String, Value> = serde_json::from_str(tx_datum_raw).map_err(|e| {
-            TxDatumError::InvalidContent(anyhow!(e).context("tx datum was = '{tx_datum_raw}'"))
-        })?;
+        let v: HashMap<String, Value> = serde_json::from_str(tx_datum_raw)
+            .with_context(|| format!("tx datum was = '{tx_datum_raw}'"))
+            .map_err(TxDatumError::InvalidContent)?;
+
         // 2- Convert the 'fields' entry to a vec of json objects
-        let fields = v.get("fields").ok_or_else(|| {
-            TxDatumError::InvalidContent(
-                anyhow!("Error: missing 'fields' entry, tx datum was = '{tx_datum_raw}'"),
-            )
-        })?.as_array().ok_or_else(|| {
-            TxDatumError::InvalidContent(
-                anyhow!("Error: 'fields' entry is not correctly structured, tx datum was = '{tx_datum_raw}'"),
-            )
-        })?;
+        let fields = v.get("fields")
+            .with_context(|| format!("Error: missing 'fields' entry, tx datum was = '{tx_datum_raw}'"))
+            .map_err(TxDatumError::InvalidContent)?
+            .as_array()
+            .with_context(|| format!("Error: 'fields' entry is not correctly structured, tx datum was = '{tx_datum_raw}'"))
+            .map_err(TxDatumError::InvalidContent)?;
+
         // 3- Filter the vec (keep the ones that match the given type), and retrieve the nth entry of this filtered vec
         Ok(fields
             .iter()
             .filter(|&field| field.get(type_name.to_string()).is_some())
             .map(|field| field.get(type_name.to_string()).unwrap().to_owned())
-            .collect::<_>())
+            .collect())
     }
 
     /// Retrieves the nth field of the datum with given type
@@ -90,9 +87,8 @@ impl TxDatum {
         Ok(self
             .get_fields_by_type(type_name)?
             .get(index)
-            .ok_or_else(|| {
-                TxDatumError::InvalidContent(anyhow!("Error: missing field at index {index}"))
-            })?
+            .with_context(|| format!("Error: missing field at index {index}"))
+            .map_err(TxDatumError::InvalidContent)?
             .to_owned())
     }
 }

internal/cardano-node/mithril-cardano-node-internal-database/src/immutable_file_observer.rs

@@ -48,7 +48,6 @@ impl ImmutableFileSystemObserver {
 impl ImmutableFileObserver for ImmutableFileSystemObserver {
     async fn get_last_immutable_number(&self) -> StdResult<u64> {
         let immutable_file_number = ImmutableFile::list_completed_in_dir(&self.db_path)
-            .map_err(|e| anyhow!(e))
             .with_context(|| "Immutable File System Observer can not list all immutable files")?
             .into_iter()
             .next_back()