refactor: replace custom MPT and triehash with alloy-trie (#506)

* replace custom proof impl and triehash with alloy-trie

* fix some clippy warnings

Author: eshaan7

Cargo.lock

@@ -43,16 +43,16 @@ alloy = { version = "0.9.1", features = [
     "ssz",
     "json-rpc",
     "signers",
-]}
+] }
+alloy-trie = "0.7.8"
 op-alloy-rpc-types = "0.9.0"
 revm = { version = "18.0.0", default-features = false, features = [
     "std",
     "serde",
     "optional_block_gas_limit",
     "optional_eip3607",
     "optional_no_base_fee",
-]}
-triehash-ethereum = { git = "https://github.com/openethereum/parity-ethereum", rev = "55c90d4016505317034e3e98f699af07f5404b63" }
+] }
 
 # async/futures
 async-trait = "0.1.57"

Cargo.toml

@@ -6,8 +6,8 @@ edition = "2021"
 [dependencies]
 # execution
 alloy.workspace = true
+alloy-trie.workspace = true
 revm.workspace = true
-triehash-ethereum.workspace = true
 
 # async/futures
 futures.workspace = true

core/Cargo.toml

@@ -4,29 +4,31 @@ use alloy::consensus::BlockHeader;
 use alloy::network::primitives::HeaderResponse;
 use alloy::network::{BlockResponse, ReceiptResponse};
 use alloy::primitives::{keccak256, Address, B256, U256};
-use alloy::rlp::encode;
+use alloy::rlp;
 use alloy::rpc::types::{BlockTransactions, Filter, FilterChanges, Log};
+use alloy_trie::{
+    proof::verify_proof as mpt_verify_proof,
+    root::ordered_trie_root_with_encoder,
+    {Nibbles, TrieAccount},
+};
 use constants::{BLOB_BASE_FEE_UPDATE_FRACTION, MIN_BASE_FEE_PER_BLOB_GAS};
 use eyre::Result;
 use futures::future::try_join_all;
 use revm::primitives::KECCAK_EMPTY;
 use tracing::warn;
-use triehash_ethereum::ordered_trie_root;
 
 use crate::network_spec::NetworkSpec;
 use crate::types::BlockTag;
 
 use self::constants::MAX_SUPPORTED_LOGS_NUMBER;
 use self::errors::ExecutionError;
-use self::proof::{encode_account, verify_proof};
 use self::rpc::ExecutionRpc;
 use self::state::{FilterType, State};
 use self::types::Account;
 
 pub mod constants;
 pub mod errors;
 pub mod evm;
-pub mod proof;
 pub mod rpc;
 pub mod state;
 pub mod types;
@@ -69,48 +71,49 @@ impl<N: NetworkSpec, R: ExecutionRpc<N>> ExecutionClient<N, R> {
             .get_proof(address, slots, block.header().number().into())
             .await?;
 
-        let account_path = keccak256(address).to_vec();
-        let account_encoded = encode_account(&proof);
+        // Verify the account proof
+        let account_key = Nibbles::unpack(keccak256(proof.address));
+        let account = TrieAccount {
+            nonce: proof.nonce,
+            balance: proof.balance,
+            storage_root: proof.storage_hash,
+            code_hash: proof.code_hash,
+        };
+        let account_encoded = rlp::encode(account);
 
-        let is_valid = verify_proof(
+        mpt_verify_proof(
+            block.header().state_root(),
+            account_key,
+            account_encoded.into(),
             &proof.account_proof,
-            block.header().state_root().as_slice(),
-            &account_path,
-            &account_encoded,
-        );
-
-        if !is_valid {
-            return Err(ExecutionError::InvalidAccountProof(address).into());
-        }
+        )
+        .map_err(|_| ExecutionError::InvalidAccountProof(address))?;
 
+        // Verify the storage proofs, collecting the slot values
         let mut slot_map = HashMap::new();
 
         for storage_proof in proof.storage_proof {
             let key = storage_proof.key.as_b256();
             let key_hash = keccak256(key);
-            let value = encode(storage_proof.value);
+            let key_nibbles = Nibbles::unpack(key_hash);
+            let encoded_value = rlp::encode(storage_proof.value);
 
-            let is_valid = verify_proof(
+            mpt_verify_proof(
+                proof.storage_hash,
+                key_nibbles,
+                encoded_value.into(),
                 &storage_proof.proof,
-                proof.storage_hash.as_slice(),
-                key_hash.as_slice(),
-                &value,
-            );
-
-            if !is_valid {
-                return Err(ExecutionError::InvalidStorageProof(address, key).into());
-            }
+            )
+            .map_err(|_| ExecutionError::InvalidStorageProof(address, key))?;
 
             slot_map.insert(key, storage_proof.value);
         }
 
+        // Verify the code hash
         let code = if proof.code_hash == KECCAK_EMPTY || proof.code_hash == B256::ZERO {
             Vec::new()
         } else {
-            let code = self
-                .rpc
-                .get_code(address, block.header().number().into())
-                .await?;
+            let code = self.rpc.get_code(address, block.header().number()).await?;
             let code_hash = keccak256(&code);
 
             if proof.code_hash != code_hash {
@@ -256,8 +259,7 @@ impl<N: NetworkSpec, R: ExecutionRpc<N>> ExecutionClient<N, R> {
             .ok_or(eyre::eyre!(ExecutionError::NoReceiptsForBlock(tag)))?;
 
         let receipts_encoded = receipts.iter().map(N::encode_receipt).collect::<Vec<_>>();
-        let expected_receipt_root = ordered_trie_root(receipts_encoded.clone());
-        let expected_receipt_root = B256::from_slice(&expected_receipt_root.to_fixed_bytes());
+        let expected_receipt_root = ordered_trie_root(&receipts_encoded);
 
         if expected_receipt_root != block.header().receipts_root()
             // Note: Some RPC providers return different response in `eth_getTransactionReceipt` vs `eth_getBlockReceipts`
@@ -286,7 +288,7 @@ impl<N: NetworkSpec, R: ExecutionRpc<N>> ExecutionClient<N, R> {
             return Ok(None);
         };
 
-        let tag = BlockTag::Number(block.header().number().into());
+        let tag = BlockTag::Number(block.header().number());
 
         let receipts = self
             .rpc
@@ -295,8 +297,7 @@ impl<N: NetworkSpec, R: ExecutionRpc<N>> ExecutionClient<N, R> {
             .ok_or(eyre::eyre!(ExecutionError::NoReceiptsForBlock(tag)))?;
 
         let receipts_encoded = receipts.iter().map(N::encode_receipt).collect::<Vec<_>>();
-        let expected_receipt_root = ordered_trie_root(receipts_encoded);
-        let expected_receipt_root = B256::from_slice(&expected_receipt_root.to_fixed_bytes());
+        let expected_receipt_root = ordered_trie_root(&receipts_encoded);
 
         if expected_receipt_root != block.header().receipts_root() {
             return Err(ExecutionError::BlockReceiptsRootMismatch(tag).into());
@@ -369,7 +370,7 @@ impl<N: NetworkSpec, R: ExecutionRpc<N>> ExecutionClient<N, R> {
                     self.state
                         .push_filter(
                             filter_id,
-                            FilterType::NewBlock(blocks.last().unwrap().header().number().into()),
+                            FilterType::NewBlock(blocks.last().unwrap().header().number()),
                         )
                         .await;
                 }
@@ -476,7 +477,10 @@ impl<N: NetworkSpec, R: ExecutionRpc<N>> ExecutionClient<N, R> {
                     None
                 } else {
                     let tx_hash = logs[0].transaction_hash.unwrap();
-                    let encoded_logs = logs.iter().map(|l| encode(&l.inner)).collect::<Vec<_>>();
+                    let encoded_logs = logs
+                        .iter()
+                        .map(|l| rlp::encode(&l.inner))
+                        .collect::<Vec<_>>();
                     Some((tx_hash, encoded_logs))
                 }
             })
@@ -486,7 +490,7 @@ impl<N: NetworkSpec, R: ExecutionRpc<N>> ExecutionClient<N, R> {
             // Check if the receipt contains the desired log
             // Encoding logs for comparison
             let tx_hash = log.transaction_hash.unwrap();
-            let log_encoded = encode(&log.inner);
+            let log_encoded = rlp::encode(&log.inner);
             let receipt_logs_encoded = receipts_logs_encoded.get(&tx_hash).unwrap();
 
             if !receipt_logs_encoded.contains(&log_encoded) {
@@ -500,3 +504,13 @@ impl<N: NetworkSpec, R: ExecutionRpc<N>> ExecutionClient<N, R> {
         Ok(())
     }
 }
+
+/// Compute a trie root of a collection of encoded items.
+/// Ref: https://github.com/alloy-rs/trie/blob/main/src/root.rs.
+fn ordered_trie_root(items: &[Vec<u8>]) -> B256 {
+    fn noop_encoder(item: &Vec<u8>, buffer: &mut Vec<u8>) {
+        buffer.extend_from_slice(item);
+    }
+
+    ordered_trie_root_with_encoder(items, noop_encoder)
+}