From 89d0281ce3dd06e57c18b226df84af8809b750cd Mon Sep 17 00:00:00 2001 From: joshieDo <93316087+joshieDo@users.noreply.github.com> Date: Wed, 17 Jul 2024 14:06:05 +0200 Subject: [PATCH] chore: replace `StoredBranchNode`, `StoredTrieMask` and `StoredHashBuilderValue` types with `Compact` impl instead (#9573) --- Cargo.lock | 1 + crates/storage/codecs/Cargo.toml | 1 + crates/storage/codecs/src/alloy/mod.rs | 1 + crates/storage/codecs/src/alloy/trie.rs | 138 ++++++++++++++++++ crates/storage/db-api/src/models/mod.rs | 2 +- crates/storage/db/src/tables/mod.rs | 4 +- crates/trie/common/src/hash_builder/mod.rs | 3 - crates/trie/common/src/hash_builder/state.rs | 19 ++- crates/trie/common/src/hash_builder/value.rs | 43 ------ crates/trie/common/src/lib.rs | 8 +- crates/trie/common/src/mask.rs | 20 --- crates/trie/common/src/nodes/branch.rs | 93 ------------ crates/trie/common/src/nodes/mod.rs | 6 - crates/trie/common/src/storage.rs | 8 +- crates/trie/common/src/subnode.rs | 8 +- crates/trie/trie/src/trie.rs | 2 +- .../trie/src/trie_cursor/database_cursors.rs | 12 +- crates/trie/trie/src/trie_cursor/subnode.rs | 2 +- crates/trie/trie/src/updates.rs | 6 +- crates/trie/trie/src/walker.rs | 4 +- 20 files changed, 175 insertions(+), 206 deletions(-) create mode 100644 crates/storage/codecs/src/alloy/trie.rs delete mode 100644 crates/trie/common/src/hash_builder/value.rs delete mode 100644 crates/trie/common/src/mask.rs delete mode 100644 crates/trie/common/src/nodes/branch.rs delete mode 100644 crates/trie/common/src/nodes/mod.rs diff --git a/Cargo.lock b/Cargo.lock index 16f40337da..b37c137a73 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -6575,6 +6575,7 @@ dependencies = [ "alloy-eips", "alloy-genesis", "alloy-primitives", + "alloy-trie", "arbitrary", "bytes", "modular-bitfield", diff --git a/crates/storage/codecs/Cargo.toml b/crates/storage/codecs/Cargo.toml index 0c69ca5438..63fcc004ac 100644 --- a/crates/storage/codecs/Cargo.toml +++ b/crates/storage/codecs/Cargo.toml @@ -19,6 +19,7 @@ alloy-consensus = { workspace = true, optional = true } alloy-eips = { workspace = true, optional = true } alloy-genesis = { workspace = true, optional = true } alloy-primitives.workspace = true +alloy-trie.workspace = true # misc bytes.workspace = true diff --git a/crates/storage/codecs/src/alloy/mod.rs b/crates/storage/codecs/src/alloy/mod.rs index bb0a9cd42e..41a5ba20e2 100644 --- a/crates/storage/codecs/src/alloy/mod.rs +++ b/crates/storage/codecs/src/alloy/mod.rs @@ -3,5 +3,6 @@ mod authorization_list; mod genesis_account; mod log; mod request; +mod trie; mod txkind; mod withdrawal; diff --git a/crates/storage/codecs/src/alloy/trie.rs b/crates/storage/codecs/src/alloy/trie.rs new file mode 100644 index 0000000000..24b3112675 --- /dev/null +++ b/crates/storage/codecs/src/alloy/trie.rs @@ -0,0 +1,138 @@ +//! Native Compact codec impl for EIP-7685 requests. + +use crate::Compact; +use alloy_primitives::B256; +use alloy_trie::{hash_builder::HashBuilderValue, BranchNodeCompact, TrieMask}; +use bytes::{Buf, BufMut}; + +impl Compact for HashBuilderValue { + fn to_compact(self, buf: &mut B) -> usize + where + B: BufMut + AsMut<[u8]>, + { + match self { + Self::Hash(hash) => { + buf.put_u8(0); + 1 + hash.to_compact(buf) + } + Self::Bytes(bytes) => { + buf.put_u8(1); + 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() { + 0 => { + let (hash, buf) = B256::from_compact(buf, 32); + (Self::Hash(hash), buf) + } + 1 => { + let (bytes, buf) = Vec::from_compact(buf, 0); + (Self::Bytes(bytes), buf) + } + _ => unreachable!("Junk data in database: unknown HashBuilderValue variant"), + } + } +} + +impl Compact for BranchNodeCompact { + fn to_compact(self, buf: &mut B) -> usize + where + B: bytes::BufMut + AsMut<[u8]>, + { + let mut buf_size = 0; + + buf_size += self.state_mask.to_compact(buf); + buf_size += self.tree_mask.to_compact(buf); + buf_size += self.hash_mask.to_compact(buf); + + if let Some(root_hash) = self.root_hash { + buf_size += B256::len_bytes(); + buf.put_slice(root_hash.as_slice()); + } + + for hash in &self.hashes { + buf_size += B256::len_bytes(); + buf.put_slice(hash.as_slice()); + } + + buf_size + } + + fn from_compact(buf: &[u8], _len: usize) -> (Self, &[u8]) { + let hash_len = B256::len_bytes(); + + // Assert the buffer is long enough to contain the masks and the hashes. + assert_eq!(buf.len() % hash_len, 6); + + // Consume the masks. + let (state_mask, buf) = TrieMask::from_compact(buf, 0); + let (tree_mask, buf) = TrieMask::from_compact(buf, 0); + let (hash_mask, buf) = TrieMask::from_compact(buf, 0); + + let mut buf = buf; + let mut num_hashes = buf.len() / hash_len; + let mut root_hash = None; + + // Check if the root hash is present + if hash_mask.count_ones() as usize + 1 == num_hashes { + root_hash = Some(B256::from_slice(&buf[..hash_len])); + buf.advance(hash_len); + num_hashes -= 1; + } + + // Consume all remaining hashes. + let mut hashes = Vec::::with_capacity(num_hashes); + for _ in 0..num_hashes { + hashes.push(B256::from_slice(&buf[..hash_len])); + buf.advance(hash_len); + } + + (Self::new(state_mask, tree_mask, hash_mask, hashes, root_hash), buf) + } +} + +impl Compact for TrieMask { + fn to_compact(self, buf: &mut B) -> usize + where + B: bytes::BufMut + AsMut<[u8]>, + { + buf.put_u16(self.get()); + 2 + } + + fn from_compact(mut buf: &[u8], _len: usize) -> (Self, &[u8]) { + let mask = buf.get_u16(); + (Self::new(mask), buf) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use alloy_primitives::hex; + + #[test] + fn node_encoding() { + let n = BranchNodeCompact::new( + 0xf607, + 0x0005, + 0x4004, + vec![ + hex!("90d53cd810cc5d4243766cd4451e7b9d14b736a1148b26b3baac7617f617d321").into(), + hex!("cc35c964dda53ba6c0b87798073a9628dbc9cd26b5cce88eb69655a9c609caf1").into(), + ], + Some(hex!("aaaabbbb0006767767776fffffeee44444000005567645600000000eeddddddd").into()), + ); + + let mut out = Vec::new(); + let compact_len = n.clone().to_compact(&mut out); + assert_eq!(BranchNodeCompact::from_compact(&out, compact_len).0, n); + } +} diff --git a/crates/storage/db-api/src/models/mod.rs b/crates/storage/db-api/src/models/mod.rs index a290af914d..1533df123e 100644 --- a/crates/storage/db-api/src/models/mod.rs +++ b/crates/storage/db-api/src/models/mod.rs @@ -208,7 +208,7 @@ impl_compression_for_compact!( Receipt, TxType, StorageEntry, - StoredBranchNode, + BranchNodeCompact, StoredNibbles, StoredNibblesSubKey, StorageTrieEntry, diff --git a/crates/storage/db/src/tables/mod.rs b/crates/storage/db/src/tables/mod.rs index af350b74ae..c3c0d0b3f8 100644 --- a/crates/storage/db/src/tables/mod.rs +++ b/crates/storage/db/src/tables/mod.rs @@ -35,7 +35,7 @@ use reth_primitives::{ use reth_primitives_traits::IntegerList; use reth_prune_types::{PruneCheckpoint, PruneSegment}; use reth_stages_types::StageCheckpoint; -use reth_trie_common::{StorageTrieEntry, StoredBranchNode, StoredNibbles, StoredNibblesSubKey}; +use reth_trie_common::{BranchNodeCompact, StorageTrieEntry, StoredNibbles, StoredNibblesSubKey}; use serde::{Deserialize, Serialize}; use std::fmt; @@ -381,7 +381,7 @@ tables! { table HashedStorages; /// Stores the current state's Merkle Patricia Tree. - table AccountsTrie; + table AccountsTrie; /// From HashedAddress => NibblesSubKey => Intermediate value table StoragesTrie; diff --git a/crates/trie/common/src/hash_builder/mod.rs b/crates/trie/common/src/hash_builder/mod.rs index a9bad00a53..b41693ad16 100644 --- a/crates/trie/common/src/hash_builder/mod.rs +++ b/crates/trie/common/src/hash_builder/mod.rs @@ -3,7 +3,4 @@ mod state; pub use state::HashBuilderState; -mod value; -pub(crate) use value::StoredHashBuilderValue; - pub use alloy_trie::hash_builder::*; diff --git a/crates/trie/common/src/hash_builder/state.rs b/crates/trie/common/src/hash_builder/state.rs index c70d7817e4..3a8f8e4207 100644 --- a/crates/trie/common/src/hash_builder/state.rs +++ b/crates/trie/common/src/hash_builder/state.rs @@ -1,5 +1,4 @@ -use super::StoredHashBuilderValue; -use crate::{StoredTrieMask, TrieMask}; +use crate::TrieMask; use alloy_trie::{hash_builder::HashBuilderValue, HashBuilder}; use bytes::Buf; use nybbles::Nibbles; @@ -77,24 +76,24 @@ impl Compact for HashBuilderState { len += 2 + item.len(); } - len += StoredHashBuilderValue(self.value).to_compact(buf); + len += self.value.to_compact(buf); buf.put_u16(self.groups.len() as u16); len += 2; for item in &self.groups { - len += StoredTrieMask(*item).to_compact(buf); + len += (*item).to_compact(buf); } buf.put_u16(self.tree_masks.len() as u16); len += 2; for item in &self.tree_masks { - len += StoredTrieMask(*item).to_compact(buf); + len += (*item).to_compact(buf); } buf.put_u16(self.hash_masks.len() as u16); len += 2; for item in &self.hash_masks { - len += StoredTrieMask(*item).to_compact(buf); + len += (*item).to_compact(buf); } buf.put_u8(self.stored_in_database as u8); @@ -113,12 +112,12 @@ impl Compact for HashBuilderState { buf.advance(item_len); } - let (StoredHashBuilderValue(value), mut buf) = StoredHashBuilderValue::from_compact(buf, 0); + let (value, mut buf) = HashBuilderValue::from_compact(buf, 0); let groups_len = buf.get_u16() as usize; let mut groups = Vec::with_capacity(groups_len); for _ in 0..groups_len { - let (StoredTrieMask(item), rest) = StoredTrieMask::from_compact(buf, 0); + let (item, rest) = TrieMask::from_compact(buf, 0); groups.push(item); buf = rest; } @@ -126,7 +125,7 @@ impl Compact for HashBuilderState { let tree_masks_len = buf.get_u16() as usize; let mut tree_masks = Vec::with_capacity(tree_masks_len); for _ in 0..tree_masks_len { - let (StoredTrieMask(item), rest) = StoredTrieMask::from_compact(buf, 0); + let (item, rest) = TrieMask::from_compact(buf, 0); tree_masks.push(item); buf = rest; } @@ -134,7 +133,7 @@ impl Compact for HashBuilderState { let hash_masks_len = buf.get_u16() as usize; let mut hash_masks = Vec::with_capacity(hash_masks_len); for _ in 0..hash_masks_len { - let (StoredTrieMask(item), rest) = StoredTrieMask::from_compact(buf, 0); + let (item, rest) = TrieMask::from_compact(buf, 0); hash_masks.push(item); buf = rest; } diff --git a/crates/trie/common/src/hash_builder/value.rs b/crates/trie/common/src/hash_builder/value.rs deleted file mode 100644 index 1397f5756a..0000000000 --- a/crates/trie/common/src/hash_builder/value.rs +++ /dev/null @@ -1,43 +0,0 @@ -use alloy_primitives::B256; -use alloy_trie::hash_builder::HashBuilderValue; -use bytes::Buf; -use reth_codecs::Compact; - -/// A wrapper around `HashBuilderValue` that implements `Compact`. -pub(crate) struct StoredHashBuilderValue(pub(crate) HashBuilderValue); - -impl Compact for StoredHashBuilderValue { - fn to_compact(self, buf: &mut B) -> usize - where - B: bytes::BufMut + AsMut<[u8]>, - { - match self.0 { - HashBuilderValue::Hash(hash) => { - buf.put_u8(0); - 1 + hash.to_compact(buf) - } - HashBuilderValue::Bytes(bytes) => { - buf.put_u8(1); - 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], _len: usize) -> (Self, &[u8]) { - match buf.get_u8() { - 0 => { - let (hash, buf) = B256::from_compact(buf, 32); - (Self(HashBuilderValue::Hash(hash)), buf) - } - 1 => { - let (bytes, buf) = Vec::from_compact(buf, 0); - (Self(HashBuilderValue::Bytes(bytes)), buf) - } - _ => unreachable!("Junk data in database: unknown HashBuilderValue variant"), - } - } -} diff --git a/crates/trie/common/src/lib.rs b/crates/trie/common/src/lib.rs index f845c9ca5c..ee19b7ed91 100644 --- a/crates/trie/common/src/lib.rs +++ b/crates/trie/common/src/lib.rs @@ -14,15 +14,9 @@ pub mod hash_builder; mod account; pub use account::TrieAccount; -mod mask; -pub(crate) use mask::StoredTrieMask; - mod nibbles; pub use nibbles::{Nibbles, StoredNibbles, StoredNibblesSubKey}; -pub mod nodes; -pub use nodes::StoredBranchNode; - mod storage; pub use storage::StorageTrieEntry; @@ -36,4 +30,4 @@ pub use proofs::{AccountProof, StorageProof}; pub mod root; -pub use alloy_trie::{proof, BranchNodeCompact, HashBuilder, TrieMask, EMPTY_ROOT_HASH}; +pub use alloy_trie::{nodes::*, proof, BranchNodeCompact, HashBuilder, TrieMask, EMPTY_ROOT_HASH}; diff --git a/crates/trie/common/src/mask.rs b/crates/trie/common/src/mask.rs deleted file mode 100644 index 02c74d2cc0..0000000000 --- a/crates/trie/common/src/mask.rs +++ /dev/null @@ -1,20 +0,0 @@ -use super::TrieMask; -use bytes::Buf; -use reth_codecs::Compact; - -pub(crate) struct StoredTrieMask(pub(crate) TrieMask); - -impl Compact for StoredTrieMask { - fn to_compact(self, buf: &mut B) -> usize - where - B: bytes::BufMut + AsMut<[u8]>, - { - buf.put_u16(self.0.get()); - 2 - } - - fn from_compact(mut buf: &[u8], _len: usize) -> (Self, &[u8]) { - let mask = buf.get_u16(); - (Self(TrieMask::new(mask)), buf) - } -} diff --git a/crates/trie/common/src/nodes/branch.rs b/crates/trie/common/src/nodes/branch.rs deleted file mode 100644 index a4f10d7403..0000000000 --- a/crates/trie/common/src/nodes/branch.rs +++ /dev/null @@ -1,93 +0,0 @@ -use crate::StoredTrieMask; -use alloy_primitives::B256; -use alloy_trie::BranchNodeCompact; -use bytes::Buf; -use reth_codecs::Compact; -use serde::{Deserialize, Serialize}; - -/// Wrapper around `BranchNodeCompact` that implements `Compact`. -#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)] -pub struct StoredBranchNode(pub BranchNodeCompact); - -impl Compact for StoredBranchNode { - fn to_compact(self, buf: &mut B) -> usize - where - B: bytes::BufMut + AsMut<[u8]>, - { - let BranchNodeCompact { state_mask, tree_mask, hash_mask, root_hash, hashes } = self.0; - - let mut buf_size = 0; - - buf_size += StoredTrieMask(state_mask).to_compact(buf); - buf_size += StoredTrieMask(tree_mask).to_compact(buf); - buf_size += StoredTrieMask(hash_mask).to_compact(buf); - - if let Some(root_hash) = root_hash { - buf_size += B256::len_bytes(); - buf.put_slice(root_hash.as_slice()); - } - - for hash in &hashes { - buf_size += B256::len_bytes(); - buf.put_slice(hash.as_slice()); - } - - buf_size - } - - fn from_compact(buf: &[u8], _len: usize) -> (Self, &[u8]) { - let hash_len = B256::len_bytes(); - - // Assert the buffer is long enough to contain the masks and the hashes. - assert_eq!(buf.len() % hash_len, 6); - - // Consume the masks. - let (StoredTrieMask(state_mask), buf) = StoredTrieMask::from_compact(buf, 0); - let (StoredTrieMask(tree_mask), buf) = StoredTrieMask::from_compact(buf, 0); - let (StoredTrieMask(hash_mask), buf) = StoredTrieMask::from_compact(buf, 0); - - let mut buf = buf; - let mut num_hashes = buf.len() / hash_len; - let mut root_hash = None; - - // Check if the root hash is present - if hash_mask.count_ones() as usize + 1 == num_hashes { - root_hash = Some(B256::from_slice(&buf[..hash_len])); - buf.advance(hash_len); - num_hashes -= 1; - } - - // Consume all remaining hashes. - let mut hashes = Vec::::with_capacity(num_hashes); - for _ in 0..num_hashes { - hashes.push(B256::from_slice(&buf[..hash_len])); - buf.advance(hash_len); - } - - (Self(BranchNodeCompact::new(state_mask, tree_mask, hash_mask, hashes, root_hash)), buf) - } -} - -#[cfg(test)] -mod tests { - use super::*; - use alloy_primitives::hex; - - #[test] - fn node_encoding() { - let n = BranchNodeCompact::new( - 0xf607, - 0x0005, - 0x4004, - vec![ - hex!("90d53cd810cc5d4243766cd4451e7b9d14b736a1148b26b3baac7617f617d321").into(), - hex!("cc35c964dda53ba6c0b87798073a9628dbc9cd26b5cce88eb69655a9c609caf1").into(), - ], - Some(hex!("aaaabbbb0006767767776fffffeee44444000005567645600000000eeddddddd").into()), - ); - - let mut out = Vec::new(); - let compact_len = StoredBranchNode(n.clone()).to_compact(&mut out); - assert_eq!(StoredBranchNode::from_compact(&out, compact_len).0 .0, n); - } -} diff --git a/crates/trie/common/src/nodes/mod.rs b/crates/trie/common/src/nodes/mod.rs deleted file mode 100644 index f3db93f3e7..0000000000 --- a/crates/trie/common/src/nodes/mod.rs +++ /dev/null @@ -1,6 +0,0 @@ -//! Various branch nodes produced by the hash builder. - -mod branch; -pub use branch::StoredBranchNode; - -pub use alloy_trie::nodes::*; diff --git a/crates/trie/common/src/storage.rs b/crates/trie/common/src/storage.rs index 9dd07fd72a..0a6f5e8366 100644 --- a/crates/trie/common/src/storage.rs +++ b/crates/trie/common/src/storage.rs @@ -1,4 +1,4 @@ -use super::{BranchNodeCompact, StoredBranchNode, StoredNibblesSubKey}; +use super::{BranchNodeCompact, StoredNibblesSubKey}; use reth_codecs::Compact; use serde::{Deserialize, Serialize}; @@ -20,14 +20,14 @@ impl Compact for StorageTrieEntry { B: bytes::BufMut + AsMut<[u8]>, { let nibbles_len = self.nibbles.to_compact(buf); - let node_len = StoredBranchNode(self.node).to_compact(buf); + let node_len = self.node.to_compact(buf); nibbles_len + node_len } fn from_compact(buf: &[u8], len: usize) -> (Self, &[u8]) { let (nibbles, buf) = StoredNibblesSubKey::from_compact(buf, 33); - let (node, buf) = StoredBranchNode::from_compact(buf, len - 33); - let this = Self { nibbles, node: node.0 }; + let (node, buf) = BranchNodeCompact::from_compact(buf, len - 33); + let this = Self { nibbles, node }; (this, buf) } } diff --git a/crates/trie/common/src/subnode.rs b/crates/trie/common/src/subnode.rs index 0a51b561b3..db3b204e9d 100644 --- a/crates/trie/common/src/subnode.rs +++ b/crates/trie/common/src/subnode.rs @@ -1,4 +1,4 @@ -use super::{BranchNodeCompact, StoredBranchNode}; +use super::BranchNodeCompact; use bytes::Buf; use reth_codecs::Compact; @@ -36,7 +36,7 @@ impl Compact for StoredSubNode { if let Some(node) = self.node { buf.put_u8(1); len += 1; - len += StoredBranchNode(node).to_compact(buf); + len += node.to_compact(buf); } else { len += 1; buf.put_u8(0); @@ -55,9 +55,9 @@ impl Compact for StoredSubNode { let node_exists = buf.get_u8() != 0; let node = if node_exists { - let (node, rest) = StoredBranchNode::from_compact(buf, 0); + let (node, rest) = BranchNodeCompact::from_compact(buf, 0); buf = rest; - Some(node.0) + Some(node) } else { None }; diff --git a/crates/trie/trie/src/trie.rs b/crates/trie/trie/src/trie.rs index 64bcc0a7d8..c444a30563 100644 --- a/crates/trie/trie/src/trie.rs +++ b/crates/trie/trie/src/trie.rs @@ -1186,7 +1186,7 @@ mod tests { .into_iter() .map(|item| { let (key, node) = item.unwrap(); - (key.0, node.0) + (key.0, node) }) .collect(); assert_trie_updates(&account_updates); diff --git a/crates/trie/trie/src/trie_cursor/database_cursors.rs b/crates/trie/trie/src/trie_cursor/database_cursors.rs index 585ef46249..4c9e5e6a73 100644 --- a/crates/trie/trie/src/trie_cursor/database_cursors.rs +++ b/crates/trie/trie/src/trie_cursor/database_cursors.rs @@ -48,7 +48,7 @@ where &mut self, key: Nibbles, ) -> Result, DatabaseError> { - Ok(self.0.seek_exact(StoredNibbles(key))?.map(|value| (value.0 .0, value.1 .0))) + Ok(self.0.seek_exact(StoredNibbles(key))?.map(|value| (value.0 .0, value.1))) } /// Seeks a key in the account trie that matches or is greater than the provided key. @@ -56,12 +56,12 @@ where &mut self, key: Nibbles, ) -> Result, DatabaseError> { - Ok(self.0.seek(StoredNibbles(key))?.map(|value| (value.0 .0, value.1 .0))) + Ok(self.0.seek(StoredNibbles(key))?.map(|value| (value.0 .0, value.1))) } /// Move the cursor to the next entry and return it. fn next(&mut self) -> Result, DatabaseError> { - Ok(self.0.next()?.map(|value| (value.0 .0, value.1 .0))) + Ok(self.0.next()?.map(|value| (value.0 .0, value.1))) } /// Retrieves the current key in the cursor. @@ -127,7 +127,7 @@ where #[cfg(test)] mod tests { use super::*; - use crate::{StorageTrieEntry, StoredBranchNode}; + use crate::StorageTrieEntry; use reth_db_api::{cursor::DbCursorRW, transaction::DbTxMut}; use reth_primitives::hex_literal::hex; use reth_provider::test_utils::create_test_provider_factory; @@ -149,13 +149,13 @@ mod tests { cursor .upsert( key.into(), - StoredBranchNode(BranchNodeCompact::new( + BranchNodeCompact::new( 0b0000_0010_0000_0001, 0b0000_0010_0000_0001, 0, Vec::default(), None, - )), + ), ) .unwrap(); } diff --git a/crates/trie/trie/src/trie_cursor/subnode.rs b/crates/trie/trie/src/trie_cursor/subnode.rs index 15e2ac31d7..5385f6e312 100644 --- a/crates/trie/trie/src/trie_cursor/subnode.rs +++ b/crates/trie/trie/src/trie_cursor/subnode.rs @@ -1,4 +1,4 @@ -use crate::{nodes::CHILD_INDEX_RANGE, BranchNodeCompact, Nibbles, StoredSubNode}; +use crate::{BranchNodeCompact, Nibbles, StoredSubNode, CHILD_INDEX_RANGE}; use reth_primitives::B256; /// Cursor for iterating over a subtrie. diff --git a/crates/trie/trie/src/updates.rs b/crates/trie/trie/src/updates.rs index eba5d1963d..a1f7767e68 100644 --- a/crates/trie/trie/src/updates.rs +++ b/crates/trie/trie/src/updates.rs @@ -1,6 +1,6 @@ use crate::{ - walker::TrieWalker, BranchNodeCompact, HashBuilder, Nibbles, StorageTrieEntry, - StoredBranchNode, StoredNibbles, StoredNibblesSubKey, + walker::TrieWalker, BranchNodeCompact, HashBuilder, Nibbles, StorageTrieEntry, StoredNibbles, + StoredNibblesSubKey, }; use reth_db::tables; use reth_db_api::{ @@ -119,7 +119,7 @@ impl TrieUpdates { Some(node) => { if !nibbles.0.is_empty() { num_entries += 1; - account_trie_cursor.upsert(nibbles, StoredBranchNode(node))?; + account_trie_cursor.upsert(nibbles, node)?; } } None => { diff --git a/crates/trie/trie/src/walker.rs b/crates/trie/trie/src/walker.rs index 5f151e8b9a..4e8d6f9e53 100644 --- a/crates/trie/trie/src/walker.rs +++ b/crates/trie/trie/src/walker.rs @@ -242,7 +242,7 @@ mod tests { use crate::{ prefix_set::PrefixSetMut, trie_cursor::{DatabaseAccountTrieCursor, DatabaseStorageTrieCursor}, - StorageTrieEntry, StoredBranchNode, + StorageTrieEntry, }; use reth_db::tables; use reth_db_api::{cursor::DbCursorRW, transaction::DbTxMut}; @@ -276,7 +276,7 @@ mod tests { let mut account_cursor = tx.tx_ref().cursor_write::().unwrap(); for (k, v) in &inputs { - account_cursor.upsert(k.clone().into(), StoredBranchNode(v.clone())).unwrap(); + account_cursor.upsert(k.clone().into(), v.clone()).unwrap(); } let account_trie = DatabaseAccountTrieCursor::new(account_cursor); test_cursor(account_trie, &expected);