Rename to TrieAccount / Use simple u64 serialize/deserialize

src/account.rs

@@ -2,15 +2,12 @@ use crate::{EMPTY_ROOT_HASH, KECCAK_EMPTY};
 use alloy_primitives::{keccak256, B256, U256};
 use alloy_rlp::{RlpDecodable, RlpEncodable};
 
-#[cfg(feature = "serde")]
-use crate::serde::quantity;
-
-/// Represents an Account in the account trie.
+/// Represents an TrieAccount in the account trie.
 #[derive(Copy, Clone, Debug, PartialEq, Eq, RlpDecodable, RlpEncodable)]
 #[cfg_attr(any(test, feature = "arbitrary"), derive(arbitrary::Arbitrary))]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
-pub struct Account {
+pub struct TrieAccount {
     /// The account's nonce.
     #[cfg_attr(feature = "serde", serde(with = "quantity"))]
     pub nonce: u64,
@@ -22,7 +19,7 @@ pub struct Account {
     pub code_hash: B256,
 }
 
-impl Default for Account {
+impl Default for TrieAccount {
     fn default() -> Self {
         Self {
             nonce: 0,
@@ -33,9 +30,31 @@ impl Default for Account {
     }
 }
 
-impl Account {
+impl TrieAccount {
     /// Compute  hash as committed to in the MPT trie without memorizing.
     pub fn trie_hash_slow(&self) -> B256 {
         keccak256(alloy_rlp::encode(self))
     }
 }
+
+#[cfg(feature = "serde")]
+mod quantity {
+    use alloy_primitives::U64;
+    use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+    /// Serializes a primitive number as a "quantity" hex string.
+    pub(crate) fn serialize<S>(value: &u64, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        U64::from(*value).serialize(serializer)
+    }
+
+    /// Deserializes a primitive number from a "quantity" hex string.
+    pub(crate) fn deserialize<'de, D>(deserializer: D) -> Result<u64, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        U64::deserialize(deserializer).map(|value| value.to())
+    }
+}

src/lib.rs

@@ -28,11 +28,8 @@ pub use hash_builder::HashBuilder;
 
 pub mod proof;
 
-#[cfg(feature = "serde")]
-pub mod serde;
-
 mod account;
-pub use account::Account;
+pub use account::TrieAccount;
 
 mod mask;
 pub use mask::TrieMask;

src/root.rs

@@ -1,4 +1,4 @@
-use crate::{Account, HashBuilder, EMPTY_ROOT_HASH};
+use crate::{HashBuilder, TrieAccount, EMPTY_ROOT_HASH};
 use alloy_primitives::{keccak256, B256};
 use alloy_rlp::Encodable;
 
@@ -55,7 +55,7 @@ where
 /// represented as MPT.
 /// See [`state_root_unsorted`] for more info.
 #[cfg(feature = "std")]
-pub fn state_root_ref_unhashed<'a, A: Into<Account> + Clone + 'a>(
+pub fn state_root_ref_unhashed<'a, A: Into<TrieAccount> + Clone + 'a>(
     state: impl IntoIterator<Item = (&'a Address, &'a A)>,
 ) -> B256 {
     state_root_unsorted(
@@ -67,7 +67,7 @@ pub fn state_root_ref_unhashed<'a, A: Into<Account> + Clone + 'a>(
 /// represented as MPT.
 /// See [`state_root_unsorted`] for more info.
 #[cfg(feature = "std")]
-pub fn state_root_unhashed<A: Into<Account>>(
+pub fn state_root_unhashed<A: Into<TrieAccount>>(
     state: impl IntoIterator<Item = (Address, A)>,
 ) -> B256 {
     state_root_unsorted(state.into_iter().map(|(address, account)| (keccak256(address), account)))
@@ -76,7 +76,9 @@ pub fn state_root_unhashed<A: Into<Account>>(
 /// Sorts the hashed account keys and calculates the root hash of the state represented as MPT.
 /// See [`state_root`] for more info.
 #[cfg(feature = "std")]
-pub fn state_root_unsorted<A: Into<Account>>(state: impl IntoIterator<Item = (B256, A)>) -> B256 {
+pub fn state_root_unsorted<A: Into<TrieAccount>>(
+    state: impl IntoIterator<Item = (B256, A)>,
+) -> B256 {
     state_root(state.into_iter().sorted_unstable_by_key(|(key, _)| *key))
 }
 
@@ -87,7 +89,7 @@ pub fn state_root_unsorted<A: Into<Account>>(state: impl IntoIterator<Item = (B2
 /// # Panics
 ///
 /// If the items are not in sorted order.
-pub fn state_root<A: Into<Account>>(state: impl IntoIterator<Item = (B256, A)>) -> B256 {
+pub fn state_root<A: Into<TrieAccount>>(state: impl IntoIterator<Item = (B256, A)>) -> B256 {
     let mut hb = HashBuilder::default();
     for (hashed_key, account) in state {
         let account_rlp_buf = alloy_rlp::encode(account.into());