chore(deps): bump alloy-trie 0.7

Cargo.toml

@@ -424,7 +424,7 @@ alloy-dyn-abi = "0.8.0"
 alloy-primitives = { version = "0.8.4", default-features = false }
 alloy-rlp = "0.3.4"
 alloy-sol-types = "0.8.0"
-alloy-trie = { version = "0.6", default-features = false }
+alloy-trie = { version = "0.7", default-features = false }
 
 alloy-consensus = { version = "0.4.0", default-features = false }
 alloy-eips = { version = "0.4.0", default-features = false }

crates/stages/types/src/checkpoints.rs

@@ -8,7 +8,7 @@ use std::ops::RangeInclusive;
 use super::StageId;
 
 /// Saves the progress of Merkle stage.
-#[derive(Default, Debug, Clone, PartialEq)]
+#[derive(Default, Debug, Clone, PartialEq, Eq)]
 pub struct MerkleCheckpoint {
     /// The target block number.
     pub target_block: BlockNumber,

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

@@ -1,50 +1,53 @@
-//! Native Compact codec impl for EIP-7685 requests.
+//! Native Compact codec impl for alloy-trie types.
 
 use crate::Compact;
 use alloc::vec::Vec;
 use alloy_primitives::B256;
-use alloy_trie::{hash_builder::HashBuilderValue, BranchNodeCompact, TrieMask};
+use alloy_trie::{
+    hash_builder::{HashBuilderValue, HashBuilderValueRef},
+    BranchNodeCompact, TrieMask,
+};
 use bytes::{Buf, BufMut};
 
-/// Identifier for [`HashBuilderValue::Hash`]
+/// Identifier for [`HashBuilderValueRef::Hash`]
 const HASH_BUILDER_TYPE_HASH: u8 = 0;
 
-/// Identifier for [`HashBuilderValue::Bytes`]
+/// Identifier for [`HashBuilderValueRef::Bytes`]
 const HASH_BUILDER_TYPE_BYTES: u8 = 1;
 
 impl Compact for HashBuilderValue {
     fn to_compact<B>(&self, buf: &mut B) -> usize
     where
         B: BufMut + AsMut<[u8]>,
     {
-        match self {
-            Self::Hash(hash) => {
+        match self.as_ref() {
+            HashBuilderValueRef::Hash(hash) => {
                 buf.put_u8(HASH_BUILDER_TYPE_HASH);
                 1 + hash.to_compact(buf)
             }
-            Self::Bytes(bytes) => {
+            HashBuilderValueRef::Bytes(bytes) => {
                 buf.put_u8(HASH_BUILDER_TYPE_BYTES);
                 1 + bytes.to_compact(buf)
             }
         }
     }
 
-    // # Panics
-    //
-    // A panic will be triggered if a HashBuilderValue variant greater than 1 is passed from the
-    // database.
     fn from_compact(mut buf: &[u8], _: usize) -> (Self, &[u8]) {
-        match buf.get_u8() {
+        let mut this = Self::default();
+        let buf = match buf.get_u8() {
             HASH_BUILDER_TYPE_HASH => {
                 let (hash, buf) = B256::from_compact(buf, 32);
-                (Self::Hash(hash), buf)
+                this.set_from_ref(HashBuilderValueRef::Hash(&hash));
+                buf
             }
             HASH_BUILDER_TYPE_BYTES => {
                 let (bytes, buf) = Vec::from_compact(buf, 0);
-                (Self::Bytes(bytes), buf)
+                this.set_bytes_owned(bytes);
+                buf
             }
             _ => unreachable!("Junk data in database: unknown HashBuilderValue variant"),
-        }
+        };
+        (this, buf)
     }
 }
 

crates/trie/common/src/hash_builder/state.rs

@@ -1,13 +1,13 @@
 use crate::TrieMask;
-use alloy_trie::{hash_builder::HashBuilderValue, HashBuilder};
+use alloy_trie::{hash_builder::HashBuilderValue, nodes::RlpNode, HashBuilder};
 use bytes::Buf;
 use nybbles::Nibbles;
 use reth_codecs::Compact;
 use serde::{Deserialize, Serialize};
 
 /// The hash builder state for storing in the database.
 /// Check the `reth-trie` crate for more info on hash builder.
-#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
 #[cfg_attr(
     feature = "arbitrary",
     derive(arbitrary::Arbitrary),
@@ -16,10 +16,10 @@ use serde::{Deserialize, Serialize};
 pub struct HashBuilderState {
     /// The current key.
     pub key: Vec<u8>,
-    /// The builder stack.
-    pub stack: Vec<Vec<u8>>,
     /// The current node value.
     pub value: HashBuilderValue,
+    /// The builder stack.
+    pub stack: Vec<RlpNode>,
 
     /// Group masks.
     pub groups: Vec<TrieMask>,
@@ -112,7 +112,7 @@ impl Compact for HashBuilderState {
         let mut stack = Vec::with_capacity(stack_len);
         for _ in 0..stack_len {
             let item_len = buf.get_u16() as usize;
-            stack.push(Vec::from(&buf[..item_len]));
+            stack.push(RlpNode::from_raw(&buf[..item_len]).unwrap());
             buf.advance(item_len);
         }
 
@@ -154,7 +154,7 @@ mod tests {
     #[test]
     fn hash_builder_state_regression() {
         let mut state = HashBuilderState::default();
-        state.stack.push(vec![]);
+        state.stack.push(Default::default());
         let mut buf = vec![];
         let len = state.clone().to_compact(&mut buf);
         let (decoded, _) = HashBuilderState::from_compact(&buf, len);

crates/trie/trie/src/witness.rs

@@ -1,5 +1,3 @@
-use std::collections::BTreeMap;
-
 use crate::{
     hashed_cursor::HashedCursorFactory,
     prefix_set::TriePrefixSetsMut,
@@ -19,6 +17,7 @@ use reth_primitives::constants::EMPTY_ROOT_HASH;
 use reth_trie_common::{
     BranchNode, HashBuilder, Nibbles, StorageMultiProof, TrieAccount, TrieNode, CHILD_INDEX_RANGE,
 };
+use std::collections::BTreeMap;
 
 /// State transition witness for the trie.
 #[derive(Debug)]
@@ -239,7 +238,10 @@ where
                 TrieNode::Leaf(leaf) => {
                     next_path.extend_from_slice(&leaf.key);
                     if next_path != key {
-                        trie_nodes.insert(next_path.clone(), Either::Right(leaf.value.clone()));
+                        trie_nodes.insert(
+                            next_path.clone(),
+                            Either::Right(leaf.value.as_slice().to_vec()),
+                        );
                     }
                 }
                 TrieNode::EmptyRoot => {