feat: v78

Cargo.toml

@@ -6,9 +6,9 @@ license = "MIT OR Apache-2.0"
 
 [dependencies]
 # revm
-revm = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v74", default-features = false, features = ["secp256r1", "enable_eip7702", "enable_eip7623"] }
-revm-primitives = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v74", default-features = false }
-revm-inspector = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v74", default-features = false }
+revm = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v78", default-features = false, features = ["enable_eip7702", "enable_eip7623"] }
+revm-primitives = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v78", default-features = false }
+revm-inspector = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v78", default-features = false }
 
 # misc
 auto_impl = "1.2.0"

src/builder.rs

@@ -4,10 +4,11 @@ use crate::{
 };
 
 use revm::{
-    context::{BlockEnv, Cfg, CfgEnv, JournalOutput, JournalTr, TxEnv},
+    context::{BlockEnv, Cfg, CfgEnv, JournalTr, TxEnv},
     context_interface::Block,
     database::EmptyDB,
     interpreter::interpreter::EthInterpreter,
+    state::EvmState,
     Context, Database, Journal, MainContext,
 };
 
@@ -31,7 +32,7 @@ where
     TX: ScrollTxTr,
     CFG: Cfg<Spec = ScrollSpecId>,
     DB: Database,
-    JOURNAL: JournalTr<Database = DB, FinalOutput = JournalOutput>,
+    JOURNAL: JournalTr<Database = DB, State = EvmState>,
 {
     type Context = Self;
 

src/evm.rs

@@ -1,10 +1,15 @@
-use crate::{instructions::ScrollInstructions, precompile::ScrollPrecompileProvider};
+use crate::{
+    exec::ScrollContextTr, instructions::ScrollInstructions, precompile::ScrollPrecompileProvider,
+};
 
-use crate::exec::ScrollContextTr;
 use revm::{
-    context::{Cfg, ContextSetters, ContextTr, Evm},
-    handler::{instructions::InstructionProvider, EvmTr, PrecompileProvider},
-    interpreter::{interpreter::EthInterpreter, Interpreter, InterpreterAction, InterpreterTypes},
+    context::{Cfg, ContextError, ContextSetters, ContextTr, Evm, FrameStack},
+    handler::{
+        instructions::InstructionProvider, EthFrame, EvmTr, FrameInitOrResult, FrameTr,
+        ItemOrResult, PrecompileProvider,
+    },
+    interpreter::{interpreter::EthInterpreter, InterpreterResult},
+    Database,
 };
 use revm_inspector::{Inspector, InspectorEvmTr, JournalExt};
 
@@ -14,7 +19,8 @@ pub struct ScrollEvm<
     INSP,
     I = ScrollInstructions<EthInterpreter, CTX>,
     P = ScrollPrecompileProvider,
->(pub Evm<CTX, INSP, I, P>);
+    F = EthFrame<EthInterpreter>,
+>(pub Evm<CTX, INSP, I, P, F>);
 
 impl<CTX: ScrollContextTr, INSP>
     ScrollEvm<CTX, INSP, ScrollInstructions<EthInterpreter, CTX>, ScrollPrecompileProvider>
@@ -26,6 +32,7 @@ impl<CTX: ScrollContextTr, INSP>
             inspector,
             instruction: ScrollInstructions::new_mainnet(),
             precompiles: ScrollPrecompileProvider::new_with_spec(spec),
+            frame_stack: FrameStack::new(),
         })
     }
 }
@@ -50,27 +57,13 @@ impl<CTX, INSP, I, P> ScrollEvm<CTX, INSP, I, P> {
 impl<CTX, INSP, I, P> EvmTr for ScrollEvm<CTX, INSP, I, P>
 where
     CTX: ContextTr,
-    I: InstructionProvider<
-        Context = CTX,
-        InterpreterTypes: InterpreterTypes<Output = InterpreterAction>,
-    >,
-    P: PrecompileProvider<CTX>,
+    I: InstructionProvider<Context = CTX, InterpreterTypes = EthInterpreter>,
+    P: PrecompileProvider<CTX, Output = InterpreterResult>,
 {
     type Context = CTX;
     type Instructions = I;
     type Precompiles = P;
-
-    fn run_interpreter(
-        &mut self,
-        interpreter: &mut Interpreter<
-            <Self::Instructions as InstructionProvider>::InterpreterTypes,
-        >,
-    ) -> <<Self::Instructions as InstructionProvider>::InterpreterTypes as InterpreterTypes>::Output
-    {
-        let context = &mut self.0.ctx;
-        let instructions = &mut self.0.instruction;
-        interpreter.run_plain(instructions.instruction_table(), context)
-    }
+    type Frame = EthFrame<EthInterpreter>;
 
     fn ctx(&mut self) -> &mut Self::Context {
         &mut self.0.ctx
@@ -87,17 +80,49 @@ where
     fn ctx_precompiles(&mut self) -> (&mut Self::Context, &mut Self::Precompiles) {
         (&mut self.0.ctx, &mut self.0.precompiles)
     }
+
+    fn frame_stack(&mut self) -> &mut FrameStack<Self::Frame> {
+        &mut self.0.frame_stack
+    }
+
+    fn frame_init(
+        &mut self,
+        frame_input: <Self::Frame as FrameTr>::FrameInit,
+    ) -> Result<
+        ItemOrResult<&mut Self::Frame, <Self::Frame as FrameTr>::FrameResult>,
+        ContextError<<<Self::Context as ContextTr>::Db as Database>::Error>,
+    > {
+        self.0.frame_init(frame_input)
+    }
+
+    fn frame_run(
+        &mut self,
+    ) -> Result<
+        FrameInitOrResult<Self::Frame>,
+        ContextError<<<Self::Context as ContextTr>::Db as Database>::Error>,
+    > {
+        self.0.frame_run()
+    }
+
+    #[doc = " Returns the result of the frame to the caller. Frame is popped from the frame stack."]
+    #[doc = " Consumes the frame result or returns it if there is more frames to run."]
+    fn frame_return_result(
+        &mut self,
+        result: <Self::Frame as FrameTr>::FrameResult,
+    ) -> Result<
+        Option<<Self::Frame as FrameTr>::FrameResult>,
+        ContextError<<<Self::Context as ContextTr>::Db as Database>::Error>,
+    > {
+        self.0.frame_return_result(result)
+    }
 }
 
 impl<CTX, INSP, I, P> InspectorEvmTr for ScrollEvm<CTX, INSP, I, P>
 where
     CTX: ContextTr<Journal: JournalExt> + ContextSetters,
-    I: InstructionProvider<
-        Context = CTX,
-        InterpreterTypes: InterpreterTypes<Output = InterpreterAction>,
-    >,
+    I: InstructionProvider<Context = CTX, InterpreterTypes = EthInterpreter>,
+    P: PrecompileProvider<CTX, Output = InterpreterResult>,
     INSP: Inspector<CTX, I::InterpreterTypes>,
-    P: PrecompileProvider<CTX>,
 {
     type Inspector = INSP;
 
@@ -109,13 +134,15 @@ where
         (&mut self.0.ctx, &mut self.0.inspector)
     }
 
-    fn run_inspect_interpreter(
+    fn ctx_inspector_frame(
+        &mut self,
+    ) -> (&mut Self::Context, &mut Self::Inspector, &mut Self::Frame) {
+        (&mut self.0.ctx, &mut self.0.inspector, self.0.frame_stack.get())
+    }
+
+    fn ctx_inspector_frame_instructions(
         &mut self,
-        interpreter: &mut Interpreter<
-            <Self::Instructions as InstructionProvider>::InterpreterTypes,
-        >,
-    ) -> <<Self::Instructions as InstructionProvider>::InterpreterTypes as InterpreterTypes>::Output
-    {
-        self.0.run_inspect_interpreter(interpreter)
+    ) -> (&mut Self::Context, &mut Self::Inspector, &mut Self::Frame, &mut Self::Instructions) {
+        (&mut self.0.ctx, &mut self.0.inspector, self.0.frame_stack.get(), &mut self.0.instruction)
     }
 }

src/exec.rs

@@ -4,20 +4,24 @@ use crate::{
 };
 
 use revm::{
-    context::{result::HaltReason, ContextSetters, JournalOutput, JournalTr},
+    context::{
+        result::{ExecResultAndState, HaltReason},
+        ContextSetters, JournalTr,
+    },
     context_interface::{
-        result::{EVMError, ExecutionResult, ResultAndState},
+        result::{EVMError, ExecutionResult},
         Cfg, ContextTr, Database,
     },
-    handler::{EthFrame, EvmTr, Handler, PrecompileProvider},
+    handler::{EthFrame, Handler, PrecompileProvider},
     interpreter::{interpreter::EthInterpreter, InterpreterResult},
+    state::EvmState,
     DatabaseCommit, ExecuteCommitEvm, ExecuteEvm,
 };
 use revm_inspector::{InspectCommitEvm, InspectEvm, Inspector, InspectorHandler, JournalExt};
 
 pub trait ScrollContextTr:
     ContextTr<
-    Journal: JournalTr<FinalOutput = JournalOutput>,
+    Journal: JournalTr<State = EvmState>,
     Tx: ScrollTxTr,
     Cfg: Cfg<Spec = ScrollSpecId>,
     Chain = L1BlockInfo,
@@ -27,39 +31,52 @@ pub trait ScrollContextTr:
 
 impl<T> ScrollContextTr for T where
     T: ContextTr<
-        Journal: JournalTr<FinalOutput = JournalOutput>,
+        Journal: JournalTr<State = EvmState>,
         Tx: ScrollTxTr,
         Cfg: Cfg<Spec = ScrollSpecId>,
         Chain = L1BlockInfo,
     >
 {
 }
 
+/// Type alias for the error type of the ScrollEvm.
+pub type ScrollError<CTX> = EVMError<<<CTX as ContextTr>::Db as Database>::Error>;
+
 impl<CTX, INSP, PRECOMPILE> ExecuteEvm
     for ScrollEvm<CTX, INSP, ScrollInstructions<EthInterpreter, CTX>, PRECOMPILE>
 where
     CTX: ScrollContextTr + ContextSetters,
     PRECOMPILE: PrecompileProvider<CTX, Output = InterpreterResult>,
 {
-    type Output =
-        Result<ResultAndState<HaltReason>, EVMError<<<CTX as ContextTr>::Db as Database>::Error>>;
-
     type Tx = <CTX as ContextTr>::Tx;
-
     type Block = <CTX as ContextTr>::Block;
-
-    fn set_tx(&mut self, tx: Self::Tx) {
-        self.0.ctx.set_tx(tx);
-    }
+    type State = EvmState;
+    type Error = ScrollError<CTX>;
+    type ExecutionResult = ExecutionResult<HaltReason>;
 
     fn set_block(&mut self, block: Self::Block) {
         self.0.ctx.set_block(block);
     }
 
-    fn replay(&mut self) -> Self::Output {
-        let mut h = ScrollHandler::<_, _, EthFrame<_, _, _>>::new();
+    fn transact_one(&mut self, tx: Self::Tx) -> Result<Self::ExecutionResult, Self::Error> {
+        self.0.ctx.set_tx(tx);
+        let mut h = ScrollHandler::<_, _, EthFrame<EthInterpreter>>::new();
         h.run(self)
     }
+
+    fn finalize(&mut self) -> Self::State {
+        self.0.ctx.journal_mut().finalize()
+    }
+
+    fn replay(
+        &mut self,
+    ) -> Result<ExecResultAndState<Self::ExecutionResult, Self::State>, Self::Error> {
+        let mut h = ScrollHandler::<_, _, EthFrame<EthInterpreter>>::new();
+        h.run(self).map(|result| {
+            let state = self.finalize();
+            ExecResultAndState::new(result, state)
+        })
+    }
 }
 
 impl<CTX, INSP, PRECOMPILE> ExecuteCommitEvm
@@ -68,14 +85,8 @@ where
     CTX: ScrollContextTr<Db: DatabaseCommit> + ContextSetters,
     PRECOMPILE: PrecompileProvider<CTX, Output = InterpreterResult>,
 {
-    type CommitOutput =
-        Result<ExecutionResult<HaltReason>, EVMError<<<CTX as ContextTr>::Db as Database>::Error>>;
-
-    fn replay_commit(&mut self) -> Self::CommitOutput {
-        self.replay().map(|r| {
-            self.ctx().db().commit(r.state);
-            r.result
-        })
+    fn commit(&mut self, state: Self::State) {
+        self.0.ctx.db_mut().commit(state)
     }
 }
 
@@ -92,8 +103,9 @@ where
         self.0.inspector = inspector;
     }
 
-    fn inspect_replay(&mut self) -> Self::Output {
-        let mut h = ScrollHandler::<_, _, EthFrame<_, _, _>>::new();
+    fn inspect_one_tx(&mut self, tx: Self::Tx) -> Result<Self::ExecutionResult, Self::Error> {
+        self.0.ctx.set_tx(tx);
+        let mut h = ScrollHandler::<_, _, EthFrame<_>>::new();
         h.inspect_run(self)
     }
 }
@@ -105,10 +117,4 @@ where
     INSP: Inspector<CTX, EthInterpreter>,
     PRECOMPILE: PrecompileProvider<CTX, Output = InterpreterResult>,
 {
-    fn inspect_replay_commit(&mut self) -> Self::CommitOutput {
-        self.inspect_replay().map(|r| {
-            self.ctx().db().commit(r.state);
-            r.result
-        })
-    }
 }