diff --git a/interpreter/src/etable.rs b/interpreter/src/etable.rs
index 73d095123..8d38ded60 100644
--- a/interpreter/src/etable.rs
+++ b/interpreter/src/etable.rs
@@ -5,20 +5,28 @@ use crate::{
 use core::marker::PhantomData;
 use core::ops::{Deref, DerefMut};
 
-pub trait EtableSet<S, H, Tr> {
+pub trait EtableSet {
+	type State;
+	type Handle;
+	type Trap;
+
 	fn eval(
 		&self,
-		machine: &mut Machine<S>,
-		handle: &mut H,
+		machine: &mut Machine<Self::State>,
+		handle: &mut Self::Handle,
 		opcode: Opcode,
 		position: usize,
-	) -> Control<Tr>;
+	) -> Control<Self::Trap>;
 }
 
-impl<S, H, Tr, F> EtableSet<S, H, Tr> for Etable<S, H, Tr, F>
+impl<S, H, Tr, F> EtableSet for Etable<S, H, Tr, F>
 where
 	F: Fn(&mut Machine<S>, &mut H, Opcode, usize) -> Control<Tr>,
 {
+	type State = S;
+	type Handle = H;
+	type Trap = Tr;
+
 	fn eval(
 		&self,
 		machine: &mut Machine<S>,
@@ -30,11 +38,15 @@ where
 	}
 }
 
-impl<S, H, Tr, F1, F2> EtableSet<S, H, Tr> for (Etable<S, H, Tr, F1>, Etable<S, H, Tr, F2>)
+impl<S, H, Tr, F1, F2> EtableSet for (Etable<S, H, Tr, F1>, Etable<S, H, Tr, F2>)
 where
 	F1: Fn(&mut Machine<S>, &mut H, Opcode, usize) -> Control<Tr>,
 	F2: Fn(&mut Machine<S>, &mut H, Opcode, usize) -> Control<Tr>,
 {
+	type State = S;
+	type Handle = H;
+	type Trap = Tr;
+
 	fn eval(
 		&self,
 		machine: &mut Machine<S>,
diff --git a/interpreter/src/interpreter/etable.rs b/interpreter/src/interpreter/etable.rs
index 170cb81ed..6594365bb 100644
--- a/interpreter/src/interpreter/etable.rs
+++ b/interpreter/src/interpreter/etable.rs
@@ -1,20 +1,19 @@
+use crate::interpreter::{Interpreter, RunInterpreter, StepInterpreter};
 use crate::{
 	Capture, Control, EtableSet, ExitError, ExitException, ExitFatal, ExitResult, ExitSucceed,
-	Interpreter, Machine, Opcode, Stack, StepInterpreter, Valids,
+	Machine, Opcode, Stack, Valids,
 };
 use alloc::vec::Vec;
-use core::marker::PhantomData;
 use core::ops::{Deref, DerefMut};
 
-pub struct EtableInterpreter<'etable, S, H, Tr, ES> {
+pub struct EtableInterpreter<'etable, S, ES> {
 	valids: Valids,
 	position: usize,
 	machine: Machine<S>,
 	etable: &'etable ES,
-	_marker: PhantomData<(H, Tr)>,
 }
 
-impl<'etable, S, H, Tr, ES> Deref for EtableInterpreter<'etable, S, H, Tr, ES> {
+impl<'etable, S, ES> Deref for EtableInterpreter<'etable, S, ES> {
 	type Target = Machine<S>;
 
 	fn deref(&self) -> &Machine<S> {
@@ -22,15 +21,15 @@ impl<'etable, S, H, Tr, ES> Deref for EtableInterpreter<'etable, S, H, Tr, ES> {
 	}
 }
 
-impl<'etable, S, H, Tr, ES> DerefMut for EtableInterpreter<'etable, S, H, Tr, ES> {
+impl<'etable, S, ES> DerefMut for EtableInterpreter<'etable, S, ES> {
 	fn deref_mut(&mut self) -> &mut Machine<S> {
 		&mut self.machine
 	}
 }
 
-impl<'etable, S, H, Tr, ES> EtableInterpreter<'etable, S, H, Tr, ES>
+impl<'etable, S, ES> EtableInterpreter<'etable, S, ES>
 where
-	ES: EtableSet<S, H, Tr>,
+	ES: EtableSet<State = S>,
 {
 	/// Return a reference of the program counter.
 	pub const fn position(&self) -> usize {
@@ -45,7 +44,6 @@ where
 			valids,
 			position: 0,
 			etable,
-			_marker: PhantomData,
 		}
 	}
 
@@ -86,10 +84,9 @@ where
 	}
 }
 
-impl<'etable, S, H, Tr, ES> Interpreter<S, H, Tr> for EtableInterpreter<'etable, S, H, Tr, ES>
-where
-	ES: EtableSet<S, H, Tr>,
-{
+impl<'etable, S, ES> Interpreter for EtableInterpreter<'etable, S, ES> {
+	type State = S;
+
 	fn machine(&self) -> &Machine<S> {
 		&self.machine
 	}
@@ -102,6 +99,19 @@ where
 		(self.machine.state, self.machine.retval)
 	}
 
+	fn advance(&mut self) {
+		if self.position == self.code.len() {
+			return;
+		}
+
+		self.position += 1;
+	}
+}
+
+impl<'etable, S, H, Tr, ES> RunInterpreter<H, Tr> for EtableInterpreter<'etable, S, ES>
+where
+	ES: EtableSet<State = S, Handle = H, Trap = Tr>,
+{
 	fn run(&mut self, handle: &mut H) -> Capture<ExitResult, Tr> {
 		loop {
 			match self.step(handle) {
@@ -110,19 +120,11 @@ where
 			}
 		}
 	}
-
-	fn advance(&mut self) {
-		if self.position == self.code.len() {
-			return;
-		}
-
-		self.position += 1;
-	}
 }
 
-impl<'etable, S, H, Tr, ES> StepInterpreter<S, H, Tr> for EtableInterpreter<'etable, S, H, Tr, ES>
+impl<'etable, S, H, Tr, ES> StepInterpreter<H, Tr> for EtableInterpreter<'etable, S, ES>
 where
-	ES: EtableSet<S, H, Tr>,
+	ES: EtableSet<State = S, Handle = H, Trap = Tr>,
 {
 	#[inline]
 	fn step(&mut self, handle: &mut H) -> Result<(), Capture<ExitResult, Tr>> {
diff --git a/interpreter/src/interpreter/mod.rs b/interpreter/src/interpreter/mod.rs
index 8de9b7cd6..37f66a83a 100644
--- a/interpreter/src/interpreter/mod.rs
+++ b/interpreter/src/interpreter/mod.rs
@@ -5,15 +5,20 @@ pub use self::etable::EtableInterpreter;
 use crate::{Capture, ExitResult, Machine};
 use alloc::vec::Vec;
 
-pub trait Interpreter<S, H, Tr> {
-	fn machine(&self) -> &Machine<S>;
-	fn machine_mut(&mut self) -> &mut Machine<S>;
+pub trait Interpreter {
+	type State;
 
-	fn deconstruct(self) -> (S, Vec<u8>);
-	fn run(&mut self, handle: &mut H) -> Capture<ExitResult, Tr>;
+	fn machine(&self) -> &Machine<Self::State>;
+	fn machine_mut(&mut self) -> &mut Machine<Self::State>;
+
+	fn deconstruct(self) -> (Self::State, Vec<u8>);
 	fn advance(&mut self);
 }
 
-pub trait StepInterpreter<S, H, Tr>: Interpreter<S, H, Tr> {
+pub trait RunInterpreter<H, Tr>: Interpreter {
+	fn run(&mut self, handle: &mut H) -> Capture<ExitResult, Tr>;
+}
+
+pub trait StepInterpreter<H, Tr>: Interpreter {
 	fn step(&mut self, handle: &mut H) -> Result<(), Capture<ExitResult, Tr>>;
 }
diff --git a/interpreter/src/lib.rs b/interpreter/src/lib.rs
index cc5d97e94..6cc589ece 100644
--- a/interpreter/src/lib.rs
+++ b/interpreter/src/lib.rs
@@ -9,7 +9,7 @@ extern crate alloc;
 mod error;
 mod etable;
 pub mod eval;
-mod interpreter;
+pub mod interpreter;
 mod memory;
 mod opcode;
 mod runtime;
@@ -20,7 +20,6 @@ mod valids;
 
 pub use crate::error::{Capture, ExitError, ExitException, ExitFatal, ExitResult, ExitSucceed};
 pub use crate::etable::{Control, Efn, Etable, EtableSet};
-pub use crate::interpreter::{EtableInterpreter, Interpreter, StepInterpreter};
 pub use crate::memory::Memory;
 pub use crate::opcode::Opcode;
 pub use crate::runtime::{
diff --git a/interpreter/src/trap.rs b/interpreter/src/trap.rs
index 18b85b974..f111e5e80 100644
--- a/interpreter/src/trap.rs
+++ b/interpreter/src/trap.rs
@@ -2,8 +2,8 @@
 
 use crate::utils::{h256_to_u256, u256_to_usize};
 use crate::{
-	Context, ExitError, ExitException, ExitResult, Interpreter, Machine, Memory, RuntimeBackend,
-	RuntimeState, Transfer,
+	interpreter::Interpreter, Context, ExitError, ExitException, ExitResult, Machine, Memory,
+	RuntimeBackend, RuntimeState, Transfer,
 };
 use alloc::vec::Vec;
 use core::cmp::{max, min};
@@ -297,17 +297,15 @@ impl CallTrapData {
 		}
 	}
 
-	pub fn feedback<
-		S: AsRef<RuntimeState> + AsMut<RuntimeState>,
-		H,
-		Tr,
-		I: Interpreter<S, H, Tr>,
-	>(
+	pub fn feedback<I: Interpreter>(
 		self,
 		reason: ExitResult,
 		retbuf: Vec<u8>,
 		interpreter: &mut I,
-	) -> Result<(), ExitError> {
+	) -> Result<(), ExitError>
+	where
+		I::State: AsRef<RuntimeState> + AsMut<RuntimeState>,
+	{
 		let target_len = min(self.out_len, U256::from(retbuf.len()));
 		let out_offset = self.out_offset;
 
@@ -466,17 +464,15 @@ impl CreateTrapData {
 		})
 	}
 
-	pub fn feedback<
-		S: AsRef<RuntimeState> + AsMut<RuntimeState>,
-		H,
-		Tr,
-		I: Interpreter<S, H, Tr>,
-	>(
+	pub fn feedback<I: Interpreter>(
 		self,
 		reason: Result<H160, ExitError>,
 		retbuf: Vec<u8>,
 		interpreter: &mut I,
-	) -> Result<(), ExitError> {
+	) -> Result<(), ExitError>
+	where
+		I::State: AsRef<RuntimeState> + AsMut<RuntimeState>,
+	{
 		let ret = match reason {
 			Ok(address) => {
 				interpreter.machine_mut().stack.push(address.into())?;
diff --git a/interpreter/tests/performance.rs b/interpreter/tests/performance.rs
index aa69af9ca..1e9d255f2 100644
--- a/interpreter/tests/performance.rs
+++ b/interpreter/tests/performance.rs
@@ -1,4 +1,5 @@
-use evm_interpreter::{Capture, Etable, EtableInterpreter, ExitSucceed, Interpreter, Machine};
+use evm_interpreter::interpreter::{EtableInterpreter, RunInterpreter};
+use evm_interpreter::{Capture, Etable, ExitSucceed, Machine};
 use std::rc::Rc;
 
 static ETABLE: Etable<(), (), ()> = Etable::core();
diff --git a/interpreter/tests/usability.rs b/interpreter/tests/usability.rs
index 45e79dad9..02421a987 100644
--- a/interpreter/tests/usability.rs
+++ b/interpreter/tests/usability.rs
@@ -1,7 +1,8 @@
+use evm_interpreter::interpreter::{EtableInterpreter, RunInterpreter};
 use evm_interpreter::{
-	trap::CallCreateTrap, Capture, Context, Control, Etable, EtableInterpreter, ExitError,
-	ExitSucceed, Interpreter, Log, Machine, Opcode, RuntimeBackend, RuntimeBaseBackend,
-	RuntimeEnvironment, RuntimeState, TransactionContext,
+	trap::CallCreateTrap, Capture, Context, Control, Etable, ExitError, ExitSucceed, Log, Machine,
+	Opcode, RuntimeBackend, RuntimeBaseBackend, RuntimeEnvironment, RuntimeState,
+	TransactionContext,
 };
 use primitive_types::{H160, H256, U256};
 use std::rc::Rc;
diff --git a/jsontests/src/run.rs b/jsontests/src/run.rs
index 7ee51edf7..c5306426f 100644
--- a/jsontests/src/run.rs
+++ b/jsontests/src/run.rs
@@ -4,7 +4,7 @@ use crate::types::*;
 use evm::standard::{Config, Etable, EtableResolver, Invoker, TransactArgs};
 use evm::utils::u256_to_h256;
 use evm::Capture;
-use evm::{GasState, Interpreter};
+use evm::{interpreter::Interpreter, GasState};
 use evm_precompile::StandardPrecompileSet;
 use primitive_types::U256;
 use std::collections::{BTreeMap, BTreeSet};
diff --git a/src/call_stack.rs b/src/call_stack.rs
index 2c0670f23..d0f08adce 100644
--- a/src/call_stack.rs
+++ b/src/call_stack.rs
@@ -1,7 +1,5 @@
-use crate::{
-	Capture, ExitError, ExitFatal, ExitResult, Interpreter, Invoker, InvokerControl,
-	StepInterpreter,
-};
+use crate::interpreter::{Interpreter, RunInterpreter, StepInterpreter};
+use crate::{Capture, ExitError, ExitFatal, ExitResult, Invoker, InvokerControl};
 use alloc::vec::Vec;
 use core::convert::Infallible;
 
@@ -23,7 +21,7 @@ enum LastSubstackStatus<Tr> {
 
 // Note: this should not be exposed to public because it does not implement
 // Drop.
-struct CallStack<'backend, 'invoker, S, H, Tr, I: Invoker<S, H, Tr>> {
+struct CallStack<'backend, 'invoker, H, Tr, I: Invoker<H, Tr>> {
 	stack: Vec<Substack<I::Interpreter, I::SubstackInvoke>>,
 	last: Option<LastSubstack<I::Interpreter, Tr>>,
 	initial_depth: usize,
@@ -31,9 +29,9 @@ struct CallStack<'backend, 'invoker, S, H, Tr, I: Invoker<S, H, Tr>> {
 	invoker: &'invoker I,
 }
 
-impl<'backend, 'invoker, S, H, Tr, I> CallStack<'backend, 'invoker, S, H, Tr, I>
+impl<'backend, 'invoker, H, Tr, I> CallStack<'backend, 'invoker, H, Tr, I>
 where
-	I: Invoker<S, H, Tr>,
+	I: Invoker<H, Tr>,
 {
 	pub fn new(
 		machine: I::Interpreter,
@@ -53,29 +51,6 @@ where
 		}
 	}
 
-	#[allow(clippy::type_complexity)]
-	pub fn run(
-		&mut self,
-	) -> Capture<Result<(ExitResult, I::Interpreter), ExitFatal>, I::Interrupt> {
-		loop {
-			let step_ret = self.step_run();
-
-			if let Err(step_ret) = step_ret {
-				return step_ret;
-			}
-		}
-	}
-
-	#[allow(clippy::type_complexity)]
-	pub fn step_run(
-		&mut self,
-	) -> Result<(), Capture<Result<(ExitResult, I::Interpreter), ExitFatal>, I::Interrupt>> {
-		self.step_with(|machine, handler| {
-			let result = machine.run(handler);
-			LastSubstackStatus::Exited(result)
-		})
-	}
-
 	#[allow(clippy::type_complexity)]
 	fn step_with<FS>(
 		&mut self,
@@ -206,10 +181,39 @@ where
 	}
 }
 
-impl<'backend, 'invoker, S, H, Tr, I> CallStack<'backend, 'invoker, S, H, Tr, I>
+impl<'backend, 'invoker, H, Tr, I> CallStack<'backend, 'invoker, H, Tr, I>
+where
+	I: Invoker<H, Tr>,
+	I::Interpreter: RunInterpreter<H, Tr>,
+{
+	#[allow(clippy::type_complexity)]
+	pub fn run(
+		&mut self,
+	) -> Capture<Result<(ExitResult, I::Interpreter), ExitFatal>, I::Interrupt> {
+		loop {
+			let step_ret = self.step_run();
+
+			if let Err(step_ret) = step_ret {
+				return step_ret;
+			}
+		}
+	}
+
+	#[allow(clippy::type_complexity)]
+	pub fn step_run(
+		&mut self,
+	) -> Result<(), Capture<Result<(ExitResult, I::Interpreter), ExitFatal>, I::Interrupt>> {
+		self.step_with(|machine, handler| {
+			let result = machine.run(handler);
+			LastSubstackStatus::Exited(result)
+		})
+	}
+}
+
+impl<'backend, 'invoker, H, Tr, I> CallStack<'backend, 'invoker, H, Tr, I>
 where
-	I: Invoker<S, H, Tr>,
-	I::Interpreter: StepInterpreter<S, H, Tr>,
+	I: Invoker<H, Tr>,
+	I::Interpreter: StepInterpreter<H, Tr>,
 {
 	#[allow(clippy::type_complexity)]
 	pub fn step(
@@ -225,7 +229,7 @@ where
 	}
 }
 
-fn execute<S, H, Tr, I>(
+fn execute<H, Tr, I>(
 	mut machine: I::Interpreter,
 	initial_depth: usize,
 	heap_depth: Option<usize>,
@@ -233,7 +237,8 @@ fn execute<S, H, Tr, I>(
 	invoker: &I,
 ) -> Result<(ExitResult, I::Interpreter), ExitFatal>
 where
-	I: Invoker<S, H, Tr, Interrupt = Infallible>,
+	I: Invoker<H, Tr, Interrupt = Infallible>,
+	I::Interpreter: RunInterpreter<H, Tr>,
 {
 	let mut result = machine.run(backend);
 
@@ -295,14 +300,14 @@ where
 	}
 }
 
-enum HeapTransactState<'backend, 'invoker, S, H, Tr, I: Invoker<S, H, Tr>> {
+enum HeapTransactState<'backend, 'invoker, H, Tr, I: Invoker<H, Tr>> {
 	Created {
 		args: I::TransactArgs,
 		invoker: &'invoker I,
 		backend: &'backend mut H,
 	},
 	Running {
-		call_stack: CallStack<'backend, 'invoker, S, H, Tr, I>,
+		call_stack: CallStack<'backend, 'invoker, H, Tr, I>,
 		transact_invoke: I::TransactInvoke,
 	},
 }
@@ -310,13 +315,13 @@ enum HeapTransactState<'backend, 'invoker, S, H, Tr, I: Invoker<S, H, Tr>> {
 /// Heap-based call stack for a transaction. This is suitable for single
 /// stepping or debugging. The hybrid version [transact] uses a heap-based call
 /// stack internally after certain depth.
-pub struct HeapTransact<'backend, 'invoker, S, H, Tr, I: Invoker<S, H, Tr>>(
-	Option<HeapTransactState<'backend, 'invoker, S, H, Tr, I>>,
+pub struct HeapTransact<'backend, 'invoker, H, Tr, I: Invoker<H, Tr>>(
+	Option<HeapTransactState<'backend, 'invoker, H, Tr, I>>,
 );
 
-impl<'backend, 'invoker, S, H, Tr, I> HeapTransact<'backend, 'invoker, S, H, Tr, I>
+impl<'backend, 'invoker, H, Tr, I> HeapTransact<'backend, 'invoker, H, Tr, I>
 where
-	I: Invoker<S, H, Tr>,
+	I: Invoker<H, Tr>,
 {
 	/// Create a new heap-based call stack.
 	pub fn new(
@@ -338,7 +343,7 @@ where
 	) -> Result<(), Capture<Result<I::TransactValue, ExitError>, I::Interrupt>>
 	where
 		FS: Fn(
-			&mut CallStack<'backend, 'invoker, S, H, Tr, I>,
+			&mut CallStack<'backend, 'invoker, H, Tr, I>,
 		) -> Result<
 			(),
 			Capture<Result<(ExitResult, I::Interpreter), ExitFatal>, I::Interrupt>,
@@ -407,6 +412,24 @@ where
 		ret
 	}
 
+	/// The machine of the last item on the call stack. This will be `None` if
+	/// the heap stack is just created.
+	pub fn last_interpreter(&self) -> Option<&I::Interpreter> {
+		match &self.0 {
+			Some(HeapTransactState::Running { call_stack, .. }) => match &call_stack.last {
+				Some(last) => Some(&last.machine),
+				None => None,
+			},
+			_ => None,
+		}
+	}
+}
+
+impl<'backend, 'invoker, H, Tr, I> HeapTransact<'backend, 'invoker, H, Tr, I>
+where
+	I: Invoker<H, Tr>,
+	I::Interpreter: RunInterpreter<H, Tr>,
+{
 	/// Step the call stack, but run the interpreter inside.
 	#[allow(clippy::type_complexity)]
 	pub fn step_run(
@@ -425,24 +448,12 @@ where
 			}
 		}
 	}
-
-	/// The machine of the last item on the call stack. This will be `None` if
-	/// the heap stack is just created.
-	pub fn last_interpreter(&self) -> Option<&I::Interpreter> {
-		match &self.0 {
-			Some(HeapTransactState::Running { call_stack, .. }) => match &call_stack.last {
-				Some(last) => Some(&last.machine),
-				None => None,
-			},
-			_ => None,
-		}
-	}
 }
 
-impl<'backend, 'invoker, S, H, Tr, I> HeapTransact<'backend, 'invoker, S, H, Tr, I>
+impl<'backend, 'invoker, H, Tr, I> HeapTransact<'backend, 'invoker, H, Tr, I>
 where
-	I: Invoker<S, H, Tr>,
-	I::Interpreter: StepInterpreter<S, H, Tr>,
+	I: Invoker<H, Tr>,
+	I::Interpreter: StepInterpreter<H, Tr>,
 {
 	/// Step the call stack, and step the interpreter inside.
 	#[allow(clippy::type_complexity)]
@@ -453,9 +464,9 @@ where
 	}
 }
 
-impl<'backend, 'invoker, S, H, Tr, I> Drop for HeapTransact<'backend, 'invoker, S, H, Tr, I>
+impl<'backend, 'invoker, H, Tr, I> Drop for HeapTransact<'backend, 'invoker, H, Tr, I>
 where
-	I: Invoker<S, H, Tr>,
+	I: Invoker<H, Tr>,
 {
 	fn drop(&mut self) {
 		if let Some(HeapTransactState::Running {
@@ -506,14 +517,15 @@ where
 ///
 /// Because a stack-based call stack cannot handle interrupts, the [Invoker]
 /// type must have its `Interrupt` type set to [Infallible].
-pub fn transact<S, H, Tr, I>(
+pub fn transact<H, Tr, I>(
 	args: I::TransactArgs,
 	heap_depth: Option<usize>,
 	backend: &mut H,
 	invoker: &I,
 ) -> Result<I::TransactValue, ExitError>
 where
-	I: Invoker<S, H, Tr, Interrupt = Infallible>,
+	I: Invoker<H, Tr, Interrupt = Infallible>,
+	I::Interpreter: RunInterpreter<H, Tr>,
 {
 	let (transact_invoke, control) = invoker.new_transact(args, backend)?;
 
diff --git a/src/invoker.rs b/src/invoker.rs
index f4d4ea321..755834763 100644
--- a/src/invoker.rs
+++ b/src/invoker.rs
@@ -1,4 +1,4 @@
-use crate::{Capture, ExitError, ExitResult, Interpreter};
+use crate::{interpreter::Interpreter, Capture, ExitError, ExitResult};
 use alloc::vec::Vec;
 
 /// Control for an invoker.
@@ -10,8 +10,9 @@ pub enum InvokerControl<VE, VD> {
 }
 
 /// An invoker, responsible for pushing/poping values in the call stack.
-pub trait Invoker<S, H, Tr> {
-	type Interpreter: Interpreter<S, H, Tr>;
+pub trait Invoker<H, Tr> {
+	type State;
+	type Interpreter: Interpreter<State = Self::State>;
 	/// Possible interrupt type that may be returned by the call stack.
 	type Interrupt;
 
@@ -35,7 +36,7 @@ pub trait Invoker<S, H, Tr> {
 	) -> Result<
 		(
 			Self::TransactInvoke,
-			InvokerControl<Self::Interpreter, (ExitResult, (S, Vec<u8>))>,
+			InvokerControl<Self::Interpreter, (ExitResult, (Self::State, Vec<u8>))>,
 		),
 		ExitError,
 	>;
@@ -45,7 +46,7 @@ pub trait Invoker<S, H, Tr> {
 		&self,
 		invoke: &Self::TransactInvoke,
 		exit: ExitResult,
-		machine: (S, Vec<u8>),
+		machine: (Self::State, Vec<u8>),
 		handler: &mut H,
 	) -> Result<Self::TransactValue, ExitError>;
 
@@ -61,7 +62,7 @@ pub trait Invoker<S, H, Tr> {
 		Result<
 			(
 				Self::SubstackInvoke,
-				InvokerControl<Self::Interpreter, (ExitResult, (S, Vec<u8>))>,
+				InvokerControl<Self::Interpreter, (ExitResult, (Self::State, Vec<u8>))>,
 			),
 			ExitError,
 		>,
@@ -72,7 +73,7 @@ pub trait Invoker<S, H, Tr> {
 	fn exit_substack(
 		&self,
 		result: ExitResult,
-		child: (S, Vec<u8>),
+		child: (Self::State, Vec<u8>),
 		trap_data: Self::SubstackInvoke,
 		parent: &mut Self::Interpreter,
 		handler: &mut H,
diff --git a/src/standard/invoker/mod.rs b/src/standard/invoker/mod.rs
index 36c888c39..24b9f8617 100644
--- a/src/standard/invoker/mod.rs
+++ b/src/standard/invoker/mod.rs
@@ -8,15 +8,15 @@ pub use self::state::InvokerState;
 use super::Config;
 use crate::trap::{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, TrapConsume,
+	interpreter::Interpreter, Capture, Context, ExitError, ExitException, ExitResult, ExitSucceed,
+	GasState, Invoker as InvokerT, InvokerControl, MergeStrategy, Opcode, RuntimeBackend,
+	RuntimeEnvironment, RuntimeState, TransactionContext, TransactionalBackend, Transfer,
+	TrapConsume,
 };
 use alloc::rc::Rc;
 use alloc::vec::Vec;
 use core::cmp::min;
 use core::convert::Infallible;
-use core::marker::PhantomData;
 use primitive_types::{H160, H256, U256};
 use sha3::{Digest, Keccak256};
 
@@ -141,31 +141,26 @@ impl TransactArgs {
 /// * `R`: Code resolver type, also handle precompiles. Usually
 ///   [EtableResolver] but can be customized.
 /// * `Tr`: Trap type, usually [crate::Opcode] but can be customized.
-pub struct Invoker<'config, 'resolver, S, H, R, Tr> {
+pub struct Invoker<'config, 'resolver, R> {
 	config: &'config Config,
 	resolver: &'resolver R,
-	_marker: PhantomData<(S, H, Tr)>,
 }
 
-impl<'config, 'resolver, S, H, R, Tr> Invoker<'config, 'resolver, S, H, R, Tr> {
+impl<'config, 'resolver, R> Invoker<'config, 'resolver, R> {
 	/// Create a new standard invoker with the given config and resolver.
 	pub fn new(config: &'config Config, resolver: &'resolver R) -> Self {
-		Self {
-			config,
-			resolver,
-			_marker: PhantomData,
-		}
+		Self { config, resolver }
 	}
 }
 
-impl<'config, 'resolver, S, H, R, Tr> InvokerT<S, H, Tr>
-	for Invoker<'config, 'resolver, S, H, R, Tr>
+impl<'config, 'resolver, H, R, Tr> InvokerT<H, Tr> for Invoker<'config, 'resolver, R>
 where
-	S: InvokerState<'config> + AsRef<RuntimeState> + AsMut<RuntimeState>,
+	R::State: InvokerState<'config> + AsRef<RuntimeState> + AsMut<RuntimeState>,
 	H: RuntimeEnvironment + RuntimeBackend + TransactionalBackend,
-	R: Resolver<S, H, Tr>,
+	R: Resolver<H>,
 	Tr: TrapConsume<CallCreateTrap>,
 {
+	type State = R::State;
 	type Interpreter = R::Interpreter;
 	type Interrupt = Tr::Rest;
 	type TransactArgs = TransactArgs;
@@ -180,7 +175,7 @@ where
 	) -> Result<
 		(
 			Self::TransactInvoke,
-			InvokerControl<Self::Interpreter, (ExitResult, (S, Vec<u8>))>,
+			InvokerControl<Self::Interpreter, (ExitResult, (R::State, Vec<u8>))>,
 		),
 		ExitError,
 	> {
@@ -260,7 +255,7 @@ where
 						}
 					}
 
-					let state = S::new_transact_call(
+					let state = <R::State>::new_transact_call(
 						RuntimeState {
 							context,
 							transaction_context: Rc::new(transaction_context),
@@ -300,7 +295,7 @@ where
 					access_list,
 					..
 				} => {
-					let state = S::new_transact_create(
+					let state = <R::State>::new_transact_create(
 						RuntimeState {
 							context,
 							transaction_context: Rc::new(transaction_context),
@@ -340,7 +335,7 @@ where
 		&self,
 		invoke: &Self::TransactInvoke,
 		result: ExitResult,
-		(mut substate, retval): (S, Vec<u8>),
+		(mut substate, retval): (R::State, Vec<u8>),
 		handler: &mut H,
 	) -> Result<Self::TransactValue, ExitError> {
 		let left_gas = substate.effective_gas();
@@ -397,7 +392,7 @@ where
 		Result<
 			(
 				Self::SubstackInvoke,
-				InvokerControl<Self::Interpreter, (ExitResult, (S, Vec<u8>))>,
+				InvokerControl<Self::Interpreter, (ExitResult, (R::State, Vec<u8>))>,
 			),
 			ExitError,
 		>,
@@ -508,7 +503,7 @@ where
 	fn exit_substack(
 		&self,
 		result: ExitResult,
-		(mut substate, retval): (S, Vec<u8>),
+		(mut substate, retval): (R::State, Vec<u8>),
 		trap_data: Self::SubstackInvoke,
 		parent: &mut Self::Interpreter,
 		handler: &mut H,
diff --git a/src/standard/invoker/resolver.rs b/src/standard/invoker/resolver.rs
index 1155bf60c..bd853b3c9 100644
--- a/src/standard/invoker/resolver.rs
+++ b/src/standard/invoker/resolver.rs
@@ -1,6 +1,7 @@
+use crate::interpreter::{EtableInterpreter, Interpreter};
 use crate::{
-	standard::Config, EtableInterpreter, EtableSet, ExitError, ExitResult, Interpreter,
-	InvokerControl, Machine, RuntimeBackend, RuntimeState,
+	standard::Config, EtableSet, ExitError, ExitResult, InvokerControl, Machine, RuntimeBackend,
+	RuntimeState,
 };
 use alloc::{rc::Rc, vec::Vec};
 use core::marker::PhantomData;
@@ -12,8 +13,9 @@ use primitive_types::H160;
 /// (with the init code) is turned into a colored machine. The resolver can
 /// construct a machine, pushing the call stack, or directly exit, handling a
 /// precompile.
-pub trait Resolver<S, H, Tr> {
-	type Interpreter: Interpreter<S, H, Tr>;
+pub trait Resolver<H> {
+	type State;
+	type Interpreter: Interpreter<State = Self::State>;
 
 	/// Resolve a call (with the target code address).
 	#[allow(clippy::type_complexity)]
@@ -21,18 +23,18 @@ pub trait Resolver<S, H, Tr> {
 		&self,
 		code_address: H160,
 		input: Vec<u8>,
-		state: S,
+		state: Self::State,
 		handler: &mut H,
-	) -> Result<InvokerControl<Self::Interpreter, (ExitResult, (S, Vec<u8>))>, ExitError>;
+	) -> Result<InvokerControl<Self::Interpreter, (ExitResult, (Self::State, Vec<u8>))>, ExitError>;
 
 	/// Resolve a create (with the init code).
 	#[allow(clippy::type_complexity)]
 	fn resolve_create(
 		&self,
 		init_code: Vec<u8>,
-		state: S,
+		state: Self::State,
 		handler: &mut H,
-	) -> Result<InvokerControl<Self::Interpreter, (ExitResult, (S, Vec<u8>))>, ExitError>;
+	) -> Result<InvokerControl<Self::Interpreter, (ExitResult, (Self::State, Vec<u8>))>, ExitError>;
 }
 
 /// A set of precompiles.
@@ -62,15 +64,15 @@ impl<S, H> PrecompileSet<S, H> for () {
 
 /// The standard code resolver where the color is an [Etable]. This is usually
 /// what you need.
-pub struct EtableResolver<'config, 'precompile, 'etable, S, H, Pre, Tr, ES> {
+pub struct EtableResolver<'config, 'precompile, 'etable, S, Pre, ES> {
 	config: &'config Config,
 	etable: &'etable ES,
 	precompiles: &'precompile Pre,
-	_marker: PhantomData<(S, H, Tr)>,
+	_marker: PhantomData<S>,
 }
 
-impl<'config, 'precompile, 'etable, S, H, Pre, Tr, ES>
-	EtableResolver<'config, 'precompile, 'etable, S, H, Pre, Tr, ES>
+impl<'config, 'precompile, 'etable, S, Pre, ES>
+	EtableResolver<'config, 'precompile, 'etable, S, Pre, ES>
 {
 	pub fn new(
 		config: &'config Config,
@@ -86,15 +88,16 @@ impl<'config, 'precompile, 'etable, S, H, Pre, Tr, ES>
 	}
 }
 
-impl<'config, 'precompile, 'etable, S, H, Pre, Tr, ES> Resolver<S, H, Tr>
-	for EtableResolver<'config, 'precompile, 'etable, S, H, Pre, Tr, ES>
+impl<'config, 'precompile, 'etable, S, H, Pre, ES> Resolver<H>
+	for EtableResolver<'config, 'precompile, 'etable, S, Pre, ES>
 where
 	S: AsRef<RuntimeState> + AsMut<RuntimeState>,
 	H: RuntimeBackend,
 	Pre: PrecompileSet<S, H>,
-	ES: EtableSet<S, H, Tr>,
+	ES: EtableSet<State = S, Handle = H>,
 {
-	type Interpreter = EtableInterpreter<'etable, S, H, Tr, ES>;
+	type State = S;
+	type Interpreter = EtableInterpreter<'etable, S, ES>;
 
 	/// Resolve a call (with the target code address).
 	#[allow(clippy::type_complexity)]
diff --git a/src/standard/invoker/routines.rs b/src/standard/invoker/routines.rs
index cac2b7e0f..fbc0ff8a2 100644
--- a/src/standard/invoker/routines.rs
+++ b/src/standard/invoker/routines.rs
@@ -8,19 +8,19 @@ use alloc::vec::Vec;
 use primitive_types::{H160, U256};
 
 #[allow(clippy::too_many_arguments, clippy::type_complexity)]
-pub fn make_enter_call_machine<S, H, R, Tr>(
+pub fn make_enter_call_machine<H, R>(
 	_config: &Config,
 	resolver: &R,
 	code_address: H160,
 	input: Vec<u8>,
 	transfer: Option<Transfer>,
-	state: S,
+	state: R::State,
 	handler: &mut H,
-) -> Result<InvokerControl<R::Interpreter, (ExitResult, (S, Vec<u8>))>, ExitError>
+) -> Result<InvokerControl<R::Interpreter, (ExitResult, (R::State, Vec<u8>))>, ExitError>
 where
-	S: AsRef<RuntimeState>,
+	R::State: AsRef<RuntimeState>,
 	H: RuntimeEnvironment + RuntimeBackend + TransactionalBackend,
-	R: Resolver<S, H, Tr>,
+	R: Resolver<H>,
 {
 	handler.mark_hot(state.as_ref().context.address, None);
 
@@ -32,19 +32,19 @@ where
 }
 
 #[allow(clippy::type_complexity, clippy::too_many_arguments)]
-pub fn make_enter_create_machine<S, H, R, Tr>(
+pub fn make_enter_create_machine<H, R>(
 	config: &Config,
 	resolver: &R,
 	caller: H160,
 	init_code: Vec<u8>,
 	transfer: Transfer,
-	state: S,
+	state: R::State,
 	handler: &mut H,
-) -> Result<InvokerControl<R::Interpreter, (ExitResult, (S, Vec<u8>))>, ExitError>
+) -> Result<InvokerControl<R::Interpreter, (ExitResult, (R::State, Vec<u8>))>, ExitError>
 where
-	S: AsRef<RuntimeState>,
+	R::State: AsRef<RuntimeState>,
 	H: RuntimeEnvironment + RuntimeBackend + TransactionalBackend,
-	R: Resolver<S, H, Tr>,
+	R: Resolver<H>,
 {
 	if let Some(limit) = config.max_initcode_size {
 		if init_code.len() > limit {
@@ -73,24 +73,24 @@ where
 }
 
 #[allow(clippy::type_complexity, clippy::too_many_arguments)]
-pub fn enter_call_substack<S, H, R, Tr>(
+pub fn enter_call_substack<H, R>(
 	config: &Config,
 	resolver: &R,
 	trap_data: CallTrapData,
 	code_address: H160,
-	state: S,
+	state: R::State,
 	handler: &mut H,
 ) -> Result<
 	(
 		SubstackInvoke,
-		InvokerControl<R::Interpreter, (ExitResult, (S, Vec<u8>))>,
+		InvokerControl<R::Interpreter, (ExitResult, (R::State, Vec<u8>))>,
 	),
 	ExitError,
 >
 where
-	S: AsRef<RuntimeState>,
+	R::State: AsRef<RuntimeState>,
 	H: RuntimeEnvironment + RuntimeBackend + TransactionalBackend,
-	R: Resolver<S, H, Tr>,
+	R: Resolver<H>,
 {
 	handler.push_substate();
 
@@ -118,28 +118,28 @@ where
 }
 
 #[allow(clippy::type_complexity, clippy::too_many_arguments)]
-pub fn enter_create_substack<S, H, R, Tr>(
+pub fn enter_create_substack<H, R>(
 	config: &Config,
 	resolver: &R,
 	code: Vec<u8>,
 	trap_data: CreateTrapData,
-	state: S,
+	state: R::State,
 	handler: &mut H,
 ) -> Result<
 	(
 		SubstackInvoke,
-		InvokerControl<R::Interpreter, (ExitResult, (S, Vec<u8>))>,
+		InvokerControl<R::Interpreter, (ExitResult, (R::State, Vec<u8>))>,
 	),
 	ExitError,
 >
 where
-	S: AsRef<RuntimeState>,
+	R::State: AsRef<RuntimeState>,
 	H: RuntimeEnvironment + RuntimeBackend + TransactionalBackend,
-	R: Resolver<S, H, Tr>,
+	R: Resolver<H>,
 {
 	handler.push_substate();
 
-	let work = || -> Result<(SubstackInvoke, InvokerControl<R::Interpreter, (ExitResult, (S, Vec<u8>))>), ExitError> {
+	let work = || -> Result<(SubstackInvoke, InvokerControl<R::Interpreter, (ExitResult, (R::State, Vec<u8>))>), ExitError> {
 		let CreateTrapData {
 			scheme,
 			value,