precompile run wip

crates/revm/src/handler.rs

@@ -9,13 +9,17 @@ use context::{
 };
 // Exports.
 use mainnet::{EthExecution, EthFrame, EthPostExecution, EthPreExecution, EthValidation};
+use precompile::PrecompileErrors;
 use primitives::Log;
 use state::EvmState;
 pub use wires::*;
 
 // Includes.
 
-use interpreter::{interpreter::EthInterpreter, Host};
+use interpreter::{
+    interpreter::{EthInstructionProvider, EthInterpreter},
+    Host,
+};
 //use register::{EvmHandler, HandleRegisters};
 use std::vec::Vec;
 use wiring::{
@@ -66,7 +70,10 @@ where
         + ErrorGetter<Error = ERROR>
         + JournalStateGetter<Journal: JournaledState<FinalOutput = (EvmState, Vec<Log>)>>
         + Host,
-    ERROR: From<InvalidTransaction> + From<InvalidHeader> + From<JournalStateGetterDBError<CTX>>,
+    ERROR: From<InvalidTransaction>
+        + From<InvalidHeader>
+        + From<JournalStateGetterDBError<CTX>>
+        + From<PrecompileErrors>,
 {
     type Validation = <EthHand<CTX, ERROR> as Handler>::Validation;
     type PreExecution = <EthHand<CTX, ERROR> as Handler>::PreExecution;
@@ -100,7 +107,10 @@ where
         + ErrorGetter<Error = ERROR>
         + JournalStateGetter<Journal: JournaledState<FinalOutput = (EvmState, Vec<Log>)>>
         + Host,
-    ERROR: From<InvalidTransaction> + From<InvalidHeader> + From<JournalStateGetterDBError<CTX>>,
+    ERROR: From<InvalidTransaction>
+        + From<InvalidHeader>
+        + From<JournalStateGetterDBError<CTX>>
+        + From<PrecompileErrors>,
     VAL: ValidationWire,
     PREEXEC: PreExecutionWire,
     EXEC: ExecutionWire,
@@ -145,15 +155,25 @@ pub struct EEVM<ERROR, CTX = Context> {
 
 pub type EthContext<DB> = Context<BlockEnv, TxEnv, DB, ()>;
 
-pub type NEW_PRECOMPILE<DB, ERROR> = GEVM<
+pub type NEW_PRECOMPILE<DB, ERROR, PRECOMPILE> = GEVM<
     ERROR,
     EthContext<DB>,
     EthHand<
         EthContext<DB>,
         ERROR,
         EthValidation<EthContext<DB>, ERROR>,
         EthPreExecution<EthContext<DB>, ERROR>,
-        EthExecution<EthContext<DB>, ERROR>,
+        EthExecution<
+            EthContext<DB>,
+            ERROR,
+            EthFrame<
+                EthContext<DB>,
+                ERROR,
+                EthInterpreter<()>,
+                PRECOMPILE,
+                EthInstructionProvider<EthInterpreter<()>, EthContext<DB>>,
+            >,
+        >,
     >,
 >;
 
@@ -171,7 +191,10 @@ where
                 Database = <CTX as DatabaseGetter>::Database,
             >,
         > + Host,
-    ERROR: From<InvalidTransaction> + From<InvalidHeader> + From<JournalStateGetterDBError<CTX>>,
+    ERROR: From<InvalidTransaction>
+        + From<InvalidHeader>
+        + From<JournalStateGetterDBError<CTX>>
+        + From<PrecompileErrors>,
 {
     // TODO
     // transact_commit (needs DatabaseCommit requirement)
@@ -248,11 +271,6 @@ where
         // load access list and beneficiary if needed.
         pre_exec.load_accounts(ctx)?;
 
-        // load precompiles
-        let precompiles = pre_exec.load_precompiles();
-        // TODO SET PRECOMPILE
-        //ctx.evm.set_precompiles(precompiles);
-
         // deduce caller balance with its limit.
         pre_exec.deduct_caller(ctx)?;
 

crates/revm/src/handler/mainnet/execution.rs

@@ -1,34 +1,30 @@
 use super::{frame_data::FrameResult, EthFrame};
 use crate::handler::{
     wires::Frame as FrameTrait, EthPrecompileProvider, ExecutionWire, FrameOrResultGen,
-    PrecompileProvider,
 };
 use bytecode::EOF_MAGIC_BYTES;
 use context::{
     BlockGetter, CfgGetter, ErrorGetter, JournalStateGetter, JournalStateGetterDBError,
     TransactionGetter,
 };
-use core::cell::RefCell;
 use interpreter::{
     interpreter::{EthInstructionProvider, EthInterpreter},
     return_ok, return_revert, CallInputs, CallScheme, CallValue, CreateInputs, CreateScheme,
-    EOFCreateInputs, EOFCreateKind, Gas, NewFrameAction, SharedMemory,
+    EOFCreateInputs, EOFCreateKind, Gas, NewFrameAction,
 };
-use precompile::PrecompileSpecId;
 use primitives::TxKind;
 use specification::hardfork::SpecId;
-use std::{boxed::Box, rc::Rc};
-use wiring::{journaled_state::JournaledState, result::InvalidTransaction, Cfg, Transaction};
+use std::boxed::Box;
+use wiring::{result::InvalidTransaction, Cfg, Transaction};
 
-/// TODO EvmWiringT is temporary, replace it with getter traits.
 pub struct EthExecution<
     CTX,
     ERROR,
     FRAME = EthFrame<
         CTX,
         ERROR,
         EthInterpreter<()>,
-        EthPrecompileProvider<CTX>,
+        EthPrecompileProvider<CTX, ERROR>,
         EthInstructionProvider<EthInterpreter<()>, CTX>,
     >,
 > {
@@ -61,14 +57,6 @@ where
         gas_limit: u64,
     ) -> Result<FrameOrResultGen<Self::Frame, <Self::Frame as FrameTrait>::FrameResult>, Self::Error>
     {
-        // TODO do this in frame
-        // self.precompiles
-        //     .set_spec_id(PrecompileSpecId::from_spec_id(self.spec_id));
-        // // wamr up precompile address.
-        // for address in self.precompiles.warm_addresses() {
-        //     context.journal().warm_account(address);
-        // }
-
         // Make new frame action.
         let spec = context.cfg().spec().into();
         let tx = context.tx();

crates/revm/src/handler/mainnet/frame.rs

@@ -18,7 +18,7 @@ use interpreter::{
     InterpreterWire, MemoryGetter, NewFrameAction, NewInterpreter, SharedMemory,
     EMPTY_SHARED_MEMORY,
 };
-use precompile::Precompiles;
+use precompile::{PrecompileErrors, Precompiles};
 use primitives::{keccak256, Address, Bytes, B256, U256};
 use specification::{
     constants::CALL_STACK_LIMIT,
@@ -126,8 +126,8 @@ where
         + BlockGetter
         + JournalStateGetter
         + CfgGetter,
-    //IW = ,
-    ERROR: From<JournalStateGetterDBError<CTX>>,
+    PRECOMPILE: PrecompileProvider<Context = CTX, Error = ERROR>,
+    ERROR: From<JournalStateGetterDBError<CTX>> + From<PrecompileErrors>,
 {
     /// Make call frame
     #[inline]
@@ -187,72 +187,83 @@ where
             _ => {}
         };
         // TODO
-        // if let Some(result) = ctx.call_precompile(&inputs.bytecode_address, &inputs.input, gas)? {
-        //     if result.result.is_ok() {
-        //         self.journaled_state.checkpoint_commit();
-        //     } else {
-        //         self.journaled_state.checkpoint_revert(checkpoint);
-        //     }
-        //     Ok(FrameOrResult::new_call_result(
-        //         result,
-        //         inputs.return_memory_offset.clone(),
-        //     ))
-        // } else {
-        let account = ctx.journal().load_account_code(inputs.bytecode_address)?;
-
-        let code_hash = account.info.code_hash();
-        let mut bytecode = account.info.code.clone().unwrap_or_default();
-
-        // ExtDelegateCall is not allowed to call non-EOF contracts.
-        if inputs.scheme.is_ext_delegate_call()
-            && !bytecode.bytes_slice().starts_with(&EOF_MAGIC_BYTES)
-        {
-            return return_result(InstructionResult::InvalidExtDelegateCallTarget);
-        }
+        if let Some(result) = precompile.run(
+            ctx,
+            &inputs.bytecode_address,
+            &inputs.input,
+            inputs.gas_limit,
+        ) {
+            let result = result?;
+            if result.result.is_ok() {
+                ctx.journal().checkpoint_commit();
+            } else {
+                ctx.journal().checkpoint_revert(checkpoint);
+            }
+            Ok(FrameOrResultGen::Result(FrameResult::Call(CallOutcome {
+                result: InterpreterResult {
+                    result: result,
+                    gas,
+                    output: Bytes::new(),
+                },
+                memory_offset,
+            })))
+        } else {
+            let account = ctx.journal().load_account_code(inputs.bytecode_address)?;
 
-        if bytecode.is_empty() {
-            ctx.journal().checkpoint_commit();
-            return return_result(InstructionResult::Stop);
-        }
+            let code_hash = account.info.code_hash();
+            let mut bytecode = account.info.code.clone().unwrap_or_default();
 
-        if let Bytecode::Eip7702(eip7702_bytecode) = bytecode {
-            bytecode = ctx
-                .journal()
-                .load_account_code(eip7702_bytecode.delegated_address)?
-                .info
-                .code
-                .clone()
-                .unwrap_or_default();
-        }
+            // ExtDelegateCall is not allowed to call non-EOF contracts.
+            if inputs.scheme.is_ext_delegate_call()
+                && !bytecode.bytes_slice().starts_with(&EOF_MAGIC_BYTES)
+            {
+                return return_result(InstructionResult::InvalidExtDelegateCallTarget);
+            }
 
-        //let contract =
-        //    Contract::new_with_context(inputs.input.clone(), bytecode, Some(code_hash), inputs);
-        // Create interpreter and executes call and push new CallStackFrame.
-        let interpreter_input = InputsImpl {
-            target_address: inputs.target_address,
-            caller_address: inputs.caller,
-            input: inputs.input.clone(),
-            call_value: inputs.value.get(),
-        };
+            if bytecode.is_empty() {
+                ctx.journal().checkpoint_commit();
+                return return_result(InstructionResult::Stop);
+            }
 
-        Ok(FrameOrResultGen::Frame(Self::new(
-            FrameData::Call(CallFrame {
-                return_memory_range: inputs.return_memory_offset.clone(),
-            }),
-            NewInterpreter::new(
-                memory.clone(),
-                bytecode,
-                interpreter_input,
-                inputs.is_static,
-                false,
-                ctx.cfg().spec().into(),
-                inputs.gas_limit,
-            ),
-            checkpoint,
-            precompile,
-            instructions,
-            memory,
-        )))
+            if let Bytecode::Eip7702(eip7702_bytecode) = bytecode {
+                bytecode = ctx
+                    .journal()
+                    .load_account_code(eip7702_bytecode.delegated_address)?
+                    .info
+                    .code
+                    .clone()
+                    .unwrap_or_default();
+            }
+
+            //let contract =
+            //    Contract::new_with_context(inputs.input.clone(), bytecode, Some(code_hash), inputs);
+            // Create interpreter and executes call and push new CallStackFrame.
+            let interpreter_input = InputsImpl {
+                target_address: inputs.target_address,
+                caller_address: inputs.caller,
+                input: inputs.input.clone(),
+                call_value: inputs.value.get(),
+            };
+
+            Ok(FrameOrResultGen::Frame(Self::new(
+                FrameData::Call(CallFrame {
+                    return_memory_range: inputs.return_memory_offset.clone(),
+                }),
+                NewInterpreter::new(
+                    memory.clone(),
+                    bytecode,
+                    interpreter_input,
+                    inputs.is_static,
+                    false,
+                    ctx.cfg().spec().into(),
+                    inputs.gas_limit,
+                ),
+                checkpoint,
+                precompile,
+                instructions,
+                memory,
+            )))
+        }
     }
 
     /// Make create frame.
@@ -460,26 +471,6 @@ where
             return return_error(InstructionResult::CreateCollision);
         };
 
-        // let contract = Contract::new(
-        //     input.clone(),
-        //     // fine to clone as it is Bytes.
-        //     Bytecode::Eof(Arc::new(initcode.clone())),
-        //     None,
-        //     created_address,
-        //     None,
-        //     inputs.caller,
-        //     inputs.value,
-        // );
-
-        // let mut interpreter = Interpreter::new(contract, inputs.gas_limit, false);
-        // // EOF init will enable RETURNCONTRACT opcode.
-        // interpreter.set_is_eof_init();
-
-        // Ok(FrameOrResult::new_eofcreate_frame(
-        //     created_address,
-        //     checkpoint,
-        //     interpreter,
-        // ))
         let bytecode = Bytecode::new_legacy(input).into_analyzed();
 
         let interpreter_input = InputsImpl {
@@ -540,8 +531,8 @@ where
         + JournalStateGetter
         + CfgGetter
         + Host,
-    ERROR: From<JournalStateGetterDBError<CTX>>,
-    PRECOMPILE: PrecompileProvider<Context = CTX>,
+    ERROR: From<JournalStateGetterDBError<CTX>> + From<PrecompileErrors>,
+    PRECOMPILE: PrecompileProvider<Context = CTX, Error = ERROR>,
     INSTRUCTION: InstructionProvider<WIRE = EthInterpreter<()>, Host = CTX>,
 {
     type Context = CTX;
@@ -556,6 +547,12 @@ where
         let memory = Rc::new(RefCell::new(SharedMemory::new()));
         let precompiles = PRECOMPILE::new(ctx);
         let instructions = INSTRUCTION::new(ctx);
+
+        // load precompiles addresses as warm.
+        for address in precompiles.warm_addresses() {
+            ctx.journal().load_account(address)?;
+        }
+
         memory.borrow_mut().new_context();
         Self::init_with_context(0, frame_action, memory, precompiles, instructions, ctx)
     }

crates/revm/src/handler/mainnet/pre_execution.rs

@@ -40,11 +40,6 @@ where
 {
     type Context = CTX;
     type Error = ERROR;
-    type Precompiles = ();
-
-    fn load_precompiles(&self) -> Self::Precompiles {
-        todo!()
-    }
 
     fn load_accounts(&self, context: &mut Self::Context) -> Result<(), Self::Error> {
         // set journaling state flag.