feat(isthmus): Integrate OpExecutionPayloadValidator (#14207)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
Co-authored-by: caglarkaya <caglaryucekaya@gmail.com>

crates/optimism/rpc/src/engine.rs

@@ -3,19 +3,21 @@
 use alloy_eips::eip7685::Requests;
 use alloy_primitives::{BlockHash, B256, U64};
 use alloy_rpc_types_engine::{
-    ClientVersionV1, ExecutionData, ExecutionPayloadBodiesV1, ExecutionPayloadInputV2,
-    ExecutionPayloadV3, ForkchoiceState, ForkchoiceUpdated, PayloadId, PayloadStatus,
+    ClientVersionV1, ExecutionPayloadBodiesV1, ExecutionPayloadInputV2, ExecutionPayloadV3,
+    ForkchoiceState, ForkchoiceUpdated, PayloadId, PayloadStatus,
 };
 use derive_more::Constructor;
 use jsonrpsee::proc_macros::rpc;
 use jsonrpsee_core::{server::RpcModule, RpcResult};
-use op_alloy_rpc_types_engine::OpExecutionPayloadV4;
+use op_alloy_rpc_types_engine::{OpExecutionData, OpExecutionPayloadV4};
 use reth_chainspec::EthereumHardforks;
 use reth_node_api::{EngineTypes, EngineValidator};
 use reth_provider::{BlockReader, HeaderProvider, StateProviderFactory};
 use reth_rpc_api::IntoEngineApiRpcModule;
-use reth_rpc_engine_api::{EngineApi, EngineApiServer};
+use reth_rpc_engine_api::{EngineApi, EngineCapabilities};
 use reth_transaction_pool::TransactionPool;
+use std::collections::HashSet;
+use tracing::trace;
 
 /// The list of all supported Engine capabilities available over the engine endpoint.
 ///
@@ -35,6 +37,13 @@ pub const OP_CAPABILITIES: &[&str] = &[
     "engine_getPayloadBodiesByRangeV1",
 ];
 
+/// Returns [`EngineCapabilities`] supported by OP stack.
+pub fn op_capabilities() -> EngineCapabilities {
+    EngineCapabilities::new(
+        OP_CAPABILITIES.iter().map(|cap| cap.to_string()).collect::<HashSet<_>>(),
+    )
+}
+
 /// Extension trait that gives access to Optimism engine API RPC methods.
 ///
 /// Note:
@@ -224,13 +233,15 @@ impl<Provider, EngineT, Pool, Validator, ChainSpec> OpEngineApiServer<EngineT>
     for OpEngineApi<Provider, EngineT, Pool, Validator, ChainSpec>
 where
     Provider: HeaderProvider + BlockReader + StateProviderFactory + 'static,
-    EngineT: EngineTypes<ExecutionData = ExecutionData>,
+    EngineT: EngineTypes<ExecutionData = OpExecutionData>,
     Pool: TransactionPool + 'static,
     Validator: EngineValidator<EngineT>,
     ChainSpec: EthereumHardforks + Send + Sync + 'static,
 {
     async fn new_payload_v2(&self, payload: ExecutionPayloadInputV2) -> RpcResult<PayloadStatus> {
-        EngineApiServer::new_payload_v2(&self.inner, payload).await
+        trace!(target: "rpc::engine", "Serving engine_newPayloadV2");
+        let payload = OpExecutionData::v2(payload);
+        Ok(self.inner.new_payload_v2_metered(payload).await?)
     }
 
     async fn new_payload_v3(
@@ -239,13 +250,10 @@ where
         versioned_hashes: Vec<B256>,
         parent_beacon_block_root: B256,
     ) -> RpcResult<PayloadStatus> {
-        EngineApiServer::new_payload_v3(
-            &self.inner,
-            payload,
-            versioned_hashes,
-            parent_beacon_block_root,
-        )
-        .await
+        trace!(target: "rpc::engine", "Serving engine_newPayloadV3");
+        let payload = OpExecutionData::v3(payload, versioned_hashes, parent_beacon_block_root);
+
+        Ok(self.inner.new_payload_v3_metered(payload).await?)
     }
 
     async fn new_payload_v4(
@@ -255,16 +263,15 @@ where
         parent_beacon_block_root: B256,
         execution_requests: Requests,
     ) -> RpcResult<PayloadStatus> {
-        // todo: custom op engine validator <https://github.com/paradigmxyz/reth/pull/14207>
-        let payload = payload.payload_inner;
-        EngineApiServer::new_payload_v4(
-            &self.inner,
+        trace!(target: "rpc::engine", "Serving engine_newPayloadV4");
+        let payload = OpExecutionData::v4(
             payload,
             versioned_hashes,
             parent_beacon_block_root,
             execution_requests,
-        )
-        .await
+        );
+
+        Ok(self.inner.new_payload_v4_metered(payload).await?)
     }
 
     async fn fork_choice_updated_v2(
@@ -272,8 +279,7 @@ where
         fork_choice_state: ForkchoiceState,
         payload_attributes: Option<EngineT::PayloadAttributes>,
     ) -> RpcResult<ForkchoiceUpdated> {
-        EngineApiServer::fork_choice_updated_v2(&self.inner, fork_choice_state, payload_attributes)
-            .await
+        Ok(self.inner.fork_choice_updated_v2_metered(fork_choice_state, payload_attributes).await?)
     }
 
     async fn fork_choice_updated_v3(
@@ -281,36 +287,35 @@ where
         fork_choice_state: ForkchoiceState,
         payload_attributes: Option<EngineT::PayloadAttributes>,
     ) -> RpcResult<ForkchoiceUpdated> {
-        EngineApiServer::fork_choice_updated_v3(&self.inner, fork_choice_state, payload_attributes)
-            .await
+        Ok(self.inner.fork_choice_updated_v3_metered(fork_choice_state, payload_attributes).await?)
     }
 
     async fn get_payload_v2(
         &self,
         payload_id: PayloadId,
     ) -> RpcResult<EngineT::ExecutionPayloadEnvelopeV2> {
-        EngineApiServer::get_payload_v2(&self.inner, payload_id).await
+        Ok(self.inner.get_payload_v2_metered(payload_id).await?)
     }
 
     async fn get_payload_v3(
         &self,
         payload_id: PayloadId,
     ) -> RpcResult<EngineT::ExecutionPayloadEnvelopeV3> {
-        EngineApiServer::get_payload_v3(&self.inner, payload_id).await
+        Ok(self.inner.get_payload_v3_metered(payload_id).await?)
     }
 
     async fn get_payload_v4(
         &self,
         payload_id: PayloadId,
     ) -> RpcResult<EngineT::ExecutionPayloadEnvelopeV4> {
-        EngineApiServer::get_payload_v4(&self.inner, payload_id).await
+        Ok(self.inner.get_payload_v4_metered(payload_id).await?)
     }
 
     async fn get_payload_bodies_by_hash_v1(
         &self,
         block_hashes: Vec<BlockHash>,
     ) -> RpcResult<ExecutionPayloadBodiesV1> {
-        EngineApiServer::get_payload_bodies_by_hash_v1(&self.inner, block_hashes).await
+        Ok(self.inner.get_payload_bodies_by_hash_v1_metered(block_hashes).await?)
     }
 
     async fn get_payload_bodies_by_range_v1(
@@ -318,14 +323,14 @@ where
         start: U64,
         count: U64,
     ) -> RpcResult<ExecutionPayloadBodiesV1> {
-        EngineApiServer::get_payload_bodies_by_range_v1(&self.inner, start, count).await
+        Ok(self.inner.get_payload_bodies_by_range_v1_metered(start.to(), count.to()).await?)
     }
 
     async fn get_client_version_v1(
         &self,
         client: ClientVersionV1,
     ) -> RpcResult<Vec<ClientVersionV1>> {
-        EngineApiServer::get_client_version_v1(&self.inner, client).await
+        Ok(self.inner.get_client_version_v1(client)?)
     }
 
     async fn exchange_capabilities(&self, _capabilities: Vec<String>) -> RpcResult<Vec<String>> {

crates/optimism/rpc/src/lib.rs

@@ -17,7 +17,7 @@ pub mod witness;
 
 #[cfg(feature = "client")]
 pub use engine::OpEngineApiClient;
-pub use engine::{OpEngineApi, OpEngineApiServer, OP_CAPABILITIES};
+pub use engine::{op_capabilities, OpEngineApi, OpEngineApiServer, OP_CAPABILITIES};
 pub use error::{OpEthApiError, OpInvalidTransactionError, SequencerClientError};
 pub use eth::{OpEthApi, OpReceiptBuilder};
 pub use sequencer::SequencerClient;