chore: remove Beacon from type names (paradigmxyz#17868)

Co-authored-by: petarjuki7 <[email protected]>

Author: mattsse

bin/reth/src/ress.rs

@@ -2,7 +2,7 @@ use reth_ethereum_primitives::EthPrimitives;
 use reth_evm::ConfigureEvm;
 use reth_network::{protocol::IntoRlpxSubProtocol, NetworkProtocols};
 use reth_network_api::FullNetwork;
-use reth_node_api::BeaconConsensusEngineEvent;
+use reth_node_api::ConsensusEngineEvent;
 use reth_node_core::args::RessArgs;
 use reth_provider::providers::{BlockchainProvider, ProviderNodeTypes};
 use reth_ress_protocol::{NodeType, ProtocolState, RessProtocolHandler};
@@ -19,7 +19,7 @@ pub fn install_ress_subprotocol<P, E, N>(
     evm_config: E,
     network: N,
     task_executor: TaskExecutor,
-    engine_events: EventStream<BeaconConsensusEngineEvent<EthPrimitives>>,
+    engine_events: EventStream<ConsensusEngineEvent<EthPrimitives>>,
 ) -> eyre::Result<()>
 where
     P: ProviderNodeTypes<Primitives = EthPrimitives>,

crates/consensus/debug-client/src/client.rs

@@ -1,8 +1,8 @@
 use alloy_consensus::Sealable;
 use alloy_primitives::B256;
 use reth_node_api::{
-    BeaconConsensusEngineHandle, BuiltPayload, EngineApiMessageVersion, ExecutionPayload,
-    NodePrimitives, PayloadTypes,
+    BuiltPayload, ConsensusEngineHandle, EngineApiMessageVersion, ExecutionPayload, NodePrimitives,
+    PayloadTypes,
 };
 use reth_primitives_traits::{Block, SealedBlock};
 use reth_tracing::tracing::warn;
@@ -62,15 +62,15 @@ pub trait BlockProvider: Send + Sync + 'static {
 #[derive(Debug)]
 pub struct DebugConsensusClient<P: BlockProvider, T: PayloadTypes> {
     /// Handle to execution client.
-    engine_handle: BeaconConsensusEngineHandle<T>,
+    engine_handle: ConsensusEngineHandle<T>,
     /// Provider to get consensus blocks from.
     block_provider: P,
 }
 
 impl<P: BlockProvider, T: PayloadTypes> DebugConsensusClient<P, T> {
     /// Create a new debug consensus client with the given handle to execution
     /// client and block provider.
-    pub const fn new(engine_handle: BeaconConsensusEngineHandle<T>, block_provider: P) -> Self {
+    pub const fn new(engine_handle: ConsensusEngineHandle<T>, block_provider: P) -> Self {
         Self { engine_handle, block_provider }
     }
 }

crates/engine/local/src/miner.rs

@@ -5,7 +5,7 @@ use alloy_primitives::{TxHash, B256};
 use alloy_rpc_types_engine::ForkchoiceState;
 use eyre::OptionExt;
 use futures_util::{stream::Fuse, StreamExt};
-use reth_engine_primitives::BeaconConsensusEngineHandle;
+use reth_engine_primitives::ConsensusEngineHandle;
 use reth_payload_builder::PayloadBuilderHandle;
 use reth_payload_primitives::{
     BuiltPayload, EngineApiMessageVersion, PayloadAttributesBuilder, PayloadKind, PayloadTypes,
@@ -95,7 +95,7 @@ pub struct LocalMiner<T: PayloadTypes, B> {
     /// The payload attribute builder for the engine
     payload_attributes_builder: B,
     /// Sender for events to engine.
-    to_engine: BeaconConsensusEngineHandle<T>,
+    to_engine: ConsensusEngineHandle<T>,
     /// The mining mode for the engine
     mode: MiningMode,
     /// The payload builder for the engine
@@ -115,7 +115,7 @@ where
     pub fn new(
         provider: impl BlockReader,
         payload_attributes_builder: B,
-        to_engine: BeaconConsensusEngineHandle<T>,
+        to_engine: ConsensusEngineHandle<T>,
         mode: MiningMode,
         payload_builder: PayloadBuilderHandle<T>,
     ) -> Self {

crates/engine/primitives/src/event.rs

@@ -14,9 +14,13 @@ use reth_chain_state::ExecutedBlockWithTrieUpdates;
 use reth_ethereum_primitives::EthPrimitives;
 use reth_primitives_traits::{NodePrimitives, SealedBlock, SealedHeader};
 
+/// Type alias for backwards compat
+#[deprecated(note = "Use ConsensusEngineEvent instead")]
+pub type BeaconConsensusEngineEvent<N> = ConsensusEngineEvent<N>;
+
 /// Events emitted by the consensus engine.
 #[derive(Clone, Debug)]
-pub enum BeaconConsensusEngineEvent<N: NodePrimitives = EthPrimitives> {
+pub enum ConsensusEngineEvent<N: NodePrimitives = EthPrimitives> {
     /// The fork choice state was updated, and the current fork choice status
     ForkchoiceUpdated(ForkchoiceState, ForkchoiceStatus),
     /// A block was added to the fork chain.
@@ -33,9 +37,9 @@ pub enum BeaconConsensusEngineEvent<N: NodePrimitives = EthPrimitives> {
     LiveSyncProgress(ConsensusEngineLiveSyncProgress),
 }
 
-impl<N: NodePrimitives> BeaconConsensusEngineEvent<N> {
+impl<N: NodePrimitives> ConsensusEngineEvent<N> {
     /// Returns the canonical header if the event is a
-    /// [`BeaconConsensusEngineEvent::CanonicalChainCommitted`].
+    /// [`ConsensusEngineEvent::CanonicalChainCommitted`].
     pub const fn canonical_header(&self) -> Option<&SealedHeader<N::BlockHeader>> {
         match self {
             Self::CanonicalChainCommitted(header, _) => Some(header),
@@ -44,7 +48,7 @@ impl<N: NodePrimitives> BeaconConsensusEngineEvent<N> {
     }
 }
 
-impl<N> Display for BeaconConsensusEngineEvent<N>
+impl<N> Display for ConsensusEngineEvent<N>
 where
     N: NodePrimitives<BlockHeader: BlockHeader>,
 {

crates/engine/primitives/src/message.rs

@@ -17,6 +17,10 @@ use reth_payload_builder_primitives::PayloadBuilderError;
 use reth_payload_primitives::{EngineApiMessageVersion, PayloadTypes};
 use tokio::sync::{mpsc::UnboundedSender, oneshot};
 
+/// Type alias for backwards compat
+#[deprecated(note = "Use ConsensusEngineHandle instead")]
+pub type BeaconConsensusEngineHandle<Payload> = ConsensusEngineHandle<Payload>;
+
 /// Represents the outcome of forkchoice update.
 ///
 /// This is a future that resolves to [`ForkChoiceUpdateResult`]
@@ -191,14 +195,14 @@ impl<Payload: PayloadTypes> Display for BeaconEngineMessage<Payload> {
 ///
 /// This type mirrors consensus related functions of the engine API.
 #[derive(Debug, Clone)]
-pub struct BeaconConsensusEngineHandle<Payload>
+pub struct ConsensusEngineHandle<Payload>
 where
     Payload: PayloadTypes,
 {
     to_engine: UnboundedSender<BeaconEngineMessage<Payload>>,
 }
 
-impl<Payload> BeaconConsensusEngineHandle<Payload>
+impl<Payload> ConsensusEngineHandle<Payload>
 where
     Payload: PayloadTypes,
 {

crates/engine/service/src/service.rs

@@ -2,7 +2,7 @@ use futures::{Stream, StreamExt};
 use pin_project::pin_project;
 use reth_chainspec::EthChainSpec;
 use reth_consensus::{ConsensusError, FullConsensus};
-use reth_engine_primitives::{BeaconConsensusEngineEvent, BeaconEngineMessage};
+use reth_engine_primitives::{BeaconEngineMessage, ConsensusEngineEvent};
 use reth_engine_tree::{
     backfill::PipelineSync,
     download::BasicBlockDownloader,
@@ -130,7 +130,7 @@ where
     N: ProviderNodeTypes,
     Client: BlockClient<Block = BlockTy<N>> + 'static,
 {
-    type Item = ChainEvent<BeaconConsensusEngineEvent<N::Primitives>>;
+    type Item = ChainEvent<ConsensusEngineEvent<N::Primitives>>;
 
     fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
         let mut orchestrator = self.project().orchestrator;

crates/engine/tree/src/engine.rs

@@ -8,7 +8,7 @@ use crate::{
 use alloy_primitives::B256;
 use futures::{Stream, StreamExt};
 use reth_chain_state::ExecutedBlockWithTrieUpdates;
-use reth_engine_primitives::{BeaconConsensusEngineEvent, BeaconEngineMessage};
+use reth_engine_primitives::{BeaconEngineMessage, ConsensusEngineEvent};
 use reth_ethereum_primitives::EthPrimitives;
 use reth_payload_primitives::PayloadTypes;
 use reth_primitives_traits::{Block, NodePrimitives, RecoveredBlock};
@@ -191,7 +191,7 @@ impl<Request, N: NodePrimitives> EngineRequestHandler for EngineApiRequestHandle
 where
     Request: Send,
 {
-    type Event = BeaconConsensusEngineEvent<N>;
+    type Event = ConsensusEngineEvent<N>;
     type Request = Request;
     type Block = N::Block;
 
@@ -279,7 +279,7 @@ impl<T: PayloadTypes, N: NodePrimitives> From<EngineApiRequest<T, N>>
 pub enum EngineApiEvent<N: NodePrimitives = EthPrimitives> {
     /// Event from the consensus engine.
     // TODO(mattsse): find a more appropriate name for this variant, consider phasing it out.
-    BeaconConsensus(BeaconConsensusEngineEvent<N>),
+    BeaconConsensus(ConsensusEngineEvent<N>),
     /// Backfill action is needed.
     BackfillAction(BackfillAction),
     /// Block download is needed.
@@ -293,8 +293,8 @@ impl<N: NodePrimitives> EngineApiEvent<N> {
     }
 }
 
-impl<N: NodePrimitives> From<BeaconConsensusEngineEvent<N>> for EngineApiEvent<N> {
-    fn from(event: BeaconConsensusEngineEvent<N>) -> Self {
+impl<N: NodePrimitives> From<ConsensusEngineEvent<N>> for EngineApiEvent<N> {
+    fn from(event: ConsensusEngineEvent<N>) -> Self {
         Self::BeaconConsensus(event)
     }
 }

crates/engine/tree/src/tree/mod.rs

@@ -19,7 +19,7 @@ use reth_chain_state::{
 };
 use reth_consensus::{Consensus, FullConsensus};
 use reth_engine_primitives::{
-    BeaconConsensusEngineEvent, BeaconEngineMessage, BeaconOnNewPayloadError, ExecutionPayload,
+    BeaconEngineMessage, BeaconOnNewPayloadError, ConsensusEngineEvent, ExecutionPayload,
     ForkchoiceStateTracker, OnForkChoiceUpdated,
 };
 use reth_errors::{ConsensusError, ProviderResult};
@@ -518,7 +518,7 @@ where
             .record_payload_validation(validation_start.elapsed().as_secs_f64());
 
         let num_hash = payload.num_hash();
-        let engine_event = BeaconConsensusEngineEvent::BlockReceived(num_hash);
+        let engine_event = ConsensusEngineEvent::BlockReceived(num_hash);
         self.emit_event(EngineApiEvent::BeaconConsensus(engine_event));
 
         let block_hash = num_hash.hash;
@@ -1064,7 +1064,7 @@ where
                         self.state.tree_state.insert_executed(block.clone());
                         self.metrics.engine.inserted_already_executed_blocks.increment(1);
                         self.emit_event(EngineApiEvent::BeaconConsensus(
-                            BeaconConsensusEngineEvent::CanonicalBlockAdded(block, now.elapsed()),
+                            ConsensusEngineEvent::CanonicalBlockAdded(block, now.elapsed()),
                         ));
                     }
                     EngineApiRequest::Beacon(request) => {
@@ -1085,7 +1085,7 @@ where
                                         .set_latest(state, res.outcome.forkchoice_status());
 
                                     // emit an event about the handled FCU
-                                    self.emit_event(BeaconConsensusEngineEvent::ForkchoiceUpdated(
+                                    self.emit_event(ConsensusEngineEvent::ForkchoiceUpdated(
                                         state,
                                         res.outcome.forkchoice_status(),
                                     ));
@@ -1626,7 +1626,7 @@ where
 
         // insert the head block into the invalid header cache
         self.state.invalid_headers.insert_with_invalid_ancestor(head.hash(), invalid);
-        self.emit_event(BeaconConsensusEngineEvent::InvalidBlock(Box::new(head)));
+        self.emit_event(ConsensusEngineEvent::InvalidBlock(Box::new(head)));
 
         Ok(status)
     }
@@ -1907,7 +1907,7 @@ where
         self.canonical_in_memory_state.notify_canon_state(notification);
 
         // emit event
-        self.emit_event(BeaconConsensusEngineEvent::CanonicalChainCommitted(
+        self.emit_event(ConsensusEngineEvent::CanonicalChainCommitted(
             Box::new(tip),
             start.elapsed(),
         ));
@@ -2155,9 +2155,9 @@ where
         // emit insert event
         let elapsed = start.elapsed();
         let engine_event = if is_fork {
-            BeaconConsensusEngineEvent::ForkBlockAdded(executed, elapsed)
+            ConsensusEngineEvent::ForkBlockAdded(executed, elapsed)
         } else {
-            BeaconConsensusEngineEvent::CanonicalBlockAdded(executed, elapsed)
+            ConsensusEngineEvent::CanonicalBlockAdded(executed, elapsed)
         };
         self.emit_event(EngineApiEvent::BeaconConsensus(engine_event));
 
@@ -2296,7 +2296,7 @@ where
 
         // keep track of the invalid header
         self.state.invalid_headers.insert(block.block_with_parent());
-        self.emit_event(EngineApiEvent::BeaconConsensus(BeaconConsensusEngineEvent::InvalidBlock(
+        self.emit_event(EngineApiEvent::BeaconConsensus(ConsensusEngineEvent::InvalidBlock(
             Box::new(block),
         )));
         Ok(PayloadStatus::new(

crates/engine/tree/src/tree/tests.rs

@@ -301,7 +301,7 @@ impl TestHarness {
         // check for ForkchoiceUpdated event
         let event = self.from_tree_rx.recv().await.unwrap();
         match event {
-            EngineApiEvent::BeaconConsensus(BeaconConsensusEngineEvent::ForkchoiceUpdated(
+            EngineApiEvent::BeaconConsensus(ConsensusEngineEvent::ForkchoiceUpdated(
                 state,
                 status,
             )) => {

crates/node/api/src/node.rs

@@ -5,7 +5,7 @@ use alloy_rpc_types_engine::JwtSecret;
 use reth_basic_payload_builder::PayloadBuilder;
 use reth_consensus::{ConsensusError, FullConsensus};
 use reth_db_api::{database_metrics::DatabaseMetrics, Database};
-use reth_engine_primitives::{BeaconConsensusEngineEvent, BeaconConsensusEngineHandle};
+use reth_engine_primitives::{ConsensusEngineEvent, ConsensusEngineHandle};
 use reth_evm::ConfigureEvm;
 use reth_network_api::FullNetwork;
 use reth_node_core::node_config::NodeConfig;
@@ -113,9 +113,9 @@ pub struct AddOnsContext<'a, N: FullNodeComponents> {
     /// Node configuration.
     pub config: &'a NodeConfig<<N::Types as NodeTypes>::ChainSpec>,
     /// Handle to the beacon consensus engine.
-    pub beacon_engine_handle: BeaconConsensusEngineHandle<<N::Types as NodeTypes>::Payload>,
+    pub beacon_engine_handle: ConsensusEngineHandle<<N::Types as NodeTypes>::Payload>,
     /// Notification channel for engine API events
-    pub engine_events: EventSender<BeaconConsensusEngineEvent<<N::Types as NodeTypes>::Primitives>>,
+    pub engine_events: EventSender<ConsensusEngineEvent<<N::Types as NodeTypes>::Primitives>>,
     /// JWT secret for the node.
     pub jwt_secret: JwtSecret,
 }