fix(cast/bin) ; correcting the offset of Storage

crates/cast/bin/cmd/storage.rs

@@ -22,7 +22,7 @@ use foundry_config::{
     impl_figment_convert_cast, Config,
 };
 use foundry_utils::types::{ToAlloy, ToEthers};
-use futures::future::join_all;
+
 use semver::Version;
 use std::str::FromStr;
 
@@ -202,23 +202,52 @@ async fn fetch_storage_slots(
     address: NameOrAddress,
     layout: &StorageLayout,
 ) -> Result<Vec<B256>> {
-    // TODO: Batch request
-    let futures: Vec<_> = layout
-        .storage
-        .iter()
-        .map(|slot| {
-            let slot = B256::from(U256::from_str(&slot.slot)?);
-            Ok(provider.get_storage_at(address.clone(), slot.to_ethers(), None))
-        })
-        .collect::<Result<_>>()?;
-
-    join_all(futures).await.into_iter().map(|r| Ok(r?.to_alloy())).collect()
+    let mut results = Vec::new();
+
+    for storage_entry in &layout.storage {
+        let slot_number = U256::from_str_radix(&storage_entry.slot, 10)?.to_be_bytes();
+
+        let storage_result = provider
+            .get_storage_at(address.clone(), B256::from(slot_number).to_ethers(), None)
+            .await?;
+        let storage_bytes = storage_result.as_fixed_bytes();
+
+        let type_details = layout.types.get(&storage_entry.storage_type).ok_or_else(|| {
+            eyre::eyre!("Type details not found for {}", &storage_entry.storage_type)
+        })?;
+
+        let number_of_bytes = type_details.number_of_bytes.parse::<usize>().map_err(|_| {
+            eyre::eyre!("Invalid number of bytes: {}", type_details.number_of_bytes)
+        })?;
+
+        if storage_entry.offset < 0 {
+            return Err(eyre::eyre!("Negative offset for storage entry: {}", storage_entry.label))
+        }
+        let offset = storage_entry.offset as usize;
+
+        let slice_end = offset
+            .checked_add(number_of_bytes)
+            .ok_or_else(|| eyre::eyre!("Offset and number of bytes exceed storage slot size"))?;
+
+        let relevant_bytes = &storage_bytes[offset..slice_end];
+
+        let mut padded_value = [0u8; 32];
+
+        let pad_start = 32 - relevant_bytes.len();
+        padded_value[pad_start..].copy_from_slice(relevant_bytes);
+
+        let value = B256::from(padded_value);
+
+        results.push(value);
+    }
+
+    Ok(results)
 }
 
 fn print_storage(layout: StorageLayout, values: Vec<B256>, pretty: bool) -> Result<()> {
     if !pretty {
         println!("{}", serde_json::to_string_pretty(&serde_json::to_value(layout)?)?);
-        return Ok(());
+        return Ok(())
     }
 
     let mut table = Table::new();