chore: op-revm cleanup and few docs (bluealloy#2156)

crates/handler/src/mainnet_builder.rs

@@ -1,5 +1,5 @@
 use crate::{instructions::EthInstructions, EthPrecompiles};
-use context::{BlockEnv, Cfg, CfgEnv, Context, Evm, EvmData, Journal, JournalOutput, TxEnv};
+use context::{BlockEnv, Cfg, CfgEnv, Context, Evm, EvmData, Journal, TxEnv};
 use context_interface::{Block, Database, JournalTr, Transaction};
 use database_interface::EmptyDB;
 use interpreter::interpreter::EthInterpreter;
@@ -23,7 +23,7 @@ where
     TX: Transaction,
     CFG: Cfg,
     DB: Database,
-    JOURNAL: JournalTr<Database = DB, FinalOutput = JournalOutput>,
+    JOURNAL: JournalTr<Database = DB>,
 {
     type Context = Self;
 

crates/optimism/src/api/builder.rs

@@ -1,17 +1,21 @@
-use crate::{evm::OpEvm, transaction::OpTxTr, L1BlockInfo, OpSpecId, OpTransaction};
+use crate::{evm::OpEvm, transaction::OpTxTr, L1BlockInfo, OpSpecId};
 use revm::{
-    context::{BlockEnv, Cfg, CfgEnv, JournalOutput, TxEnv},
+    context::{Cfg, JournalOutput},
     context_interface::{Block, JournalTr},
     handler::instructions::EthInstructions,
     interpreter::interpreter::EthInterpreter,
-    Context, Database, Journal,
+    Context, Database,
 };
 
+/// Trait that allows for optimism OpEvm to be built.
 pub trait OpBuilder: Sized {
+    /// Type of the context.
     type Context;
 
+    /// Build the op.
     fn build_op(self) -> OpEvm<Self::Context, (), EthInstructions<EthInterpreter, Self::Context>>;
 
+    /// Build the op with an inspector.
     fn build_op_with_inspector<INSP>(
         self,
         inspector: INSP,
@@ -39,6 +43,3 @@ where
         OpEvm::new(self, inspector)
     }
 }
-
-pub type OpContext<DB> =
-    Context<BlockEnv, OpTransaction<TxEnv>, CfgEnv<OpSpecId>, DB, Journal<DB>, L1BlockInfo>;

crates/optimism/src/api/default_ctx.rs

@@ -5,27 +5,17 @@ use revm::{
     Context, Journal, MainContext,
 };
 
+/// Type alias for the default context type of the OpEvm.
+pub type OpContext<DB> =
+    Context<BlockEnv, OpTransaction<TxEnv>, CfgEnv<OpSpecId>, DB, Journal<DB>, L1BlockInfo>;
+
+/// Trait that allows for a default context to be created.
 pub trait DefaultOp {
-    fn op() -> Context<
-        BlockEnv,
-        OpTransaction<TxEnv>,
-        CfgEnv<OpSpecId>,
-        EmptyDB,
-        Journal<EmptyDB>,
-        L1BlockInfo,
-    >;
+    /// Create a default context.
+    fn op() -> OpContext<EmptyDB>;
 }
 
-impl DefaultOp
-    for Context<
-        BlockEnv,
-        OpTransaction<TxEnv>,
-        CfgEnv<OpSpecId>,
-        EmptyDB,
-        Journal<EmptyDB>,
-        L1BlockInfo,
-    >
-{
+impl DefaultOp for OpContext<EmptyDB> {
     fn op() -> Self {
         Context::mainnet()
             .with_tx(OpTransaction::default())

crates/optimism/src/api/exec.rs

@@ -3,66 +3,62 @@ use crate::{
     OpTransactionError,
 };
 use revm::{
-    context::JournalOutput,
+    context::{setters::ContextSetters, JournalOutput},
     context_interface::{
         result::{EVMError, ExecutionResult, ResultAndState},
-        Block, Cfg, ContextTr, Database, JournalTr,
+        Cfg, ContextTr, Database, JournalTr,
     },
     handler::{instructions::EthInstructions, EthFrame, EvmTr, Handler, PrecompileProvider},
     inspector::{InspectCommitEvm, InspectEvm, Inspector, JournalExt},
     interpreter::{interpreter::EthInterpreter, InterpreterResult},
-    Context, DatabaseCommit, ExecuteCommitEvm, ExecuteEvm,
+    DatabaseCommit, ExecuteCommitEvm, ExecuteEvm,
 };
 
-impl<BLOCK, TX, CFG, DB, JOURNAL, INSP, PRECOMPILE> ExecuteEvm
-    for OpEvm<
-        Context<BLOCK, TX, CFG, DB, JOURNAL, L1BlockInfo>,
-        INSP,
-        EthInstructions<EthInterpreter, Context<BLOCK, TX, CFG, DB, JOURNAL, L1BlockInfo>>,
-        PRECOMPILE,
-    >
+// Type alias for Optimism context
+pub trait OpContextTr:
+    ContextTr<
+        Journal: JournalTr<FinalOutput = JournalOutput>,
+        Tx: OpTxTr,
+        Cfg: Cfg<Spec = OpSpecId>,
+        Chain = L1BlockInfo,
+    > + ContextSetters
+{
+}
+
+impl<T> OpContextTr for T where
+    T: ContextTr<
+            Journal: JournalTr<FinalOutput = JournalOutput>,
+            Tx: OpTxTr,
+            Cfg: Cfg<Spec = OpSpecId>,
+            Chain = L1BlockInfo,
+        > + ContextSetters
+{
+}
+
+/// Type alias for the error type of the OpEvm.
+type OpError<CTX> = EVMError<<<CTX as ContextTr>::Db as Database>::Error, OpTransactionError>;
+
+impl<CTX, INSP, PRECOMPILE> ExecuteEvm
+    for OpEvm<CTX, INSP, EthInstructions<EthInterpreter, CTX>, PRECOMPILE>
 where
-    BLOCK: Block,
-    TX: OpTxTr,
-    CFG: Cfg<Spec = OpSpecId>,
-    DB: Database,
-    JOURNAL: JournalTr<Database = DB, FinalOutput = JournalOutput>,
-    PRECOMPILE: PrecompileProvider<
-        Context = Context<BLOCK, TX, CFG, DB, JOURNAL, L1BlockInfo>,
-        Output = InterpreterResult,
-    >,
+    CTX: OpContextTr,
+    PRECOMPILE: PrecompileProvider<Context = CTX, Output = InterpreterResult>,
 {
-    type Output =
-        Result<ResultAndState<OpHaltReason>, EVMError<<DB as Database>::Error, OpTransactionError>>;
+    type Output = Result<ResultAndState<OpHaltReason>, OpError<CTX>>;
 
     fn replay(&mut self) -> Self::Output {
         let mut h = OpHandler::<_, _, EthFrame<_, _, _>>::new();
         h.run(self)
     }
 }
 
-impl<BLOCK, TX, CFG, DB, JOURNAL, INSP, PRECOMPILE> ExecuteCommitEvm
-    for OpEvm<
-        Context<BLOCK, TX, CFG, DB, JOURNAL, L1BlockInfo>,
-        INSP,
-        EthInstructions<EthInterpreter, Context<BLOCK, TX, CFG, DB, JOURNAL, L1BlockInfo>>,
-        PRECOMPILE,
-    >
+impl<CTX, INSP, PRECOMPILE> ExecuteCommitEvm
+    for OpEvm<CTX, INSP, EthInstructions<EthInterpreter, CTX>, PRECOMPILE>
 where
-    BLOCK: Block,
-    TX: OpTxTr,
-    CFG: Cfg<Spec = OpSpecId>,
-    DB: Database + DatabaseCommit,
-    JOURNAL: JournalTr<Database = DB, FinalOutput = JournalOutput> + JournalExt,
-    PRECOMPILE: PrecompileProvider<
-        Context = Context<BLOCK, TX, CFG, DB, JOURNAL, L1BlockInfo>,
-        Output = InterpreterResult,
-    >,
+    CTX: OpContextTr<Db: DatabaseCommit>,
+    PRECOMPILE: PrecompileProvider<Context = CTX, Output = InterpreterResult>,
 {
-    type CommitOutput = Result<
-        ExecutionResult<OpHaltReason>,
-        EVMError<<DB as Database>::Error, OpTransactionError>,
-    >;
+    type CommitOutput = Result<ExecutionResult<OpHaltReason>, OpError<CTX>>;
 
     fn replay_commit(&mut self) -> Self::CommitOutput {
         self.replay().map(|r| {
@@ -72,24 +68,12 @@ where
     }
 }
 
-impl<BLOCK, TX, CFG, DB, JOURNAL, INSP, PRECOMPILE> InspectEvm
-    for OpEvm<
-        Context<BLOCK, TX, CFG, DB, JOURNAL, L1BlockInfo>,
-        INSP,
-        EthInstructions<EthInterpreter, Context<BLOCK, TX, CFG, DB, JOURNAL, L1BlockInfo>>,
-        PRECOMPILE,
-    >
+impl<CTX, INSP, PRECOMPILE> InspectEvm
+    for OpEvm<CTX, INSP, EthInstructions<EthInterpreter, CTX>, PRECOMPILE>
 where
-    BLOCK: Block,
-    TX: OpTxTr,
-    CFG: Cfg<Spec = OpSpecId>,
-    DB: Database,
-    JOURNAL: JournalTr<Database = DB, FinalOutput = JournalOutput> + JournalExt,
-    INSP: Inspector<Context<BLOCK, TX, CFG, DB, JOURNAL, L1BlockInfo>, EthInterpreter>,
-    PRECOMPILE: PrecompileProvider<
-        Context = Context<BLOCK, TX, CFG, DB, JOURNAL, L1BlockInfo>,
-        Output = InterpreterResult,
-    >,
+    CTX: OpContextTr<Journal: JournalExt>,
+    INSP: Inspector<CTX, EthInterpreter>,
+    PRECOMPILE: PrecompileProvider<Context = CTX, Output = InterpreterResult>,
 {
     type Inspector = INSP;
 
@@ -103,24 +87,12 @@ where
     }
 }
 
-impl<BLOCK, TX, CFG, DB, JOURNAL, INSP, PRECOMPILE> InspectCommitEvm
-    for OpEvm<
-        Context<BLOCK, TX, CFG, DB, JOURNAL, L1BlockInfo>,
-        INSP,
-        EthInstructions<EthInterpreter, Context<BLOCK, TX, CFG, DB, JOURNAL, L1BlockInfo>>,
-        PRECOMPILE,
-    >
+impl<CTX, INSP, PRECOMPILE> InspectCommitEvm
+    for OpEvm<CTX, INSP, EthInstructions<EthInterpreter, CTX>, PRECOMPILE>
 where
-    BLOCK: Block,
-    TX: OpTxTr,
-    CFG: Cfg<Spec = OpSpecId>,
-    DB: Database + DatabaseCommit,
-    JOURNAL: JournalTr<Database = DB, FinalOutput = JournalOutput> + JournalExt,
-    INSP: Inspector<Context<BLOCK, TX, CFG, DB, JOURNAL, L1BlockInfo>, EthInterpreter>,
-    PRECOMPILE: PrecompileProvider<
-        Context = Context<BLOCK, TX, CFG, DB, JOURNAL, L1BlockInfo>,
-        Output = InterpreterResult,
-    >,
+    CTX: OpContextTr<Journal: JournalExt, Db: DatabaseCommit>,
+    INSP: Inspector<CTX, EthInterpreter>,
+    PRECOMPILE: PrecompileProvider<Context = CTX, Output = InterpreterResult>,
 {
     fn inspect_commit_previous(&mut self) -> Self::CommitOutput {
         self.inspect_previous().map(|r| {

crates/optimism/src/evm.rs

@@ -1,3 +1,4 @@
+use crate::precompiles::OpPrecompileProvider;
 use revm::{
     context::{setters::ContextSetters, Evm, EvmData},
     context_interface::ContextTr,
@@ -10,8 +11,6 @@ use revm::{
     },
 };
 
-use crate::handler::precompiles::OpPrecompileProvider;
-
 pub struct OpEvm<CTX, INSP, I = EthInstructions<EthInterpreter, CTX>, P = OpPrecompileProvider<CTX>>(
     pub Evm<CTX, INSP, I, P>,
 );

crates/optimism/src/handler.rs

@@ -1,8 +1,6 @@
 //!Handler related to Optimism chain
-
-pub mod precompiles;
-
 use crate::{
+    api::exec::OpContextTr,
     constants::{BASE_FEE_RECIPIENT, L1_FEE_RECIPIENT, OPERATOR_FEE_RECIPIENT},
     transaction::{
         deposit::{DepositTransaction, DEPOSIT_TRANSACTION_TYPE},
@@ -11,7 +9,6 @@ use crate::{
     L1BlockInfo, OpHaltReason, OpSpecId,
 };
 use revm::{
-    context::JournalOutput,
     context_interface::{
         result::{EVMError, ExecutionResult, FromStringError, ResultAndState},
         Block, Cfg, ContextTr, JournalTr, Transaction,
@@ -60,14 +57,7 @@ impl<DB, TX> IsTxError for EVMError<DB, TX> {
 
 impl<EVM, ERROR, FRAME> Handler for OpHandler<EVM, ERROR, FRAME>
 where
-    EVM: EvmTr<
-        Context: ContextTr<
-            Journal: JournalTr<FinalOutput = JournalOutput>,
-            Tx: OpTxTr,
-            Cfg: Cfg<Spec = OpSpecId>,
-            Chain = L1BlockInfo,
-        >,
-    >,
+    EVM: EvmTr<Context: OpContextTr>,
     ERROR: EvmTrError<EVM> + From<OpTransactionError> + FromStringError + IsTxError,
     // TODO `FrameResult` should be a generic trait.
     // TODO `FrameInit` should be a generic.
@@ -461,12 +451,7 @@ where
 impl<EVM, ERROR, FRAME> InspectorHandler for OpHandler<EVM, ERROR, FRAME>
 where
     EVM: InspectorEvmTr<
-        Context: ContextTr<
-            Journal: JournalTr<FinalOutput = JournalOutput>,
-            Tx: OpTxTr,
-            Cfg: Cfg<Spec = OpSpecId>,
-            Chain = L1BlockInfo,
-        >,
+        Context: OpContextTr,
         Inspector: Inspector<<<Self as Handler>::Evm as EvmTr>::Context, EthInterpreter>,
     >,
     ERROR: EvmTrError<EVM> + From<OpTransactionError> + FromStringError + IsTxError,
@@ -486,7 +471,7 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{DefaultOp, OpBuilder, OpContext};
+    use crate::{api::default_ctx::OpContext, DefaultOp, OpBuilder};
     use revm::{
         context::Context,
         context_interface::result::InvalidTransaction,