Add executionPayload abstraction in PayloadTypes

[mattsse]

Describe the feature

currently we have hardcoded the executionpayload type and sidecar:

reth/crates/engine/primitives/src/message.rs

Lines 144 to 148 in 3408059

	/// The execution payload received by Engine API.
	payload: ExecutionPayload,
	/// The execution payload sidecar with additional version-specific fields received by
	/// engine API.
	sidecar: ExecutionPayloadSidecar,

ideally we want this to be configurable.

especially when we want to make custom block types work.

first step would be introducing an associated in the EngineTypes

reth/crates/engine/primitives/src/lib.rs

Line 33 in 3408059

pub trait EngineTypes:

that encapsulates both, for example type ExecutionPayloadRequest

and add a helper type that has the payload and sidecar as fields

Additional context

No response

[nils-mathieu]

I'd like to work on this.

[nils-mathieu]

I'm running into a roadblock.

The create_reorg_head function relies on the internals of the ExecutionPayloadRequest (which is being abstracted out). Specifically, it requires the ExecutionPayloadValidator<Spec> to be coupled with the ExecutionPayloadRequest.

reth/crates/engine/util/src/reorg.rs

Lines 250 to 257 in 3408059

	fn create_reorg_head<Provider, Evm, Spec>(
	provider: &Provider,
	evm_config: &Evm,
	payload_validator: &ExecutionPayloadValidator<Spec>,
	mut depth: usize,
	next_payload: ExecutionPayload,
	next_sidecar: ExecutionPayloadSidecar,
	) -> RethResult<(ExecutionPayload, ExecutionPayloadSidecar)>

Currently, I have added an associated type to the EngineTypes trait.

trait EngineTypes {
    type ExecutionPayloadRequest;
}

One thing I could do is to add a dependency on Spec for EngineTypes. This way, we would be able to do the following:

trait EngineTypes<Spec> {
    type ExecutionPayloadRequest: ExecutionPayloadRequest<Spec>;
}

trait ExecutionPayloadRequest<Spec> {
    fn create_reorg_head(
        self,
        provider: &Provider,
        evm_config: &Evm,
        payload_validator: &ExecutionPayloadValidator<Spec>,
        depth: usize,
    ) -> RethResult<Self>;
}

Or one alternative would be:

trait EngineTypes {
    type Spec;
    type ExecutionPayloadRequest: ExecutionPayloadRequest<Self::Spec>;
}

Would that be fine? Or am I missing an obvious thing.

---

Actually I havn't looked too much into it but it seems like Provider and Evm would both need to be coupled as well. Not sure what would the right thing be for this project.