Implement compact codec for alloy eip access_list (#7554)

Cargo.lock

@@ -6240,6 +6240,7 @@ dependencies = [
 name = "reth-codecs"
 version = "0.2.0-beta.5"
 dependencies = [
+ "alloy-eips",
  "alloy-primitives",
  "arbitrary",
  "bytes",

crates/primitives/src/transaction/access_list.rs

@@ -173,3 +173,30 @@ impl From<AccessList> for reth_rpc_types::AccessList {
         )
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use proptest::proptest;
+
+    proptest!(
+        #[test]
+        fn test_roundtrip_accesslist_conversion(access_list: AccessList) {
+            // Convert access_list to buffer and then create alloy_access_list from buffer and
+            // compare
+            let mut compacted_access_list = Vec::<u8>::new();
+            let len = access_list.clone().to_compact(&mut compacted_access_list);
+
+            let alloy_access_list = AccessList::from_compact(&compacted_access_list, len).0;
+            assert_eq!(access_list, alloy_access_list);
+
+            // Create alloy_access_list from access_list and then convert it to buffer and compare
+            // compacted_alloy_access_list and compacted_access_list
+            let alloy_access_list = AccessList(access_list.0);
+            let mut compacted_alloy_access_list = Vec::<u8>::new();
+            let _len = alloy_access_list.to_compact(&mut compacted_alloy_access_list);
+            assert_eq!(compacted_access_list, compacted_alloy_access_list);
+        }
+    );
+}

crates/storage/codecs/Cargo.toml

@@ -13,10 +13,12 @@ workspace = true
 [dependencies]
 reth-codecs-derive = { path = "./derive", default-features = false }
 
+alloy-eips.workspace = true
 alloy-primitives.workspace = true
 bytes.workspace = true
 
 [dev-dependencies]
+alloy-eips = { workspace = true, features = ["arbitrary", "serde"] }
 alloy-primitives = { workspace = true, features = ["arbitrary", "serde"] }
 serde.workspace = true
 modular-bitfield = "0.11.2"

crates/storage/codecs/src/alloy/access_list.rs

@@ -0,0 +1,99 @@
+use crate::Compact;
+use alloy_eips::eip2930::{AccessList, AccessListItem};
+use alloy_primitives::Address;
+
+/// Implement `Compact` for `AccessListItem` and `AccessList`.
+impl Compact for AccessListItem {
+    fn to_compact<B>(self, buf: &mut B) -> usize
+    where
+        B: bytes::BufMut + AsMut<[u8]>,
+    {
+        let mut buffer = bytes::BytesMut::new();
+        self.address.to_compact(&mut buffer);
+        self.storage_keys.specialized_to_compact(&mut buffer);
+        let total_length = buffer.len();
+        buf.put(buffer);
+        total_length
+    }
+
+    fn from_compact(mut buf: &[u8], _: usize) -> (Self, &[u8]) {
+        let (address, new_buf) = Address::from_compact(buf, buf.len());
+        buf = new_buf;
+        let (storage_keys, new_buf) = Vec::specialized_from_compact(buf, buf.len());
+        buf = new_buf;
+        let access_list_item = AccessListItem { address, storage_keys };
+        (access_list_item, buf)
+    }
+}
+
+impl Compact for AccessList {
+    fn to_compact<B>(self, buf: &mut B) -> usize
+    where
+        B: bytes::BufMut + AsMut<[u8]>,
+    {
+        let mut buffer = bytes::BytesMut::new();
+        self.0.to_compact(&mut buffer);
+        let total_length = buffer.len();
+        buf.put(buffer);
+        total_length
+    }
+
+    fn from_compact(mut buf: &[u8], _: usize) -> (Self, &[u8]) {
+        let (access_list_items, new_buf) = Vec::from_compact(buf, buf.len());
+        buf = new_buf;
+        let access_list = AccessList(access_list_items);
+        (access_list, buf)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use alloy_primitives::Bytes;
+    use proptest::proptest;
+    use serde::Deserialize;
+
+    proptest! {
+        #[test]
+        fn test_roundtrip_compact_access_list_item(access_list_item: AccessListItem) {
+            let mut compacted_access_list_item = Vec::<u8>::new();
+            let len = access_list_item.clone().to_compact(&mut compacted_access_list_item);
+
+            let (decoded_access_list_item, _) = AccessListItem::from_compact(&compacted_access_list_item, len);
+            assert_eq!(access_list_item, decoded_access_list_item);
+        }
+    }
+
+    proptest! {
+        #[test]
+        fn test_roundtrip_compact_access_list(access_list: AccessList) {
+            let mut compacted_access_list = Vec::<u8>::new();
+            let len = access_list.clone().to_compact(&mut compacted_access_list);
+
+            let (decoded_access_list, _) = AccessList::from_compact(&compacted_access_list, len);
+            assert_eq!(access_list, decoded_access_list);
+        }
+    }
+
+    #[derive(Deserialize)]
+    struct CompactAccessListTestVector {
+        access_list: AccessList,
+        encoded_bytes: Bytes,
+    }
+
+    #[test]
+    fn test_compact_access_list_codec() {
+        let test_vectors: Vec<CompactAccessListTestVector> =
+            serde_json::from_str(include_str!("../../testdata/access_list_compact.json"))
+                .expect("Failed to parse test vectors");
+
+        for test_vector in test_vectors {
+            let mut buf = Vec::<u8>::new();
+            let len = test_vector.access_list.clone().to_compact(&mut buf);
+            assert_eq!(test_vector.encoded_bytes.0, buf);
+
+            let (decoded, _) = AccessList::from_compact(&test_vector.encoded_bytes, len);
+            assert_eq!(test_vector.access_list, decoded);
+        }
+    }
+}

crates/storage/codecs/src/alloy/log.rs

@@ -77,7 +77,8 @@ mod tests {
     #[test]
     fn test_compact_log_codec() {
         let test_vectors: Vec<CompactLogTestVector> =
-            serde_json::from_str(include_str!("../../testdata/log_compact.json")).unwrap();
+            serde_json::from_str(include_str!("../../testdata/log_compact.json"))
+                .expect("Failed to parse test vectors");
 
         for test_vector in test_vectors {
             let log_data = LogData::new_unchecked(test_vector.topics, test_vector.data);

crates/storage/codecs/src/alloy/mod.rs

@@ -1 +1,2 @@
+mod access_list;
 mod log;