logs(ledger/store): add context for errors in ledger

Author: kaimast

ledger/src/check_next_block.rs

@@ -17,6 +17,8 @@ use super::*;
 
 use crate::narwhal::BatchHeader;
 
+use anyhow::{Context, bail};
+
 impl<N: Network, C: ConsensusStorage<N>> Ledger<N, C> {
     /// Checks the given block is valid next block.
     pub fn check_next_block<R: CryptoRng + Rng>(&self, block: &Block<N>, rng: &mut R) -> Result<()> {
@@ -40,29 +42,6 @@ impl<N: Network, C: ConsensusStorage<N>> Ledger<N, C> {
             }
         }
 
-        // TODO (howardwu): Remove this after moving the total supply into credits.aleo.
-        {
-            // // Retrieve the latest total supply.
-            // let latest_total_supply = self.latest_total_supply_in_microcredits();
-            // // Retrieve the block reward from the first block ratification.
-            // let block_reward = match block.ratifications()[0] {
-            //     Ratify::BlockReward(block_reward) => block_reward,
-            //     _ => bail!("Block {height} is invalid - the first ratification must be a block reward"),
-            // };
-            // // Retrieve the puzzle reward from the second block ratification.
-            // let puzzle_reward = match block.ratifications()[1] {
-            //     Ratify::PuzzleReward(puzzle_reward) => puzzle_reward,
-            //     _ => bail!("Block {height} is invalid - the second ratification must be a puzzle reward"),
-            // };
-            // // Compute the next total supply in microcredits.
-            // let next_total_supply_in_microcredits =
-            //     update_total_supply(latest_total_supply, block_reward, puzzle_reward, block.transactions())?;
-            // // Ensure the total supply in microcredits is correct.
-            // if next_total_supply_in_microcredits != block.total_supply_in_microcredits() {
-            //     bail!("Invalid total supply in microcredits")
-            // }
-        }
-
         // Construct the finalize state.
         let state = FinalizeGlobalState::new::<N>(
             block.round(),
@@ -74,14 +53,17 @@ impl<N: Network, C: ConsensusStorage<N>> Ledger<N, C> {
 
         // Ensure speculation over the unconfirmed transactions is correct and ensure each transaction is well-formed and unique.
         let time_since_last_block = block.timestamp().saturating_sub(self.latest_timestamp());
-        let ratified_finalize_operations = self.vm.check_speculate(
-            state,
-            time_since_last_block,
-            block.ratifications(),
-            block.solutions(),
-            block.transactions(),
-            rng,
-        )?;
+        let ratified_finalize_operations = self
+            .vm
+            .check_speculate(
+                state,
+                time_since_last_block,
+                block.ratifications(),
+                block.solutions(),
+                block.transactions(),
+                rng,
+            )
+            .with_context(|| "Failed to speculate over unconfirmed transactions")?;
 
         // Retrieve the committee lookback.
         let committee_lookback = self
@@ -98,16 +80,18 @@ impl<N: Network, C: ConsensusStorage<N>> Ledger<N, C> {
         };
 
         // Ensure the block is correct.
-        let (expected_existing_solution_ids, expected_existing_transaction_ids) = block.verify(
-            &latest_block,
-            self.latest_state_root(),
-            &previous_committee_lookback,
-            &committee_lookback,
-            self.puzzle(),
-            self.latest_epoch_hash()?,
-            OffsetDateTime::now_utc().unix_timestamp(),
-            ratified_finalize_operations,
-        )?;
+        let (expected_existing_solution_ids, expected_existing_transaction_ids) = block
+            .verify(
+                &latest_block,
+                self.latest_state_root(),
+                &previous_committee_lookback,
+                &committee_lookback,
+                self.puzzle(),
+                self.latest_epoch_hash()?,
+                OffsetDateTime::now_utc().unix_timestamp(),
+                ratified_finalize_operations,
+            )
+            .with_context(|| "Failed to verify block")?;
 
         // Ensure that the provers are within their stake bounds.
         if let Some(solutions) = block.solutions().deref() {
@@ -130,7 +114,7 @@ impl<N: Network, C: ConsensusStorage<N>> Ledger<N, C> {
         // Determine if the block subdag is correctly constructed and is not a combination of multiple subdags.
         self.check_block_subdag_atomicity(block)?;
 
-        // Ensure that all leafs of the subdag point to valid batches in other subdags/blocks.
+        // Ensure that all leaves of the subdag point to valid batches in other subdags/blocks.
         self.check_block_subdag_leaves(block)?;
 
         // Ensure that each existing solution ID from the block exists in the ledger.
@@ -204,8 +188,9 @@ impl<N: Network, C: ConsensusStorage<N>> Ledger<N, C> {
         cfg_iter!(subdag).try_for_each(|(round, certificates)| {
             // Retrieve the committee lookback for the round.
             let committee_lookback = self
-                .get_committee_lookback_for_round(*round)?
-                .ok_or_else(|| anyhow!("No committee lookback found for round {round}"))?;
+                .get_committee_lookback_for_round(*round)
+                .with_context(|| format!("Failed to get committee lookback for round {round}"))?
+                .ok_or_else(|| anyhow!("No committee lookback for round {round}"))?;
 
             // Check that each certificate for this round has met quorum requirements.
             // Note that we do not need to check the quorum requirement for the previous certificates
@@ -273,7 +258,7 @@ impl<N: Network, C: ConsensusStorage<N>> Ledger<N, C> {
             // Compute the leader for the commit round.
             let computed_leader = previous_committee_lookback
                 .get_leader(round)
-                .map_err(|e| anyhow!("Failed to compute leader for round {round}: {e}"))?;
+                .with_context(|| format!("Failed to compute leader for round {round}"))?;
 
             // Retrieve the previous leader certificates.
             let previous_certificate = match subdag.get(&round).and_then(|certificates| {

ledger/store/src/helpers/memory/internal/nested_map.rs

@@ -18,6 +18,7 @@
 use crate::helpers::{NestedMap, NestedMapRead};
 use console::network::prelude::*;
 
+use anyhow::Context;
 use core::hash::Hash;
 #[cfg(feature = "locktick")]
 use locktick::parking_lot::{Mutex, RwLock};
@@ -282,9 +283,9 @@ impl<
     ///
     fn contains_key_confirmed(&self, map: &M, key: &K) -> Result<bool> {
         // Serialize 'm'.
-        let m = bincode::serialize(map)?;
+        let m = bincode::serialize(map).with_context(|| "Failed to serialize map")?;
         // Concatenate 'm' and 'k' with a 0-byte separator.
-        let mk = to_map_key(&m, &bincode::serialize(key)?);
+        let mk = to_map_key(&m, &bincode::serialize(key).with_context(|| "Failed to serialize map key")?);
         // Return whether the concatenated key exists in the map.
         Ok(self.map_inner.read().contains_key(&mk))
     }

ledger/store/src/helpers/rocksdb/internal/nested_map.rs

@@ -19,6 +19,7 @@ use super::*;
 use crate::helpers::{NestedMap, NestedMapRead};
 use console::prelude::{FromBytes, anyhow, cfg_into_iter};
 
+use anyhow::Context;
 use core::{fmt, fmt::Debug, hash::Hash, mem};
 use std::{borrow::Cow, sync::atomic::Ordering};
 use tracing::error;
@@ -59,10 +60,11 @@ impl<M: Serialize + DeserializeOwned, K: Serialize + DeserializeOwned, V: Serial
     fn create_prefixed_map(&self, map: &M) -> Result<Vec<u8>> {
         let mut raw_map = self.context.clone();
 
-        let map_size: u32 = bincode::serialized_size(&map)?.try_into()?;
+        let map_size: u32 =
+            bincode::serialized_size(&map).with_context(|| "Failed to get size of serialize map")?.try_into()?;
         raw_map.extend_from_slice(&map_size.to_le_bytes());
 
-        bincode::serialize_into(&mut raw_map, map)?;
+        bincode::serialize_into(&mut raw_map, map).with_context(|| "Failed to serialize map")?;
         Ok(raw_map)
     }
 
@@ -463,14 +465,15 @@ impl<
         }
 
         // Possibly deserialize the entries in parallel.
-        Ok(cfg_into_iter!(entries)
+        cfg_into_iter!(entries)
             .map(|(k, v)| {
                 let k = bincode::deserialize::<K>(&k);
                 let v = bincode::deserialize::<V>(&v);
 
                 k.and_then(|k| v.map(|v| (k, v)))
             })
-            .collect::<Result<_, bincode::Error>>()?)
+            .collect::<Result<_, bincode::Error>>()
+            .with_context(|| "Failed to deserialize map entries")
     }
 
     ///
@@ -520,7 +523,10 @@ impl<
     ///
     fn get_value_confirmed(&'a self, map: &M, key: &K) -> Result<Option<Cow<'a, V>>> {
         match self.get_map_key_raw(map, key) {
-            Ok(Some(bytes)) => Ok(Some(Cow::Owned(bincode::deserialize(&bytes)?))),
+            Ok(Some(bytes)) => {
+                let v = bincode::deserialize(&bytes).with_context(|| "Failed to deserialize value")?;
+                Ok(Some(Cow::Owned(v)))
+            }
             Ok(None) => Ok(None),
             Err(e) => Err(e),
         }

utilities/src/errors.rs

@@ -89,7 +89,7 @@ macro_rules! ensure_equals {
     };
 }
 
-/// A trait to provide a way to turn an `anyhow::Result` into a log message.
+/// A trait that allows turning  an Error into a log message.
 pub trait LoggableError {
     /// Log the error with the given context and log level `ERROR`.
     fn log_error<S: Send + Sync + Display + 'static>(self, context: S);