feat(mpt): Migrate to thiserror

bin/client/src/fault/handler/mod.rs

@@ -3,7 +3,7 @@
 //! [KonaHandleRegister]: kona_executor::KonaHandleRegister
 
 use alloc::sync::Arc;
-use kona_mpt::{TrieDB, TrieDBFetcher, TrieDBHinter};
+use kona_mpt::{TrieDB, TrieHinter, TrieProvider};
 use revm::{
     handler::register::EvmHandler,
     primitives::{spec_to_generic, SpecId},
@@ -20,8 +20,8 @@ mod kzg_point_eval;
 pub(crate) fn fpvm_handle_register<F, H>(
     handler: &mut EvmHandler<'_, (), &mut State<&mut TrieDB<F, H>>>,
 ) where
-    F: TrieDBFetcher,
-    H: TrieDBHinter,
+    F: TrieProvider,
+    H: TrieHinter,
 {
     let spec_id = handler.cfg.spec_id;
 

bin/client/src/kona.rs

@@ -63,7 +63,7 @@ fn main() -> Result<()> {
 
         let mut executor = StatelessL2BlockExecutor::builder(&boot.rollup_config)
             .with_parent_header(driver.take_l2_safe_head_header())
-            .with_fetcher(l2_provider.clone())
+            .with_provider(l2_provider.clone())
             .with_hinter(l2_provider)
             .with_handle_register(fpvm_handle_register)
             .build()?;

bin/client/src/l1/chain_provider.rs

@@ -9,7 +9,7 @@ use alloy_rlp::Decodable;
 use anyhow::{anyhow, Result};
 use async_trait::async_trait;
 use kona_derive::traits::ChainProvider;
-use kona_mpt::{OrderedListWalker, TrieDBFetcher};
+use kona_mpt::{OrderedListWalker, TrieProvider};
 use kona_preimage::{CommsClient, PreimageKey, PreimageKeyType};
 use op_alloy_protocol::BlockInfo;
 
@@ -121,7 +121,9 @@ impl<T: CommsClient + Sync + Send> ChainProvider for OracleL1ChainProvider<T> {
     }
 }
 
-impl<T: CommsClient> TrieDBFetcher for OracleL1ChainProvider<T> {
+impl<T: CommsClient> TrieProvider for OracleL1ChainProvider<T> {
+    type Error = anyhow::Error;
+
     fn trie_node_preimage(&self, key: B256) -> Result<Bytes> {
         // On L1, trie node preimages are stored as keccak preimage types in the oracle. We assume
         // that a hint for these preimages has already been sent, prior to this call.
@@ -134,10 +136,10 @@ impl<T: CommsClient> TrieDBFetcher for OracleL1ChainProvider<T> {
     }
 
     fn bytecode_by_hash(&self, _: B256) -> Result<Bytes> {
-        unimplemented!("TrieDBFetcher::bytecode_by_hash unimplemented for OracleL1ChainProvider")
+        unimplemented!("TrieProvider::bytecode_by_hash unimplemented for OracleL1ChainProvider")
     }
 
     fn header_by_hash(&self, _: B256) -> Result<Header> {
-        unimplemented!("TrieDBFetcher::header_by_hash unimplemented for OracleL1ChainProvider")
+        unimplemented!("TrieProvider::header_by_hash unimplemented for OracleL1ChainProvider")
     }
 }

bin/client/src/l1/driver.rs

@@ -19,7 +19,7 @@ use kona_derive::{
     },
     traits::{BlobProvider, ChainProvider, L2ChainProvider, OriginProvider},
 };
-use kona_mpt::TrieDBFetcher;
+use kona_mpt::TrieProvider;
 use kona_preimage::{CommsClient, PreimageKey, PreimageKeyType};
 use op_alloy_protocol::{BlockInfo, L2BlockInfo};
 use op_alloy_rpc_types_engine::OptimismAttributesWithParent;

bin/client/src/l2/chain_provider.rs

@@ -9,7 +9,7 @@ use alloy_rlp::Decodable;
 use anyhow::{anyhow, Result};
 use async_trait::async_trait;
 use kona_derive::traits::L2ChainProvider;
-use kona_mpt::{OrderedListWalker, TrieDBFetcher, TrieDBHinter};
+use kona_mpt::{OrderedListWalker, TrieHinter, TrieProvider};
 use kona_preimage::{CommsClient, PreimageKey, PreimageKeyType};
 use kona_primitives::{L2ExecutionPayloadEnvelope, OpBlock};
 use op_alloy_consensus::OpTxEnvelope;
@@ -120,7 +120,9 @@ impl<T: CommsClient + Send + Sync> L2ChainProvider for OracleL2ChainProvider<T>
     }
 }
 
-impl<T: CommsClient> TrieDBFetcher for OracleL2ChainProvider<T> {
+impl<T: CommsClient> TrieProvider for OracleL2ChainProvider<T> {
+    type Error = anyhow::Error;
+
     fn trie_node_preimage(&self, key: B256) -> Result<Bytes> {
         // On L2, trie node preimages are stored as keccak preimage types in the oracle. We assume
         // that a hint for these preimages has already been sent, prior to this call.
@@ -157,7 +159,9 @@ impl<T: CommsClient> TrieDBFetcher for OracleL2ChainProvider<T> {
     }
 }
 
-impl<T: CommsClient> TrieDBHinter for OracleL2ChainProvider<T> {
+impl<T: CommsClient> TrieHinter for OracleL2ChainProvider<T> {
+    type Error = anyhow::Error;
+
     fn hint_trie_node(&self, hash: B256) -> Result<()> {
         kona_common::block_on(async move {
             self.oracle.write(&HintType::L2StateNode.encode_with(&[hash.as_slice()])).await

crates/executor/benches/execution.rs

@@ -7,22 +7,22 @@ use alloy_rpc_types_engine::PayloadAttributes;
 use anyhow::{anyhow, Result};
 use criterion::{criterion_group, criterion_main, Bencher, Criterion};
 use kona_executor::StatelessL2BlockExecutor;
-use kona_mpt::{NoopTrieDBHinter, TrieDBFetcher};
+use kona_mpt::{NoopTrieHinter, TrieProvider};
 use op_alloy_genesis::{RollupConfig, OP_BASE_FEE_PARAMS, OP_CANYON_BASE_FEE_PARAMS};
 use op_alloy_rpc_types_engine::OptimismPayloadAttributes;
 use pprof::criterion::{Output, PProfProfiler};
 use serde::Deserialize;
 use std::collections::HashMap;
 
-/// A [TrieDBFetcher] implementation that fetches trie nodes and bytecode from the local
+/// A [TrieProvider] implementation that fetches trie nodes and bytecode from the local
 /// testdata folder.
 #[derive(Deserialize)]
-struct TestdataTrieDBFetcher {
+struct TestdataTrieProvider {
     preimages: HashMap<B256, Bytes>,
 }
 
-impl TestdataTrieDBFetcher {
-    /// Constructs a new [TestdataTrieDBFetcher] with the given testdata folder.
+impl TestdataTrieProvider {
+    /// Constructs a new [TestdataTrieProvider] with the given testdata folder.
     pub(crate) fn new(testdata_folder: &str) -> Self {
         let file_name = format!("testdata/{}/output.json", testdata_folder);
         let preimages = serde_json::from_str::<HashMap<B256, Bytes>>(
@@ -33,7 +33,9 @@ impl TestdataTrieDBFetcher {
     }
 }
 
-impl TrieDBFetcher for TestdataTrieDBFetcher {
+impl TrieProvider for TestdataTrieProvider {
+    type Error = anyhow::Error;
+
     fn trie_node_preimage(&self, key: B256) -> Result<Bytes> {
         self.preimages
             .get(&key)
@@ -79,8 +81,8 @@ fn op_mainnet_exec_bench(
     bencher.iter(|| {
         let mut l2_block_executor = StatelessL2BlockExecutor::builder(&rollup_config)
             .with_parent_header(pre_state_header.clone().seal_slow())
-            .with_fetcher(TestdataTrieDBFetcher::new(data_folder))
-            .with_hinter(NoopTrieDBHinter)
+            .with_provider(TestdataTrieProvider::new(data_folder))
+            .with_hinter(NoopTrieHinter)
             .build()
             .unwrap();
         l2_block_executor.execute_payload(payload_attrs.clone()).unwrap();

crates/executor/src/builder.rs

@@ -3,7 +3,7 @@
 use crate::StatelessL2BlockExecutor;
 use alloy_consensus::{Header, Sealable, Sealed};
 use anyhow::Result;
-use kona_mpt::{TrieDB, TrieDBFetcher, TrieDBHinter};
+use kona_mpt::{TrieDB, TrieHinter, TrieProvider};
 use op_alloy_genesis::RollupConfig;
 use revm::{db::State, handler::register::EvmHandler};
 
@@ -15,25 +15,25 @@ pub type KonaHandleRegister<F, H> =
 #[derive(Debug)]
 pub struct StatelessL2BlockExecutorBuilder<'a, F, H>
 where
-    F: TrieDBFetcher,
-    H: TrieDBHinter,
+    F: TrieProvider,
+    H: TrieHinter,
 {
     /// The [RollupConfig].
     config: &'a RollupConfig,
     /// The parent [Header] to begin execution from.
     parent_header: Option<Sealed<Header>>,
     /// The [KonaHandleRegister] to use during execution.
     handler_register: Option<KonaHandleRegister<F, H>>,
-    /// The [TrieDBFetcher] to fetch the state trie preimages.
+    /// The [TrieProvider] to fetch the state trie preimages.
     fetcher: Option<F>,
-    /// The [TrieDBHinter] to hint the state trie preimages.
+    /// The [TrieHinter] to hint the state trie preimages.
     hinter: Option<H>,
 }
 
 impl<'a, F, H> StatelessL2BlockExecutorBuilder<'a, F, H>
 where
-    F: TrieDBFetcher,
-    H: TrieDBHinter,
+    F: TrieProvider,
+    H: TrieHinter,
 {
     /// Instantiate a new builder with the given [RollupConfig].
     pub fn with_config(config: &'a RollupConfig) -> Self {
@@ -46,13 +46,13 @@ where
         self
     }
 
-    /// Set the [TrieDBFetcher] to fetch the state trie preimages.
-    pub fn with_fetcher(mut self, fetcher: F) -> Self {
+    /// Set the [TrieProvider] to fetch the state trie preimages.
+    pub fn with_provider(mut self, fetcher: F) -> Self {
         self.fetcher = Some(fetcher);
         self
     }
 
-    /// Set the [TrieDBHinter] to hint the state trie preimages.
+    /// Set the [TrieHinter] to hint the state trie preimages.
     pub fn with_hinter(mut self, hinter: H) -> Self {
         self.hinter = Some(hinter);
         self

crates/executor/src/canyon.rs

@@ -2,7 +2,7 @@
 
 use alloy_primitives::{address, b256, hex, Address, Bytes, B256};
 use anyhow::Result;
-use kona_mpt::{TrieDB, TrieDBFetcher, TrieDBHinter};
+use kona_mpt::{TrieDB, TrieHinter, TrieProvider};
 use op_alloy_genesis::RollupConfig;
 use revm::{
     primitives::{Account, Bytecode, HashMap},
@@ -28,8 +28,8 @@ pub(crate) fn ensure_create2_deployer_canyon<F, H>(
     timestamp: u64,
 ) -> Result<()>
 where
-    F: TrieDBFetcher,
-    H: TrieDBHinter,
+    F: TrieProvider,
+    H: TrieHinter,
 {
     // If the canyon hardfork is active at the current timestamp, and it was not active at the
     // previous block timestamp, then we need to force-deploy the create2 deployer contract.

crates/executor/src/lib.rs

@@ -12,7 +12,7 @@ use alloy_consensus::{Header, Sealable, EMPTY_OMMER_ROOT_HASH, EMPTY_ROOT_HASH};
 use alloy_eips::eip2718::{Decodable2718, Encodable2718};
 use alloy_primitives::{address, keccak256, Address, Bytes, TxKind, B256, U256};
 use anyhow::{anyhow, Result};
-use kona_mpt::{ordered_trie_with_encoder, TrieDB, TrieDBFetcher, TrieDBHinter};
+use kona_mpt::{ordered_trie_with_encoder, TrieDB, TrieHinter, TrieProvider};
 use op_alloy_consensus::{OpReceiptEnvelope, OpTxEnvelope};
 use op_alloy_genesis::RollupConfig;
 use op_alloy_rpc_types_engine::OptimismPayloadAttributes;
@@ -43,8 +43,8 @@ use util::{extract_tx_gas_limit, is_system_transaction, logs_bloom, receipt_enve
 #[derive(Debug)]
 pub struct StatelessL2BlockExecutor<'a, F, H>
 where
-    F: TrieDBFetcher,
-    H: TrieDBHinter,
+    F: TrieProvider,
+    H: TrieHinter,
 {
     /// The [RollupConfig].
     config: &'a RollupConfig,
@@ -56,8 +56,8 @@ where
 
 impl<'a, F, H> StatelessL2BlockExecutor<'a, F, H>
 where
-    F: TrieDBFetcher,
-    H: TrieDBHinter,
+    F: TrieProvider,
+    H: TrieHinter,
 {
     /// Constructs a new [StatelessL2BlockExecutorBuilder] with the given [RollupConfig].
     pub fn builder(config: &'a RollupConfig) -> StatelessL2BlockExecutorBuilder<'a, F, H> {
@@ -647,20 +647,20 @@ mod test {
     use alloy_primitives::{address, b256, hex};
     use alloy_rlp::Decodable;
     use alloy_rpc_types_engine::PayloadAttributes;
-    use kona_mpt::NoopTrieDBHinter;
+    use kona_mpt::NoopTrieHinter;
     use op_alloy_genesis::{OP_BASE_FEE_PARAMS, OP_CANYON_BASE_FEE_PARAMS};
     use serde::Deserialize;
     use std::{collections::HashMap, format};
 
-    /// A [TrieDBFetcher] implementation that fetches trie nodes and bytecode from the local
+    /// A [TrieProvider] implementation that fetches trie nodes and bytecode from the local
     /// testdata folder.
     #[derive(Deserialize)]
-    struct TestdataTrieDBFetcher {
+    struct TestdataTrieProvider {
         preimages: HashMap<B256, Bytes>,
     }
 
-    impl TestdataTrieDBFetcher {
-        /// Constructs a new [TestdataTrieDBFetcher] with the given testdata folder.
+    impl TestdataTrieProvider {
+        /// Constructs a new [TestdataTrieProvider] with the given testdata folder.
         pub(crate) fn new(testdata_folder: &str) -> Self {
             let file_name = format!("testdata/{}/output.json", testdata_folder);
             let preimages = serde_json::from_str::<HashMap<B256, Bytes>>(
@@ -671,7 +671,9 @@ mod test {
         }
     }
 
-    impl TrieDBFetcher for TestdataTrieDBFetcher {
+    impl TrieProvider for TestdataTrieProvider {
+        type Error = anyhow::Error;
+
         fn trie_node_preimage(&self, key: B256) -> Result<Bytes> {
             self.preimages
                 .get(&key)
@@ -721,8 +723,8 @@ mod test {
         // Initialize the block executor on block #120794431's post-state.
         let mut l2_block_executor = StatelessL2BlockExecutor::builder(&rollup_config)
             .with_parent_header(header.seal_slow())
-            .with_fetcher(TestdataTrieDBFetcher::new("block_120794432_exec"))
-            .with_hinter(NoopTrieDBHinter)
+            .with_provider(TestdataTrieProvider::new("block_120794432_exec"))
+            .with_hinter(NoopTrieHinter)
             .build()
             .unwrap();
 
@@ -778,8 +780,8 @@ mod test {
         // Initialize the block executor on block #121049888's post-state.
         let mut l2_block_executor = StatelessL2BlockExecutor::builder(&rollup_config)
             .with_parent_header(parent_header.seal_slow())
-            .with_fetcher(TestdataTrieDBFetcher::new("block_121049889_exec"))
-            .with_hinter(NoopTrieDBHinter)
+            .with_provider(TestdataTrieProvider::new("block_121049889_exec"))
+            .with_hinter(NoopTrieHinter)
             .build()
             .unwrap();
 
@@ -839,8 +841,8 @@ mod test {
         // Initialize the block executor on block #121003240's post-state.
         let mut l2_block_executor = StatelessL2BlockExecutor::builder(&rollup_config)
             .with_parent_header(parent_header.seal_slow())
-            .with_fetcher(TestdataTrieDBFetcher::new("block_121003241_exec"))
-            .with_hinter(NoopTrieDBHinter)
+            .with_provider(TestdataTrieProvider::new("block_121003241_exec"))
+            .with_hinter(NoopTrieHinter)
             .build()
             .unwrap();
 
@@ -907,8 +909,8 @@ mod test {
         // Initialize the block executor on block #121057302's post-state.
         let mut l2_block_executor = StatelessL2BlockExecutor::builder(&rollup_config)
             .with_parent_header(parent_header.seal_slow())
-            .with_fetcher(TestdataTrieDBFetcher::new("block_121057303_exec"))
-            .with_hinter(NoopTrieDBHinter)
+            .with_provider(TestdataTrieProvider::new("block_121057303_exec"))
+            .with_hinter(NoopTrieHinter)
             .build()
             .unwrap();
 
@@ -969,8 +971,8 @@ mod test {
         // Initialize the block executor on block #121057302's post-state.
         let mut l2_block_executor = StatelessL2BlockExecutor::builder(&rollup_config)
             .with_parent_header(parent_header.seal_slow())
-            .with_fetcher(TestdataTrieDBFetcher::new("block_121065789_exec"))
-            .with_hinter(NoopTrieDBHinter)
+            .with_provider(TestdataTrieProvider::new("block_121065789_exec"))
+            .with_hinter(NoopTrieHinter)
             .build()
             .unwrap();
 
@@ -1040,8 +1042,8 @@ mod test {
         // Initialize the block executor on block #121135703's post-state.
         let mut l2_block_executor = StatelessL2BlockExecutor::builder(&rollup_config)
             .with_parent_header(parent_header.seal_slow())
-            .with_fetcher(TestdataTrieDBFetcher::new("block_121135704_exec"))
-            .with_hinter(NoopTrieDBHinter)
+            .with_provider(TestdataTrieProvider::new("block_121135704_exec"))
+            .with_hinter(NoopTrieHinter)
             .build()
             .unwrap();
 

crates/mpt/Cargo.toml

@@ -10,8 +10,8 @@ homepage.workspace = true
 
 [dependencies]
 # General
-anyhow.workspace = true
 tracing.workspace = true
+thiserror.workspace = true
 
 # Revm + Alloy
 revm.workspace = true
@@ -22,6 +22,7 @@ alloy-trie.workspace = true
 
 [dev-dependencies]
 tokio.workspace = true
+anyhow.workspace = true
 reqwest.workspace = true
 futures.workspace = true
 tracing-subscriber.workspace = true