Better trap handling

interpreter/src/call_create.rs

@@ -2,11 +2,12 @@
 
 use crate::utils::{h256_to_u256, u256_to_usize};
 use crate::{
-	Context, ExitError, ExitException, ExitResult, Machine, Memory, Opcode, RuntimeBackend,
-	RuntimeState, Transfer,
+	Context, ExitError, ExitException, ExitResult, Machine, Memory, RuntimeBackend, RuntimeState,
+	Transfer, TrapConstruct, TrapConsume,
 };
 use alloc::vec::Vec;
 use core::cmp::{max, min};
+use core::convert::Infallible;
 use primitive_types::{H160, H256, U256};
 use sha3::{Digest, Keccak256};
 
@@ -75,6 +76,29 @@ pub enum CallScheme {
 	StaticCall,
 }
 
+pub enum CallCreateTrap {
+	Create,
+	Create2,
+	Call,
+	CallCode,
+	DelegateCall,
+	StaticCall,
+}
+
+impl TrapConstruct<CallCreateTrap> for CallCreateTrap {
+	fn construct(v: CallCreateTrap) -> Self {
+		v
+	}
+}
+
+impl TrapConsume<CallCreateTrap> for CallCreateTrap {
+	type Rest = Infallible;
+
+	fn consume(self) -> Result<CallCreateTrap, Infallible> {
+		Ok(self)
+	}
+}
+
 /// Combined call create trap data.
 pub enum CallCreateTrapData {
 	/// A call trap data.
@@ -92,29 +116,28 @@ impl CallCreateTrapData {
 	}
 
 	pub fn new_from<S: AsRef<RuntimeState> + AsMut<RuntimeState>>(
-		opcode: Opcode,
+		opcode: CallCreateTrap,
 		machine: &mut Machine<S>,
 	) -> Result<Self, ExitError> {
 		match opcode {
-			Opcode::CREATE => Ok(Self::Create(CreateTrapData::new_create_from(machine)?)),
-			Opcode::CREATE2 => Ok(Self::Create(CreateTrapData::new_create2_from(machine)?)),
-			Opcode::CALL => Ok(Self::Call(CallTrapData::new_from(
+			CallCreateTrap::Create => Ok(Self::Create(CreateTrapData::new_create_from(machine)?)),
+			CallCreateTrap::Create2 => Ok(Self::Create(CreateTrapData::new_create2_from(machine)?)),
+			CallCreateTrap::Call => Ok(Self::Call(CallTrapData::new_from(
 				CallScheme::Call,
 				machine,
 			)?)),
-			Opcode::CALLCODE => Ok(Self::Call(CallTrapData::new_from(
+			CallCreateTrap::CallCode => Ok(Self::Call(CallTrapData::new_from(
 				CallScheme::CallCode,
 				machine,
 			)?)),
-			Opcode::DELEGATECALL => Ok(Self::Call(CallTrapData::new_from(
+			CallCreateTrap::DelegateCall => Ok(Self::Call(CallTrapData::new_from(
 				CallScheme::DelegateCall,
 				machine,
 			)?)),
-			Opcode::STATICCALL => Ok(Self::Call(CallTrapData::new_from(
+			CallCreateTrap::StaticCall => Ok(Self::Call(CallTrapData::new_from(
 				CallScheme::StaticCall,
 				machine,
 			)?)),
-			_ => Err(ExitException::InvalidOpcode(opcode).into()),
 		}
 	}
 

interpreter/src/etable.rs

@@ -1,6 +1,6 @@
 use crate::{
-	eval::*, CallCreateTrap, ExitResult, GasState, Machine, Opcode, RuntimeBackend,
-	RuntimeEnvironment, RuntimeState,
+	call_create::CallCreateTrap, eval::*, ExitResult, GasState, Machine, Opcode, RuntimeBackend,
+	RuntimeEnvironment, RuntimeState, TrapConstruct,
 };
 use core::marker::PhantomData;
 use core::ops::{Deref, DerefMut};
@@ -236,7 +236,7 @@ impl<S, H, Tr> Etable<S, H, Tr> {
 	}
 }
 
-impl<S, H: RuntimeEnvironment + RuntimeBackend, Tr: CallCreateTrap> Etable<S, H, Tr>
+impl<S, H: RuntimeEnvironment + RuntimeBackend, Tr: TrapConstruct<CallCreateTrap>> Etable<S, H, Tr>
 where
 	S: AsRef<RuntimeState> + GasState,
 {

interpreter/src/eval/mod.rs

@@ -6,8 +6,8 @@ mod misc;
 mod system;
 
 use crate::{
-	CallCreateTrap, Control, ExitException, ExitSucceed, GasState, Machine, Opcode, RuntimeBackend,
-	RuntimeEnvironment, RuntimeState,
+	call_create::CallCreateTrap, Control, ExitException, ExitSucceed, GasState, Machine, Opcode,
+	RuntimeBackend, RuntimeEnvironment, RuntimeState, TrapConstruct,
 };
 use core::ops::{BitAnd, BitOr, BitXor};
 use primitive_types::{H256, U256};
@@ -1272,11 +1272,21 @@ pub fn eval_basefee<S: AsRef<RuntimeState>, H: RuntimeEnvironment + RuntimeBacke
 	self::system::basefee(machine, handle)
 }
 
-pub fn eval_call_create_trap<S, H, Tr: CallCreateTrap>(
+pub fn eval_call_create_trap<S, H, Tr: TrapConstruct<CallCreateTrap>>(
 	_machine: &mut Machine<S>,
 	_handle: &mut H,
 	opcode: Opcode,
 	_position: usize,
 ) -> Control<Tr> {
-	Control::Trap(Tr::call_create_trap(opcode))
+	let trap = match opcode {
+		Opcode::CREATE => CallCreateTrap::Create,
+		Opcode::CREATE2 => CallCreateTrap::Create2,
+		Opcode::CALL => CallCreateTrap::Call,
+		Opcode::CALLCODE => CallCreateTrap::CallCode,
+		Opcode::DELEGATECALL => CallCreateTrap::DelegateCall,
+		Opcode::STATICCALL => CallCreateTrap::StaticCall,
+		_ => return Control::Exit(Err(ExitException::InvalidOpcode(opcode).into())),
+	};
+
+	Control::Trap(Tr::construct(trap))
 }

interpreter/src/lib.rs

@@ -15,6 +15,7 @@ mod memory;
 mod opcode;
 mod runtime;
 mod stack;
+mod trap;
 pub mod utils;
 mod valids;
 
@@ -24,10 +25,11 @@ pub use crate::interpreter::{EtableInterpreter, Interpreter, StepInterpreter};
 pub use crate::memory::Memory;
 pub use crate::opcode::Opcode;
 pub use crate::runtime::{
-	CallCreateTrap, Context, GasState, Log, RuntimeBackend, RuntimeBaseBackend, RuntimeEnvironment,
-	RuntimeState, TransactionContext, Transfer,
+	Context, GasState, Log, RuntimeBackend, RuntimeBaseBackend, RuntimeEnvironment, RuntimeState,
+	TransactionContext, Transfer,
 };
 pub use crate::stack::Stack;
+pub use crate::trap::{TrapConstruct, TrapConsume};
 pub use crate::valids::Valids;
 
 use alloc::rc::Rc;

interpreter/src/runtime.rs

@@ -1,4 +1,4 @@
-use crate::{ExitError, Opcode};
+use crate::ExitError;
 use alloc::rc::Rc;
 use alloc::vec::Vec;
 use primitive_types::{H160, H256, U256};
@@ -75,16 +75,6 @@ pub struct Log {
 	pub data: Vec<u8>,
 }
 
-pub trait CallCreateTrap: Sized {
-	fn call_create_trap(opcode: Opcode) -> Self;
-}
-
-impl CallCreateTrap for Opcode {
-	fn call_create_trap(opcode: Opcode) -> Self {
-		opcode
-	}
-}
-
 pub trait RuntimeEnvironment {
 	/// Get environmental block hash.
 	fn block_hash(&self, number: U256) -> H256;

interpreter/src/trap.rs

@@ -0,0 +1,9 @@
+pub trait TrapConstruct<T> {
+	fn construct(v: T) -> Self;
+}
+
+pub trait TrapConsume<T> {
+	type Rest;
+
+	fn consume(self) -> Result<T, Self::Rest>;
+}

interpreter/tests/usability.rs

@@ -1,7 +1,7 @@
 use evm_interpreter::{
-	Capture, Context, Control, Etable, EtableInterpreter, ExitError, ExitSucceed, Interpreter, Log,
-	Machine, Opcode, RuntimeBackend, RuntimeBaseBackend, RuntimeEnvironment, RuntimeState,
-	TransactionContext,
+	call_create::CallCreateTrap, Capture, Context, Control, Etable, EtableInterpreter, ExitError,
+	ExitSucceed, Interpreter, Log, Machine, Opcode, RuntimeBackend, RuntimeBaseBackend,
+	RuntimeEnvironment, RuntimeState, TransactionContext,
 };
 use primitive_types::{H160, H256, U256};
 use std::rc::Rc;
@@ -167,7 +167,8 @@ impl RuntimeBackend for UnimplementedHandler {
 	}
 }
 
-static RUNTIME_ETABLE: Etable<RuntimeState, UnimplementedHandler, Opcode> = Etable::runtime();
+static RUNTIME_ETABLE: Etable<RuntimeState, UnimplementedHandler, CallCreateTrap> =
+	Etable::runtime();
 
 #[test]
 fn etable_runtime() {

src/standard/invoker/mod.rs

@@ -6,11 +6,13 @@ pub use self::resolver::{EtableResolver, PrecompileSet, Resolver};
 pub use self::state::InvokerState;
 
 use super::Config;
-use crate::call_create::{CallCreateTrapData, CallTrapData, CreateScheme, CreateTrapData};
+use crate::call_create::{
+	CallCreateTrap, CallCreateTrapData, CallTrapData, CreateScheme, CreateTrapData,
+};
 use crate::{
 	Capture, Context, ExitError, ExitException, ExitResult, ExitSucceed, Interpreter,
 	Invoker as InvokerT, InvokerControl, MergeStrategy, Opcode, RuntimeBackend, RuntimeEnvironment,
-	RuntimeState, TransactionContext, TransactionalBackend, Transfer,
+	RuntimeState, TransactionContext, TransactionalBackend, Transfer, TrapConsume,
 };
 use alloc::rc::Rc;
 use alloc::vec::Vec;
@@ -164,10 +166,10 @@ where
 	S: InvokerState<'config> + AsRef<RuntimeState> + AsMut<RuntimeState>,
 	H: RuntimeEnvironment + RuntimeBackend + TransactionalBackend,
 	R: Resolver<S, H, Tr>,
-	Tr: IntoCallCreateTrap,
+	Tr: TrapConsume<CallCreateTrap>,
 {
 	type Interpreter = R::Interpreter;
-	type Interrupt = Tr::Interrupt;
+	type Interrupt = Tr::Rest;
 	type TransactArgs = TransactArgs;
 	type TransactInvoke = TransactInvoke;
 	type TransactValue = (ExitSucceed, Option<H160>);
@@ -407,7 +409,7 @@ where
 			gas - gas / U256::from(64)
 		}
 
-		let opcode = match trap.into_call_create_trap() {
+		let opcode = match trap.consume() {
 			Ok(opcode) => opcode,
 			Err(interrupt) => return Capture::Trap(interrupt),
 		};

src/standard/mod.rs

@@ -22,11 +22,11 @@ use primitive_types::{H160, H256, U256};
 pub type Machine<'config> = crate::Machine<State<'config>>;
 
 /// Standard Etable opcode handle function.
-pub type Efn<'config, H> = crate::Efn<State<'config>, H, crate::Opcode>;
+pub type Efn<'config, H> = crate::Efn<State<'config>, H, crate::call_create::CallCreateTrap>;
 
 /// Standard Etable.
 pub type Etable<'config, H, F = Efn<'config, H>> =
-	crate::Etable<State<'config>, H, crate::Opcode, F>;
+	crate::Etable<State<'config>, H, crate::call_create::CallCreateTrap, F>;
 
 pub trait GasMutState: GasState {
 	fn record_gas(&mut self, gas: U256) -> Result<(), ExitError>;