How to have a custom block execution flow at the BasicBlockExecutor level?

[debjit-bw]

After reth combined the block execution with evm, the functions execute_one and execute_one_with_state_hook got one level down in the abstraction. Suppose we need a CustomBlockExecutor that needs custom implementations of these functions, what is the recommended way?

ConfigureEvm has the following functions where BasicBlockExecutor is hardcoded.

...
    /// Returns a new [`BasicBlockExecutor`].
    #[auto_impl(keep_default_for(&, Arc))]
    fn executor<DB: Database>(&self, db: DB) -> BasicBlockExecutor<&Self, DB> {
        BasicBlockExecutor::new(self, db)
    }

    /// Returns a new [`BasicBlockExecutor`].
    #[auto_impl(keep_default_for(&, Arc))]
    fn batch_executor<DB: Database>(&self, db: DB) -> BasicBlockExecutor<&Self, DB> {
        BasicBlockExecutor::new(self, db)
    }
...

Should we have generic return types for these in order to have our custom executor?

[klkvr]

Which parts of block execution do you need to override? Abstraction was changed to contain entire logic for block execution in BlockExecutor trait and BasicBlockExecutor is now just a thin wrapper around it which is why it's not overridable:

reth/crates/evm/evm/src/execute.rs

Lines 430 to 443 in 06d4319

	fn execute_one(
	&mut self,
	block: &RecoveredBlock<<Self::Primitives as NodePrimitives>::Block>,
	) -> Result<BlockExecutionResult<<Self::Primitives as NodePrimitives>::Receipt>, Self::Error>
	{
	let result = self
	.strategy_factory
	.executor_for_block(&mut self.db, block)
	.execute_block(block.transactions_recovered())?;
	self.db.merge_transitions(BundleRetention::Reverts);
	Ok(result)
	}

For overriding the pre/post changes or transaction execution logic, you could introduce a custom BlockExecutorFactory, one simple example of it can be found here:

reth/examples/custom-beacon-withdrawals/src/main.rs

Lines 165 to 206 in 06d4319

	impl<'db, DB, E> BlockExecutor for CustomBlockExecutor<'_, E>
	where
	DB: Database + 'db,
	E: Evm<DB = &'db mut State<DB>, Tx = TxEnv>,
	{
	type Transaction = TransactionSigned;
	type Receipt = Receipt;
	type Evm = E;
	fn apply_pre_execution_changes(&mut self) -> Result<(), BlockExecutionError> {
	self.inner.apply_pre_execution_changes()
	}
	fn execute_transaction_with_commit_condition(
	&mut self,
	tx: impl ExecutableTx<Self>,
	f: impl FnOnce(&ExecutionResult<<Self::Evm as Evm>::HaltReason>) -> CommitChanges,
	) -> Result<Option<u64>, BlockExecutionError> {
	self.inner.execute_transaction_with_commit_condition(tx, f)
	}
	fn finish(mut self) -> Result<(Self::Evm, BlockExecutionResult<Receipt>), BlockExecutionError> {
	if let Some(withdrawals) = self.inner.ctx.withdrawals.clone() {
	apply_withdrawals_contract_call(withdrawals.as_ref(), self.inner.evm_mut())?;
	}
	// Invoke inner finish method to apply Ethereum post-execution changes
	self.inner.finish()
	}
	fn set_state_hook(&mut self, _hook: Option<Box<dyn OnStateHook>>) {
	self.inner.set_state_hook(_hook)
	}
	fn evm_mut(&mut self) -> &mut Self::Evm {
	self.inner.evm_mut()
	}
	fn evm(&self) -> &Self::Evm {
	self.inner.evm()
	}
	}

Please lmk if this works for your usecase as this abstraction is relatively new and we might still consider adding changes to it if it's not flexible enough

[debjit-bw]

i was looking to make deeper changes, specifically changes before the pre execution begins. i need to check a custom inspector and make changes to the evm before the pre-execution begins, so i wanted control over the very pre-ex – execution – post-ex flow.

here's a specific change for example:

https://github.com/SovaNetwork/sova-reth/blob/34b49394cc251e910a7397248dd33aa53bb701f7/crates/sova-evm/src/execute.rs#L211-L342

[klkvr]

I'd suggest implementing BlockExecutor trait on SovaBlockExecutor and returning it here https://github.com/SovaNetwork/sova-reth/blob/34b49394cc251e910a7397248dd33aa53bb701f7/crates/sova-evm/src/lib.rs#L185-L201 instead of basic OP executor.

That way, you will be able to move this part of logic into apply_pre_execution_changes, and this part into apply_post_execution_changes

[debjit-bw]

while trying to do this, i'm running into a few problems:

• how do i ensure that the evm always runs with the inspector (because we depend on some inspector insights for tx execution)
• and how to access this inspector inside the BlockExecutor functions?

also, is there any way of getting block-related info inside functions in the BlockExecutor trait?

[debjit-bw]

solved here: #16621