Apply review comments

Author: stanislav-tkach

rust/c509-certificate/src/attributes/mod.rs

@@ -62,11 +62,9 @@ impl Encode<()> for Attributes {
             ));
         }
         // The attribute type should be included in array too
-        let Some(len) = (self.0.len() as u64).checked_mul(2) else {
-            return Err(minicbor::encode::Error::message(
-                "Attributes length overflow",
-            ));
-        };
+        let len = (self.0.len() as u64)
+            .checked_mul(2)
+            .ok_or_else(|| minicbor::encode::Error::message("Attributes length overflow"))?;
         encode_array_len(e, "Attributes", len)?;
         for attribute in &self.0 {
             attribute.encode(e, ctx)?;

rust/c509-certificate/src/general_names/mod.rs

@@ -59,11 +59,9 @@ impl Encode<()> for GeneralNames {
             ));
         }
         // The general name type should be included in array too
-        let Some(len) = (self.0.len() as u64).checked_mul(2) else {
-            return Err(minicbor::encode::Error::message(
-                "General Names length overflow",
-            ));
-        };
+        let len = (self.0.len() as u64)
+            .checked_mul(2)
+            .ok_or_else(|| minicbor::encode::Error::message("General Names length overflow"))?;
         encode_array_len(e, "General Names", len)?;
         for gn in &self.0 {
             gn.encode(e, ctx)?;

rust/c509-certificate/src/name/mod.rs

@@ -106,23 +106,19 @@ impl Encode<()> for NameValue {
 
                         encode_cn_value(e, cn_value)?;
                     } else {
-                        let Some(len) = (attrs.len() as u64).checked_mul(2) else {
-                            return Err(minicbor::encode::Error::message(
-                                "Attribute length overflow",
-                            ));
-                        };
+                        let len = (attrs.len() as u64).checked_mul(2).ok_or_else(|| {
+                            minicbor::encode::Error::message("Attribute length overflow")
+                        })?;
                         encode_array_len(e, "Attributes", len)?;
                         for attribute in attrs {
                             attribute.encode(e, ctx)?;
                         }
                     }
                 } else {
                     // If is okay if the attributes is empty
-                    let Some(len) = (attrs.len() as u64).checked_mul(2) else {
-                        return Err(minicbor::encode::Error::message(
-                            "Attribute length overflow",
-                        ));
-                    };
+                    let len = (attrs.len() as u64).checked_mul(2).ok_or_else(|| {
+                        minicbor::encode::Error::message("Attribute length overflow")
+                    })?;
                     encode_array_len(e, "Attributes", len)?;
                     for attribute in attrs {
                         attribute.encode(e, ctx)?;

rust/cardano-chain-follower/examples/follow_chains.rs

@@ -97,8 +97,8 @@ async fn start_sync_for(network: &Network, matches: ArgMatches) -> Result<(), Bo
 
     if let Some(chunk_size) = matches.get_one::<u16>("mithril-sync-chunk-size") {
         let chunk_size = (*chunk_size as usize)
-            .checked_mul(1024)
-            .and_then(|v| v.checked_mul(1024))
+            // 1024 * 1024
+            .checked_mul(1_048_576)
             .ok_or("Chunk size overflow")?;
         dl_config = dl_config.with_chunk_size(chunk_size);
     }

rust/cardano-chain-follower/src/chain_sync.rs

@@ -193,6 +193,7 @@ async fn process_rollback(
     let head_slot = previous_point.slot_or_default();
     debug!("Head slot: {head_slot:?}");
     debug!("Rollback slot: {rollback_slot:?}");
+    // It is ok because slot implement saturating subtraction.
     #[allow(clippy::arithmetic_side_effects)]
     let slot_rollback_size = head_slot - rollback_slot;
 

rust/cardano-chain-follower/src/mithril_snapshot_iterator.rs

@@ -56,6 +56,7 @@ pub(crate) fn probe_point(point: &Point, distance: u64) -> Point {
     const STEP_BACK_ORIGIN: u64 = 0;
     // Now that we have the tip, step back about 4 block intervals from tip, and do a fuzzy
     // iteration to find the exact two blocks at the end of the immutable chain.
+    // It is ok because slot implement saturating subtraction.
     #[allow(clippy::arithmetic_side_effects)]
     let step_back_search = point.slot_or_default() - distance.into();