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 6430aa63b..34344c7cd 100644
--- a/interpreter/src/interpreter/etable.rs
+++ b/interpreter/src/interpreter/etable.rs
@@ -31,7 +31,7 @@ impl<'etable, S, H, Tr, ES> DerefMut for EtableInterpreter<'etable, S, H, Tr, ES
 
 impl<'etable, S, H, Tr, ES> EtableInterpreter<'etable, S, H, Tr, ES>
 where
-	ES: EtableSet<S, H, Tr>,
+	ES: EtableSet<State = S, Handle = H, Trap = Tr>,
 {
 	/// Return a reference of the program counter.
 	pub const fn position(&self) -> usize {
@@ -87,11 +87,12 @@ where
 	}
 }
 
-impl<'etable, S, H, Tr, ES> Interpreter<H> for EtableInterpreter<'etable, S, H, Tr, ES>
+impl<'etable, S, H, Tr, ES> Interpreter for EtableInterpreter<'etable, S, H, Tr, ES>
 where
-	ES: EtableSet<S, H, Tr>,
+	ES: EtableSet<State = S, Handle = H, Trap = Tr>,
 {
 	type State = S;
+	type Handle = H;
 	type Trap = Tr;
 
 	fn machine(&self) -> &Machine<S> {
@@ -124,9 +125,9 @@ where
 	}
 }
 
-impl<'etable, S, H, Tr, ES> StepInterpreter<H> for EtableInterpreter<'etable, S, H, Tr, ES>
+impl<'etable, S, H, Tr, ES> StepInterpreter for EtableInterpreter<'etable, S, H, Tr, 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 be7666d0d..e019ce56d 100644
--- a/interpreter/src/interpreter/mod.rs
+++ b/interpreter/src/interpreter/mod.rs
@@ -5,22 +5,24 @@ pub use self::etable::EtableInterpreter;
 use crate::{Capture, ExitResult, Machine};
 use alloc::vec::Vec;
 
-pub type StateFor<H, I> = <I as Interpreter<H>>::State;
-pub type TrapFor<H, I> = <I as Interpreter<H>>::Trap;
-pub type DeconstructFor<H, I> = (StateFor<H, I>, Vec<u8>);
+pub type StateFor<I> = <I as Interpreter>::State;
+pub type TrapFor<I> = <I as Interpreter>::Trap;
+pub type HandleFor<I> = <I as Interpreter>::Handle;
+pub type DeconstructFor<I> = (StateFor<I>, Vec<u8>);
 
-pub trait Interpreter<H> {
+pub trait Interpreter {
 	type State;
+	type Handle;
 	type Trap;
 
 	fn machine(&self) -> &Machine<Self::State>;
 	fn machine_mut(&mut self) -> &mut Machine<Self::State>;
 
 	fn deconstruct(self) -> (Self::State, Vec<u8>);
-	fn run(&mut self, handle: &mut H) -> Capture<ExitResult, Self::Trap>;
+	fn run(&mut self, handle: &mut Self::Handle) -> Capture<ExitResult, Self::Trap>;
 	fn advance(&mut self);
 }
 
-pub trait StepInterpreter<H>: Interpreter<H> {
-	fn step(&mut self, handle: &mut H) -> Result<(), Capture<ExitResult, Self::Trap>>;
+pub trait StepInterpreter: Interpreter {
+	fn step(&mut self, handle: &mut Self::Handle) -> Result<(), Capture<ExitResult, Self::Trap>>;
 }
diff --git a/interpreter/src/trap.rs b/interpreter/src/trap.rs
index 7c6e80342..42fdef172 100644
--- a/interpreter/src/trap.rs
+++ b/interpreter/src/trap.rs
@@ -297,14 +297,14 @@ impl CallTrapData {
 		}
 	}
 
-	pub fn feedback<H, I>(
+	pub fn feedback<I>(
 		self,
 		reason: ExitResult,
 		retbuf: Vec<u8>,
 		interpreter: &mut I,
 	) -> Result<(), ExitError>
 	where
-		I: Interpreter<H>,
+		I: Interpreter,
 		I::State: AsRef<RuntimeState> + AsMut<RuntimeState>,
 	{
 		let target_len = min(self.out_len, U256::from(retbuf.len()));
@@ -465,14 +465,14 @@ impl CreateTrapData {
 		})
 	}
 
-	pub fn feedback<H, I: Interpreter<H>>(
+	pub fn feedback<I>(
 		self,
 		reason: Result<H160, ExitError>,
 		retbuf: Vec<u8>,
 		interpreter: &mut I,
 	) -> Result<(), ExitError>
 	where
-		I: Interpreter<H>,
+		I: Interpreter,
 		I::State: AsRef<RuntimeState> + AsMut<RuntimeState>,
 	{
 		let ret = match reason {
diff --git a/src/call_stack.rs b/src/call_stack.rs
index 5e9c0b0c7..b9b5498e9 100644
--- a/src/call_stack.rs
+++ b/src/call_stack.rs
@@ -1,4 +1,4 @@
-use crate::interpreter::{Interpreter, StepInterpreter, TrapFor};
+use crate::interpreter::{HandleFor, Interpreter, StepInterpreter, TrapFor};
 use crate::{Capture, ExitError, ExitFatal, ExitResult, Invoker, InvokerControl};
 use alloc::vec::Vec;
 use core::convert::Infallible;
@@ -21,23 +21,23 @@ enum LastSubstackStatus<Tr> {
 
 // Note: this should not be exposed to public because it does not implement
 // Drop.
-struct CallStack<'backend, 'invoker, H, I: Invoker<H>> {
+struct CallStack<'backend, 'invoker, I: Invoker> {
 	stack: Vec<Substack<I::Interpreter, I::SubstackInvoke>>,
 	#[allow(clippy::type_complexity)]
-	last: Option<LastSubstack<I::Interpreter, TrapFor<H, I::Interpreter>>>,
+	last: Option<LastSubstack<I::Interpreter, TrapFor<I::Interpreter>>>,
 	initial_depth: usize,
-	backend: &'backend mut H,
+	backend: &'backend mut HandleFor<I::Interpreter>,
 	invoker: &'invoker I,
 }
 
-impl<'backend, 'invoker, H, I> CallStack<'backend, 'invoker, H, I>
+impl<'backend, 'invoker, I> CallStack<'backend, 'invoker, I>
 where
-	I: Invoker<H>,
+	I: Invoker,
 {
 	pub fn new(
 		machine: I::Interpreter,
 		initial_depth: usize,
-		backend: &'backend mut H,
+		backend: &'backend mut HandleFor<I::Interpreter>,
 		invoker: &'invoker I,
 	) -> Self {
 		Self {
@@ -81,7 +81,10 @@ where
 		fs: FS,
 	) -> Result<(), Capture<Result<(ExitResult, I::Interpreter), ExitFatal>, I::Interrupt>>
 	where
-		FS: Fn(&mut I::Interpreter, &mut H) -> LastSubstackStatus<TrapFor<H, I::Interpreter>>,
+		FS: Fn(
+			&mut I::Interpreter,
+			&mut HandleFor<I::Interpreter>,
+		) -> LastSubstackStatus<TrapFor<I::Interpreter>>,
 	{
 		let mut step_ret = None;
 
@@ -205,10 +208,10 @@ where
 	}
 }
 
-impl<'backend, 'invoker, H, I> CallStack<'backend, 'invoker, H, I>
+impl<'backend, 'invoker, I> CallStack<'backend, 'invoker, I>
 where
-	I: Invoker<H>,
-	I::Interpreter: StepInterpreter<H>,
+	I: Invoker,
+	I::Interpreter: StepInterpreter,
 {
 	#[allow(clippy::type_complexity)]
 	pub fn step(
@@ -224,15 +227,15 @@ where
 	}
 }
 
-fn execute<H, I>(
+fn execute<I>(
 	mut machine: I::Interpreter,
 	initial_depth: usize,
 	heap_depth: Option<usize>,
-	backend: &mut H,
+	backend: &mut HandleFor<I::Interpreter>,
 	invoker: &I,
 ) -> Result<(ExitResult, I::Interpreter), ExitFatal>
 where
-	I: Invoker<H, Interrupt = Infallible>,
+	I: Invoker<Interrupt = Infallible>,
 {
 	let mut result = machine.run(backend);
 
@@ -294,14 +297,14 @@ where
 	}
 }
 
-enum HeapTransactState<'backend, 'invoker, H, I: Invoker<H>> {
+enum HeapTransactState<'backend, 'invoker, I: Invoker> {
 	Created {
 		args: I::TransactArgs,
 		invoker: &'invoker I,
-		backend: &'backend mut H,
+		backend: &'backend mut HandleFor<I::Interpreter>,
 	},
 	Running {
-		call_stack: CallStack<'backend, 'invoker, H, I>,
+		call_stack: CallStack<'backend, 'invoker, I>,
 		transact_invoke: I::TransactInvoke,
 	},
 }
@@ -309,19 +312,19 @@ enum HeapTransactState<'backend, 'invoker, H, I: Invoker<H>> {
 /// 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, H, I: Invoker<H>>(
-	Option<HeapTransactState<'backend, 'invoker, H, I>>,
+pub struct HeapTransact<'backend, 'invoker, I: Invoker>(
+	Option<HeapTransactState<'backend, 'invoker, I>>,
 );
 
-impl<'backend, 'invoker, H, I> HeapTransact<'backend, 'invoker, H, I>
+impl<'backend, 'invoker, I> HeapTransact<'backend, 'invoker, I>
 where
-	I: Invoker<H>,
+	I: Invoker,
 {
 	/// Create a new heap-based call stack.
 	pub fn new(
 		args: I::TransactArgs,
 		invoker: &'invoker I,
-		backend: &'backend mut H,
+		backend: &'backend mut HandleFor<I::Interpreter>,
 	) -> Result<Self, ExitError> {
 		Ok(Self(Some(HeapTransactState::Created {
 			args,
@@ -337,7 +340,7 @@ where
 	) -> Result<(), Capture<Result<I::TransactValue, ExitError>, I::Interrupt>>
 	where
 		FS: Fn(
-			&mut CallStack<'backend, 'invoker, H, I>,
+			&mut CallStack<'backend, 'invoker, I>,
 		) -> Result<
 			(),
 			Capture<Result<(ExitResult, I::Interpreter), ExitFatal>, I::Interrupt>,
@@ -438,10 +441,10 @@ where
 	}
 }
 
-impl<'backend, 'invoker, H, I> HeapTransact<'backend, 'invoker, H, I>
+impl<'backend, 'invoker, I> HeapTransact<'backend, 'invoker, I>
 where
-	I: Invoker<H>,
-	I::Interpreter: StepInterpreter<H>,
+	I: Invoker,
+	I::Interpreter: StepInterpreter,
 {
 	/// Step the call stack, and step the interpreter inside.
 	#[allow(clippy::type_complexity)]
@@ -452,9 +455,9 @@ where
 	}
 }
 
-impl<'backend, 'invoker, H, I> Drop for HeapTransact<'backend, 'invoker, H, I>
+impl<'backend, 'invoker, I> Drop for HeapTransact<'backend, 'invoker, I>
 where
-	I: Invoker<H>,
+	I: Invoker,
 {
 	fn drop(&mut self) {
 		if let Some(HeapTransactState::Running {
@@ -505,14 +508,14 @@ where
 ///
 /// Because a stack-based call stack cannot handle interrupts, the [Invoker]
 /// type must have its `Interrupt` type set to [Infallible].
-pub fn transact<H, I>(
+pub fn transact<I>(
 	args: I::TransactArgs,
 	heap_depth: Option<usize>,
-	backend: &mut H,
+	backend: &mut HandleFor<I::Interpreter>,
 	invoker: &I,
 ) -> Result<I::TransactValue, ExitError>
 where
-	I: Invoker<H, Interrupt = Infallible>,
+	I: Invoker<Interrupt = Infallible>,
 {
 	let (transact_invoke, control) = invoker.new_transact(args, backend)?;
 
diff --git a/src/invoker.rs b/src/invoker.rs
index ced31191f..16ecd0270 100644
--- a/src/invoker.rs
+++ b/src/invoker.rs
@@ -1,4 +1,4 @@
-use crate::interpreter::{DeconstructFor, Interpreter, TrapFor};
+use crate::interpreter::{DeconstructFor, HandleFor, Interpreter, TrapFor};
 use crate::{Capture, ExitError, ExitResult};
 
 /// Control for an invoker.
@@ -10,8 +10,8 @@ pub enum InvokerControl<VE, VD> {
 }
 
 /// An invoker, responsible for pushing/poping values in the call stack.
-pub trait Invoker<H> {
-	type Interpreter: Interpreter<H>;
+pub trait Invoker {
+	type Interpreter: Interpreter;
 	/// Possible interrupt type that may be returned by the call stack.
 	type Interrupt;
 
@@ -31,11 +31,11 @@ pub trait Invoker<H> {
 	fn new_transact(
 		&self,
 		args: Self::TransactArgs,
-		handler: &mut H,
+		handler: &mut HandleFor<Self::Interpreter>,
 	) -> Result<
 		(
 			Self::TransactInvoke,
-			InvokerControl<Self::Interpreter, (ExitResult, DeconstructFor<H, Self::Interpreter>)>,
+			InvokerControl<Self::Interpreter, (ExitResult, DeconstructFor<Self::Interpreter>)>,
 		),
 		ExitError,
 	>;
@@ -45,26 +45,23 @@ pub trait Invoker<H> {
 		&self,
 		invoke: &Self::TransactInvoke,
 		exit: ExitResult,
-		machine: DeconstructFor<H, Self::Interpreter>,
-		handler: &mut H,
+		machine: DeconstructFor<Self::Interpreter>,
+		handler: &mut HandleFor<Self::Interpreter>,
 	) -> Result<Self::TransactValue, ExitError>;
 
 	/// Enter a sub-layer call stack.
 	#[allow(clippy::type_complexity)]
 	fn enter_substack(
 		&self,
-		trap: TrapFor<H, Self::Interpreter>,
+		trap: TrapFor<Self::Interpreter>,
 		machine: &mut Self::Interpreter,
-		handler: &mut H,
+		handler: &mut HandleFor<Self::Interpreter>,
 		depth: usize,
 	) -> Capture<
 		Result<
 			(
 				Self::SubstackInvoke,
-				InvokerControl<
-					Self::Interpreter,
-					(ExitResult, DeconstructFor<H, Self::Interpreter>),
-				>,
+				InvokerControl<Self::Interpreter, (ExitResult, DeconstructFor<Self::Interpreter>)>,
 			),
 			ExitError,
 		>,
@@ -75,9 +72,9 @@ pub trait Invoker<H> {
 	fn exit_substack(
 		&self,
 		result: ExitResult,
-		child: DeconstructFor<H, Self::Interpreter>,
+		child: DeconstructFor<Self::Interpreter>,
 		trap_data: Self::SubstackInvoke,
 		parent: &mut Self::Interpreter,
-		handler: &mut H,
+		handler: &mut HandleFor<Self::Interpreter>,
 	) -> Result<(), ExitError>;
 }
diff --git a/src/standard/invoker/mod.rs b/src/standard/invoker/mod.rs
index 8c9f6e40a..cb12941ec 100644
--- a/src/standard/invoker/mod.rs
+++ b/src/standard/invoker/mod.rs
@@ -6,7 +6,7 @@ pub use self::resolver::{EtableResolver, PrecompileSet, Resolver};
 pub use self::state::InvokerState;
 
 use super::Config;
-use crate::interpreter::{DeconstructFor, StateFor, TrapFor};
+use crate::interpreter::{DeconstructFor, HandleFor, StateFor, TrapFor};
 use crate::trap::{CallCreateTrap, CallCreateTrapData, CallTrapData, CreateScheme, CreateTrapData};
 use crate::{
 	interpreter::Interpreter, Capture, Context, ExitError, ExitException, ExitResult, ExitSucceed,
@@ -18,7 +18,6 @@ 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};
 
@@ -143,32 +142,27 @@ 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, H, R> {
+pub struct Invoker<'config, 'resolver, R> {
 	config: &'config Config,
 	resolver: &'resolver R,
-	_marker: PhantomData<H>,
 }
 
-impl<'config, 'resolver, H, R> Invoker<'config, 'resolver, H, R> {
+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, H, R> InvokerT<H> for Invoker<'config, 'resolver, H, R>
+impl<'config, 'resolver, R> InvokerT for Invoker<'config, 'resolver, R>
 where
-	StateFor<H, R::Interpreter>: InvokerState<'config> + AsRef<RuntimeState> + AsMut<RuntimeState>,
-	H: RuntimeEnvironment + RuntimeBackend + TransactionalBackend,
-	R: Resolver<H>,
-	TrapFor<H, R::Interpreter>: TrapConsume<CallCreateTrap>,
+	StateFor<R::Interpreter>: InvokerState<'config> + AsRef<RuntimeState> + AsMut<RuntimeState>,
+	HandleFor<R::Interpreter>: RuntimeEnvironment + RuntimeBackend + TransactionalBackend,
+	R: Resolver,
+	TrapFor<R::Interpreter>: TrapConsume<CallCreateTrap>,
 {
 	type Interpreter = R::Interpreter;
-	type Interrupt = <TrapFor<H, R::Interpreter> as TrapConsume<CallCreateTrap>>::Rest;
+	type Interrupt = <TrapFor<R::Interpreter> as TrapConsume<CallCreateTrap>>::Rest;
 	type TransactArgs = TransactArgs;
 	type TransactInvoke = TransactInvoke;
 	type TransactValue = (ExitSucceed, Option<H160>);
@@ -177,11 +171,11 @@ where
 	fn new_transact(
 		&self,
 		args: Self::TransactArgs,
-		handler: &mut H,
+		handler: &mut HandleFor<R::Interpreter>,
 	) -> Result<
 		(
 			Self::TransactInvoke,
-			InvokerControl<Self::Interpreter, (ExitResult, DeconstructFor<H, R::Interpreter>)>,
+			InvokerControl<Self::Interpreter, (ExitResult, DeconstructFor<R::Interpreter>)>,
 		),
 		ExitError,
 	> {
@@ -261,7 +255,7 @@ where
 						}
 					}
 
-					let state = <StateFor<H, R::Interpreter>>::new_transact_call(
+					let state = <StateFor<R::Interpreter>>::new_transact_call(
 						RuntimeState {
 							context,
 							transaction_context: Rc::new(transaction_context),
@@ -301,7 +295,7 @@ where
 					access_list,
 					..
 				} => {
-					let state = <StateFor<H, R::Interpreter>>::new_transact_create(
+					let state = <StateFor<R::Interpreter>>::new_transact_create(
 						RuntimeState {
 							context,
 							transaction_context: Rc::new(transaction_context),
@@ -341,8 +335,8 @@ where
 		&self,
 		invoke: &Self::TransactInvoke,
 		result: ExitResult,
-		(mut substate, retval): DeconstructFor<H, R::Interpreter>,
-		handler: &mut H,
+		(mut substate, retval): DeconstructFor<R::Interpreter>,
+		handler: &mut HandleFor<R::Interpreter>,
 	) -> Result<Self::TransactValue, ExitError> {
 		let left_gas = substate.effective_gas();
 
@@ -390,15 +384,15 @@ where
 
 	fn enter_substack(
 		&self,
-		trap: TrapFor<H, R::Interpreter>,
-		machine: &mut Self::Interpreter,
-		handler: &mut H,
+		trap: TrapFor<R::Interpreter>,
+		machine: &mut R::Interpreter,
+		handler: &mut HandleFor<R::Interpreter>,
 		depth: usize,
 	) -> Capture<
 		Result<
 			(
 				Self::SubstackInvoke,
-				InvokerControl<Self::Interpreter, (ExitResult, DeconstructFor<H, R::Interpreter>)>,
+				InvokerControl<Self::Interpreter, (ExitResult, DeconstructFor<R::Interpreter>)>,
 			),
 			ExitError,
 		>,
@@ -509,10 +503,10 @@ where
 	fn exit_substack(
 		&self,
 		result: ExitResult,
-		(mut substate, retval): DeconstructFor<H, R::Interpreter>,
+		(mut substate, retval): DeconstructFor<R::Interpreter>,
 		trap_data: Self::SubstackInvoke,
-		parent: &mut Self::Interpreter,
-		handler: &mut H,
+		parent: &mut R::Interpreter,
+		handler: &mut HandleFor<R::Interpreter>,
 	) -> Result<(), ExitError> {
 		let strategy = match &result {
 			Ok(_) => MergeStrategy::Commit,
diff --git a/src/standard/invoker/resolver.rs b/src/standard/invoker/resolver.rs
index eb7636fa4..8d86151d6 100644
--- a/src/standard/invoker/resolver.rs
+++ b/src/standard/invoker/resolver.rs
@@ -1,4 +1,4 @@
-use crate::interpreter::{DeconstructFor, EtableInterpreter, Interpreter};
+use crate::interpreter::{DeconstructFor, EtableInterpreter, HandleFor, Interpreter, StateFor};
 use crate::{
 	standard::Config, EtableSet, ExitError, ExitResult, InvokerControl, Machine, RuntimeBackend,
 	RuntimeState,
@@ -13,8 +13,8 @@ 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<H> {
-	type Interpreter: Interpreter<H>;
+pub trait Resolver {
+	type Interpreter: Interpreter;
 
 	/// Resolve a call (with the target code address).
 	#[allow(clippy::type_complexity)]
@@ -22,10 +22,10 @@ pub trait Resolver<H> {
 		&self,
 		code_address: H160,
 		input: Vec<u8>,
-		state: <Self::Interpreter as Interpreter<H>>::State,
-		handler: &mut H,
+		state: StateFor<Self::Interpreter>,
+		handler: &mut HandleFor<Self::Interpreter>,
 	) -> Result<
-		InvokerControl<Self::Interpreter, (ExitResult, DeconstructFor<H, Self::Interpreter>)>,
+		InvokerControl<Self::Interpreter, (ExitResult, DeconstructFor<Self::Interpreter>)>,
 		ExitError,
 	>;
 
@@ -34,10 +34,10 @@ pub trait Resolver<H> {
 	fn resolve_create(
 		&self,
 		init_code: Vec<u8>,
-		state: <Self::Interpreter as Interpreter<H>>::State,
-		handler: &mut H,
+		state: StateFor<Self::Interpreter>,
+		handler: &mut HandleFor<Self::Interpreter>,
 	) -> Result<
-		InvokerControl<Self::Interpreter, (ExitResult, DeconstructFor<H, Self::Interpreter>)>,
+		InvokerControl<Self::Interpreter, (ExitResult, DeconstructFor<Self::Interpreter>)>,
 		ExitError,
 	>;
 }
@@ -93,13 +93,13 @@ impl<'config, 'precompile, 'etable, S, H, Pre, Tr, ES>
 	}
 }
 
-impl<'config, 'precompile, 'etable, S, H, Pre, Tr, ES> Resolver<H>
+impl<'config, 'precompile, 'etable, S, H, Pre, Tr, ES> Resolver
 	for EtableResolver<'config, 'precompile, 'etable, S, H, Pre, Tr, ES>
 where
 	S: AsRef<RuntimeState> + AsMut<RuntimeState>,
 	H: RuntimeBackend,
 	Pre: PrecompileSet<S, H>,
-	ES: EtableSet<S, H, Tr>,
+	ES: EtableSet<State = S, Handle = H, Trap = Tr>,
 {
 	type Interpreter = EtableInterpreter<'etable, S, H, Tr, ES>;
 
diff --git a/src/standard/invoker/routines.rs b/src/standard/invoker/routines.rs
index 2729e9ee6..c14ddca09 100644
--- a/src/standard/invoker/routines.rs
+++ b/src/standard/invoker/routines.rs
@@ -1,30 +1,27 @@
 use super::{CallTrapData, CreateTrapData, InvokerState, Resolver, SubstackInvoke};
-use crate::interpreter::{DeconstructFor, StateFor};
+use crate::interpreter::{DeconstructFor, HandleFor, StateFor};
 use crate::standard::Config;
 use crate::{
 	ExitError, ExitException, ExitResult, InvokerControl, MergeStrategy, Opcode, RuntimeBackend,
-	RuntimeEnvironment, RuntimeState, TransactionalBackend, Transfer,
+	RuntimeBaseBackend, RuntimeEnvironment, RuntimeState, TransactionalBackend, Transfer,
 };
 use alloc::vec::Vec;
 use primitive_types::{H160, U256};
 
 #[allow(clippy::too_many_arguments, clippy::type_complexity)]
-pub fn make_enter_call_machine<H, R>(
+pub fn make_enter_call_machine<R>(
 	_config: &Config,
 	resolver: &R,
 	code_address: H160,
 	input: Vec<u8>,
 	transfer: Option<Transfer>,
-	state: StateFor<H, R::Interpreter>,
-	handler: &mut H,
-) -> Result<
-	InvokerControl<R::Interpreter, (ExitResult, DeconstructFor<H, R::Interpreter>)>,
-	ExitError,
->
+	state: StateFor<R::Interpreter>,
+	handler: &mut HandleFor<R::Interpreter>,
+) -> Result<InvokerControl<R::Interpreter, (ExitResult, DeconstructFor<R::Interpreter>)>, ExitError>
 where
-	StateFor<H, R::Interpreter>: AsRef<RuntimeState>,
-	H: RuntimeEnvironment + RuntimeBackend + TransactionalBackend,
-	R: Resolver<H>,
+	StateFor<R::Interpreter>: AsRef<RuntimeState>,
+	HandleFor<R::Interpreter>: RuntimeEnvironment + RuntimeBackend + TransactionalBackend,
+	R: Resolver,
 {
 	handler.mark_hot(state.as_ref().context.address, None);
 
@@ -36,22 +33,19 @@ where
 }
 
 #[allow(clippy::type_complexity, clippy::too_many_arguments)]
-pub fn make_enter_create_machine<H, R>(
+pub fn make_enter_create_machine<R>(
 	config: &Config,
 	resolver: &R,
 	caller: H160,
 	init_code: Vec<u8>,
 	transfer: Transfer,
-	state: StateFor<H, R::Interpreter>,
-	handler: &mut H,
-) -> Result<
-	InvokerControl<R::Interpreter, (ExitResult, DeconstructFor<H, R::Interpreter>)>,
-	ExitError,
->
+	state: StateFor<R::Interpreter>,
+	handler: &mut HandleFor<R::Interpreter>,
+) -> Result<InvokerControl<R::Interpreter, (ExitResult, DeconstructFor<R::Interpreter>)>, ExitError>
 where
-	StateFor<H, R::Interpreter>: AsRef<RuntimeState>,
-	H: RuntimeEnvironment + RuntimeBackend + TransactionalBackend,
-	R: Resolver<H>,
+	StateFor<R::Interpreter>: AsRef<RuntimeState>,
+	HandleFor<R::Interpreter>: RuntimeEnvironment + RuntimeBackend + TransactionalBackend,
+	R: Resolver,
 {
 	if let Some(limit) = config.max_initcode_size {
 		if init_code.len() > limit {
@@ -80,24 +74,24 @@ where
 }
 
 #[allow(clippy::type_complexity, clippy::too_many_arguments)]
-pub fn enter_call_substack<H, R>(
+pub fn enter_call_substack<R>(
 	config: &Config,
 	resolver: &R,
 	trap_data: CallTrapData,
 	code_address: H160,
-	state: StateFor<H, R::Interpreter>,
-	handler: &mut H,
+	state: StateFor<R::Interpreter>,
+	handler: &mut HandleFor<R::Interpreter>,
 ) -> Result<
 	(
 		SubstackInvoke,
-		InvokerControl<R::Interpreter, (ExitResult, DeconstructFor<H, R::Interpreter>)>,
+		InvokerControl<R::Interpreter, (ExitResult, DeconstructFor<R::Interpreter>)>,
 	),
 	ExitError,
 >
 where
-	StateFor<H, R::Interpreter>: AsRef<RuntimeState>,
-	H: RuntimeEnvironment + RuntimeBackend + TransactionalBackend,
-	R: Resolver<H>,
+	StateFor<R::Interpreter>: AsRef<RuntimeState>,
+	HandleFor<R::Interpreter>: RuntimeEnvironment + RuntimeBackend + TransactionalBackend,
+	R: Resolver,
 {
 	handler.push_substate();
 
@@ -125,28 +119,28 @@ where
 }
 
 #[allow(clippy::type_complexity, clippy::too_many_arguments)]
-pub fn enter_create_substack<H, R>(
+pub fn enter_create_substack<R>(
 	config: &Config,
 	resolver: &R,
 	code: Vec<u8>,
 	trap_data: CreateTrapData,
-	state: StateFor<H, R::Interpreter>,
-	handler: &mut H,
+	state: StateFor<R::Interpreter>,
+	handler: &mut HandleFor<R::Interpreter>,
 ) -> Result<
 	(
 		SubstackInvoke,
-		InvokerControl<R::Interpreter, (ExitResult, DeconstructFor<H, R::Interpreter>)>,
+		InvokerControl<R::Interpreter, (ExitResult, DeconstructFor<R::Interpreter>)>,
 	),
 	ExitError,
 >
 where
-	StateFor<H, R::Interpreter>: AsRef<RuntimeState>,
-	H: RuntimeEnvironment + RuntimeBackend + TransactionalBackend,
-	R: Resolver<H>,
+	StateFor<R::Interpreter>: AsRef<RuntimeState>,
+	HandleFor<R::Interpreter>: RuntimeEnvironment + RuntimeBackend + TransactionalBackend,
+	R: Resolver,
 {
 	handler.push_substate();
 
-	let work = || -> Result<(SubstackInvoke, InvokerControl<R::Interpreter, (ExitResult, DeconstructFor<H, R::Interpreter>)>), ExitError> {
+	let work = || -> Result<(SubstackInvoke, InvokerControl<R::Interpreter, (ExitResult, DeconstructFor<R::Interpreter>)>), ExitError> {
 		let CreateTrapData {
 			scheme,
 			value,