kona_executor/executor/
builder.rs

1//! Contains the builder pattern for the [StatelessL2BlockExecutor].
2
3use super::StatelessL2BlockExecutor;
4use crate::db::{TrieDB, TrieDBProvider};
5use alloy_consensus::{Header, Sealable, Sealed};
6use kona_genesis::RollupConfig;
7use kona_mpt::TrieHinter;
8use revm::{db::State, handler::register::EvmHandler};
9
10/// A type alias for the [revm::handler::register::HandleRegister] for kona's block executor.
11pub type KonaHandleRegister<F, H> =
12    for<'i> fn(&mut EvmHandler<'i, (), &mut State<&mut TrieDB<F, H>>>);
13
14/// The builder pattern for the [StatelessL2BlockExecutor].
15#[derive(Debug)]
16pub struct StatelessL2BlockExecutorBuilder<'a, F, H>
17where
18    F: TrieDBProvider,
19    H: TrieHinter,
20{
21    /// The [RollupConfig].
22    config: &'a RollupConfig,
23    /// The [TrieDBProvider] to fetch the state trie preimages.
24    provider: F,
25    /// The [TrieHinter] to hint the state trie preimages.
26    hinter: H,
27    /// The parent [Header] to begin execution from.
28    parent_header: Option<Sealed<Header>>,
29    /// The [KonaHandleRegister] to use during execution.
30    handler_register: Option<KonaHandleRegister<F, H>>,
31}
32
33impl<'a, F, H> StatelessL2BlockExecutorBuilder<'a, F, H>
34where
35    F: TrieDBProvider,
36    H: TrieHinter,
37{
38    /// Instantiate a new builder with the given [RollupConfig].
39    pub fn new(config: &'a RollupConfig, provider: F, hinter: H) -> Self {
40        Self { config, provider, hinter, parent_header: None, handler_register: None }
41    }
42
43    /// Set the [Header] to begin execution from.
44    pub fn with_parent_header(mut self, parent_header: Sealed<Header>) -> Self {
45        self.parent_header = Some(parent_header);
46        self
47    }
48
49    /// Set the [KonaHandleRegister] for execution.
50    pub fn with_handle_register(mut self, handler_register: KonaHandleRegister<F, H>) -> Self {
51        self.handler_register = Some(handler_register);
52        self
53    }
54
55    /// Build the [StatelessL2BlockExecutor] from the builder configuration.
56    pub fn build(self) -> StatelessL2BlockExecutor<'a, F, H> {
57        let parent_header = self.parent_header.unwrap_or_else(|| {
58            let default_header = Header::default();
59            default_header.seal_slow()
60        });
61
62        let trie_db =
63            TrieDB::new(parent_header.state_root, parent_header, self.provider, self.hinter);
64        StatelessL2BlockExecutor {
65            config: self.config,
66            trie_db,
67            handler_register: self.handler_register,
68        }
69    }
70}
71
72#[cfg(test)]
73mod tests {
74    use super::*;
75    use crate::NoopTrieDBProvider;
76    use kona_mpt::NoopTrieHinter;
77
78    #[test]
79    fn test_build_full() {
80        let config = RollupConfig::default();
81        let parent_header = Header::default().seal_slow();
82
83        fn test_handler_register<F, H>(_: &mut EvmHandler<'_, (), &mut State<&mut TrieDB<F, H>>>)
84        where
85            F: TrieDBProvider,
86            H: TrieHinter,
87        {
88        }
89
90        let executor =
91            StatelessL2BlockExecutorBuilder::new(&config, NoopTrieDBProvider, NoopTrieHinter)
92                .with_handle_register(test_handler_register)
93                .build();
94
95        assert_eq!(*executor.config, config);
96        assert_eq!(*executor.trie_db.parent_block_header(), parent_header);
97    }
98}