refactor: get many reordering allowed

Author: prestwich

crates/storage/src/hot/mdbx.rs

@@ -489,11 +489,11 @@ mod tests {
         {
             let reader: Tx<RO> = db.reader().unwrap();
             let addresses: Vec<Address> = accounts.iter().map(|(addr, _)| *addr).collect();
-            let read_accounts: Vec<Option<Account>> =
+            let read_accounts: Vec<(_, Option<Account>)> =
                 reader.get_many::<hot::PlainAccountState, _>(addresses.iter()).unwrap();
 
             for (i, (_, expected_account)) in accounts.iter().enumerate() {
-                assert_eq!(read_accounts[i].as_ref(), Some(expected_account));
+                assert_eq!(read_accounts[i].1.as_ref(), Some(expected_account));
             }
         }
     }

crates/storage/src/hot/mem.rs

@@ -581,9 +581,9 @@ mod tests {
             let values = reader.get_many::<TestTable, _>(keys).unwrap();
 
             assert_eq!(values.len(), 3);
-            assert_eq!(values[0], Some(Bytes::from_static(b"first")));
-            assert_eq!(values[1], Some(Bytes::from_static(b"second")));
-            assert_eq!(values[2], Some(Bytes::from_static(b"third")));
+            assert_eq!(values[0], (&1u64, Some(Bytes::from_static(b"first"))));
+            assert_eq!(values[1], (&2u64, Some(Bytes::from_static(b"second"))));
+            assert_eq!(values[2], (&3u64, Some(Bytes::from_static(b"third"))));
         }
     }
 

crates/storage/src/hot/revm.rs

@@ -69,7 +69,10 @@ impl<U: HotKvRead> HotKvRead for RevmRead<U> {
         self.reader.get_dual::<T>(key1, key2)
     }
 
-    fn get_many<'a, T, I>(&self, keys: I) -> Result<Vec<Option<T::Value>>, Self::Error>
+    fn get_many<'a, T, I>(
+        &self,
+        keys: I,
+    ) -> Result<Vec<(&'a T::Key, Option<T::Value>)>, Self::Error>
     where
         T::Key: 'a,
         T: Table,
@@ -138,7 +141,10 @@ impl<U: HotKvWrite> HotKvRead for RevmWrite<U> {
         self.writer.get_dual::<T>(key1, key2)
     }
 
-    fn get_many<'a, T, I>(&self, keys: I) -> Result<Vec<Option<T::Value>>, Self::Error>
+    fn get_many<'a, T, I>(
+        &self,
+        keys: I,
+    ) -> Result<Vec<(&'a T::Key, Option<T::Value>)>, Self::Error>
     where
         T::Key: 'a,
         T: Table,

crates/storage/src/hot/traits.rs

@@ -125,13 +125,21 @@ pub trait HotKvRead {
     ///
     /// # Returns
     ///
-    /// A vector of `Option<T::Value>`, where each element corresponds to the
-    /// value for the respective key in the input iterator. If a key does not
-    /// exist in the table, the corresponding element will be `None`.
+    /// A vector of `(&'a T::Key, Option<T::Value>)`, where each element
+    /// corresponds to the value for the respective key in the input iterator.
+    /// If a key does not exist in the table, the corresponding element will be
+    /// `None`.
+    ///
+    /// Implementations ARE NOT required to preserve the order of the input
+    /// keys in the output vector. Users should not rely on any specific
+    /// ordering.
     ///
     /// If any error occurs during retrieval or deserialization, the entire
     /// operation will return an error.
-    fn get_many<'a, T, I>(&self, keys: I) -> Result<Vec<Option<T::Value>>, Self::Error>
+    fn get_many<'a, T, I>(
+        &self,
+        keys: I,
+    ) -> Result<Vec<(&'a T::Key, Option<T::Value>)>, Self::Error>
     where
         T::Key: 'a,
         T: Table,
@@ -140,10 +148,11 @@ pub trait HotKvRead {
         let mut key_buf = [0u8; MAX_KEY_SIZE];
 
         keys.into_iter()
-            .map(|key| self.raw_get(T::NAME, key.encode_key(&mut key_buf)))
-            .map(|maybe_val| {
+            .map(|key| (key, self.raw_get(T::NAME, key.encode_key(&mut key_buf))))
+            .map(|(key, maybe_val)| {
                 maybe_val
                     .and_then(|val| ValSer::maybe_decode_value(val.as_deref()).map_err(Into::into))
+                    .map(|res| (key, res))
             })
             .collect()
     }