perf(l1): use Bytes for trie values to enable O(1) clones

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## Perf
 
+### 2026-01-30
+
+- Use `Bytes` for trie values to enable O(1) clones [#6057](https://github.com/lambdaclass/ethrex/pull/6057)
+
 ### 2026-01-27
 
 - Optimize prewarmer by grouping transactions by sender [#6047](https://github.com/lambdaclass/ethrex/pull/6047)

crates/common/trie/db.rs

@@ -1,3 +1,4 @@
+use bytes::Bytes;
 use ethereum_types::H256;
 use ethrex_rlp::encode::RLPEncode;
 
@@ -12,17 +13,17 @@ pub type NodeMap = Arc<Mutex<BTreeMap<Vec<u8>, Vec<u8>>>>;
 
 pub trait TrieDB: Send + Sync {
     fn get(&self, key: Nibbles) -> Result<Option<Vec<u8>>, TrieError>;
-    fn put_batch(&self, key_values: Vec<(Nibbles, Vec<u8>)>) -> Result<(), TrieError>;
+    fn put_batch(&self, key_values: Vec<(Nibbles, Bytes)>) -> Result<(), TrieError>;
     // TODO: replace putbatch with this function.
     fn put_batch_no_alloc(&self, key_values: &[(Nibbles, Node)]) -> Result<(), TrieError> {
         self.put_batch(
             key_values
                 .iter()
-                .map(|node| (node.0.clone(), node.1.encode_to_vec()))
+                .map(|node| (node.0.clone(), node.1.encode_to_vec().into()))
                 .collect(),
         )
     }
-    fn put(&self, key: Nibbles, value: Vec<u8>) -> Result<(), TrieError> {
+    fn put(&self, key: Nibbles, value: Bytes) -> Result<(), TrieError> {
         self.put_batch(vec![(key, value)])
     }
     /// Commits any pending changes to the underlying storage
@@ -107,12 +108,12 @@ impl TrieDB for InMemoryTrieDB {
             .cloned())
     }
 
-    fn put_batch(&self, key_values: Vec<(Nibbles, Vec<u8>)>) -> Result<(), TrieError> {
+    fn put_batch(&self, key_values: Vec<(Nibbles, Bytes)>) -> Result<(), TrieError> {
         let mut db = self.inner.lock().map_err(|_| TrieError::LockError)?;
 
         for (key, value) in key_values {
             let prefixed_key = self.apply_prefix(key);
-            db.insert(prefixed_key.into_vec(), value);
+            db.insert(prefixed_key.into_vec(), value.to_vec());
         }
 
         Ok(())

crates/common/trie/logger.rs

@@ -5,6 +5,7 @@ use std::{
 
 use ethrex_rlp::decode::RLPDecode;
 
+use bytes::Bytes;
 use crate::{Nibbles, Node, NodeHash, Trie, TrieDB, TrieError};
 
 pub type TrieWitness = Arc<Mutex<HashMap<NodeHash, Node>>>;
@@ -44,11 +45,11 @@ impl TrieDB for TrieLogger {
         Ok(result)
     }
 
-    fn put(&self, key: Nibbles, value: Vec<u8>) -> Result<(), TrieError> {
+    fn put(&self, key: Nibbles, value: Bytes) -> Result<(), TrieError> {
         self.inner_db.put(key, value)
     }
 
-    fn put_batch(&self, key_values: Vec<(Nibbles, Vec<u8>)>) -> Result<(), TrieError> {
+    fn put_batch(&self, key_values: Vec<(Nibbles, Bytes)>) -> Result<(), TrieError> {
         self.inner_db.put_batch(key_values)
     }
 }

crates/common/trie/node.rs

@@ -150,7 +150,7 @@ impl NodeRef {
                 node.encode(&mut buf);
                 let hash = *hash.get_or_init(|| NodeHash::from_encoded(&buf));
                 if let Node::Leaf(leaf) = node.as_ref() {
-                    acc.push((path.concat(&leaf.partial), leaf.value.clone()));
+                    acc.push((path.concat(&leaf.partial), leaf.value.to_vec()));
                 }
                 acc.push((path, buf));
 
@@ -240,6 +240,12 @@ impl From<ValueRLP> for ValueOrHash {
     }
 }
 
+impl From<Vec<u8>> for ValueOrHash {
+    fn from(value: Vec<u8>) -> Self {
+        Self::Value(value.into())
+    }
+}
+
 impl From<NodeHash> for ValueOrHash {
     fn from(value: NodeHash) -> Self {
         Self::Hash(value)
@@ -268,7 +274,7 @@ impl Default for Node {
         // empty leaf node as a placeholder
         Self::Leaf(LeafNode {
             partial: Nibbles::from_bytes(&[]),
-            value: Vec::new(),
+            value: Default::default(),
         })
     }
 }

crates/common/trie/node/branch.rs

@@ -24,6 +24,7 @@ use super::{ExtensionNode, LeafNode, Node, NodeRef, ValueOrHash};
 )]
 pub struct BranchNode {
     pub choices: [NodeRef; 16],
+    #[rkyv(with = crate::rkyv_utils::BytesWrapper)]
     pub value: ValueRLP,
 }
 
@@ -42,13 +43,16 @@ impl BranchNode {
     }
 
     /// Creates a new branch node given its children and value
-    pub const fn new_with_value(choices: [NodeRef; 16], value: ValueRLP) -> Self {
-        Self { choices, value }
+    pub fn new_with_value(choices: [NodeRef; 16], value: impl Into<ValueRLP>) -> Self {
+        Self {
+            choices,
+            value: value.into(),
+        }
     }
 
     /// Updates the node's path and value
-    pub fn update(&mut self, new_value: ValueRLP) {
-        self.value = new_value;
+    pub fn update(&mut self, new_value: impl Into<ValueRLP>) {
+        self.value = new_value.into();
     }
 
     /// Retrieves a value from the subtrie originating from this node given its path
@@ -365,12 +369,12 @@ mod test {
         assert_eq!(
             node.get(trie.db.as_ref(), Nibbles::from_bytes(&[0x00]))
                 .unwrap(),
-            Some(vec![0x12, 0x34, 0x56, 0x78]),
+            Some(vec![0x12, 0x34, 0x56, 0x78].into()),
         );
         assert_eq!(
             node.get(trie.db.as_ref(), Nibbles::from_bytes(&[0x10]))
                 .unwrap(),
-            Some(vec![0x34, 0x56, 0x78, 0x9A]),
+            Some(vec![0x34, 0x56, 0x78, 0x9A].into()),
         );
     }
 
@@ -406,7 +410,7 @@ mod test {
         node.insert(trie.db.as_ref(), path.clone(), value.clone().into())
             .unwrap();
 
-        assert_eq!(node.get(trie.db.as_ref(), path).unwrap(), Some(value));
+        assert_eq!(node.get(trie.db.as_ref(), path).unwrap(), Some(value.into()));
     }
 
     #[test]
@@ -425,7 +429,7 @@ mod test {
         node.insert(trie.db.as_ref(), path.clone(), value.clone().into())
             .unwrap();
 
-        assert_eq!(node.get(trie.db.as_ref(), path).unwrap(), Some(value));
+        assert_eq!(node.get(trie.db.as_ref(), path).unwrap(), Some(value.into()));
     }
 
     #[test]
@@ -448,7 +452,7 @@ mod test {
             .unwrap();
 
         assert_eq!(new_node.choices, node.choices);
-        assert_eq!(new_node.value, value);
+        assert_eq!(new_node.value, ValueRLP::from(value));
     }
 
     #[test]
@@ -466,7 +470,7 @@ mod test {
             .unwrap();
 
         assert!(matches!(node, Some(NodeRemoveResult::New(Node::Leaf(_)))));
-        assert_eq!(value, Some(vec![0x00]));
+        assert_eq!(value, Some(vec![0x00].into()));
     }
 
     #[test]
@@ -485,7 +489,7 @@ mod test {
             .unwrap();
 
         assert!(matches!(node, Some(NodeRemoveResult::Mutated)));
-        assert_eq!(value, Some(vec![0x00]));
+        assert_eq!(value, Some(vec![0x00].into()));
     }
 
     #[test]
@@ -502,7 +506,7 @@ mod test {
             .unwrap();
 
         assert!(matches!(node, Some(NodeRemoveResult::New(Node::Leaf(_)))));
-        assert_eq!(value, Some(vec![0x00]));
+        assert_eq!(value, Some(vec![0x00].into()));
     }
 
     #[test]
@@ -519,7 +523,7 @@ mod test {
             .unwrap();
 
         assert!(matches!(node, Some(NodeRemoveResult::New(Node::Leaf(_)))));
-        assert_eq!(value, Some(vec![0xFF]));
+        assert_eq!(value, Some(vec![0xFF].into()));
     }
 
     #[test]
@@ -537,7 +541,7 @@ mod test {
             .unwrap();
 
         assert!(matches!(node, Some(NodeRemoveResult::Mutated)));
-        assert_eq!(value, Some(vec![0xFF]));
+        assert_eq!(value, Some(vec![0xFF].into()));
     }
 
     #[test]

crates/common/trie/node/extension.rs

@@ -297,12 +297,12 @@ mod test {
         assert_eq!(
             node.get(trie.db.as_ref(), Nibbles::from_bytes(&[0x00]))
                 .unwrap(),
-            Some(vec![0x12, 0x34, 0x56, 0x78]),
+            Some(vec![0x12, 0x34, 0x56, 0x78].into()),
         );
         assert_eq!(
             node.get(trie.db.as_ref(), Nibbles::from_bytes(&[0x01]))
                 .unwrap(),
-            Some(vec![0x34, 0x56, 0x78, 0x9A]),
+            Some(vec![0x34, 0x56, 0x78, 0x9A].into()),
         );
     }
 
@@ -369,7 +369,7 @@ mod test {
         assert_eq!(
             node.get(trie.db.as_ref(), Nibbles::from_bytes(&[0x10]))
                 .unwrap(),
-            Some(vec![0x20])
+            Some(vec![0x20].into())
         );
     }
 
@@ -397,7 +397,7 @@ mod test {
         assert_eq!(
             node.get(trie.db.as_ref(), Nibbles::from_bytes(&[0x10]))
                 .unwrap(),
-            Some(vec![0x20])
+            Some(vec![0x20].into())
         );
     }
 
@@ -419,7 +419,7 @@ mod test {
             .unwrap();
 
         assert!(none.is_none());
-        assert_eq!(node.get(trie.db.as_ref(), path).unwrap(), Some(value));
+        assert_eq!(node.get(trie.db.as_ref(), path).unwrap(), Some(value.into()));
     }
 
     #[test]
@@ -440,7 +440,7 @@ mod test {
             .unwrap();
 
         assert!(none.is_none());
-        assert_eq!(node.get(trie.db.as_ref(), path).unwrap(), Some(value));
+        assert_eq!(node.get(trie.db.as_ref(), path).unwrap(), Some(value.into()));
     }
 
     #[test]
@@ -476,7 +476,7 @@ mod test {
             .unwrap();
 
         assert!(matches!(node, Some(NodeRemoveResult::New(Node::Leaf(_)))));
-        assert_eq!(value, Some(vec![0x01]));
+        assert_eq!(value, Some(vec![0x01].into()));
     }
 
     #[test]
@@ -500,7 +500,7 @@ mod test {
             node,
             Some(NodeRemoveResult::New(Node::Extension(_)))
         ));
-        assert_eq!(value, Some(vec![0x00]));
+        assert_eq!(value, Some(vec![0x00].into()));
     }
 
     #[test]

crates/common/trie/node/leaf.rs

@@ -27,13 +27,17 @@ use super::{ExtensionNode, Node, ValueOrHash};
 )]
 pub struct LeafNode {
     pub partial: Nibbles,
+    #[rkyv(with = crate::rkyv_utils::BytesWrapper)]
     pub value: ValueRLP,
 }
 
 impl LeafNode {
     /// Creates a new leaf node and stores the given (path, value) pair
-    pub const fn new(partial: Nibbles, value: ValueRLP) -> Self {
-        Self { partial, value }
+    pub fn new(partial: Nibbles, value: impl Into<ValueRLP>) -> Self {
+        Self {
+            partial,
+            value: value.into(),
+        }
     }
 
     /// Returns the stored value if the given path matches the stored path
@@ -180,7 +184,7 @@ mod test {
 
     #[test]
     fn new() {
-        let node = LeafNode::new(Default::default(), Default::default());
+        let node = LeafNode::new(Default::default(), ValueRLP::default());
         assert_eq!(node.value, ValueRLP::default());
     }
 
@@ -192,7 +196,7 @@ mod test {
 
         assert_eq!(
             node.get(Nibbles::from_bytes(&[0x12])).unwrap(),
-            Some(vec![0x12, 0x34, 0x56, 0x78]),
+            Some(vec![0x12, 0x34, 0x56, 0x78].into()),
         );
     }
 
@@ -233,7 +237,7 @@ mod test {
             Some(Node::Branch(x)) => x,
             _ => panic!("expected a branch node"),
         };
-        assert_eq!(node.get(trie.db.as_ref(), path).unwrap(), Some(value));
+        assert_eq!(node.get(trie.db.as_ref(), path).unwrap(), Some(value.into()));
     }
 
     #[test]
@@ -251,7 +255,7 @@ mod test {
         assert!(matches!(node, Some(Node::Extension(_))));
         assert_eq!(
             node.unwrap().get(trie.db.as_ref(), path).unwrap(),
-            Some(value)
+            Some(value.into())
         );
     }
 
@@ -270,7 +274,7 @@ mod test {
         assert!(matches!(node, Some(Node::Extension(_))));
         assert_eq!(
             node.unwrap().get(trie.db.as_ref(), path).unwrap(),
-            Some(value)
+            Some(value.into())
         );
     }
 
@@ -289,7 +293,7 @@ mod test {
         assert!(matches!(node, Some(Node::Extension(_))));
         assert_eq!(
             node.unwrap().get(trie.db.as_ref(), path).unwrap(),
-            Some(value)
+            Some(value.into())
         );
     }
 
@@ -310,7 +314,7 @@ mod test {
         let (node, value) = node.remove(Nibbles::from_bytes(&[0x12, 0x34])).unwrap();
 
         assert!(node.is_none());
-        assert_eq!(value, Some(vec![0x12, 0x34, 0x56, 0x78]));
+        assert_eq!(value, Some(vec![0x12, 0x34, 0x56, 0x78].into()));
     }
 
     #[test]

crates/common/trie/rkyv_utils.rs

@@ -1,3 +1,4 @@
+use bytes::Bytes;
 use ethereum_types::H256;
 use rkyv::{Archive, Deserialize, Serialize};
 use std::hash::{Hash, Hasher};
@@ -39,3 +40,20 @@ impl Hash for ArchivedH256Wrapper {
         self.0.hash(state);
     }
 }
+
+#[derive(Archive, Serialize, Deserialize)]
+#[rkyv(remote = Bytes)]
+pub struct BytesWrapper {
+    #[rkyv(getter = bytes_to_vec)]
+    bytes: Vec<u8>,
+}
+
+fn bytes_to_vec(bytes: &Bytes) -> Vec<u8> {
+    bytes.to_vec()
+}
+
+impl From<BytesWrapper> for Bytes {
+    fn from(value: BytesWrapper) -> Self {
+        Self::from(value.bytes)
+    }
+}